diff --git a/erpnext/translations/lt.csv b/erpnext/translations/lt.csv
index 5fa5af0..f6655da 100644
--- a/erpnext/translations/lt.csv
+++ b/erpnext/translations/lt.csv
@@ -1,5866 +1,5852 @@
-DocType: Employee,Salary Mode,Pajamos režimas
-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/config/education.py +118,Assessment Reports,Vertinimo ataskaitos
-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 +225,"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 +253,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,% Sąskaitos pateiktos
-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/healthcare/doctype/consultation/consultation.py +24,Diagnosis and Complaints cannot be left blank,Diagnozė ir skundai negali būti tušti
-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 +6,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 +74,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 +117,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 +241,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 +546,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 Order,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: Hotel Room Reservation,Guest Name,Svečio vardas
-DocType: Lab Prescription,Lab Prescription,Lab receptas
-,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 +899,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 +880,Invoice,faktūra
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145,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 +225,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 +162,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: Daily Work Summary Group,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 +239,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 +46,Abbreviation cannot have more than 5 characters,Santrumpa negali turėti daugiau nei 5 simboliai
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Klientas&gt; Klientų grupė&gt; Teritorija
-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/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,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 +114,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} Rezultatas pateiktas
-DocType: Item Attribute,Increment,prieaugis
-apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,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 +42,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 +467,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
-DocType: Accounts Settings,Use Custom Cash Flow Format,Naudokite tinkintą pinigų srautų formatą
-DocType: SMS Center,All Sales Person,Visi Pardavimų Vadybininkai
-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 +1752,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/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 +268,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Yra Ilgalaikis turtas"" negali būti nepažymėtas, nes egzistuoja prieštaraujantis turto įrašas."
-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 +581,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,(Per valandą/ 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 +966,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
-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 +216,Opening,atidarymas
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,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 +365,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 +269,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 +260,"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
-DocType: Asset Settings,Asset Settings,Turto nustatymai
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,vartojimo
-DocType: Student,B-,B
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98,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 +954,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 +231,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 +393,{0} {1} is frozen,{0} {1} yra sušaldyti
-apps/erpnext/erpnext/setup/doctype/company/company.py +140,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 +111,Select Target Warehouse,Pasirinkite Target sandėlis
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,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ą
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxNum,CompAuxNum
-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
-DocType: BOM,Quality Inspection Template,Kokybės tikrinimo šablonas
-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 +152,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 +519,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
-DocType: Customer,Primary Address,Pirminis adresas
-DocType: Production Plan,Material Request Detail,Medžiagos užklausa išsamiai
-DocType: Selling Settings,Default Quotation Validity Days,Numatytų kuponų galiojimo dienos
-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: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,"Nustatykite B2C sąskaitos faktūros vertę. B2CL ir B2CS, apskaičiuotos pagal šią sąskaitos faktūros vertę."
-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/job_offer/job_offer.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
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +252,Preference,Pirmenybė
-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: Share Transfer,Share Transfer,Dalintis pervedimu
-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: Daily Work Summary,Daily Work Summary Group,Dienos darbo santraukų grupė
-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: Job Offer,Select Terms and Conditions,Pasirinkite Terminai ir sąlygos
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Out Value,iš Vertė
-DocType: Production Plan,Sales Orders,pardavimų užsakymai
-DocType: Purchase Taxes and Charges,Valuation,įvertinimas
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +386,Set as Default,Nustatyti kaip numatytąją
-DocType: Production Plan,PLN-,PLN-
-,Purchase Order Trends,Pirkimui užsakyti tendencijos
-apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Eikite į klientus
-DocType: Hotel Room Reservation,Late Checkin,Vėlyvas registravimas
-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 +262,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 +430,Advance amount cannot be greater than {0} {1},Avanso suma gali būti ne didesnė kaip {0} {1}
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,Žurnalo kodas
-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 +206,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
-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 +44,Net Cash from Financing,Grynieji pinigų srautai iš finansavimo
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2359,"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/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 +408,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/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 +239,Leaves per Year,Lapai per metus
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,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 +219,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 +449,Leave Blocked,Palikite Užblokuoti
-apps/erpnext/erpnext/stock/doctype/item/item.py +739,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 +83,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 +761,Item {0} is cancelled,Prekė {0} atšaukiamas
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1055,Material Request,medžiaga Prašymas
-DocType: Bank Reconciliation,Update Clearance Date,Atnaujinti Sąskaitų data
-,GSTR-2,GSTR-2
-DocType: Item,Purchase Details,pirkimo informacija
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +394,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 +276,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: Shareholder,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 +138,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 +406,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/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Prašome nustatyti viešbučio kambario kainą už ()
-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 +939,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 +478,{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 +257,[Urgent] Error while creating recurring %s for %s,[Skubu] Klaida kuriant pasikartoja %s %s
-DocType: Land Unit,LInked Analysis,Įtraukta analizė
-DocType: Item Tax,Tax Rate,Mokesčio tarifas
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,Application period cannot be across two allocation records,Paraiškų teikimo laikotarpis negali būti per du paskirstymo įrašus
-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/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}"
-DocType: Material Request Plan Item,Material Request Plan Item,Materialinio prašymo plano punktas
-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 +249,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 +425,Please see attachment,Žiūrėkite priedą
-DocType: Purchase Order,% Received,% Gavo
-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 +113,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 į eigą {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: 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
-DocType: Job Offer Term,Job Offer Term,Darbo pasiūlymo terminas
-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/report/accounts_receivable/accounts_receivable.html +54,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 +1533,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
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +119,Patient not found,Pacientas nerastas
-DocType: Scheduling Tool,Rechedule,Rechedule
-DocType: Landed Cost Item,Applicable Charges,Taikomi Mokesčiai
-DocType: Workstation,Consumable Cost,vartojimo kaina
-DocType: Purchase Receipt,Vehicle Date,Automobilio data
-DocType: Student Log,Medical,medicinos
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,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: Purchase Invoice,01-Sales Return,01-Pardavimų grąža
-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.',"""Iki bylos Nr. ' negali būti mažesnis, nei ""Nuo bylos Nr. '"
-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 +215,{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 +174,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 +699,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 +85,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"
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceRef,PieceRef
-DocType: Request for Quotation,Message for Supplier,Pranešimo tiekėjas
-DocType: Driver,DRIVER-.#####,DRIVER -. #####
-DocType: Sales Invoice,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
-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 +132,{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 +33,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 +45,"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 +349,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 +551,"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/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} neegzistuoja.
-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.
-DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Pinigų srautų žemėlapių šablonas
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2539,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
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104,"Not permitted, configure Lab Test Template as required","Neleidžiama sukonfigūruoti laboratorijos bandymo šabloną, jei reikia"
-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 +334,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 +70,Account {0} does not belong to company: {1},Sąskaita {0} nepriklauso įmonės: {1}
-apps/erpnext/erpnext/setup/doctype/company/company.py +52,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: Company,Delete Company Transactions,Ištrinti bendrovės verslo sandoriai
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,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 +256,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 +118,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 +397,{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 +154,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 +143,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 +34,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: Sales Invoice,Shipping Bill Date,Pristatymo sąskaitos data
-DocType: Production Order,Production Plan,Gamybos planas
-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 +853,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 +228,Opening (Cr),Anga (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +871,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: Share Balance,Share Balance,Dalintis balansas
-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 +118,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"
-DocType: Hotel Settings,Default Invoice Naming Series,Numatytoji sąskaitų vardų serija
-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
-apps/erpnext/erpnext/config/education.py +176,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 +29,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 +177,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,"""Remiantis"" ir ""grupuoti pagal"" 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
-,Hotel Room Occupancy,Viešbučio kambario užimtumas
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +358,Timesheet created:,Lapą sukurta:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931,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: 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: Accounts Settings,Report Settings,Pranešimo nustatymai
-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 +158,{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 +221,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 +1526,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į
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47,EcritureLib,&quot;EcritureLib&quot;
-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: Sales Invoice,Port Code,Uosto kodas
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,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: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Pasirinkite tik tada, jei turite nustatymus Pinigų srauto kartografavimo dokumentus"
-DocType: Email Digest,Next email will be sent on:,Kitas laiškas bus išsiųstas į:
-DocType: Supplier Scorecard,Per Week,Per savaitę
-apps/erpnext/erpnext/stock/doctype/item/item.py +665,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
-,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
-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 +70,In Value,vertės
-DocType: Asset Settings,Depreciation Options,Nusidėvėjimo galimybės
-apps/erpnext/erpnext/utilities/transaction_base.py +35,Invalid Posting Time,Neteisingas skelbimo laikas
-DocType: Lead,Campaign Name,kampanijos pavadinimas
-DocType: Hotel Room,Capacity,Talpa
-DocType: Selling Settings,Close Opportunity After Days,Uždaryti progą dienų
-,Reserved,rezervuotas
-DocType: Driver,License Details,Informacija apie licenciją
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85,The field From Shareholder cannot be blank,Laukas iš akcininko negali būti tuščias
-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 +108,{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 +272,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 +152,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 +887,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/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 +344,"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 +514,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 +405,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_plan/production_plan.js +21,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 +218,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcijos suma negali būti didesnė nei ieškinio suma eilutėje {0}.
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Academic Term: ,Akademinis terminas:
-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 +1005,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 +369,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 +227,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 +766,No Permission,Nėra leidimo
-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 +59,"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},"""Atnaujinti sandėlį"" negali būti patikrintas, nes daiktai nėra pristatomi 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: Cash Flow Mapper,Cash Flow Mapper,Grynųjų pinigų srauto kartotuvas
-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 +295,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/accounts/doctype/share_transfer/share_transfer.py +73,The shares already exist,Akcijos jau yra
-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
-DocType: HR Settings,Retirement Age,pensijinis amžius
-DocType: Bin,Moving Average Rate,Moving Average Balsuok
-DocType: Production Plan,Select Items,pasirinkite prekę
-DocType: Share Transfer,To Shareholder,Akcininkui
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{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: Daily Work Summary Group,Select Users,Pasirinkite vartotojus
-DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Viešbučių kambario kainų punktas
-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/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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteLib,CompteLib
-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
-DocType: Customer,"Reselect, if the chosen address is edited after save","Iš naujo pažymėkite, jei pasirinktas adresas yra redaguotas po įrašymo"
-apps/erpnext/erpnext/stock/doctype/item/item.js +492,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 +114,'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: 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
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +93,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
-DocType: SMS Log,Requested Numbers,Pageidaujami numeriai
-DocType: Volunteer,Evening,Vakaras
-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 +99,"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
-,Final Assessment Grades,Galutiniai vertinimo balai
-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 +845,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 +204,Reference Doctype must be one of {0},Nuoroda Dokumento tipo turi būti vienas iš {0}
-apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Filtras iš viso nulinio kiekio
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +341,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 +595,BOM {0} must be active,BOM {0} turi būti aktyvus
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +409,No Items available for transfer,Nepavyko perkelti jokių elementų
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218,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 +32,Please select the document type first,Prašome pasirinkti dokumento tipą pirmas
-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
-DocType: Pricing Rule,Rate or Discount,Įkainiai arba nuolaidos
-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 (%)
-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 +74,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
-DocType: Item Barcode,Item Barcode,Prekės brūkšninis kodas
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +329,Please enter Asset Category in Item {0},Prašome įvesti Turto kategorija prekės {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +660,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: Share Transfer,From Folio No,Iš Folio Nr
-DocType: Purchase Invoice Advance,Purchase Invoice Advance,Pirkimo faktūros Advance
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,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: 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 +789,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 +802,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: Asset,Available-for-use Date,Galima naudoti 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 ,privalomas. Galbūt nebuvo sukurtas Valiutų Keitimo įrašas
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +126,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 +633,"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)
-DocType: Share Balance,Purchased,Supirkta
-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 +132,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 +783,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
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +22,Lab testing datetime cannot be before collection datetime,&quot;Lab test&quot; datatime negali būti prieš rinkimo datą
-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
-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 +257,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})
-apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,Iš žymos langelių sąrašo galite pasirinkti tik vieną variantą.
-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 +635,Assigning {0} to {1} (row {2}),Priskirti {0} iki {1} (eilutė {2})
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,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 +478,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 +235,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 +267,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
-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 +386,Variant creation has been queued.,Variantų kūrimas buvo eilėje.
-apps/erpnext/erpnext/stock/doctype/item/item.py +695,Attribute table is mandatory,Įgūdis lentelė yra privalomi
-DocType: Production Plan,Get Sales Orders,Gauk Pardavimų Užsakymus
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68,{0} can not be negative,{0} negali būti neigiamas
-DocType: Training Event,Self-Study,Savarankiškas mokymasis
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +26,Soil compositions do not add up to 100,Dirvožemio kompozicijos neprideda iki 100
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +554,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 +790,Please select a field to edit from numpad,"Pasirinkite lauką, kurį norite redaguoti iš numpad"
-apps/erpnext/erpnext/stock/doctype/item/item.py +263,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: Quality Inspection Template,Quality Inspection Template Name,Kokybės patikrinimo šablono pavadinimas
-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
-DocType: Serial No,Creation Document No,Kūrimas dokumentas Nr
-DocType: Share Transfer,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ą
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858,Delivery Trip,Pristatymo kelionė
-DocType: Student,A-,A-
-DocType: Share Transfer,Transfer Type,Pervedimo tipas
-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 +1623,ZIP Code,Pašto kodas
-apps/erpnext/erpnext/controllers/selling_controller.py +251,Sales Order {0} is {1},Pardavimų užsakymų {0} yra {1}
-DocType: Opportunity,Contact Info,Kontaktinė informacija
-apps/erpnext/erpnext/config/stock.py +319,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
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337,Invoice can't be made for zero billing hour,Sąskaitą faktūrą atlikti negalima už nulinę atsiskaitymo valandą
-DocType: Sales Person,Select company name first.,Pasirinkite įmonės pavadinimas pirmas.
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189,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 +59,All BOMs,Visi BOMs
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Viešbučio kambario tipo {0} negalima {1}
-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 +94,Invalid Attribute,Neteisingas Įgūdis
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +235,{0} {1} must be submitted,{0} {1} turi būti pateiktas
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,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 +38,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 +228,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}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +63,PDC/LC,PDC / LC
-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 +385,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 +428,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.
-DocType: Setup Progress Action,Domains,Domenai
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',"'Pradžios data' negali būti didesnė nei 
-'Pabaigos data'"
-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 +92,Caution,Atsargiai
-apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +16,Start day is greater than end day in task '{0}',Pradžios diena yra didesnė nei pabaigos diena užduočiai &quot;{0}&quot;
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815,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 +212,{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 +750,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 +2500,"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 +105,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 +63,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 +152,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/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Nario veikla
-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 +448,'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 +88,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
-DocType: Hotel Room Reservation,Hotel Reservation User,Viešbučių rezervavimo vartotojas
-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 +35,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 +525,"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
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +112,Dr {0} on Leave on {1},Dr {0} paliktas {1}
-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: Purchase Invoice,05-Change in POS,05 pakeitimas POS
-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 +53,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/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Lab testo rekvizitai
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166,"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 +973,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 +97,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 +794,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 +201,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 +433,"{0}: Employee email not found, hence email not sent","{0}: Darbuotojų elektroninis paštas nerastas, todėl elektroninis laiškas neišsiųstas"
-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 +145,"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 +82,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 +588,Delivery Note {0} is not submitted,Važtaraštis {0} nebus pateiktas
-apps/erpnext/erpnext/stock/get_item_details.py +148,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 +912,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)
-DocType: Daily Work Summary Group,Reminder,Priminimas
-apps/erpnext/erpnext/stock/utils.py +207,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 +608,BOM {0} does not belong to Item {1},BOM {0} nepriklauso punkte {1}
-DocType: Sales Partner,Target Distribution,Tikslinė pasiskirstymas
-DocType: Purchase Invoice,06-Finalization of Provisional assessment,06 - Laikinasis vertinimas
-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 +176,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
-DocType: Asset Settings,This value is used for pro-rata temporis calculation,Ši vertė naudojama pro rata temporis apskaičiavimui
-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: Item Barcode,EAN,EAN
-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/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 +192,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 +71,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
-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
-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',"""Tikėtina pradžios data"" negali būti didesnis nei ""Tikėtina pabaigos data"""
-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 +226,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 +38,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 +195,"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."
-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: 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 +581,cannot be greater than 100,negali būti didesnis nei 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +751,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 +217,"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 +349,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 +241,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)
-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 +158,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 +863,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 +309,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 +1041,Select Possible Supplier,Pasirinkite Galima Tiekėjo
-DocType: Sales Invoice,Source,šaltinis
-DocType: Customer,"Select, to make the customer searchable with these fields","Pasirinkite, kad klientas galėtų ieškoti šių laukų"
-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 +260,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 +146,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/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
-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 +295,Packing Slip(s) cancelled,Pakavimo Kuponas (-ai) atšauktas
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36,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 +464,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 +141,{0} {1} has not been submitted so the action cannot be completed,{0} {1} nebuvo pateikta ir todėl veiksmai negali būti užbaigti
-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/healthcare/doctype/lab_test/lab_test.js +220,Please input all required Result Value(s),Įveskite visus reikiamus rezultatų vertes (-ius)
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94,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 +39,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: Production Plan,Ignore Existing Ordered Quantity,Ignoruoti esamą užsakytą kiekį
-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 +2684,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 +1038,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 +314,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
-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;
-DocType: Shipping Rule Condition,From Value,nuo Vertė
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +593,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 +196,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 +395,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 +123,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"
-DocType: Customer,Primary Address and Contact Detail,Pirminis adresas ir kontaktiniai duomenys
-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/education.py +226,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 +443,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 +189,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 +1093,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 +100,Net Change in Cash,Grynasis Pakeisti pinigais
-DocType: Assessment Plan,Grading Scale,vertinimo skalė
-apps/erpnext/erpnext/stock/doctype/item/item.py +437,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 +639,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: Share Balance,To No,Ne
-DocType: Subscription,Reference Document,Informacinis dokumentas
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229,{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: Purchase Invoice,03-Deficiency in services,03 - paslaugų trūkumas
-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}% Sąskaitos išrašytos
-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 +138,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,"{frequency} Santrauka """
-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 +322,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 +185,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: Purchase Invoice,Eligibility For ITC,Tinkamumas ITC
-DocType: Journal Entry,Entry Type,įrašo tipas
-,Customer Credit Balance,Klientų kredito likučio
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28,Net Change in Accounts Payable,Grynasis pokytis mokėtinos sumos
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,EcritureLet,&quot;EcritureLet&quot;
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +216,Credit limit has been crossed for customer {0} ({1}/{2}),Kredito limitas buvo perkeltas klientui {0} ({1} / {2})
-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 +192,'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 +260,"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
-DocType: Production Plan,Include Non Stock Items,Įtraukti sandėlyje nėra atsargų
-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 +82,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/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Negalima sukurti standartinių kriterijų. Pervardykite kriterijus
-apps/erpnext/erpnext/stock/doctype/item/item.js +282,"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: Drug Prescription,Dosage by time interval,Dozavimas pagal laiko intervalą
-DocType: Cash Flow Mapper,Section Header,Skirsnio antraštė
-,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 +145,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 +677,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 +167,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: Purchase 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 +324,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 +218,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 +457,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 +1139,Make Purchase Order,Padaryti pirkinių užsakymą
-DocType: SMS Center,Send To,siųsti
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +134,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 +204,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 +256,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/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 +236,Please set filter based on Item or Warehouse,Prašome nustatyti filtrą remiantis punktą arba sandėlyje
-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: 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ų)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +798,Discount amount cannot be greater than 100%,Nuolaida negali būti didesnė nei 100%
-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 +598,BOM {0} must be submitted,BOM {0} turi būti pateiktas
-apps/erpnext/erpnext/config/accounts.py +460,Share Management,Dalinkis valdymu
-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 +810,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 +56,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 +217,"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: Material Request Plan Item,Actual Qty,Tikrasis Kiekis
-DocType: Sales Invoice Item,References,Nuorodos
-DocType: Quality Inspection Reading,Reading 10,Skaitymas 10
-DocType: Item,Barcodes,Brūkšniniai kodai
-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 +2199,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 Plan,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 +264,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 +41,"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/controllers/accounts_controller.py +487,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Negalima perduoti {0} {1} daugiau nei {2} eilutėje. Jei norite leisti pernumeruoti mokestį, nustatykite Suvestinės nustatymuose"
-apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Atnaujinti atsakymą
-apps/erpnext/erpnext/public/js/utils.js +232,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 +95,Batch ID is mandatory,Serija ID privalomi
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Serija ID privalomi
-DocType: Sales Person,Parent Sales Person,Tėvų pardavimų asmuo
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100,The seller and the buyer cannot be the same,Pardavėjas ir pirkėjas negali būti vienodi
-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 +253,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 +257,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 +167,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 +334,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 +190,There were errors.,Nebuvo klaidų.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +167,Employee {0} has already applied for {1} between {2} and {3} : ,Darbuotojas {0} jau pateikė paraišką {1} nuo {2} iki {3}:
-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,Pagal Pardavimo Užsakymą
-,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 +385,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 +309,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/hr/doctype/payroll_entry/payroll_entry.py +458,No salary slip found to submit for the above selected criteria OR salary slip already submitted,"Nė vienas atlyginimų slipas, kuris buvo pateiktas dėl pirmiau nurodytų kriterijų ar jau pateikto atlyginimo užstato"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Muitai ir mokesčiai
-DocType: Projects Settings,Projects Settings,Projektų nustatymai
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,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 filtruojami pagal {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: Production Plan,Total Produced Qty,Bendras pagamintas kiekis
-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)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Raw Materials,Žaliavos
-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 +204,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,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 +82,"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/buying/page/purchase_analytics/purchase_analytics.js +131,Not Set,nenustatyta
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +334,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 +334,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/utilities/user_progress.py +143,Pair,Pora
-DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,"Numatytoji paskyra bus automatiškai atnaujinama POS sąskaitoje, kai bus pasirinktas šis režimas."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +961,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/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Tiekėjas&gt; Tiekėjo tipas
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +53,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
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139,Please set the Default Cost Center in {0} company.,Nustatykite &quot;Numatytųjų kainų centro&quot; skaičių {0} kompanijoje.
-DocType: Item,Has Batch No,Turi Serijos Nr
-apps/erpnext/erpnext/public/js/utils.js +106,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 +227,"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 +380,Amount {0} {1} against {2} {3},Suma {0} {1} prieš {2} {3}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,New Message,Nauja žinutė
-,Quotation Trends,Kainų tendencijos
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160,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 +368,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 +212,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 +442,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: Purchase Invoice,Availed ITC Central Tax,Pasinaudojo ITC centriniu mokesčiu
-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
-DocType: Projects Settings,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į.
-DocType: Email Digest,New Expenses,Nauja išlaidos
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79,PDC/LC Amount,PDC / LC suma
-DocType: Shareholder,Shareholder,Akcininkas
-DocType: Purchase Invoice,Additional Discount Amount,Papildoma Nuolaida suma
-DocType: Cash Flow Mapper,Position,Pozicija
-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 +317,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 +138,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
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118,Please set B2C Limit in GST Settings.,Nustatykite B2C limitus GST nustatymuose.
-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,Laukiantieji sprendimo Pardavimo Užsakymai
-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 +356,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 +60,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 +919,Quotation,Pasiūlymas
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984,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 +18,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 +203,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 +232,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 +237,Job Description,Darbo aprašymas
-DocType: Student Applicant,Applied,taikomas
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,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
-DocType: Purchase Invoice,02-Post Sale Discount,02-pardavimo nuolaida
-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ąžą."
-,SO Qty,SO Kiekis
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91,The field To Shareholder cannot be blank,Laukas &quot;Akcininkas&quot; negali būti tuščias
-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 +41,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)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1009,"Item Code, warehouse, quantity are required on row","Prekės kodas, sandėlis, kiekis eilutėje"
-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 +434,{0} is mandatory for Item {1},{0} yra privalomas punktas {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"Item {0}: {1} qty produced, ",Prekė {0}: {1} pagamintas kiekis
-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 +202,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 +171,"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/agriculture/doctype/crop_cycle/crop_cycle.py +35,All tasks for the detected diseases were imported,Visi užfiksuoti ligų uždaviniai buvo importuoti
-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 +90,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/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Pelnas už metus
-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.
-DocType: Cash Flow Mapping,Cash Flow Mapping,Pinigų srautų žemėlapiai
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} pagal Pardavimo Užsakymą {1}
-DocType: Account,Fixed Asset,Ilgalaikio turto
-apps/erpnext/erpnext/config/stock.py +324,Serialized Inventory,Serijinis Inventorius
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,Numatytojo adreso el. Pašto adresas nerastas
-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/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 +871,Please select correct account,Prašome pasirinkti tinkamą sąskaitą
-DocType: Purchase Invoice Item,Weight UOM,Svoris UOM
-apps/erpnext/erpnext/config/accounts.py +466,List of available Shareholders with folio numbers,Turimų akcininkų sąrašas su folio numeriais
-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
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326,Debit ({0}),Debetas ({0})
-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 +362,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: Job Offer 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 +108,Total Unpaid: {0},Iš viso nesumokėtas: {0}
-DocType: BOM Website Operation,BOM Website Operation,BOM svetainė Operacija
-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 +208,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 +348,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 +21,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 +148,"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 +1017,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/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Nepavyko rasti DocType {0}
-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 +996,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 +291,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 +216,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 +135,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 +52,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
-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 +2565,Select Batch No,Pasirinkite Serija Nėra
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61,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,"""Nuo data"" privalomas."
-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 +127,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 +527,Boms,Boms
-apps/erpnext/erpnext/stock/doctype/item/item.py +161,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: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Pinigų srautų žemėlapių šablono detalės
-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 +849,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 +1154,Please set recurring after saving,Prašome nustatyti pasikartojančių po taupymo
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769,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 +45,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 +78,"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: Cash Flow Mapping,Is Income Tax Liability,Yra pajamų mokesčio atskaitomybė
-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
-DocType: Sales Invoice, Shipping Bill Number,Pristatymo sąskaitos numeris
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,atsekamumas
-DocType: Asset Maintenance Log,Actions performed,Veiksmai atlikti
-DocType: Cash Flow Mapper,Section Leader,Skyriaus vedėjas
-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 +418,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
-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 +244,{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ą?
-DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Viešbučių kainų nustatymo paketas
-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 +320,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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceDate,PieceDate
-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 +224,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 +909,Please specify Company to proceed,Prašome nurodyti Bendrovei toliau
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27,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: Job Offer,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."
-apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Paieškos rezultatai
-DocType: Room,Room Number,Kambario numeris
-apps/erpnext/erpnext/utilities/transaction_base.py +103,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 planuotas kiekis ({2}) Gamybos Užsakyme {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 +318,Raw Materials cannot be blank.,Žaliavos negali būti tuščias.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498,"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 +491,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 +93,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 +241,{0} {1} is not submitted,{0} {1} nebus pateiktas
-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 +446,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 +848,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 +191,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 +1026,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 +247,{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
-DocType: Purchase Invoice,ineligible,netinkamas
-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ų"
-DocType: Share Balance,Current State,Dabartinė valstybė
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Pažymėti dabartis
-DocType: Share Transfer,From Shareholder,Iš akcininko
-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: Cash Flow Mapping,Is Finance Cost Adjustment,Ar yra finansinių sąnaudų koregavimas
-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 +14,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 +796,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ą
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80,Remaining Balance,Esamas likutis
-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 +86,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/stock/doctype/item/item.py +497,Barcode {0} is not a valid {1} code,Brūkšninis kodas {0} nėra galiojantis {1} kodas
-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 +376,{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 +210,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/accounts/doctype/sales_invoice/sales_invoice.py +913,Row #{0} (Payment Table): Amount must be positive,Eilutė # {0} (mokėjimo lentelė): suma turi būti teigiama
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteNum,CompteNum
-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 +362,Select Attribute Values,Pasirinkite atributo reikšmes
-DocType: Purchase Invoice,Reason For Issuing document,Paaiškinimas Dokumento išdavimas
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,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;"
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Nustatykite daiktų saugojimo trukmę dienomis, norėdami nustatyti galiojimo laiką pagal gamintojo datą ir savaiminį gyvenimą"
-DocType: Journal Entry,Credit Note,kredito Pastaba
-DocType: Projects Settings,Ignore Employee Time Overlap,Ignoruoti darbuotojo laiko dubliavimą
-DocType: Warranty Claim,Service Address,Paslaugų Adresas
-DocType: Asset Maintenance Task,Calibration,Kalibravimas
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,{0} is a company holiday,{0} yra įmonės atostogos
-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 +247,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 +240,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 +240,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
-,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/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Jei pasirinktas &quot;Kainos nustatymas&quot; yra nustatytas kainų taisyklės, jis pakeis kainoraštį. Kainodaros taisyklė yra galutinė norma, taigi daugiau nuolaida neturėtų būti taikoma. Taigi sandoriuose, pvz., &quot;Pardavimų užsakymas&quot;, &quot;Pirkimo užsakymas&quot; ir tt, jis bus įrašytas laukelyje &quot;Vertė&quot;, o ne &quot;Kainų sąrašo norma&quot;."
-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 +780,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
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +313,For row {0}: Enter planned qty,Eilutėje {0}: įveskite numatytą kiekį
-DocType: Shareholder,SH-,SH-
-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 +825,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 +151,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 +848,"LocalStorage is full, did not save","LocalStorage &quot;yra pilna, neišsaugojo"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,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 +90,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/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 +1255,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 +880,Please select a value for {0} quotation_to {1},Prašome pasirinkti vertę už {0} quotation_to {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414,No Items selected for transfer,Neleidžiama perkelti elementų
-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
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Paskyros numeris sąskaitai {0} nėra. <br> Tinkamai nustatykite savo sąskaitų planą.
-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: Hotel Room,Hotels,Viešbučiai
-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}
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Priminimas atnaujinti išsiųstą GSTIN
-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 +389,{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: Customer,"Reselect, if the chosen contact is edited after save","Iš naujo pasirinkite, jei pasirinktas kontaktas bus redaguojamas po įrašymo"
-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 +542,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 +247,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 +257,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: Production Plan Item,Produced Qty,Pagamintas kiekis
-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 +114,Total Outstanding Amount,Iš viso neapmokėta suma
-DocType: Sales Partner,Targets,tikslai
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54,Please register the SIREN number in the company information file,Prašome įregistruoti SIREN numerį bendrovės informacijos byloje
-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/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/projects/doctype/timesheet/timesheet.py +340,Invoice already created for all billing hours,Sąskaita faktūra jau sukurta visoms atsiskaitymo valandoms
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Vardas klaida: {0}
-DocType: Cash Flow Mapping,Is Finance Cost,Ar yra finansinės išlaidos
-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 +546,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 +259,Quantity must be positive,Kiekis turi būti teigiamas
-DocType: Material Request Plan Item,Requested Qty,prašoma Kiekis
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96,The fields From Shareholder and To Shareholder cannot be blank,Laukai iš akcininko ir akcininko negali būti tušti
-DocType: Tax Rule,Use for Shopping Cart,Naudokite krepšelį
-apps/erpnext/erpnext/controllers/item_variant.py +98,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 +477,"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 +337,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
-DocType: Cash Flow Mapper,Section Subtotal,Tarpinė dalis
-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 +546,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/accounts/doctype/share_transfer/share_transfer.py +192,The folio numbers are not matching,Folio numeriai nesuderinami
-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: Item Barcode,Barcode Type,Brūkšninio kodo tipas
-DocType: Antibiotic,Antibiotic Name,Antibiotiko pavadinimas
-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 +164,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 +806,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 +720,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 +166,Please enter {0} first,Prašome įvesti {0} pirmas
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,Nėra atsakymų
-DocType: Production Order Operation,Actual End Time,Tikrasis Pabaigos laikas
-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
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +118,Expiry date is mandatory for selected item,Galiojimo data yra privaloma pasirinktam elementui
-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 +51,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 +388,Price List Currency not selected,Kainų sąrašas Valiuta nepasirinkote
-DocType: Purchase Invoice,Availed ITC Cess,Pasinaudojo ITC Cess
-,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/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 +18,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/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 +270,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: Member,MEM-,MEM-
-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 +44,"{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 +172,Could not retrieve information for {0}.,Nepavyko gauti informacijos apie {0}.
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134,Opening Entry Journal,Atidarymo leidinys
-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 +232,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 +136,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
-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 +218,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
-DocType: Material Request Plan Item,Minimum Order Quantity,Minimalus Užsakymo Kiekis
-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 +352,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 +516,[Error],[Klaida]
-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ą
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalLib,JournalLib
-DocType: Assessment Group,Assessment Group Name,Vertinimas Grupės pavadinimas
-DocType: Manufacturing Settings,Material Transferred for Manufacture,"Medžiagos, perduotos gamybai"
-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 pateiktos sąskaitos pagal šį 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 +367,Amount {0} {1} {2} {3},Suma {0} {1} {2} {3}
-DocType: Account,Depreciation,amortizacija
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102,The number of shares and the share numbers are inconsistent,Akcijų skaičius ir akcijų skaičius yra nenuoseklūs
-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: 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
-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
-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: 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 +318,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 +518,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/regional/france/utils.py +30,Deletion is not permitted for country {0},Pašalinti neleidžiama šaliai {0}
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +105,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šauktas arba uždarytas
-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 +35,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 +354,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: 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 +249,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: 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: Share Transfer,(including),(įskaitant)
-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,"""Atnaujinti sandėlį"" negali būti patikrintas 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 +368,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 +166,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ų
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21,Please select Employee,Pasirinkite darbuotoją
-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 +183,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 +203,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 +945,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
-DocType: Item Barcode,UPC-A,UPC-A
-,Stock Projected Qty,Akcijų Numatoma Kiekis
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444,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 Invoice,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 +448,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 +59,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 +840,Add All Suppliers,Pridėti visus tiekėjus
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +89,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 +156,Email sent to supplier {0},Paštas išsiųstas tiekėjo {0}
-DocType: Item,Default Sales Unit of Measure,Numatytasis pardavimų matavimo vienetas
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Academic Year: ,Mokslo metai:
-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/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 +830,Get Suppliers By,Gaukite tiekėjų
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +172,{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/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory",Banko sąskaita nuo datos iki datos yra privaloma
-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 +213,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 +41,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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,DateLet,DateLet
-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/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 +163,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: BOM,Inspection Required,Patikrinimo Reikalinga
-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: 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/accounts/report/general_ledger/general_ledger.py +338,Balance ({0}),Balansas ({0})
-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
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,Priminimai el. Paštu bus išsiųsti visoms šalims elektroniniu paštu
-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/healthcare/doctype/patient/patient.js +86,Please save the patient first,Pirmiausia išsaugokite pacientą
-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 +171,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
-,Item Balance (Simple),Prekės balansas (paprastas)
-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 +210,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 +787,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 +23,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 +57,"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 +2039,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: Production Plan Sales Order,Sales Order Date,Pardavimų užsakymų data
-DocType: Sales Invoice Item,Delivered Qty,Paskelbta Kiekis
-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/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Šiuo metu nėra nei viename 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
-DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Viešbučio kambario rezervavimo punktas
-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
-DocType: Share Balance,Share Type,Bendrinti tipą
-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 +378,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 +499,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
-apps/erpnext/erpnext/setup/doctype/company/company.js +95,Company name not same,Įmonės pavadinimas nėra tas pats
-DocType: Lead,Address Desc,Adresas desc
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +108,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 +37,Atleast one of the Selling or Buying must be selected,"Atleast vienas, pardavimas arba pirkimas turi būti parenkamas"
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290,Select an employee to get the employee advance.,"Pasirinkite darbuotoją, kad darbuotojas gautų anksčiau."
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Pasirinkite teisingą datą
-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 +81,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/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Dalinkis &quot;Ledger&quot;
-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 +50,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: Production Plan,Sales Orders Detail,Pardavimų užsakymų detalės
-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-
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Idevise,Idevise
-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 +29,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}% Pristatyta
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107,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/doctype/hub_settings/hub_settings.js +49,Please login as another user.,Prašau prisijungti kaip kitas vartotojas.
-DocType: Daily Work Summary Group User,Daily Work Summary Group User,Dienos darbo santraukos grupės naudotojas
-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 +33,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
-,Warehouse wise Item Balance Age and Value,Sandėlis protingas Prekės balansas Amžius ir vertė
-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
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332,Credit ({0}),Kreditas ({0})
-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."
-DocType: Asset Settings,Number of Days in Fiscal Year,Dienų skaičius fiskaliniais metais
-,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 +92,Purpose must be one of {0},Tikslas turi būti vienas iš {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Fill the form and save it,Užpildykite formą ir išsaugokite jį
-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: Hotel Room Amenity,Billable,Apmokestinama
-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ų"
-DocType: Cash Flow Mapper,Section Name,Skyriaus pavadinimas
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77,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 +60,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/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
-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}) nebėra 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 +321,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/healthcare/doctype/lab_test_template/lab_test_template.py +39,Not permitted. Please disable the Test Template,Neleistina. Prašome išjungti testo šabloną
-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 +222,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 +179,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 +131,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 +69,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 +238,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ė
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Student Group: ,Studentų 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 +475,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 +343,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 +113,Debit Note Amount,Debeto Pastaba suma
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106,"There are inconsistencies between the rate, no of shares and the amount calculated","Yra neatitikimų tarp normos, akcijų nėra ir apskaičiuotos sumos"
-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 +211,Total Outstanding Amt,Visos negrąžintos Amt
-DocType: Journal Entry,Printing Settings,Spausdinimo nustatymai
-DocType: Employee Advance,Advance Account,Išankstinė sąskaita
-DocType: Job Offer,Job Offer Terms,Darbo pasiūlymo sąlygos
-DocType: Sales Invoice,Include Payment (POS),Įtraukti mokėjimą (POS)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,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
-DocType: Hotel Settings,Hotel Settings,Viešbučio nustatymai
-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
-DocType: Purchase Invoice,input,įvestis
-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: Hotel Room Reservation,Booked,Rezervuota
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxLib,CompAuxLib
-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
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639,Splitting {0} units of {1},Suskaidyti {0} vienetų {1}
-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 +122,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 +853,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 +735,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: Sales Invoice,Customer PO Details,Kliento PO duomenys
-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 +1962,Enter value must be positive,Įveskite vertė turi būti teigiamas
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446,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į.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78,PDC/LC Ref,PDC / LC Nuoroda
-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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Montantdevise,Montantdevise
-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
-DocType: Cash Flow Mapping,Is Working Capital,Ar apyvartinis kapitalas
-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 +688,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 +946,No Items with Bill of Materials to Manufacture,"Neturite prekių su Bill iš medžiagų, Gamyba"
-DocType: Hotel Settings,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 +24,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,"""Dienos nuo paskutinio užsakymo"" 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/buying/doctype/purchase_order/purchase_order.js +932,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 +366,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 +77,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.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +110,Dr {0} on Half day Leave on {1},Dr {0} per pusę dienos Išeiti {1}
-DocType: Production Plan,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 +789,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 +115,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 +392,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: Hotel Room,Hotel Room Type,Viešbučio kambario tipas
-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: 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: 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: Production Plan,Get Raw Materials For Production,Gauk žaliavą gamybai
-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 +1012,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}.
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Type in Buying Settings.,Nurodykite tiekėjo tipą pirkimo nustatymuose.
-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 +433,Quantity to Manufacture must be greater than 0.,"Kiekis, Gamyba turi būti didesnis nei 0."
-DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,"Apskaičiuokite apskaičiuotą nusidėvėjimo planą, pagrįstą fiskaliniais metais"
-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 +128,New Batch ID (Optional),Nauja Serija kodas (neprivaloma)
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,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 +47,Net Change in Equity,Grynasis pokytis nuosavo kapitalo
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +220,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 +871,Receipt,gavimas
-,Sales Register,pardavimų Registruotis
-DocType: Daily Work Summary Group,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 +374,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/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/manufacturing/doctype/production_plan/production_plan.py +472,No material request created,Nepateiktas jokių svarbių užklausų
-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 +491,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
-DocType: Hotel Room,Hotel Room,Viešbučio kambarys
-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 +884,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 +613,Please select a BOM,Pasirinkite BOM
-DocType: Purchase Invoice,Availed ITC Integrated Tax,Pasinaudojo ITC integruotu mokesčiu
-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/hr/doctype/payroll_entry/payroll_entry.py +461,"Could not submit any Salary Slip <br>\
-			Possible reasons: <br>\
-			1. Net pay is less than 0. <br>\
-			2. Company Email Address specified in employee master is not valid. <br>",Nepavyko pateikti jokio atlyginimo užmokesčio <br> \ Galimos priežastys: <br> \ 1. Grynasis atlyginimas yra mažesnis nei 0. <br> \ 2. Įmonės darbuotojo kapitono nurodytas įmonės el. Pašto adresas negalioja. <br>
-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/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 +462,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 +187,Cr,kr
-DocType: Tax Rule,Billing State,atsiskaitymo valstybė
-DocType: Share Transfer,Transfer,perkėlimas
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917,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 +82,Increment for Attribute {0} cannot be 0,Taškinis atributas {0} negali būti 0
-apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Rezervuoti kambariai
-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: Shareholder,Contact HTML,Susisiekite su HTML
-apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Registracijos mokestis negali būti lygus nuliui
-DocType: Disease,Treatment Period,Gydymo laikotarpis
-apps/erpnext/erpnext/education/api.py +338,Result already Submitted,Rezultatas jau pateiktas
-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
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,"Prašome palaukti 3 dienas, kol vėl persiųsite priminimą."
-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: 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/accounts/doctype/journal_entry/journal_entry.py +212,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: Hotel Room Amenity,Hotel Room Amenity,Viešbučio kambario patogumas
-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 +809,Send Supplier Emails,Siųsti Tiekėjo laiškus
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +97,"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 +40,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: Job Offer,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 +1462,Total Amount {0},Bendra suma {0}
-apps/erpnext/erpnext/controllers/item_variant.py +303,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 +25,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}
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureDate,&quot;EcritureDate&quot;
-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 +686,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 +72,Split,skilimas
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,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 +263,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 +100,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 +122,New Batch Qty,Nauja Serija Kiekis
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,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"
-DocType: Production Plan,Total Planned Qty,Bendras planuojamas kiekis
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,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 +181,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: Job Offer 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 +98,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
-DocType: Cash Flow Mapping,Select Maximum Of 1,Pasirinkite maksimalų iš 1
-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 +130,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.","""Susitikimas užtruko"" 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 +131,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 +811,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 +112,Total Paid Amount,Iš viso sumokėta suma
-DocType: GST Settings,B2C Limit,B2C riba
-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: Share Balance,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 +277,Quantity should be greater than 0,Kiekis turėtų būti didesnis už 0
-DocType: Journal Entry,Cash Entry,Pinigai įrašas
-DocType: Production Plan,Get Items For Production Order,Gauti daiktus produkcijos užsakymui
-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 +280,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: Hotel Room,Hotel Manager,Viešbučių vadybininkas
-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 +49,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 +43,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
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +102,Customer LPO No.,Kliento LPO Nr.
-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 +1295,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/accounts/report/accounts_receivable/accounts_receivable.js +88,Show PDC in Print,Rodyti PDC spausdintuvu
-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/hr/doctype/job_applicant/job_applicant.js +13,Job Offer,Darbo pasiūlymas
-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 +1073,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 +160,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 +160,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 +491,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: Hotel Room,Extra Bed Capacity,Papildomos lovos talpa
-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/accounts/report/accounts_receivable/accounts_receivable.py +77,PDC/LC Date,PDC / LC 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 +196,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 +567,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 +152,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 +360,{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 +229,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 +653,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 +160,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/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,"Klientas yra privalomas, jei pasirinkta kaip &quot;Klientas&quot; iš &quot;Galimybės&quot;"
-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,capital goods,kapitalo prekės
-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
-DocType: Hotel Room Reservation,Invoiced,Sąskaitos faktūros
-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 +125,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 +48,"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 +918,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
-DocType: Agriculture Task,End Day,Pabaiga diena
-DocType: Batch,Batch ID,Serija ID
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,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: Share Balance,From No,Iš Nr
-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 +270,New Message from {sender},Nauja žinutė iš {siuntėjo}
-DocType: Customer,Customer Primary Address,Pirminis kliento adresas
-apps/erpnext/erpnext/config/learn.py +107,Newsletters,Naujienų prenumerata
-DocType: Drug Prescription,Description/Strength,Aprašymas / stiprumas
-DocType: Share Balance,Is Company,Yra kompanija
-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 +69,"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 +377,{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: Shareholder,Contact List,Kontaktų sarašas
-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 +367,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 +178,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 į Seriją {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}"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +72,Cheques Required,Reikalingi čekiai
-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 +142,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 +585,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 +1071,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 +110,The selected item cannot have Batch,Pasirinktas elementas negali turėti Serija
-DocType: Delivery Note,% of materials delivered against this Delivery Note,% medžiagų pristatyta pagal šią Pristatymo Pažymą
-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"
-apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,Įmonės santrumpa negali būti daugiau nei 5 simboliai
-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 +869,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 +895,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 +210,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/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 +2494,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/config/accounts.py +471,List of all share transactions,Visų akcijų sandorių sąrašas
-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 +244,Please find attached {0} #{1},Pridedamas {0} # {1}
-apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Vidutinė norma
-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/accounts/report/general_ledger/general_ledger.html +25,Balance (Dr - Cr),Balansas (dr - cr)
-apps/erpnext/erpnext/public/js/utils.js +55,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
-DocType: Hotel Room Pricing,Hotel Room Pricing,Viešbučių kainų nustatymas
-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
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84,Customer LPO,Kliento LPO
-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 +74,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: Hotel Settings,Default Taxes and Charges,Numatytieji mokesčiai ir mokesčiai
-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 +980,Select Items to Manufacture,Pasirinkite prekę Gamyba
-DocType: Delivery Stop,Delivery Stop,Pristatymas Stotelė
-apps/erpnext/erpnext/accounts/page/pos/pos.js +963,"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 +42,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 +92,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 +231,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,"""Gavėjai"" nenurodyti"
-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: 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 +186,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
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154,Period Closing Journal,Periodo uždarymo leidinys
-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 +363,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 +498,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;"
-DocType: Production Plan,Include Subcontracted Items,Įtraukite subrangos elementus
-apps/erpnext/erpnext/projects/doctype/project/project.py +218,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 +671,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 +713,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,"""Iki data"" privalomas"
-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 +1113,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: Cash Flow Mapping Accounts,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 +1351,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.
-DocType: Shareholder,Folio no.,Folio Nr.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246,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: Production Plan,Material Requested,Prašoma medžiaga
-DocType: Warehouse,PIN,PIN kodas
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116,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 +74,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
-DocType: Cash Flow Mapper,e.g Adjustments for:,"pvz., koregavimai:"
-apps/erpnext/erpnext/stock/doctype/item/item.py +274," {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 +283,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 +858,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.,"""Užšaldyti atsargas senesnes negu` 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 +98,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 +438,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: Shareholder,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 +924,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 +426,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
-DocType: Hotel Room Package,Hotel Room Package,Viešbučio kambarių paketas
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,valandos
-DocType: Project,Expected Start Date,"Tikimasi, pradžios data"
-DocType: Purchase Invoice,04-Correction in Invoice,04-taisymas sąskaitoje faktūroje
-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}% Užbaigta
-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 +476,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 +509,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 +495,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
-DocType: Cash Flow Mapper,Section Footer,Sekcijos pataisa
-apps/erpnext/erpnext/stock/doctype/item/item.js +275,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/public/js/hub/hub_page.js +137,My Orders,Mano įsakymai
-DocType: Price List,Price List Name,Kainų sąrašas vardas
-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 +106,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 +275,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 +381,{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/agriculture/doctype/soil_texture/soil_texture.py +24,{0} should be a value between 0 and 100,{0} turėtų būti vertė nuo 0 iki 100
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +94,Next Depreciation Date cannot be before Available-for-use Date,Kitas Nusidėvėjimo data negali būti ankstesnė už Galimos naudojimo datą
-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 +209,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 +299,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 +370,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/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 +194,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 +209,{0} {1} does not exist,{0} {1} neegzistuoja
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,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 +87,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/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Sėkmingai nustatykite tiekėją
-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 +84,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
-DocType: Share Balance,No of Shares,Akcijų skaičius
-apps/erpnext/erpnext/stock/doctype/item/item.py +447,'Has Serial No' can not be 'Yes' for non-stock item,"""Turi serijinį Nr."" negali būti ""Taip"" , daiktui kurio nėra sandelyje."
-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 +348,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 +365,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 +324,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: Production Plan Item,Ordered Qty,Užsakytas Kiekis
-apps/erpnext/erpnext/stock/doctype/item/item.py +743,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 +930,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/agriculture/doctype/water_analysis/water_analysis.py +24,Lab result datetime cannot be before testing datetime,Lab datetime rezultatas negali būti prieš bandymą datatime
-DocType: POS Profile,Allow user to edit Discount,Leisti naudotojui redaguoti nuolaidą
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55,Get customers from,Gaukite klientus iš
-DocType: Production Plan Item,Include Exploded Items,Įtraukti sprogus elementus
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45,"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
-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 +548,Default BOM for {0} not found,Numatytasis BOM už {0} nerastas
-apps/erpnext/erpnext/stock/doctype/item/item.py +513,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: Share Transfer,To Folio No,Folio Nr
-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
-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 +231,"{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 +129,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 +571,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 +85,No Delivery Note selected for Customer {},Kliento pasirinkta pristatymo pastaba ()
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25,BOM replaced,BOM pakeisti
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1043,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 +127,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 +90,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
-DocType: Hotel Room Reservation,Hotel Room Reservation,Viešbučių kambario rezervacija
-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
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66,{0} Students have been enrolled,{0} Įstojo mokiniai
-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 +282,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/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
-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}
-DocType: Projects Settings,Ignore User Time Overlap,Ignoruoti naudotojo laiko dubliavimą
-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 +146,Split Batch,Splitas Serija
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Splitas Serija
-DocType: Stock Settings,Batch Identification,Partijos identifikavimas
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,sėkmingai Suderinta
-DocType: Request for Quotation Supplier,Download PDF,atsisiųsti PDF
-DocType: Production Order,Planned End Date,Planuojamas Pabaigos data
-DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Paslėptas sąrašas palaikydamas su akcininku susietus kontaktus
-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 +94,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 +111,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 +573,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
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185,The shareholder does not belong to this company,Akcininkas nėra šios bendrovės narys
-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 +92,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 +175,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 +240,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
-DocType: Purchase Invoice,07-Others,07-Kiti
-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
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureNum,EcritureNum
-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 +500,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,Pagal Pardavimo Užsakymo Objektą
-DocType: Company,Company Logo,Įmonės logotipas
-apps/erpnext/erpnext/stock/doctype/item/item.py +708,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"
-apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,"Prieš kurdami dienos darbo santraukų grupę, įjunkite numatytąją prisijungiančią paskyrą"
-DocType: Assessment Result,Total Score,Galutinis rezultatas
-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
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49,ValidDate,Galiojanti data
-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/healthcare/doctype/consultation/consultation.js +124,Please select Patient,Pasirinkite pacientą
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Pardavėjas
-DocType: Hotel Room Package,Amenities,Patogumai
-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."
-DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Pinigų srautų žemėlapių sąskaitos
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupės salės Nr.
-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: Opening Invoice Creation Tool,Create Missing Party,Sukurti trūkstamą vakarėlį
-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-
-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 +173,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
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},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: Purchase Invoice,Availed ITC State/UT Tax,Pasinaudojo ITC valstybės / UT mokesčiu
-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 +120,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 +1384,Select or add new customer,Pasirinkite arba pridėti naujų klientų
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +171,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 +494,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 +261,Supplier Quotation {0} created,Tiekėjas Citata {0} sukūrė
-apps/erpnext/erpnext/accounts/report/financial_statements.py +101,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 +233,Employee Benefits,Išmokos darbuotojams
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264,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/accounts/doctype/share_transfer/share_transfer.py +78,The shares don't exist with the {0},Akcijos neegzistuoja {0}
-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
-DocType: Projects Settings,Ignore Workstation Time Overlap,Ignoruoti darbo vietos laiko dubliavimą
-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 +534,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 +1716,Price List not found or disabled,Kainų sąrašas nerastas arba išjungtas
-DocType: Student Applicant,Approved,patvirtinta
-apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,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
-DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Sukurkite trūkstamą klientą ar tiekėją.
-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
-DocType: POS Profile,Account for Change Amount,Sąskaita už pokyčio sumą
-DocType: Purchase Invoice,input service,įvesties paslauga
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,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 +13,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 +329,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
-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 +191,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ų pristatyta pagal šį Pardavimo 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 +260,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 +282,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 +144,"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 +874,Material to Supplier,"Medžiaga, iš Tiekėjui"
-DocType: Soil Texture,Loamy Sand,Gluosnių smėlis
-DocType: Production Plan,Material Request Planning,Medžiagų užklausos planavimas
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +630,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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158,No Reference,Nr nuorodos
-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 +92,"{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 +51,Stock Levels,atsargų kiekis
-DocType: Customer,Commission Rate,Komisija Balsuok
-apps/erpnext/erpnext/stock/doctype/item/item.js +475,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 +150,"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 +25,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 Invoice,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 +431, (Half Day),(Pusė dienos)
-DocType: Payment Term,Credit Days,kredito dienų
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,"Prašome pasirinkti &quot;Pacientas&quot;, kad gautumėte &quot;Lab&quot; testus"
-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 +841,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
-DocType: Cash Flow Mapping,Is Income Tax Expense,Yra pajamų mokesčio sąnaudos
-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 +54,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 +105,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 +196,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ų.
+b'DocType: Employee',b'Salary Mode',b'Pajamos re\xc5\xbeimas'
+b'DocType: Patient',b'Divorced',b'i\xc5\xa1siskyr\xc4\x99s'
+b'DocType: Buying Settings',b'Allow Item to be added multiple times in a transaction',b'Leisti punktas turi b\xc5\xabti prid\xc4\x97tas kelis kartus i\xc5\xa1 sandorio'
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33',b'Cancel Material Visit {0} before cancelling this Warranty Claim',b'At\xc5\xa1aukti med\xc5\xbeiaga Apsilankymas {0} prie\xc5\xa1 panaikinant \xc5\xa1\xc4\xaf garantin\xc4\x97s pretenzijos'
+b'apps/erpnext/erpnext/config/education.py +118',b'Assessment Reports',b'Vertinimo ataskaitos'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19',b'Consumer Products',b'Vartotoj\xc5\xb3 gaminiai'
+b'DocType: Purchase Receipt',b'Subscription Detail',b'Prenumeratos informacija'
+b'DocType: Supplier Scorecard',b'Notify Supplier',b'Prane\xc5\xa1ti tiek\xc4\x97jui'
+b'DocType: Item',b'Customer Items',b'klient\xc5\xb3 daiktai'
+b'DocType: Project',b'Costing and Billing',b'S\xc4\x85naud\xc5\xb3 ir atsiskaitymas'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +48',b'Account {0}: Parent account {1} can not be a ledger',b'S\xc4\x85skaita {0}: T\xc4\x97v\xc5\xb3 s\xc4\x85skait\xc4\x85 {1} negali b\xc5\xabti knygos'
+b'DocType: Item',b'Publish Item to hub.erpnext.com',b'Paskelbti Prek\xc4\x99 hub.erpnext.com'
+b'apps/erpnext/erpnext/config/setup.py +88',b'Email Notifications',b'Si\xc5\xb3sti Prane\xc5\xa1imai'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26',b'Evaluation',b'vertinimas'
+b'DocType: Item',b'Default Unit of Measure',b'Numatytasis matavimo vienetas'
+b'DocType: SMS Center',b'All Sales Partner Contact',b'Visos pardavimo partner\xc4\x97 Susisiekite'
+b'DocType: Employee',b'Leave Approvers',b'Palikite Approvers'
+b'DocType: Sales Partner',b'Dealer',b'prekiautojas'
+b'DocType: Work Order',b'WO-',b'WO-'
+b'DocType: Consultation',b'Investigations',b'Tyrimai'
+b'DocType: Restaurant Order Entry',b'Click Enter To Add',b'Spustel\xc4\x97kite &quot;\xc4\xaetraukti&quot;'
+b'DocType: Employee',b'Rented',b'nuomojamos'
+b'DocType: Purchase Order',b'PO-',b'po-'
+b'DocType: Vehicle Service',b'Mileage',b'Rida'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +253',b'Do you really want to scrap this asset?',b'Ar tikrai norite atsisakyti \xc5\xa1ios turt\xc4\x85?'
+b'DocType: Drug Prescription',b'Update Schedule',b'Atnaujinti tvarkara\xc5\xa1t\xc4\xaf'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44',b'Select Default Supplier',b'Pasirinkti Default Tiek\xc4\x97jas'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37',b'Currency is required for Price List {0}',b'Valiut\xc5\xb3 reikia kainora\xc5\xa1\xc4\x8dio {0}'
+b'DocType: Sales Taxes and Charges Template',b'* Will be calculated in the transaction.',b'* Bus apskai\xc4\x8diuojama sandor\xc4\xaf.'
+b'DocType: Purchase Order',b'Customer Contact',b'Klient\xc5\xb3 Susisiekite'
+b'DocType: Patient Appointment',b'Check availability',b'Patikrinkite u\xc5\xbeimtum\xc4\x85'
+b'DocType: Job Applicant',b'Job Applicant',b'Darbas Parei\xc5\xa1k\xc4\x97jas'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6',b'This is based on transactions against this Supplier. See timeline below for details',b'Tai grind\xc5\xbeiama sandori\xc5\xb3 at\xc5\xbevilgiu \xc5\xa1is tiek\xc4\x97jas. \xc5\xbdi\xc5\xabr\xc4\x97ti grafikas \xc5\xbeemiau detales'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120',b'Legal',b'juridinis'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191',b'Actual type tax cannot be included in Item rate in row {0}',b'Tikrasis tipas mokestis negali b\xc5\xabti \xc4\xaftrauktos prek\xc4\x97s lygis eil\xc4\x97s {0}'
+b'DocType: Bank Guarantee',b'Customer',b'klientas'
+b'DocType: Purchase Receipt Item',b'Required By',b'reikalaujama pagal'
+b'DocType: Delivery Note',b'Return Against Delivery Note',b'Gr\xc4\xaf\xc5\xbeti Prie\xc5\xa1 va\xc5\xbetara\xc5\xa1tyje'
+b'DocType: Purchase Order',b'% Billed',b'% S\xc4\x85skaitos pateiktos'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43',b'Exchange Rate must be same as {0} {1} ({2})',"b'Valiut\xc5\xb3 kursai turi b\xc5\xabti toks pat, kaip {0} {1} ({2})'"
+b'DocType: Sales Invoice',b'Customer Name',b'Klientas'
+b'DocType: Vehicle',b'Natural Gas',b'Gamtini\xc5\xb3 duj\xc5\xb3'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64',b'Bank account cannot be named as {0}',b'Banko s\xc4\x85skaita negali b\xc5\xabti vadinamas {0}'
+b'DocType: Account',b'Heads (or groups) against which Accounting Entries are made and balances are maintained.',"b'Vadovai (ar j\xc5\xb3 grup\xc4\x97s), pagal kur\xc4\xaf apskaitos \xc4\xafra\xc5\xa1ai yra pagaminti ir liku\xc4\x8diai i\xc5\xa1lieka.'"
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196',b'Outstanding for {0} cannot be less than zero ({1})',b'Ne\xc4\xafvykdyti {0} negali b\xc5\xabti ma\xc5\xbeesn\xc4\x97 u\xc5\xbe nul\xc4\xaf ({1})'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348',b'There are no submitted Salary Slips to process.',b'Apdorojimo atlyginimo u\xc5\xbestatas n\xc4\x97ra.'
+b'DocType: Manufacturing Settings',b'Default 10 mins',b'Numatytasis 10 min'
+b'DocType: Leave Type',b'Leave Type Name',b'Palikite Modelio pavadinimas'
+b'apps/erpnext/erpnext/templates/pages/projects.js +62',b'Show open',b'Rodyti atvira'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8',b'It is necessary to take this action today itself for the above mentioned recurring',b'\xc5\xa0iuos veiksmus reikia pa\xc4\x8diam patys imtis pirmiau min\xc4\x97tuose pasikartojan\xc4\x8diuose veiksmuose'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156',b'Series Updated Successfully',b'Serija Atnaujinta s\xc4\x97kmingai'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6',b'Checkout',b'U\xc5\xbesakymas'
+b'DocType: Pricing Rule',b'Apply On',b'taikyti ant'
+b'DocType: Item Price',b'Multiple Item prices.',b'Keli punktas kainos.'
+,b'Purchase Order Items To Be Received',b'Pirkimui u\xc5\xbesakyti prekes bus gauta'
+b'DocType: SMS Center',b'All Supplier Contact',b'Visi tiek\xc4\x97ju Kontaktai Reklama'
+b'DocType: Support Settings',b'Support Settings',b'paramos Nustatymai'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +75',b'Expected End Date can not be less than Expected Start Date',b'Tikimasi Pabaigos data negali b\xc5\xabti ma\xc5\xbeesn\xc4\x97 nei planuotos datos'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +121',b'Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ',"b'Eilut\xc4\x97s # {0}: dydis turi b\xc5\xabti toks pat, kaip {1} {2} ({3} / {4})'"
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241',b'New Leave Application',b'Nauja atostogos taikymas'
+,b'Batch Item Expiry Status',b'Serija punktas Galiojimo B\xc5\xabsena'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184',b'Bank Draft',b'bankas projektas'
+b'DocType: Membership',b'membership validaty section',b'naryst\xc4\x97s patvirtinantis skyrius'
+b'DocType: Mode of Payment Account',b'Mode of Payment Account',b'mok\xc4\x97jimo s\xc4\x85skaitos re\xc5\xbeimas'
+b'DocType: Consultation',b'Consultation',b'Konsultacijos'
+b'DocType: Accounts Settings',b'Show Payment Schedule in Print',b'Rodyti mok\xc4\x97jimo grafik\xc4\x85 Spausdinti'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19',b'Sales and Returns',b'Pardavimai ir gr\xc4\x85\xc5\xbeinimai'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +56',b'Show Variants',b'Rodyti Variantai'
+b'DocType: Academic Term',b'Academic Term',b'akademin\xc4\x97 terminas'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14',b'Material',b'med\xc5\xbeiaga'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66',b'Making website',b'Svetain\xc4\x97s k\xc5\xabrimas'
+b'DocType: Opening Invoice Creation Tool Item',b'Quantity',b'kiekis'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546',b'Accounts table cannot be blank.',b'S\xc4\x85skaitos lentel\xc4\x97 gali b\xc5\xabti tu\xc5\xa1\xc4\x8dias.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154',b'Loans (Liabilities)',b'Paskolos (\xc4\xafsipareigojimai)'
+b'DocType: Employee Education',b'Year of Passing',b'Metus artim\xc5\xb3j\xc5\xb3'
+b'DocType: Item',b'Country of Origin',b'Kilm\xc4\x97s \xc5\xa1alis'
+b'DocType: Soil Texture',b'Soil Texture Criteria',b'Dirvo\xc5\xbeemio tekst\xc5\xabros kriterijai'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +25',b'In Stock',b'Prekyboje'
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16',b'Primary Contact Details',b'Pagrindin\xc4\x97 kontaktin\xc4\x97 informacija'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46',b'Open Issues',b'Atviri klausimai'
+b'DocType: Production Plan Item',b'Production Plan Item',b'Gamybos planas punktas'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +149',b'User {0} is already assigned to Employee {1}',b'Vartotojas {0} jau priskirtas Darbuotojo {1}'
+b'DocType: Lab Test Groups',b'Add new line',b'Prid\xc4\x97ti nauj\xc4\x85 eilut\xc4\x99'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31',b'Health Care',b'Sveikatos apsauga'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65',b'Delay in payment (Days)',b'Delsimas mok\xc4\x97jimo (dienomis)'
+b'DocType: Payment Terms Template Detail',b'Payment Terms Template Detail',b'Apmok\xc4\x97jimo s\xc4\x85lygos \xc5\xa0ablono detal\xc4\x97s'
+b'DocType: Hotel Room Reservation',b'Guest Name',b'Sve\xc4\x8dio vardas'
+b'DocType: Lab Prescription',b'Lab Prescription',b'Lab receptas'
+,b'Delay Days',b'V\xc4\x97lavimo dienos'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26',b'Service Expense',b'Paslaug\xc5\xb3 i\xc5\xa1laid\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899',b'Serial Number: {0} is already referenced in Sales Invoice: {1}',b'Serijos numeris: {0} jau yra nuorodos \xc4\xaf pardavimo s\xc4\x85skaita-fakt\xc5\xabra: {1}'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889',b'Invoice',b'fakt\xc5\xabra'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145',b'Make Retention Stock Entry',b'Padarykite atsarg\xc5\xb3 \xc4\xafra\xc5\xa1\xc4\x85'
+b'DocType: Purchase Invoice Item',b'Item Weight Details',b'Prek\xc4\x97s svarumo duomenys'
+b'DocType: Asset Maintenance Log',b'Periodicity',b'periodi\xc5\xa1kumas'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21',b'Fiscal Year {0} is required',b'Finansiniai metai {0} reikalingas'
+b'DocType: Crop Cycle',b'The minimum distance between rows of plants for optimum growth',b'Ma\xc5\xbeiausias atstumas tarp augal\xc5\xb3 eilu\xc4\x8di\xc5\xb3 siekiant optimalaus augimo'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21',b'Defense',b'apsauga'
+b'DocType: Salary Component',b'Abbr',b'abbr'
+b'DocType: Appraisal Goal',b'Score (0-5)',b'Rezultatas (0-5)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225',b'Row {0}: {1} {2} does not match with {3}',b'Eilut\xc4\x97s {0}: {1} {2} nesutampa su {3}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77',b'Row # {0}:',b'Eilut\xc4\x97s # {0}:'
+b'DocType: Timesheet',b'Total Costing Amount',b'I\xc5\xa1 viso S\xc4\x85naud\xc5\xb3 suma'
+b'DocType: Delivery Note',b'Vehicle No',b'Automobilio N\xc4\x97ra'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163',b'Please select Price List',b'Pra\xc5\xa1ome pasirinkti Kainora\xc5\xa1tis'
+b'DocType: Accounts Settings',b'Currency Exchange Settings',b'Valiutos keitimo nustatymai'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94',b'Row #{0}: Payment document is required to complete the trasaction',b'Eilut\xc4\x97s # {0}: mok\xc4\x97jimo dokumentas privalo baigti trasaction'
+b'DocType: Work Order Operation',b'Work In Progress',b'Darbas vyksta'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13',b'Please select date',b'Pra\xc5\xa1ome pasirinkti dat\xc4\x85'
+b'DocType: Daily Work Summary Group',b'Holiday List',b'Atostog\xc5\xb3 s\xc4\x85ra\xc5\xa1as'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88',b'Please setup numbering series for Attendance via Setup &gt; Numbering Series',b'Nustatykite numeri\xc5\xb3 serij\xc4\x85 lankytojams per s\xc4\x85rank\xc4\x85&gt; numeravimo serija'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127',b'Accountant',b'buhalteris'
+b'DocType: Hub Settings',b'Selling Price List',b'Pardavimo kainora\xc5\xa1tis'
+b'DocType: Patient',b'Tobacco Current Use',b'Tabako vartojimas'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56',b'Selling Rate',b'Pardavimo norma'
+b'DocType: Cost Center',b'Stock User',b'akcij\xc5\xb3 Vartotojas'
+b'DocType: Soil Analysis',b'(Ca+Mg)/K',b'(Ca + Mg) / K'
+b'DocType: Company',b'Phone No',b'Telefonas N\xc4\x97ra'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239',b'New {0}: #{1}',b'Nauja {0}: # {1}'
+b'DocType: Delivery Trip',b'Initial Email Notification Sent',b'I\xc5\xa1siun\xc4\x8diamas pradinis el. Pa\xc5\xa1to prane\xc5\xa1imas'
+,b'Sales Partners Commission',b'Pardavim\xc5\xb3 Partneriai Komisija'
+b'DocType: Soil Texture',b'Sandy Clay Loam',b'Sm\xc4\x97lio molio nuos\xc4\x97dos'
+b'DocType: Purchase Invoice',b'Rounding Adjustment',b'Apvalinimo reguliavimas'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +46',b'Abbreviation cannot have more than 5 characters',b'Santrumpa negali tur\xc4\x97ti daugiau nei 5 simboliai'
+b'DocType: Physician Schedule Time Slot',b'Physician Schedule Time Slot',b'Gydytojo tvarkara\xc5\xa1\xc4\x8dio laiko tarpsnis'
+b'DocType: Payment Request',b'Payment Request',b'mok\xc4\x97jimo pra\xc5\xa1ymas'
+b'DocType: Asset',b'Value After Depreciation',b'Vert\xc4\x97 po nusid\xc4\x97v\xc4\x97jimo'
+b'DocType: Student',b'O+',b'O +'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8',b'Related',b'Susij\xc4\x99s'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43',"b""Attendance date can not be less than employee's joining date""","b'Lankomumas data negali b\xc5\xabti ma\xc5\xbeesn\xc4\x97 nei darbuotojo, jungian\xc4\x8dia datos'"
+b'DocType: Grading Scale',b'Grading Scale Name',b'Vertinimo skal\xc4\x97 Vardas'
+b'DocType: Subscription',b'Repeat on Day',b'Pakartokite dien\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +41',b'This is a root account and cannot be edited.',b'Tai \xc5\xa1aknys s\xc4\x85skaita ir negali b\xc5\xabti redaguojami.'
+b'DocType: Sales Invoice',b'Company Address',b'Kompanijos adresas'
+b'DocType: BOM',b'Operations',b'operacijos'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38',b'Cannot set authorization on basis of Discount for {0}',b'Negalima nustatyti leidimo pagrindu Nuolaida {0}'
+b'DocType: Rename Tool',"b'Attach .csv file with two columns, one for the old name and one for the new name'","b'Prisegti .csv fail\xc4\x85 su dviem stulpeliais, po vien\xc4\x85 sen\xc4\x85 pavadinim\xc4\x85 ir vien\xc4\x85 nauj\xc4\x85 vard\xc4\x85'"
+b'apps/erpnext/erpnext/accounts/utils.py +73',b'{0} {1} not in any active Fiscal Year.',b'{0} {1} jokiu aktyviu finansinius metus.'
+b'DocType: Packed Item',b'Parent Detail docname',b'T\xc4\x97v\xc5\xb3 I\xc5\xa1samiau DOCNAME'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69',"b'Reference: {0}, Item Code: {1} and Customer: {2}'","b'Nuoroda: {0}, Prek\xc4\x97s kodas: {1} ir klient\xc5\xb3: {2}'"
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Kg',b'Kilogramas'
+b'apps/erpnext/erpnext/config/hr.py +45',b'Opening for a Job.',b'Atidarymo d\xc4\x97l darbo.'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114',b'BOM is not specified for subcontracting item {0} at row {1}',b'BOM n\xc4\x97ra nurodyta subrangos elementui {0} eilut\xc4\x97je {1}'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149',b'{0} Result submittted',b'{0} Rezultatas pateiktas'
+b'DocType: Item Attribute',b'Increment',b'prieaugis'
+b'apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74',b'Timespan',b'Laiko tarpas'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +58',b'Select Warehouse...',b'Pasirinkite sand\xc4\x97lio ...'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6',b'Advertising',b'reklaminis'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22',b'Same Company is entered more than once',b'Pati bendrov\xc4\x97 yra \xc4\xafra\xc5\xa1ytas daugiau nei vien\xc4\x85 kart\xc4\x85'
+b'DocType: Patient',b'Married',b'Ved\xc4\x99s'
+b'apps/erpnext/erpnext/accounts/party.py +41',b'Not permitted for {0}',b'Neleid\xc5\xbeiama {0}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593',b'Get items from',b'Gauk elementus i\xc5\xa1'
+b'DocType: Price List',b'Price Not UOM Dependant',b'Kaina ne priklausomai nuo UOM'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467',b'Stock cannot be updated against Delivery Note {0}',"b'Akcij\xc5\xb3, negali b\xc5\xabti atnaujintas prie\xc5\xa1 va\xc5\xbetara\xc5\xa1tyje {0}'"
+b'apps/erpnext/erpnext/templates/pages/home.py +25',b'Product {0}',b'Prek\xc4\x97s {0}'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +43',b'No items listed',b'N\xc4\x97ra i\xc5\xa1vardytus punktus'
+b'DocType: Asset Repair',b'Error Description',b'Klaida Apra\xc5\xa1ymas'
+b'DocType: Payment Reconciliation',b'Reconcile',b'suderinti'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30',b'Grocery',b'Parduotuv\xc4\x97'
+b'DocType: Quality Inspection Reading',b'Reading 1',b'Skaitymas 1'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40',b'Pension Funds',b'pensij\xc5\xb3 fondai'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +91',b'Next Depreciation Date cannot be before Purchase Date',b'Kitas Nusid\xc4\x97v\xc4\x97jimas data negali b\xc5\xabti prie\xc5\xa1 perkant data'
+b'DocType: Crop',b'Perennial',b'Daugiametis'
+b'DocType: Consultation',b'Consultation Date',b'Konsultacijos data'
+b'DocType: Accounts Settings',b'Use Custom Cash Flow Format',b'Naudokite tinkint\xc4\x85 pinig\xc5\xb3 sraut\xc5\xb3 format\xc4\x85'
+b'DocType: SMS Center',b'All Sales Person',b'Visi Pardavim\xc5\xb3 Vadybininkai'
+b'DocType: Monthly Distribution',b'**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.',"b'** M\xc4\x97nesio pasiskirstymas ** Jums pad\xc4\x97s platinti biud\xc5\xbeeto / target visoje m\xc4\x97nesius, jei turite sezoni\xc5\xa1kum\xc4\x85 savo versl\xc4\x85.'"
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1753',b'Not items found',b'Nerasta daiktai'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184',b'Salary Structure Missing',b'Darbo u\xc5\xbemokes\xc4\x8dio strukt\xc5\xabr\xc4\x85 Tr\xc5\xabksta'
+b'DocType: Lead',b'Person Name',"b'asmens vardas, pavard\xc4\x97'"
+b'DocType: Sales Invoice Item',b'Sales Invoice Item',b'Pardavim\xc5\xb3 s\xc4\x85skaita fakt\xc5\xabra punktas'
+b'DocType: Account',b'Credit',b'kreditas'
+b'DocType: POS Profile',b'Write Off Cost Center',b'Nura\xc5\xa1yti i\xc5\xa1laid\xc5\xb3 centrus'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +117',"b'e.g. ""Primary School"" or ""University""'",b'pvz &quot;pradin\xc4\x97 mokykla&quot; arba &quot;Universitetas&quot;'
+b'apps/erpnext/erpnext/config/stock.py +28',b'Stock Reports',b'Akcij\xc5\xb3 ataskaitos'
+b'DocType: Warehouse',b'Warehouse Detail',b'Sand\xc4\x97li\xc5\xb3 detal\xc4\x97s'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33',b'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.',"b'Kadencijos pabaigos data negali b\xc5\xabti v\xc4\x97lesn\xc4\x97 nei met\xc5\xb3 pabaigoje mokslo met\xc5\xb3 data, iki kurios terminas yra susij\xc4\x99s (akademiniai metai {}). I\xc5\xa1taisykite datas ir bandykite dar kart\xc4\x85.'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +269',"b'""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item'","b'""Yra Ilgalaikis turtas"" negali b\xc5\xabti nepa\xc5\xbeym\xc4\x97tas, nes egzistuoja prie\xc5\xa1taraujantis turto \xc4\xafra\xc5\xa1as.'"
+b'DocType: Delivery Trip',b'Departure Time',b'I\xc5\xa1vykimo laikas'
+b'DocType: Vehicle Service',b'Brake Oil',b'stabd\xc5\xbei\xc5\xb3 Nafta'
+b'DocType: Tax Rule',b'Tax Type',b'mokes\xc4\x8di\xc5\xb3 tipas'
+,b'Completed Work Orders',b'U\xc5\xbebaigti darbo u\xc5\xbesakymai'
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +581',b'Taxable Amount',b'apmokestinamoji vert\xc4\x97'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160',b'You are not authorized to add or update entries before {0}',b'J\xc5\xabs nesate \xc4\xafgaliotas prid\xc4\x97ti ar atnaujinti \xc4\xafra\xc5\xa1us prie\xc5\xa1 {0}'
+b'DocType: BOM',b'Item Image (if not slideshow)',b'Prek\xc4\x97 vaizdas (jei ne skaidri\xc5\xb3)'
+b'DocType: Work Order Operation',b'(Hour Rate / 60) * Actual Operation Time',b'(Per valand\xc4\x85/ 60) * Tikrasis veikimo laikas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103',b'Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry',b'Eilut\xc4\x97 # {0}: standartinio dokumento tipas turi b\xc5\xabti vienas i\xc5\xa1 i\xc5\xa1laid\xc5\xb3 reikalavimo arba leidimo \xc4\xafra\xc5\xa1o'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975',b'Select BOM',b'Pasirinkite BOM'
+b'DocType: SMS Log',b'SMS Log',b'SMS Prisijungti'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Delivered Items',b'I\xc5\xa1laidos pristatyto objekto'
+b'apps/erpnext/erpnext/config/hr.py +127',b'Manage advance amount given to the Employee',b'Tvarkyti darbuotojui skirt\xc4\x85 i\xc5\xa1ankstin\xc4\x99 sum\xc4\x85'
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38',b'The holiday on {0} is not between From Date and To Date',b'Atostog\xc5\xb3 \xc4\xaf {0} yra ne tarp Nuo datos ir iki \xc5\xa1iol'
+b'DocType: Student Log',b'Student Log',b'Student\xc5\xb3 Prisijungti'
+b'apps/erpnext/erpnext/config/buying.py +165',b'Templates of supplier standings.',b'Tiek\xc4\x97jo lentel\xc4\x97s \xc5\xa1ablonai.'
+b'DocType: Lead',b'Interested',b'Suinteresuotas'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216',b'Opening',b'atidarymas'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32',b'From {0} to {1}',b'I\xc5\xa1 {0} ir {1}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234',b'Program: ',b'Programa:'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50',b'Failed to setup taxes',b'Nepavyko nustatyti mokes\xc4\x8di\xc5\xb3'
+b'DocType: Item',b'Copy From Item Group',b'Kopijuoti Nuo punktas grup\xc4\x97s'
+b'DocType: Delivery Trip',b'Delivery Notification',b'Pristatymo prane\xc5\xa1imas'
+b'DocType: Journal Entry',b'Opening Entry',b'atidarymas \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25',b'Account Pay Only',b'S\xc4\x85skaita mokate tik'
+b'DocType: Employee Loan',b'Repay Over Number of Periods',b'Gr\xc4\x85\xc5\xbeinti Over period\xc5\xb3 skai\xc4\x8dius'
+b'DocType: Stock Entry',b'Additional Costs',b'Papildomos i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +138',b'Account with existing transaction can not be converted to group.',b'S\xc4\x85skaita su esama sandoris negali b\xc5\xabti konvertuojamos \xc4\xaf grup\xc4\x99.'
+b'DocType: Lead',b'Product Enquiry',b'Prek\xc4\x97s U\xc5\xbeklausa'
+b'DocType: Education Settings',b'Validate Batch for Students in Student Group',b'Patvirtinti Serija studentams Student\xc5\xb3 grup\xc4\x97s'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35',b'No leave record found for employee {0} for {1}',b'Ne atostogos rekordas darbuotojo rado {0} u\xc5\xbe {1}'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23',b'Please enter company first',b'Pra\xc5\xa1ome \xc4\xafvesti \xc4\xafmon\xc4\x99 pirmas'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365',b'Please select Company first',b'Pra\xc5\xa1ome pasirinkti Company pirmas'
+b'DocType: Employee Education',b'Under Graduate',b'pagal diplomas'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27',b'Target On',b'Tikslin\xc4\x97 Apie'
+b'DocType: BOM',b'Total Cost',b'I\xc5\xa1 viso i\xc5\xa1laid\xc5\xb3'
+b'DocType: Soil Analysis',b'Ca/K',b'Ca / K'
+b'DocType: Journal Entry Account',b'Employee Loan',b'Darbuotoj\xc5\xb3 Paskolos'
+b'DocType: Fee Schedule',b'Send Payment Request Email',b'Si\xc5\xb3sti mok\xc4\x97jimo u\xc5\xbeklaus\xc4\x85 el. Pa\xc5\xa1tu'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268',b'Item {0} does not exist in the system or has expired',b'Prek\xc4\x97 {0} sistemoje neegzistuoja arba pasibaig\xc4\x97 galiojimas'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44',b'Real Estate',b'Nekilnojamasis turtas'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1',b'Statement of Account',b'S\xc4\x85skait\xc5\xb3 ataskaita'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41',b'Pharmaceuticals',b'vaistai'
+b'DocType: Purchase Invoice Item',b'Is Fixed Asset',b'Ar Ilgalaikio turto'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273',"b'Available qty is {0}, you need {1}'","b'Turimas Kiekis yra {0}, jums reikia {1}'"
+b'DocType: Expense Claim Detail',b'Claim Amount',b'reikalavimo suma'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +653',b'Work Order has been {0}',b'Darbo tvarka buvo {0}'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56',b'Duplicate customer group found in the cutomer group table',b'rasti abonentu grup\xc4\x97s lentel\xc4\x97je dublikatas klient\xc5\xb3 grup\xc4\x97'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31',b'Supplier Type / Supplier',b'Tiek\xc4\x97jas Tipas / Tiek\xc4\x97jas'
+b'DocType: Naming Series',b'Prefix',b'prie\xc5\xa1d\xc4\x97lis'
+b'apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7',b'Event Location',b'Renginio vieta'
+b'DocType: Asset Settings',b'Asset Settings',b'Turto nustatymai'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68',b'Consumable',b'vartojimo'
+b'DocType: Student',b'B-',b'B'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98',b'Successfully unregistered.',b'S\xc4\x97kmingai ne\xc4\xafregistruota.'
+b'DocType: Assessment Result',b'Grade',b'klas\xc4\x97'
+b'DocType: Restaurant Table',b'No of Seats',b'S\xc4\x97dim\xc5\xb3 viet\xc5\xb3 skai\xc4\x8dius'
+b'DocType: Subscription',"b'To add dynamic subject, use jinja tags like\n\n<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>'","b'Nor\xc4\x97dami prid\xc4\x97ti dinamin\xc4\xaf tem\xc4\x85, naudokite jinja \xc5\xbeymes kaip <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>'"
+b'DocType: Sales Invoice Item',b'Delivered By Supplier',b'Paskelbta tiek\xc4\x97jo'
+b'DocType: Asset Maintenance Task',b'Asset Maintenance Task',b'Turto i\xc5\xa1laikymo u\xc5\xbeduotis'
+b'DocType: SMS Center',b'All Contact',b'visi Susisiekite'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232',b'Annual Salary',b'Metinis atlyginimas'
+b'DocType: Daily Work Summary',b'Daily Work Summary',b'Dienos darbo santrauka'
+b'DocType: Period Closing Voucher',b'Closing Fiscal Year',b'U\xc5\xbedarius finansinius metus'
+b'apps/erpnext/erpnext/accounts/party.py +392',b'{0} {1} is frozen',b'{0} {1} yra su\xc5\xa1aldyti'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +140',b'Please select Existing Company for creating Chart of Accounts',b'Pra\xc5\xa1ome pasirinkti veikian\xc4\x8di\xc4\x85 bendrov\xc4\x99 kurti s\xc4\x85skait\xc5\xb3 plan\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80',b'Stock Expenses',b'Akcij\xc5\xb3 i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Pasirinkite Target sand\xc4\x97lis'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Pasirinkite Target sand\xc4\x97lis'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.js +80',b'Please enter Preferred Contact Email',b'Pra\xc5\xa1ome \xc4\xafvesti Pageidautina kontaktin\xc4\xaf elektroninio pa\xc5\xa1to adres\xc4\x85'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxNum',b'CompAuxNum'
+b'DocType: Journal Entry',b'Contra Entry',b'contra \xc4\xafra\xc5\xa1as'
+b'DocType: Journal Entry Account',b'Credit in Company Currency',b'Kredito \xc4\xafmon\xc4\x97je Valiuta'
+b'DocType: Lab Test UOM',b'Lab Test UOM',b'Lab Test UOM'
+b'DocType: Delivery Note',b'Installation Status',b'\xc4\xaerengimas b\xc5\xabsena'
+b'DocType: BOM',b'Quality Inspection Template',b'Kokyb\xc4\x97s tikrinimo \xc5\xa1ablonas'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135',b'Do you want to update attendance?<br>Present: {0}\\\n\t\t\t\t\t<br>Absent: {1}',b'Norite atnaujinti lankomum\xc4\x85? <br> Dovana: {0} \\ <br> N\xc4\x97ra: {1}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +334',b'Accepted + Rejected Qty must be equal to Received quantity for Item {0}',b'Priimamos + Atmesta Kiekis turi b\xc5\xabti lygi Gauta kiekio punktui {0}'
+b'DocType: Request for Quotation',b'RFQ-',b'RFQ-'
+b'DocType: Item',b'Supply Raw Materials for Purchase',b'Tiekimo \xc5\xbdaliavos pirkimas'
+b'DocType: Agriculture Analysis Criteria',b'Fertilizer',b'Tr\xc4\x85\xc5\xa1\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152',b'At least one mode of payment is required for POS invoice.',b'Bent vienas re\xc5\xbeimas mok\xc4\x97jimo reikalingas POS s\xc4\x85skait\xc4\x85.'
+b'DocType: Products Settings',b'Show Products as a List',b'Rodyti produktus s\xc4\x85ra\xc5\xa1e'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +532',b'Item {0} is not active or end of life has been reached',"b'Prek\xc4\x97 {0} n\xc4\x97ra aktyvus, ar buvo pasiektas gyvenimo pabaigos'"
+b'DocType: Student Admission Program',b'Minimum Age',b'Minimalus am\xc5\xbeius'
+b'apps/erpnext/erpnext/utilities/user_progress.py +190',b'Example: Basic Mathematics',b'Pavyzdys: Elementarioji matematika'
+b'DocType: Customer',b'Primary Address',b'Pirminis adresas'
+b'DocType: Production Plan',b'Material Request Detail',b'Med\xc5\xbeiagos u\xc5\xbeklausa i\xc5\xa1samiai'
+b'DocType: Selling Settings',b'Default Quotation Validity Days',b'Numatyt\xc5\xb3 kupon\xc5\xb3 galiojimo dienos'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +800',"b'To include tax in row {0} in Item rate, taxes in rows {1} must also be included'","b'\xc4\xaetraukti mokest\xc4\xaf i\xc5\xa1 eil\xc4\x97s {0} prek\xc4\x97s norma, mokes\xc4\x8diai eilu\xc4\x8di\xc5\xb3 {1}, taip pat turi b\xc5\xabti \xc4\xaftraukti'"
+b'apps/erpnext/erpnext/config/hr.py +223',b'Settings for HR Module',b'Nustatymai HR modulio'
+b'DocType: SMS Center',b'SMS Center',b'SMS centro'
+b'DocType: Sales Invoice',b'Change Amount',b'Pakeisti suma'
+b'DocType: GST Settings',b'Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.',"b'Nustatykite B2C s\xc4\x85skaitos fakt\xc5\xabros vert\xc4\x99. B2CL ir B2CS, apskai\xc4\x8diuotos pagal \xc5\xa1i\xc4\x85 s\xc4\x85skaitos fakt\xc5\xabros vert\xc4\x99.'"
+b'DocType: BOM Update Tool',b'New BOM',b'nauja BOM'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36',b'Show only POS',b'Rodyti tik POS'
+b'DocType: Driver',b'Driving License Categories',b'Vairuotojo pa\xc5\xbeym\xc4\x97jimo kategorijos'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118',b'Please enter Delivery Date',b'\xc4\xaeveskite pristatymo dat\xc4\x85'
+b'DocType: Depreciation Schedule',b'Make Depreciation Entry',b'Padaryti nusid\xc4\x97v\xc4\x97jimo \xc4\xafra\xc5\xa1\xc4\x85'
+b'DocType: Appraisal Template Goal',b'KRA',b'KRA'
+b'DocType: Lead',b'Request Type',b'pra\xc5\xa1ymas tipas'
+b'apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17',b'Make Employee',b'Padaryti Darbuotojas'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14',b'Broadcasting',b'transliavimas'
+b'apps/erpnext/erpnext/config/accounts.py +313',b'Setup mode of POS (Online / Offline)',b'POS nustatymas (internetu / neprisijungus)'
+b'DocType: Manufacturing Settings',b'Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order',b'Neleid\xc5\xbeia kurti laiko \xc5\xbeurnal\xc5\xb3 prie\xc5\xa1 darbo u\xc5\xbesakymus. Operacijos neturi b\xc5\xabti stebimos pagal darbo tvark\xc4\x85'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191',b'Execution',b'vykdymas'
+b'apps/erpnext/erpnext/config/manufacturing.py +62',b'Details of the operations carried out.',b'I\xc5\xa1sami informacija apie atliktas operacijas.'
+b'DocType: Asset Maintenance Log',b'Maintenance Status',b'technin\xc4\x97s prie\xc5\xbei\xc5\xabros b\xc5\xabsen\xc4\x85'
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10',b'Membership Details',b'Naryst\xc4\x97s duomenys'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56',b'{0} {1}: Supplier is required against Payable account {2}',b'{0} {1}: Tiek\xc4\x97jas privalo prie\xc5\xa1 MOK\xc4\x96TINOS s\xc4\x85skait\xc4\x85 {2}'
+b'apps/erpnext/erpnext/config/selling.py +52',b'Items and Pricing',b'Elementus ir kainodara'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2',b'Total hours: {0}',b'I\xc5\xa1 viso valand\xc5\xb3: {0}'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43',b'From Date should be within the Fiscal Year. Assuming From Date = {0}',b'Nuo data tur\xc4\x97t\xc5\xb3 b\xc5\xabti per finansinius metus. Darant prielaid\xc4\x85 I\xc5\xa1 data = {0}'
+b'DocType: Drug Prescription',b'Interval',b'Intervalas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253',b'Preference',b'Pirmenyb\xc4\x97'
+b'DocType: Grant Application',b'Individual',b'individualus'
+b'DocType: Academic Term',b'Academics User',b'akademikai Vartotojas'
+b'DocType: Cheque Print Template',b'Amount In Figure',b'Suma pav'
+b'DocType: Employee Loan Application',b'Loan Info',b'paskolos informacija'
+b'apps/erpnext/erpnext/config/maintenance.py +12',b'Plan for maintenance visits.',b'Planas technin\xc4\x97s prie\xc5\xbei\xc5\xabros apsilankym\xc5\xb3.'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Period',b'Tiek\xc4\x97jo rezultat\xc5\xb3 kortel\xc4\x97s laikotarpis'
+b'DocType: Share Transfer',b'Share Transfer',b'Dalintis pervedimu'
+b'DocType: POS Profile',b'Customer Groups',b'klient\xc5\xb3 Grup\xc4\x97s'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +51',b'Financial Statements',b'Finansin\xc4\x97s ataskaitos'
+b'DocType: Guardian',b'Students',b'studentai'
+b'apps/erpnext/erpnext/config/selling.py +91',b'Rules for applying pricing and discount.',b'Taikymo taisykl\xc4\x97s kainodaros ir nuolaida.'
+b'DocType: Daily Work Summary',b'Daily Work Summary Group',b'Dienos darbo santrauk\xc5\xb3 grup\xc4\x97'
+b'DocType: Physician Schedule',b'Time Slots',b'Laiko lizdai'
+b'apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14',b'Price List must be applicable for Buying or Selling',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as turi b\xc5\xabti taikoma perkant ar parduodant'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79',b'Installation date cannot be before delivery date for Item {0}',b'Montavimo data gali b\xc5\xabti ne anks\xc4\x8diau pristatymo datos punkte {0}'
+b'DocType: Pricing Rule',b'Discount on Price List Rate (%)',b'Nuolaida Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as tarifas (%)'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112',b'Item Template',b'Elemento \xc5\xa1ablonas'
+b'apps/erpnext/erpnext/healthcare/setup.py +215',b'Biochemistry',b'Biochemija'
+b'DocType: Job Offer',b'Select Terms and Conditions',b'Pasirinkite Terminai ir s\xc4\x85lygos'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72',b'Out Value',b'i\xc5\xa1 Vert\xc4\x97'
+b'DocType: Production Plan',b'Sales Orders',b'pardavim\xc5\xb3 u\xc5\xbesakymai'
+b'DocType: Purchase Taxes and Charges',b'Valuation',b'\xc4\xafvertinimas'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +390',b'Set as Default',b'Nustatyti kaip numatyt\xc4\x85j\xc4\x85'
+b'DocType: Production Plan',b'PLN-',b'PLN-'
+,b'Purchase Order Trends',b'Pirkimui u\xc5\xbesakyti tendencijos'
+b'apps/erpnext/erpnext/utilities/user_progress.py +78',b'Go to Customers',b'Eikite \xc4\xaf klientus'
+b'DocType: Hotel Room Reservation',b'Late Checkin',b'V\xc4\x97lyvas registravimas'
+b'apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7',b'The request for quotation can be accessed by clicking on the following link',b'U\xc5\xbe citatos pra\xc5\xa1ymas gali b\xc5\xabti atvertas paspaud\xc4\x99 \xc5\xa1i\xc4\x85 nuorod\xc4\x85'
+b'apps/erpnext/erpnext/config/hr.py +81',b'Allocate leaves for the year.',b'Skirti lapai per metus.'
+b'DocType: SG Creation Tool Course',b'SG Creation Tool Course',b'SG k\xc5\xabrimo \xc4\xafrankis kursai'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275',b'Insufficient Stock',b'nepakankamas sand\xc4\x97lyje'
+b'DocType: Manufacturing Settings',b'Disable Capacity Planning and Time Tracking',b'I\xc5\xa1jungti paj\xc4\x97gum\xc5\xb3 planavimas ir laiko sekimo'
+b'DocType: Email Digest',b'New Sales Orders',b'Nauj\xc5\xb3 pardavimo u\xc5\xbesakymus'
+b'DocType: Bank Guarantee',b'Bank Account',b'Banko s\xc4\x85skaita'
+b'DocType: Leave Type',b'Allow Negative Balance',b'Leiskite neigiamas balansas'
+b'apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13',"b""You cannot delete Project Type 'External'""",b'Negalite i\xc5\xa1trinti projekto tipo &quot;I\xc5\xa1orinis&quot;'
+b'DocType: Employee',b'Create User',b'Sukurti vartotoj\xc4\x85'
+b'DocType: Selling Settings',b'Default Territory',b'numatytasis teritorija'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53',b'Television',b'televizija'
+b'DocType: Work Order Operation',"b""Updated via 'Time Log'""",b'Atnaujinta per &quot;Time Prisijungti&quot;'
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +430',b'Advance amount cannot be greater than {0} {1}',b'Avanso suma gali b\xc5\xabti ne didesn\xc4\x97 kaip {0} {1}'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalCode',b'\xc5\xbdurnalo kodas'
+b'DocType: Naming Series',b'Series List for this Transaction',b'Serija s\xc4\x85ra\xc5\xa1as \xc5\xa1io sandorio'
+b'DocType: Company',b'Enable Perpetual Inventory',b'\xc4\xaejungti nuolatinio inventorizavimo'
+b'DocType: Company',b'Default Payroll Payable Account',b'Numatytasis darbo u\xc5\xbemokes\xc4\x8dio mokamas paskyra'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51',b'Update Email Group',b'Atnaujinti pa\xc5\xa1tas grup\xc4\x97'
+b'DocType: Sales Invoice',b'Is Opening Entry',b'Ar atidarymas \xc4\xafra\xc5\xa1\xc4\x85'
+b'DocType: Lab Test Template',"b'If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. '","b'Jei nepa\xc5\xbeym\xc4\x97ta, prek\xc4\x97 bus ne\xc4\xaftraukta \xc4\xaf pardavimo s\xc4\x85skait\xc4\x85, bet gali b\xc5\xabti naudojama grup\xc4\x97s bandym\xc5\xb3 k\xc5\xabrimui.'"
+b'DocType: Customer Group',b'Mention if non-standard receivable account applicable',"b'Nurodyk, jei nestandartinis gautinos s\xc4\x85skaitos taikoma'"
+b'DocType: Course Schedule',b'Instructor Name',b'instruktorius Vardas'
+b'DocType: Supplier Scorecard',b'Criteria Setup',b'Kriterij\xc5\xb3 nustatymas'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206',b'For Warehouse is required before Submit',b'Sand\xc4\x97liavimo reikalingas prie\xc5\xa1 Pateikti'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8',b'Received On',b'gautas'
+b'DocType: Sales Partner',b'Reseller',b'perpardavin\xc4\x97jimo'
+b'DocType: Codification Table',b'Medical Code',b'Medicinos kodeksas'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20',b'Please enter Company',b'Pra\xc5\xa1ome \xc4\xafvesti \xc4\xaemon\xc4\x97s'
+b'DocType: Delivery Note Item',b'Against Sales Invoice Item',b'Prie\xc5\xa1 Pardavim\xc5\xb3 s\xc4\x85skaitos punktas'
+b'DocType: Agriculture Analysis Criteria',b'Linked Doctype',b'Susietas &quot;Doctype&quot;'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44',b'Net Cash from Financing',b'Grynieji pinig\xc5\xb3 srautai i\xc5\xa1 finansavimo'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2375',"b'LocalStorage is full , did not save'","b'LocalStorage &quot;yra pilna, nei\xc5\xa1saugojo'"
+b'DocType: Lead',b'Address & Contact',b'Adresas ir kontaktai'
+b'DocType: Leave Allocation',b'Add unused leaves from previous allocations',b'Prid\xc4\x97ti nepanaudotas lapus i\xc5\xa1 ankstesni\xc5\xb3 paskirstym\xc5\xb3'
+b'DocType: Sales Partner',b'Partner website',b'partnerio svetain\xc4\x97'
+b'DocType: Restaurant Order Entry',b'Add Item',b'Prid\xc4\x97ti Prek\xc4\x99'
+b'DocType: Lab Test',b'Custom Result',b'Tinkintas rezultatas'
+b'DocType: Delivery Stop',b'Contact Name',b'Kontaktinis vardas'
+b'DocType: Course Assessment Criteria',b'Course Assessment Criteria',b'\xc5\xbdinoma vertinimo kriterijai'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18',b'Tax Id: ',b'Mokes\xc4\x8di\xc5\xb3 ID:'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216',b'Student ID: ',b'Studento pa\xc5\xbeym\xc4\x97jimas:'
+b'DocType: POS Customer Group',b'POS Customer Group',b'POS Klient\xc5\xb3 grup\xc4\x97'
+b'DocType: Land Unit',b'Land Unit describing various land assets',"b'\xc5\xbdem\xc4\x97s skyrius, kuriame apra\xc5\xa1omas \xc4\xafvairias \xc5\xbeem\xc4\x97s turtas'"
+b'DocType: Cheque Print Template',b'Line spacing for amount in words',b'Tarpai tarp eilu\xc4\x8di\xc5\xb3 ir suma \xc5\xbeod\xc5\xbeiais'
+b'DocType: Vehicle',b'Additional Details',b'Papildoma informacija'
+b'apps/erpnext/erpnext/templates/generators/bom.html +85',b'No description given',b'N\xc4\x97ra apra\xc5\xa1ymo suteikta'
+b'apps/erpnext/erpnext/config/buying.py +13',b'Request for purchase.',b'U\xc5\xbesisakyti \xc4\xafsigyti.'
+b'DocType: Lab Test',b'Submitted Date',b'Pateiktas data'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6',b'This is based on the Time Sheets created against this project',"b'Tai grind\xc5\xbeiama darbo laiko apskaitos \xc5\xbeiniara\xc5\xa1\xc4\x8diai, sukurt\xc5\xb3 prie\xc5\xa1 \xc5\xa1\xc4\xaf projekt\xc4\x85'"
+,b'Open Work Orders',b'Atidaryti darbo u\xc5\xbesakymus'
+b'DocType: Payment Term',b'Credit Months',b'Kredito m\xc4\x97nesiai'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409',b'Net Pay cannot be less than 0',b'Neto darbo u\xc5\xbemokestis negali b\xc5\xabti ma\xc5\xbeesnis u\xc5\xbe 0'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',"b'To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription'","b'Nor\xc4\x97dami sustabdyti pakartotini\xc5\xb3 klaid\xc5\xb3 prane\xc5\xa1im\xc5\xb3 siuntim\xc4\x85 i\xc5\xa1 sistemos, prenumeruojame lauk\xc4\x85 &quot;I\xc5\xa1jungta&quot;'"
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +121',b'Relieving Date must be greater than Date of Joining',b'Mal\xc5\xa1inan\xc4\x8di\xc5\xb3 data turi b\xc5\xabti didesnis nei \xc4\xafstoti data'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240',b'Leaves per Year',b'Lapai per metus'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130',"b""Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.""","b'Eilut\xc4\x97s {0}: Pra\xc5\xa1ome patikrinti &quot;yra i\xc5\xa1 anksto&quot; prie\xc5\xa1 paskyra {1}, jei tai yra i\xc5\xa1ankstinis \xc4\xafra\xc5\xa1as.'"
+b'apps/erpnext/erpnext/stock/utils.py +219',b'Warehouse {0} does not belong to company {1}',b'Sand\xc4\x97li\xc5\xb3 {0} nepriklauso bendrovei {1}'
+b'DocType: Email Digest',b'Profit & Loss',b'Pelnas ir nuostoliai'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Litre',b'litr\xc5\xb3'
+b'DocType: Task',b'Total Costing Amount (via Time Sheet)',b'I\xc5\xa1 viso S\xc4\x85naud\xc5\xb3 suma (per Time lapas)'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76',b'Please setup Students under Student Groups',b'Nustatykite studentus pagal student\xc5\xb3 grupes'
+b'DocType: Item Website Specification',b'Item Website Specification',b'Prek\xc4\x97 svetain\xc4\x97 Specifikacija'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449',b'Leave Blocked',b'Palikite U\xc5\xbeblokuoti'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +740',b'Item {0} has reached its end of life on {1}',b'Prek\xc4\x97s {0} galiojimas pasibaig\xc4\x97 {1}'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83',b'Bank Entries',b'Banko \xc4\xafra\xc5\xa1ai'
+b'DocType: Crop',b'Annual',b'metinis'
+b'DocType: Stock Reconciliation Item',b'Stock Reconciliation Item',b'Akcij\xc5\xb3 Susitaikymas punktas'
+b'DocType: Stock Entry',b'Sales Invoice No',b'Pardavim\xc5\xb3 s\xc4\x85skaita fakt\xc5\xabra n\xc4\x97ra'
+b'DocType: Material Request Item',b'Min Order Qty',b'Min U\xc5\xbesakomas kiekis'
+b'DocType: Student Group Creation Tool Course',b'Student Group Creation Tool Course',b'Student\xc5\xb3 grup\xc4\x97 k\xc5\xabrimo \xc4\xafrankis kursai'
+b'DocType: Lead',b'Do Not Contact',b'N\xc4\x97ra jokio tikslo susisiekti'
+b'apps/erpnext/erpnext/utilities/user_progress.py +210',b'People who teach at your organisation',"b'\xc5\xbdmon\xc4\x97s, kurie mokyti savo organizacij\xc4\x85'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135',b'Software Developer',b'Programin\xc4\x97s \xc4\xafrangos k\xc5\xabr\xc4\x97jas'
+b'DocType: Item',b'Minimum Order Qty',b'Ma\xc5\xbeiausias u\xc5\xbesakymo Kiekis'
+b'DocType: Pricing Rule',b'Supplier Type',b'tiek\xc4\x97jas tipas'
+b'DocType: Course Scheduling Tool',b'Course Start Date',b'\xc5\xbdinoma prad\xc5\xbeios data'
+,b'Student Batch-Wise Attendance',b'Student\xc5\xb3 Serija-I\xc5\xa1min\xc4\x8dius Lankomumas'
+b'DocType: POS Profile',b'Allow user to edit Rate',b'Leisti vartotojui redaguoti Balsuok'
+b'DocType: Item',b'Publish in Hub',b'Skelbia Hub'
+b'DocType: Student Admission',b'Student Admission',b'Student\xc5\xb3 Pri\xc4\x97mimas'
+,b'Terretory',b'Terretory'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +762',b'Item {0} is cancelled',b'Prek\xc4\x97 {0} at\xc5\xa1aukiamas'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064',b'Material Request',b'med\xc5\xbeiaga Pra\xc5\xa1ymas'
+b'DocType: Bank Reconciliation',b'Update Clearance Date',b'Atnaujinti S\xc4\x85skait\xc5\xb3 data'
+,b'GSTR-2',b'GSTR-2'
+b'DocType: Item',b'Purchase Details',b'pirkimo informacija'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407',"b""Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}""",b'Prek\xc4\x97 {0} nerastas &quot;In \xc5\xbealiavos&quot; stalo U\xc5\xbesakymo {1}'
+b'DocType: Salary Slip',b'Total Principal Amount',b'Visa pagrindin\xc4\x97 suma'
+b'DocType: Student Guardian',b'Relation',b'santykis'
+b'DocType: Student Guardian',b'Mother',b'Motina'
+b'DocType: Restaurant Reservation',b'Reservation End Time',b'Rezervacijos pabaiga'
+b'DocType: Crop',b'Biennial',b'Bienal\xc4\x97'
+b'apps/erpnext/erpnext/config/selling.py +18',b'Confirmed orders from Customers.',b'Patvirtinti u\xc5\xbesakymus i\xc5\xa1 klient\xc5\xb3.'
+b'DocType: Purchase Receipt Item',b'Rejected Quantity',b'atmesta Kiekis'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.py +80',b'Payment request {0} created',b'Mokes\xc4\x8dio u\xc5\xbeklausa {0} sukurta'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Open Orders',b'Atvirieji u\xc5\xbesakymai'
+b'apps/erpnext/erpnext/healthcare/setup.py +255',b'Low Sensitivity',b'\xc5\xbdemas jautrumas'
+b'DocType: Notification Control',b'Notification Control',b'prane\xc5\xa1imas Valdymo'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +17',b'Please confirm once you have completed your training',"b'Patvirtinkite, kai baigsite savo mokym\xc4\x85'"
+b'DocType: Lead',b'Suggestions',b'Pasi\xc5\xablymai'
+b'DocType: Territory',b'Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.',b'Rinkinio prek\xc4\x97 Grup\xc4\x97 i\xc5\xa1mintingas biud\xc5\xbeetai \xc5\xa1ioje teritorijoje. Taip pat galite \xc4\xaftraukti sezoni\xc5\xa1kum\xc4\x85 nustatant platinimas.'
+b'DocType: Payment Term',b'Payment Term Name',b'Mok\xc4\x97jimo terminas Vardas'
+b'DocType: Healthcare Settings',b'Create documents for sample collection',b'Sukurkite dokumentus pavyzd\xc5\xbei\xc5\xb3 rinkimui'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276',b'Payment against {0} {1} cannot be greater than Outstanding Amount {2}',b'Mok\xc4\x97jimo prie\xc5\xa1 {0} {1} negali b\xc5\xabti didesnis nei nesumok\xc4\x97tos sumos {2}'
+b'DocType: Shareholder',b'Address HTML',b'adresas HTML'
+b'DocType: Lead',b'Mobile No.',b'Mobilus Ne'
+b'DocType: Maintenance Schedule',b'Generate Schedule',b'Sukurti Tvarkara\xc5\xa1tis'
+b'DocType: Purchase Invoice Item',b'Expense Head',b'Kompensuojamos vadovas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138',b'Please select Charge Type first',b'Pra\xc5\xa1ome pasirinkti mokes\xc4\x8di\xc5\xb3 r\xc5\xab\xc5\xa1is pirm\xc4\x85 kart\xc4\x85'
+b'DocType: Crop',"b'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.. '","b'\xc4\x8cia galite apibr\xc4\x97\xc5\xbeti visas u\xc5\xbeduotis, kuri\xc5\xb3 reikia atlikti \xc5\xa1iam pas\xc4\x97liui. Dienos laukas naudojamas pamin\xc4\x97ti t\xc4\x85 dien\xc4\x85, kuri\xc4\x85 reikia atlikti u\xc5\xbeduot\xc4\xaf, 1 yra 1 diena ir kt.'"
+b'DocType: Student Group Student',b'Student Group Student',b'Student\xc5\xb3 grup\xc4\x97 student\xc4\x97'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Latest',b'paskutinis'
+b'DocType: Asset Maintenance Task',b'2 Yearly',b'2 metai'
+b'DocType: Education Settings',b'Education Settings',b'\xc5\xa0vietimo nustatymai'
+b'DocType: Vehicle Service',b'Inspection',b'Ap\xc5\xbei\xc5\xabra'
+b'DocType: Supplier Scorecard Scoring Standing',b'Max Grade',b'Maksimalus \xc4\xafvertinimas'
+b'DocType: Email Digest',b'New Quotations',b'Nauja citatos'
+b'DocType: HR Settings',b'Emails salary slip to employee based on preferred email selected in Employee',b'Para\xc5\xa1yta darbo u\xc5\xbemokest\xc4\xaf \xc4\xaf darbuotojo remiantis pageidaujam\xc4\x85 pa\xc5\xa1tu pasirinkto darbuotojo'
+b'DocType: Employee',b'The first Leave Approver in the list will be set as the default Leave Approver',b'Pirmasis atostogos Tvirtintojas s\xc4\x85ra\xc5\xa1e bus nustatytas kaip numatytasis Palikite j\xc4\xaf patvirtinusio'
+b'DocType: Tax Rule',b'Shipping County',b'Pristatymas apskritis'
+b'apps/erpnext/erpnext/config/desktop.py +167',b'Learn',b'Mokytis'
+b'DocType: Asset',b'Next Depreciation Date',b'Kitas Nusid\xc4\x97v\xc4\x97jimas data'
+b'apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3',b'Activity Cost per Employee',b'Veiklos s\xc4\x85naudos vienam darbuotojui'
+b'DocType: Accounts Settings',b'Settings for Accounts',b'Nustatymai s\xc4\x85skait\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673',b'Supplier Invoice No exists in Purchase Invoice {0}',b'Tiek\xc4\x97jas s\xc4\x85skaitoje Nr egzistuoja pirkimo s\xc4\x85skaitoje fakt\xc5\xabroje {0}'
+b'apps/erpnext/erpnext/config/selling.py +118',b'Manage Sales Person Tree.',b'Valdyti pardavimo asmuo med\xc4\xaf.'
+b'DocType: Job Applicant',b'Cover Letter',b'lydra\xc5\xa1tis'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37',b'Outstanding Cheques and Deposits to clear',b'Ne\xc4\xafvykdyti \xc4\x8dekiai ir u\xc5\xbestatai ir i\xc5\xa1valyti'
+b'DocType: Item',b'Synced With Hub',b'Sinchronizuojami su Hub'
+b'DocType: Driver',b'Fleet Manager',b'laivyno direktorius'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542',b'Row #{0}: {1} can not be negative for item {2}',b'Eilut\xc4\x97 # {0}: {1} negali b\xc5\xabti neigiamas u\xc5\xbe prek\xc4\x99 {2}'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59',b'Wrong Password',b'Neteisingas slapta\xc5\xbeodis'
+b'DocType: Item',b'Variant Of',b'variantas'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406',"b""Completed Qty can not be greater than 'Qty to Manufacture'""",b'U\xc5\xbebaigtas Kiekis negali b\xc5\xabti didesnis nei &quot;Kiekis iki Gamyba&quot;'
+b'DocType: Period Closing Voucher',b'Closing Account Head',b'U\xc5\xbedarymo s\xc4\x85skaita vadovas'
+b'DocType: Employee',b'External Work History',b'I\xc5\xa1orinis darbo istorij\xc4\x85'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +111',b'Circular Reference Error',b'Ciklin\xc4\x99 nuorod\xc4\x85 Klaida'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206',b'Student Report Card',b'Student\xc5\xb3 kortel\xc4\x97s ataskaita'
+b'DocType: Appointment Type',b'Is Inpatient',b'Yra stacionarus'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55',b'Guardian1 Name',b'Guardian1 Vardas'
+b'DocType: Delivery Note',b'In Words (Export) will be visible once you save the Delivery Note.',"b'\xc5\xbdod\xc5\xbeiais (eksportas) bus matomas, kai j\xc5\xabs i\xc5\xa1gelb\xc4\x97ti va\xc5\xbetara\xc5\xa1tyje.'"
+b'DocType: Cheque Print Template',b'Distance from left edge',b'Atstumas nuo kairiojo kra\xc5\xa1to'
+b'apps/erpnext/erpnext/utilities/bot.py +29',b'{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2})',b'{0} vienetai [{1}] (# forma / vnt / {1}) rasta [{2}] (# forma / sand\xc4\x97liavimo / {2})'
+b'DocType: Lead',b'Industry',b'Industrija'
+b'DocType: Employee',b'Job Profile',b'darbo profilis'
+b'DocType: BOM Item',b'Rate & Amount',b'\xc4\xaevertinti ir sum\xc4\x85'
+b'apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6',b'This is based on transactions against this Company. See timeline below for details',b'Tai grind\xc5\xbeiama sandoriais prie\xc5\xa1 \xc5\xa1i\xc4\x85 bendrov\xc4\x99. \xc5\xbdi\xc5\xabr\xc4\x97kite \xc5\xbeemiau pateikt\xc4\x85 laiko juost\xc4\x85'
+b'DocType: Stock Settings',b'Notify by Email on creation of automatic Material Request',b'Prane\xc5\xa1kite elektroniniu pa\xc5\xa1tu steigti automatinio Med\xc5\xbeiaga U\xc5\xbesisakyti'
+b'apps/erpnext/erpnext/healthcare/setup.py +259',b'Resistant',b'Atsparus'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77',b'Please set Hotel Room Rate on {}',b'Pra\xc5\xa1ome nustatyti vie\xc5\xa1bu\xc4\x8dio kambario kain\xc4\x85 u\xc5\xbe ()'
+b'DocType: Journal Entry',b'Multi Currency',b'Daugiafunkciniai Valiuta'
+b'DocType: Opening Invoice Creation Tool',b'Invoice Type',b'S\xc4\x85skaitos fakt\xc5\xabros tipas'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939',b'Delivery Note',b'Va\xc5\xbetara\xc5\xa1tis'
+b'DocType: Consultation',b'Encounter Impression',b'Susiduria su \xc4\xafsp\xc5\xabd\xc5\xbeiais'
+b'apps/erpnext/erpnext/config/learn.py +82',b'Setting up Taxes',b'\xc4\xaesteigti Mokes\xc4\x8diai'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134',b'Cost of Sold Asset',b'Kaina Parduota turto'
+b'DocType: Volunteer',b'Morning',b'Rytas'
+b'apps/erpnext/erpnext/accounts/utils.py +350',b'Payment Entry has been modified after you pulled it. Please pull it again.',"b'Mok\xc4\x97jimo \xc4\xaera\xc5\xa1as buvo pakeistas po to, kai i\xc5\xa1trauk\xc4\x97 j\xc4\x85. Pra\xc5\xa1ome traukti j\xc4\xaf dar kart\xc4\x85.'"
+b'DocType: Program Enrollment Tool',b'New Student Batch',b'Naujoji student\xc5\xb3 partija'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +479',b'{0} entered twice in Item Tax',b'{0} \xc4\xafvestas du kartus Prek\xc4\x97s mokes\xc4\x8dio'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113',b'Summary for this week and pending activities',b'Santrauka \xc5\xa1i\xc4\x85 savait\xc4\x99 ir laukiant veikla'
+b'DocType: Student Applicant',b'Admitted',b'pripa\xc5\xbeino'
+b'DocType: Workstation',b'Rent Cost',b'nuomos kaina'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81',b'Amount After Depreciation',b'Suma po nusid\xc4\x97v\xc4\x97jimo'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97',b'Upcoming Calendar Events',b'Artimiausi Kalendoriaus \xc4\xafvykiai'
+b'apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1',b'Variant Attributes',b'Varianto atributai'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85',b'Please select month and year',b'Pra\xc5\xa1ome pasirinkti m\xc4\x97nes\xc4\xaf ir metus'
+b'DocType: Employee',b'Company Email',b'\xc4\xaemon\xc4\x97s pa\xc5\xa1tas'
+b'DocType: GL Entry',b'Debit Amount in Account Currency',b'Debeto Suma s\xc4\x85skaitos valiuta'
+b'DocType: Supplier Scorecard',b'Scoring Standings',b'Ta\xc5\xa1k\xc5\xb3 skai\xc4\x8diavimas'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'U\xc5\xbesakyti Vert\xc4\x97'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'U\xc5\xbesakyti Vert\xc4\x97'
+b'apps/erpnext/erpnext/config/accounts.py +27',b'Bank/Cash transactions against party or for internal transfer',b'Bankas / Gryn\xc5\xb3j\xc5\xb3 pinig\xc5\xb3 operacijos nuo \xc5\xa1alies arba d\xc4\x97l vidinio pervedimo'
+b'DocType: Shipping Rule',b'Valid for Countries',b'Galioja \xc5\xa1ali\xc5\xb3'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +55',"b""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""",b'\xc5\xa0is punktas yra \xc5\xa1ablon\xc5\xb3 ir negali b\xc5\xabti naudojamas sandoriams. Elemento atributai bus nukopijuoti \xc4\xaf variantai nebent &quot;Ne Kopijuoti&quot; yra nustatytas'
+b'DocType: Grant Application',b'Grant Application',b'Parai\xc5\xa1kos dotacija'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69',b'Total Order Considered',b'Viso U\xc5\xbesakyti Laikomas'
+b'apps/erpnext/erpnext/config/hr.py +243',"b'Employee designation (e.g. CEO, Director etc.).'","b'Darbuotoj\xc5\xb3 \xc5\xbeym\xc4\x97jimas (pvz Vadovas, direktorius ir tt).'"
+b'DocType: Sales Invoice',"b""Rate at which Customer Currency is converted to customer's base currency""","b'Norma, pagal kuri\xc4\x85 Klientas valiuta konvertuojama \xc4\xaf kliento bazine valiuta'"
+b'DocType: Course Scheduling Tool',b'Course Scheduling Tool',b'\xc5\xbdinoma planavimas \xc4\xafranki\xc5\xb3'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +623',b'Row #{0}: Purchase Invoice cannot be made against an existing asset {1}',b'Eilut\xc4\x97s # {0}: Pirkimo s\xc4\x85skaita fakt\xc5\xabra negali b\xc5\xabti pareik\xc5\xa1tas esamo turto {1}'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257',b'[Urgent] Error while creating recurring %s for %s',b'[Skubu] Klaida kuriant pasikartoja %s %s'
+b'DocType: Land Unit',b'LInked Analysis',b'\xc4\xaetraukta analiz\xc4\x97'
+b'DocType: Item Tax',b'Tax Rate',b'Mokes\xc4\x8dio tarifas'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73',b'Application period cannot be across two allocation records',b'Parai\xc5\xa1k\xc5\xb3 teikimo laikotarpis negali b\xc5\xabti per du paskirstymo \xc4\xafra\xc5\xa1us'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59',b'{0} already allocated for Employee {1} for period {2} to {3}',b'{0} jau skirta darbuotojo {1} laikotarpiui {2} \xc4\xaf {3}'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141',b'Purchase Invoice {0} is already submitted',b'Pirkimo s\xc4\x85skaita fakt\xc5\xabra {0} jau pateiktas'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92',b'Row # {0}: Batch No must be same as {1} {2}',"b'Eilut\xc4\x97s # {0}: Serijos Nr turi b\xc5\xabti toks pat, kaip {1} {2}'"
+b'DocType: Material Request Plan Item',b'Material Request Plan Item',b'Materialinio pra\xc5\xa1ymo plano punktas'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52',b'Convert to non-Group',b'Konvertuoti \xc4\xaf ne grup\xc4\x97s'
+b'DocType: Project Update',b'Good/Steady',b'Geras / pastovus'
+b'DocType: C-Form Invoice Detail',b'Invoice Date',b'S\xc4\x85skaitos data'
+b'DocType: GL Entry',b'Debit Amount',b'debeto suma'
+b'apps/erpnext/erpnext/accounts/party.py +248',b'There can only be 1 Account per Company in {0} {1}',b'Gali b\xc5\xabti tik 1 s\xc4\x85skaita u\xc5\xbe Bendrov\xc4\x97s {0} {1}'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426',b'Please see attachment',b'\xc5\xbdi\xc5\xabr\xc4\x97kite pried\xc4\x85'
+b'DocType: Purchase Order',b'% Received',b'% Gavo'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3',b'Create Student Groups',b'Sukurti student\xc5\xb3 grupi\xc5\xb3'
+b'DocType: Volunteer',b'Weekends',b'Savaitgaliai'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Credit Note Amount',b'Kredito Pastaba suma'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187',b'{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3}',b'{0} ({1}) negali b\xc5\xabti didesnis u\xc5\xbe numatyt\xc4\x85 kiekybin\xc4\x99 ({2}) darbo tvarkoje {3}'
+b'DocType: Setup Progress Action',b'Action Document',b'Veiksm\xc5\xb3 dokumentas'
+b'DocType: Chapter Member',b'Website URL',b'Svetain\xc4\x97s URL'
+,b'Finished Goods',b'gatav\xc5\xb3 preki\xc5\xb3'
+b'DocType: Delivery Note',b'Instructions',b'instrukcijos'
+b'DocType: Quality Inspection',b'Inspected By',b'tikrina'
+b'DocType: Asset Maintenance Log',b'Maintenance Type',b'prie\xc5\xbei\xc5\xabra tipas'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45',b'{0} - {1} is not enrolled in the Course {2}',b'{0} - {1} n\xc4\x97ra \xc4\xaftraukti \xc4\xaf eig\xc4\x85 {2}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225',b'Student Name: ',b'Studento vardas:'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59',b'Serial No {0} does not belong to Delivery Note {1}',b'Serijos Nr {0} nepriklauso va\xc5\xbetara\xc5\xa1tyje {1}'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97',"b""There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.""","b'Atrodo, kad yra problema d\xc4\x97l serverio &quot;GoCardless&quot; konfig\xc5\xabracijos. Nesijaudinkite, nes\xc4\x97km\xc4\x97s atveju suma bus gr\xc4\x85\xc5\xbeinta \xc4\xaf j\xc5\xabs\xc5\xb3 s\xc4\x85skait\xc4\x85.'"
+b'apps/erpnext/erpnext/templates/pages/demo.html +47',b'ERPNext Demo',b'ERPNext demo'
+b'apps/erpnext/erpnext/public/js/utils/item_selector.js +20',b'Add Items',b'Prid\xc4\x97ti prek\xc4\x99'
+b'DocType: Item Quality Inspection Parameter',b'Item Quality Inspection Parameter',b'Prek\xc4\x97 kokyb\xc4\x97s inspekcija Parametras'
+b'DocType: Depreciation Schedule',b'Schedule Date',b'Tvarkara\xc5\xa1tis data'
+b'apps/erpnext/erpnext/config/hr.py +116',"b'Earnings, Deductions and other Salary components'","b'Darbo u\xc5\xbemokestis, atskaitymai ir kito atlyginimo dalys'"
+b'DocType: Packed Item',b'Packed Item',b'supakuotas punktas'
+b'DocType: Job Offer Term',b'Job Offer Term',b'Darbo pasi\xc5\xablymo terminas'
+b'apps/erpnext/erpnext/config/buying.py +65',b'Default settings for buying transactions.',b'Numatytieji nustatymai pirkti sandorius.'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29',b'Activity Cost exists for Employee {0} against Activity Type - {1}',b'Veiklos s\xc4\x85naudos egzistuoja darbuotojo {0} prie\xc5\xa1 Veiklos r\xc5\xab\xc5\xa1is - {1}'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Privalomas laukas - Gauk Studentai i\xc5\xa1'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Privalomas laukas - Gauk Studentai i\xc5\xa1'
+b'DocType: Program Enrollment',b'Enrolled courses',b'studijuojantys kursai'
+b'DocType: Program Enrollment',b'Enrolled courses',b'studijuojantys kursai'
+b'DocType: Currency Exchange',b'Currency Exchange',b'Valiutos keitykla'
+b'DocType: Opening Invoice Creation Tool Item',b'Item Name',b'Daikto pavadinimas'
+b'DocType: Authorization Rule',b'Approving User  (above authorized value)',b'Patvirtinimo vartotoj\xc4\x85 (vir\xc5\xa1 \xc4\xafgalioto vert\xc4\x97s)'
+b'DocType: Email Digest',b'Credit Balance',b'Kredito balansas'
+b'DocType: Employee',b'Widowed',b'likusi na\xc5\xa1le'
+b'DocType: Request for Quotation',b'Request for Quotation',b'U\xc5\xbeklausimas'
+b'DocType: Healthcare Settings',b'Require Lab Test Approval',b'Reikalauti gero bandymo patvirtinimo'
+b'DocType: Salary Slip Timesheet',b'Working Hours',b'Darbo valandos'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59',b'Total Outstanding',b'Viso ne\xc4\xafvykdyti'
+b'DocType: Naming Series',b'Change the starting / current sequence number of an existing series.',b'Pakeisti pradin\xc4\xaf / trumpalaikiai eil\xc4\x97s numer\xc4\xaf esamo serijos.'
+b'DocType: Dosage Strength',b'Strength',b'J\xc4\x97ga'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1534',b'Create a new Customer',b'Sukurti nauj\xc4\x85 klient\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59',"b'If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.'","b'Jei ir toliau vyrauja daug kainodaros taisykl\xc4\x97s, vartotojai, pra\xc5\xa1oma, kad prioritetas rankiniu b\xc5\xabdu i\xc5\xa1spr\xc4\x99sti konflikt\xc4\x85.'"
+b'apps/erpnext/erpnext/utilities/activation.py +90',b'Create Purchase Orders',b'Sukurti Pirkim\xc5\xb3 u\xc5\xbesakymus'
+,b'Purchase Register',b'pirkimo Registruotis'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116',b'Patient not found',b'Pacientas nerastas'
+b'DocType: Scheduling Tool',b'Rechedule',b'Rechedule'
+b'DocType: Landed Cost Item',b'Applicable Charges',b'Taikomi Mokes\xc4\x8diai'
+b'DocType: Workstation',b'Consumable Cost',b'vartojimo kaina'
+b'DocType: Purchase Receipt',b'Vehicle Date',b'Automobilio data'
+b'DocType: Student Log',b'Medical',b'medicinos'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175',b'Reason for losing',"b'Prie\xc5\xbeastis, d\xc4\x97l kurios praranda'"
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +52',b'Update Account Number',b'Atnaujinti s\xc4\x85skaitos numer\xc4\xaf'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +44',b'Lead Owner cannot be same as the Lead',"b'\xc5\xa0vinas savininkas gali b\xc5\xabti toks pat, kaip pirmaujan\xc4\x8dios'"
+b'apps/erpnext/erpnext/accounts/utils.py +356',b'Allocated amount can not greater than unadjusted amount',b'Paskirti suma gali ne didesnis nei originalios suma'
+b'DocType: Announcement',b'Receiver',b'imtuvas'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83',b'Workstation is closed on the following dates as per Holiday List: {0}',"b'Kompiuterizuotos darbo vietos yra u\xc5\xbedarytas \xc5\xa1i\xc5\xb3 dat\xc5\xb3, kaip u\xc5\xbe Atostog\xc5\xb3 s\xc4\x85ra\xc5\xa1as: {0}'"
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32',b'Opportunities',b'galimyb\xc4\x97s'
+b'DocType: Lab Test Template',b'Single',b'vienas'
+b'DocType: Salary Slip',b'Total Loan Repayment',b'Viso paskol\xc5\xb3 gr\xc4\x85\xc5\xbeinimas'
+b'DocType: Account',b'Cost of Goods Sold',b'Parduot\xc5\xb3 preki\xc5\xb3 kaina'
+b'DocType: Subscription',b'Yearly',b'kasmet'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230',b'Please enter Cost Center',b'Pra\xc5\xa1ome \xc4\xafvesti s\xc4\x85naud\xc5\xb3 centro'
+b'DocType: Drug Prescription',b'Dosage',b'Dozavimas'
+b'DocType: Journal Entry Account',b'Sales Order',b'Pardavimo u\xc5\xbesakymas'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69',b'Avg. Selling Rate',b'Vid. pardavimo kaina'
+b'DocType: Assessment Plan',b'Examiner Name',b'Eksperto vardas'
+b'DocType: Lab Test Template',b'No Result',b'N\xc4\x97ra rezultatas'
+b'DocType: Purchase Invoice Item',b'Quantity and Rate',b'Kiekis ir Balsuok'
+b'DocType: Delivery Note',b'% Installed',b'% \xc4\xaediegta'
+b'apps/erpnext/erpnext/utilities/user_progress.py +230',b'Classrooms/ Laboratories etc where lectures can be scheduled.',"b'Kabinetai / Laboratorijos tt, kai paskaitos gali b\xc5\xabti planuojama.'"
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46',b'Please enter company name first',b'Pra\xc5\xa1ome \xc4\xafvesti \xc4\xafmon\xc4\x97s pavadinim\xc4\x85 pirmoji'
+b'DocType: Purchase Invoice',b'Supplier Name',b'tiek\xc4\x97jas Vardas'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25',b'Read the ERPNext Manual',b'Skaityti ERPNext vadovas'
+b'DocType: Purchase Invoice',b'01-Sales Return',b'01-Pardavim\xc5\xb3 gr\xc4\x85\xc5\xbea'
+b'DocType: Account',b'Is Group',b'yra grup\xc4\x97'
+b'DocType: Email Digest',b'Pending Purchase Orders',b'Kol Pirkim\xc5\xb3 u\xc5\xbesakymus'
+b'DocType: Stock Settings',b'Automatically Set Serial Nos based on FIFO',b'Automati\xc5\xa1kai Eil\xc4\x97s Nr remiantis FIFO'
+b'DocType: Accounts Settings',b'Check Supplier Invoice Number Uniqueness',b'Patikrinkite Tiek\xc4\x97jas s\xc4\x85skaitos fakt\xc5\xabros numeris Unikalumas'
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34',b'Primary Address Details',b'Pagrindinio adreso duomenys'
+b'DocType: Vehicle Service',b'Oil Change',b'Tepal\xc5\xb3 keitimas'
+b'DocType: Asset Maintenance Log',b'Asset Maintenance Log',b'Turto prie\xc5\xbei\xc5\xabros \xc5\xbeurnalas'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57',"b""'To Case No.' cannot be less than 'From Case No.'""","b'""Iki bylos Nr. \' negali b\xc5\xabti ma\xc5\xbeesnis, nei ""Nuo bylos Nr. \''"
+b'DocType: Chapter',b'Non Profit',b'nepelno'
+b'DocType: Production Plan',b'Not Started',b'Neprad\xc4\x97jau'
+b'DocType: Lead',b'Channel Partner',b'kanalo Partneriai'
+b'DocType: Account',b'Old Parent',b'Senas T\xc4\x97v\xc5\xb3'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Privalomas laukas - akademiniai metai'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Privalomas laukas - akademiniai metai'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220',b'{0} {1} is not associated with {2} {3}',b'{0} {1} n\xc4\x97ra susietas su {2} {3}'
+b'DocType: Notification Control',b'Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.',"b'Tinkinti \xc4\xafvadin\xc4\xaf tekst\xc4\x85, kad eina kaip tos pa\xc5\xa1tu dal\xc4\xaf. Kiekvienas sandoris turi atskir\xc4\x85 \xc4\xaf\xc5\xbeangin\xc4\xaf tekst\xc4\x85.'"
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176',b'Please set default payable account for the company {0}',b'Pra\xc5\xa1ome nustatyti numatyt\xc4\x85j\xc4\x85 mok\xc4\x97tin\xc4\x85 s\xc4\x85skaitos u\xc5\xbe bendrov\xc4\x97s {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +511',b'Transaction not allowed against stopped Work Order {0}',b'Sandoris neleid\xc5\xbeiamas nuo sustojimo Darb\xc5\xb3 u\xc5\xbesakymas {0}'
+b'DocType: Setup Progress Action',b'Min Doc Count',b'Min Doc Count'
+b'apps/erpnext/erpnext/config/manufacturing.py +84',b'Global settings for all manufacturing processes.',b'Global nustatymai visus gamybos procesus.'
+b'DocType: Accounts Settings',b'Accounts Frozen Upto',b'S\xc4\x85skaitos \xc5\xa0aldyti upto'
+b'DocType: SMS Log',b'Sent On',b'i\xc5\xa1si\xc5\xb3stas'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +700',b'Attribute {0} selected multiple times in Attributes Table',b'\xc4\xaeg\xc5\xabdis {0} pasirinktas kelis kartus po\xc5\xbeymiai lentel\xc4\x97je'
+b'DocType: HR Settings',b'Employee record is created using selected field. ',b'Darbuotoj\xc5\xb3 \xc4\xafra\xc5\xa1as sukurtas naudojant pasirinkt\xc4\x85 lauk\xc4\x85.'
+b'DocType: Sales Order',b'Not Applicable',b'Netaikoma'
+b'apps/erpnext/erpnext/config/hr.py +70',b'Holiday master.',b'Atostog\xc5\xb3 meistras.'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85',b'Opening Invoice Item',b'Atidarymo s\xc4\x85skaitos fakt\xc5\xabros punktas'
+b'DocType: Request for Quotation Item',b'Required Date',b'Reikalinga data'
+b'DocType: Delivery Note',b'Billing Address',b'atsiskaitymo Adresas'
+b'DocType: BOM',b'Costing',b'S\xc4\x85naud\xc5\xb3'
+b'DocType: Tax Rule',b'Billing County',b'atsiskaitymo apskritis'
+b'DocType: Purchase Taxes and Charges',"b'If checked, the tax amount will be considered as already included in the Print Rate / Print Amount'","b'Jei pa\xc5\xbeym\xc4\x97ta, mokes\xc4\x8di\xc5\xb3 suma bus laikoma jau \xc4\xaftrauktas Print Rate / Spausdinti Suma'"
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceRef',b'PieceRef'
+b'DocType: Request for Quotation',b'Message for Supplier',b'Prane\xc5\xa1imo tiek\xc4\x97jas'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40',b'Work Order',b'Darbo u\xc5\xbesakymas'
+b'DocType: Driver',b'DRIVER-.#####',b'DRIVER -. #####'
+b'DocType: Sales Invoice',b'Total Qty',b'viso Kiekis'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 E-mail ID'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 E-mail ID'
+b'DocType: Item',b'Show in Website (Variant)',b'Rodyti svetain\xc4\x97 (variantas)'
+b'DocType: Employee',b'Health Concerns',b'sveikatos problemas'
+b'DocType: Payroll Entry',b'Select Payroll Period',b'Pasirinkite Darbo u\xc5\xbemokes\xc4\x8dio laikotarpis'
+b'DocType: Purchase Invoice',b'Unpaid',b'neapmokamas'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49',b'Reserved for sale',b'Skirta pardavimui'
+b'DocType: Packing Slip',b'From Package No.',b'Nuo paketas Nr'
+b'DocType: Item Attribute',b'To Range',b'Nor\xc4\x97dami Diapazonas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29',b'Securities and Deposits',b'Vertybiniai popieriai ir u\xc5\xbestatai'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46',"b""Can't change valuation method, as there are transactions against some items which does not have it's own valuation method""","b'Nepavyksta pakeisti vertinimo metod\xc4\x85, nes yra sandoriai prie\xc5\xa1 kai daikt\xc5\xb3 kuri neturi tai savo vertinimo metodas'"
+b'DocType: Student Report Generation Tool',b'Attended by Parents',b'Dalyvauja t\xc4\x97vai'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82',b'Total leaves allocated is mandatory',b'skiriamos viso lapai yra privalomi'
+b'DocType: Patient',b'AB Positive',b'AB teigiamas'
+b'DocType: Job Opening',b'Description of a Job Opening',b'Apra\xc5\xa1ymas apie Darbo skelbimai'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110',b'Pending activities for today',b'Kol veikla \xc5\xa1iandien'
+b'apps/erpnext/erpnext/config/hr.py +24',b'Attendance record.',b'Lankomumas \xc4\xafra\xc5\xa1as.'
+b'DocType: Salary Structure',b'Salary Component for timesheet based payroll.',b'Pajamos komponentas \xc5\xbeiniara\xc5\xa1tis pagr\xc4\xafst\xc4\x85 darbo u\xc5\xbemokes\xc4\x8dio.'
+b'DocType: Sales Order Item',b'Used for Production Plan',b'Naudojamas gamybos planas'
+b'DocType: Employee Loan',b'Total Payment',b'bendras Apmok\xc4\x97jimas'
+b'DocType: Manufacturing Settings',b'Time Between Operations (in mins)',b'Laikas tarp operacij\xc5\xb3 (minut\xc4\x97mis)'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132',b'{0} {1} is cancelled so the action cannot be completed',b'{0} {1} yra at\xc5\xa1aukta ir tod\xc4\x97l veiksmai negali b\xc5\xabti u\xc5\xbebaigtas'
+b'DocType: Customer',b'Buyer of Goods and Services.',b'Pirk\xc4\x97jas prekes ir paslaugas.'
+b'DocType: Journal Entry',b'Accounts Payable',b'MOK\xc4\x96TINOS SUMOS'
+b'DocType: Patient',b'Allergies',b'Alergijos'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33',b'The selected BOMs are not for the same item',b'Pasirinktos BOMs yra ne to paties objekto'
+b'DocType: Supplier Scorecard Standing',b'Notify Other',b'Prane\xc5\xa1ti apie kit\xc4\x85'
+b'DocType: Vital Signs',b'Blood Pressure (systolic)',b'Kraujo spaudimas (sistolinis)'
+b'DocType: Pricing Rule',b'Valid Upto',b'galioja upto'
+b'DocType: Training Event',b'Workshop',b'dirbtuv\xc4\x97'
+b'DocType: Supplier Scorecard Scoring Standing',b'Warn Purchase Orders',b'\xc4\xaesp\xc4\x97ti pirkimo u\xc5\xbesakymus'
+b'apps/erpnext/erpnext/utilities/user_progress.py +67',b'List a few of your customers. They could be organizations or individuals.',b'S\xc4\x85ra\xc5\xa1as kelet\xc4\x85 savo klientams. Jie gali b\xc5\xabti organizacijos ar asmenys.'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23',b'Enough Parts to Build',b'Pakankamai Dalys sukurti'
+b'DocType: POS Profile User',b'POS Profile User',b'POS vartotojo profilis'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128',b'Direct Income',b'tiesiogini\xc5\xb3 pajam\xc5\xb3'
+b'DocType: Patient Appointment',b'Date TIme',b'Data TIme'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45',"b'Can not filter based on Account, if grouped by Account'","b'Negali filtruoti pagal s\xc4\x85skait\xc4\x85, jei sugrupuoti pagal s\xc4\x85skait\xc4\x85'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130',b'Administrative Officer',b'administracijos pareig\xc5\xabnas'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39',b'Setting up company and taxes',b'\xc4\xaemon\xc4\x97s steigimas ir mokes\xc4\x8diai'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Pra\xc5\xa1ome pasirinkti kursai'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Pra\xc5\xa1ome pasirinkti kursai'
+b'DocType: Codification Table',b'Codification Table',b'Kodifikavimo lentel\xc4\x97'
+b'DocType: Timesheet Detail',b'Hrs',b'h'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349',b'Please select Company',b'Pra\xc5\xa1ome pasirinkti kompanij\xc4\x85'
+b'DocType: Stock Entry Detail',b'Difference Account',b'skirtumas paskyra'
+b'DocType: Purchase Invoice',b'Supplier GSTIN',b'tiek\xc4\x97jas GSTIN'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +47',b'Cannot close task as its dependant task {0} is not closed.',"b'Ar n\xc4\x97ra artimas u\xc5\xbeduotis, nes jos priklauso nuo u\xc5\xbeduoties {0} n\xc4\x97ra u\xc5\xbedarytas.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435',b'Please enter Warehouse for which Material Request will be raised',"b'Pra\xc5\xa1ome \xc4\xafvesti sand\xc4\x97lis, kuris bus i\xc5\xa1keltas Med\xc5\xbeiaga Pra\xc5\xa1ymas'"
+b'DocType: Work Order',b'Additional Operating Cost',b'Papildoma eksploatavimo i\xc5\xa1laidos'
+b'DocType: Lab Test Template',b'Lab Routine',b'&quot;Lab Routine&quot;'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20',b'Cosmetics',b'kosmetika'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18',b'Please select Completion Date for Completed Asset Maintenance Log',b'Pra\xc5\xa1ome pasirinkti baigtinio turto prie\xc5\xbei\xc5\xabros \xc5\xbeurnalo u\xc5\xbebaigimo dat\xc4\x85'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +552',"b'To merge, following properties must be same for both items'","b'Sujungti, \xc5\xa1ie savyb\xc4\x97s turi b\xc5\xabti tokios pa\xc4\x8dios tiek daikt\xc5\xb3'"
+b'DocType: Shipping Rule',b'Net Weight',b'Grynas svoris'
+b'DocType: Employee',b'Emergency Phone',b'avarinis telefonas'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82',b'{0} {1} does not exist.',b'{0} {1} neegzistuoja.'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29',b'Buy',b'nupirkti'
+,b'Serial No Warranty Expiry',b'Serijos Nr Garantija galiojimo'
+b'DocType: Sales Invoice',b'Offline POS Name',b'Atsijung\xc4\x99s amp Vardas'
+b'apps/erpnext/erpnext/utilities/user_progress.py +180',b'Student Application',b'Studento parai\xc5\xa1ka'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Pra\xc5\xa1ome apibr\xc4\x97\xc5\xbeti kokyb\xc4\x97s u\xc5\xbe slenks\xc4\x8dio 0%'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Pra\xc5\xa1ome apibr\xc4\x97\xc5\xbeti kokyb\xc4\x97s u\xc5\xbe slenks\xc4\x8dio 0%'
+b'DocType: Sales Order',b'To Deliver',b'Pristatyti'
+b'DocType: Purchase Invoice Item',b'Item',b'Prek\xc4\x97'
+b'apps/erpnext/erpnext/healthcare/setup.py +256',b'High Sensitivity',b'Didelis jautrumas'
+b'apps/erpnext/erpnext/config/non_profit.py +48',b'Volunteer Type information.',b'Savanorio tipo informacija.'
+b'DocType: Cash Flow Mapping Template',b'Cash Flow Mapping Template',b'Pinig\xc5\xb3 sraut\xc5\xb3 \xc5\xbeem\xc4\x97lapi\xc5\xb3 \xc5\xa1ablonas'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2555',b'Serial no item cannot be a fraction',b'Serijos Nr punktas negali b\xc5\xabti frakcija'
+b'DocType: Journal Entry',b'Difference (Dr - Cr)',b'Skirtumas (dr - Cr)'
+b'DocType: Account',b'Profit and Loss',b'Pelnas ir nuostoliai'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104',"b'Not permitted, configure Lab Test Template as required'","b'Neleid\xc5\xbeiama sukonfig\xc5\xabruoti laboratorijos bandymo \xc5\xa1ablon\xc4\x85, jei reikia'"
+b'DocType: Patient',b'Risk Factors',b'Rizikos veiksniai'
+b'DocType: Patient',b'Occupational Hazards and Environmental Factors',b'Profesiniai pavojai ir aplinkos veiksniai'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239',b'Stock Entries already created for Work Order ',b'Daliniai \xc4\xafra\xc5\xa1ai jau sukurta darbo u\xc5\xbesakymui'
+b'DocType: Vital Signs',b'Respiratory rate',b'Kv\xc4\x97pavimo da\xc5\xbenis'
+b'apps/erpnext/erpnext/config/stock.py +334',b'Managing Subcontracting',b'valdymas Subranga'
+b'DocType: Vital Signs',b'Body Temperature',b'K\xc5\xabno temperat\xc5\xabra'
+b'DocType: Project',b'Project will be accessible on the website to these users',b'Projektas bus prieinama tinklalapyje \xc5\xa1i\xc5\xb3 vartotoj\xc5\xb3'
+b'DocType: Detected Disease',b'Disease',b'Liga'
+b'apps/erpnext/erpnext/config/projects.py +29',b'Define Project type.',b'Nurodykite projekto tip\xc4\x85.'
+b'DocType: Supplier Scorecard',b'Weighting Function',b'Svorio funkcija'
+b'DocType: Physician',b'OP Consulting Charge',b'&quot;OP Consulting&quot; mokestis'
+b'apps/erpnext/erpnext/utilities/user_progress.py +28',b'Setup your ',b'Nustatykite savo'
+b'DocType: Student Report Generation Tool',b'Show Marks',b'Rodyti \xc5\xbeenklus'
+b'DocType: Quotation',"b""Rate at which Price list currency is converted to company's base currency""","b'Norma, pagal kuri\xc4\x85 Kainora\xc5\xa1tis valiuta konvertuojama \xc4\xaf \xc4\xafmon\xc4\x97s bazine valiuta'"
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +70',b'Account {0} does not belong to company: {1}',b'S\xc4\x85skaita {0} nepriklauso \xc4\xafmon\xc4\x97s: {1}'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +52',b'Abbreviation already used for another company',b'Santrumpa jau naudojamas kitos bendrov\xc4\x97s'
+b'DocType: Selling Settings',b'Default Customer Group',b'Pagal nutyl\xc4\x97jim\xc4\x85 klient\xc5\xb3 grupei'
+b'DocType: Asset Repair',b'ARLOG-',b'ARLOG-'
+b'DocType: Global Defaults',"b""If disable, 'Rounded Total' field will not be visible in any transaction""",b'Jei i\xc5\xa1jungti &quot;suapvalinti sum\xc4\x85&quot; laukas nebus matomas bet koks sandoris'
+b'DocType: BOM',b'Operating Cost',b'Operacin\xc4\x97 Kaina'
+b'DocType: Crop',b'Produced Items',b'Pagaminti daiktai'
+b'DocType: Sales Order Item',b'Gross Profit',b'Bendrasis pelnas'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49',b'Increment cannot be 0',"b'Prieaugis negali b\xc5\xabti 0,'"
+b'DocType: Company',b'Delete Company Transactions',b'I\xc5\xa1trinti bendrov\xc4\x97s verslo sandoriai'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364',b'Reference No and Reference Date is mandatory for Bank transaction',b'Nuorodos Nr ir nuoroda data yra privalomas banko sandorio'
+b'DocType: Purchase Receipt',b'Add / Edit Taxes and Charges',b'\xc4\xaed\xc4\x97ti / Redaguoti mokes\xc4\x8di\xc5\xb3 ir rinkliav\xc5\xb3'
+b'DocType: Payment Entry Reference',b'Supplier Invoice No',b'Tiek\xc4\x97jas s\xc4\x85skaitoje Nr'
+b'DocType: Territory',b'For reference',b'pra\xc5\xa1ym\xc4\x85 priimti prejudicin\xc4\xaf sprendim\xc4\x85'
+b'DocType: Healthcare Settings',b'Appointment Confirmation',b'Paskyrimo patvirtinimas'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158',"b'Cannot delete Serial No {0}, as it is used in stock transactions'","b'Negalite trinti Serijos Nr {0}, kaip ji yra naudojama akcij\xc5\xb3 sandori\xc5\xb3'"
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256',b'Closing (Cr)',b'U\xc5\xbedarymo (CR)'
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1',b'Hello',b'Sveiki'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118',b'Move Item',b'Perkelti punktas'
+b'DocType: Serial No',b'Warranty Period (Days)',b'Garantinis laikotarpis (dienomis)'
+b'DocType: Installation Note Item',b'Installation Note Item',b'\xc4\xaerengimas Pastaba Prek\xc4\x97'
+b'DocType: Production Plan Item',b'Pending Qty',b'Kol Kiekis'
+b'DocType: Budget',b'Ignore',b'ignoruoti'
+b'apps/erpnext/erpnext/accounts/party.py +396',b'{0} {1} is not active',b'{0} {1} is not active'
+b'apps/erpnext/erpnext/config/accounts.py +272',b'Setup cheque dimensions for printing',b'S\xc4\x85ranka patikrinti matmenys spausdinti'
+b'DocType: Salary Slip',b'Salary Slip Timesheet',b'Pajamos Kuponas Lap\xc4\x85'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +160',b'Supplier Warehouse mandatory for sub-contracted Purchase Receipt',b'Tiek\xc4\x97jas tiekiantis sand\xc4\x97lis privalomas SUBRANGOVAMS pirkimo kvito'
+b'DocType: Pricing Rule',b'Valid From',b'Galioja nuo'
+b'DocType: Sales Invoice',b'Total Commission',b'I\xc5\xa1 viso Komisija'
+b'DocType: Pricing Rule',b'Sales Partner',b'Partneriai pardavimo'
+b'apps/erpnext/erpnext/config/buying.py +150',b'All Supplier scorecards.',b'Visi tiek\xc4\x97j\xc5\xb3 rezultat\xc5\xb3 kortel\xc4\x97s.'
+b'DocType: Buying Settings',b'Purchase Receipt Required',b'Pirkimo kvito Reikalinga'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188',b'Target warehouse in row {0} must be same as Work Order',b'Tikslin\xc4\x97 sand\xc4\x97lio eilut\xc4\x97 {0} turi b\xc5\xabti tokia pat kaip ir darbo u\xc5\xbesakymas'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +155',b'Valuation Rate is mandatory if Opening Stock entered',"b'Vertinimo rodiklis yra privalomas, jei atidarymas sand\xc4\x97lyje \xc4\xafvesta'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143',b'No records found in the Invoice table',b'rasti s\xc4\x85skaitos fakt\xc5\xabros lentel\xc4\x97s N\xc4\x97ra \xc4\xafra\xc5\xa1\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34',b'Please select Company and Party Type first',b'Pra\xc5\xa1ome pasirinkti bendrov\xc4\x97 ir \xc5\xa1alies tipo pirmas'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31',"b'Already set default in pos profile {0} for user {1}, kindly disabled default'","b'Jau nustatytas numatytasis naudotojo {1} pos profilyje {0}, maloniai i\xc5\xa1jungtas numatytasis'"
+b'apps/erpnext/erpnext/config/accounts.py +293',b'Financial / accounting year.',b'Finans\xc5\xb3 / apskaitos metus.'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9',b'Accumulated Values',b'sukauptos vertyb\xc4\x97s'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162',"b'Sorry, Serial Nos cannot be merged'","b'Atsipra\xc5\xa1ome, Eil\xc4\x97s Nr negali b\xc5\xabti sujungtos'"
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72',b'Territory is Required in POS Profile',b'Teritorija reikalinga POS profilyje'
+b'DocType: Supplier',b'Prevent RFQs',b'U\xc5\xbekirsti keli\xc4\x85 RFQ'
+b'apps/erpnext/erpnext/utilities/activation.py +83',b'Make Sales Order',b'Padaryti pardavimo u\xc5\xbesakym\xc5\xb3'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168',b'Salary Slip submitted for period from {0} to {1}',b'Atlyginimo u\xc5\xbestatas pateiktas laikotarpiui nuo {0} iki {1}'
+b'DocType: Project Task',b'Project Task',b'Projekt\xc5\xb3 U\xc5\xbeduotis'
+,b'Lead Id',b'\xc5\xa0vinas ID'
+b'DocType: C-Form Invoice Detail',b'Grand Total',b'Bendra suma'
+b'DocType: Assessment Plan',b'Course',b'kursas'
+b'DocType: Timesheet',b'Payslip',b'algalap\xc4\xaf'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +4',b'Item Cart',b'krep\xc5\xa1elis'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38',b'Fiscal Year Start Date should not be greater than Fiscal Year End Date',b'Finansiniai metai prad\xc5\xbeios data tur\xc4\x97t\xc5\xb3 b\xc5\xabti ne didesnis nei finansini\xc5\xb3 met\xc5\xb3 pabaigos data'
+b'DocType: Issue',b'Resolution',b'rezoliucija'
+b'DocType: C-Form',b'IV',b'IV'
+b'apps/erpnext/erpnext/templates/pages/order.html +76',b'Delivered: {0}',b'Paskelbta: {0}'
+b'DocType: Expense Claim',b'Payable Account',b'mok\xc4\x97tinos s\xc4\x85skaitos'
+b'DocType: Payment Entry',b'Type of Payment',b'Mok\xc4\x97jimo r\xc5\xab\xc5\xa1is'
+b'DocType: Sales Order',b'Billing and Delivery Status',b'Atsiskaitymo ir pristatymo statusas'
+b'DocType: Job Applicant',b'Resume Attachment',b'Gyvenimo Priedas'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58',b'Repeat Customers',b'Pakartokite Klientai'
+b'DocType: Leave Control Panel',b'Allocate',b'paskirstyti'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108',b'Create Variant',b'Sukurkite variant\xc4\x85'
+b'DocType: Sales Invoice',b'Shipping Bill Date',b'Pristatymo s\xc4\x85skaitos data'
+b'DocType: Production Plan',b'Production Plan',b'Gamybos planas'
+b'DocType: Opening Invoice Creation Tool',b'Opening Invoice Creation Tool',b'S\xc4\x85skait\xc5\xb3 fakt\xc5\xabr\xc5\xb3 k\xc5\xabrimo \xc4\xafrankio atidarymas'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853',b'Sales Return',b'pardavim\xc5\xb3 Gr\xc4\xaf\xc5\xbeti'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96',"b""Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period""",b'Pastaba: I\xc5\xa1 viso skiriami lapai {0} turi b\xc5\xabti ne ma\xc5\xbeesnis nei jau patvirtint\xc5\xb3 lap\xc5\xb3 {1} laikotarpiui'
+,b'Total Stock Summary',b'Viso sand\xc4\x97lyje santrauka'
+b'DocType: Announcement',b'Posted By',b'Paskelbtas'
+b'DocType: Item',b'Delivered by Supplier (Drop Ship)',b'Paskelbta tiek\xc4\x97jo (Drop Ship)'
+b'DocType: Healthcare Settings',b'Confirmation Message',b'Patvirtinimo prane\xc5\xa1imas'
+b'apps/erpnext/erpnext/config/crm.py +12',b'Database of potential customers.',b'Duomen\xc5\xb3 baz\xc4\x97 potencialiems klientams.'
+b'DocType: Authorization Rule',b'Customer or Item',b'Klientas ar punktas'
+b'apps/erpnext/erpnext/config/selling.py +28',b'Customer database.',b'Klient\xc5\xb3 duomen\xc5\xb3 baz\xc4\x97.'
+b'DocType: Quotation',b'Quotation To',b'citatos'
+b'DocType: Lead',b'Middle Income',b'vidutines pajamas'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228',b'Opening (Cr)',b'Anga (Cr)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +872',b'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.',"b'Numatytasis Matavimo vienetas u\xc5\xbe prek\xc4\x99 {0} negali b\xc5\xabti pakeistas tiesiogiai, nes j\xc5\xabs jau padar\xc4\x97 tam tikr\xc4\x85 sandor\xc4\xaf (-ius) su kitu UOM. Jums reik\xc4\x97s sukurti nauj\xc4\x85 element\xc4\x85 naudoti kit\xc4\x85 numatyt\xc4\x85j\xc4\xaf UOM.'"
+b'apps/erpnext/erpnext/accounts/utils.py +354',b'Allocated amount can not be negative',b'Paskirti suma negali b\xc5\xabti neigiama'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Pra\xc5\xa1ome nurodyti Bendrovei'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Pra\xc5\xa1ome nurodyti Bendrovei'
+b'DocType: Share Balance',b'Share Balance',b'Dalintis balansas'
+b'DocType: Purchase Order Item',b'Billed Amt',b'Apmokestinti Amt'
+b'DocType: Training Result Employee',b'Training Result Employee',b'Mokymai Rezultatas Darbuotoj\xc5\xb3'
+b'DocType: Warehouse',b'A logical Warehouse against which stock entries are made.',b'Logi\xc5\xa1kas Sand\xc4\x97li\xc5\xb3 nuo kuri\xc5\xb3 akcij\xc5\xb3 \xc4\xafra\xc5\xa1ai b\xc5\xabt\xc5\xb3 daromi.'
+b'DocType: Repayment Schedule',b'Principal Amount',b'pagrindin\xc4\x99 sum\xc4\x85'
+b'DocType: Employee Loan Application',b'Total Payable Interest',b'Viso mok\xc4\x97tinos pal\xc5\xabkanos'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57',b'Total Outstanding: {0}',b'I\xc5\xa1 viso ne\xc4\xafvykdyti: {0}'
+b'DocType: Sales Invoice Timesheet',b'Sales Invoice Timesheet',b'Pardavim\xc5\xb3 s\xc4\x85skaita fakt\xc5\xabra Lap\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118',b'Reference No & Reference Date is required for {0}',b'Nuorodos Nr &amp; nuoroda data reikalingas {0}'
+b'DocType: Payroll Entry',b'Select Payment Account to make Bank Entry',"b'Pasirinkite mok\xc4\x97jimo s\xc4\x85skaitos, kad bank\xc5\xb3 \xc4\xaf\xc4\x97jimo'"
+b'DocType: Hotel Settings',b'Default Invoice Naming Series',b'Numatytoji s\xc4\x85skait\xc5\xb3 vard\xc5\xb3 serija'
+b'apps/erpnext/erpnext/utilities/activation.py +136',"b'Create Employee records to manage leaves, expense claims and payroll'","b'Sukurti darbuotojams \xc4\xafra\xc5\xa1us valdyti lapai, i\xc5\xa1laid\xc5\xb3 parai\xc5\xa1kos ir darbo u\xc5\xbemokes\xc4\x8dio'"
+b'DocType: Restaurant Reservation',b'Restaurant Reservation',b'Restorano rezervavimas'
+b'DocType: Land Unit',b'Land Unit Name',b'\xc5\xbdem\xc4\x97s vieneto pavadinimas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190',b'Proposal Writing',b'Pasi\xc5\xablymas ra\xc5\xa1ymas'
+b'DocType: Payment Entry Deduction',b'Payment Entry Deduction',b'Mok\xc4\x97jimo \xc4\xae\xc4\x97jimo i\xc5\xa1skai\xc4\x8diavimas'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14',b'Wrapping up',b'\xc4\xaepakavimas'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35',b'Notify Customers via Email',b'Prane\xc5\xa1ti klientams el. Pa\xc5\xa1tu'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35',b'Another Sales Person {0} exists with the same Employee id',b'Kitas pardavim\xc5\xb3 asmuo {0} egzistuoja su tuo pa\xc4\x8diu Darbuotojo ID'
+b'DocType: Employee Advance',b'Claimed Amount',b'Reikalaujama suma'
+b'apps/erpnext/erpnext/config/education.py +180',b'Masters',b'Kandidatas'
+b'DocType: Assessment Plan',b'Maximum Assessment Score',b'Maksimalus vertinimo balas'
+b'apps/erpnext/erpnext/config/accounts.py +138',b'Update Bank Transaction Dates',b'Atnaujinti banko sandorio dien\xc4\x85'
+b'apps/erpnext/erpnext/config/projects.py +41',b'Time Tracking',b'laikas steb\xc4\x97jimas'
+b'DocType: Purchase Invoice',b'DUPLICATE FOR TRANSPORTER',b'Dublikat\xc4\x85 TRANSPORTER'
+b'apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49',b'Row {0}# Paid Amount cannot be greater than requested advance amount',b'Eilut\xc4\x97 {0} # Mokama suma negali b\xc5\xabti didesn\xc4\x97 u\xc5\xbe pra\xc5\xa1om\xc4\x85 avans\xc4\x85'
+b'DocType: Fiscal Year Company',b'Fiscal Year Company',b'Finansiniai metai \xc4\xaemon\xc4\x97s'
+b'DocType: Packing Slip Item',b'DN Detail',b'DN detal\xc4\x97s'
+b'DocType: Training Event',b'Conference',b'konferencija'
+b'DocType: Timesheet',b'Billed',b'\xc4\xafvardintas'
+b'DocType: Batch',b'Batch Description',b'Serija Apra\xc5\xa1ymas'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Student\xc5\xb3 grup\xc4\x97s k\xc5\xabrimas'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Student\xc5\xb3 grup\xc4\x97s k\xc5\xabrimas'
+b'apps/erpnext/erpnext/accounts/utils.py +727',"b'Payment Gateway Account not created, please create one manually.'","b'Mok\xc4\x97jimo \xc5\xa1liuzai paskyra nebuvo sukurta, pra\xc5\xa1ome sukurti rankiniu b\xc5\xabdu.'"
+b'DocType: Supplier Scorecard',b'Per Year',b'Per metus'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51',b'Not eligible for the admission in this program as per DOB',b'Negalima dalyvauti \xc5\xa1ioje programoje pagal DOB'
+b'DocType: Sales Invoice',b'Sales Taxes and Charges',b'Pardavim\xc5\xb3 Mokes\xc4\x8diai ir rinkliavos'
+b'DocType: Employee',b'Organization Profile',b'organizacijos profil\xc4\xaf'
+b'DocType: Vital Signs',b'Height (In Meter)',b'Auk\xc5\xa1tis (matuoklyje)'
+b'DocType: Student',b'Sibling Details',b'Giminyst\xc4\x97s detal\xc4\x97s'
+b'DocType: Vehicle Service',b'Vehicle Service',b'Autoservis\xc5\xb3'
+b'apps/erpnext/erpnext/config/setup.py +101',b'Automatically triggers the feedback request based on conditions.',b'Automati\xc5\xa1kai \xc4\xafjungia atsiliepimai pra\xc5\xa1ymas grind\xc5\xbeiamas s\xc4\x85lygomis.'
+b'DocType: Employee',b'Reason for Resignation',"b'Prie\xc5\xbeastis, d\xc4\x97l atsistatydinimo'"
+b'apps/erpnext/erpnext/config/hr.py +152',b'Template for performance appraisals.',b'\xc5\xa0ablonas na\xc5\xa1umo vertinimus.'
+b'DocType: Sales Invoice',b'Credit Note Issued',b'Kredito Pastaba I\xc5\xa1duotas'
+b'DocType: Project Task',b'Weight',b'svoris'
+b'DocType: Payment Reconciliation',b'Invoice/Journal Entry Details',b'S\xc4\x85skaita / leidinys \xc4\xae\xc4\x97jimo detal\xc4\x97s'
+b'apps/erpnext/erpnext/accounts/utils.py +83',"b""{0} '{1}' not in Fiscal Year {2}""",b'{0} &quot;{1}&quot; ne fiskaliniais metais {2}'
+b'DocType: Buying Settings',b'Settings for Buying Module',b'Nustatymai Ie\xc5\xa1ko modulis'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21',b'Asset {0} does not belong to company {1}',b'Turto {0} nepriklauso bendrovei {1}'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70',b'Please enter Purchase Receipt first',b'Pra\xc5\xa1ome \xc4\xafvesti pirkimo kvito pirmasis'
+b'DocType: Buying Settings',b'Supplier Naming By',b'Tiek\xc4\x97jas \xc4\xafvardijimas Iki'
+b'DocType: Activity Type',b'Default Costing Rate',b'Numatytasis S\xc4\x85naud\xc5\xb3 norma'
+b'DocType: Maintenance Schedule',b'Maintenance Schedule',b'Prie\xc5\xbei\xc5\xabros planas'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36',"b'Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.'","b'Tada Kainodaros taisykl\xc4\x97s yra i\xc5\xa1filtruotas remiantis Klientui, klient\xc5\xb3 grup\xc4\x97s, teritorijoje, tiek\xc4\x97jas, Tiek\xc4\x97jas tipas, kampanijos partneris pardavimo ir tt'"
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29',b'Net Change in Inventory',b'Grynasis pokytis Inventorius'
+b'apps/erpnext/erpnext/config/hr.py +162',b'Employee Loan Management',b'Darbuotoj\xc5\xb3 Paskolos valdymas'
+b'DocType: Employee',b'Passport Number',b'Paso numeris'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60',b'Relation with Guardian2',b'Ry\xc5\xa1ys su Guardian2'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124',b'Manager',b'vadybininkas'
+b'DocType: Payment Entry',b'Payment From / To',b'Mok\xc4\x97jimo Nuo / Iki'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +170',b'New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0}',b'Nauja kredito limitas yra ma\xc5\xbeesnis nei dabartinio nesumok\xc4\x97tos sumos klientui. Kredito limitas turi b\xc5\xabti atleast {0}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428',b'Please set account in Warehouse {0}',b'Nustatykite s\xc4\x85skait\xc4\x85 sand\xc4\x97lyje {0}'
+b'apps/erpnext/erpnext/controllers/trends.py +39',"b""'Based On' and 'Group By' can not be same""","b'""Remiantis"" ir ""grupuoti pagal"" negali b\xc5\xabti tas pats'"
+b'DocType: Sales Person',b'Sales Person Targets',b'Pardavim\xc5\xb3 asmuo tikslai'
+b'DocType: Installation Note',b'IN-',b'VAR\xc5\xbdYBOSE'
+b'DocType: Work Order Operation',b'In minutes',b'per kelias minutes'
+b'DocType: Issue',b'Resolution Date',b'geba data'
+b'DocType: Lab Test Template',b'Compound',b'Junginys'
+b'DocType: Student Batch Name',b'Batch Name',b'Serija Vardas'
+b'DocType: Fee Validity',b'Max number of visit',b'Maksimalus apsilankymo skai\xc4\x8dius'
+,b'Hotel Room Occupancy',b'Vie\xc5\xa1bu\xc4\x8dio kambario u\xc5\xbeimtumas'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358',b'Timesheet created:',b'Lap\xc4\x85 sukurta:'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931',b'Please set default Cash or Bank account in Mode of Payment {0}',b'Pra\xc5\xa1ome nustatyti numatyt\xc4\x85j\xc4\x85 grynaisiais ar banko s\xc4\x85skait\xc4\x85 mok\xc4\x97jimo b\xc5\xabdas {0}'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24',b'Enroll',b'\xc4\xafra\xc5\xa1yti'
+b'DocType: GST Settings',b'GST Settings',b'GST Nustatymai'
+b'DocType: Selling Settings',b'Customer Naming By',b'Klient\xc5\xb3 \xc4\xafvardijimas Iki'
+b'DocType: Student Leave Application',b'Will show the student as Present in Student Monthly Attendance Report',b'Parodys student\xc4\x85 kaip pristatyti Student\xc5\xb3 M\xc4\x97nesio Lankomumas ataskaitos'
+b'DocType: Depreciation Schedule',b'Depreciation Amount',b'turto nusid\xc4\x97v\xc4\x97jimo suma'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56',b'Convert to Group',b'Konvertuoti \xc4\xaf grup\xc4\x99'
+b'DocType: Delivery Trip',b'TOUR-.#####',b'TOUR -. #####'
+b'DocType: Activity Cost',b'Activity Type',b'veiklos r\xc5\xab\xc5\xa1is'
+b'DocType: Request for Quotation',b'For individual supplier',b'D\xc4\x97l individualaus tiek\xc4\x97jo'
+b'DocType: BOM Operation',b'Base Hour Rate(Company Currency)',b'Bazin\xc4\x97 valand\xc4\x85 grei\xc4\x8diu (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47',b'Delivered Amount',b'Paskelbta suma'
+b'DocType: Quotation Item',b'Item Balance',b'Prek\xc4\x97 balansas'
+b'DocType: Sales Invoice',b'Packing List',b'Pakavimo s\xc4\x85ra\xc5\xa1as'
+b'apps/erpnext/erpnext/config/buying.py +28',b'Purchase Orders given to Suppliers.',b'U\xc5\xbesakym\xc5\xb3 skiriamas tiek\xc4\x97j\xc5\xb3.'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43',b'Publishing',b'leidyba'
+b'DocType: Accounts Settings',b'Report Settings',b'Prane\xc5\xa1imo nustatymai'
+b'DocType: Activity Cost',b'Projects User',b'projektai Vartotojas'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Consumed',b'Suvartojo'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158',b'{0}: {1} not found in Invoice Details table',b'{0}: {1} nerasta S\xc4\x85skaitos informacijos lentel\xc4\x97s'
+b'DocType: Asset',b'Asset Owner Company',b'Turto savininko \xc4\xafmon\xc4\x97'
+b'DocType: Company',b'Round Off Cost Center',b'Suapvalinti s\xc4\x85naud\xc5\xb3 centro'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242',b'Maintenance Visit {0} must be cancelled before cancelling this Sales Order',b'Prie\xc5\xbei\xc5\xabra Aplankykite {0} turi b\xc5\xabti at\xc5\xa1auktas prie\xc5\xa1 panaikinant \xc5\xa1\xc4\xaf pardavimo u\xc5\xbesakym\xc5\xb3'
+b'DocType: Asset Maintenance Log',b'AML-',b'AML-'
+b'DocType: Item',b'Material Transfer',b'med\xc5\xbeiagos perne\xc5\xa1imas'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24',b'Could not find path for ',b'Nepavyko rasti kelio'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221',b'Opening (Dr)',b'Atidarymas (dr)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39',b'Posting timestamp must be after {0}',b'Siun\xc4\x8diamos laiko \xc5\xbeymos turi b\xc5\xabti po {0}'
+b'apps/erpnext/erpnext/config/accounts.py +39',b'To make recurring documents',b'Sukurti pasikartojan\xc4\x8dius dokumentus'
+,b'GST Itemised Purchase Register',"b'Paai\xc5\xa1k\xc4\x97jo, kad GST Detalios Pirkimo Registruotis'"
+b'DocType: Course Scheduling Tool',b'Reschedule',b'I\xc5\xa1 naujo nustatytas'
+b'DocType: Employee Loan',b'Total Interest Payable',b'I\xc5\xa1 viso pal\xc5\xabkan\xc5\xb3 Mok\xc4\x97tina'
+b'DocType: Landed Cost Taxes and Charges',b'Landed Cost Taxes and Charges',b'\xc4\xaeve\xc5\xbetin\xc4\x97 kaina Mokes\xc4\x8diai ir rinkliavos'
+b'DocType: Work Order Operation',b'Actual Start Time',b'Tikrasis Prad\xc5\xbeios laikas'
+b'DocType: BOM Operation',b'Operation Time',b'veikimo laikas'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316',b'Finish',b'Baigti'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412',b'Base',b'Baz\xc4\x97'
+b'DocType: Timesheet',b'Total Billed Hours',b'I\xc5\xa1 viso Apmokestintos valandos'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1530',b'Write Off Amount',b'Nura\xc5\xa1yti suma'
+b'DocType: Leave Block List Allow',b'Allow User',b'leid\xc5\xbeia vartotojui'
+b'DocType: Journal Entry',b'Bill No',b'Billas N\xc4\x97ra'
+b'DocType: Company',b'Gain/Loss Account on Asset Disposal',b'Pelnas / nuostolis paskyra nuo turto perdavimo'
+b'DocType: Vehicle Log',b'Service Details',b'paslaug\xc5\xb3 detal\xc4\x97s'
+b'DocType: Vehicle Log',b'Service Details',b'paslaug\xc5\xb3 detal\xc4\x97s'
+b'DocType: Subscription',b'Quarterly',b'kas ketvirt\xc4\xaf'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47',b'EcritureLib',b'&quot;EcritureLib&quot;'
+b'DocType: Lab Test Template',b'Grouped',b'Grupuojami'
+b'DocType: Selling Settings',b'Delivery Note Required',b'Reikalinga Va\xc5\xbetara\xc5\xa1tis'
+b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Banko garantija Ta\xc5\xa1k\xc5\xb3'
+b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Banko garantija Ta\xc5\xa1k\xc5\xb3'
+b'DocType: Assessment Criteria',b'Assessment Criteria',b'vertinimo kriterijai'
+b'DocType: BOM Item',b'Basic Rate (Company Currency)',b'Bazinis tarifas (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Student Attendance',b'Student Attendance',b'Student\xc5\xb3 dalyvavimas'
+b'DocType: Sales Invoice Timesheet',b'Time Sheet',b'laikas lapas'
+b'DocType: Manufacturing Settings',b'Backflush Raw Materials Based On',b'Backflush \xc5\xbdaliavos remiantis'
+b'DocType: Sales Invoice',b'Port Code',b'Uosto kodas'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957',b'Reserve Warehouse',b'Rezerv\xc5\xb3 sand\xc4\x97lis'
+b'DocType: Lead',b'Lead is an Organization',b'\xc5\xa0vinas yra organizacija'
+b'DocType: Guardian Interest',b'Interest',b'pal\xc5\xabkanos'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10',b'Pre Sales',b'Pre Pardavimai'
+b'DocType: Instructor Log',b'Other Details',b'Kitos detal\xc4\x97s'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18',b'Suplier',b'suplier'
+b'DocType: Lab Test',b'Test Template',b'Bandymo \xc5\xa1ablonas'
+b'DocType: Restaurant Order Entry Item',b'Served',b'Pateikta'
+b'apps/erpnext/erpnext/config/non_profit.py +13',b'Chapter information.',b'Skyrius informacija.'
+b'DocType: Account',b'Accounts',b's\xc4\x85skaitos'
+b'DocType: Vehicle',b'Odometer Value (Last)',b'Odometras Vert\xc4\x97 (Paskutinis)'
+b'apps/erpnext/erpnext/config/buying.py +160',b'Templates of supplier scorecard criteria.',b'Tiekimo rezultat\xc5\xb3 vertinimo kriterij\xc5\xb3 \xc5\xa1ablonai.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109',b'Marketing',b'prekyba'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303',b'Payment Entry is already created',b'Mok\xc4\x97jimo \xc4\xafra\xc5\xa1as jau yra sukurta'
+b'DocType: Request for Quotation',b'Get Suppliers',b'Gaukite tiek\xc4\x97jus'
+b'DocType: Purchase Receipt Item Supplied',b'Current Stock',b'Dabartinis sand\xc4\x97lyje'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +610',b'Row #{0}: Asset {1} does not linked to Item {2}',"b'Eilut\xc4\x97s # {0}: Turto {1} n\xc4\x97ra susij\xc4\x99s su straipsniais, {2}'"
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15',b'Please setup Instructor Naming System in Education &gt; Education Settings',b'Pra\xc5\xa1ome nustatyti &quot;Instruktori\xc5\xb3 pavadinimo&quot; sistem\xc4\x85 &quot;Education&quot;&gt; &quot;Education Settings&quot;'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394',b'Preview Salary Slip',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti darbo u\xc5\xbemokest\xc4\xaf'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54',b'Account {0} has been entered multiple times',b'S\xc4\x85skaita {0} buvo \xc4\xafra\xc5\xa1ytas kelis kartus'
+b'DocType: Account',b'Expenses Included In Valuation',"b'S\xc4\x85naud\xc5\xb3, \xc4\xaftraukt\xc5\xb3 Vertinimo'"
+b'apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37',b'You can only renew if your membership expires within 30 days',b'Galite atnaujinti tik jei naryst\xc4\x97s terminas baigiasi per 30 dien\xc5\xb3'
+b'DocType: Land Unit',b'Longitude',b'Ilguma'
+,b'Absent Student Report',b'N\xc4\x97ra studento ataskaitos'
+b'DocType: Crop',b'Crop Spacing UOM',b'Crop Spacing UOM'
+b'DocType: Accounts Settings',b'Only select if you have setup Cash Flow Mapper documents',"b'Pasirinkite tik tada, jei turite nustatymus Pinig\xc5\xb3 srauto kartografavimo dokumentus'"
+b'DocType: Email Digest',b'Next email will be sent on:',b'Kitas lai\xc5\xa1kas bus i\xc5\xa1si\xc5\xb3stas \xc4\xaf:'
+b'DocType: Supplier Scorecard',b'Per Week',b'Per savait\xc4\x99'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +666',b'Item has variants.',b'Prek\xc4\x97 turi variantus.'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154',b'Total Student',b'Viso studento'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65',b'Item {0} not found',b'Prek\xc4\x97 {0} nerastas'
+b'DocType: Bin',b'Stock Value',b'vertybini\xc5\xb3 popieri\xc5\xb3 kaina'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +239',b'Company {0} does not exist',b'\xc4\xaemon\xc4\x97s {0} neegzistuoja'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40',b'{0} has fee validity till {1}',b'{0} mokestis galioja iki {1}'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54',b'Tree Type',b'medis tipas'
+b'DocType: BOM Explosion Item',b'Qty Consumed Per Unit',b'Kiekis Suvartoti Vieneto'
+b'DocType: GST Account',b'IGST Account',b'IGST s\xc4\x85skaita'
+b'DocType: Serial No',b'Warranty Expiry Date',b'Garantija Galiojimo data'
+b'DocType: Material Request Item',b'Quantity and Warehouse',b'Kiekis ir sand\xc4\x97liavimo'
+b'DocType: Hub Settings',b'Unregister',b'Atsisakyti registracijos'
+b'DocType: Sales Invoice',b'Commission Rate (%)',b'Komisija tarifas (%)'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Pra\xc5\xa1ome pasirinkti program\xc4\x85'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Pra\xc5\xa1ome pasirinkti program\xc4\x85'
+b'DocType: Project',b'Estimated Cost',b'Numatoma kaina'
+b'DocType: Purchase Order',b'Link to material requests',b'Nuoroda \xc4\xaf materialini\xc5\xb3 pra\xc5\xa1ymus'
+b'DocType: Hub Settings',b'Publish',b'Paskelbti'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7',b'Aerospace',b'Aviacija'
+,b'Fichier des Ecritures Comptables [FEC]',b'Fichier des Ecritures Comptables [FEC]'
+b'DocType: Journal Entry',b'Credit Card Entry',b'Kreditin\xc4\x97 kortel\xc4\x97 \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/config/accounts.py +57',b'Company and Accounts',b'\xc4\xaemon\xc4\x97 ir s\xc4\x85skaitos'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70',b'In Value',b'vert\xc4\x97s'
+b'DocType: Asset Settings',b'Depreciation Options',b'Nusid\xc4\x97v\xc4\x97jimo galimyb\xc4\x97s'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +35',b'Invalid Posting Time',b'Neteisingas skelbimo laikas'
+b'DocType: Lead',b'Campaign Name',b'kampanijos pavadinimas'
+b'DocType: Hotel Room',b'Capacity',b'Talpa'
+b'DocType: Selling Settings',b'Close Opportunity After Days',b'U\xc5\xbedaryti prog\xc4\x85 dien\xc5\xb3'
+,b'Reserved',b'rezervuotas'
+b'DocType: Driver',b'License Details',b'Informacija apie licencij\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85',b'The field From Shareholder cannot be blank',b'Laukas i\xc5\xa1 akcininko negali b\xc5\xabti tu\xc5\xa1\xc4\x8dias'
+b'DocType: Purchase Order',b'Supply Raw Materials',b'Tiekimo \xc5\xbdaliavos'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10',b'Current Assets',b'Turimas turtas'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121',b'{0} is not a stock Item',b'{0} n\xc4\x97ra sand\xc4\x97lyje punktas'
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6',"b""Please share your feedback to the training by clicking on 'Training Feedback' and then 'New'""","b'Pra\xc5\xa1ome pasidalinti savo atsiliepimais su mokymu spustel\xc4\x97dami &quot;Mokymo atsiliepimai&quot;, tada &quot;Naujas&quot;'"
+b'DocType: Mode of Payment Account',b'Default Account',b'numatytoji paskyra'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +273',b'Please select Sample Retention Warehouse in Stock Settings first',b'Pirmiausia pasirinkite &quot;Sample Storage Warehouse&quot; atsarg\xc5\xb3 nustatymuose'
+b'DocType: Payment Entry',b'Received Amount (Company Currency)',b'Gautos sumos (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192',b'Lead must be set if Opportunity is made from Lead',"b'\xc5\xa0vinas turi b\xc5\xabti nustatyti, jei galimyb\xc4\x97s yra pagamintas i\xc5\xa1 \xc5\xa1vino'"
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136',b'Payment Cancelled. Please check your GoCardless Account for more details',"b'Mok\xc4\x97jimas at\xc5\xa1auktas. Pra\xc5\xa1ome patikrinti savo &quot;GoCardless&quot; s\xc4\x85skait\xc4\x85, kad gautum\xc4\x97te daugiau informacijos'"
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29',b'Please select weekly off day',b'Pra\xc5\xa1ome pasirinkti savait\xc4\x99 nuo dien\xc4\x85'
+b'DocType: Patient',b'O Negative',b'O neigiamas'
+b'DocType: Work Order Operation',b'Planned End Time',b'Planuojamas Pabaigos laikas'
+,b'Sales Person Target Variance Item Group-Wise',b'Pardavim\xc5\xb3 Asmuo Tikslin\xc4\x97 Dispersija punktas grup\xc4\x97-I\xc5\xa1min\xc4\x8dius'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +93',b'Account with existing transaction cannot be converted to ledger',b'S\xc4\x85skaita su esamais sandoris negali b\xc5\xabti konvertuojamos \xc4\xaf s\xc4\x85skait\xc5\xb3 knygos'
+b'apps/erpnext/erpnext/config/non_profit.py +33',b'Memebership Type Details',b'Mokes\xc4\x8di\xc5\xb3 tipo duomenys'
+b'DocType: Delivery Note',"b""Customer's Purchase Order No""",b'Kliento U\xc5\xbesakymo N\xc4\x97ra'
+b'DocType: Budget',b'Budget Against',b'biud\xc5\xbeeto prie\xc5\xa1'
+b'DocType: Employee',b'Cell Number',b'Telefono numeris'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450',"b""There's no employee for the given criteria. Check that Salary Slips have not already been created.""","b'N\xc4\x97 vienas darbuotojas pagal nurodytus kriterijus n\xc4\x97ra. Patikrinkite, ar atlyginim\xc5\xb3 \xc4\x8dekiai dar nebuvo sukurti.'"
+b'apps/erpnext/erpnext/stock/reorder_item.py +194',b'Auto Material Requests Generated',b'Auto Med\xc5\xbeiaga Pra\xc5\xa1ymai Sugeneruoti'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7',b'Lost',b'prarastas'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152',"b""You can not enter current voucher in 'Against Journal Entry' column""",b'J\xc5\xabs negalite \xc4\xafvesti dabartin\xc4\xaf kupon\xc4\x85 \xc4\xaf &quot;prie\xc5\xa1 leidinys \xc4\xafra\xc5\xa1as&quot; skiltyje'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50',b'Reserved for manufacturing',b'Skirta gamybos'
+b'DocType: Soil Texture',b'Sand',b'Sm\xc4\x97lis'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25',b'Energy',b'energija'
+b'DocType: Opportunity',b'Opportunity From',b'galimyb\xc4\x97 Nuo'
+b'apps/erpnext/erpnext/config/hr.py +98',b'Monthly salary statement.',b'M\xc4\x97nesinis darbo u\xc5\xbemokestis parei\xc5\xa1kimas.'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887',b'Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.',b'Eilut\xc4\x97 {0}: {1} {2} elementui reikalingi eil\xc4\x97s numeriai. J\xc5\xabs pateik\xc4\x97 {3}.'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79',b'Please select a table',b'Pasirinkite lentel\xc4\x99'
+b'DocType: BOM',b'Website Specifications',b'Interneto svetain\xc4\x97 duomenys'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78',"b""{0} is an invalid email address in 'Recipients'""",b'{0} yra netinkamas el. Pa\xc5\xa1to adresas &quot;gav\xc4\x97jams&quot;'
+b'DocType: Special Test Items',b'Particulars',b'Duomenys'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24',b'{0}: From {0} of type {1}',b'{0}: Nuo {0} tipo {1}'
+b'DocType: Warranty Claim',b'CI-',b'CI-'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +300',b'Row {0}: Conversion Factor is mandatory',b'Eilut\xc4\x97s {0}: konversijos faktorius yra privalomas'
+b'DocType: Student',b'A+',b'A +'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344',"b'Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}'","b'Keli Kaina Taisykl\xc4\x97s egzistuoja tais pa\xc4\x8diais kriterijais, pra\xc5\xa1ome i\xc5\xa1spr\xc4\x99sti konflikt\xc4\x85 suteikti pirmenyb\xc4\x99. Kaina Taisykl\xc4\x97s: {0}'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519',b'Cannot deactivate or cancel BOM as it is linked with other BOMs',b'Negalima i\xc5\xa1jungti arba at\xc5\xa1aukti BOM kaip ji yra susijusi su kitais BOMs'
+b'DocType: Asset',b'Maintenance',b'prie\xc5\xbei\xc5\xabra'
+b'DocType: Item Attribute Value',b'Item Attribute Value',b'Prek\xc4\x97 Pavadinimas Reik\xc5\xa1m\xc4\x97'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +406',b'Please Update your Project Status',b'Atnaujinkite savo projekto b\xc5\xabsen\xc4\x85'
+b'DocType: Item',b'Maximum sample quantity that can be retained',"b'Maksimalus m\xc4\x97gini\xc5\xb3 kiekis, kur\xc4\xaf galima i\xc5\xa1saugoti'"
+b'DocType: Project Update',b'How is the Project Progressing Right Now?',b'Kaip projektas t\xc4\x99siasi dabar?'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418',b'Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3}',b'Eilut\xc4\x97 {0} # Item {1} negalima perkelti daugiau nei {2} prie\xc5\xa1 pirkimo u\xc5\xbesakym\xc4\x85 {3}'
+b'apps/erpnext/erpnext/config/selling.py +158',b'Sales campaigns.',b'Pardavim\xc5\xb3 kampanijas.'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117',b'Make Timesheet',b'Padaryti \xc5\xbeiniara\xc5\xa1tis'
+b'DocType: Sales Taxes and Charges Template',"b'Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.'","b'Standartin\xc4\x97 mokestis \xc5\xa1ablonas, kuris gali b\xc5\xabti taikomas visiems pardavimo sandori\xc5\xb3. \xc5\xa0is \xc5\xa1ablonas gali b\xc5\xabti s\xc4\x85ra\xc5\xa1\xc4\x85 mokes\xc4\x8di\xc5\xb3 vadov\xc5\xb3, taip pat kit\xc5\xb3 i\xc5\xa1laid\xc5\xb3 / pajam\xc5\xb3 vadov\xc5\xb3, pavyzd\xc5\xbeiui, &quot;Pristatymas&quot;, &quot;Draudimas&quot;, &quot;tvarkymas&quot; ir tt #### Pastaba mokes\xc4\x8dio tarifas, kur\xc4\xaf nurodote \xc4\x8dia bus standartinis mokes\xc4\x8dio tarifas u\xc5\xbe visus ** Daiktai **. Jei yra ** daiktai **, kurios turi skirtingus tarifus, jie turi b\xc5\xabti prid\xc4\x97ta ** Prek\xc4\x97s mokes\xc4\x8dio ** lentel\xc4\x99 ** Prek\xc4\x97s ** meistras. #### Apra\xc5\xa1ymas Stulpeliai 1. Skai\xc4\x8diavimo tipas: - Tai gali b\xc5\xabti ** Grynasis Viso ** (tai yra bazinio dyd\xc5\xbeio suma). - ** D\xc4\x97l ankstesn\xc4\x97s eil\xc4\x97s viso / suma ** (kumuliacin\xc4\xaf mokes\xc4\x8dius ar rinkliavas). Jei pasirinksite \xc5\xa1i\xc4\x85 parinkt\xc4\xaf, mokestis bus taikomas kaip ankstesn\xc4\x97s eil\xc4\x97s procentais (mokes\xc4\x8di\xc5\xb3 lentel\xc4\x99) sumos arba i\xc5\xa1 viso. - ** Tikrasis ** (kaip min\xc4\x97ta). 2. S\xc4\x85skaitos vadovas: S\xc4\x85skaitos knygos, pagal kuri\xc4\x85 \xc5\xa1is mokestis bus nubaustas 3. S\xc4\x85naud\xc5\xb3 centras: Jei mokestis / mokestis yra pajam\xc5\xb3 (pavyzd\xc5\xbeiui, laivybos) arba i\xc5\xa1laid\xc5\xb3 ji turi b\xc5\xabti nubaustas nuo i\xc5\xa1laid\xc5\xb3 centro. 4. Apra\xc5\xa1ymas: Apra\xc5\xa1ymas mokes\xc4\x8dio (kuris bus spausdinamas s\xc4\x85skait\xc5\xb3 fakt\xc5\xabr\xc5\xb3 / kabu\xc4\x8di\xc5\xb3). 5. Vertinti: Mokes\xc4\x8dio tarifas. 6. Suma: Mokes\xc4\x8di\xc5\xb3 suma. 7. I\xc5\xa1 viso: Kaupiamasis viso \xc5\xa1io ta\xc5\xa1ko. 8. \xc4\xaeveskite Row: Jei remiantis &quot;ankstesn\xc4\x97s eil\xc4\x97s viso&quot; galite pasirinkti numer\xc4\xaf eilut\xc4\x97s, kurios bus imtasi kaip pagrind\xc4\x85 \xc5\xa1iam apskai\xc4\x8diavimui (pagal nutyl\xc4\x97jim\xc4\x85 yra ankstesn\xc4\x97 eilut\xc4\x97). 9. Ar \xc5\xa1is mokestis \xc4\xaftrauktas \xc4\xaf bazin\xc4\x99 pal\xc5\xabkan\xc5\xb3 norm\xc4\x85 ?: Jei pa\xc5\xbeym\xc4\x97site \xc5\xa1i\xc4\x85, tai rei\xc5\xa1kia, kad \xc5\xa1is mokestis nebus rodomas \xc5\xbeemiau punkto lentel\xc4\x97je, bet bus \xc4\xaftrauktas \xc4\xaf bazin\xc4\x99 kain\xc4\x85 savo pagrindinio punkto lentel\xc4\x97je. Tai naudinga, kai norite suteikti plok\xc5\xa1\xc4\x8di\xc4\x85 kain\xc4\x85 (\xc4\xafskaitant visus mokes\xc4\x8dius) kaina vartotojams.'"
+b'DocType: Employee',b'Bank A/C No.',b'Bank A / C Nr'
+b'DocType: Bank Guarantee',b'Project',b'projektas'
+b'DocType: Quality Inspection Reading',b'Reading 7',b'Skaitymas 7'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9',b'Partially Ordered',b'dalinai U\xc5\xbesakytas'
+b'DocType: Lab Test',b'Lab Test',b'Laboratorijos testas'
+b'DocType: Student Report Generation Tool',b'Student Report Generation Tool',b'Student\xc5\xb3 ataskaitos k\xc5\xabrimo \xc4\xafrankis'
+b'DocType: Expense Claim Detail',b'Expense Claim Type',b'Kompensuojamos Parai\xc5\xa1kos tipas'
+b'DocType: Shopping Cart Settings',b'Default settings for Shopping Cart',b'Numatytieji nustatymai krep\xc5\xa1el\xc4\xaf'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27',b'Add Timeslots',b'Prid\xc4\x97ti &quot;Timeslots&quot;'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138',b'Asset scrapped via Journal Entry {0}',b'Turto sunaikintas per \xc5\xbeurnalo \xc4\xafra\xc5\xa1\xc4\x85 {0}'
+b'DocType: Employee Loan',b'Interest Income Account',b'Pal\xc5\xabkan\xc5\xb3 pajam\xc5\xb3 s\xc4\x85skaita'
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58',b'Review Invitation Sent',b'I\xc5\xa1si\xc5\xb3sta pakvietimo per\xc5\xbei\xc5\xabra'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13',b'Biotechnology',b'biotechnologijos'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109',b'Office Maintenance Expenses',b'Biuro i\xc5\xa1laikymo s\xc4\x85naudos'
+b'apps/erpnext/erpnext/utilities/user_progress.py +54',b'Go to ',b'Eiti \xc4\xaf'
+b'apps/erpnext/erpnext/config/learn.py +47',b'Setting up Email Account',b'\xc4\xaesteigti pa\xc5\xa1to d\xc4\x97\xc5\xbeut\xc4\x99'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21',b'Please enter Item first',b'Pra\xc5\xa1ome \xc4\xafvesti Element\xc4\x85 pirmas'
+b'DocType: Asset Repair',b'Downtime',b'Prastovos laikas'
+b'DocType: Account',b'Liability',b'atsakomyb\xc4\x97'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220',b'Sanctioned Amount cannot be greater than Claim Amount in Row {0}.',b'Sankcijos suma negali b\xc5\xabti didesn\xc4\x97 nei ie\xc5\xa1kinio suma eilut\xc4\x97je {0}.'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11',b'Academic Term: ',b'Akademinis terminas:'
+b'DocType: Salary Detail',b'Do not include in total',b'Ne\xc4\xaftraukite i\xc5\xa1 viso'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206',b'Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series',b'Nustatym\xc5\xb3 serij\xc4\x85 galite nustatyti {0} naudodami s\xc4\x85rank\xc4\x85&gt; Nustatymai&gt; vard\xc5\xb3 serija'
+b'DocType: Company',b'Default Cost of Goods Sold Account',b'Numatytasis i\xc5\xa1laidos parduot\xc5\xb3 preki\xc5\xb3 s\xc4\x85skaita'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1019',b'Sample quantity {0} cannot be more than received quantity {1}',b'M\xc4\x97ginio kiekis {0} negali b\xc5\xabti didesnis nei gautas kiekis {1}'
+b'apps/erpnext/erpnext/stock/get_item_details.py +369',b'Price List not selected',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as nepasirinkote'
+b'DocType: Employee',b'Family Background',b'\xc5\xa1eimos faktai'
+b'DocType: Request for Quotation Supplier',b'Send Email',b'Si\xc5\xb3sti lai\xc5\xa1k\xc4\x85'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +228',b'Warning: Invalid Attachment {0}',b'\xc4\xaesp\xc4\x97jimas: Neteisingas Priedas {0}'
+b'DocType: Item',b'Max Sample Quantity',b'Maksimalus m\xc4\x97ginio kiekis'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766',b'No Permission',b'N\xc4\x97ra leidimo'
+b'DocType: Vital Signs',b'Heart Rate / Pulse',b'\xc5\xa0irdies ritmas / impulsas'
+b'DocType: Company',b'Default Bank Account',b'Numatytasis banko s\xc4\x85skaitos'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59',"b'To filter based on Party, select Party Type first'","b'Filtruoti remiantis partijos, pasirinkite \xc5\xa0alis \xc4\xaeveskite pirm\xc4\x85'"
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48',"b""'Update Stock' can not be checked because items are not delivered via {0}""","b'""Atnaujinti sand\xc4\x97l\xc4\xaf"" negali b\xc5\xabti patikrintas, nes daiktai n\xc4\x97ra pristatomi per {0}'"
+b'DocType: Vehicle',b'Acquisition Date',b'\xc4\xafsigijimo data'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Nos',b'nos'
+b'DocType: Item',b'Items with higher weightage will be shown higher',"b'Daiktai, turintys auk\xc5\xa1t\xc4\x85j\xc4\xaf weightage bus rodomas didesnis'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14',b'Lab Tests and Vital Signs',b'Lab testus ir gyvybinius po\xc5\xbeymius'
+b'DocType: Bank Reconciliation Detail',b'Bank Reconciliation Detail',b'Bankas Susitaikymas detal\xc4\x97s'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +614',b'Row #{0}: Asset {1} must be submitted',b'Eilut\xc4\x97s # {0}: Turto {1} turi b\xc5\xabti pateiktas'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40',b'No employee found',b'N\xc4\x97ra darbuotojas nerasta'
+b'DocType: Subscription',b'Stopped',b'sustabdyta'
+b'DocType: Item',b'If subcontracted to a vendor',b'Jei subrangos sutart\xc4\xaf pardav\xc4\x97jas'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Student\xc5\xb3 grup\xc4\x97 jau yra atnaujinama.'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Student\xc5\xb3 grup\xc4\x97 jau yra atnaujinama.'
+b'apps/erpnext/erpnext/config/projects.py +18',b'Project Update.',b'Projekto atnaujinimas.'
+b'DocType: SMS Center',b'All Customer Contact',b'Viskas Klient\xc5\xb3 Susisiekite'
+b'DocType: Land Unit',b'Tree Details',b'medis detal\xc4\x97s'
+b'DocType: Training Event',b'Event Status',b'Statusas renginiai'
+b'DocType: Volunteer',b'Availability Timeslot',b'Prieinamumo laikra\xc5\xa1tis'
+,b'Support Analytics',b'paramos Analytics &quot;'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365',"b'If you have any questions, please get back to us.'","b'Jei turite koki\xc5\xb3 nors klausim\xc5\xb3, pra\xc5\xa1ome gr\xc4\xaf\xc5\xbeti \xc4\xaf mus.'"
+b'DocType: Cash Flow Mapper',b'Cash Flow Mapper',b'Gryn\xc5\xb3j\xc5\xb3 pinig\xc5\xb3 srauto kartotuvas'
+b'DocType: Item',b'Website Warehouse',b'Interneto svetain\xc4\x97 sand\xc4\x97lis'
+b'DocType: Payment Reconciliation',b'Minimum Invoice Amount',b'Minimalus s\xc4\x85skaitos fakt\xc5\xabros suma'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111',b'{0} {1}: Cost Center {2} does not belong to Company {3}',b'{0} {1}: Kaina centras {2} nepriklauso Company {3}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +92',b'Upload your letter head (Keep it web friendly as 900px by 100px)',b'\xc4\xaekelkite savo lai\xc5\xa1ko galva (laikykite j\xc4\xaf tinkamu kaip 900 pikseli\xc5\xb3 100 pikseli\xc5\xb3)'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88',b'{0} {1}: Account {2} cannot be a Group',b'{0} {1}: S\xc4\x85skaitos {2} negali b\xc5\xabti Grup\xc4\x97'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63',"b""Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table""",b'Prek\xc4\x97 eilut\xc4\x97 {IDX}: {DOCTYPE} {DOCNAME} neegzistuoja vir\xc5\xa1aus &quot;{DOCTYPE}&quot; stalo'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295',b'Timesheet {0} is already completed or cancelled',b'Lap\xc4\x85 {0} jau baig\xc4\x97 arba at\xc5\xa1aukti'
+b'apps/erpnext/erpnext/templates/pages/projects.html +42',b'No tasks',b'n\xc4\x97ra u\xc5\xbeduotys'
+b'DocType: Item Variant Settings',b'Copy Fields to Variant',b'Kopijuoti laukus \xc4\xaf variant\xc4\x85'
+b'DocType: Asset',b'Opening Accumulated Depreciation',b'Atidarymo sukauptas nusid\xc4\x97v\xc4\x97jimas'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49',b'Score must be less than or equal to 5',b'Rezultatas turi b\xc5\xabti ma\xc5\xbeesnis arba lygus 5'
+b'DocType: Program Enrollment Tool',b'Program Enrollment Tool',b'Programos \xc4\xaera\xc5\xa1as \xc4\xafrankis'
+b'apps/erpnext/erpnext/config/accounts.py +335',b'C-Form records',"b'\xc4\xafra\xc5\xa1\xc5\xb3, C-forma'"
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73',b'The shares already exist',b'Akcijos jau yra'
+b'apps/erpnext/erpnext/config/selling.py +316',b'Customer and Supplier',b'Klient\xc5\xb3 ir tiek\xc4\x97jas'
+b'DocType: Email Digest',b'Email Digest Settings',b'Si\xc5\xb3sti Digest Nustatymai'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367',b'Thank you for your business!',b'D\xc4\x97koju Jums u\xc5\xbe bendradarbiavim\xc4\x85!'
+b'apps/erpnext/erpnext/config/support.py +12',b'Support queries from customers.',b'Paramos u\xc5\xbeklausos i\xc5\xa1 klient\xc5\xb3.'
+b'DocType: Setup Progress Action',b'Action Doctype',b'&quot;Action Doctype&quot;'
+b'DocType: HR Settings',b'Retirement Age',b'pensijinis am\xc5\xbeius'
+b'DocType: Bin',b'Moving Average Rate',b'Moving Average Balsuok'
+b'DocType: Production Plan',b'Select Items',b'pasirinkite prek\xc4\x99'
+b'DocType: Share Transfer',b'To Shareholder',b'Akcininkui'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372',b'{0} against Bill {1} dated {2}',b'{0} prie\xc5\xa1 Bill {1} {2} data'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Institution',b'S\xc4\x85rankos institucija'
+b'DocType: Program Enrollment',b'Vehicle/Bus Number',b'Transporto priemon\xc4\x97 / autobusai Ta\xc5\xa1k\xc5\xb3'
+b'apps/erpnext/erpnext/education/doctype/course/course.js +17',b'Course Schedule',b'\xc5\xbdinoma Tvarkara\xc5\xa1tis'
+b'DocType: Request for Quotation Supplier',b'Quote Status',b'Citata statusas'
+b'DocType: GoCardless Settings',b'Webhooks Secret',b'Webhooks paslaptis'
+b'DocType: Maintenance Visit',b'Completion Status',b'u\xc5\xbebaigimo b\xc5\xabsena'
+b'DocType: Daily Work Summary Group',b'Select Users',b'Pasirinkite vartotojus'
+b'DocType: Hotel Room Pricing Item',b'Hotel Room Pricing Item',b'Vie\xc5\xa1bu\xc4\x8di\xc5\xb3 kambario kain\xc5\xb3 punktas'
+b'DocType: HR Settings',b'Enter retirement age in years',b'\xc4\xaeveskite pensin\xc4\xaf am\xc5\xbei\xc5\xb3 metais'
+b'DocType: Crop',b'Target Warehouse',b'Tikslin\xc4\x97 sand\xc4\x97lis'
+b'DocType: Payroll Employee Detail',b'Payroll Employee Detail',b'I\xc5\xa1sami darbo u\xc5\xbemokes\xc4\x8dio darbuotojo informacija'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128',b'Please select a warehouse',b'Pra\xc5\xa1ome pasirinkti sand\xc4\x97l\xc4\xaf'
+b'DocType: Cheque Print Template',b'Starting location from left edge',b'Nuo viet\xc4\x85 i\xc5\xa1 kairiojo kra\xc5\xa1to'
+b'DocType: Item',b'Allow over delivery or receipt upto this percent',b'Leisti per pristatym\xc4\x85 ar gavimo net iki \xc5\xa1io proc'
+b'DocType: Stock Entry',b'STE-',b'STE-'
+b'DocType: Upload Attendance',b'Import Attendance',b'importas Lankomumas'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +124',b'All Item Groups',b'Visi punktas Grup\xc4\x97s'
+b'apps/erpnext/erpnext/config/setup.py +89',b'Automatically compose message on submission of transactions.',b'Automati\xc5\xa1kai kurti prane\xc5\xa1im\xc4\x85 pateikus sandorius.'
+b'DocType: Work Order',b'Item To Manufacture',b'Prek\xc4\x97 Gamyba'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteLib',b'CompteLib'
+b'apps/erpnext/erpnext/buying/utils.py +80',b'{0} {1} status is {2}',b'{0} {1} statusas {2}'
+b'DocType: Water Analysis',b'Collection Temperature ',b'Kolekcijos temperat\xc5\xabra'
+b'DocType: Employee',b'Provide Email Address registered in company',b'Pateikite registruota bendrov\xc4\x97 pa\xc5\xa1to adres\xc4\x85'
+b'DocType: Shopping Cart Settings',b'Enable Checkout',b'\xc4\xaejungti Checkout'
+b'apps/erpnext/erpnext/config/learn.py +202',b'Purchase Order to Payment',b'Pirkimo u\xc5\xbesakymas su mok\xc4\x97jimo'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48',b'Projected Qty',"b'prognozuojama, Kiekis'"
+b'DocType: Sales Invoice',b'Payment Due Date',b'Sumok\xc4\x97ti iki'
+b'DocType: Drug Prescription',b'Interval UOM',b'Intervalas UOM'
+b'DocType: Customer',"b'Reselect, if the chosen address is edited after save'","b'I\xc5\xa1 naujo pa\xc5\xbeym\xc4\x97kite, jei pasirinktas adresas yra redaguotas po \xc4\xafra\xc5\xa1ymo'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +522',b'Item Variant {0} already exists with same attributes',b'Prek\xc4\x97 variantas {0} jau egzistuoja su tais pa\xc4\x8diais atributais'
+b'DocType: Item',b'Hub Publishing Details',b'Hub Publishing duomenys'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117',"b""'Opening'""",b'&quot;Atidarymas&quot;'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130',b'Open To Do',b'Atidarykite daryti'
+b'DocType: Notification Control',b'Delivery Note Message',b'Va\xc5\xbetara\xc5\xa1tis prane\xc5\xa1imas'
+b'DocType: Lab Test Template',b'Result Format',b'Rezultato formatas'
+b'DocType: Expense Claim',b'Expenses',b'i\xc5\xa1laidos'
+b'DocType: Item Variant Attribute',b'Item Variant Attribute',b'Prek\xc4\x97 variantas \xc4\xaeg\xc5\xabdis'
+,b'Purchase Receipt Trends',b'Pirkimo kvito tendencijos'
+b'DocType: Payroll Entry',b'Bimonthly',b'Dviej\xc5\xb3 m\xc4\x97nesi\xc5\xb3'
+b'DocType: Vehicle Service',b'Brake Pad',b'stabd\xc5\xbei\xc5\xb3 bloknotas'
+b'DocType: Fertilizer',b'Fertilizer Contents',b'Tr\xc4\x85\xc5\xa1\xc5\xb3 turinys'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119',b'Research & Development',b'Tyrimai ir pl\xc4\x97tra'
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20',b'Amount to Bill',b'Suma Bill'
+b'DocType: Company',b'Registration Details',b'Registracija detal\xc4\x97s'
+b'DocType: Timesheet',b'Total Billed Amount',b'I\xc5\xa1 viso mokes\xc4\x8dio suma'
+b'DocType: Item Reorder',b'Re-Order Qty',b'Re U\xc5\xbesakomas kiekis'
+b'DocType: Leave Block List Date',b'Leave Block List Date',b'Palikite Blokuoti s\xc4\x85ra\xc5\xa1\xc4\x85 data'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94',b'BOM #{0}: Raw material cannot be same as main Item',b'BOM # {0}: \xc5\xbealiava negali b\xc5\xabti tokia pati kaip pagrindinis elementas'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92',b'Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges',b'I\xc5\xa1 viso taikomi mokes\xc4\x8diai \xc4\xaf pirkimo kvito sum\xc5\xb3 lentel\xc4\x97 turi b\xc5\xabti tokios pa\xc4\x8dios kaip viso mokes\xc4\x8di\xc5\xb3 ir rinkliav\xc5\xb3'
+b'DocType: Sales Team',b'Incentives',b'paskatos'
+b'DocType: SMS Log',b'Requested Numbers',b'Pageidaujami numeriai'
+b'DocType: Volunteer',b'Evening',b'Vakaras'
+b'DocType: Customer',b'Bypass credit limit check at Sales Order',b'Apskai\xc4\x8diuokite kredito limito patikrinim\xc4\x85 Pardavim\xc5\xb3 u\xc5\xbesakyme'
+b'apps/erpnext/erpnext/config/hr.py +147',b'Performance appraisal.',b'Veiklos vertinimas.'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100',"b""Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart""","b'\xc4\xaejungus &quot;Naudokite krep\xc5\xa1el\xc4\xaf&quot;, kaip Krep\xc5\xa1elis yra \xc4\xafjungtas ir ten tur\xc4\x97t\xc5\xb3 b\xc5\xabti bent viena Mokes\xc4\x8di\xc5\xb3 taisykl\xc4\x97 krep\xc5\xa1el\xc4\xaf'"
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +412',"b'Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.'","b'Mok\xc4\x97jimo \xc4\xae\xc4\x97jimo {0} yra susij\xc4\x99s su ordino {1}, patikrinti, ar jis turi b\xc5\xabti traukiamas kaip anksto \xc5\xa1ioje s\xc4\x85skaitoje fakt\xc5\xabroje.'"
+b'DocType: Sales Invoice Item',b'Stock Details',b'akcij\xc5\xb3 detal\xc4\x97s'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29',b'Project Value',b'projekto vert\xc4\x97'
+b'apps/erpnext/erpnext/config/selling.py +326',b'Point-of-Sale',b'Pardavimo punktas'
+b'DocType: Fee Schedule',b'Fee Creation Status',b'Mokes\xc4\x8dio k\xc5\xabrimo b\xc5\xabsena'
+b'DocType: Vehicle Log',b'Odometer Reading',b'odometro parodymus'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +116',"b""Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'""","b'S\xc4\x85skaitos likutis jau kredito, jums neleid\xc5\xbeiama nustatyti &quot;Balansas turi b\xc5\xabti&quot; kaip &quot;debeto&quot;'"
+b'DocType: Account',b'Balance must be',b'Balansas turi b\xc5\xabti'
+b'DocType: Hub Settings',b'Publish Pricing',b'Paskelbti Kainos'
+b'DocType: Notification Control',b'Expense Claim Rejected Message',b'Kompensuojamos teiginys atmetamas prane\xc5\xa1imas'
+,b'Available Qty',b'Turimas Kiekis'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Total',b'D\xc4\x97l ankstesn\xc4\x97s eil\xc4\x97s viso'
+b'DocType: Purchase Invoice Item',b'Rejected Qty',b'atmesta Kiekis'
+b'DocType: Setup Progress Action',b'Action Field',b'Veiksm\xc5\xb3 laukas'
+b'DocType: Healthcare Settings',b'Manage Customer',b'Valdyti klient\xc4\x85'
+b'DocType: Delivery Trip',b'Delivery Stops',b'Pristatymas sustoja'
+b'DocType: Salary Slip',b'Working Days',b'Darbo dienos'
+b'DocType: Serial No',b'Incoming Rate',b'Priimamojo Balsuok'
+b'DocType: Packing Slip',b'Gross Weight',b'Bendras svoris'
+,b'Final Assessment Grades',b'Galutiniai vertinimo balai'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47',b'Enable Hub',b'\xc4\xaegalinti koncentratori\xc5\xb3'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +110',b'The name of your company for which you are setting up this system.',"b'J\xc5\xabs\xc5\xb3 \xc4\xafmon\xc4\x97s pavadinimas, d\xc4\x97l kuri\xc5\xb3 j\xc5\xabs nustatote \xc5\xa1i\xc4\x85 sistem\xc4\x85.'"
+b'DocType: HR Settings',b'Include holidays in Total no. of Working Days',b'\xc4\xaetraukti atostogas i\xc5\xa1 viso ne. darbo dien\xc5\xb3'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108',b'Setup your Institute in ERPNext',b'Nustatykite savo institut\xc4\x85 ERPNext'
+b'DocType: Agriculture Analysis Criteria',b'Plant Analysis',b'Augal\xc5\xb3 analiz\xc4\x97'
+b'DocType: Job Applicant',b'Hold',b'laikyti'
+b'DocType: Project Update',b'Progress Details',b'Pa\xc5\xbeangos detal\xc4\x97s'
+b'DocType: Employee',b'Date of Joining',b'Data Prisijungimas'
+b'DocType: Naming Series',b'Update Series',b'Atnaujinti serija'
+b'DocType: Supplier Quotation',b'Is Subcontracted',b'subrangos sutartis'
+b'DocType: Restaurant Table',b'Minimum Seating',b'Minimali s\xc4\x97dimoji vietov\xc4\x97'
+b'DocType: Item Attribute',b'Item Attribute Values',b'Prek\xc4\x97 atribut\xc5\xb3 reik\xc5\xa1mes'
+b'DocType: Examination Result',b'Examination Result',b'tyrimo rezultatas'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845',b'Purchase Receipt',b'pirkimo kvito'
+,b'Received Items To Be Billed',b'Gauti duomenys turi b\xc5\xabti apmokestinama'
+b'apps/erpnext/erpnext/config/accounts.py +303',b'Currency exchange rate master.',b'Valiutos kursas meistras.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209',b'Reference Doctype must be one of {0}',b'Nuoroda Dokumento tipo turi b\xc5\xabti vienas i\xc5\xa1 {0}'
+b'apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46',b'Filter Total Zero Qty',b'Filtras i\xc5\xa1 viso nulinio kiekio'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341',b'Unable to find Time Slot in the next {0} days for Operation {1}',b'Nepavyko rasti laiko tarpsni\xc5\xb3 per ateinan\xc4\x8dius {0} dien\xc5\xb3 darbui {1}'
+b'DocType: Work Order',b'Plan material for sub-assemblies',b'Planas med\xc5\xbeiaga mazgams'
+b'apps/erpnext/erpnext/config/selling.py +97',b'Sales Partners and Territory',b'Pardavim\xc5\xb3 Partneriai ir teritorija'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +600',b'BOM {0} must be active',b'BOM {0} turi b\xc5\xabti aktyvus'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414',b'No Items available for transfer',b'Nepavyko perkelti joki\xc5\xb3 element\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218',b'Closing (Opening + Total)',b'U\xc5\xbedarymas (atidarymas + viso)'
+b'DocType: Journal Entry',b'Depreciation Entry',b'Nusid\xc4\x97v\xc4\x97jimas \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32',b'Please select the document type first',b'Pra\xc5\xa1ome pasirinkti dokumento tip\xc4\x85 pirmas'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65',b'Cancel Material Visits {0} before cancelling this Maintenance Visit',b'At\xc5\xa1aukti Med\xc5\xbeiaga Apsilankymai {0} prie\xc5\xa1 at\xc5\xa1aukiant \xc5\xa1i\xc4\x85 Prie\xc5\xbei\xc5\xabros vizitas'
+b'DocType: Crop Cycle',b'ISO 8016 standard',b'ISO 8016 standartas'
+b'DocType: Pricing Rule',b'Rate or Discount',b'\xc4\xaekainiai arba nuolaidos'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213',b'Serial No {0} does not belong to Item {1}',b'Serijos Nr {0} nepriklauso punkte {1}'
+b'DocType: Purchase Receipt Item Supplied',b'Required Qty',b'Reikalinga Kiekis'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126',b'Warehouses with existing transaction can not be converted to ledger.',b'Sand\xc4\x97liai su esamais sandoris negali b\xc5\xabti konvertuojamos \xc4\xaf knyg\xc4\x85.'
+b'DocType: Bank Reconciliation',b'Total Amount',b'Visas kiekis'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32',b'Internet Publishing',b'Interneto leidyba'
+b'DocType: Prescription Duration',b'Number',b'Numeris'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25',b'Creating {0} Invoice',b'Kuriama {0} s\xc4\x85skaita fakt\xc5\xabra'
+b'DocType: Medical Code',b'Medical Code Standard',b'Medicinos kodekso standartas'
+b'DocType: Soil Texture',b'Clay Composition (%)',b'Molio sud\xc4\x97tis (%)'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81',b'Please save before assigning task.',b'Pra\xc5\xa1ome i\xc5\xa1saugoti prie\xc5\xa1 priskirdami u\xc5\xbeduot\xc4\xaf.'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74',b'Balance Value',b'balansin\xc4\x97 vert\xc4\x97'
+b'DocType: Lab Test',b'Lab Technician',b'Laboratorijos technikas'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38',b'Sales Price List',b'Pardavim\xc5\xb3 Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as'
+b'DocType: Healthcare Settings',"b'If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.'","b'Jei pa\xc5\xbeym\xc4\x97site, klientas bus sukurtas, priskirtas pacientui. Paciento s\xc4\x85skaita bus sukurta prie\xc5\xa1 \xc5\xa1\xc4\xaf Klient\xc4\x85. Kuriant pacient\xc4\x85 galite pasirinkti esam\xc4\x85 klient\xc4\x85.'"
+b'DocType: Bank Reconciliation',b'Account Currency',b's\xc4\x85skaita Valiuta'
+b'DocType: Lab Test',b'Sample ID',b'Pavyzd\xc5\xbeio ID'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +167',b'Please mention Round Off Account in Company',b'Pamin\xc4\x97kite suapvalinti Naryst\xc4\x97 Bendrov\xc4\x97je'
+b'DocType: Purchase Receipt',b'Range',b'diapazonas'
+b'DocType: Supplier',b'Default Payable Accounts',b'Numatytieji mok\xc4\x97tin\xc5\xb3 sum\xc5\xb3'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49',b'Employee {0} is not active or does not exist',b'Darbuotoj\xc5\xb3 {0} is not active arba neegzistuoja'
+b'DocType: Fee Structure',b'Components',b'komponentai'
+b'DocType: Item Barcode',b'Item Barcode',b'Prek\xc4\x97s br\xc5\xabk\xc5\xa1ninis kodas'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +329',b'Please enter Asset Category in Item {0}',b'Pra\xc5\xa1ome \xc4\xafvesti Turto kategorija prek\xc4\x97s {0}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +661',b'Item Variants {0} updated',b'Prek\xc4\x97 Variantai {0} atnaujinama'
+b'DocType: Quality Inspection Reading',b'Reading 6',b'Skaitymas 6'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9',"b'to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field\nof this'","b'turi b\xc5\xabti sukurta. Jei v\xc4\x97luojama, tur\xc4\x97site rankiniu b\xc5\xabdu pakeisti lauko &quot;Kartoti m\xc4\x97nesio dien\xc4\x85&quot; lauk\xc4\x85'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961',b'Cannot {0} {1} {2} without any negative outstanding invoice',b'Negaliu {0} {1} {2} be jokio neigiamo i\xc5\xa1skirtinis s\xc4\x85skaita'
+b'DocType: Share Transfer',b'From Folio No',b'I\xc5\xa1 Folio Nr'
+b'DocType: Purchase Invoice Advance',b'Purchase Invoice Advance',b'Pirkimo fakt\xc5\xabros Advance'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199',b'Row {0}: Credit entry can not be linked with a {1}',b'Eilut\xc4\x97s {0}: Kredito \xc4\xafra\xc5\xa1as negali b\xc5\xabti susieta su {1}'
+b'apps/erpnext/erpnext/config/accounts.py +246',b'Define budget for a financial year.',b'Nustatykite biud\xc5\xbeet\xc4\x85 per finansinius metus.'
+b'DocType: Lead',b'LEAD-',b'VADOVAUTI-'
+b'DocType: Employee',b'Permanent Address Is',b'Nuolatin\xc4\x97 adresas'
+b'DocType: Work Order Operation',b'Operation completed for how many finished goods?',"b'Operacija baigta, kaip daug gatav\xc5\xb3 preki\xc5\xb3?'"
+b'DocType: Payment Terms Template',b'Payment Terms Template',b'Mok\xc4\x97jimo s\xc4\x85lygos \xc5\xa1ablonas'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +51',b'The Brand',b'Brand'
+b'DocType: Employee',b'Exit Interview Details',b'I\xc5\xa1eiti Interviu detal\xc4\x97s'
+b'DocType: Item',b'Is Purchase Item',b'Ar pirkimas Prek\xc4\x97s'
+b'DocType: Journal Entry Account',b'Purchase Invoice',b'pirkimo s\xc4\x85skaita fakt\xc5\xabra'
+b'DocType: Stock Ledger Entry',b'Voucher Detail No',b'Bon I\xc5\xa1samiau N\xc4\x97ra'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +789',b'New Sales Invoice',b'Nauja pardavimo s\xc4\x85skaita-fakt\xc5\xabra'
+b'DocType: Stock Entry',b'Total Outgoing Value',b'I\xc5\xa1 viso Siuntimo kaina'
+b'DocType: Physician',b'Appointments',b'Paskyrimai'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +223',b'Opening Date and Closing Date should be within same Fiscal Year',b'Atidarymo data ir galutinis terminas tur\xc4\x97t\xc5\xb3 b\xc5\xabti per pat\xc4\xaf finansiniams metams'
+b'DocType: Lead',b'Request for Information',b'Papra\xc5\xa1yti informacijos'
+,b'LeaderBoard',b'Lyderi\xc5\xb3'
+b'DocType: Sales Invoice Item',b'Rate With Margin (Company Currency)',b'Norma su mar\xc5\xbea (\xc4\xafmon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +802',b'Sync Offline Invoices',b'Sinchronizuoti Atsijung\xc4\x99s S\xc4\x85skaitos'
+b'DocType: Payment Request',b'Paid',b'Mokama'
+b'DocType: Program Fee',b'Program Fee',b'programos mokestis'
+b'DocType: BOM Update Tool',"b'Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.'","b'Pakeiskite tam tikr\xc4\x85 BOM visose kitose BOM, kur jis naudojamas. Jis pakeis sen\xc4\x85 BOM nuorod\xc4\x85, atnaujins kain\xc4\x85 ir atkurs &quot;BOM sprogimo element\xc4\x85&quot; lentel\xc4\x99 pagal nauj\xc4\x85 BOM. Taip pat atnaujinama naujausia kaina visose BOM.'"
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447',b'The following Work Orders were created:',b'Buvo sukurti \xc5\xa1ie darbo u\xc5\xbesakymai:'
+b'DocType: Salary Slip',b'Total in words',b'I\xc5\xa1 viso \xc5\xbeod\xc5\xbeiais'
+b'DocType: Material Request Item',b'Lead Time Date',b'\xc5\xa0vinas Laikas Data'
+,b'Employee Advance Summary',b'Darbuotojo i\xc5\xa1ankstinio suvestin\xc4\x97'
+b'DocType: Asset',b'Available-for-use Date',b'Galima naudoti data'
+b'DocType: Guardian',b'Guardian Name',b'glob\xc4\x97jas Vardas'
+b'DocType: Cheque Print Template',b'Has Print Format',b'Ar spausdintos'
+b'DocType: Employee Loan',b'Sanctioned',b'sankcijos'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +75',b' is mandatory. Maybe Currency Exchange record is not created for ',b'privalomas. Galb\xc5\xabt nebuvo sukurtas Valiut\xc5\xb3 Keitimo \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139',b'Row #{0}: Please specify Serial No for Item {1}',b'Eilut\xc4\x97s # {0}: Pra\xc5\xa1ome nurodyti Serijos Nr u\xc5\xbe prek\xc4\x99 {1}'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54',b'Supplier &gt; Supplier Type',b'Tiek\xc4\x97jas&gt; Tiek\xc4\x97jo tipas'
+b'DocType: Crop Cycle',b'Crop Cycle',b'Pas\xc4\x97li\xc5\xb3 ciklas'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633',"b""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.""","b'D\xc4\x97l &quot;produktas Bundle reikmenys, sand\xc4\x97lis, Serijos Nr paketais N\xc4\x97ra bus laikomas i\xc5\xa1&quot; apyra\xc5\xa1as stalo &quot;. Jei Sand\xc4\x97lio ir Serija Ne yra vienoda visoms pakavimo joki\xc5\xb3 daikt\xc5\xb3 &quot;produktas Bundle&quot; elemento, tos vert\xc4\x97s gali b\xc5\xabti \xc4\xafra\xc5\xa1oma \xc4\xaf pagrindin\xc4\x99 punkto lentel\xc4\x97je, vert\xc4\x97s bus nukopijuoti \xc4\xaf &quot;apyra\xc5\xa1as stalo.'"
+b'DocType: Student Admission',b'Publish on website',b'Skelbti tinklapyje'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651',b'Supplier Invoice Date cannot be greater than Posting Date',b'Tiek\xc4\x97jas s\xc4\x85skaitos fakt\xc5\xabros i\xc5\xa1ra\xc5\xa1ymo data negali b\xc5\xabti didesnis nei Skelbimo data'
+b'DocType: Purchase Invoice Item',b'Purchase Order Item',b'Pirkimui u\xc5\xbesakyti Element\xc4\x85'
+b'DocType: Agriculture Task',b'Agriculture Task',b'\xc5\xbdem\xc4\x97s \xc5\xabkio U\xc5\xbeduotis'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132',b'Indirect Income',b'netiesiogin\xc4\x97 pajamos'
+b'DocType: Student Attendance Tool',b'Student Attendance Tool',b'Student\xc5\xb3 dalyvavimas \xc4\xafrankis'
+b'DocType: Restaurant Menu',b'Price List (Auto created)',b'Kainora\xc5\xa1tis (automati\xc5\xa1kai sukurta)'
+b'DocType: Cheque Print Template',b'Date Settings',b'data Nustatymai'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48',b'Variance',b'varianti\xc5\xa1kumas'
+,b'Company Name',b'\xc4\xaemon\xc4\x97s pavadinimas'
+b'DocType: SMS Center',b'Total Message(s)',b'Bendras prane\xc5\xa1imas (-ai)'
+b'DocType: Share Balance',b'Purchased',b'Supirkta'
+b'DocType: Item Variant Settings',b'Rename Attribute Value in Item Attribute.',b'Pavadinkite atributo vert\xc4\x99 elemento elementu.'
+b'DocType: Purchase Invoice',b'Additional Discount Percentage',b'Papildoma nuolaida procentais'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24',b'View a list of all the help videos',b'Per\xc5\xbei\xc5\xabr\xc4\x97kite visas pagalbos video s\xc4\x85ra\xc5\xa1\xc4\x85'
+b'DocType: Agriculture Analysis Criteria',b'Soil Texture',b'Dirvo\xc5\xbeemio tekst\xc5\xabra'
+b'DocType: Bank Reconciliation',b'Select account head of the bank where cheque was deposited.',b'Pasirinkite s\xc4\x85skaita Banko vadovas kurioje patikrinimas buvo deponuoti.'
+b'DocType: Selling Settings',b'Allow user to edit Price List Rate in transactions',b'Leisti vartotojui redaguoti kainora\xc5\xa1t\xc4\xaf Balsuok sandoriuose'
+b'DocType: Pricing Rule',b'Max Qty',b'Maksimalus Kiekis'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25',b'Print Report Card',b'Spausdinti ataskaitos kortel\xc4\x99'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30',"b'Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \\\n\t\t\t\t\t\tPlease enter a valid Invoice'","b'Eilut\xc4\x97s {0}: S\xc4\x85skaita {1} yra negaliojantis, jis gali b\xc5\xabti at\xc5\xa1auktas / neegzistuoja. \\ Pra\xc5\xa1ome \xc4\xafvesti galiojant\xc4\xaf s\xc4\x85skaita fakt\xc5\xabra'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132',b'Row {0}: Payment against Sales/Purchase Order should always be marked as advance',b'Eilut\xc4\x97s {0}: Mok\xc4\x97jimo prie\xc5\xa1 pirkimo / pardavimo ordino visada turi b\xc5\xabti pa\xc5\xbeym\xc4\x97tas kaip anksto'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16',b'Chemical',b'cheminis'
+b'DocType: Salary Component Account',b'Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.',"b'Numatytasis Bankas / Pinig\xc5\xb3 s\xc4\x85skaita bus automati\xc5\xa1kai atnaujinta u\xc5\xbemokes\xc4\x8di\xc5\xb3 \xc5\xbeurnalo \xc4\xafra\xc5\xa1\xc4\x85, kai pasirinktas \xc5\xa1is b\xc5\xabdas.'"
+b'DocType: BOM',b'Raw Material Cost(Company Currency)',b'\xc5\xbdaliav\xc5\xb3 kaina (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Eilut\xc4\x97 # {0}: \xc4\xaevertinti gali b\xc5\xabti ne didesnis nei naudotu dyd\xc5\xbeiu {1} {2}'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Eilut\xc4\x97 # {0}: \xc4\xaevertinti gali b\xc5\xabti ne didesnis nei naudotu dyd\xc5\xbeiu {1} {2}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Meter',b'matuoklis'
+b'DocType: Workstation',b'Electricity Cost',b'elektros kaina'
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23',b'Lab testing datetime cannot be before collection datetime',b'&quot;Lab test&quot; datatime negali b\xc5\xabti prie\xc5\xa1 rinkimo dat\xc4\x85'
+b'DocType: HR Settings',"b""Don't send Employee Birthday Reminders""",b'Nesi\xc5\xb3skite Darbuotoj\xc5\xb3 Gimimo diena Priminimai'
+b'DocType: Expense Claim',b'Total Advance Amount',b'Visa avansin\xc4\x97 suma'
+b'DocType: Delivery Stop',b'Estimated Arrival',b'Numatytas atvykimas'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34',b'Save Settings',b'I\xc5\xa1saugoti nustatymus'
+b'DocType: Delivery Stop',b'Notified by Email',b'Prane\xc5\xa1ta el. Pa\xc5\xa1tu'
+b'DocType: Item',b'Inspection Criteria',b'tikrinimo kriterijai'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14',b'Transfered',b'pervestos'
+b'DocType: BOM Website Item',b'BOM Website Item',b'BOM svetain\xc4\x97 punktas'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +52',b'Upload your letter head and logo. (you can edit them later).',b'\xc4\xaekelti savo lai\xc5\xa1ke galv\xc4\x85 ir logotip\xc4\x85. (Galite redaguoti juos v\xc4\x97liau).'
+b'DocType: Timesheet Detail',b'Bill',b's\xc4\x85skaita'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +88',b'Next Depreciation Date is entered as past date',b'Kitas Nusid\xc4\x97v\xc4\x97jimas data yra \xc4\xafvesta kaip praeities datos'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208',b'White',b'baltas'
+b'DocType: SMS Center',b'All Lead (Open)',b'Visi \xc5\xa1vinas (Atviras)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270',b'Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3})',b'Eilut\xc4\x97s {0}: Kiekis neprieinama {4} sand\xc4\x97lyje {1} ne komandiruot\xc4\x97s laik\xc4\x85 \xc4\xafra\xc5\xa1o ({2} {3})'
+b'apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18',b'You can only select a maximum of one option from the list of check boxes.',b'I\xc5\xa1 \xc5\xbeymos langeli\xc5\xb3 s\xc4\x85ra\xc5\xa1o galite pasirinkti tik vien\xc4\x85 variant\xc4\x85.'
+b'DocType: Purchase Invoice',b'Get Advances Paid',b'Gauti avansai Mokama'
+b'DocType: Item',b'Automatically Create New Batch',b'Automati\xc5\xa1kai Sukurti nauj\xc4\x85 partij\xc4\x85'
+b'DocType: Item',b'Automatically Create New Batch',b'Automati\xc5\xa1kai Sukurti nauj\xc4\x85 partij\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635',b'Assigning {0} to {1} (row {2})',b'Priskirti {0} iki {1} (eilut\xc4\x97 {2})'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Make ',b'padaryti'
+b'DocType: Student Admission',b'Admission Start Date',b'Pri\xc4\x97mimo prad\xc5\xbeios data'
+b'DocType: Journal Entry',b'Total Amount in Words',b'I\xc5\xa1 viso suma \xc5\xbeod\xc5\xbeiais'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29',b'New Employee',b'Naujas darbuotojas'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7',"b""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.""","b'\xc4\xaevyko klaida. Vienas tik\xc4\x97tina prie\xc5\xbeastis gali b\xc5\xabti, kad j\xc5\xabs nei\xc5\xa1saugojote form\xc4\x85. Pra\xc5\xa1ome susisiekti su support@erpnext.com jei problema i\xc5\xa1lieka.'"
+b'apps/erpnext/erpnext/templates/pages/cart.html +5',b'My Cart',b'Mano krep\xc5\xa1elis'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +130',b'Order Type must be one of {0}',b'Pavedimo tipas turi b\xc5\xabti vienas i\xc5\xa1 {0}'
+b'DocType: Lead',b'Next Contact Date',b'Kitas Kontaktin\xc4\x97 data'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36',b'Opening Qty',b'atidarymo Kiekis'
+b'DocType: Healthcare Settings',b'Appointment Reminder',b'Paskyrim\xc5\xb3 priminimas'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478',b'Please enter Account for Change Amount',b'Pra\xc5\xa1ome \xc4\xafvesti s\xc4\x85skait\xc4\x85 poky\xc4\x8dio sum\xc4\x85'
+b'DocType: Program Enrollment Tool Student',b'Student Batch Name',b'Student\xc5\xb3 Serija Vardas'
+b'DocType: Consultation',b'Doctor',b'Gydytojas'
+b'DocType: Holiday List',b'Holiday List Name',b'Atostog\xc5\xb3 s\xc4\x85ra\xc5\xa1as Vardas'
+b'DocType: Repayment Schedule',b'Balance Loan Amount',b'Balansas Paskolos suma'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14',b'Schedule Course',b'Tvarkara\xc5\xa1tis Kurso'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236',b'Stock Options',b'Akcij\xc5\xb3 pasirinkimai'
+b'DocType: Buying Settings',b'Disable Fetching Last Purchase Details in Purchase Order',b'Neleisti gauti paskutini\xc5\xb3 pirkimo duomen\xc5\xb3 pirkimo u\xc5\xbesakyme'
+b'DocType: Journal Entry Account',b'Expense Claim',b'Kompensuojamos Pretenzija'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +267',b'Do you really want to restore this scrapped asset?',b'Ar tikrai norite atstatyti \xc5\xa1\xc4\xaf metalo lau\xc5\xbe\xc4\x85 turt\xc4\x85?'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381',b'Qty for {0}',b'Kiekis d\xc4\x97l {0}'
+b'DocType: Leave Application',b'Leave Application',b'atostogos taikymas'
+b'DocType: Patient',b'Patient Relation',b'Paciento santykis'
+b'apps/erpnext/erpnext/config/hr.py +80',b'Leave Allocation Tool',b'Palikite Allocation \xc4\xafrankis'
+b'DocType: Item',b'Hub Category to Publish',b'Hub kategorija paskelbti'
+b'DocType: Leave Block List',b'Leave Block List Dates',b'Palikite blokuojam\xc5\xb3 s\xc4\x85ra\xc5\xa1\xc4\x85 Datos'
+b'DocType: Sales Invoice',b'Billing Address GSTIN',b'Atsiskaitymo adresas GSTIN'
+b'DocType: Assessment Plan',b'Evaluate',b'\xc4\xaevertinti'
+b'DocType: Workstation',b'Net Hour Rate',b'Grynasis valand\xc4\x85 grei\xc4\x8diu'
+b'DocType: Landed Cost Purchase Receipt',b'Landed Cost Purchase Receipt',b'Nusileido Kaina pirkimas gavimas'
+b'DocType: Company',b'Default Terms',b'numatytieji s\xc4\x85lygos'
+b'DocType: Supplier Scorecard Period',b'Criteria',b'Kriterijai'
+b'DocType: Packing Slip Item',b'Packing Slip Item',b'Pakavimo Kuponas punktas'
+b'DocType: Purchase Invoice',b'Cash/Bank Account',b'Pinigai / banko s\xc4\x85skaitos'
+b'apps/erpnext/erpnext/public/js/queries.js +96',b'Please specify a {0}',b'Nurodykite {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73',b'Removed items with no change in quantity or value.',"b'Pa\xc5\xa1alinti elementai, be joki\xc5\xb3 kiekio ar vert\xc4\x97s poky\xc4\x8dius.'"
+b'DocType: Delivery Note',b'Delivery To',b'Pristatyti'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +415',b'Variant creation has been queued.',b'Variant\xc5\xb3 k\xc5\xabrimas buvo eil\xc4\x97je.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +696',b'Attribute table is mandatory',b'\xc4\xaeg\xc5\xabdis lentel\xc4\x97 yra privalomi'
+b'DocType: Production Plan',b'Get Sales Orders',b'Gauk Pardavim\xc5\xb3 U\xc5\xbesakymus'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68',b'{0} can not be negative',b'{0} negali b\xc5\xabti neigiamas'
+b'DocType: Training Event',b'Self-Study',b'Savaranki\xc5\xa1kas mokymasis'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27',b'Soil compositions do not add up to 100',b'Dirvo\xc5\xbeemio kompozicijos neprideda iki 100'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558',b'Discount',b'Nuolaida'
+b'DocType: Membership',b'Membership',b'Naryst\xc4\x97'
+b'DocType: Asset',b'Total Number of Depreciations',b'Viso nuvertinimai'
+b'DocType: Sales Invoice Item',b'Rate With Margin',b'Norma atsargos'
+b'DocType: Sales Invoice Item',b'Rate With Margin',b'Norma atsargos'
+b'DocType: Workstation',b'Wages',b'u\xc5\xbemokestis'
+b'DocType: Asset Maintenance',b'Maintenance Manager Name',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros vadybininko vardas'
+b'DocType: Agriculture Task',b'Urgent',b'skubus'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174',b'Please specify a valid Row ID for row {0} in table {1}',b'Nurodykite tinkam\xc4\x85 Row ID eil\xc4\x97s {0} lentel\xc4\x97je {1}'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84',b'Unable to find variable: ',b'Ne\xc4\xafmanoma rasti kintamojo:'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +794',b'Please select a field to edit from numpad',"b'Pasirinkite lauk\xc4\x85, kur\xc4\xaf norite redaguoti i\xc5\xa1 numpad'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +264',b'Cannot be a fixed asset item as Stock Ledger is created.',"b'Negali b\xc5\xabti elementas ilgalaikio turto, kaip sukuriamas atsarg\xc5\xb3 vadovas.'"
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23',b'Go to the Desktop and start using ERPNext',b'Eiti \xc4\xaf Desktop ir prad\xc4\x97ti naudoti ERPNext'
+b'DocType: Item',b'Manufacturer',b'gamintojas'
+b'DocType: Landed Cost Item',b'Purchase Receipt Item',b'Pirkimo kvito punktas'
+b'DocType: Purchase Receipt',b'PREC-RET-',b'PREC-RET-'
+b'DocType: POS Profile',b'Sales Invoice Payment',b'Pardavim\xc5\xb3 s\xc4\x85skait\xc5\xb3 apmok\xc4\x97jimo'
+b'DocType: Quality Inspection Template',b'Quality Inspection Template Name',b'Kokyb\xc4\x97s patikrinimo \xc5\xa1ablono pavadinimas'
+b'DocType: Project',b'First Email',b'Pirmasis el. Pa\xc5\xa1tas'
+b'DocType: Production Plan Item',b'Reserved Warehouse in Sales Order / Finished Goods Warehouse',b'Reserved Sand\xc4\x97lis pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 / Finished produkcijos sand\xc4\x97lis'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71',b'Selling Amount',b'Parduodami suma'
+b'DocType: Repayment Schedule',b'Interest Amount',b'pal\xc5\xabkan\xc5\xb3 suma'
+b'DocType: Serial No',b'Creation Document No',b'K\xc5\xabrimas dokumentas Nr'
+b'DocType: Share Transfer',b'Issue',b'emisija'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11',b'Records',b'\xc4\xaera\xc5\xa1ai'
+b'DocType: Asset',b'Scrapped',b'metalo lau\xc5\xbe\xc4\x85'
+b'DocType: Purchase Invoice',b'Returns',b'gr\xc4\x85\xc5\xbeinimas'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42',b'WIP Warehouse',b'WIP sand\xc4\x97lis'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195',b'Serial No {0} is under maintenance contract upto {1}',b'Serijos Nr {0} yra pagal prie\xc5\xbei\xc5\xabros sutart\xc4\xaf net iki {1}'
+b'apps/erpnext/erpnext/config/hr.py +35',b'Recruitment',b'verbavimas'
+b'DocType: Lead',b'Organization Name',b'Organizacijos pavadinimas'
+b'DocType: Tax Rule',b'Shipping State',b'Pristatymas valstyb\xc4\x97'
+,b'Projected Quantity as Source',"b'Prognozuojama, Kiekis, kaip \xc5\xa1altin\xc4\xaf'"
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61',"b""Item must be added using 'Get Items from Purchase Receipts' button""",b'Prek\xc4\x97 turi b\xc5\xabti prid\xc4\x97ta naudojant &quot;gauti prekes nuo pirkimo kvitus&quot; mygtuk\xc4\x85'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858',b'Delivery Trip',b'Pristatymo kelion\xc4\x97'
+b'DocType: Student',b'A-',b'A-'
+b'DocType: Share Transfer',b'Transfer Type',b'Pervedimo tipas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117',b'Sales Expenses',b'pardavim\xc5\xb3 s\xc4\x85naudos'
+b'DocType: Consultation',b'Diagnosis',b'Diagnoz\xc4\x97'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18',b'Standard Buying',b'Standartin\xc4\x97 Ie\xc5\xa1ko'
+b'DocType: GL Entry',b'Against',b'prie\xc5\xa1'
+b'DocType: Item',b'Default Selling Cost Center',b'Numatytasis Parduodami Kaina centras'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +85',b'Disc',b'diskas'
+b'DocType: Sales Partner',b'Implementation Partner',b'\xc4\xafgyvendinimas partneriu'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1624',b'ZIP Code',b'Pa\xc5\xa1to kodas'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +252',b'Sales Order {0} is {1}',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 {0} yra {1}'
+b'DocType: Opportunity',b'Contact Info',b'Kontaktin\xc4\x97 informacija'
+b'apps/erpnext/erpnext/config/stock.py +319',b'Making Stock Entries',b'Padaryti atsarg\xc5\xb3 papildymams'
+b'DocType: Packing Slip',b'Net Weight UOM',b'Grynasis svoris UOM'
+b'DocType: Item',b'Default Supplier',b'numatytasis Tiek\xc4\x97jas'
+b'DocType: Manufacturing Settings',b'Over Production Allowance Percentage',b'Per Gamybos pa\xc5\xa1alp\xc5\xb3 procentin\xc4\x97 dalis'
+b'DocType: Employee Loan',b'Repayment Schedule',b'gr\xc4\x85\xc5\xbeinimo grafikas'
+b'DocType: Shipping Rule Condition',b'Shipping Rule Condition',b'Gamykliniai nustatymai taisykl\xc4\x97'
+b'DocType: Holiday List',b'Get Weekly Off Dates',b'Gauk Savaitinis Off Datos'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33',b'End Date can not be less than Start Date',b'Pabaigos data negali b\xc5\xabti ma\xc5\xbeesn\xc4\x97 negu prad\xc5\xbeios data'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337',"b""Invoice can't be made for zero billing hour""",b'S\xc4\x85skait\xc4\x85 fakt\xc5\xabr\xc4\x85 atlikti negalima u\xc5\xbe nulin\xc4\x99 atsiskaitymo valand\xc4\x85'
+b'DocType: Sales Person',b'Select company name first.',b'Pasirinkite \xc4\xafmon\xc4\x97s pavadinimas pirmas.'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189',b'Email sent to {0}',b'El. Lai\xc5\xa1kas i\xc5\xa1si\xc5\xb3stas {0}'
+b'apps/erpnext/erpnext/config/buying.py +23',b'Quotations received from Suppliers.',"b'Citatos, gaut\xc5\xb3 i\xc5\xa1 tiek\xc4\x97j\xc5\xb3.'"
+b'apps/erpnext/erpnext/config/manufacturing.py +74',b'Replace BOM and update latest price in all BOMs',b'Pakeiskite BOM ir atnaujinkite naujausi\xc4\x85 kain\xc4\x85 visose BOM'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +27',b'To {0} | {1} {2}',b'Nor\xc4\x97dami {0} | {1} {2}'
+b'DocType: Delivery Trip',b'Driver Name',b'Vairuotojo vardas'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40',b'Average Age',b'Vidutinis am\xc5\xbeius'
+b'DocType: Education Settings',b'Attendance Freeze Date',b'Lankomumas nuo u\xc5\xbe\xc5\xa1alimo data'
+b'DocType: Education Settings',b'Attendance Freeze Date',b'Lankomumas nuo u\xc5\xbe\xc5\xa1alimo data'
+b'apps/erpnext/erpnext/utilities/user_progress.py +110',b'List a few of your suppliers. They could be organizations or individuals.',b'S\xc4\x85ra\xc5\xa1as kelet\xc4\x85 savo tiek\xc4\x97jais. Jie gali b\xc5\xabti organizacijos ar asmenys.'
+b'apps/erpnext/erpnext/templates/pages/home.html +31',b'View All Products',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti visus produktus'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimalus \xc5\xa0vinas Am\xc5\xbeius (dienomis)'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimalus \xc5\xa0vinas Am\xc5\xbeius (dienomis)'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60',b'All BOMs',b'Visi BOMs'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35',b'Hotel Rooms of type {0} are unavailable on {1}',b'Vie\xc5\xa1bu\xc4\x8dio kambario tipo {0} negalima {1}'
+b'DocType: Patient',b'Default Currency',b'Pirmin\xc4\x97 kainora\xc5\xa1\xc4\x8dio valiuta'
+b'DocType: Expense Claim',b'From Employee',b'i\xc5\xa1 darbuotojo'
+b'DocType: Driver',b'Cellphone Number',b'Mobiliojo telefono numeris'
+b'DocType: Project',b'Monitor Progress',b'Steb\xc4\x97ti progres\xc4\x85'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +472',b'Warning: System will not check overbilling since amount for Item {0} in {1} is zero',"b'\xc4\xaesp\xc4\x97jimas: sistema netikrins per dideli\xc5\xb3 s\xc4\x85skait\xc5\xb3, nes suma u\xc5\xbe prek\xc4\x99 {0} i\xc5\xa1 {1} yra lygus nuliui'"
+b'DocType: Journal Entry',b'Make Difference Entry',b'Padaryti Skirtumas \xc4\xafra\xc5\xa1\xc4\x85'
+b'DocType: Upload Attendance',b'Attendance From Date',b'Lankomumas Nuo data'
+b'DocType: Appraisal Template Goal',b'Key Performance Area',b'Pagrindiniai veiklos sritis'
+b'DocType: Program Enrollment',b'Transportation',b'Transportavimas'
+b'apps/erpnext/erpnext/controllers/item_variant.py +94',b'Invalid Attribute',b'Neteisingas \xc4\xaeg\xc5\xabdis'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240',b'{0} {1} must be submitted',b'{0} {1} turi b\xc5\xabti pateiktas'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159',b'Quantity must be less than or equal to {0}',b'Kiekis turi b\xc5\xabti ma\xc5\xbeesnis arba lygus {0}'
+b'DocType: SMS Center',b'Total Characters',b'I\xc5\xa1 viso Veik\xc4\x97jai'
+b'DocType: Employee Advance',b'Claimed',b'Pateikta pretenzija'
+b'DocType: Crop',b'Row Spacing',b'Eilu\xc4\x8di\xc5\xb3 tarpas'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +164',b'Please select BOM in BOM field for Item {0}',b'Pra\xc5\xa1ome pasirinkti BOM BOM \xc4\xaf lauk\xc4\x85 punkte {0}'
+b'DocType: C-Form Invoice Detail',b'C-Form Invoice Detail',b'C-formos s\xc4\x85skaita fakt\xc5\xabra detal\xc4\x97s'
+b'DocType: Payment Reconciliation Invoice',b'Payment Reconciliation Invoice',b'Mok\xc4\x97jimo Susitaikymas S\xc4\x85skaita'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38',b'Contribution %',b'ind\xc4\x97lis%'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215',"b""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}""","b'Kaip u\xc5\xbe pirkimo parametrus, jei pirkimas \xc4\xafsakymu Reikalinga == &quot;Taip&quot;, tada sukurti s\xc4\x85skait\xc4\x85-fakt\xc5\xabr\xc4\x85, vartotojo pirmiausia reikia sukurti pirkini\xc5\xb3 u\xc5\xbesakym\xc4\x85 u\xc5\xbe prek\xc4\x99 {0}'"
+b'DocType: Company',b'Company registration numbers for your reference. Tax numbers etc.',b'\xc4\xaemon\xc4\x97s registracijos numeriai j\xc5\xabs\xc5\xb3 nuoroda. Mokes\xc4\x8di\xc5\xb3 numeriai ir kt'
+b'DocType: Sales Partner',b'Distributor',b'skirstytuvas'
+b'DocType: Shopping Cart Shipping Rule',b'Shopping Cart Shipping Rule',b'Krep\xc5\xa1elis Pristatymas taisykl\xc4\x97'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +71',"b""Please set 'Apply Additional Discount On'""",b'Pra\xc5\xa1ome nustatyti &quot;Taikyti papildom\xc4\x85 nuolaid\xc4\x85 On&quot;'
+,b'Ordered Items To Be Billed',b'U\xc5\xbesakytas prekes Nor\xc4\x97dami b\xc5\xabti mokami'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46',b'From Range has to be less than To Range',b'I\xc5\xa1 klas\xc4\x97s turi b\xc5\xabti ma\xc5\xbeesnis nei svyruoja'
+b'DocType: Global Defaults',b'Global Defaults',b'Global Numatytasis'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +230',b'Project Collaboration Invitation',b'Projekt\xc5\xb3 Bendradarbiavimas Kvietimas'
+b'DocType: Salary Slip',b'Deductions',b'atskaitymai'
+b'DocType: Leave Allocation',b'LAL/',b'LAL /'
+b'DocType: Setup Progress Action',b'Action Name',b'Veiksmo pavadinimas'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +75',b'Start Year',b'prad\xc5\xbeios metus'
+b'apps/erpnext/erpnext/regional/india/utils.py +25',b'First 2 digits of GSTIN should match with State number {0}',b'Pirmieji 2 skaitmenys GSTIN turi sutapti su Valstybinio numerio {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68',b'PDC/LC',b'PDC / LC'
+b'DocType: Purchase Invoice',"b""Start date of current invoice's period""",b'Prad\xc5\xbeios data einam\xc5\xb3j\xc5\xb3 s\xc4\x85skaitos fakt\xc5\xabros laikotarp\xc4\xaf'
+b'DocType: Salary Slip',b'Leave Without Pay',b'Palikite be darbo u\xc5\xbemokes\xc4\x8dio'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385',b'Capacity Planning Error',b'Talpa planavimas Klaida'
+,b'Trial Balance for Party',b'Bandomoji likutis partijos'
+b'DocType: Lead',b'Consultant',b'konsultantas'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356',b'Parents Teacher Meeting Attendance',b'T\xc4\x97v\xc5\xb3 mokytoj\xc5\xb3 susitikim\xc5\xb3 lankymas'
+b'DocType: Salary Slip',b'Earnings',b'Pajamos'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +441',b'Finished Item {0} must be entered for Manufacture type entry',b'Baig\xc4\x97 punktas {0} reikia \xc4\xafvesti Gamyba tipo \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/config/learn.py +87',b'Opening Accounting Balance',b'Atidarymo Apskaitos balansas'
+,b'GST Sales Register',"b'Paai\xc5\xa1k\xc4\x97jo, kad GST Pardavim\xc5\xb3 Registruotis'"
+b'DocType: Sales Invoice Advance',b'Sales Invoice Advance',b'Pardavim\xc5\xb3 s\xc4\x85skaita fakt\xc5\xabra I\xc5\xa1ankstinis'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552',b'Nothing to request',b'Nieko pra\xc5\xa1yti'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +18',b'Select your Domains',b'Pasirinkite savo domenus'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34',"b""Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3}""",b'Kitas Biud\xc5\xbeeto \xc4\xafra\xc5\xa1as &#39;{0} &quot;jau egzistuoja nuo {1} {2}&quot; fiskalinio met\xc5\xb3 {3}'
+b'DocType: Item Variant Settings',b'Fields will be copied over only at time of creation.',b'Laukai bus kopijuojami tik k\xc5\xabrimo metu.'
+b'DocType: Setup Progress Action',b'Domains',b'Domenai'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +41',"b""'Actual Start Date' can not be greater than 'Actual End Date'""","b""'Prad\xc5\xbeios data' negali b\xc5\xabti didesn\xc4\x97 nei \n'Pabaigos data'"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117',b'Management',b'valdymas'
+b'DocType: Cheque Print Template',b'Payer Settings',b'mok\xc4\x97tojo Nustatymai'
+b'DocType: Item Attribute Value',"b'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""'","b'Tai bus prid\xc4\x97tas prie elemento kodekso variante. Pavyzd\xc5\xbeiui, jei j\xc5\xabs\xc5\xb3 santrumpa yra &quot;S.&quot;, o prek\xc4\x97s kodas yra T-shirt &quot;, elementas kodas variantas bus&quot; T-shirt-SM &quot;'"
+b'DocType: Salary Slip',b'Net Pay (in words) will be visible once you save the Salary Slip.',"b'Neto darbo u\xc5\xbemokestis (\xc5\xbeod\xc5\xbeiais) bus matomas, kai jums sutaupyti darbo u\xc5\xbemokest\xc4\xaf.'"
+b'DocType: Purchase Invoice',b'Is Return',b'Ar Gr\xc4\xaf\xc5\xbeti'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',b'Caution',b'Atsargiai'
+b'apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17',"b""Start day is greater than end day in task '{0}'""",b'Prad\xc5\xbeios diena yra didesn\xc4\x97 nei pabaigos diena u\xc5\xbeduo\xc4\x8diai &quot;{0}&quot;'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815',b'Return / Debit Note',b'Preki\xc5\xb3 gr\xc4\x85\xc5\xbeinimas / debeto aviza'
+b'DocType: Price List Country',b'Price List Country',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as \xc5\xa0alis'
+b'DocType: Item',b'UOMs',b'UOMs'
+b'apps/erpnext/erpnext/stock/utils.py +212',b'{0} valid serial nos for Item {1}',b'{0} galioja eil\xc4\x97s numeriai u\xc5\xbe prek\xc4\x99 {1}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57',b'Item Code cannot be changed for Serial No.',b'Prek\xc4\x97s kodas negali b\xc5\xabti kei\xc4\x8diamas Serial No.'
+b'DocType: Purchase Invoice Item',b'UOM Conversion Factor',b'UOM konversijos faktorius'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40',b'Please enter Item Code to get Batch Number',b'Pra\xc5\xa1ome \xc4\xafvesti Prek\xc4\x97s kodas gauti SERIJOS NUMERIS'
+b'DocType: Stock Settings',b'Default Item Group',b'Numatytasis Elementas Grup\xc4\x97'
+b'DocType: Employee Loan',b'Partially Disbursed',b'dalinai I\xc5\xa1mok\xc4\x97ta'
+b'apps/erpnext/erpnext/config/non_profit.py +73',b'Grant information.',b'Informacija apie dotacij\xc4\x85.'
+b'apps/erpnext/erpnext/config/buying.py +38',b'Supplier database.',b'Tiek\xc4\x97jas duomen\xc5\xb3 baz\xc4\x99.'
+b'DocType: Account',b'Balance Sheet',b'Balanso lapas'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750',"b""Cost Center For Item with Item Code '""",b'Kainuos centras u\xc5\xbe prek\xc4\x99 su Prek\xc4\x97s kodas &quot;'
+b'DocType: Fee Validity',b'Valid Till',b'Galioja iki'
+b'DocType: Student Report Generation Tool',b'Total Parents Teacher Meeting',b'Viso t\xc4\x97v\xc5\xb3 mokytoj\xc5\xb3 susitikimas'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2516',"b'Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.'","b'Mok\xc4\x97jimo b\xc5\xabdas yra neu\xc5\xbepild\xc4\x97. Pra\xc5\xa1ome patikrinti, ar s\xc4\x85skaita buvo nustatytas mok\xc4\x97jim\xc5\xb3 Mode arba POS profilis.'"
+b'apps/erpnext/erpnext/buying/utils.py +74',b'Same item cannot be entered multiple times.',b'Tas pats daiktas negali b\xc5\xabti \xc4\xafra\xc5\xa1ytas kelis kartus.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30',"b'Further accounts can be made under Groups, but entries can be made against non-Groups'","b'Daugiau s\xc4\x85skaitos gali b\xc5\xabti grup\xc4\x97se, ta\xc4\x8diau \xc4\xafra\xc5\xa1ai gali b\xc5\xabti pareik\xc5\xa1tas ne grup\xc4\x97s'"
+b'DocType: Lead',b'Lead',b'Vadovauti'
+b'DocType: Email Digest',b'Payables',b'Mok\xc4\x97tinos sumos'
+b'DocType: Course',b'Course Intro',b'\xc5\xbdinoma \xc4\xaevadas'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +105',b'Stock Entry {0} created',"b'Atsarg\xc5\xb3, {0} suk\xc5\xabr\xc4\x97'"
+b'apps/erpnext/erpnext/controllers/buying_controller.py +306',b'Row #{0}: Rejected Qty can not be entered in Purchase Return',b'Eilut\xc4\x97s # {0}: Atmesta Kiekis negali b\xc5\xabti \xc4\xafra\xc5\xa1ytas \xc4\xaf pirkimo Gr\xc4\xaf\xc5\xbeti'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +182',b'Changing Customer Group for the selected Customer is not allowed.',b'Kliento grup\xc4\x97s keitimas pasirinktam Klientui yra draud\xc5\xbeiamas.'
+,b'Purchase Order Items To Be Billed',b'Pirkimui u\xc5\xbesakyti klausimai turi b\xc5\xabti apmokestinama'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63',b'Updating estimated arrival times.',b'Atnaujintas numatomas atvykimo laikas.'
+b'DocType: Program Enrollment Tool',b'Enrollment Details',b'Registracijos duomenys'
+b'DocType: Purchase Invoice Item',b'Net Rate',b'grynasis Balsuok'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152',b'Please select a customer',b'Pasirinkite klient\xc4\x85'
+b'DocType: Purchase Invoice Item',b'Purchase Invoice Item',b'Pirkimo fakt\xc5\xabros Element\xc4\x85'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58',b'Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts',b'Akcij\xc5\xb3 Ledgeris \xc4\xaera\xc5\xa1ai ir GL \xc4\xaera\xc5\xa1ai pakartotinai paskelbtas kur nors pasirinkt\xc5\xb3 \xc4\xafsigijimo kvitai'
+b'DocType: Student Report Generation Tool',b'Assessment Terms',b'Vertinimo s\xc4\x85lygos'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8',b'Item 1',b'1 punktas'
+b'DocType: Holiday',b'Holiday',b'atostog\xc5\xb3'
+b'DocType: Support Settings',b'Close Issue After Days',b'U\xc5\xbedaryti i\xc5\xa1davimas Po dienos'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all branches',"b'Palikite tu\xc5\xa1\xc4\x8di\xc4\x85, jei laikomas vis\xc5\xb3 \xc5\xa1ak\xc5\xb3'"
+b'DocType: Bank Guarantee',b'Validity in Days',b'Galiojimas dienomis'
+b'DocType: Bank Guarantee',b'Validity in Days',b'Galiojimas dienomis'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21',b'C-form is not applicable for Invoice: {0}',b'C-formos netaikoma S\xc4\x85skaita: {0}'
+b'DocType: Payment Reconciliation',b'Unreconciled Payment Details',b'Unreconciled Mok\xc4\x97jimo informacija'
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6',b'Member Activity',b'Nario veikla'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'U\xc5\xbesakyti Grafas'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'U\xc5\xbesakyti Grafas'
+b'DocType: Global Defaults',b'Current Fiscal Year',b'Einamuosius fiskalinius metus'
+b'DocType: Purchase Order',b'Group same items',b'Grup\xc4\x97 pa\xc4\x8di\xc5\xb3 daikt\xc5\xb3'
+b'DocType: Purchase Invoice',b'Disable Rounded Total',b'I\xc5\xa1jungti Apvalus I\xc5\xa1 viso'
+b'DocType: Employee Loan Application',b'Repayment Info',b'gr\xc4\x85\xc5\xbeinimas Informacija'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448',"b""'Entries' cannot be empty""",b'&quot;\xc4\xaera\xc5\xa1ai&quot; negali b\xc5\xabti tu\xc5\xa1\xc4\x8dias'
+b'DocType: Maintenance Team Member',b'Maintenance Role',b'Prie\xc5\xbei\xc5\xabros vaidmuo'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +92',b'Duplicate row {0} with same {1}',b'Dubliuoti eilut\xc4\x97 {0} su tuo pa\xc4\x8diu {1}'
+,b'Trial Balance',b'bandomasis balansas'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443',b'Fiscal Year {0} not found',b'Finansiniai metai {0} nerastas'
+b'apps/erpnext/erpnext/config/hr.py +309',b'Setting up Employees',b'\xc4\xaesteigti Darbuotojai'
+b'DocType: Sales Order',b'SO-',b'SO'
+b'DocType: Hotel Room Reservation',b'Hotel Reservation User',b'Vie\xc5\xa1bu\xc4\x8di\xc5\xb3 rezervavimo vartotojas'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158',b'Please select prefix first',b'Pra\xc5\xa1ome pasirinkti prefiks\xc4\x85 pirmas'
+b'DocType: Student',b'O-',b'O-'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189',b'Research',b'tyrimas'
+b'DocType: Maintenance Visit Purpose',b'Work Done',b'Darbas pabaigtas'
+b'apps/erpnext/erpnext/controllers/item_variant.py +35',b'Please specify at least one attribute in the Attributes table',b'Pra\xc5\xa1ome nurodyti bent vien\xc4\x85 atribut\xc4\x85 Atribut\xc5\xb3 lentel\xc4\x97s'
+b'DocType: Announcement',b'All Students',b'Visi studentai'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +45',b'Item {0} must be a non-stock item',b'Prek\xc4\x97 {0} turi b\xc5\xabti ne akcij\xc5\xb3 punktas'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +18',b'View Ledger',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti Ledgeris'
+b'DocType: Grading Scale',b'Intervals',b'intervalai'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Earliest',b'Seniausi'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +526',"b'An Item Group exists with same name, please change the item name or rename the item group'","b'Prek\xc4\x99 grup\xc4\x97 egzistuoja to paties pavadinimo, pra\xc5\xa1om pakeisti element\xc4\x85 vard\xc4\x85 ar pervardyti element\xc4\x85 grup\xc4\x99'"
+b'DocType: Crop Cycle',b'Less than a year',b'Ma\xc5\xbeiau nei metus'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52',b'Student Mobile No.',b'Student\xc5\xb3 Mobilus Ne'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105',b'Rest Of The World',b'Lik\xc4\x99s pasaulis'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81',b'The Item {0} cannot have Batch',b'Naudodami {0} punktas negali tur\xc4\x97ti Serija'
+b'DocType: Crop',b'Yield UOM',b'I\xc5\xa1eiga UOM'
+,b'Budget Variance Report',b'Biud\xc5\xbeeto Dispersija ataskaita'
+b'DocType: Salary Slip',b'Gross Pay',b'Pilna Mok\xc4\x97ti'
+b'DocType: Item',b'Is Item from Hub',b'Ar prek\xc4\x97 i\xc5\xa1 centro'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118',b'Row {0}: Activity Type is mandatory.',b'Eilut\xc4\x97s {0}: veiklos r\xc5\xab\xc5\xa1is yra privalomas.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166',b'Dividends Paid',b'Dividendai'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36',b'Accounting Ledger',b'apskaitos Ledgeris'
+b'DocType: Stock Reconciliation',b'Difference Amount',b'skirtumas suma'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107',b'Dr {0} on Leave on {1}',b'Dr {0} paliktas {1}'
+b'DocType: Purchase Invoice',b'Reverse Charge',b'Atvirk\xc5\xa1tinio apmokestinimo'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172',b'Retained Earnings',b'Nepaskirstytasis pelnas'
+b'DocType: Purchase Invoice',b'05-Change in POS',b'05 pakeitimas POS'
+b'DocType: Vehicle Log',b'Service Detail',b'Paslaug\xc5\xb3 detal\xc4\x97s'
+b'DocType: BOM',b'Item Description',b'Prek\xc4\x97s Apra\xc5\xa1ymas'
+b'DocType: Student Sibling',b'Student Sibling',b'Student\xc5\xb3 giminyst\xc4\x97s'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18',b'Payment Mode',b'Mok\xc4\x97jimo b\xc5\xabdas'
+b'DocType: Purchase Invoice',b'Supplied Items',"b'preki\xc5\xb3 tiekimu,'"
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85',b'Please set an active menu for Restaurant {0}',b'Nustatykite aktyv\xc5\xb3 Restorano {0} meniu'
+b'DocType: Student',b'STUD.',b'Stud.'
+b'DocType: Work Order',b'Qty To Manufacture',b'Kiekis gaminti'
+b'DocType: Email Digest',b'New Income',b'nauja pajamos'
+b'DocType: Buying Settings',b'Maintain same rate throughout purchase cycle',b'I\xc5\xa1laikyti t\xc4\x85 pat\xc4\xaf tarif\xc4\x85 visoje pirkimo ciklo'
+b'DocType: Opportunity Item',b'Opportunity Item',b'galimyb\xc4\x97 punktas'
+,b'Student and Guardian Contact Details',b'Student\xc5\xb3 ir glob\xc4\x97jas Kontaktin\xc4\x97 informacija'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53',b'Row {0}: For supplier {0} Email Address is required to send email',b'Eilut\xc4\x97s {0}: D\xc4\x97l tiek\xc4\x97jo {0} el.pa\xc5\xa1to adresas yra reikalingi si\xc5\xb3sti lai\xc5\xa1k\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72',b'Temporary Opening',b'laikinas atidarymas'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10',b'View Hub',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti centru'
+,b'Employee Leave Balance',b'Darbuotoj\xc5\xb3 atostogos balansas'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147',b'Balance for Account {0} must always be {1}',b'Likutis s\xc4\x85skaitoje {0} visada turi b\xc5\xabti {1}'
+b'DocType: Patient Appointment',b'More Info',b'Daugiau informacijos'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180',b'Valuation Rate required for Item in row {0}',"b'Vertinimo tarifas, kurio reikia u\xc5\xbe prek\xc4\x99 i\xc5\xa1 eil\xc4\x97s {0}'"
+b'DocType: Supplier Scorecard',b'Scorecard Actions',b'Rezultat\xc5\xb3 kortel\xc4\x97s veiksmai'
+b'apps/erpnext/erpnext/utilities/user_progress.py +169',b'Example: Masters in Computer Science',b'Pavyzdys: magistro Computer Science'
+b'DocType: Purchase Invoice',b'Rejected Warehouse',b'atmesta sand\xc4\x97lis'
+b'DocType: GL Entry',b'Against Voucher',b'prie\xc5\xa1 kupono'
+b'DocType: Item',b'Default Buying Cost Center',b'Numatytasis Ie\xc5\xa1ko kaina centras'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6',"b'To get the best out of ERPNext, we recommend that you take some time and watch these help videos.'","b'Nor\xc4\x97dami gauti geriausi\xc4\x85 i\xc5\xa1 ERPNext, mes rekomenduojame, kad j\xc5\xabs \xc5\xa1iek tiek laiko ir \xc5\xbei\xc5\xabr\xc4\x97ti \xc5\xa1iuos pagalbos video.'"
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +76',b' to ',b'\xc4\xaf'
+b'DocType: Supplier Quotation Item',b'Lead Time in days',b'\xc5\xa0vinas Laikas dien\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70',b'Accounts Payable Summary',b'Mok\xc4\x97tinos sumos Santrauka'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326',b'Payment of salary from {0} to {1}',b'Apmok\xc4\x97jimas algos nuo {0} ir {1}'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213',b'Not authorized to edit frozen Account {0}',b'Neregistruota redaguoti \xc4\xaf\xc5\xa1aldyt\xc4\x85 s\xc4\x85skait\xc4\x85 {0}'
+b'DocType: Journal Entry',b'Get Outstanding Invoices',b'Gauk neapmok\xc4\x97t\xc5\xb3 s\xc4\x85skait\xc5\xb3 fakt\xc5\xabr\xc5\xb3'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84',b'Sales Order {0} is not valid',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 {0} negalioja'
+b'DocType: Supplier Scorecard',b'Warn for new Request for Quotations',b'\xc4\xaesp\xc4\x97ti apie nauj\xc4\x85 pra\xc5\xa1ym\xc4\x85 d\xc4\x97l pasi\xc5\xablym\xc5\xb3'
+b'apps/erpnext/erpnext/utilities/activation.py +91',b'Purchase orders help you plan and follow up on your purchases',b'Pirkimo pavedimai pad\xc4\x97s jums planuoti ir sekti savo pirkim\xc5\xb3'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151',b'Lab Test Prescriptions',b'Lab testo rekvizitai'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166',b'The total Issue / Transfer quantity {0} in Material Request {1}  \\\n\t\t\t\t\t\t\tcannot be greater than requested quantity {2} for Item {3}',b'Bendras i\xc5\xa1davimas / Perve\xc5\xbeimas kiekis {0} Krovimas U\xc5\xbesisakyti {1} \\ negali b\xc5\xabti didesnis nei pra\xc5\xa1omo kiekio {2} u\xc5\xbe prek\xc4\x99 {3}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197',b'Small',b'ma\xc5\xbeas'
+b'DocType: Opening Invoice Creation Tool Item',b'Opening Invoice Creation Tool Item',b'S\xc4\x85skait\xc5\xb3 fakt\xc5\xabr\xc5\xb3 k\xc5\xabrimo \xc4\xafrankio atidarymas'
+b'DocType: Education Settings',b'Employee Number',b'Darbuotojo numeris'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67',b'Case No(s) already in use. Try from Case No {0}',b'Byloje Nr (-ai) jau naudojamas. Pabandykite i\xc5\xa1 byloje Nr {0}'
+b'DocType: Project',b'% Completed',b'% Baigtas'
+,b'Invoiced Amount (Exculsive Tax)',b'S\xc4\x85skaitoje suma (Exculsive Mokes\xc4\x8di\xc5\xb3)'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14',b'Item 2',b'2 punktas'
+b'DocType: Supplier',b'SUPP-',b'maitinimo i\xc5\xa1 tinklo laidas'
+b'DocType: Training Event',b'Training Event',b'Kvalifikacijos tobulinimo renginys'
+b'DocType: Item',b'Auto re-order',b'Auto naujo u\xc5\xbesakymas'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59',b'Total Achieved',b'I\xc5\xa1 viso Pasiektas'
+b'DocType: Employee',b'Place of Issue',b'I\xc5\xa1davimo vieta'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101',b'Contract',b'sutartis'
+b'DocType: Plant Analysis',b'Laboratory Testing Datetime',b'Laboratorijos bandymo data laikas'
+b'DocType: Email Digest',b'Add Quote',b'Prid\xc4\x97ti Citata'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +987',b'UOM coversion factor required for UOM: {0} in Item: {1}',b'UOM coversion faktorius reikalingas UOM: {0} prek\xc4\x97s: {1}'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92',b'Indirect Expenses',b'netiesiogin\xc4\x97s i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98',b'Row {0}: Qty is mandatory',b'Eilut\xc4\x97s {0}: Kiekis yra privalomi'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture',b'\xc5\xbdemdirbyst\xc4\x97'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +794',b'Sync Master Data',b'Sinchronizavimo Master Data'
+b'DocType: Asset Repair',b'Repair Cost',b'Remonto kaina'
+b'apps/erpnext/erpnext/utilities/user_progress.py +138',b'Your Products or Services',b'Savo produktus ar paslaugas'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15',b'Failed to login',b'Nepavyko prisijungti'
+b'DocType: Special Test Items',b'Special Test Items',b'Special\xc5\xabs testo elementai'
+b'DocType: Mode of Payment',b'Mode of Payment',b'mok\xc4\x97jimo b\xc5\xabdas'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +202',b'Website Image should be a public file or website URL',b'Interneto svetain\xc4\x97 Paveiksl\xc4\x97lis tur\xc4\x97t\xc5\xb3 b\xc5\xabti valstyb\xc4\x97s fail\xc4\x85 ar svetain\xc4\x97s URL'
+b'DocType: Student Applicant',b'AP',b'A.'
+b'DocType: Purchase Invoice Item',b'BOM',b'BOM'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37',b'This is a root item group and cannot be edited.',b'Tai yra \xc5\xa1aknis punktas grup\xc4\x97 ir negali b\xc5\xabti pakeisti.'
+b'DocType: Journal Entry Account',b'Purchase Order',b'Pirkimo u\xc5\xbesakymas'
+b'DocType: Vehicle',b'Fuel UOM',b'kuro UOM'
+b'DocType: Warehouse',b'Warehouse Contact Info',b'Sand\xc4\x97li\xc5\xb3 Kontaktin\xc4\x97 informacija'
+b'DocType: Payment Entry',b'Write Off Difference Amount',b'Nura\xc5\xa1yti skirtumo suma'
+b'DocType: Volunteer',b'Volunteer Name',b'Savanorio vardas'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434',"b'{0}: Employee email not found, hence email not sent'","b'{0}: Darbuotoj\xc5\xb3 elektroninis pa\xc5\xa1tas nerastas, tod\xc4\x97l elektroninis lai\xc5\xa1kas nei\xc5\xa1si\xc5\xb3stas'"
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85',b'Shipping rule not applicable for country {0}',b'Pristatymo taisykl\xc4\x97 netaikoma \xc5\xa1aliai {0}'
+b'DocType: Item',b'Foreign Trade Details',b'U\xc5\xbesienio prekybos informacija'
+,b'Assessment Plan Status',b'Vertinimo plano b\xc5\xabsena'
+b'DocType: Email Digest',b'Annual Income',b'Metin\xc4\x97s pajamos'
+b'DocType: Serial No',b'Serial No Details',b'Serijos Nr detal\xc4\x97s'
+b'DocType: Purchase Invoice Item',b'Item Tax Rate',b'Prek\xc4\x97 Mokes\xc4\x8dio tarifas'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89',b'Please select Physician and Date',b'Pasirinkite gydytoj\xc4\x85 ir dat\xc4\x85'
+b'DocType: Student Group Student',b'Group Roll Number',b'Grup\xc4\x97 sal\xc4\x97 Ta\xc5\xa1k\xc5\xb3'
+b'DocType: Student Group Student',b'Group Roll Number',b'Grup\xc4\x97 sal\xc4\x97 Ta\xc5\xa1k\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145',"b'For {0}, only credit accounts can be linked against another debit entry'",b'D\xc4\x97l {0} tik kredito s\xc4\x85skaitos gali b\xc5\xabti susij\xc4\x99s su kitos debeto \xc4\xafra\xc5\xa1\xc4\x85'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +84',b'Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly',b'Bendras vis\xc5\xb3 u\xc5\xbeduo\xc4\x8di\xc5\xb3 svoriai tur\xc4\x97t\xc5\xb3 b\xc5\xabti 1. Pra\xc5\xa1ome reguliuoti svareliai vis\xc5\xb3 projekto u\xc5\xbeduotis atitinkamai'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588',b'Delivery Note {0} is not submitted',b'Va\xc5\xbetara\xc5\xa1tis {0} nebus pateiktas'
+b'apps/erpnext/erpnext/stock/get_item_details.py +148',b'Item {0} must be a Sub-contracted Item',b'Prek\xc4\x97 {0} turi b\xc5\xabti Prek\xc4\x97 pagal subrangos sutartis'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43',b'Capital Equipments',b'kapitalo \xc4\xafranga'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33',"b""Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.""","b'Kainodaros taisykl\xc4\x97 pirmiausia atrenkami remiantis &quot;Taikyti&quot; srityje, kuris gali b\xc5\xabti punktas, punktas Grup\xc4\x97 ar prek\xc4\x97s \xc5\xbeenkl\xc4\x85.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246',b'Please set the Item Code first',b'Pirmiausia nustatykite elemento kod\xc4\x85'
+b'DocType: Item',b'ITEM-',b'item-'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +123',b'Total allocated percentage for sales team should be 100',b'I\xc5\xa1 viso skyr\xc4\x97 procentas pardavim\xc5\xb3 vadybininkas turi b\xc5\xabti 100'
+b'DocType: Sales Invoice Item',b'Edit Description',b'Redaguoti Apra\xc5\xa1ymas'
+b'DocType: Antibiotic',b'Antibiotic',b'Antibiotikas'
+,b'Team Updates',b'komanda Atnaujinimai'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912',b'For Supplier',b'tiek\xc4\x97jas'
+b'DocType: Account',b'Setting Account Type helps in selecting this Account in transactions.',"b'Nustatymas s\xc4\x85skaitos r\xc5\xab\xc5\xa1is, padedanti renkantis \xc5\xa1\xc4\xaf Naryst\xc4\x97 sandoriuose.'"
+b'DocType: Purchase Invoice',b'Grand Total (Company Currency)',b'Bendra suma (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Create Print Format',b'Sukurti Spausdinti formatas'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5',b'Fee Created',b'Sukurtas mokestis'
+b'apps/erpnext/erpnext/utilities/bot.py +39',b'Did not find any item called {0}',"b'Neradote bet kur\xc4\xaf element\xc4\x85, vadinam\xc4\x85 {0}'"
+b'DocType: Supplier Scorecard Criteria',b'Criteria Formula',b'Kriterij\xc5\xb3 formul\xc4\x97'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Total Outgoing',b'I\xc5\xa1 viso Siun\xc4\x8diami'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39',"b'There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""'",b'Gali b\xc5\xabti tik vienas Pristatymas taisykl\xc4\x97 B\xc5\xabkl\xc4\x97 0 arba tu\xc5\xa1\xc4\x8di\xc4\x85 vert\xc4\x97s &quot;vert\xc4\x97&quot;'
+b'DocType: Authorization Rule',b'Transaction',b'sandoris'
+b'DocType: Patient Appointment',b'Duration',b'Trukm\xc4\x97'
+b'apps/erpnext/erpnext/controllers/status_updater.py +160',"b'For an item {0}, quantity must be positive number'",b'Prek\xc4\x97s {0} atveju kiekis turi b\xc5\xabti teigiamas'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27',b'Note: This Cost Center is a Group. Cannot make accounting entries against groups.',b'Pastaba: \xc5\xa0i kaina centras yra grup\xc4\x97. Negali padaryti apskaitos \xc4\xafra\xc5\xa1us pagal grupes.'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53',b'Child warehouse exists for this warehouse. You can not delete this warehouse.',b'Vaik\xc5\xb3 sand\xc4\x97lis egzistuoja \xc5\xa1iame sand\xc4\x97lyje. J\xc5\xabs negalite trinti \xc5\xa1\xc4\xaf sand\xc4\x97l\xc4\xaf.'
+b'DocType: Item',b'Website Item Groups',b'Interneto svetain\xc4\x97 punktas Grup\xc4\x97s'
+b'DocType: Purchase Invoice',b'Total (Company Currency)',b'I\xc5\xa1 viso (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Daily Work Summary Group',b'Reminder',b'Priminimas'
+b'apps/erpnext/erpnext/stock/utils.py +207',b'Serial number {0} entered more than once',b'Serijos numeris {0} \xc4\xafvesta daugiau nei vien\xc4\x85 kart\xc4\x85'
+b'DocType: Journal Entry',b'Journal Entry',b'\xc5\xbeurnalo \xc4\xafra\xc5\xa1\xc4\x85'
+b'DocType: Expense Claim Advance',b'Unclaimed amount',b'Nepra\xc5\xa1yta suma'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148',b'{0} items in progress',b'{0} element\xc5\xb3 pa\xc5\xbeang\xc4\x85'
+b'DocType: Workstation',b'Workstation Name',b'Kompiuterizuotos darbo vietos Vardas'
+b'DocType: Grading Scale Interval',b'Grade Code',b'\xc4\xaevertinimas kodas'
+b'DocType: POS Item Group',b'POS Item Group',b'POS punktas grup\xc4\x97'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17',b'Email Digest:',b'Si\xc5\xb3skite Digest:'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613',b'BOM {0} does not belong to Item {1}',b'BOM {0} nepriklauso punkte {1}'
+b'DocType: Sales Partner',b'Target Distribution',b'Tikslin\xc4\x97 pasiskirstymas'
+b'DocType: Purchase Invoice',b'06-Finalization of Provisional assessment',b'06 - Laikinasis vertinimas'
+b'DocType: Salary Slip',b'Bank Account No.',b'Banko s\xc4\x85skaitos Nr'
+b'DocType: Naming Series',b'This is the number of the last created transaction with this prefix',b'Tai yra paskutinio sukurto skai\xc4\x8dius operacijoje su \xc5\xa1io prefikso'
+b'DocType: Supplier Scorecard',"b'Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n'","b'Galima naudoti rodikli\xc5\xb3 korteli\xc5\xb3 kintamieji, taip pat: {total_score} (bendras rezultatas i\xc5\xa1 \xc5\xa1io laikotarpio), {period_number} (laikotarpi\xc5\xb3 skai\xc4\x8dius iki dabartin\xc4\x97s dienos)'"
+b'DocType: Quality Inspection Reading',b'Reading 8',b'Skaitymas 8'
+b'DocType: Sales Partner',b'Agent',b'agentas'
+b'DocType: Purchase Invoice',b'Taxes and Charges Calculation',b'Mokes\xc4\x8diai ir rinkliavos apskai\xc4\x8diavimas'
+b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'U\xc5\xbesakyti Turto nusid\xc4\x97v\xc4\x97jimas \xc4\xae\xc4\x97jimas Automati\xc5\xa1kai'
+b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'U\xc5\xbesakyti Turto nusid\xc4\x97v\xc4\x97jimas \xc4\xae\xc4\x97jimas Automati\xc5\xa1kai'
+b'DocType: BOM Operation',b'Workstation',b'Kompiuterizuotos darbo vietos'
+b'DocType: Request for Quotation Supplier',b'Request for Quotation Supplier',b'U\xc5\xbeklausimas Tiek\xc4\x97jo'
+b'DocType: Healthcare Settings',b'Registration Message',b'Registracijos prane\xc5\xa1imas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154',b'Hardware',b'technin\xc4\x97 \xc4\xafranga'
+b'DocType: Prescription Dosage',b'Prescription Dosage',b'Receptinis dozavimas'
+b'DocType: Attendance',b'HR Manager',b'\xc5\xbdmogi\xc5\xa1k\xc5\xb3j\xc5\xb3 i\xc5\xa1tekli\xc5\xb3 vadybininkas'
+b'apps/erpnext/erpnext/accounts/party.py +175',b'Please select a Company',"b'Pra\xc5\xa1ome pasirinkti \xc4\xafmon\xc4\x99,'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92',b'Privilege Leave',b'privilegija atostogos'
+b'DocType: Purchase Invoice',b'Supplier Invoice Date',b'Tiek\xc4\x97jas s\xc4\x85skaitos fakt\xc5\xabros i\xc5\xa1ra\xc5\xa1ymo data'
+b'DocType: Asset Settings',b'This value is used for pro-rata temporis calculation',b'\xc5\xa0i vert\xc4\x97 naudojama pro rata temporis apskai\xc4\x8diavimui'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90',b'You need to enable Shopping Cart',b'Jums reikia \xc4\xafgalinti Preki\xc5\xb3 krep\xc5\xa1elis'
+b'DocType: Payment Entry',b'Writeoff',b'Nusira\xc5\xa1in\xc4\x97ti'
+b'DocType: Stock Settings',b'Naming Series Prefix',b'Vard\xc5\xb3 serijos prefiksas'
+b'DocType: Appraisal Template Goal',b'Appraisal Template Goal',b'Vertinimas \xc5\xa0ablonas tikslas'
+b'DocType: Salary Component',b'Earning',b'Pelningiausi'
+b'DocType: Supplier Scorecard',b'Scoring Criteria',b'Bal\xc5\xb3 kriterijai'
+b'DocType: Purchase Invoice',b'Party Account Currency',b'\xc5\xa0alis paskyra Valiuta'
+,b'BOM Browser',b'BOM nar\xc5\xa1ykl\xc4\x97'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +13',b'Please update your status for this training event',b'Pra\xc5\xa1ome atnaujinti savo status\xc4\x85 \xc5\xa1iam renginiui'
+b'DocType: Item Barcode',b'EAN',b'EAN'
+b'DocType: Purchase Taxes and Charges',b'Add or Deduct',b'Prid\xc4\x97ti arba atimama'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148',b'Overlapping conditions found between:',b'rasti tarp sutampan\xc4\x8di\xc5\xb3 s\xc4\x85lygos:'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187',b'Against Journal Entry {0} is already adjusted against some other voucher',b'Prie\xc5\xa1 leidinyje \xc4\xae\xc4\x97jimo {0} jau koreguojama kitu kupon\xc4\x85'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68',b'Total Order Value',b'I\xc5\xa1 viso u\xc5\xbesakymo vert\xc4\x97'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +328',b'Food',b'maistas'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57',b'Ageing Range 3',b'Sen\xc4\x97jimas klas\xc4\x97s 3'
+b'DocType: Maintenance Schedule Item',b'No of Visits',b'N\xc4\x97ra apsilankym\xc5\xb3'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165',b'Maintenance Schedule {0} exists against {1}',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros grafikas {0} egzistuoja nuo {1}'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36',b'Enrolling student',b'mokosi studentas'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33',b'Currency of the Closing Account must be {0}',b'Valiuta u\xc5\xbedarymo s\xc4\x85skaita turi b\xc5\xabti {0}'
+b'apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21',b'Sum of points for all goals should be 100. It is {0}',b'Suma kiekis vis\xc5\xb3 tiksl\xc5\xb3 tur\xc4\x97t\xc5\xb3 b\xc5\xabti 100. Tai {0}'
+b'DocType: Project',b'Start and End Dates',b'Prad\xc5\xbeios ir pabaigos datos'
+,b'Delivered Items To Be Billed',b'Pristatyto objekto Nor\xc4\x97dami b\xc5\xabti mokami'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16',b'Open BOM {0}',b'Atviras BOM {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60',b'Warehouse cannot be changed for Serial No.',b'Sand\xc4\x97li\xc5\xb3 negali b\xc5\xabti kei\xc4\x8diama Serijos Nr'
+b'DocType: Authorization Rule',b'Average Discount',b'Vidutinis nuolaida'
+b'DocType: Project Update',b'Great/Quickly',b'Puikiai / greitai'
+b'DocType: Purchase Invoice Item',b'UOM',b'UOM'
+b'DocType: Rename Tool',b'Utilities',b'Komunalin\xc4\x97s paslaugos'
+b'DocType: POS Profile',b'Accounting',b'apskaita'
+b'DocType: Employee',b'EMP/',b'EMP /'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133',b'Please select batches for batched item ',b'Pra\xc5\xa1ome pasirinkti partijas partijomis prek\xc4\x99'
+b'DocType: Asset',b'Depreciation Schedules',b'nusid\xc4\x97v\xc4\x97jimo Tvarkara\xc5\xa1\xc4\x8diai'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192',b'Following accounts might be selected in GST Settings:',b'GST nustatymuose gali b\xc5\xabti parinktos \xc5\xa1ios paskyros:'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70',b'Application period cannot be outside leave allocation period',b'Taikymo laikotarpis negali b\xc5\xabti ne atostogos paskirstymo laikotarpis'
+b'DocType: Activity Cost',b'Projects',b'projektai'
+b'DocType: Payment Request',b'Transaction Currency',b'Operacijos valiuta'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +30',b'From {0} | {1} {2}',b'I\xc5\xa1 {0} | {1} {2}'
+b'DocType: Work Order Operation',b'Operation Description',b'Veikimo apra\xc5\xa1ymas'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34',b'Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.',"b'Nepavyksta pakeisti finansiniai metai prad\xc5\xbeios data ir fiskalini\xc5\xb3 met\xc5\xb3 pabaigos, kai finansiniai metai yra i\xc5\xa1saugotas.'"
+b'DocType: Quotation',b'Shopping Cart',b'Preki\xc5\xb3 krep\xc5\xa1elis'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Avg Daily Outgoing',b'Vid Dienos Siun\xc4\x8diami'
+b'DocType: POS Profile',b'Campaign',b'Kampanija'
+b'DocType: Supplier',b'Name and Type',b'Pavadinimas ir tipas'
+b'DocType: Physician',b'Contacts and Address',b'Kontaktai ir adresas'
+b'DocType: Purchase Invoice',b'Contact Person',b'kontaktinis asmuo'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +38',"b""'Expected Start Date' can not be greater than 'Expected End Date'""","b'""Tik\xc4\x97tina prad\xc5\xbeios data"" negali b\xc5\xabti didesnis nei ""Tik\xc4\x97tina pabaigos data""'"
+b'DocType: Course Scheduling Tool',b'Course End Date',b'\xc5\xbdinoma Pabaigos data'
+b'DocType: Holiday List',b'Holidays',b'\xc5\xa1vent\xc4\x97s'
+b'DocType: Sales Order Item',b'Planned Quantity',b'planuojamas kiekis'
+b'DocType: Purchase Invoice Item',b'Item Tax Amount',b'Prek\xc4\x97 Mokes\xc4\x8di\xc5\xb3 suma'
+b'DocType: Water Analysis',b'Water Analysis Criteria',b'Vandens analiz\xc4\x97s kriterijai'
+b'DocType: Item',b'Maintain Stock',b'i\xc5\xa1laikyti Stock'
+b'DocType: Employee',b'Prefered Email',b'Pageidaujamas pa\xc5\xa1tas'
+b'DocType: Student Admission',b'Eligibility and Details',b'Tinkamumas ir detal\xc4\x97s'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38',b'Net Change in Fixed Asset',b'Grynasis pokytis ilgalaikio turto'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all designations',"b'Palikite tu\xc5\xa1\xc4\x8di\xc4\x85, jei laikomas vis\xc5\xb3 pavadinim\xc5\xb3'"
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +806',"b""Charge of type 'Actual' in row {0} cannot be included in Item Rate""",b'Mokes\xc4\x8dio tipas &quot;Tikrasis&quot; i\xc5\xa1 eil\xc4\x97s {0} negali b\xc5\xabti \xc4\xaftraukti \xc4\xaf klausimus lygis'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382',b'Max: {0}',b'Max: {0}'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'From Datetime',b'nuo datetime'
+b'DocType: Email Digest',b'For Company',b'd\xc4\x97l Company'
+b'apps/erpnext/erpnext/config/support.py +17',b'Communication log.',b'Ry\xc5\xa1io \xc5\xbeurnalas.'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195',"b'Request for Quotation is disabled to access from portal, for more check portal settings.'","b'U\xc5\xbeklausimas yra i\xc5\xa1jungtas patekti i\xc5\xa1 portalo, daugiau patikrinim\xc5\xb3 portalo nustatymus.'"
+b'DocType: Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable',b'Tiek\xc4\x97jo rezultat\xc5\xb3 lentel\xc4\x97s vertinimo kintamasis'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72',b'Buying Amount',b'Ie\xc5\xa1ko suma'
+b'DocType: Sales Invoice',b'Shipping Address Name',b'Pristatymas Adresas Pavadinimas'
+b'DocType: Material Request',b'Terms and Conditions Content',b'Terminai ir s\xc4\x85lygos turinys'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18',b'There were errors creating Course Schedule',b'Kuriant tvarkara\xc5\xa1t\xc4\xaf suk\xc5\xabr\xc4\x97me klaid\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581',b'cannot be greater than 100',b'negali b\xc5\xabti didesnis nei 100'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +752',b'Item {0} is not a stock Item',b'Prek\xc4\x97 {0} n\xc4\x97ra sand\xc4\x97lyje punktas'
+b'DocType: Maintenance Visit',b'Unscheduled',b'Neplanuotai'
+b'DocType: Employee',b'Owned',b'priklauso'
+b'DocType: Salary Detail',b'Depends on Leave Without Pay',b'Priklauso nuo atostog\xc5\xb3 be Pay'
+b'DocType: Pricing Rule',"b'Higher the number, higher the priority'","b'Kuo didesnis skai\xc4\x8dius, didesnis prioritetas'"
+,b'Purchase Invoice Trends',b'Pirkimo fakt\xc5\xabros tendencijos'
+b'DocType: Employee',b'Better Prospects',b'Geresn\xc4\x97s perspektyvos'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +217',"b'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'","b'Eilut\xc4\x97 # {0}: Partija {1} turi tik {2} vnt. Pra\xc5\xa1ome pasirinkti kit\xc4\x85 partij\xc4\x85, kuri turi gauti {3} Kiekis arba padalinti eilut\xc4\x99 \xc4\xaf kelias eilutes, pristatyti / problem\xc4\x85 i\xc5\xa1 keli\xc5\xb3 partij\xc5\xb3'"
+b'DocType: Vehicle',b'License Plate',b'Valstybinis numeris'
+b'DocType: Appraisal',b'Goals',b'Tikslai'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +353',b'Select POS Profile',b'Pasirinkite POS profil\xc4\xaf'
+b'DocType: Warranty Claim',b'Warranty / AMC Status',b'Garantija / AMC B\xc5\xabsena'
+,b'Accounts Browser',b's\xc4\x85skaitos nar\xc5\xa1ykl\xc4\x97'
+b'DocType: Payment Entry Reference',b'Payment Entry Reference',b'Mok\xc4\x97jimo \xc4\xae\xc4\x97jimo Nuoroda'
+b'DocType: GL Entry',b'GL Entry',b'GL \xc4\xafra\xc5\xa1as'
+b'DocType: HR Settings',b'Employee Settings',b'darbuotoj\xc5\xb3 Nustatymai'
+,b'Batch-Wise Balance History',b'Serija-I\xc5\xa1min\xc4\x8dius Balansas istorija'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73',b'Print settings updated in respective print format',b'Spausdinimo parametrai atnaujinama atitinkamos spausdinimo format\xc4\x85'
+b'DocType: Package Code',b'Package Code',b'Pakuot\xc4\x97s kodas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105',b'Apprentice',b'mokinys'
+b'DocType: Purchase Invoice',b'Company GSTIN',b'\xc4\xaemon\xc4\x97s GSTIN'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105',b'Negative Quantity is not allowed',b'Neigiama Kiekis neleid\xc5\xbeiama'
+b'DocType: Purchase Invoice Item',b'Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges',b'Mokes\xc4\x8di\xc5\xb3 detal\xc4\x97 stalo nerealu i\xc5\xa1 punkto meistras kaip eilut\xc4\x99 ir saugomi \xc5\xa1ioje srityje. Naudojama mokes\xc4\x8di\xc5\xb3 ir rinkliav\xc5\xb3'
+b'DocType: Supplier Scorecard Period',b'SSC-',b'SSC-'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +159',b'Employee cannot report to himself.',b'Darbuotojas negali prane\xc5\xa1ti pats.'
+b'DocType: Account',"b'If the account is frozen, entries are allowed to restricted users.'","b'Jei s\xc4\x85skaita yra su\xc5\xa1aldyti, \xc4\xafra\xc5\xa1ai leid\xc5\xbeiama ribojam\xc5\xb3 vartotojams.'"
+b'DocType: Email Digest',b'Bank Balance',b'banko balansas'
+b'apps/erpnext/erpnext/accounts/party.py +240',b'Accounting Entry for {0}: {1} can only be made in currency: {2}',b'Apskaitos \xc4\xafra\xc5\xa1as u\xc5\xbe {0}: {1} galima tik valiuta: {2}'
+b'DocType: Job Opening',"b'Job profile, qualifications required etc.'","b'Darbo profilis, reikalingas kvalifikacijos ir tt'"
+b'DocType: Journal Entry Account',b'Account Balance',b'S\xc4\x85skaitos balansas'
+b'apps/erpnext/erpnext/config/accounts.py +183',b'Tax Rule for transactions.',b'Mokes\xc4\x8di\xc5\xb3 taisykl\xc4\x97 sandorius.'
+b'DocType: Rename Tool',b'Type of document to rename.',b'Dokumento tipas pervadinti.'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53',b'{0} {1}: Customer is required against Receivable account {2}',b'{0} {1}: Klientas privalo prie\xc5\xa1 gautinos s\xc4\x85skaitos {2}'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges (Company Currency)',b'I\xc5\xa1 viso mokes\xc4\x8diai ir rinkliavos (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Weather',b'Weather Parameter',b'Oras parametras'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60',"b""Show unclosed fiscal year's P&L balances""",b'Rodyti Atvir\xc5\xb3 fiskalinius metus anketa P &amp; L liku\xc4\x8dius'
+b'DocType: Lab Test Template',b'Collection Details',b'Kolekcijos duomenys'
+b'DocType: POS Profile',b'Allow Print Before Pay',b'Leisti spausdinti prie\xc5\xa1 apmok\xc4\x97jim\xc4\x85'
+b'DocType: Land Unit',b'Linked Soil Texture',b'Susijusi dirvo\xc5\xbeemio tekst\xc5\xabra'
+b'DocType: Shipping Rule',b'Shipping Account',b'Pristatymas paskyra'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92',b'{0} {1}: Account {2} is inactive',b'{0} {1}: S\xc4\x85skaitos {2} yra neaktyvus'
+b'apps/erpnext/erpnext/utilities/activation.py +82',b'Make Sales Orders to help you plan your work and deliver on-time',"b'Padaryti pardavimo u\xc5\xbesakymus, siekiant pad\xc4\x97ti jums planuoti savo darb\xc4\x85 ir \xc4\xafgyvendinti laiku'"
+b'DocType: Quality Inspection',b'Readings',b'Skaitiniai'
+b'DocType: Stock Entry',b'Total Additional Costs',b'I\xc5\xa1 viso papildom\xc5\xb3 i\xc5\xa1laid\xc5\xb3'
+b'DocType: Course Schedule',b'SH',b'SH'
+b'DocType: BOM',b'Scrap Material Cost(Company Currency)',b'Lau\xc5\xbeas Med\xc5\xbeiaga Kaina (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66',b'Sub Assemblies',b'sub Agregatai'
+b'DocType: Asset',b'Asset Name',"b'turto pavadinimas,'"
+b'DocType: Project',b'Task Weight',b'u\xc5\xbeduotis Svoris'
+b'DocType: Shipping Rule Condition',b'To Value',b'Vertinti'
+b'DocType: Asset Movement',b'Stock Manager',b'akcij\xc5\xb3 direktorius'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171',b'Source warehouse is mandatory for row {0}',b'\xc5\xa0altinis sand\xc4\x97lis yra privalomas eil\xc4\x97s {0}'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38',b'The Payment Term at row {0} is possibly a duplicate.',b'Apmok\xc4\x97jimo terminas eilut\xc4\x97je {0} yra galimas dublikatas.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +30',b'Agriculture (beta)',b'\xc5\xbdem\xc4\x97s \xc5\xabkis (beta)'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863',b'Packing Slip',b'Pakavimo lapelis'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110',b'Office Rent',b'Biuro nuoma'
+b'apps/erpnext/erpnext/config/setup.py +111',b'Setup SMS gateway settings',b'S\xc4\x85ranka SMS Gateway nustatymai'
+b'DocType: Disease',b'Common Name',b'Da\xc5\xbenas vardas'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61',b'Import Failed!',b'Importas Nepavyko!'
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +20',b'No address added yet.',b'N\xc4\x97ra adresas prid\xc4\x97ta dar.'
+b'DocType: Workstation Working Hour',b'Workstation Working Hour',b'Kompiuterizuotos darbo vietos Darbo valandos'
+b'DocType: Vital Signs',b'Blood Pressure',b'Kraujo spaudimas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125',b'Analyst',b'analitikas'
+b'DocType: Item',b'Inventory',b'inventorius'
+b'DocType: Item',b'Sales Details',b'pardavim\xc5\xb3 detal\xc4\x97s'
+b'DocType: Quality Inspection',b'QI-',b'QI-'
+b'DocType: Opportunity',b'With Items',b'su daiktais'
+b'DocType: Asset Maintenance',b'Maintenance Team',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros komanda'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'In Qty',b'Be Kiekis'
+b'DocType: Education Settings',b'Validate Enrolled Course for Students in Student Group',b'Patvirtinti mokosi kursai studentams Student\xc5\xb3 grup\xc4\x97s'
+b'DocType: Notification Control',b'Expense Claim Rejected',b'Kompensuojamos teiginys atmetamas'
+b'DocType: Item',b'Item Attribute',b'Prek\xc4\x97 \xc4\xaeg\xc5\xabdis'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147',b'Government',b'vyriausyb\xc4\x97'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40',b'Expense Claim {0} already exists for the Vehicle Log',"b'Kompensuojamos Pretenzija {0} jau egzistuoja, kad transporto priemon\xc4\x97 Prisijungti'"
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +64',b'Institute Name',b'institutas Vardas'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117',b'Please enter repayment Amount',b'Pra\xc5\xa1ome \xc4\xafvesti gr\xc4\x85\xc5\xbeinimo suma'
+b'apps/erpnext/erpnext/config/stock.py +309',b'Item Variants',b'Prek\xc4\x97 Variantai'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +29',b'Services',b'Paslaugos'
+b'DocType: HR Settings',b'Email Salary Slip to Employee',b'Si\xc5\xb3sti darbo u\xc5\xbemokest\xc4\xaf \xc4\xaf darbuotoj\xc5\xb3'
+b'DocType: Cost Center',b'Parent Cost Center',b'T\xc4\x97v\xc5\xb3 Kaina centras'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041',b'Select Possible Supplier',b'Pasirinkite Galima Tiek\xc4\x97jo'
+b'DocType: Sales Invoice',b'Source',b'\xc5\xa1altinis'
+b'DocType: Customer',"b'Select, to make the customer searchable with these fields'","b'Pasirinkite, kad klientas gal\xc4\x97t\xc5\xb3 ie\xc5\xa1koti \xc5\xa1i\xc5\xb3 lauk\xc5\xb3'"
+b'apps/erpnext/erpnext/templates/pages/projects.html +31',b'Show closed',b'Rodyti u\xc5\xbedarytas'
+b'DocType: Leave Type',b'Is Leave Without Pay',b'Ar palikti be Pay'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +261',b'Asset Category is mandatory for Fixed Asset item',b'Turto Kategorija privaloma ilgalaikio turto'
+b'DocType: Fee Validity',b'Fee Validity',b'Mokes\xc4\x8dio galiojimas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146',b'No records found in the Payment table',b'rasti Mok\xc4\x97jimo stalo N\xc4\x97ra \xc4\xafra\xc5\xa1\xc5\xb3'
+b'apps/erpnext/erpnext/education/utils.py +19',b'This {0} conflicts with {1} for {2} {3}',b'\xc5\xa0is {0} prie\xc5\xa1tarauja {1} ir {2} {3}'
+b'DocType: Student Attendance Tool',b'Students HTML',b'studentai HTML'
+b'DocType: POS Profile',b'Apply Discount',b'taikyti nuolaid\xc4\x85'
+b'DocType: GST HSN Code',b'GST HSN Code',"b'Paai\xc5\xa1k\xc4\x97jo, kad GST HSN kodas'"
+b'DocType: Employee External Work History',b'Total Experience',b'I\xc5\xa1 viso Patirtis'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70',b'Open Projects',b'Atviri projektai'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295',b'Packing Slip(s) cancelled',b'Pakavimo Kuponas (-ai) at\xc5\xa1auktas'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36',b'Cash Flow from Investing',b'Pinig\xc5\xb3 srautai i\xc5\xa1 investicin\xc4\x97s'
+b'DocType: Program Course',b'Program Course',b'programos kursas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99',b'Freight and Forwarding Charges',b'Krovini\xc5\xb3 ir ekspedijavimo Mokes\xc4\x8diai'
+b'DocType: Homepage',b'Company Tagline for website homepage',b'\xc4\xaemon\xc4\x97s Paantra\xc5\xa1t\xc4\x97 interneto svetain\xc4\x97s pagrindiniame puslapyje'
+b'DocType: Item Group',b'Item Group Name',b'Prek\xc4\x97 Grup\xc4\x97s pavadinimas'
+b'apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27',b'Taken',b'Paimta'
+b'DocType: Student',b'Date of Leaving',b'Data Palikus'
+b'DocType: Pricing Rule',b'For Price List',b'Kaina s\xc4\x85ra\xc5\xa1as'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27',b'Executive Search',b'Executive Search'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55',b'Setting defaults',b'Numatytasis nustatymas'
+b'apps/erpnext/erpnext/utilities/activation.py +63',b'Create Leads',b'Sukurti leads'
+b'DocType: Maintenance Schedule',b'Schedules',b'tvarkara\xc5\xa1\xc4\x8diai'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +468',b'POS Profile is required to use Point-of-Sale',"b'Pozicijos profilis reikalingas, norint naudoti &quot;Point-of-Sale&quot;'"
+b'DocType: Purchase Invoice Item',b'Net Amount',b'Grynoji suma'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141',b'{0} {1} has not been submitted so the action cannot be completed',b'{0} {1} nebuvo pateikta ir tod\xc4\x97l veiksmai negali b\xc5\xabti u\xc5\xbebaigti'
+b'DocType: Purchase Order Item Supplied',b'BOM Detail No',b'BOM I\xc5\xa1samiau N\xc4\x97ra'
+b'DocType: Landed Cost Voucher',b'Additional Charges',b'Papildomi mokes\xc4\x8diai'
+b'DocType: Purchase Invoice',b'Additional Discount Amount (Company Currency)',b'Papildoma nuolaida Suma (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Supplier Scorecard',b'Supplier Scorecard',b'Tiek\xc4\x97jo rezultat\xc5\xb3 kortel\xc4\x97'
+b'DocType: Plant Analysis',b'Result Datetime',b'Rezultatas Datetime'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +21',b'Please create new account from Chart of Accounts.',b'Pra\xc5\xa1ome sukurti nauj\xc4\x85 s\xc4\x85skait\xc4\x85 i\xc5\xa1 s\xc4\x85skait\xc5\xb3 plano.'
+,b'Support Hour Distribution',b'Paramos valandos platinimas'
+b'DocType: Maintenance Visit',b'Maintenance Visit',b'prie\xc5\xbei\xc5\xabra Aplankyti'
+b'DocType: Student',b'Leaving Certificate Number',b'Palikus Sertifikato numeris'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58',"b'Appointment cancelled, Please review and cancel the invoice {0}'",b'Paskyrimas at\xc5\xa1auktas. Per\xc5\xbei\xc5\xabr\xc4\x97kite ir at\xc5\xa1aukite s\xc4\x85skait\xc4\x85 {0}'
+b'DocType: Sales Invoice Item',b'Available Batch Qty at Warehouse',b'Turimas Serija Kiekis \xc4\xaf sand\xc4\x97l\xc4\xaf'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Update Print Format',b'Atnaujinti Spausdinti Formatas'
+b'DocType: Landed Cost Voucher',b'Landed Cost Help',b'Nusileido kaina Pagalba'
+b'DocType: Purchase Invoice',b'Select Shipping Address',b'Pasirinkite pristatymo adresas'
+b'apps/erpnext/erpnext/config/non_profit.py +28',b'Memebership Details',b'Savivaldyb\xc4\x97s duomenys'
+b'DocType: Leave Block List',b'Block Holidays on important days.',b'Blokuoti \xc5\xa0vent\xc4\x97s svarbiais dien\xc5\xb3.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220',b'Please input all required Result Value(s)',b'\xc4\xaeveskite visus reikiamus rezultat\xc5\xb3 vertes (-ius)'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106',b'Accounts Receivable Summary',b'Gautinos Santrauka'
+b'DocType: Employee Loan',b'Monthly Repayment Amount',b'M\xc4\x97nesio gr\xc4\x85\xc5\xbeinimo suma'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9',b'Opening Invoices',b'S\xc4\x85skait\xc5\xb3 atidarymas'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +195',b'Please set User ID field in an Employee record to set Employee Role',b'Pra\xc5\xa1ome nustatyti vartotojo ID lauk\xc4\x85 darbuotojas \xc4\xafra\xc5\xa1o nustatyti Darbuotoj\xc5\xb3 vaidmuo'
+b'DocType: UOM',b'UOM Name',b'UOM Vardas'
+b'DocType: GST HSN Code',b'HSN Code',b'HSN kodas'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39',b'Contribution Amount',b'\xc4\xafna\xc5\xa1o suma'
+b'DocType: Purchase Invoice',b'Shipping Address',b'Pristatymo adresas'
+b'DocType: Stock Reconciliation',b'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.',b'\xc5\xa0is \xc4\xafrankis padeda jums atnaujinti arba pataisyti kiek\xc4\xaf ir vertinimui atsarg\xc5\xb3 sistemoje. Ji paprastai naudojama sinchronizuoti sistemos vertybes ir kas i\xc5\xa1 tikr\xc5\xb3j\xc5\xb3 yra j\xc5\xabs\xc5\xb3 sand\xc4\x97li\xc5\xb3.'
+b'DocType: Delivery Note',b'In Words will be visible once you save the Delivery Note.',"b'\xc5\xbdod\xc5\xbeiais bus matomas, kai j\xc5\xabs i\xc5\xa1gelb\xc4\x97ti va\xc5\xbetara\xc5\xa1tyje.'"
+b'DocType: Expense Claim',b'EXP',b'Tinka'
+b'DocType: Water Analysis',b'Container',b'Konteineris'
+b'apps/erpnext/erpnext/education/utils.py +50',b'Student {0} - {1} appears Multiple times in row {2} & {3}',b'Student\xc5\xb3 {0} - {1} pasirodo kelis kartus i\xc5\xa1 eil\xc4\x97s {2} ir {3}'
+b'DocType: Project',b'Day to Send',b'Diena si\xc5\xb3sti'
+b'DocType: Healthcare Settings',b'Manage Sample Collection',b'Tvarkykite pavyzd\xc5\xbei\xc5\xb3 rinkin\xc4\xaf'
+b'DocType: Production Plan',b'Ignore Existing Ordered Quantity',b'Ignoruoti esam\xc4\x85 u\xc5\xbesakyt\xc4\x85 kiek\xc4\xaf'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66',b'Please set the series to be used.',b'Nurodykite naudojam\xc4\x85 serij\xc4\x85.'
+b'DocType: Patient',b'Tobacco Past Use',b'Tabako praeitis'
+b'DocType: Sales Invoice Item',b'Brand Name',b'Mark\xc4\x97s pavadinimas'
+b'DocType: Purchase Receipt',b'Transporter Details',b'Transporter detal\xc4\x97s'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55',b'User {0} is already assigned to Physician {1}',b'Naudotojas {0} jau yra priskirtas gydytojui {1}'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2700',b'Default warehouse is required for selected item',b'Numatytasis sand\xc4\x97lis reikalingas pasirinkt\xc4\x85 element\xc4\x85'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Box',b'D\xc4\x97\xc5\xbe\xc4\x97'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038',b'Possible Supplier',b'galimas Tiek\xc4\x97jas'
+b'DocType: Budget',b'Monthly Distribution',b'M\xc4\x97nesio pasiskirstymas'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68',b'Receiver List is empty. Please create Receiver List',b'Imtuvas s\xc4\x85ra\xc5\xa1as tu\xc5\xa1\xc4\x8dias. Pra\xc5\xa1ome sukurti imtuvas s\xc4\x85ra\xc5\xa1as'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +31',b'Healthcare (beta)',b'Sveikatos prie\xc5\xbei\xc5\xabra (beta)'
+b'DocType: Production Plan Sales Order',b'Production Plan Sales Order',b'Gamybos planas pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3'
+b'DocType: Sales Partner',b'Sales Partner Target',b'Partneriai pardavimo Tikslin\xc4\x97'
+b'DocType: Loan Type',b'Maximum Loan Amount',b'Maksimali paskolos suma'
+b'DocType: Pricing Rule',b'Pricing Rule',b'kainodaros taisykl\xc4\x97'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Dublikatas ritinys numeris studentas {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Dublikatas ritinys numeris studentas {0}'
+b'DocType: Budget',b'Action if Annual Budget Exceeded',"b'Veiksm\xc5\xb3, jei metinio biud\xc5\xbeeto Vir\xc5\xa1ytas'"
+b'apps/erpnext/erpnext/config/learn.py +197',b'Material Request to Purchase Order',b'Med\xc5\xbeiaga Pra\xc5\xa1ymas Pirkimo u\xc5\xbesakymas'
+b'DocType: Shopping Cart Settings',b'Payment Success URL',b'Mok\xc4\x97jimo S\xc4\x97km\xc4\x97s adresas'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81',b'Row # {0}: Returned Item {1} does not exists in {2} {3}',b'Eilut\xc4\x97s # {0}: gr\xc4\x85\xc5\xbeinama prek\xc4\x97 {1} n\xc4\x97ra egzistuoja {2} {3}'
+b'DocType: Purchase Receipt',b'PREC-',b'PREC-'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16',b'Bank Accounts',b'Banko s\xc4\x85skaitos'
+,b'Bank Reconciliation Statement',b'Bankas Susitaikymas parei\xc5\xa1kimas'
+b'DocType: Consultation',b'Medical Coding',b'Medicininis kodavimas'
+b'DocType: Healthcare Settings',b'Reminder Message',b'Priminimo prane\xc5\xa1imas'
+,b'Lead Name',b'\xc5\xa0vinas Vardas'
+,b'POS',b'POS'
+b'DocType: C-Form',b'III',b'III'
+b'apps/erpnext/erpnext/config/stock.py +314',b'Opening Stock Balance',b'Atidarymo sand\xc4\x97lyje balansas'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58',b'{0} must appear only once',b'{0} turi b\xc5\xabti tik vien\xc4\x85 kart\xc4\x85'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59',b'Leaves Allocated Successfully for {0}',b'Lapai Paskirti s\xc4\x97kmingai {0}'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42',b'No Items to pack',b'Neturite preki\xc5\xb3 pakuot\xc4\x97s'
+b'DocType: Shipping Rule Condition',b'From Value',b'nuo Vert\xc4\x97'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +606',b'Manufacturing Quantity is mandatory',b'Gamyba Kiekis yra privalomi'
+b'DocType: Employee Loan',b'Repayment Method',b'gr\xc4\x85\xc5\xbeinimas b\xc5\xabdas'
+b'DocType: Products Settings',"b'If checked, the Home page will be the default Item Group for the website'","b'Jei pa\xc5\xbeym\xc4\x97ta, Titulinis puslapis bus numatytasis punktas grup\xc4\x97 svetain\xc4\x97je'"
+b'DocType: Quality Inspection Reading',b'Reading 4',b'svarstym\xc4\x85 4'
+b'apps/erpnext/erpnext/config/hr.py +132',b'Claims for company expense.',b'Ie\xc5\xa1kiniai d\xc4\x97l \xc4\xafmon\xc4\x97s s\xc4\x85skaita.'
+b'apps/erpnext/erpnext/utilities/activation.py +118',"b'Students are at the heart of the system, add all your students'","b'Studentai ne sistemos \xc5\xa1irdyje, prid\xc4\x97ti visus savo mokinius'"
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97',b'Row #{0}: Clearance date {1} cannot be before Cheque Date {2}',b'Eilut\xc4\x97s # {0} klirensas data {1} negali b\xc5\xabti prie\xc5\xa1 \xc4\x8dekis data {2}'
+b'DocType: Asset Maintenance Task',b'Certificate Required',b'Reikalingas sertifikatas'
+b'DocType: Company',b'Default Holiday List',b'Numatytasis poilsis s\xc4\x85ra\xc5\xa1as'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196',b'Row {0}: From Time and To Time of {1} is overlapping with {2}',b'Eilut\xc4\x97s {0}: Nuo laik\xc4\x85 ir Laikas {1} i\xc5\xa1 dalies sutampa su {2}'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145',b'Stock Liabilities',b'Akcij\xc5\xb3 \xc4\xaesipareigojimai'
+b'DocType: Purchase Invoice',b'Supplier Warehouse',b'tiek\xc4\x97jas tiekiantis sand\xc4\x97lis'
+b'DocType: Opportunity',b'Contact Mobile No',b'Kontaktin\xc4\x97 Mobilus N\xc4\x97ra'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399',b'Select Company',b'Pasirinkite \xc4\xafmon\xc4\x99'
+,b'Material Requests for which Supplier Quotations are not created',b'Med\xc5\xbeiaga Pra\xc5\xa1ymai d\xc4\x97l kuri\xc5\xb3 Tiek\xc4\x97jas Citatos n\xc4\x97ra sukurtos'
+b'DocType: Student Report Generation Tool',b'Print Section',b'Spausdinti skyriuje'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34',"b""User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.""",b'Vartotojas {0} neturi numatytojo POS profilio. Patikrinkite numatytuosius \xc5\xa1io vartotojo {1} eilut\xc4\x97je (1).'
+b'DocType: Student Group',b'Set 0 for no limit',b'Nustatykite 0 jokios ribos'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122',b'The day(s) on which you are applying for leave are holidays. You need not apply for leave.',"b'Dien\xc4\x85 (-os), kada pra\xc5\xa1ote atostog\xc5\xb3 yra \xc5\xa1vent\xc4\x97s. Jums nereikia pra\xc5\xa1yti atostog\xc5\xb3.'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64',b'Row {idx}: {field} is required to create the Opening {invoice_type} Invoices',"b'Rida {idx}: {field} reikalinga, kad b\xc5\xabt\xc5\xb3 sukurtos &quot;Opening {invoice_type}&quot; s\xc4\x85skaitos fakt\xc5\xabros'"
+b'DocType: Customer',b'Primary Address and Contact Detail',b'Pirminis adresas ir kontaktiniai duomenys'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20',b'Resend Payment Email',b'Persi\xc5\xb3sti Mok\xc4\x97jimo pa\xc5\xa1tu'
+b'apps/erpnext/erpnext/templates/pages/projects.html +27',b'New task',b'Nauja u\xc5\xbeduotis'
+b'DocType: Consultation',b'Appointment',b'Paskyrimas'
+b'apps/erpnext/erpnext/utilities/activation.py +74',b'Make Quotation',b'Padaryti Citata'
+b'apps/erpnext/erpnext/config/education.py +230',b'Other Reports',b'Kiti prane\xc5\xa1imai'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +39',b'Please select at least one domain.',b'Pasirinkite bent vien\xc4\x85 domen\xc4\x85.'
+b'DocType: Dependent Task',b'Dependent Task',b'priklauso nuo darbo'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +444',b'Conversion factor for default Unit of Measure must be 1 in row {0}',b'Konversijos koeficientas pagal nutyl\xc4\x97jim\xc4\x85 Matavimo vienetas turi b\xc5\xabti 1 eil\xc4\x97s {0}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188',b'Leave of type {0} cannot be longer than {1}',b'Atostogos tipo {0} negali b\xc5\xabti ilgesnis nei {1}'
+b'DocType: Manufacturing Settings',b'Try planning operations for X days in advance.',b'Pabandykite planuoja operacijas X dien\xc5\xb3 i\xc5\xa1 anksto.'
+b'DocType: HR Settings',b'Stop Birthday Reminders',b'Sustabdyti Gimimo diena Priminimai'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235',b'Please set Default Payroll Payable Account in Company {0}',b'Pra\xc5\xa1ome Set Default Darbo u\xc5\xbemokes\xc4\x8dio MOK\xc4\x96TINOS Naryst\xc4\x97 Bendrov\xc4\x97je {0}'
+b'DocType: SMS Center',b'Receiver List',b'imtuvas s\xc4\x85ra\xc5\xa1as'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1094',b'Search Item',b'Paie\xc5\xa1ka punktas'
+b'DocType: Payment Schedule',b'Payment Amount',b'Mok\xc4\x97jimo suma'
+b'DocType: Patient Appointment',b'Referring Physician',b'Kreipiantis gydytojas'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46',b'Consumed Amount',b'suvartoti suma'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100',b'Net Change in Cash',b'Grynasis Pakeisti pinigais'
+b'DocType: Assessment Plan',b'Grading Scale',b'vertinimo skal\xc4\x97'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +438',b'Unit of Measure {0} has been entered more than once in Conversion Factor Table',b'Matavimo vienetas {0} buvo \xc4\xafra\xc5\xa1ytas daugiau nei vien\xc4\x85 kart\xc4\x85 konversijos koeficientas lentel\xc4\x97je'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +639',b'Already completed',b'jau baigtas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33',b'Stock In Hand',b'Akcij\xc5\xb3 In Hand'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64',b'Import Successful!',b'Importas s\xc4\x97kmingai!'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29',b'Payment Request already exists {0}',b'Mok\xc4\x97jimo pra\xc5\xa1ymas jau yra {0}'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Issued Items',b'Kaina i\xc5\xa1duot\xc4\x85 prek\xc4\x97s'
+b'DocType: Physician',b'Hospital',b'Ligonin\xc4\x97'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385',b'Quantity must not be more than {0}',b'Kiekis turi b\xc5\xabti ne daugiau kaip {0}'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117',b'Previous Financial Year is not closed',b'Pra\xc4\x97j\xc4\x99 finansiniai metai yra neu\xc5\xbedarytas'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46',b'Age (Days)',b'Am\xc5\xbeius (dienomis)'
+b'DocType: Quotation Item',b'Quotation Item',b'citata punktas'
+b'DocType: Customer',b'Customer POS Id',b'Klient\xc5\xb3 POS ID'
+b'DocType: Account',b'Account Name',b'Paskyros vardas'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40',b'From Date cannot be greater than To Date',b'Nuo data negali b\xc5\xabti didesnis nei data'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198',b'Serial No {0} quantity {1} cannot be a fraction',b'Serijos Nr {0} kiekis {1} negali b\xc5\xabti frakcija'
+b'apps/erpnext/erpnext/config/buying.py +43',b'Supplier Type master.',b'Tiek\xc4\x97jas tipas meistras.'
+b'DocType: Purchase Order Item',b'Supplier Part Number',b'Tiek\xc4\x97jas Dalies numeris'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108',b'Conversion rate cannot be 0 or 1',b'Perskai\xc4\x8diavimo kursas negali b\xc5\xabti 0 arba 1'
+b'DocType: Share Balance',b'To No',b'Ne'
+b'DocType: Subscription',b'Reference Document',b'Informacinis dokumentas'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229',b'{0} {1} is cancelled or stopped',b'{0} {1} yra at\xc5\xa1auktas arba sustabdytas'
+b'DocType: Accounts Settings',b'Credit Controller',b'kredito valdiklis'
+b'DocType: Grant Application',b'Applicant Type',b'Parei\xc5\xa1k\xc4\x97jo tipas'
+b'DocType: Purchase Invoice',b'03-Deficiency in services',b'03 - paslaug\xc5\xb3 tr\xc5\xabkumas'
+b'DocType: Delivery Note',b'Vehicle Dispatch Date',b'Automobilio i\xc5\xa1siuntimo data'
+b'DocType: Healthcare Settings',b'Default Medical Code Standard',b'Numatytasis medicinos kodekso standartas'
+b'DocType: Purchase Invoice Item',b'HSN/SAC',b'HSN / SAC'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237',b'Purchase Receipt {0} is not submitted',b'Pirkimo kvito {0} nebus pateiktas'
+b'DocType: Company',b'Default Payable Account',b'Numatytasis Mok\xc4\x97tina paskyra'
+b'apps/erpnext/erpnext/config/website.py +17',"b'Settings for online shopping cart such as shipping rules, price list etc.'","b'Nustatymai internetin\xc4\x97je krep\xc5\xa1el\xc4\xaf pavyzd\xc5\xbeiui, laivybos taisykles, kainora\xc5\xa1t\xc4\xaf ir tt'"
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +113',b'{0}% Billed',b'{0}% S\xc4\x85skaitos i\xc5\xa1ra\xc5\xa1ytos'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18',b'Reserved Qty',b'saugomos Kiekis'
+b'DocType: Party Account',b'Party Account',b'\xc5\xa1alis paskyra'
+b'apps/erpnext/erpnext/config/setup.py +122',b'Human Resources',b'\xc5\xbdmogi\xc5\xa1kieji i\xc5\xa1tekliai'
+b'DocType: Lead',b'Upper Income',b'vir\xc5\xa1utin\xc4\x97 pajamos'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17',b'Reject',b'atmesti'
+b'DocType: Journal Entry Account',b'Debit in Company Currency',b'Debeto \xc4\xafmon\xc4\x97je Valiuta'
+b'DocType: BOM Item',b'BOM Item',b'BOM punktas'
+b'DocType: Appraisal',b'For Employee',b'darbuotojo'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49',b'Make Disbursement Entry',b'Padaryti I\xc5\xa1mok \xc3\xb7 jimo \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138',b'Row {0}: Advance against Supplier must be debit',b'Eilut\xc4\x97s {0}: I\xc5\xa1ankstinis prie\xc5\xa1 Tiek\xc4\x97jas turi b\xc5\xabti nura\xc5\xa1yti'
+b'DocType: Company',b'Default Values',b'numatytosios vert\xc4\x97s'
+b'DocType: Membership',b'INR',b'INR'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60',b'{frequency} Digest',"b'{frequency} Santrauka ""'"
+b'DocType: Expense Claim',b'Total Amount Reimbursed',b'I\xc5\xa1 viso kompensuojama suma'
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5',b'This is based on logs against this Vehicle. See timeline below for details',b'Tai grind\xc5\xbeiama r\xc4\x85st\xc5\xb3 prie\xc5\xa1 \xc5\xa1i\xc4\x85 transporto priemon\xc4\x99. \xc5\xbdi\xc5\xabr\xc4\x97ti grafikas \xc5\xbeemiau detales'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90',b'Against Supplier Invoice {0} dated {1}',b'Prie\xc5\xa1 tiek\xc4\x97jo s\xc4\x85skaitoje {0} data {1}'
+b'DocType: Customer',b'Default Price List',b'Numatytasis Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +322',b'Asset Movement record {0} created',b'Turto Jud\xc4\x97jimo \xc4\xafra\xc5\xa1as {0} suk\xc5\xabr\xc4\x97'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51',b'You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings',b'J\xc5\xabs negalite trinti finansiniai metai {0}. Finansiniai metai {0} yra numatytoji Global Settings'
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20',b'A customer with the same name already exists',b'Tokio paties kliento klientas jau egzistuoja'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185',b'This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?',b'Tai pateikia Atlyginimo lapelius ir sukuria kaupimo \xc5\xbeurnalo \xc4\xafra\xc5\xa1\xc4\x85. Ar norite testi?'
+b'DocType: Purchase Invoice',b'Total Net Weight',b'Bendras grynasis svoris'
+b'DocType: Purchase Invoice',b'Eligibility For ITC',b'Tinkamumas ITC'
+b'DocType: Journal Entry',b'Entry Type',b'\xc4\xafra\xc5\xa1o tipas'
+,b'Customer Credit Balance',b'Klient\xc5\xb3 kredito liku\xc4\x8dio'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28',b'Net Change in Accounts Payable',b'Grynasis pokytis mok\xc4\x97tinos sumos'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'EcritureLet',b'&quot;EcritureLet&quot;'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +209',b'Credit limit has been crossed for customer {0} ({1}/{2})',b'Kredito limitas buvo perkeltas klientui {0} ({1} / {2})'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42',"b""Customer required for 'Customerwise Discount'""",b'Klient\xc5\xb3 reikalinga &quot;Customerwise nuolaid\xc5\xb3&quot;'
+b'apps/erpnext/erpnext/config/accounts.py +140',b'Update bank payment dates with journals.',b'Atnaujinkite banko mok\xc4\x97jimo datos ir \xc5\xbeurnaluose.'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21',b'Pricing',b'Kainos'
+b'DocType: Quotation',b'Term Details',b'Terminuoti detal\xc4\x97s'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30',b'Cannot enroll more than {0} students for this student group.',b'Negalima registruotis daugiau nei {0} studentams \xc5\xa1io student\xc5\xb3 grup\xc4\x99.'
+b'apps/erpnext/erpnext/templates/print_formats/includes/total.html +4',b'Total (Without Tax)',b'I\xc5\xa1 viso (be mokes\xc4\x8dio)'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'\xc5\xa0vinas Grafas'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'\xc5\xa0vinas Grafas'
+b'apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15',b'{0} must be greater than 0',b'{0} turi b\xc5\xabti didesnis nei 0'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30',b'Stock Available',b'Sand\xc4\x97lyje galima'
+b'DocType: Manufacturing Settings',b'Capacity Planning For (Days)',b'Talpa planavimas (dienos)'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10',b'Procurement',b'Vie\xc5\xa1\xc5\xb3j\xc5\xb3 pirkim\xc5\xb3'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66',b'None of the items have any change in quantity or value.',b'N\xc4\x97 vienas i\xc5\xa1 daikt\xc5\xb3 turite koki\xc5\xb3 nors kiekio ar vert\xc4\x97s poky\xc4\x8dius.'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Privalomas laukas - Programa'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Privalomas laukas - Programa'
+b'DocType: Special Test Template',b'Result Component',b'Rezultato komponentas'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46',b'Warranty Claim',b'Garantija Pretenzija'
+,b'Lead Details',b'\xc5\xa0vino detal\xc4\x97s'
+b'DocType: Volunteer',b'Availability and Skills',b'Prieinamumas ir \xc4\xafg\xc5\xabd\xc5\xbeiai'
+b'DocType: Salary Slip',b'Loan repayment',b'paskolos gr\xc4\x85\xc5\xbeinimo'
+b'DocType: Purchase Invoice',"b""End date of current invoice's period""",b'Pabaigos data einam\xc5\xb3j\xc5\xb3 s\xc4\x85skaitos fakt\xc5\xabros laikotarp\xc4\xaf'
+b'DocType: Pricing Rule',b'Applicable For',b'taikytina'
+b'DocType: Lab Test',b'Technician Name',b'Technikos vardas'
+b'DocType: Accounts Settings',b'Unlink Payment on Cancellation of Invoice',b'Atsieti Apmok\xc4\x97jimas at\xc5\xa1aukimas s\xc4\x85skaita fakt\xc5\xabra'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16',b'Current Odometer reading entered should be greater than initial Vehicle Odometer {0}',b'Dabartinis Odometro skaitymo \xc4\xafvesta tur\xc4\x97t\xc5\xb3 b\xc5\xabti didesnis nei pradinis transporto priemon\xc4\x97s hodometro {0}'
+b'DocType: Restaurant Reservation',b'No Show',b'Nr \xc5\xa1ou'
+b'DocType: Shipping Rule Country',b'Shipping Rule Country',b'Pristatymas taisykl\xc4\x97 \xc5\xa0alis'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10',b'Leave and Attendance',b'Palikite ir lankymas'
+b'DocType: Maintenance Visit',b'Partially Completed',b'dalinai u\xc5\xbepildyt\xc4\x85'
+b'apps/erpnext/erpnext/healthcare/setup.py +257',b'Moderate Sensitivity',b'Vidutinis jautrumas'
+b'DocType: Leave Type',b'Include holidays within leaves as leaves',b'\xc4\xaetraukti atostogas per lapus kaip lapai'
+b'DocType: Sales Invoice',b'Packed Items',b'Fasuoti daiktai'
+b'apps/erpnext/erpnext/config/support.py +27',b'Warranty Claim against Serial No.',b'Garantija pretenzija Serijos Nr'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197',"b""'Total'""",b'&quot;I\xc5\xa1 viso&quot;'
+b'DocType: Shopping Cart Settings',b'Enable Shopping Cart',b'\xc4\xaejungti Preki\xc5\xb3 krep\xc5\xa1elis'
+b'DocType: Employee',b'Permanent Address',b'Nuolatinis adresas'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260',b'Advance paid against {0} {1} cannot be greater \\\n\t\t\t\t\t\tthan Grand Total {2}',b'I\xc5\xa1 anksto sumok\xc4\x97ta prie\xc5\xa1 {0} {1} negali b\xc5\xabti didesnis \\ nei I\xc5\xa0 VISO {2}'
+b'DocType: Consultation',b'Medication',b'Vaistas'
+b'DocType: Production Plan',b'Include Non Stock Items',b'\xc4\xaetraukti sand\xc4\x97lyje n\xc4\x97ra atsarg\xc5\xb3'
+b'DocType: Project Update',b'Challenging/Slow',b'I\xc5\xa1\xc5\xa1\xc5\xabkis / l\xc4\x97tas'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147',b'Please select item code',b'Pra\xc5\xa1ome pasirinkti Prek\xc4\x97s kodas'
+b'DocType: Student Sibling',b'Studying in Same Institute',b'Studijos pa\xc4\x8diu instituto'
+b'DocType: Territory',b'Territory Manager',b'teritorija direktorius'
+b'DocType: Packed Item',b'To Warehouse (Optional)',b'\xc4\xae sand\xc4\x97l\xc4\xaf (neprivalomas)'
+b'DocType: GST Settings',b'GST Accounts',b'GST s\xc4\x85skaitos'
+b'DocType: Payment Entry',b'Paid Amount (Company Currency)',b'Mokama suma (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Purchase Invoice',b'Additional Discount',b'Papildoma nuolaida'
+b'DocType: Selling Settings',b'Selling Settings',b'parduoda Nustatymai'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83',b'Confirm Action',b'Patvirtinti veiksm\xc4\x85'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39',b'Online Auctions',b'Dabar Aukcionai'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100',b'Please specify either Quantity or Valuation Rate or both',b'Pra\xc5\xa1ome nurodyti arba kiekis ar Vertinimo norma arba abu'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18',b'Fulfillment',b'\xc4\xafvykdymas'
+b'apps/erpnext/erpnext/templates/generators/item.html +82',b'View in Cart',b'\xc5\xbdi\xc5\xabr\xc4\x97ti krep\xc5\xa1el\xc4\xaf'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103',b'Marketing Expenses',b'rinkodaros i\xc5\xa1laidos'
+,b'Item Shortage Report',b'Prek\xc4\x97 tr\xc5\xabkumas ataskaita'
+b'apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15',"b""Can't create standard criteria. Please rename the criteria""",b'Negalima sukurti standartini\xc5\xb3 kriterij\xc5\xb3. Pervardykite kriterijus'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +311',"b'Weight is mentioned,\\nPlease mention ""Weight UOM"" too'",b'Svoris pamin\xc4\x97ta \\ nL\xc5\xabdzu pamin\xc4\x97ti &quot;Svoris UOM&quot; per'
+b'DocType: Stock Entry Detail',b'Material Request used to make this Stock Entry',"b'Med\xc5\xbeiaga Pra\xc5\xa1ymas naudojamas, kad \xc5\xa1i\xc5\xb3 i\xc5\xa1tekli\xc5\xb3 \xc4\xafra\xc5\xa1as'"
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +68',b'Next Depreciation Date is mandatory for new asset',b'Kitas Nusid\xc4\x97v\xc4\x97jimas data yra privalomas naujo turto'
+b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Atskiras kursas grind\xc5\xbeiamas grup\xc4\x97 kiekvien\xc4\x85 partij\xc4\x85'
+b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Atskiras kursas grind\xc5\xbeiamas grup\xc4\x97 kiekvien\xc4\x85 partij\xc4\x85'
+b'apps/erpnext/erpnext/config/support.py +32',b'Single unit of an Item.',b'Vieno vieneto element\xc4\x85.'
+b'DocType: Fee Category',b'Fee Category',b'mokestis Kategorija'
+b'DocType: Agriculture Task',b'Next Business Day',b'Kitas verslo diena'
+b'DocType: Drug Prescription',b'Dosage by time interval',b'Dozavimas pagal laiko interval\xc4\x85'
+b'DocType: Cash Flow Mapper',b'Section Header',b'Skirsnio antra\xc5\xa1t\xc4\x97'
+,b'Student Fee Collection',b'Student\xc5\xb3 mokestis kolekcija'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24',b'Appointment Duration (mins)',b'Paskyrimo trukm\xc4\x97 (min.)'
+b'DocType: Accounts Settings',b'Make Accounting Entry For Every Stock Movement',b'Padaryti apskaitos \xc4\xafra\xc5\xa1as Kiekvienas vertybini\xc5\xb3 popieri\xc5\xb3 jud\xc4\x97jimo'
+b'DocType: Leave Allocation',b'Total Leaves Allocated',b'I\xc5\xa1 viso Lapai Paskirti'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163',b'Warehouse required at Row No {0}',b'Sand\xc4\x97li\xc5\xb3 reikalaujama Row Nr {0}'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +145',b'Please enter valid Financial Year Start and End Dates',b'Pra\xc5\xa1ome \xc4\xafvesti galiojant\xc4\xaf finansini\xc5\xb3 met\xc5\xb3 prad\xc5\xbeios ir pabaigos datos'
+b'DocType: Employee',b'Date Of Retirement',b'Data nuo i\xc5\xa1\xc4\x97jimo \xc4\xaf pensij\xc4\x85'
+b'DocType: Upload Attendance',b'Get Template',b'Gauk \xc5\xa1ablon\xc4\x85'
+b'DocType: Material Request',b'Transferred',b'Perduotas'
+b'DocType: Vehicle',b'Doors',b'durys'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117',b'ERPNext Setup Complete!',b'ERPNext s\xc4\x85ranka baigta'
+b'DocType: Healthcare Settings',b'Collect Fee for Patient Registration',b'Rinkti paciento registracijos mokest\xc4\xaf'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +678',b'Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item',b'Negalima keisti po\xc5\xbeymi\xc5\xb3 po atsarg\xc5\xb3 sandorio. Padarykite nauj\xc4\x85 prek\xc4\x99 ir perkelkite akcijas \xc4\xaf nauj\xc4\x85 prek\xc4\x99'
+b'DocType: Course Assessment Criteria',b'Weightage',b'weightage'
+b'DocType: Purchase Invoice',b'Tax Breakup',b'mokes\xc4\x8di\xc5\xb3 Breakup'
+b'DocType: Packing Slip',b'PS-',b'PS'
+b'DocType: Member',b'Non Profit Member',b'Ne pelno narys'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67',"b""{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.""",b'{0} {1}: Kaina centras yra reikalingas &quot;Pelno ir nuostolio&quot; s\xc4\x85skaitos {2}. Pra\xc5\xa1ome \xc4\xafkurti numatyt\xc4\x85j\xc4\x85 s\xc4\x85naud\xc5\xb3 centro bendrovei.'
+b'DocType: Payment Schedule',b'Payment Term',b'Mok\xc4\x97jimo terminas'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +160',b'A Customer Group exists with same name please change the Customer name or rename the Customer Group',b'Klient\xc5\xb3 grup\xc4\x97 egzistuoja to paties pavadinimo pra\xc5\xa1ome pakeisti kliento vard\xc4\x85 arba pervardyti klient\xc5\xb3 grupei'
+b'DocType: Land Unit',b'Area',b'Plotas'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +37',b'New Contact',b'nauja Susisiekite'
+b'DocType: Territory',b'Parent Territory',b't\xc4\x97v\xc5\xb3 teritorija'
+b'DocType: Purchase Invoice',b'Place of Supply',b'Tiekimo vieta'
+b'DocType: Quality Inspection Reading',b'Reading 2',b'Skaitymas 2'
+b'DocType: Stock Entry',b'Material Receipt',b'med\xc5\xbeiaga gavimas'
+b'DocType: Homepage',b'Products',b'produktai'
+b'DocType: Announcement',b'Instructor',b'Instruktorius'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61',b'Select Item (optional)',b'Pasirinkite element\xc4\x85 (neprivaloma)'
+b'DocType: Fee Schedule Student Group',b'Fee Schedule Student Group',b'Mokes\xc4\x8di\xc5\xb3 lentel\xc4\x97 Student\xc5\xb3 grup\xc4\x97'
+b'DocType: Student',b'AB+',b'AB &quot;+&quot;'
+b'DocType: Item',"b'If this item has variants, then it cannot be selected in sales orders etc.'","b'Jei \xc5\xa1i prek\xc4\x97 yra variant\xc5\xb3, tada jis negali b\xc5\xabti parenkamos pardavimo u\xc5\xbesakymus ir tt'"
+b'DocType: Lead',b'Next Contact By',b'Kitas Susisiekti'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325',b'Quantity required for Item {0} in row {1}',b'reikalingas punktas {0} i\xc5\xa1 eil\xc4\x97s Kiekis {1}'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45',b'Warehouse {0} can not be deleted as quantity exists for Item {1}',"b'Sand\xc4\x97li\xc5\xb3 {0} negali b\xc5\xabti i\xc5\xa1brauktas, nes egzistuoja kiekis u\xc5\xbe prek\xc4\x99 {1}'"
+b'DocType: Quotation',b'Order Type',b'pavedimo tipas'
+,b'Item-wise Sales Register',b'Prek\xc4\x97 i\xc5\xa1mintingas Pardavim\xc5\xb3 Registruotis'
+b'DocType: Asset',b'Gross Purchase Amount',b'Pilna Pirkimo suma'
+b'apps/erpnext/erpnext/utilities/user_progress.py +39',b'Opening Balances',b'Atidarymo liku\xc4\x8diai'
+b'DocType: Asset',b'Depreciation Method',b'nusid\xc4\x97v\xc4\x97jimo metodas'
+b'DocType: Purchase Taxes and Charges',b'Is this Tax included in Basic Rate?',b'Ar \xc5\xa1is mokestis \xc4\xaftrauktas \xc4\xaf bazin\xc4\x99 pal\xc5\xabkan\xc5\xb3 norm\xc4\x85?'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Target',b'I\xc5\xa1 viso Tikslin\xc4\x97'
+b'DocType: Soil Texture',b'Sand Composition (%)',b'Sm\xc4\x97lio sudedamoji dalis (%)'
+b'DocType: Job Applicant',b'Applicant for a Job',b'Parei\xc5\xa1k\xc4\x97jas d\xc4\x97l darbo'
+b'DocType: Production Plan Material Request',b'Production Plan Material Request',b'Gamybos planas Med\xc5\xbeiaga Pra\xc5\xa1ymas'
+b'DocType: Stock Reconciliation',b'Reconciliation JSON',b'susitaikymas JSON'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.html +3',b'Too many columns. Export the report and print it using a spreadsheet application.',b'Per daug stulpeli\xc5\xb3. Eksportuoti ataskait\xc4\x85 ir j\xc4\xaf atspausdinti naudojant skai\xc4\x8diuokl\xc4\x97s program\xc4\x85.'
+b'DocType: Purchase Invoice Item',b'Batch No',b'Serijos Nr'
+b'DocType: Selling Settings',"b""Allow multiple Sales Orders against a Customer's Purchase Order""",b'Leisti kelis pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 prie\xc5\xa1 Kliento U\xc5\xbesakymo'
+b'DocType: Student Group Instructor',b'Student Group Instructor',b'Student\xc5\xb3 grup\xc4\x97 instruktorius'
+b'DocType: Student Group Instructor',b'Student Group Instructor',b'Student\xc5\xb3 grup\xc4\x97 instruktorius'
+b'DocType: Grant Application',b'Assessment  Mark (Out of 10)',b'Vertinimo \xc5\xbeenklas (i\xc5\xa1 10)'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61',b'Guardian2 Mobile No',b'Guardian2 Mobilus N\xc4\x97ra'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +218',b'Main',b'pagrindinis'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +72',b'Variant',b'variantas'
+b'DocType: Naming Series',b'Set prefix for numbering series on your transactions',b'Nustatyti prie\xc5\xa1d\xc4\x97lis numeracijos serij\xc4\x85 apie sandorius savo'
+b'DocType: Employee Attendance Tool',b'Employees HTML',b'darbuotojai HTML'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +458',b'Default BOM ({0}) must be active for this item or its template',b'Numatytasis BOM ({0}) turi b\xc5\xabti aktyvus \xc5\xa1i\xc4\x85 prek\xc4\x99 ar jo \xc5\xa1ablon\xc4\x85'
+b'DocType: Employee',b'Leave Encashed?',b'Palikite Encashed?'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32',b'Opportunity From field is mandatory',b'Galimyb\xc4\x97 Nuo srityje yra privalomas'
+b'DocType: Email Digest',b'Annual Expenses',b'metin\xc4\x97s i\xc5\xa1laidos'
+b'DocType: Item',b'Variants',b'variantai'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1148',b'Make Purchase Order',b'Padaryti pirkini\xc5\xb3 u\xc5\xbesakym\xc4\x85'
+b'DocType: SMS Center',b'Send To',b'si\xc5\xb3sti'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133',b'There is not enough leave balance for Leave Type {0}',b'N\xc4\x97ra pakankamai atostogos balansas Palikti tipas {0}'
+b'DocType: Payment Reconciliation Payment',b'Allocated amount',b'skirtos sumos'
+b'DocType: Sales Team',b'Contribution to Net Total',b'Ind\xc4\x97lis \xc4\xaf grynuosius'
+b'DocType: Sales Invoice Item',"b""Customer's Item Code""",b'Kliento punktas kodas'
+b'DocType: Stock Reconciliation',b'Stock Reconciliation',b'akcij\xc5\xb3 suderinimas'
+b'DocType: Territory',b'Territory Name',b'teritorija Vardas'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204',b'Work-in-Progress Warehouse is required before Submit',b'Darbas-in-progress sand\xc4\x97lio reikalingas prie\xc5\xa1 Pateikti'
+b'apps/erpnext/erpnext/config/hr.py +40',b'Applicant for a Job.',b'Kandidatui \xc4\xaf darb\xc4\x85.'
+b'DocType: Purchase Order Item',b'Warehouse and Reference',b'Sand\xc4\x97liavimo ir nuoroda'
+b'DocType: Supplier',b'Statutory info and other general information about your Supplier',b'Teis\xc4\x97s akt\xc5\xb3 informacijos ir kita bendra informacija apie j\xc5\xabs\xc5\xb3 tiek\xc4\x97jas'
+b'DocType: Item',b'Serial Nos and Batches',b'Eil\xc4\x97s Nr ir Partijos'
+b'DocType: Item',b'Serial Nos and Batches',b'Eil\xc4\x97s Nr ir Partijos'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'Student\xc5\xb3 grup\xc4\x97 Stiprumas'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'Student\xc5\xb3 grup\xc4\x97 Stiprumas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261',b'Against Journal Entry {0} does not have any unmatched {1} entry',b'Prie\xc5\xa1 leidinyje \xc4\xae\xc4\x97jimo {0} neturi neprilygstam\xc4\x85 {1} \xc4\xafra\xc5\xa1\xc4\x85'
+b'apps/erpnext/erpnext/config/hr.py +142',b'Appraisals',b'vertinimai'
+b'apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8',b'Training Events',b'Mokymo renginiai'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205',b'Duplicate Serial No entered for Item {0}',b'Duplicate Serijos Nr \xc4\xafvestas punkte {0}'
+b'apps/erpnext/erpnext/config/selling.py +179',b'Track Leads by Lead Source.',b'Steb\xc4\x97kite laid\xc5\xb3 \xc5\xa1altinius.'
+b'DocType: Shipping Rule Condition',b'A condition for a Shipping Rule',b'S\xc4\x85lyga laivybos taisykl\xc4\x97s'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +167',b'Please enter ',b'Pra\xc5\xa1ome \xc4\xafvesti'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43',b'Maintenance Log',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros \xc5\xbeurnalas'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236',b'Please set filter based on Item or Warehouse',b'Pra\xc5\xa1ome nustatyti filtr\xc4\x85 remiantis punkt\xc4\x85 arba sand\xc4\x97lyje'
+b'DocType: Packing Slip',b'The net weight of this package. (calculated automatically as sum of net weight of items)',b'Grynasis svoris \xc5\xa1io paketo. (Skai\xc4\x8diuojama automati\xc5\xa1kai suma neto mas\xc4\x97 daikt\xc5\xb3)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +802',b'Discount amount cannot be greater than 100%',b'Nuolaida negali b\xc5\xabti didesn\xc4\x97 nei 100%'
+b'DocType: Sales Order',b'To Deliver and Bill',b'Pristatyti ir Bill'
+b'DocType: Student Group',b'Instructors',b'instruktoriai'
+b'DocType: GL Entry',b'Credit Amount in Account Currency',b'Kredito sum\xc4\x85 s\xc4\x85skaitos valiuta'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +603',b'BOM {0} must be submitted',b'BOM {0} turi b\xc5\xabti pateiktas'
+b'apps/erpnext/erpnext/config/accounts.py +460',b'Share Management',b'Dalinkis valdymu'
+b'DocType: Authorization Control',b'Authorization Control',b'autorizacija Valdymo'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +317',b'Row #{0}: Rejected Warehouse is mandatory against rejected Item {1}',b'Eilut\xc4\x97s # {0}: Atmesta Sand\xc4\x97lis yra privalomas prie\xc5\xa1 atmet\xc4\x97 punkte {1}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Payment',b'mok\xc4\x97jimas'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +92',"b'Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.'","b'Sand\xc4\x97li\xc5\xb3 {0} n\xc4\x97ra susij\xc4\x99s su bet kokios s\xc4\x85skaitos, nurodykite Sand\xc4\x97l\xc4\xaf \xc4\xafra\xc5\xa1o s\xc4\x85skait\xc4\x85 arba nustatyti numatyt\xc4\x85j\xc4\x85 inventoriaus s\xc4\x85skait\xc4\x85 \xc4\xafmon\xc4\x99 {1}.'"
+b'apps/erpnext/erpnext/utilities/activation.py +81',b'Manage your orders',b'Tvarkykite savo u\xc5\xbesakymus'
+b'DocType: Work Order Operation',b'Actual Time and Cost',b'Tikrasis Laikas ir kaina'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56',b'Material Request of maximum {0} can be made for Item {1} against Sales Order {2}',b'Med\xc5\xbeiaga Pra\xc5\xa1ymas maksimali\xc5\xb3 {0} galima u\xc5\xbe prek\xc4\x99 {1} prie\xc5\xa1 Pardavim\xc5\xb3 ordino {2}'
+b'DocType: Crop',b'Crop Spacing',b'Pas\xc4\x97li\xc5\xb3 atstumas'
+b'DocType: Course',b'Course Abbreviation',b'\xc5\xbdinoma santrumpa'
+b'DocType: Student Leave Application',b'Student Leave Application',b'Student\xc5\xb3 atostogos taikymas'
+b'DocType: Item',b'Will also apply for variants',b'Bus taikoma variant\xc5\xb3'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +217',"b'Asset cannot be cancelled, as it is already {0}'","b'Turto negali b\xc5\xabti at\xc5\xa1auktas, nes jis jau yra {0}'"
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29',b'Employee {0} on Half day on {1}',b'Darbuotoj\xc5\xb3 {0} pus\xc4\x99 dienos {1}'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42',b'Total working hours should not be greater than max working hours {0}',b'I\xc5\xa1 viso darbo valand\xc5\xb3 turi b\xc5\xabti ne didesnis nei maks darbo valand\xc5\xb3 {0}'
+b'apps/erpnext/erpnext/templates/pages/task_info.html +90',b'On',b'apie'
+b'apps/erpnext/erpnext/config/selling.py +62',b'Bundle items at time of sale.',b'Rinkinys daikt\xc5\xb3 metu pardavimas.'
+b'DocType: Material Request Plan Item',b'Actual Qty',b'Tikrasis Kiekis'
+b'DocType: Sales Invoice Item',b'References',b'Nuorodos'
+b'DocType: Quality Inspection Reading',b'Reading 10',b'Skaitymas 10'
+b'DocType: Item',b'Barcodes',b'Br\xc5\xabk\xc5\xa1niniai kodai'
+b'DocType: Hub Category',b'Hub Node',b'Stebul\xc4\x97s mazgas'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78',b'You have entered duplicate items. Please rectify and try again.',b'J\xc5\xabs \xc4\xafved\xc4\x97te pasikartojan\xc4\x8dius elementus. Pra\xc5\xa1ome i\xc5\xa1taisyti ir bandykite dar kart\xc4\x85.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129',b'Associate',b'Bendradarbis'
+b'DocType: Asset Movement',b'Asset Movement',b'turto jud\xc4\x97jimas'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508',b'Work Order {0} must be submitted',b'Darb\xc5\xb3 u\xc5\xbesakymas {0} turi b\xc5\xabti pateiktas'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2214',b'New Cart',b'nauja krep\xc5\xa1el\xc4\xaf'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44',b'Item {0} is not a serialized Item',b'Prek\xc4\x97 {0} n\xc4\x97ra i\xc5\xa1spausdintas punktas'
+b'DocType: SMS Center',b'Create Receiver List',b'Sukurti imtuvas s\xc4\x85ra\xc5\xa1as'
+b'DocType: Vehicle',b'Wheels',b'ratai'
+b'DocType: Packing Slip',b'To Package No.',b'Paketas Nr'
+b'DocType: Patient Relation',b'Family',b'\xc5\xa0eima'
+b'DocType: Production Plan',b'Material Requests',b'Med\xc5\xbeiaga Pra\xc5\xa1ymai'
+b'DocType: Warranty Claim',b'Issue Date',b'I\xc5\xa1davimo data'
+b'DocType: Activity Cost',b'Activity Cost',b'veiklos s\xc4\x85naudos'
+b'DocType: Sales Invoice Timesheet',b'Timesheet Detail',b'Lap\xc4\x85 detal\xc4\x97s'
+b'DocType: Purchase Receipt Item Supplied',b'Consumed Qty',b'suvartoti Kiekis'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52',b'Telecommunications',b'Telekomunikacijos'
+b'apps/erpnext/erpnext/accounts/party.py +263',"b""Billing currency must be equal to either default company's currency or party account currency""","b'Atsiskaitymo valiuta turi b\xc5\xabti lygi arba numatytojo \xc4\xafmon\xc4\x97s valiuta, arba \xc5\xa1alies s\xc4\x85skaitos valiuta'"
+b'DocType: Packing Slip',b'Indicates that the package is a part of this delivery (Only Draft)',"b'Nurodo, kad paketas yra \xc5\xa1io pristatymo (tik projekto) dalis'"
+b'DocType: Soil Texture',b'Loam',b'Loam'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +705',b'Row {0}: Due Date cannot be before posting date',b'Eilut\xc4\x97 {0}: mok\xc4\x97jimo data negali b\xc5\xabti prie\xc5\xa1 paskelbimo dat\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36',b'Make Payment Entry',b'Padaryti Mok\xc4\x97jimo \xc4\xafra\xc5\xa1\xc4\x85'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129',b'Quantity for Item {0} must be less than {1}',b'Kiekis u\xc5\xbe prek\xc4\x99 {0} turi b\xc5\xabti ma\xc5\xbeesnis nei {1}'
+,b'Sales Invoice Trends',b'Pardavimo s\xc4\x85skaita-fakt\xc5\xabra tendencijos'
+b'DocType: Leave Application',b'Apply / Approve Leaves',b'Taikyti / Patvirtinti lapai'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'For',b'D\xc4\x97l'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167',"b""Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'""",b'Gali kreiptis eilut\xc4\x99 tik jei \xc4\xafkrova tipas &quot;D\xc4\x97l ankstesn\xc4\x97s eil\xc4\x97s suma&quot; ar &quot;ankstesn\xc4\x97s eil\xc4\x97s Total&quot;'
+b'DocType: Sales Order Item',b'Delivery Warehouse',b'Pristatymas sand\xc4\x97lis'
+b'apps/erpnext/erpnext/config/accounts.py +241',b'Tree of financial Cost Centers.',b'Medis finansini\xc5\xb3 i\xc5\xa1laid\xc5\xb3 centrai.'
+b'DocType: Serial No',b'Delivery Document No',b'Pristatymas dokumentas Nr'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191',"b""Please set 'Gain/Loss Account on Asset Disposal' in Company {0}""",b'Pra\xc5\xa1ome nustatyti &quot;Gain / Loss s\xc4\x85skait\xc4\x85 turto perdavimo&quot; Bendrov\xc4\x97je {0}'
+b'DocType: Landed Cost Voucher',b'Get Items From Purchase Receipts',b'Gauti prekes i\xc5\xa1 \xc4\xafsigijimo kvitai'
+b'DocType: Serial No',b'Creation Date',b'Suk\xc5\xabrimo data'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33',b'Item {0} appears multiple times in Price List {1}',b'Prek\xc4\x97 {0} kainora\xc5\xa1tyje {1} rodoma kelet\xc4\x85 kart\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41',"b'Selling must be checked, if Applicable For is selected as {0}'","b'Parduodami turi b\xc5\xabti patikrinta, jei taikoma pasirinkta kaip {0}'"
+b'DocType: Production Plan Material Request',b'Material Request Date',b'Med\xc5\xbeiaga Pra\xc5\xa1ymas data'
+b'DocType: Purchase Order Item',b'Supplier Quotation Item',b'Tiek\xc4\x97jas Citata punktas'
+b'DocType: Student',b'Student Mobile Number',b'Student\xc5\xb3 Mobilusis Telefonas Numeris'
+b'DocType: Item',b'Has Variants',b'turi variantams'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +488',"b'Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings'","b'Negalima perduoti {0} {1} daugiau nei {2} eilut\xc4\x97je. Jei norite leisti pernumeruoti mokest\xc4\xaf, nustatykite Suvestin\xc4\x97s nustatymuose'"
+b'apps/erpnext/erpnext/templates/emails/training_event.html +11',b'Update Response',b'Atnaujinti atsakym\xc4\x85'
+b'apps/erpnext/erpnext/public/js/utils.js +232',b'You have already selected items from {0} {1}',b'J\xc5\xabs jau pasirinkote elementus i\xc5\xa1 {0} {1}'
+b'DocType: Monthly Distribution',b'Name of the Monthly Distribution',b'Pavadinimas M\xc4\x97nesio pasiskirstymas'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Serija ID privalomi'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Serija ID privalomi'
+b'DocType: Sales Person',b'Parent Sales Person',b'T\xc4\x97v\xc5\xb3 pardavim\xc5\xb3 asmuo'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100',b'The seller and the buyer cannot be the same',b'Pardav\xc4\x97jas ir pirk\xc4\x97jas negali b\xc5\xabti vienodi'
+b'DocType: Project',b'Collect Progress',b'Rinkti pa\xc5\xbeang\xc4\x85'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24',b'Select the program first',b'Pirmiausia pasirinkite program\xc4\x85'
+b'DocType: Patient Appointment',b'Patient Age',b'Paciento am\xc5\xbeius'
+b'apps/erpnext/erpnext/config/learn.py +253',b'Managing Projects',b'projekt\xc5\xb3 valdymas'
+b'DocType: Supplier',b'Supplier of Goods or Services.',b'Tiek\xc4\x97jas tiekiantis prekes ar paslaugas.'
+b'DocType: Budget',b'Fiscal Year',b'Fiskaliniai metai'
+b'DocType: Asset Maintenance Log',b'Planned',b'Planuojama'
+b'DocType: Healthcare Settings',b'Default receivable accounts to be used if not set in Patient to book Consultation charges.',"b'Numatytos gautinos s\xc4\x85skaitos, kurios bus naudojamos, jei nenustatytos Pacientui, kad gal\xc4\x97tum\xc4\x97te u\xc5\xbesisakyti konsultacij\xc5\xb3 mokes\xc4\x8dius.'"
+b'DocType: Vehicle Log',b'Fuel Price',b'kuro Kaina'
+b'DocType: Budget',b'Budget',b'biud\xc5\xbeetas'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65',b'Set Open',b'Nustatyti Atidaryti'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +258',b'Fixed Asset Item must be a non-stock item.',b'Ilgalaikio turto turi b\xc5\xabti ne akcij\xc5\xb3 punktas.'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50',"b""Budget cannot be assigned against {0}, as it's not an Income or Expense account""","b'Biud\xc5\xbeetas negali b\xc5\xabti skiriamas prie\xc5\xa1 {0}, nes tai ne pajamos ar s\xc4\x85naudos s\xc4\x85skaita'"
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51',b'Achieved',b'pasiektas'
+b'DocType: Student Admission',b'Application Form Route',b'Pra\xc5\xa1ymo forma Vartojimo b\xc5\xabdas'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66',b'Territory / Customer',b'Teritorija / Klient\xc5\xb3'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44',b'Leave Type {0} cannot be allocated since it is leave without pay',"b'Palikite tipas {0} negali b\xc5\xabti paskirstytos, nes ji yra palikti be darbo u\xc5\xbemokes\xc4\x8dio'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167',b'Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2}',b'Eilut\xc4\x97s {0}: Paskirti suma {1} turi b\xc5\xabti ma\xc5\xbeesnis arba lygus s\xc4\x85skait\xc4\x85 skolos likut\xc4\xaf {2}'
+b'DocType: Sales Invoice',b'In Words will be visible once you save the Sales Invoice.',"b'\xc5\xbdod\xc5\xbeiais bus matomas, kai \xc4\xafra\xc5\xa1ote pardavimo s\xc4\x85skaita-fakt\xc5\xabra.'"
+b'DocType: Lead',b'Follow Up',b'Sekti'
+b'DocType: Item',b'Is Sales Item',b'Ar Pardavim\xc5\xb3 punktas'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21',b'Item Group Tree',b'Prek\xc4\x97 Grup\xc4\x97 medis'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69',b'Item {0} is not setup for Serial Nos. Check Item master',b'Prek\xc4\x97 {0} n\xc4\x97ra setup Serijos Nr. Patikrinkite Element\xc4\x85 meistras'
+b'DocType: Maintenance Visit',b'Maintenance Time',b'Prie\xc5\xbei\xc5\xabros laikas'
+,b'Amount to Deliver',b'Suma pristatyti'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335',b'Same item has been entered multiple times. {0}',b'Tas pats elementas buvo \xc4\xafvestas kelet\xc4\x85 kart\xc5\xb3. {0}'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30',b'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.',"b'Term prad\xc5\xbeios data negali b\xc5\xabti v\xc4\x97lesn\xc4\x97 nei met\xc5\xb3 prad\xc5\xbeioje data mokslo metams, kuris terminas yra susij\xc4\x99s (akademiniai metai {}). I\xc5\xa1taisykite datas ir bandykite dar kart\xc4\x85.'"
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190',b'There were errors.',b'Nebuvo klaid\xc5\xb3.'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166',b'Employee {0} has already applied for {1} between {2} and {3} : ',b'Darbuotojas {0} jau pateik\xc4\x97 parai\xc5\xa1k\xc4\x85 {1} nuo {2} iki {3}:'
+b'DocType: Guardian',b'Guardian Interests',b'Guardian Pom\xc4\x97giai'
+b'DocType: Naming Series',b'Current Value',b'Dabartin\xc4\x97 vert\xc4\x97'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +273',b'Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year',b'Keli fiskalinius metus egzistuoja datos {0}. Pra\xc5\xa1ome nustatyti bendrov\xc4\x97s finansiniams metams'
+b'DocType: Education Settings',b'Instructor Records to be created by',"b'Instruktori\xc5\xb3 \xc4\xafra\xc5\xa1ai, kuriuos turi sukurti'"
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229',b'{0} created',b'{0} suk\xc5\xabr\xc4\x97'
+b'DocType: GST Account',b'GST Account',b'GST s\xc4\x85skaita'
+b'DocType: Delivery Note Item',b'Against Sales Order',b'Pagal Pardavimo U\xc5\xbesakym\xc4\x85'
+,b'Serial No Status',b'Serijos Nr B\xc5\xabsena'
+b'DocType: Payment Entry Reference',b'Outstanding',b'nei\xc5\xa1spr\xc4\x99stas'
+b'DocType: Supplier',b'Warn POs',b'\xc4\xaesp\xc4\x97ti PO'
+,b'Daily Timesheet Summary',b'Dienos Lap\xc4\x85 santrauka'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137',"b'Row {0}: To set {1} periodicity, difference between from and to date \\\n\t\t\t\t\t\tmust be greater than or equal to {2}'","b'Eilut\xc4\x97s {0}: Nor\xc4\x97dami nustatyti {1} periodi\xc5\xa1kumas, skirtumas tarp i\xc5\xa1 ir \xc4\xaf dat\xc4\x85 \\ turi b\xc5\xabti didesnis nei arba lygus {2}'"
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6',b'This is based on stock movement. See {0} for details',b'Tai remiantis akcij\xc5\xb3 jud\xc4\x97jimo. \xc5\xbdi\xc5\xabr\xc4\x97ti {0} daugiau informacijos'
+b'DocType: Pricing Rule',b'Selling',b'pardavimas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392',b'Amount {0} {1} deducted against {2}',b'Suma {0} {1} i\xc5\xa1skai\xc4\x8diuota nuo {2}'
+b'DocType: Employee',b'Salary Information',b'Pajamos Informacija'
+b'DocType: Sales Person',b'Name and Employee ID',b'Vardas ir darbuotojo ID'
+b'apps/erpnext/erpnext/accounts/party.py +308',b'Due Date cannot be before Posting Date',b'Terminas negali b\xc5\xabti prie\xc5\xa1 paskelbdami data'
+b'DocType: Website Item Group',b'Website Item Group',b'Interneto svetain\xc4\x97 punktas grup\xc4\x97'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463',b'No salary slip found to submit for the above selected criteria OR salary slip already submitted',"b'N\xc4\x97 vienas atlyginim\xc5\xb3 slipas, kuris buvo pateiktas d\xc4\x97l pirmiau nurodyt\xc5\xb3 kriterij\xc5\xb3 ar jau pateikto atlyginimo u\xc5\xbestato'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150',b'Duties and Taxes',b'Muitai ir mokes\xc4\x8diai'
+b'DocType: Projects Settings',b'Projects Settings',b'Projekt\xc5\xb3 nustatymai'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356',b'Please enter Reference date',b'Pra\xc5\xa1ome \xc4\xafvesti Atskaitos data'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44',b'{0} payment entries can not be filtered by {1}',b'{0} mok\xc4\x97jimo \xc4\xafra\xc5\xa1ai negali b\xc5\xabti filtruojami pagal {1}'
+b'DocType: Item Website Specification',b'Table for Item that will be shown in Web Site',"b'Staliukas element\xc4\x85, kuris bus rodomas svetain\xc4\x97je'"
+b'DocType: Purchase Order Item Supplied',b'Supplied Qty',b'Tiekiami Kiekis'
+b'DocType: Purchase Order Item',b'Material Request Item',b'Med\xc5\xbeiaga Pra\xc5\xa1ymas punktas'
+b'apps/erpnext/erpnext/config/selling.py +75',b'Tree of Item Groups.',b'Medis punktas grupes.'
+b'DocType: Production Plan',b'Total Produced Qty',b'Bendras pagamintas kiekis'
+b'DocType: Payroll Entry',b'Get Employee Details',b'Gaukite darbuotoj\xc5\xb3 informacij\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177',b'Cannot refer row number greater than or equal to current row number for this Charge type',b'Negali remtis eilut\xc4\x97s skai\xc4\x8dius didesnis nei arba lygus dabartin\xc4\x97s eilut\xc4\x97s numeris \xc5\xa0io mokes\xc4\x8dio tip\xc4\x85'
+b'DocType: Asset',b'Sold',b'parduota'
+,b'Item-wise Purchase History',b'Prek\xc4\x97 i\xc5\xa1mintingas pirkimas Istorija'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230',"b""Please click on 'Generate Schedule' to fetch Serial No added for Item {0}""",b'Pra\xc5\xa1ome spausti &quot;Generuoti grafik\xc4\x85&quot; parsi\xc5\xb3sti Serijos Nr prid\xc4\x97ta punkte {0}'
+b'DocType: Account',b'Frozen',b'u\xc5\xbe\xc5\xa1al\xc4\x99s'
+b'DocType: Sales Invoice Payment',b'Base Amount (Company Currency)',b'Bazin\xc4\x97 suma (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928',b'Raw Materials',b'\xc5\xbdaliavos'
+b'DocType: Payment Reconciliation Payment',b'Reference Row',b'nuoroda eilut\xc4\x97'
+b'DocType: Installation Note',b'Installation Time',b'montavimo laikas'
+b'DocType: Sales Invoice',b'Accounting Details',b'apskaitos informacija'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +113',b'Delete all the Transactions for this Company',b'I\xc5\xa1trinti visus sandori\xc5\xb3 \xc5\xa1iai bendrovei'
+b'DocType: Patient',b'O Positive',b'O teigiamas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68',b'Investments',b'investicijos'
+b'DocType: Issue',b'Resolution Details',b'geba detal\xc4\x97s'
+b'apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3',b'Allocations',b'asignavimai'
+b'DocType: Item Quality Inspection Parameter',b'Acceptance Criteria',b'priimtinumo kriterijai'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159',b'Please enter Material Requests in the above table',b'Pra\xc5\xa1ome \xc4\xafvesti Materialieji pra\xc5\xa1ymus pirmiau pateiktoje lentel\xc4\x97je'
+b'DocType: Item Attribute',b'Attribute Name',b'atributo pavadinimas'
+b'DocType: BOM',b'Show In Website',b'Rodyti svetain\xc4\x97'
+b'DocType: Shopping Cart Settings',b'Show Quantity in Website',b'Rodyti Kiekis svetain\xc4\x97'
+b'DocType: Employee Loan Application',b'Total Payable Amount',b'I\xc5\xa1 viso mok\xc4\x97tina suma'
+b'DocType: Task',b'Expected Time (in hours)',b'Numatomas laikas (valandomis)'
+b'DocType: Item Reorder',b'Check in (group)',b'Atvykimas (grup\xc4\x97)'
+b'DocType: Soil Texture',b'Silt',b'Silt'
+,b'Qty to Order',b'Kiekis u\xc5\xbesisakyti'
+b'DocType: Period Closing Voucher',"b'The account head under Liability or Equity, in which Profit/Loss will be booked'","b'S\xc4\x85skaitos galva pagal \xc4\xafsipareigojim\xc4\x85 arba nuosavyb\xc4\x97s, kurioje Pelnas / nuostolis bus nubaustas'"
+b'apps/erpnext/erpnext/config/projects.py +36',b'Gantt chart of all tasks.',b'Ganto diagrama vis\xc5\xb3 u\xc5\xbeduo\xc4\x8di\xc5\xb3.'
+b'DocType: Opportunity',b'Mins to First Response',b'Min First Response'
+b'DocType: Pricing Rule',b'Margin Type',b'mar\xc5\xbea tipas'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15',b'{0} hours',b'{0} valandos'
+b'DocType: Course',b'Default Grading Scale',b'Numatytasis vertinimo skal\xc4\x97'
+b'DocType: Appraisal',b'For Employee Name',b'Darbuotojo Vardas'
+b'DocType: Holiday List',b'Clear Table',b'I\xc5\xa1valyti lentel\xc4\x97'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119',b'Available slots',b'Galimos laiko tarpsniai'
+b'DocType: C-Form Invoice Detail',b'Invoice No',b's\xc4\x85skaitoje Nr'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363',b'Make Payment',b'Sumok\xc4\x97ti'
+b'DocType: Room',b'Room Name',b'Kambari\xc5\xb3 Vardas'
+b'DocType: Prescription Duration',b'Prescription Duration',b'Recepto trukm\xc4\x97'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81',"b'Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Palikite negali b\xc5\xabti taikomas / at\xc5\xa1auk\xc4\x97 prie\xc5\xa1 {0}, kaip atostogos balansas jau perk\xc4\x97limo persiun\xc4\x8diami b\xc5\xabsimos atostogos paskirstymo \xc4\xafra\xc5\xa1o {1}'"
+b'DocType: Activity Cost',b'Costing Rate',b'S\xc4\x85naud\xc5\xb3 norma'
+b'apps/erpnext/erpnext/config/selling.py +234',b'Customer Addresses And Contacts',b'Klient\xc5\xb3 Adresai ir kontaktai'
+,b'Campaign Efficiency',b'kampanija efektyvumas'
+,b'Campaign Efficiency',b'kampanija efektyvumas'
+b'DocType: Discussion',b'Discussion',b'Diskusija'
+b'DocType: Payment Entry',b'Transaction ID',b'sandorio ID'
+b'DocType: Volunteer',b'Anytime',b'Anytime'
+b'DocType: Patient',b'Surgical History',b'Chirurgin\xc4\x97 istorija'
+b'DocType: Employee',b'Resignation Letter Date',b'Atsistatydinimas ra\xc5\xa1tas data'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39',b'Pricing Rules are further filtered based on quantity.',b'Kainodaros taisykl\xc4\x97s yra toliau filtruojamas remiantis kiek\xc4\xaf.'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127',b'Not Set',b'nenustatyta'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Pra\xc5\xa1ome nustatykite data Prisijungimas darbuotojo {0}'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Pra\xc5\xa1ome nustatykite data Prisijungimas darbuotojo {0}'
+b'DocType: Task',b'Total Billing Amount (via Time Sheet)',b'I\xc5\xa1 viso Atsiskaitymo suma (per Time lapas)'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61',b'Repeat Customer Revenue',b'Pakartokite Klient\xc5\xb3 pajamos'
+b'DocType: Soil Texture',b'Silty Clay Loam',b'\xc5\xa0ilkmed\xc5\xbeio sluoksnis'
+b'DocType: Chapter',b'Chapter',b'Skyrius'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Pair',b'Pora'
+b'DocType: Mode of Payment Account',b'Default account will be automatically updated in POS Invoice when this mode is selected.',"b'Numatytoji paskyra bus automati\xc5\xa1kai atnaujinama POS s\xc4\x85skaitoje, kai bus pasirinktas \xc5\xa1is re\xc5\xbeimas.'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970',b'Select BOM and Qty for Production',b'Pasirinkite BOM ir Kiekis d\xc4\x97l gamybos'
+b'DocType: Asset',b'Depreciation Schedule',b'Nusid\xc4\x97v\xc4\x97jimas Tvarkara\xc5\xa1tis'
+b'apps/erpnext/erpnext/config/selling.py +124',b'Sales Partner Addresses And Contacts',b'Pardavim\xc5\xb3 Partneri\xc5\xb3 Adresai ir kontaktai'
+b'DocType: Bank Reconciliation Detail',b'Against Account',b'prie\xc5\xa1 s\xc4\x85skaita'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52',b'Half Day Date should be between From Date and To Date',b'Pus\xc4\x97 dienos data turi b\xc5\xabti tarp Nuo datos ir iki \xc5\xa1iol'
+b'DocType: Maintenance Schedule Detail',b'Actual Date',b'Tikrasis data'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139',b'Please set the Default Cost Center in {0} company.',b'Nustatykite &quot;Numatyt\xc5\xb3j\xc5\xb3 kain\xc5\xb3 centro&quot; skai\xc4\x8di\xc5\xb3 {0} kompanijoje.'
+b'DocType: Item',b'Has Batch No',b'Turi Serijos Nr'
+b'apps/erpnext/erpnext/public/js/utils.js +106',b'Annual Billing: {0}',b'Metin\xc4\x97 Atsiskaitymo: {0}'
+b'apps/erpnext/erpnext/config/accounts.py +200',b'Goods and Services Tax (GST India)',b'Preki\xc5\xb3 ir paslaug\xc5\xb3 mokes\xc4\x8dio (PVM Indija)'
+b'DocType: Delivery Note',b'Excise Page Number',b'Akcizo puslapio numeris'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227',"b'Company, From Date and To Date is mandatory'","b'\xc4\xaemon\xc4\x97s, Nuo datos ir iki \xc5\xa1iol yra privalomi'"
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33',b'Get from Consultation',b'Paimkite i\xc5\xa1 konsultacijos'
+b'DocType: Asset',b'Purchase Date',b'Pirkimo data'
+b'DocType: Volunteer',b'Volunteer Type',b'Savanorio tipas'
+b'DocType: Student',b'Personal Details',b'Asmenin\xc4\x97s detal\xc4\x97s'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193',"b""Please set 'Asset Depreciation Cost Center' in Company {0}""",b'Pra\xc5\xa1ome nustatyti &quot;turto nusid\xc4\x97v\xc4\x97jimo s\xc4\x85naud\xc5\xb3 centro&quot; \xc4\xafmon\xc4\x97je {0}'
+,b'Maintenance Schedules',b'prie\xc5\xbei\xc5\xabros Tvarkara\xc5\xa1\xc4\x8diai'
+b'DocType: Task',b'Actual End Date (via Time Sheet)',b'Tikrasis Pabaigos data (per Time lapas)'
+b'DocType: Soil Texture',b'Soil Type',b'Dirvo\xc5\xbeemio tipas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387',b'Amount {0} {1} against {2} {3}',b'Suma {0} {1} prie\xc5\xa1 {2} {3}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277',b'New Message',b'Nauja \xc5\xbeinut\xc4\x97'
+,b'Quotation Trends',b'Kain\xc5\xb3 tendencijos'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160',b'Item Group not mentioned in item master for item {0}',b'Prek\xc4\x97 Grup\xc4\x97 nepamin\xc4\x97ta prek\xc4\x97s \xc5\xa1eimininkui u\xc5\xbe prek\xc4\x99 {0}'
+b'DocType: GoCardless Mandate',b'GoCardless Mandate',b'GoCardless \xc4\xafgaliojimas'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368',b'Debit To account must be a Receivable account',b'Debeto s\xc4\x85skait\xc4\x85 turi b\xc5\xabti Gautinos s\xc4\x85skaitos'
+b'DocType: Shipping Rule',b'Shipping Amount',b'Pristatymas suma'
+b'DocType: Supplier Scorecard Period',b'Period Score',b'Laikotarpio balas'
+b'apps/erpnext/erpnext/utilities/user_progress.py +66',b'Add Customers',b'Prid\xc4\x97ti klientams'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Pending Amount',b'kol suma'
+b'DocType: Lab Test Template',b'Special',b'Specialus'
+b'DocType: Purchase Order Item Supplied',b'Conversion Factor',b'konversijos koeficientas'
+b'DocType: Purchase Order',b'Delivered',b'Pristatyta'
+,b'Vehicle Expenses',b'Transporto i\xc5\xa1laidos'
+b'DocType: Serial No',b'Invoice Details',b'informacija apie s\xc4\x85skait\xc4\x85'
+b'DocType: Grant Application',b'Show on Website',b'Rodyti svetain\xc4\x97je'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +212',b'Expected value after useful life must be greater than or equal to {0}',b'Tikimasi vert\xc4\x97 po naudingo tarnavimo laik\xc4\x85 turi b\xc5\xabti didesnis nei arba lygus {0}'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29',b'Start on',b'Prad\xc4\x97k nuo'
+b'DocType: Hub Category',b'Hub Category',b'Hub kategorija'
+b'DocType: Purchase Invoice',b'SEZ',b'SEZ'
+b'DocType: Purchase Receipt',b'Vehicle Number',b'Automobilio numeris'
+b'DocType: Employee Loan',b'Loan Amount',b'Paskolos suma'
+b'DocType: Student Report Generation Tool',b'Add Letterhead',b'Prid\xc4\x97ti burtin\xc4\x99'
+b'DocType: Program Enrollment',b'Self-Driving Vehicle',b'Sav\xc4\x99s Vairavimas automobiliai'
+b'DocType: Supplier Scorecard Standing',b'Supplier Scorecard Standing',b'Tiek\xc4\x97jo rezultat\xc5\xb3 lentel\xc4\x97 nuolatin\xc4\x97'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443',b'Row {0}: Bill of Materials not found for the Item {1}',b'Eilut\xc4\x97 {0}: bilis med\xc5\xbeiagas prek\xc4\x97 nerasta {1}'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98',b'Total allocated leaves {0} cannot be less than already approved leaves {1} for the period',b'I\xc5\xa1 viso skiriami lapai {0} negali b\xc5\xabti ma\xc5\xbeesn\xc4\x97 nei jau patvirtint\xc5\xb3 lap\xc5\xb3 {1} laikotarpiu'
+b'DocType: Journal Entry',b'Accounts Receivable',b'gautinos'
+,b'Supplier-Wise Sales Analytics',b'Tiek\xc4\x97jas i\xc5\xa1mintingas Pardavim\xc5\xb3 Analytics &quot;'
+b'DocType: Purchase Invoice',b'Availed ITC Central Tax',b'Pasinaudojo ITC centriniu mokes\xc4\x8diu'
+b'DocType: Salary Structure',b'Select employees for current Salary Structure',"b'Pasirinkite darbuotojams u\xc5\xbe dabartin\xc4\xaf darbo u\xc5\xbemokes\xc4\x8dio strukt\xc5\xabr\xc4\x85,'"
+b'DocType: Sales Invoice',b'Company Address Name',b'\xc4\xaemon\xc4\x97s Adresas Pavadinimas'
+b'DocType: Work Order',b'Use Multi-Level BOM',b'Naudokite Multi-level BOM'
+b'DocType: Bank Reconciliation',b'Include Reconciled Entries',b'\xc4\xaetraukti susitaik\xc4\x97 \xc4\xafra\xc5\xa1ai'
+b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'T\xc4\x97v\xc5\xb3 kursai (palikti tu\xc5\xa1\xc4\x8di\xc4\x85, jei tai ne dalis Pagrindin\xc4\x97s \xc5\xbeinoma)'"
+b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'T\xc4\x97v\xc5\xb3 kursai (palikti tu\xc5\xa1\xc4\x8di\xc4\x85, jei tai ne dalis Pagrindin\xc4\x97s \xc5\xbeinoma)'"
+b'DocType: Leave Control Panel',b'Leave blank if considered for all employee types',"b'Palikite tu\xc5\xa1\xc4\x8di\xc4\x85, jei laikomas vis\xc5\xb3 darbuotoj\xc5\xb3 tip\xc5\xb3'"
+b'DocType: Landed Cost Voucher',b'Distribute Charges Based On',b'Paskirstykite Mokes\xc4\x8diai remiantis'
+b'DocType: Projects Settings',b'Timesheets',b'laiko apskaitos \xc5\xbeiniara\xc5\xa1\xc4\x8diai'
+b'DocType: HR Settings',b'HR Settings',b'HR Nustatymai'
+b'DocType: Salary Slip',b'net pay info',b'neto darbo u\xc5\xbemokestis informacijos'
+b'DocType: Lab Test Template',b'This value is updated in the Default Sales Price List.',b'\xc5\xa0i vert\xc4\x97 yra atnaujinta pagal numatyt\xc4\x85 pardavimo kainora\xc5\xa1t\xc4\xaf.'
+b'DocType: Email Digest',b'New Expenses',b'Nauja i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79',b'PDC/LC Amount',b'PDC / LC suma'
+b'DocType: Shareholder',b'Shareholder',b'Akcininkas'
+b'DocType: Purchase Invoice',b'Additional Discount Amount',b'Papildoma Nuolaida suma'
+b'DocType: Cash Flow Mapper',b'Position',b'Pozicija'
+b'DocType: Patient',b'Patient Details',b'Paciento duomenys'
+b'DocType: Patient',b'B Positive',b'B teigiamas'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +596',"b'Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.'","b'Eilut\xc4\x97s # {0}: Kiekis turi b\xc5\xabti 1, kaip elementas yra ilgalaikio turto. Pra\xc5\xa1ome naudoti atskir\xc4\x85 eilut\xc4\x99 daugkartiniam vnt.'"
+b'DocType: Leave Block List Allow',b'Leave Block List Allow',b'Palikite Blokuoti s\xc4\x85ra\xc5\xa1as Leisti'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +317',b'Abbr can not be blank or space',b'Abbr negali b\xc5\xabti tu\xc5\xa1\xc4\x8dias arba vietos'
+b'DocType: Patient Medical Record',b'Patient Medical Record',b'Paciento medicinos ataskaita'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +68',b'Group to Non-Group',b'Grup\xc4\x97 ne grup\xc4\x97s'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50',b'Sports',b'sporto'
+b'DocType: Loan Type',b'Loan Name',b'paskolos Vardas'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Actual',b'I\xc5\xa1 viso Tikrasis'
+b'DocType: Lab Test UOM',b'Test UOM',b'Test UOM'
+b'DocType: Student Siblings',b'Student Siblings',b'student\xc5\xb3 seserys'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Unit',b'vienetas'
+b'apps/erpnext/erpnext/stock/get_item_details.py +138',b'Please specify Company',b'Pra\xc5\xa1ome nurodyti Company'
+,b'Customer Acquisition and Loyalty',b'Klient\xc5\xb3 \xc4\xafsigijimas ir lojalumo'
+b'DocType: Asset Maintenance Task',b'Maintenance Task',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros u\xc5\xbeduotis'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118',b'Please set B2C Limit in GST Settings.',b'Nustatykite B2C limitus GST nustatymuose.'
+b'DocType: Purchase Invoice',b'Warehouse where you are maintaining stock of rejected items',"b'Sand\xc4\x97lis, kuriame j\xc5\xabs i\xc5\xa1laikyti atsarg\xc5\xb3 atmest\xc5\xb3 daikt\xc5\xb3'"
+b'DocType: Work Order',b'Skip Material Transfer',b'Pereiti med\xc5\xbeiagos perne\xc5\xa1imas'
+b'DocType: Work Order',b'Skip Material Transfer',b'Pereiti med\xc5\xbeiagos perne\xc5\xa1imas'
+b'apps/erpnext/erpnext/setup/utils.py +109',b'Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually',"b'Negali rasti keitimo kurs\xc4\x85 {0}, kad {1} rakto dienos {2}. Pra\xc5\xa1ome sukurti valiutos keitykla \xc4\xafra\xc5\xa1\xc4\x85 rankiniu b\xc5\xabdu'"
+b'DocType: POS Profile',b'Price List',b'Kainora\xc5\xa1tis'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22',b'{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.',b'{0} dabar numatytasis finansinius metus. Pra\xc5\xa1ome atnaujinti savo nar\xc5\xa1ykl\xc4\x99 pakeitimas \xc4\xafsigaliot\xc5\xb3.'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +45',b'Expense Claims',b'I\xc5\xa1laid\xc5\xb3 Pretenzijos'
+b'DocType: Issue',b'Support',b'parama'
+,b'BOM Search',b'BOM Paie\xc5\xa1ka'
+b'DocType: Project',b'Total Consumed Material Cost  (via Stock Entry)',b'I\xc5\xa1 viso sunaudot\xc5\xb3 med\xc5\xbeiag\xc5\xb3 kaina (per sand\xc4\x97lius)'
+b'DocType: Item',"b'Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.'","b'Paskelbkite &quot;Sand\xc4\x97liuoju&quot; arba &quot;N\xc4\x97ra sandelyje&quot; centre, priklausomai nuo sand\xc4\x97lyje esan\xc4\x8di\xc5\xb3 atsarg\xc5\xb3.'"
+b'DocType: Vehicle',b'Fuel Type',b'degal\xc5\xb3 tipas'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27',b'Please specify currency in Company',b'Pra\xc5\xa1ome nurodyti valiut\xc4\x85 Company'
+b'DocType: Workstation',b'Wages per hour',b'Darbo u\xc5\xbemokestis per valand\xc4\x85'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47',b'Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}',b'Akcij\xc5\xb3 balansas Serija {0} taps neigiamas {1} u\xc5\xbe prek\xc4\x99 {2} \xc4\xaf sand\xc4\x97l\xc4\xaf {3}'
+b'apps/erpnext/erpnext/templates/emails/reorder_item.html +1',"b""Following Material Requests have been raised automatically based on Item's re-order level""",b'\xc5\xa0ios med\xc5\xbeiagos pra\xc5\xa1ymai buvo i\xc5\xa1keltas automati\xc5\xa1kai pagal elemento naujo u\xc5\xbesakymo lygio'
+b'DocType: Email Digest',b'Pending Sales Orders',b'Laukiantieji sprendimo Pardavimo U\xc5\xbesakymai'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +312',b'Account {0} is invalid. Account Currency must be {1}',b'S\xc4\x85skaita {0} yra neteisinga. S\xc4\x85skaitos valiuta turi b\xc5\xabti {1}'
+b'DocType: Healthcare Settings',b'Remind Before',b'Prisiminti anks\xc4\x8diau'
+b'apps/erpnext/erpnext/buying/utils.py +34',b'UOM Conversion factor is required in row {0}',b'UOM Konversijos koeficientas yra reikalaujama i\xc5\xa1 eil\xc4\x97s {0}'
+b'DocType: Production Plan Item',b'material_request_item',b'material_request_item'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087',"b'Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry'","b'Eilut\xc4\x97s # {0}: Informacinis dokumentas tipas turi b\xc5\xabti vienas i\xc5\xa1 pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3, pardavimo s\xc4\x85skaitoje-fakt\xc5\xabroje ar \xc5\xbeurnalo \xc4\xafra\xc5\xa1\xc4\x85'"
+b'DocType: Salary Component',b'Deduction',b'Atskaita'
+b'DocType: Item',b'Retain Sample',b'I\xc5\xa1saugoti pavyzd\xc4\xaf'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115',b'Row {0}: From Time and To Time is mandatory.',b'Eilut\xc4\x97s {0}: Nuo Laikas ir laiko yra privalomas.'
+b'DocType: Stock Reconciliation Item',b'Amount Difference',b'suma skirtumas'
+b'apps/erpnext/erpnext/stock/get_item_details.py +356',b'Item Price added for {0} in Price List {1}',b'Prek\xc4\x97 Kaina prid\xc4\x97ta {0} kainora\xc5\xa1tis {1}'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8',b'Please enter Employee Id of this sales person',b'Pra\xc5\xa1ome \xc4\xafvesti darbuotojo ID \xc5\xa0io pardavimo asmuo'
+b'DocType: Territory',b'Classification of Customers by region',b'Klasifikacija klientams regione'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71',b'In Production',b'Gamyboje'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65',b'Difference Amount must be zero',b'Skirtumas suma turi b\xc5\xabti lygi nuliui'
+b'DocType: Project',b'Gross Margin',b'bendroji mar\xc5\xbea'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61',b'Please enter Production Item first',b'Pra\xc5\xa1ome \xc4\xafvesti Gamybos Element\xc4\x85 pirmas'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45',b'Calculated Bank Statement balance',b'Apskai\xc4\x8diuota bankas parei\xc5\xa1kimas balansas'
+b'DocType: Normal Test Template',b'Normal Test Template',b'Normalioji bandymo \xc5\xa1ablonas'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64',b'disabled user',b'ne\xc4\xafgaliesiems vartotojas'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919',b'Quotation',b'Pasi\xc5\xablymas'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984',b'Cannot set a received RFQ to No Quote',b'Negalima nustatyti gauta RFQ jokiai citata'
+b'DocType: Quotation',b'QTN-',b'QTN-'
+b'DocType: Salary Slip',b'Total Deduction',b'I\xc5\xa1 viso i\xc5\xa1skai\xc4\x8diavimas'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18',b'Select an account to print in account currency',"b'Pasirinkite paskyr\xc4\x85, kuri\xc4\x85 norite spausdinti paskyros valiuta'"
+,b'Production Analytics',b'gamybos Analytics &quot;'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6',b'This is based on transactions against this Patient. See timeline below for details',b'Tai pagr\xc4\xafsta operacijomis su \xc5\xa1iuo pacientu. I\xc5\xa1samiau \xc5\xber. Toliau pateikt\xc4\x85 laiko juost\xc4\x85'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204',b'Cost Updated',b'kaina Atnaujinta'
+b'DocType: Patient',b'Date of Birth',b'Gimimo data'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133',b'Item {0} has already been returned',b'Prek\xc4\x97 {0} jau buvo gr\xc4\x85\xc5\xbeinta'
+b'DocType: Fiscal Year',b'**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.',b'** Finansiniai metai ** rei\xc5\xa1kia finansinius metus. Visi apskaitos \xc4\xafra\xc5\xa1ai ir kiti pagrindiniai sandoriai yra stebimi nuo ** finansiniams metams **.'
+b'DocType: Opportunity',b'Customer / Lead Address',b'Klientas / \xc5\xa0vino Adresas'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Setup',b'Tiek\xc4\x97jo rezultat\xc5\xb3 kortel\xc4\x97s s\xc4\x85ranka'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133',b'Assessment Plan Name',b'Vertinimo plano pavadinimas'
+b'DocType: Work Order Operation',b'Work Order Operation',b'Darb\xc5\xb3 u\xc5\xbesakymo operacija'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +233',b'Warning: Invalid SSL certificate on attachment {0}',b'\xc4\xaesp\xc4\x97jimas: Neteisingas SSL sertifikatas nuo prisiri\xc5\xa1imo {0}'
+b'apps/erpnext/erpnext/utilities/activation.py +64',"b'Leads help you get business, add all your contacts and more as your leads'","b'Laidai pad\xc4\x97ti jums gauti verslo, prid\xc4\x97ti visus savo kontaktus ir daugiau kaip j\xc5\xabs\xc5\xb3 laid\xc5\xb3'"
+b'DocType: Work Order Operation',b'Actual Operation Time',b'Tikrasis veikimo laikas'
+b'DocType: Authorization Rule',b'Applicable To (User)',b'Taikoma (Vartotojas)'
+b'DocType: Purchase Taxes and Charges',b'Deduct',b'atskaityti'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238',b'Job Description',b'Darbo apra\xc5\xa1ymas'
+b'DocType: Student Applicant',b'Applied',b'taikomas'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874',b'Re-open',b'I\xc5\xa1 naujo atidarykite'
+b'DocType: Sales Invoice Item',b'Qty as per Stock UOM',b'Kiekis pagal vertybini\xc5\xb3 popieri\xc5\xb3 UOM'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59',b'Guardian2 Name',b'Guardian2 Vardas'
+b'DocType: Purchase Invoice',b'02-Post Sale Discount',b'02-pardavimo nuolaida'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132',"b'Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series'","b'Special\xc5\xabs simboliai, i\xc5\xa1skyrus &quot;-&quot;. &quot;,&quot; # &quot;, ir &quot;/&quot; neleid\xc5\xbeiama pavadinim\xc5\xb3 serij\xc4\x85'"
+b'DocType: Campaign',"b'Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.'","b'Sekite pardavimo kampanij\xc5\xb3. Sekite veda, citatos, pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 ir tt i\xc5\xa1 kampanij\xc5\xb3 \xc4\xafvertinti investicij\xc5\xb3 gr\xc4\x85\xc5\xbe\xc4\x85.'"
+,b'SO Qty',b'SO Kiekis'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91',b'The field To Shareholder cannot be blank',b'Laukas &quot;Akcininkas&quot; negali b\xc5\xabti tu\xc5\xa1\xc4\x8dias'
+b'DocType: Guardian',b'Work Address',b'Darboviet\xc4\x97s adresas'
+b'DocType: Appraisal',b'Calculate Total Score',b'Apskai\xc4\x8diuokite bendras rezultatas'
+b'DocType: Health Insurance',b'Health Insurance',b'Sveikatos draudimas'
+b'DocType: Asset Repair',b'Manufacturing Manager',b'gamybos direktorius'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191',b'Serial No {0} is under warranty upto {1}',b'Serijos Nr {0} yra garantija net iki {1}'
+b'DocType: Plant Analysis Criteria',b'Minimum Permissible Value',b'Ma\xc5\xbeiausias leistinas dydis'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41',b'User {0} already exists',b'Naudotojas {0} jau egzistuoja'
+b'apps/erpnext/erpnext/hooks.py +109',b'Shipments',b've\xc5\xbeimas'
+b'DocType: Payment Entry',b'Total Allocated Amount (Company Currency)',b'Visos skirtos sumos (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Purchase Order Item',b'To be delivered to customer',b'Turi b\xc5\xabti pristatytas pirk\xc4\x97jui'
+b'DocType: BOM',b'Scrap Material Cost',b'Lau\xc5\xbeas med\xc5\xbeiag\xc5\xb3 s\xc4\x85naudos'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227',b'Serial No {0} does not belong to any Warehouse',b'Serijos Nr {0} nepriklauso bet Warehouse'
+b'DocType: Grant Application',b'Email Notification Sent',b'Siun\xc4\x8diamas prane\xc5\xa1imas el. Pa\xc5\xa1tu'
+b'DocType: Purchase Invoice',b'In Words (Company Currency)',b'\xc5\xbdod\xc5\xbeiais (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018',"b'Item Code, warehouse, quantity are required on row'","b'Prek\xc4\x97s kodas, sand\xc4\x97lis, kiekis eilut\xc4\x97je'"
+b'DocType: Pricing Rule',b'Supplier',b'tiek\xc4\x97jas'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41',b'Show Payment Details',b'Rodyti mok\xc4\x97jimo informacij\xc4\x85'
+b'DocType: Consultation',b'Consultation Time',b'Konsultacijos laikas'
+b'DocType: C-Form',b'Quarter',b'ketvirtis'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106',b'Miscellaneous Expenses',b'\xc4\xaevair\xc5\xabs i\xc5\xa1laidos'
+b'DocType: Global Defaults',b'Default Company',b'numatytasis \xc4\xaemon\xc4\x97s'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +227',b'Expense or Difference account is mandatory for Item {0} as it impacts overall stock value',b'Kompensuojamos ar Skirtumas s\xc4\x85skaitos yra privalomas punktas {0} kaip ji \xc4\xaftakoja bendra akcij\xc5\xb3 vert\xc4\x97'
+b'DocType: Payment Request',b'PR',b'PR'
+b'DocType: Cheque Print Template',b'Bank Name',b'Banko pavadinimas'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30',b'-Above',b'-Above'
+b'DocType: Employee Loan',b'Employee Loan Account',b'Darbuotoj\xc5\xb3 Paskolos paskyra'
+b'DocType: Leave Application',b'Total Leave Days',b'I\xc5\xa1 viso nedarbingumo dien\xc5\xb3'
+b'DocType: Email Digest',b'Note: Email will not be sent to disabled users',b'Pastaba: elektroninio pa\xc5\xa1to adresas nebus siun\xc4\x8diami ne\xc4\xafgaliems vartotojams'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Ta\xc5\xa1k\xc5\xb3 s\xc4\x85veika'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Ta\xc5\xa1k\xc5\xb3 s\xc4\x85veika'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +105',b'Item Variant Settings',b'Elemento variant\xc5\xb3 nustatymai'
+b'apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37',b'Select Company...',b'Pasirinkite bendrov\xc4\x97 ...'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all departments',"b'Palikite tu\xc5\xa1\xc4\x8di\xc4\x85, jei manoma, skirt\xc5\xb3 visiems departamentams'"
+b'apps/erpnext/erpnext/config/hr.py +228',"b'Types of employment (permanent, contract, intern etc.).'","b'Tipai darbo (nuolatinis, sutar\xc4\x8di\xc5\xb3, vidaus ir kt.)'"
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434',b'{0} is mandatory for Item {1}',b'{0} yra privalomas punktas {1}'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136',"b'Item {0}: {1} qty produced, '",b'Prek\xc4\x97 {0}: {1} pagamintas kiekis'
+b'DocType: Payroll Entry',b'Fortnightly',b'kas dvi savait\xc4\x97s'
+b'DocType: Currency Exchange',b'From Currency',b'nuo valiuta'
+b'DocType: Vital Signs',b'Weight (In Kilogram)',b'Svoris (kilogramais)'
+b'DocType: Chapter',b'chapters/chapter_name\nleave blank automatically set after saving chapter.',b'skyrius / chapter_name palikti tu\xc5\xa1\xc4\x8di\xc4\x85 automati\xc5\xa1kai nustatyti po i\xc5\xa1saugojimo skyriuje.'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202',b'Please set GST Accounts in GST Settings',b'Nustatykite GST paskyras'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31',b'Type of Business',b'Verslo tipas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171',"b'Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row'","b'Pra\xc5\xa1ome pasirinkti skirtos sumos, s\xc4\x85skaitos fakt\xc5\xabros tipas ir s\xc4\x85skaitos numer\xc4\xaf atleast vienoje eil\xc4\x97je'"
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128',b'Cost of New Purchase',b'Kaina New pirkimas'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35',b'All tasks for the detected diseases were imported',b'Visi u\xc5\xbefiksuoti lig\xc5\xb3 u\xc5\xbedaviniai buvo importuoti'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97',b'Sales Order required for Item {0}',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 reikalingas punktas {0}'
+b'DocType: Grant Application',b'Grant Description',b'Parei\xc5\xa1kimo apra\xc5\xa1as'
+b'DocType: Purchase Invoice Item',b'Rate (Company Currency)',b'Norma (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Student Guardian',b'Others',b'kiti'
+b'DocType: Payment Entry',b'Unallocated Amount',b'Nepaskirstytas kiekis'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +91',b'Cannot find a matching Item. Please select some other value for {0}.',b'Nerandate atitikimo element\xc4\x85. Pra\xc5\xa1ome pasirinkti koki\xc4\x85 nors kit\xc4\x85 vert\xc4\x99 {0}.'
+b'DocType: POS Profile',b'Taxes and Charges',b'Mokes\xc4\x8diai ir rinkliavos'
+b'DocType: Item',"b'A Product or a Service that is bought, sold or kept in stock.'","b'Produktas arba paslauga, kuri yra perkama, parduodama arba laikomi sand\xc4\x97lyje.'"
+b'apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44',b'No more updates',b'Ne daugiau atnaujinimai'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171',"b""Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row""","b'Negalima pasirinkti \xc4\xafkrovimo tipas, kaip &quot;D\xc4\x97l ankstesn\xc4\x97s eil\xc4\x97s Suma&quot; arba &quot;D\xc4\x97l ankstesn\xc4\x97s eil\xc4\x97s Total&quot; u\xc5\xbe pirmoje eilut\xc4\x97je'"
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6',b'This covers all scorecards tied to this Setup',"b'Tai apima visas rezultat\xc5\xb3 korteles, susietas su \xc5\xa1ia s\xc4\x85ranka'"
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29',b'Child Item should not be a Product Bundle. Please remove item `{0}` and save',b'Vaik\xc5\xb3 punktas netur\xc4\x97t\xc5\xb3 b\xc5\xabti Prek\xc4\x97s paketas. Pra\xc5\xa1ome pa\xc5\xa1alinti element\xc4\x85 `{0}` ir sutaupyti'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12',b'Banking',b'bankinis'
+b'apps/erpnext/erpnext/utilities/activation.py +108',b'Add Timesheets',b'\xc4\xaed\xc4\x97ti laiko apskaitos \xc5\xbeiniara\xc5\xa1\xc4\x8diai'
+b'DocType: Vehicle Service',b'Service Item',b'Paslaug\xc5\xb3 punktas'
+b'DocType: Bank Guarantee',b'Bank Guarantee',b'Banko garantija'
+b'DocType: Bank Guarantee',b'Bank Guarantee',b'Banko garantija'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39',"b""Please click on 'Generate Schedule' to get schedule""",b'Pra\xc5\xa1ome spausti &quot;Generuoti grafik\xc4\x85&quot; gauti tvarkara\xc5\xa1t\xc4\xaf'
+b'DocType: Bin',b'Ordered Quantity',b'U\xc5\xbesakytas Kiekis'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +118',"b'e.g. ""Build tools for builders""'",b'pvz &quot;Build \xc4\xafrankiai statybininkai&quot;'
+b'DocType: Grading Scale',b'Grading Scale Intervals',b'Vertinimo skal\xc4\x97 intervalai'
+b'apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39',b'Profit for the year',b'Pelnas u\xc5\xbe metus'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125',b'{0} {1}: Accounting Entry for {2} can only be made in currency: {3}',b'{0} {1}: apskaitos \xc4\xafra\xc5\xa1as u\xc5\xbe {2} galima tik valiuta: {3}'
+b'DocType: Fee Schedule',b'In Process',b'Procese'
+b'DocType: Authorization Rule',b'Itemwise Discount',b'Itemwise nuolaida'
+b'apps/erpnext/erpnext/config/accounts.py +75',b'Tree of financial accounts.',b'Medis finansines ataskaitas.'
+b'DocType: Cash Flow Mapping',b'Cash Flow Mapping',b'Pinig\xc5\xb3 sraut\xc5\xb3 \xc5\xbeem\xc4\x97lapiai'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364',b'{0} against Sales Order {1}',b'{0} pagal Pardavimo U\xc5\xbesakym\xc4\x85 {1}'
+b'DocType: Account',b'Fixed Asset',b'Ilgalaikio turto'
+b'apps/erpnext/erpnext/config/stock.py +324',b'Serialized Inventory',b'Serijinis Inventorius'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74',b'Email not found in default contact',b'Numatytojo adreso el. Pa\xc5\xa1to adresas nerastas'
+b'DocType: Employee Loan',b'Account Info',b'S\xc4\x85skaitos info'
+b'DocType: Activity Type',b'Default Billing Rate',b'Numatytasis Atsiskaitymo Balsuok'
+b'DocType: Fees',b'Include Payment',b'\xc4\xaetraukti mok\xc4\x97jim\xc4\x85'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Student\xc5\xb3 grup\xc4\x97s sukurtas.'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Student\xc5\xb3 grup\xc4\x97s sukurtas.'
+b'DocType: Sales Invoice',b'Total Billing Amount',b'I\xc5\xa1 viso Atsiskaitymo suma'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50',b'Program in the Fee Structure and Student Group {0} are different.',b'Mokes\xc4\x8di\xc5\xb3 strukt\xc5\xabros ir student\xc5\xb3 grup\xc4\x97s {0} programos skiriasi.'
+b'DocType: Fee Schedule',b'Receivable Account',b'gautinos s\xc4\x85skaitos'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +618',b'Row #{0}: Asset {1} is already {2}',b'Eilut\xc4\x97s # {0}: Turto {1} jau yra {2}'
+b'DocType: Quotation Item',b'Stock Balance',b'akcij\xc5\xb3 balansas'
+b'apps/erpnext/erpnext/config/selling.py +321',b'Sales Order to Payment',"b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3, kad mok\xc4\x97jimo'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123',b'CEO',b'Vadovas'
+b'DocType: Purchase Invoice',b'With Payment of Tax',b'Mokes\xc4\x8dio mok\xc4\x97jimas'
+b'DocType: Expense Claim Detail',b'Expense Claim Detail',b'Kompensuojamos Pretenzija detal\xc4\x97s'
+b'DocType: Purchase Invoice',b'TRIPLICATE FOR SUPPLIER',b'Trimis egzemplioriais tiek\xc4\x97jas'
+b'DocType: Land Unit',b'Is Container',b'Yra konteineris'
+b'DocType: Crop Cycle',b'This will be day 1 of the crop cycle',b'Tai bus pirmoji derliaus ciklo diena'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871',b'Please select correct account',b'Pra\xc5\xa1ome pasirinkti tinkam\xc4\x85 s\xc4\x85skait\xc4\x85'
+b'DocType: Purchase Invoice Item',b'Weight UOM',b'Svoris UOM'
+b'apps/erpnext/erpnext/config/accounts.py +466',b'List of available Shareholders with folio numbers',b'Turim\xc5\xb3 akcinink\xc5\xb3 s\xc4\x85ra\xc5\xa1as su folio numeriais'
+b'DocType: Salary Structure Employee',b'Salary Structure Employee',"b'Darbo u\xc5\xbemokes\xc4\x8dio strukt\xc5\xabr\xc4\x85, darbuotoj\xc5\xb3'"
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45',b'Show Variant Attributes',b'Rodyti variant\xc5\xb3 savybes'
+b'DocType: Student',b'Blood Group',b'Kraujo grup\xc4\x97'
+b'DocType: Course',b'Course Name',b'Kurso pavadinimas'
+b'DocType: Employee Leave Approver',"b""Users who can approve a specific employee's leave applications""","b'Vartotojai, kurie gali patvirtinti konkretaus darbuotojo atostog\xc5\xb3 pra\xc5\xa1ymus'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52',b'Office Equipments',b'Biuro \xc4\xafranga'
+b'DocType: Purchase Invoice Item',b'Qty',b'Kiekis'
+b'DocType: Fiscal Year',b'Companies',b'\xc4\xafmon\xc4\x97s'
+b'DocType: Supplier Scorecard',b'Scoring Setup',b'Bal\xc5\xb3 nustatymas'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24',b'Electronics',b'elektronika'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326',b'Debit ({0})',b'Debetas ({0})'
+b'DocType: Stock Settings',b'Raise Material Request when stock reaches re-order level',b'Pakelkite Material u\xc5\xbeklaus\xc4\x85 Kai akcij\xc5\xb3 pasiekia naujo u\xc5\xbesakymo lyg\xc4\xaf'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98',b'Full-time',b'Pilnas laikas'
+b'DocType: Payroll Entry',b'Employees',b'darbuotojai'
+b'DocType: Employee',b'Contact Details',b'Kontaktiniai duomenys'
+b'DocType: C-Form',b'Received Date',b'gavo data'
+b'DocType: Delivery Note',"b'If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.'","b'Jei suk\xc5\xabr\xc4\x97te standartin\xc4\xaf \xc5\xa1ablon\xc4\x85 pardavimo mokes\xc4\x8dius bei rinkliavas ruo\xc5\xa1iniu, pasirinkite vien\xc4\x85 ir spauskite \xc5\xbeemiau esant\xc4\xaf mygtuk\xc4\x85.'"
+b'DocType: BOM Scrap Item',b'Basic Amount (Company Currency)',b'Pagrindin\xc4\x97 suma (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Student',b'Guardians',b'glob\xc4\x97jai'
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13',b'Payment Confirmation',b'Mok\xc4\x97jimo patvirtinimas'
+b'DocType: Shopping Cart Settings',b'Prices will not be shown if Price List is not set',"b'Kainos nebus rodomas, jei Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as nenustatytas'"
+b'DocType: Stock Entry',b'Total Incoming Value',b'I\xc5\xa1 viso Priimamojo Vert\xc4\x97'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362',b'Debit To is required',b'Debeto reikalingas'
+b'apps/erpnext/erpnext/utilities/activation.py +109',"b'Timesheets help keep track of time, cost and billing for activites done by your team'","b'Laiko apskaitos \xc5\xbeiniara\xc5\xa1\xc4\x8diai pad\xc4\x97ti sekti laiko, i\xc5\xa1laid\xc5\xb3 ir s\xc4\x85skait\xc5\xb3 u\xc5\xbe veiklose padaryti j\xc5\xabs\xc5\xb3 komanda'"
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'Purchase Price List',b'Pirkimo Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as'
+b'apps/erpnext/erpnext/config/buying.py +155',b'Templates of supplier scorecard variables.',b'Tiekimo rezultat\xc5\xb3 kortel\xc4\x97s kintam\xc5\xb3j\xc5\xb3 \xc5\xa1ablonai.'
+b'DocType: Job Offer Term',b'Offer Term',b'Si\xc5\xablau terminas'
+b'DocType: Asset',b'Quality Manager',b'Kokyb\xc4\x97s vadybininkas'
+b'DocType: Job Applicant',b'Job Opening',b'darbo skelbimai'
+b'DocType: Payment Reconciliation',b'Payment Reconciliation',b'Mok\xc4\x97jimo suderinimas'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153',"b""Please select Incharge Person's name""",b'Pra\xc5\xa1ome pasirinkti Incharge Asmens vardas'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51',b'Technology',b'technologija'
+b'DocType: Hub Settings',b'Unregister from Hub',b'I\xc5\xa1registruoti i\xc5\xa1 &quot;Hub&quot;'
+b'apps/erpnext/erpnext/public/js/utils.js +108',b'Total Unpaid: {0}',b'I\xc5\xa1 viso nesumok\xc4\x97tas: {0}'
+b'DocType: BOM Website Operation',b'BOM Website Operation',b'BOM svetain\xc4\x97 Operacija'
+b'DocType: Supplier Scorecard',b'Supplier Score',b'Tiek\xc4\x97jo balas'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +213',b'Total Invoiced Amt',b'Viso \xc4\xaf s\xc4\x85skaitas \xc4\xaftraukto Amt'
+b'DocType: Supplier',b'Warn RFQs',b'Persp\xc4\x97ti RFQ'
+b'DocType: BOM',b'Conversion Rate',b'Perskai\xc4\x8diavimo kursas'
+b'apps/erpnext/erpnext/templates/pages/product_search.html +3',b'Product Search',b'Prek\xc4\x97s paie\xc5\xa1ka'
+b'DocType: Assessment Plan',b'To Time',b'laiko'
+b'DocType: Authorization Rule',b'Approving Role (above authorized value)',b'Patvirtinimo vaidmen\xc4\xaf (vir\xc5\xa1 \xc4\xafgalioto vert\xc4\x97s)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118',b'Credit To account must be a Payable account',b'Kreditas s\xc4\x85skaitos turi b\xc5\xabti mok\xc4\x97tinos s\xc4\x85skaitos'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43',b'Please select Student Admission which is mandatory for the paid student applicant',"b'Pra\xc5\xa1ome pasirinkti Student\xc5\xb3 pri\xc4\x97mim\xc4\x85, kuris yra privalomas mokamam studento parei\xc5\xa1k\xc4\x97jui'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355',b'BOM recursion: {0} cannot be parent or child of {2}',b'BOM rekursija: {0} negali b\xc5\xabti t\xc4\x97v\xc5\xb3 ar vaikas {2}'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21',b'Please select a Price List to publish pricing',"b'Pasirinkite kainora\xc5\xa1t\xc4\xaf, kad paskelbtum\xc4\x97te kainodar\xc4\x85'"
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38',b'Budget List',b'Biud\xc5\xbeeto s\xc4\x85ra\xc5\xa1as'
+b'DocType: Work Order Operation',b'Completed Qty',b'u\xc5\xbebaigtas Kiekis'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148',"b'For {0}, only debit accounts can be linked against another credit entry'","b'D\xc4\x97l {0}, tik debeto s\xc4\x85skaitos gali b\xc5\xabti susij\xc4\x99s su kitos kredito \xc4\xafra\xc5\xa1\xc4\x85'"
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27',b'Price List {0} is disabled',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as {0} yra i\xc5\xa1jungtas'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127',b'Row {0}: Completed Qty cannot be more than {1} for operation {2}',b'Eilut\xc4\x97s {0}: baig\xc4\x97 Kiekis gali b\xc5\xabti ne daugiau kaip {1} darbui {2}'
+b'DocType: Manufacturing Settings',b'Allow Overtime',b'Leiskite vir\xc5\xa1valand\xc5\xbeius'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Serijinis {0} Prek\xc4\x97 negali b\xc5\xabti atnaujintas naudojant Inventorinis susitaikymo, pra\xc5\xa1ome naudoti Inventorinis \xc4\xafra\xc5\xa1\xc4\x85'"
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Serijinis {0} Prek\xc4\x97 negali b\xc5\xabti atnaujintas naudojant Inventorinis susitaikymo, pra\xc5\xa1ome naudoti Inventorinis \xc4\xafra\xc5\xa1\xc4\x85'"
+b'DocType: Training Event Employee',b'Training Event Employee',b'Mokymai Rengini\xc5\xb3 Darbuotoj\xc5\xb3'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031',b'Maximum Samples - {0} can be retained for Batch {1} and Item {2}.',b'Maksimal\xc5\xabs m\xc4\x97giniai - {0} gali b\xc5\xabti laikomi paketui {1} ir vienetui {2}.'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7',b'Add Time Slots',b'Prid\xc4\x97ti laiko laiko tarpsnius'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201',b'{0} Serial Numbers required for Item {1}. You have provided {2}.',b'{0} Serial numeriai reikalingi punkte {1}. J\xc5\xabs s\xc4\x85lyga {2}.'
+b'DocType: Stock Reconciliation Item',b'Current Valuation Rate',b'Dabartinis vertinimas Balsuok'
+b'DocType: Training Event',b'Advance',b'I\xc5\xa1 anksto'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'for making recurring again.',b'dar kart\xc4\x85 pasikartoti.'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +13',b'GoCardless payment gateway settings',b'&quot;GoCardless&quot; mok\xc4\x97jimo \xc5\xa1liuzo nustatymai'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122',b'Exchange Gain/Loss',b'Valiut\xc5\xb3 Pelnas / nuostolis'
+b'DocType: Opportunity',b'Lost Reason',b'Pamir\xc5\xa1ote Prie\xc5\xbeastis'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +265',b'Row #{0}: Account {1} does not belong to company {2}',b'Eilut\xc4\x97 # {0}: s\xc4\x85skaita {1} nepriklauso bendrovei {2}'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30',b'Unable to find DocType {0}',b'Nepavyko rasti DocType {0}'
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +22',b'New Address',b'Naujas adresas'
+b'DocType: Quality Inspection',b'Sample Size',b'imties dydis'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47',b'Please enter Receipt Document',b'Pra\xc5\xa1ome \xc4\xafvesti Gavimas dokument\xc4\x85'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369',b'All items have already been invoiced',b'Visos prek\xc4\x97s jau i\xc5\xa1ra\xc5\xa1yta s\xc4\x85skaita'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49',"b""Please specify a valid 'From Case No.'""",b'Nurodykite tinkam\xc4\x85 &quot;Nuo byloje Nr &#39;'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24',b'Further cost centers can be made under Groups but entries can be made against non-Groups',"b'Daugiau ka\xc5\xa1t\xc5\xb3 centrai gali b\xc5\xabti grup\xc4\x97se, ta\xc4\x8diau \xc4\xafra\xc5\xa1ai gali b\xc5\xabti pareik\xc5\xa1tas ne grup\xc4\x97s'"
+b'apps/erpnext/erpnext/config/setup.py +66',b'Users and Permissions',b'Vartotojai ir leidimai'
+b'DocType: Vehicle Log',b'VLOG.',b'Vlog.'
+b'DocType: Branch',b'Branch',b'filialas'
+b'DocType: Soil Analysis',b'Ca/(K+Ca+Mg)',b'Ca / (K + Ca + Mg)'
+b'DocType: Delivery Trip',b'Fulfillment User',b'\xc4\xaevykdymo naudotojas'
+b'apps/erpnext/erpnext/config/setup.py +61',b'Printing and Branding',b'Spausdinimo ir paviljonai'
+b'DocType: Company',b'Total Monthly Sales',b'Bendras m\xc4\x97nesinis pardavimas'
+b'DocType: Agriculture Analysis Criteria',b'Weather',b'Orai'
+b'DocType: Bin',b'Actual Quantity',b'Tikrasis Kiekis'
+b'DocType: Shipping Rule',b'example: Next Day Shipping',b'Pavyzdys: Sekanti diena Pristatymas'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187',b'Serial No {0} not found',b'Serijos Nr {0} nerastas'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291',b'Subscription has been {0}',b'Prenumerata buvo {0}'
+b'DocType: Fee Schedule Program',b'Fee Schedule Program',b'Mokes\xc4\x8di\xc5\xb3 tvarkara\xc5\xa1\xc4\x8dio programa'
+b'DocType: Fee Schedule Program',b'Student Batch',b'Student\xc5\xb3 Serija'
+b'apps/erpnext/erpnext/utilities/activation.py +119',b'Make Student',b'Padaryti Studentas'
+b'DocType: Supplier Scorecard Scoring Standing',b'Min Grade',b'Min. Kategorija'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +218',b'You have been invited to collaborate on the project: {0}',b'J\xc5\xabs buvote pakviestas bendradarbiauti su projektu: {0}'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157',b'Physician not available on {0}',b'Gydytojas n\xc4\x97ra {0}'
+b'DocType: Leave Block List Date',b'Block Date',b'Blokuoti data'
+b'DocType: Crop',b'Crop',b'Apkarpyti'
+b'DocType: Purchase Receipt',b'Supplier Delivery Note',b'Tiek\xc4\x97jo pristatymo pastaba'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70',b'Apply Now',b'taikyti Dabar'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Faktinis Kiekis {0} / laukimo Kiekis {1}'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Faktinis Kiekis {0} / laukimo Kiekis {1}'
+b'DocType: Purchase Invoice',b'E-commerce GSTIN',b'E-komercija GSTIN'
+b'DocType: Sales Order',b'Not Delivered',b'Nepristatytas'
+,b'Bank Clearance Summary',b'Bankas S\xc4\x85skait\xc5\xb3 santrauka'
+b'apps/erpnext/erpnext/config/setup.py +106',"b'Create and manage daily, weekly and monthly email digests.'","b'Kurkite ir tvarkykite savo dienos, savait\xc4\x97s ir m\xc4\x97nesio el suskaldyti.'"
+b'DocType: Appraisal Goal',b'Appraisal Goal',b'vertinimas tikslas'
+b'DocType: Stock Reconciliation Item',b'Current Amount',b'Dabartinis suma'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58',b'Buildings',b'Pastatai'
+b'DocType: Fee Schedule',b'Fee Structure',b'mokestis strukt\xc5\xabra'
+b'DocType: Timesheet Detail',b'Costing Amount',b'S\xc4\x85naud\xc5\xb3 dydis'
+b'DocType: Student Admission Program',b'Application Fee',b'Parai\xc5\xa1kos mokestis'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52',b'Submit Salary Slip',b'Pateikti darbo u\xc5\xbemokest\xc4\xaf'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +137',b'Maxiumm discount for Item {0} is {1}%',b'Maxiumm nuolaida Prek\xc4\x97s {0} yra {1}%'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16',b'Import in Bulk',b'Importas \xc4\xaf taros'
+b'DocType: Sales Partner',b'Address & Contacts',b'Adresas ir kontaktai'
+b'DocType: SMS Log',b'Sender Name',b'siunt\xc4\x97jas Vardas'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Analysis Criteria',b'\xc5\xbdem\xc4\x97s \xc5\xabkio analiz\xc4\x97s kriterijai'
+b'DocType: POS Profile',b'[Select]',b'[Pasirinkti]'
+b'DocType: Vital Signs',b'Blood Pressure (diastolic)',b'Kraujo spaudimas (diastolinis)'
+b'DocType: SMS Log',b'Sent To',b'Siun\xc4\x8diami \xc4\xaf'
+b'DocType: Agriculture Task',b'Holiday Management',b'Atostog\xc5\xb3 valdymas'
+b'DocType: Payment Request',b'Make Sales Invoice',b'Padaryti pardavimo s\xc4\x85skaita-fakt\xc5\xabra'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61',b'Softwares',b'Programin\xc4\x97 \xc4\xafranga'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +53',b'Next Contact Date cannot be in the past',b'Kitas Kontaktin\xc4\x97 data negali b\xc5\xabti praeityje'
+b'DocType: Company',b'For Reference Only.',b'Tik nuoroda.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112',b'Physician {0} not available on {1}',b'Gydytojas {0} negalimas {1}'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2581',b'Select Batch No',b'Pasirinkite Serija N\xc4\x97ra'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61',b'Invalid {0}: {1}',b'Neteisingas {0}: {1}'
+,b'GSTR-1',b'GSTR-1'
+b'DocType: Purchase Invoice',b'PINV-RET-',b'PINV-RET-'
+b'DocType: Fee Validity',b'Reference Inv',b'Informacin\xc4\x97 investicija'
+b'DocType: Sales Invoice Advance',b'Advance Amount',b'avanso suma'
+b'DocType: Manufacturing Settings',b'Capacity Planning',b'Talpa planavimas'
+b'DocType: Supplier Quotation',b'Rounding Adjustment (Company Currency',b'Apvalinimo koregavimas (\xc4\xafmon\xc4\x97s valiuta'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43',"b""'From Date' is required""","b'""Nuo data"" privalomas.'"
+b'DocType: Journal Entry',b'Reference Number',b'\xc5\xa0altinio numeris'
+b'DocType: Employee',b'Employment Details',b'\xc4\xafdarbinimo detal\xc4\x97s'
+b'DocType: Employee',b'New Workplace',b'nauja Darbo'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17',b'Set as Closed',b'Nustatyti kaip U\xc5\xbedarymo'
+b'apps/erpnext/erpnext/stock/get_item_details.py +127',b'No Item with Barcode {0}',b'N\xc4\x97ra Prek\xc4\x97 su Br\xc5\xabk\xc5\xa1ninis kodas {0}'
+b'DocType: Normal Test Items',b'Require Result Value',b'Reikalauti rezultato vert\xc4\x97s'
+b'DocType: Item',b'Show a slideshow at the top of the page',b'Rodyti skaidri\xc5\xb3 per\xc5\xbei\xc5\xabr\xc4\x85 \xc4\xaf puslapio vir\xc5\xa1uje'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532',b'Boms',b'Boms'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +162',b'Stores',b'parduotuv\xc4\x97s'
+b'DocType: Project Type',b'Projects Manager',b'Projekt\xc5\xb3 vadovas'
+b'DocType: Serial No',b'Delivery Time',b'Pristatymo laikas'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33',b'Ageing Based On',b'Sen\xc4\x97jimo remiantis'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61',b'Appointment cancelled',b'Paskyrimas at\xc5\xa1auktas'
+b'DocType: Item',b'End of Life',b'Gyvenimo pabaiga'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +331',b'Travel',b'Kelion\xc4\x97'
+b'DocType: Student Report Generation Tool',b'Include All Assessment Group',b'\xc4\xaetraukti vis\xc4\x85 vertinimo grup\xc4\x99'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183',b'No active or default Salary Structure found for employee {0} for the given dates',b'N\xc4\x97ra aktyvus arba numatyt\xc4\x85j\xc4\xaf darbo u\xc5\xbemokes\xc4\x8dio strukt\xc5\xabr\xc4\x85 ir darbuotojo {0} nerasta pagal nurodyt\xc4\x85 dat\xc4\x85'
+b'DocType: Leave Block List',b'Allow Users',b'leisti vartotojams'
+b'DocType: Purchase Order',b'Customer Mobile No',b'Klient\xc5\xb3 Mobilus N\xc4\x97ra'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1',b'Recurring',b'pasikartojan\xc4\x8dios'
+b'DocType: Cash Flow Mapping Template Details',b'Cash Flow Mapping Template Details',b'Pinig\xc5\xb3 sraut\xc5\xb3 \xc5\xbeem\xc4\x97lapi\xc5\xb3 \xc5\xa1ablono detal\xc4\x97s'
+b'DocType: Cost Center',b'Track separate Income and Expense for product verticals or divisions.',b'Sekti atskir\xc4\x85 pajamos ir i\xc5\xa1laidos u\xc5\xbe produkt\xc5\xb3 segmentus ar padalini\xc5\xb3.'
+b'DocType: Rename Tool',b'Rename Tool',b'pervadinti \xc4\xafrankis'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72',b'Update Cost',b'Atnaujinti Kaina'
+b'DocType: Item Reorder',b'Item Reorder',b'Prek\xc4\x97 Pertvarkyti'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463',b'Show Salary Slip',b'Rodyti Pajamos Kuponas'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849',b'Transfer Material',b'perduoti med\xc5\xbeiag\xc4\x85'
+b'DocType: Fees',b'Send Payment Request',b'Si\xc5\xb3sti mok\xc4\x97jimo u\xc5\xbeklaus\xc4\x85'
+b'DocType: BOM',"b'Specify the operations, operating cost and give a unique Operation no to your operations.'","b'Nurodykite operacijas, veiklos s\xc4\x85naudas ir suteikti unikali\xc4\x85 eksploatuoti ne savo operacijas.'"
+b'DocType: Water Analysis',b'Origin',b'Kilm\xc4\x97'
+b'apps/erpnext/erpnext/controllers/status_updater.py +204',b'This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?',b'\xc5\xa0is dokumentas yra vir\xc5\xa1 ribos iki {0} {1} u\xc5\xbe prek\xc4\x99 {4}. Darai dar {3} prie\xc5\xa1 pat\xc4\xaf {2}?'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1154',b'Please set recurring after saving',b'Pra\xc5\xa1ome nustatyti pasikartojan\xc4\x8di\xc5\xb3 po taupymo'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769',b'Select change amount account',b'Pasirinkite Keisti suma s\xc4\x85skaita'
+b'DocType: Purchase Invoice',b'Price List Currency',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as Valiuta'
+b'DocType: Naming Series',b'User must always select',b'Vartotojas visada turi pasirinkti'
+b'DocType: Stock Settings',b'Allow Negative Stock',b'Leiskite Neigiama Stock'
+b'DocType: Installation Note',b'Installation Note',b'\xc4\xaerengimas Pastaba'
+b'DocType: Soil Texture',b'Clay',b'Molis'
+b'DocType: Topic',b'Topic',b'tema'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45',b'Cash Flow from Financing',b'Pinig\xc5\xb3 srautai i\xc5\xa1 finansavimo'
+b'DocType: Budget Account',b'Budget Account',b'biud\xc5\xbeeto s\xc4\x85skaita'
+b'DocType: Quality Inspection',b'Verified By',b'Patvirtinta'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +78',"b""Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.""","b'Nepavyksta pakeisti \xc4\xafmon\xc4\x97s numatytasis valiuta, nes yra esami sandoriai. Sandoriai turi b\xc5\xabti at\xc5\xa1auktas pakeisti numatytasis valiuta.'"
+b'DocType: Cash Flow Mapping',b'Is Income Tax Liability',b'Yra pajam\xc5\xb3 mokes\xc4\x8dio atskaitomyb\xc4\x97'
+b'DocType: Grading Scale Interval',b'Grade Description',b'\xc4\xaevertinimas Apra\xc5\xa1ymas'
+b'DocType: Stock Entry',b'Purchase Receipt No',b'Pirkimo kvito Ne'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30',b'Earnest Money',b'rimtai Pinigai'
+b'DocType: Sales Invoice',b' Shipping Bill Number',b'Pristatymo s\xc4\x85skaitos numeris'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34',b'Traceability',b'atsekamumas'
+b'DocType: Asset Maintenance Log',b'Actions performed',b'Veiksmai atlikti'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51',b'Customer &gt; Customer Group &gt; Territory',b'Klientas&gt; Klient\xc5\xb3 grup\xc4\x97&gt; Teritorija'
+b'DocType: Cash Flow Mapper',b'Section Leader',b'Skyriaus ved\xc4\x97jas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137',b'Source of Funds (Liabilities)',b'L\xc4\x97\xc5\xa1\xc5\xb3 \xc5\xa1altinis (\xc4\xafsipareigojimai)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +431',b'Quantity in row {0} ({1}) must be same as manufactured quantity {2}',"b'Kiekis eil\xc4\x97s {0} ({1}) turi b\xc5\xabti toks pat, kaip gaminamo kiekio {2}'"
+b'DocType: Supplier Scorecard Scoring Standing',b'Employee',b'Darbuotojas'
+b'DocType: Asset Repair',b'Failure Date',b'Gedimo data'
+b'DocType: Sample Collection',b'Collected Time',b'Surinktas laikas'
+b'DocType: Company',b'Sales Monthly History',b'Pardavim\xc5\xb3 m\xc4\x97nesio istorija'
+b'DocType: Asset Maintenance Task',b'Next Due Date',b'Kitas terminas'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214',b'Select Batch',b'Pasirinkite Serija'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244',b'{0} {1} is fully billed',b'{0} {1} yra pilnai mokami'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31',b'Vital Signs',b'Gyvyb\xc4\x97s \xc5\xbeenklai'
+b'DocType: Training Event',b'End Time',b'pabaigos laikas'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63',b'Active Salary Structure {0} found for employee {1} for the given dates',b'Aktyvus darbo u\xc5\xbemokes\xc4\x8dio strukt\xc5\xabr\xc4\x85 {0} darbuotojo {1} rasta pateikt\xc5\xb3 dat\xc5\xb3'
+b'DocType: Payment Entry',b'Payment Deductions or Loss',b'Apmok\xc4\x97jimo Atskaitymai arba nuostolis'
+b'DocType: Soil Analysis',b'Soil Analysis Criterias',b'Dirvo\xc5\xbeemio analiz\xc4\x97s kriterijai'
+b'apps/erpnext/erpnext/config/setup.py +42',b'Standard contract terms for Sales or Purchase.',b'Standartin\xc4\x97s sutar\xc4\x8di\xc5\xb3 s\xc4\x85lygos pardavimo ar pirkimo.'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +112',b'Group by Voucher',b'Grup\xc4\x97 kupon\xc4\x85'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233',b'Are you sure you want to cancel this appointment?',b'Ar tikrai norite at\xc5\xa1aukti \xc5\xa1\xc4\xaf susitikim\xc4\x85?'
+b'DocType: Hotel Room Pricing Package',b'Hotel Room Pricing Package',b'Vie\xc5\xa1bu\xc4\x8di\xc5\xb3 kain\xc5\xb3 nustatymo paketas'
+b'apps/erpnext/erpnext/config/crm.py +6',b'Sales Pipeline',b'pardavim\xc5\xb3 vamzdyn\xc5\xb3'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201',b'Please set default account in Salary Component {0}',b'Pra\xc5\xa1ome nustatyti numatyt\xc4\x85j\xc4\x85 s\xc4\x85skait\xc4\x85 u\xc5\xbemokes\xc4\x8di\xc5\xb3 Component {0}'
+b'apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7',b'Required On',b'Reikalinga Apie'
+b'DocType: Rename Tool',b'File to Rename',b'Failo pervadinti'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200',b'Please select BOM for Item in Row {0}',b'Pra\xc5\xa1ome pasirinkti BOM u\xc5\xbe prek\xc4\x99 eilut\xc4\x97je {0}'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28',b'Account {0} does not match with Company {1} in Mode of Account: {2}',b'S\xc4\x85skaita {0} nesutampa su kompanija {1} i\xc5\xa1 s\xc4\x85skaitos b\xc5\xabdas: {2}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +464',b'Specified BOM {0} does not exist for Item {1}',b'Neapib\xc5\xabdintas BOM {0} neegzistuoja punkte {1}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301',b'Course: ',b'Kursas:'
+b'DocType: Soil Texture',b'Sandy Loam',b'Sandy Loam'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232',b'Maintenance Schedule {0} must be cancelled before cancelling this Sales Order',b'Prie\xc5\xbei\xc5\xabros planas {0} turi b\xc5\xabti at\xc5\xa1auktas prie\xc5\xa1 panaikinant \xc5\xa1\xc4\xaf pardavimo u\xc5\xbesakym\xc5\xb3'
+b'DocType: POS Profile',b'Applicable for Users',b'Taikoma naudotojams'
+b'DocType: Notification Control',b'Expense Claim Approved',b'Kompensuojamos Pretenzija Patvirtinta'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231',b'No Work Orders created',b'Nepavyko sukurti u\xc5\xbesakym\xc5\xb3'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321',b'Salary Slip of employee {0} already created for this period',b'Pajamos Kuponas darbuotojo {0} jau sukurta per \xc5\xa1\xc4\xaf laikotarp\xc4\xaf'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155',b'Pharmaceutical',b'Farmacijos'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Cost of Purchased Items',b'Kaina \xc4\xafsigyt\xc5\xb3 daikt\xc5\xb3'
+b'DocType: Selling Settings',b'Sales Order Required',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 Reikalinga'
+b'DocType: Purchase Invoice',b'Credit To',b'Kreditas'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceDate',b'PieceDate'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31',b'Active Leads / Customers',b'Aktyvios laidai / Klientai'
+b'DocType: Employee Education',b'Post Graduate',b'Doktorantas'
+b'DocType: Maintenance Schedule Detail',b'Maintenance Schedule Detail',b'Prie\xc5\xbei\xc5\xabros planas I\xc5\xa1samiau'
+b'DocType: Supplier Scorecard',b'Warn for new Purchase Orders',b'\xc4\xaesp\xc4\x97ti apie naujus pirkimo u\xc5\xbesakymus'
+b'DocType: Quality Inspection Reading',b'Reading 9',b'Skaitymas 9'
+b'DocType: Supplier',b'Is Frozen',b'Ar Su\xc5\xa1aldyti'
+b'apps/erpnext/erpnext/stock/utils.py +224',b'Group node warehouse is not allowed to select for transactions',b'Grup\xc4\x97 mazgas sand\xc4\x97lis neleid\xc5\xbeiama pasirinkti sandorius'
+b'DocType: Buying Settings',b'Buying Settings',b'Ie\xc5\xa1ko Nustatymai'
+b'DocType: Stock Entry Detail',b'BOM No. for a Finished Good Item',"b'BOM Nr D\xc4\x97l gatavo geras straipsnis,'"
+b'DocType: Upload Attendance',b'Attendance To Date',b'Dalyvavimas data'
+b'DocType: Request for Quotation Supplier',b'No Quote',b'Nr citatos'
+b'DocType: Warranty Claim',b'Raised By',b'U\xc5\xbeaugino'
+b'DocType: Payment Gateway Account',b'Payment Account',b'Mok\xc4\x97jimo s\xc4\x85skaita'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909',b'Please specify Company to proceed',b'Pra\xc5\xa1ome nurodyti Bendrovei toliau'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27',b'Net Change in Accounts Receivable',b'Grynasis pokytis gautinos'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88',b'Compensatory Off',b'kompensacin\xc4\x97 I\xc5\xa1jungtas'
+b'DocType: Job Offer',b'Accepted',b'priimtas'
+b'DocType: Grant Application',b'Organization',b'organizacija'
+b'DocType: Grant Application',b'Organization',b'organizacija'
+b'DocType: BOM Update Tool',b'BOM Update Tool',b'BOM naujinimo \xc4\xafrankis'
+b'DocType: SG Creation Tool Course',b'Student Group Name',b'Student\xc5\xb3 Grup\xc4\x97s pavadinimas'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17',b'Show exploded view',b'Rodyti i\xc5\xa1skaidyt\xc4\x85 vaizd\xc4\x85'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7',b'Creating Fees',b'Mokes\xc4\x8di\xc5\xb3 k\xc5\xabrimas'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +91',b'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.',"b'Pra\xc5\xa1ome \xc4\xafsitikinkite, kad j\xc5\xabs tikrai norite i\xc5\xa1trinti visus \xc5\xa1ios bendrov\xc4\x97s sandorius. J\xc5\xabs\xc5\xb3 pagrindiniai duomenys liks kaip ji yra. \xc5\xa0is veiksmas negali b\xc5\xabti at\xc5\xa1auktas.'"
+b'apps/erpnext/erpnext/templates/pages/product_search.html +21',b'Search Results',b'Paie\xc5\xa1kos rezultatai'
+b'DocType: Room',b'Room Number',b'Kambario numeris'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +107',b'Invalid reference {0} {1}',b'Neteisingas nuoroda {0} {1}'
+b'DocType: Shipping Rule',b'Shipping Rule Label',b'Pristatymas taisykl\xc4\x97 Etiket\xc4\x97'
+b'DocType: Journal Entry Account',b'Payroll Entry',b'Darbo u\xc5\xbemokes\xc4\x8dio \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75',b'View Fees Records',b'\xc5\xbdi\xc5\xabr\xc4\x97ti mokes\xc4\x8dius \xc4\xafra\xc5\xa1ai'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +35',b'Make Tax Template',b'Padaryti mokes\xc4\x8di\xc5\xb3 \xc5\xa1ablon\xc4\x85'
+b'apps/erpnext/erpnext/public/js/conf.js +28',b'User Forum',b'vartotojas Forumas'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319',b'Raw Materials cannot be blank.',b'\xc5\xbdaliavos negali b\xc5\xabti tu\xc5\xa1\xc4\x8dias.'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498',"b'Could not update stock, invoice contains drop shipping item.'","b'Nepavyko atnaujinti atsarg\xc5\xb3, s\xc4\x85skaitos fakt\xc5\xabros yra la\xc5\xa1as laivybos element\xc4\x85.'"
+b'DocType: Lab Test Sample',b'Lab Test Sample',b'Laboratorinio bandinio pavyzdys'
+b'DocType: Item Variant Settings',b'Allow Rename Attribute Value',b'Leisti pervardyti atributo reik\xc5\xa1m\xc4\x99'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491',b'Quick Journal Entry',b'Greita leidinys \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200',b'You can not change rate if BOM mentioned agianst any item',"b'J\xc5\xabs negalite keisti greit\xc4\xaf, jei BOM min\xc4\x97ta agianst bet kur\xc4\xaf element\xc4\x85'"
+b'DocType: Restaurant',b'Invoice Series Prefix',b'S\xc4\x85skait\xc5\xb3 serijos prefiksas'
+b'DocType: Employee',b'Previous Work Experience',b'Ankstesnis Darbo patirtis'
+b'DocType: Stock Entry',b'For Quantity',b'd\xc4\x97l Kiekis'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205',b'Please enter Planned Qty for Item {0} at row {1}',b'Pra\xc5\xa1ome \xc4\xafvesti planuojama Kiekis u\xc5\xbe prek\xc4\x99 {0} ne eil\xc4\x97s {1}'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93',b'Google Maps integration is not enabled',b'&quot;Google&quot; \xc5\xbeem\xc4\x97lapi\xc5\xb3 integracija n\xc4\x97ra \xc4\xafjungta'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241',b'{0} {1} is not submitted',b'{0} {1} nebus pateiktas'
+b'DocType: Member',b'Membership Expiry Date',b'Naryst\xc4\x97s galiojimo data'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131',b'{0} must be negative in return document',b'{0} turi b\xc5\xabti neigiama gr\xc4\x85\xc5\xbeinimo dokument\xc4\x85'
+,b'Minutes to First Response for Issues',b'Minu\xc4\x8di\xc5\xb3 iki Pirmosios atsakas klausimai'
+b'DocType: Purchase Invoice',b'Terms and Conditions1',b'Taisykl\xc4\x97s ir s\xc4\x85lyg\xc5\xb31'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +109',b'The name of the institute for which you are setting up this system.',"b'Instituto pavadinimas, kur\xc4\xaf nustatote \xc5\xa1i\xc4\x85 sistem\xc4\x85.'"
+b'DocType: Accounts Settings',"b'Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.'","b'Apskaitos \xc4\xafra\xc5\xa1as, u\xc5\xbe\xc5\xa1aldyti iki \xc5\xa1ios datos, niekas negali padaryti / pakeisti \xc4\xafra\xc5\xa1\xc4\x85, i\xc5\xa1skyrus \xc5\xbeemiau nurodyt\xc4\x85 vaidmen\xc4\xaf.'"
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116',b'Please save the document before generating maintenance schedule',b'Pra\xc5\xa1ome \xc4\xafra\xc5\xa1yti dokument\xc4\x85 prie\xc5\xa1 generuoti prie\xc5\xbei\xc5\xabros tvarkara\xc5\xa1t\xc4\xaf'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30',b'Latest price updated in all BOMs',b'Paskutin\xc4\x97 kaina atnaujinta visose BOM'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28',b'Project Status',b'projekto statusas'
+b'DocType: UOM',b'Check this to disallow fractions. (for Nos)',b'Pa\xc5\xbeym\xc4\x97kite tai nor\xc4\x97dami atmesti frakcijas. (U\xc5\xbe Nr)'
+b'DocType: Student Admission Program',b'Naming Series (for Student Applicant)',b'Pavadinim\xc5\xb3 serija (Student\xc5\xb3 parei\xc5\xa1k\xc4\x97jas)'
+b'DocType: Delivery Note',b'Transporter Name',b'Ve\xc5\xbe\xc4\x97jas pavadinimas'
+b'DocType: Authorization Rule',b'Authorized Value',b'\xc4\xafgaliotas Vert\xc4\x97'
+b'DocType: BOM',b'Show Operations',b'Rodyti operacijos'
+,b'Minutes to First Response for Opportunity',b'Minu\xc4\x8di\xc5\xb3 iki Pirmosios atsakas Opportunity'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Absent',b'I\xc5\xa1 viso N\xc4\x97ra'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +862',b'Item or Warehouse for row {0} does not match Material Request',b'Punktas arba sand\xc4\x97lis eil\xc4\x97s {0} nesutampa Med\xc5\xbeiaga U\xc5\xbesisakyti'
+b'apps/erpnext/erpnext/config/stock.py +191',b'Unit of Measure',b'Matavimo vienetas'
+b'DocType: Fiscal Year',b'Year End Date',b'Dienos iki met\xc5\xb3 pabaigos'
+b'DocType: Task Depends On',b'Task Depends On',b'U\xc5\xbeduotis Priklauso nuo'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026',b'Opportunity',b'galimyb\xc4\x97'
+b'DocType: Operation',b'Default Workstation',b'numatytasis Workstation'
+b'DocType: Notification Control',b'Expense Claim Approved Message',b'Kompensuojamos Pretenzija Patvirtinta prane\xc5\xa1imas'
+b'DocType: Payment Entry',b'Deductions or Loss',b'Atskaitymai arba nuostolis'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247',b'{0} {1} is closed',b'{0} {1} yra u\xc5\xbedarytas'
+b'DocType: Email Digest',b'How frequently?',b'Kaip da\xc5\xbenai?'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55',b'Total Collected: {0}',b'I\xc5\xa1 viso surinkta: {0}'
+b'DocType: Purchase Receipt',b'Get Current Stock',b'Gauk Current Stock'
+b'DocType: Purchase Invoice',b'ineligible',b'netinkamas'
+b'apps/erpnext/erpnext/config/manufacturing.py +46',b'Tree of Bill of Materials',b'Medis bilis med\xc5\xbeiagos'
+b'DocType: Student',b'Joining Date',b'Prisijungimas data'
+,b'Employees working on a holiday',"b'Darbuotojai, dirbantys atostog\xc5\xb3'"
+b'DocType: Share Balance',b'Current State',b'Dabartin\xc4\x97 valstyb\xc4\x97'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152',b'Mark Present',b'Pa\xc5\xbeym\xc4\x97ti dabartis'
+b'DocType: Share Transfer',b'From Shareholder',b'I\xc5\xa1 akcininko'
+b'DocType: Project',b'% Complete Method',b'% Visi\xc5\xa1kas b\xc5\xabdas'
+b'apps/erpnext/erpnext/healthcare/setup.py +181',b'Drug',b'Narkotikai'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200',b'Maintenance start date can not be before delivery date for Serial No {0}',b'Prie\xc5\xbei\xc5\xabra prad\xc5\xbeios data negali b\xc5\xabti iki pristatymo datos Serijos Nr {0}'
+b'DocType: Work Order',b'Actual End Date',b'Tikrasis Pabaigos data'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost Adjustment',b'Ar yra finansini\xc5\xb3 s\xc4\x85naud\xc5\xb3 koregavimas'
+b'DocType: BOM',b'Operating Cost (Company Currency)',b'Operacin\xc4\x97 Kaina (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Purchase Invoice',b'PINV-',b'PINV-'
+b'DocType: Authorization Rule',b'Applicable To (Role)',b'Taikoma (vaidmen\xc5\xb3)'
+b'DocType: BOM Update Tool',b'Replace BOM',b'Pakeiskite BOM'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110',b'Code {0} already exist',b'Kodas {0} jau egzistuoja'
+b'DocType: Employee Advance',b'Purpose',b'tikslas'
+b'DocType: Company',b'Fixed Asset Depreciation Settings',b'Ilgalaikio turto nusid\xc4\x97v\xc4\x97jimo Nustatymai'
+b'DocType: Item',b'Will also apply for variants unless overrridden',b'Bus taikoma variant\xc5\xb3 nebent overrridden'
+b'DocType: Purchase Invoice',b'Advances',b'avansai'
+b'DocType: Work Order',b'Manufacture against Material Request',b'Gamyba prie\xc5\xa1 Med\xc5\xbeiaga U\xc5\xbesisakyti'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14',b'Assessment Group: ',b'Vertinimo grup\xc4\x97:'
+b'DocType: Item Reorder',b'Request for',b'pra\xc5\xa1ymas'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32',b'Approving User cannot be same as user the rule is Applicable To',b'Patvirtinimo vartotoj\xc4\x85 negali b\xc5\xabti tas pats kaip vartotojas taisykl\xc4\x97 yra taikoma'
+b'DocType: Stock Entry Detail',b'Basic Rate (as per Stock UOM)',b'Bazinis tarifas (pagal vertybini\xc5\xb3 popieri\xc5\xb3 UOM)'
+b'DocType: SMS Log',b'No of Requested SMS',b'Ne pra\xc5\xa1omosios SMS'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246',b'Leave Without Pay does not match with approved Leave Application records',b'Palikite be darbo u\xc5\xbemokes\xc4\x8dio nesutampa su patvirtintais pra\xc5\xa1ymo suteikti atostogas \xc4\xafra\xc5\xa1\xc5\xb3'
+b'DocType: Campaign',b'Campaign-.####',b'Kampanija-.####'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21',b'Next Steps',b'Tolesni \xc5\xbeingsniai'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796',b'Please supply the specified items at the best possible rates',b'Pra\xc5\xa1ome pateikti nurodytus elementus ne \xc4\xaf geriausias \xc4\xafmanomas normas'
+b'DocType: Membership',b'USD',b'USD'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28',b'Make Invoice',b'Padaryti s\xc4\x85skait\xc4\x85 fakt\xc5\xabr\xc4\x85'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80',b'Remaining Balance',b'Esamas likutis'
+b'DocType: Selling Settings',b'Auto close Opportunity after 15 days',b'Auto arti Galimyb\xc4\x97 po 15 dien\xc5\xb3'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86',b'Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.',"b'\xc4\xaesigijimo u\xc5\xbesakymai neleid\xc5\xbeiami {0} d\xc4\x97l rodiklio, kuris yra {1}.'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +498',b'Barcode {0} is not a valid {1} code',b'Br\xc5\xabk\xc5\xa1ninis kodas {0} n\xc4\x97ra galiojantis {1} kodas'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +83',b'End Year',b'pabaigos metai'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / \xc5\xa0vinas%'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / \xc5\xa0vinas%'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +124',b'Contract End Date must be greater than Date of Joining',b'Sutarties pabaigos data turi b\xc5\xabti didesnis nei \xc4\xafstoti data'
+b'DocType: Driver',b'Driver',b'Vairuotojas'
+b'DocType: Vital Signs',b'Nutrition Values',b'Mitybos vert\xc4\x97s'
+b'DocType: Lab Test Template',b'Is billable',b'Apmokestinamas'
+b'DocType: Delivery Note',b'DN-',b'DN-'
+b'DocType: Sales Partner',b'A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.',"b'Tre\xc4\x8dioji \xc5\xa1alis Platintojas / atstovas / Komisijos atstovas / filialo / perpardavin\xc4\x97tojas, kuris parduoda bendrovi\xc5\xb3 produktus komisija.'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376',b'{0} against Purchase Order {1}',b'{0} prie\xc5\xa1 U\xc5\xbesakymo {1}'
+b'DocType: Patient',b'Patient Demographics',b'Paciento demografija'
+b'DocType: Task',b'Actual Start Date (via Time Sheet)',b'Tikrasis prad\xc5\xbeios data (per Time lapas)'
+b'apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15',b'This is an example website auto-generated from ERPNext',"b'Tai yra pavyzdys, svetain\xc4\x97 Automati\xc5\xa1kai sugeneruota i\xc5\xa1 ERPNext'"
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43',b'Ageing Range 1',b'Sen\xc4\x97jimas klas\xc4\x97s 1'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212',b'Total advance amount cannot be greater than total claimed amount',b'Bendra i\xc5\xa1ankstin\xc4\x97 suma negali b\xc5\xabti didesn\xc4\x97 u\xc5\xbe vis\xc4\x85 reikalaujam\xc4\x85 sum\xc4\x85'
+b'DocType: Purchase Taxes and Charges Template',"b'Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.'","b'Standartin\xc4\x97 mokestis \xc5\xa1ablonas, kuris gali b\xc5\xabti taikomas visiems pirkimo sandori\xc5\xb3. \xc5\xa0is \xc5\xa1ablonas gali b\xc5\xabti s\xc4\x85ra\xc5\xa1\xc4\x85 mokes\xc4\x8di\xc5\xb3 vadov\xc5\xb3, taip pat kito s\xc4\x85skaita vadovams, pavyzd\xc5\xbeiui, &quot;Pristatymas&quot;, &quot;Draudimas&quot;, &quot;tvarkymas&quot; ir tt #### Pastaba mokes\xc4\x8dio tarifas, kur\xc4\xaf nurodote \xc4\x8dia bus standartinis mokes\xc4\x8dio tarifas visiems ** daiktai * *. Jei yra ** daiktai **, kurios turi skirtingus tarifus, jie turi b\xc5\xabti prid\xc4\x97ta ** Prek\xc4\x97s mokes\xc4\x8dio ** lentel\xc4\x99 ** Prek\xc4\x97s ** meistras. #### Apra\xc5\xa1ymas Stulpeliai 1. Skai\xc4\x8diavimo tipas: - Tai gali b\xc5\xabti ** Grynasis Viso ** (tai yra bazinio dyd\xc5\xbeio suma). - ** D\xc4\x97l ankstesn\xc4\x97s eil\xc4\x97s viso / suma ** (kumuliacin\xc4\xaf mokes\xc4\x8dius ar rinkliavas). Jei pasirinksite \xc5\xa1i\xc4\x85 parinkt\xc4\xaf, mokestis bus taikomas kaip ankstesn\xc4\x97s eil\xc4\x97s procentais (mokes\xc4\x8di\xc5\xb3 lentel\xc4\x99) sumos arba i\xc5\xa1 viso. - ** Tikrasis ** (kaip min\xc4\x97ta). 2. S\xc4\x85skaitos vadovas: S\xc4\x85skaitos knygos, pagal kuri\xc4\x85 \xc5\xa1is mokestis bus nubaustas 3. S\xc4\x85naud\xc5\xb3 centras: Jei mokestis / mokestis yra pajam\xc5\xb3 (pavyzd\xc5\xbeiui, laivybos) arba i\xc5\xa1laid\xc5\xb3 ji turi b\xc5\xabti nubaustas nuo i\xc5\xa1laid\xc5\xb3 centro. 4. Apra\xc5\xa1ymas: Apra\xc5\xa1ymas mokes\xc4\x8dio (kuris bus spausdinamas s\xc4\x85skait\xc5\xb3 fakt\xc5\xabr\xc5\xb3 / kabu\xc4\x8di\xc5\xb3). 5. Vertinti: Mokes\xc4\x8dio tarifas. 6. Suma: Mokes\xc4\x8di\xc5\xb3 suma. 7. I\xc5\xa1 viso: Kaupiamasis viso \xc5\xa1io ta\xc5\xa1ko. 8. \xc4\xaeveskite Row: Jei remiantis &quot;ankstesn\xc4\x97s eil\xc4\x97s viso&quot; galite pasirinkti numer\xc4\xaf eilut\xc4\x97s, kurios bus imtasi kaip pagrind\xc4\x85 \xc5\xa1iam apskai\xc4\x8diavimui (pagal nutyl\xc4\x97jim\xc4\x85 yra ankstesn\xc4\x97 eilut\xc4\x97). 9. Apsvarstykite mokest\xc4\xaf arba rinkliav\xc4\x85 u\xc5\xbe: \xc5\xa0iame skyriuje galite nurodyti, ar mokestis / mokestis yra tik vertinimo (ne i\xc5\xa1 vis\xc5\xb3 dalis) arba tik i\xc5\xa1 viso (neprideda vert\xc4\x97s punkte) arba abu. 10. Prid\xc4\x97ti arba atimama: Nesvarbu, ar norite \xc4\xaftraukti arba atskai\xc4\x8diuoti mokest\xc4\xaf.'"
+b'DocType: Homepage',b'Homepage',b'Pagrindinis puslapis'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68',b'Select Physician...',b'Pasirinkite gydytoj\xc4\x85 ...'
+b'DocType: Grant Application',b'Grant Application Details ',b'Parei\xc5\xa1kimo detal\xc4\x97s'
+b'DocType: Purchase Receipt Item',b'Recd Quantity',b'Recd Kiekis'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65',b'Fee Records Created - {0}',b'Fee \xc4\xaera\xc5\xa1ai Sukurta - {0}'
+b'DocType: Asset Category Account',b'Asset Category Account',b'Turto Kategorija paskyra'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913',b'Row #{0} (Payment Table): Amount must be positive',b'Eilut\xc4\x97 # {0} (mok\xc4\x97jimo lentel\xc4\x97): suma turi b\xc5\xabti teigiama'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteNum',b'CompteNum'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137',b'Cannot produce more Item {0} than Sales Order quantity {1}',b'Negali gaminti daugiau Element\xc4\x85 {0} nei pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 kiekio {1}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +391',b'Select Attribute Values',b'Pasirinkite atributo reik\xc5\xa1mes'
+b'DocType: Purchase Invoice',b'Reason For Issuing document',b'Paai\xc5\xa1kinimas Dokumento i\xc5\xa1davimas'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539',b'Stock Entry {0} is not submitted',"b'Atsarg\xc5\xb3, {0} nebus pateiktas'"
+b'DocType: Payment Reconciliation',b'Bank / Cash Account',b'Bankas / Pinig\xc5\xb3 paskyra'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +47',b'Next Contact By cannot be same as the Lead Email Address',"b'Kitas Susisiekti negali b\xc5\xabti toks pat, kaip pagrindiniam pa\xc5\xa1to adresas'"
+b'DocType: Tax Rule',b'Billing City',b'atsiskaitymo Miestas'
+b'DocType: Asset',b'Manual',b'vadovas'
+b'DocType: Salary Component Account',b'Salary Component Account',b'Pajamos Sud\xc4\x97tin\xc4\x97s paskyra'
+b'DocType: Global Defaults',b'Hide Currency Symbol',b'Sl\xc4\x97pti valiutos simbol\xc4\xaf'
+b'apps/erpnext/erpnext/config/non_profit.py +58',b'Donor information.',b'Donoro informacija.'
+b'apps/erpnext/erpnext/config/accounts.py +330',"b'e.g. Bank, Cash, Credit Card'","b'pvz bankas, grynieji pinigai, kreditin\xc4\x97s kortel\xc4\x97s'"
+b'DocType: Lead Source',b'Source Name',b'\xc5\xa1altinis Vardas'
+b'DocType: Vital Signs',"b'Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""'","b'Suaugusio kraujo spaudimo normalus palaikymas yra ma\xc5\xbedaug 120 mmHg sistolinis ir 80 mmHg diastolinis, sutrumpintas &quot;120/80 mmHg&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +119',"b'Set items shelf life in days, to set expiry based on manufacturing_date plus self life'","b'Nustatykite daikt\xc5\xb3 saugojimo trukm\xc4\x99 dienomis, nor\xc4\x97dami nustatyti galiojimo laik\xc4\x85 pagal gamintojo dat\xc4\x85 ir savaimin\xc4\xaf gyvenim\xc4\x85'"
+b'DocType: Journal Entry',b'Credit Note',b'kredito Pastaba'
+b'DocType: Projects Settings',b'Ignore Employee Time Overlap',b'Ignoruoti darbuotojo laiko dubliavim\xc4\x85'
+b'DocType: Warranty Claim',b'Service Address',b'Paslaug\xc5\xb3 Adresas'
+b'DocType: Asset Maintenance Task',b'Calibration',b'Kalibravimas'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97',b'{0} is a company holiday',b'{0} yra \xc4\xafmon\xc4\x97s atostogos'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49',b'Furnitures and Fixtures',b'Baldai ir \xc5\xa0viestuvai'
+b'DocType: Item',b'Manufacture',b'gamyba'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Company',b'S\xc4\x85rankos kompanija'
+,b'Lab Test Report',b'Lab testo ataskaita'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13',b'Please Delivery Note first',b'Pirmasis Pra\xc5\xa1ome Va\xc5\xbetara\xc5\xa1tis'
+b'DocType: Student Applicant',b'Application Date',b'parai\xc5\xa1kos pateikimo datos'
+b'DocType: Salary Detail',b'Amount based on formula',b'Suma remiantis formul\xc4\x97s'
+b'DocType: Purchase Invoice',b'Currency and Price List',b'Valiuta ir Kainora\xc5\xa1tis'
+b'DocType: Opportunity',b'Customer / Lead Name',b'Klientas / \xc5\xa0vino Vardas'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115',b'Clearance Date not mentioned',b'S\xc4\x85skait\xc5\xb3 data nepamin\xc4\x97ta'
+b'apps/erpnext/erpnext/config/manufacturing.py +7',b'Production',b'Gamyba'
+b'DocType: Guardian',b'Occupation',b'okupacija'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74',b'Row {0}:Start Date must be before End Date',b'Eilut\xc4\x97s {0}: prad\xc5\xbeios data turi b\xc5\xabti prie\xc5\xa1 End data'
+b'DocType: Crop',b'Planting Area',b'Ap\xc5\xbeeldinimo zona'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Qty)',b'I\xc5\xa1 viso (Kiekis)'
+b'DocType: Installation Note Item',b'Installed Qty',b'\xc4\xafdiegta Kiekis'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4',b'This could be because of some invalid Email Addresses in the',b'Tai gali b\xc5\xabti d\xc4\x97l tam tikr\xc5\xb3 netinkam\xc5\xb3 el. Pa\xc5\xa1to adres\xc5\xb3'
+b'apps/erpnext/erpnext/utilities/user_progress.py +31',b'You added ',b'Prid\xc4\x97jote'
+b'DocType: Purchase Taxes and Charges',b'Parenttype',b'Parenttype'
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10',b'Training Result',b'Mokymai rezultatas'
+b'DocType: Purchase Invoice',b'Is Paid',b'yra mokama'
+b'DocType: Salary Structure',b'Total Earning',b'I\xc5\xa1 viso Pelningiausi'
+b'DocType: Purchase Receipt',b'Time at which materials were received',"b'Laikas, per kur\xc4\xaf buvo gauta med\xc5\xbeiagos'"
+b'DocType: Products Settings',b'Products per Page',b'Produktai puslapyje'
+b'DocType: Stock Ledger Entry',b'Outgoing Rate',b'Siun\xc4\x8diami Balsuok'
+b'apps/erpnext/erpnext/config/hr.py +233',b'Organization branch master.',b'Organizacija filialas meistras.'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +313',b' or ',b'arba'
+b'DocType: Sales Order',b'Billing Status',b'atsiskaitymo b\xc5\xabsena'
+b'apps/erpnext/erpnext/public/js/conf.js +32',b'Report an Issue',b'Prane\xc5\xa1ti apie problem\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120',b'Utility Expenses',b'Komunalin\xc4\x97 s\xc4\x85naudos'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64',b'90-Above',b'90 Vir\xc5\xa1'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252',b'Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher',b'Eilut\xc4\x97s # {0}: leidinys \xc4\xae\xc4\x97jimo {1} neturi paskyros {2} arba jau lyginami su kito kupon\xc4\x85'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Weight',b'Kriterij\xc5\xb3 svoris'
+b'DocType: Buying Settings',b'Default Buying Price List',b'Numatytasis Ie\xc5\xa1ko Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as'
+b'DocType: Payroll Entry',b'Salary Slip Based on Timesheet',b'Pajamos Kuponas Remiantis darbo laiko apskaitos \xc5\xbeiniara\xc5\xa1tis'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43',b'Buying Rate',b'Pirkimo norma'
+b'DocType: Notification Control',b'Sales Order Message',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 prane\xc5\xa1imas'
+b'apps/erpnext/erpnext/config/setup.py +15',"b'Set Default Values like Company, Currency, Current Fiscal Year, etc.'","b'Numatytosios reik\xc5\xa1m\xc4\x97s, kaip kompanija, valiuta, einamuosius fiskalinius metus, ir tt'"
+b'DocType: Payment Entry',b'Payment Type',b'Mok\xc4\x97jimo tipas'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',"b'Pra\xc5\xa1ome pasirinkti partij\xc4\x85 punktas {0}. Nepavyko rasti vien\xc4\x85 partij\xc4\x85, kuri atitinka \xc5\xa1\xc4\xaf reikalavim\xc4\x85'"
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',"b'Pra\xc5\xa1ome pasirinkti partij\xc4\x85 punktas {0}. Nepavyko rasti vien\xc4\x85 partij\xc4\x85, kuri atitinka \xc5\xa1\xc4\xaf reikalavim\xc4\x85'"
+b'DocType: Hub Category',b'Parent Category',b'T\xc4\x97v\xc5\xb3 kategorija'
+b'DocType: Payroll Entry',b'Select Employees',b'pasirinkite Darbuotojai'
+b'DocType: Opportunity',b'Potential Sales Deal',b'Galimas Pardavim\xc5\xb3 Spr\xc4\x99sti'
+b'DocType: Complaint',b'Complaints',b'Skundai'
+b'DocType: Payment Entry',b'Cheque/Reference Date',b'\xc4\x8cekis / Nuoroda data'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges',b'I\xc5\xa1 viso Mokes\xc4\x8diai ir rinkliavos'
+b'DocType: Employee',b'Emergency Contact',b'Avarin\xc4\x97s pagalbos kontaktin\xc4\x97'
+b'DocType: Bank Reconciliation Detail',b'Payment Entry',b'Mok\xc4\x97jimo \xc4\xafra\xc5\xa1as'
+,b'sales-browser',b'pardavimo-nar\xc5\xa1ykl\xc4\x97'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +79',b'Ledger',b'buhalterijos did\xc5\xbeioji knyga'
+b'DocType: Patient Medical Record',b'PMR-',b'PMR-'
+b'DocType: Drug Prescription',b'Drug Code',b'Narkotik\xc5\xb3 kodeksas'
+b'DocType: Target Detail',b'Target  Amount',b'Tikslin\xc4\x97 suma'
+b'DocType: POS Profile',b'Print Format for Online',b'Spausdinti format\xc4\x85 internete'
+b'DocType: Shopping Cart Settings',b'Shopping Cart Settings',b'Preki\xc5\xb3 krep\xc5\xa1elis Nustatymai'
+b'DocType: Journal Entry',b'Accounting Entries',b'apskaitos \xc4\xafra\xc5\xa1ai'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17',"b""If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.""","b'Jei pasirinktas &quot;Kainos nustatymas&quot; yra nustatytas kain\xc5\xb3 taisykl\xc4\x97s, jis pakeis kainora\xc5\xa1t\xc4\xaf. Kainodaros taisykl\xc4\x97 yra galutin\xc4\x97 norma, taigi daugiau nuolaida netur\xc4\x97t\xc5\xb3 b\xc5\xabti taikoma. Taigi sandoriuose, pvz., &quot;Pardavim\xc5\xb3 u\xc5\xbesakymas&quot;, &quot;Pirkimo u\xc5\xbesakymas&quot; ir tt, jis bus \xc4\xafra\xc5\xa1ytas laukelyje &quot;Vert\xc4\x97&quot;, o ne &quot;Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1o norma&quot;.'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24',b'Duplicate Entry. Please check Authorization Rule {0}',b'Pasikartojantis \xc4\xafra\xc5\xa1as. Pra\xc5\xa1ome patikrinti Autorizacija taisykl\xc4\x97 {0}'
+b'DocType: Journal Entry Account',b'Reference Due Date',b'Atskaitos data'
+b'DocType: Purchase Order',b'Ref SQ',b'teis\xc4\x97jas SQ'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55',b'Receipt document must be submitted',b'Gavimas turi b\xc5\xabti pateiktas dokumentas'
+b'DocType: Purchase Invoice Item',b'Received Qty',b'gavo Kiekis'
+b'DocType: Stock Entry Detail',b'Serial No / Batch',b'Serijos Nr / Serija'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340',b'Not Paid and Not Delivered',b'Nesumok\xc4\x97jo ir nepateik\xc4\x97'
+b'DocType: Product Bundle',b'Parent Item',b't\xc4\x97v\xc5\xb3 punktas'
+b'DocType: Account',b'Account Type',b'Paskyros tipas'
+b'DocType: Delivery Note',b'DN-RET-',b'DN-RET-'
+b'apps/erpnext/erpnext/templates/pages/projects.html +58',b'No time sheets',b'N\xc4\x97ra darbo laiko apskaitos \xc5\xbeiniara\xc5\xa1\xc4\x8diai'
+b'DocType: GoCardless Mandate',b'GoCardless Customer',b'&quot;GoCardless&quot; klientas'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123',b'Leave Type {0} cannot be carry-forwarded',"b'Palikite tipas {0}, negali b\xc5\xabti atlikti, perduodami'"
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215',"b""Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'""",b'Prie\xc5\xbei\xc5\xabra Tvarkara\xc5\xa1tis negeneruojama vis\xc5\xb3 daikt\xc5\xb3. Pra\xc5\xa1ome spausti &quot;Generuoti grafik\xc4\x85&quot;'
+,b'To Produce',b'Gaminti'
+b'apps/erpnext/erpnext/config/hr.py +93',b'Payroll',b'Darbo u\xc5\xbemokes\xc4\x8dio'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196',"b'For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included'","b'D\xc4\x97l eil\xc4\x97s {0} i\xc5\xa1 {1}. \xc4\xaetraukti {2} prek\xc4\x97s norma, eilut\xc4\x97s {3} taip pat turi b\xc5\xabti \xc4\xaftraukti'"
+b'DocType: Patient Service Unit',b'Parent Service Unit',b'T\xc4\x97v\xc5\xb3 tarnybos skyrius'
+b'apps/erpnext/erpnext/utilities/activation.py +101',b'Make User',b'Padaryti vartotoj\xc4\x85'
+b'DocType: Packing Slip',b'Identification of the package for the delivery (for print)',b'Identifikavimas pakuot\xc4\x97s u\xc5\xbe pristatym\xc4\x85 (spausdinimui)'
+b'DocType: Bin',b'Reserved Quantity',b'reserved Kiekis'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',"b'Pra\xc5\xa1ome \xc4\xafvesti galiojant\xc4\xaf elektroninio pa\xc5\xa1to adres\xc4\x85,'"
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',"b'Pra\xc5\xa1ome \xc4\xafvesti galiojant\xc4\xaf elektroninio pa\xc5\xa1to adres\xc4\x85,'"
+b'DocType: Volunteer Skill',b'Volunteer Skill',b'Savanori\xc5\xb3 \xc4\xafg\xc5\xabdis'
+b'DocType: Bank Reconciliation',b'Include POS Transactions',b'\xc4\xaetraukti POS operacijas'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +784',b'Please select an item in the cart',b'Pra\xc5\xa1ome pasirinkti prek\xc4\x99 krep\xc5\xa1elyje'
+b'DocType: Landed Cost Voucher',b'Purchase Receipt Items',b'Pirkimo kvito daiktai'
+b'apps/erpnext/erpnext/config/learn.py +21',b'Customizing Forms',b'PRITAIKYMAS formos'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74',b'Arrear',b'\xc4\xaesiskolinimas'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158',b'Depreciation Amount during the period',b'Turto nusid\xc4\x97v\xc4\x97jimo suma per ataskaitin\xc4\xaf laikotarp\xc4\xaf'
+b'apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43',b'Disabled template must not be default template',b'Ne\xc4\xafgali\xc5\xb3j\xc5\xb3 \xc5\xa1ablonas turi b\xc5\xabti ne numatytasis \xc5\xa1ablonas'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314',b'For row {0}: Enter planned qty',b'Eilut\xc4\x97je {0}: \xc4\xafveskite numatyt\xc4\x85 kiek\xc4\xaf'
+b'DocType: Shareholder',b'SH-',b'SH-'
+b'DocType: Account',b'Income Account',b'pajam\xc5\xb3 s\xc4\x85skaita'
+b'DocType: Payment Request',"b""Amount in customer's currency""",b'Suma kliento valiuta'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825',b'Delivery',b'pristatymas'
+b'DocType: Volunteer',b'Weekdays',b'Darbo dienomis'
+b'DocType: Stock Reconciliation Item',b'Current Qty',b'Dabartinis Kiekis'
+b'DocType: Restaurant Menu',b'Restaurant Menu',b'Restorano meniu'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +36',b'Prev',b'Ankstesnis'
+b'DocType: Appraisal Goal',b'Key Responsibility Area',b'Pagrindin\xc4\x97 atsakomyb\xc4\x97 Plotas'
+b'apps/erpnext/erpnext/utilities/activation.py +127',"b'Student Batches help you track attendance, assessments and fees for students'","b'Student\xc5\xb3 Partijos pad\xc4\x97ti jums sekti lankomumo, vertinimai ir rinkliavos studentams'"
+b'DocType: Payment Entry',b'Total Allocated Amount',b'Visos skirtos sumos'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +151',b'Set default inventory account for perpetual inventory',b'Nustatykite numatyt\xc4\x85j\xc4\xaf inventoriaus s\xc4\x85skaitos u\xc5\xbe am\xc5\xbein\xc4\x85 inventoriaus'
+b'DocType: Item Reorder',b'Material Request Type',b'Med\xc5\xbeiaga Pra\xc5\xa1ymas tipas'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252',b'Accural Journal Entry for salaries from {0} to {1}',b'Accural leidinys \xc4\xae\xc4\x97jimo atlyginimus i\xc5\xa1 {0} ir {1}'
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17',b'Send Grant Review Email',b'Si\xc5\xb3sti grant\xc5\xb3 per\xc5\xbei\xc5\xabr\xc4\x85 el. Pa\xc5\xa1tu'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +848',"b'LocalStorage is full, did not save'","b'LocalStorage &quot;yra pilna, nei\xc5\xa1saugojo'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100',b'Row {0}: UOM Conversion Factor is mandatory',b'Eilut\xc4\x97s {0}: UOM konversijos faktorius yra privalomas'
+b'apps/erpnext/erpnext/utilities/user_progress.py +235',b'Room Capacity',b'Kambari\xc5\xb3 talpa'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95',b'Ref',b'teis\xc4\x97jas'
+b'DocType: Lab Test',b'LP-',b'LP-'
+b'DocType: Healthcare Settings',b'Registration Fee',b'Registracijos mokestis'
+b'DocType: Budget',b'Cost Center',b'kaina centras'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45',b'Voucher #',b'Bon #'
+b'DocType: Notification Control',b'Purchase Order Message',b'Pirkimui u\xc5\xbesakyti prane\xc5\xa1imas'
+b'DocType: Tax Rule',b'Shipping Country',b'Pristatymas \xc5\xa0alis'
+b'DocType: Selling Settings',"b""Hide Customer's Tax Id from Sales Transactions""",b'Sl\xc4\x97pti Kliento mokes\xc4\x8di\xc5\xb3 ID i\xc5\xa1 pardavimo sandori\xc5\xb3'
+b'DocType: Upload Attendance',b'Upload HTML',b'\xc4\xaekelti HTML'
+b'DocType: Employee',b'Relieving Date',b'mal\xc5\xa1inan\xc4\x8di\xc5\xb3 data'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14',"b'Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.'","b'Kainodaros taisykl\xc4\x97 yra pagamintas perra\xc5\xa1yti Kainora\xc5\xa1tis / define diskonto procentas, remiantis kai kuriais kriterijais.'"
+b'DocType: Serial No',b'Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt',b'Sand\xc4\x97li\xc5\xb3 gali b\xc5\xabti pakeista tik per vertybini\xc5\xb3 popieri\xc5\xb3 Entry / Va\xc5\xbetara\xc5\xa1tis / Pirkimo gavimas'
+b'DocType: Employee Education',b'Class / Percentage',b'Klas\xc4\x97 / procentas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134',b'Head of Marketing and Sales',b'Vadovas rinkodarai ir pardavimams'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72',b'Income Tax',b'Pajam\xc5\xb3 mokestis'
+b'apps/erpnext/erpnext/config/selling.py +174',b'Track Leads by Industry Type.',b'\xc4\xaera\xc5\xa1o Leads pramon\xc4\x97s tipo.'
+b'apps/erpnext/erpnext/utilities/user_progress.py +101',b'Go to Letterheads',b'Eikite \xc4\xaf &quot;Letterheads&quot;'
+b'DocType: Item Supplier',b'Item Supplier',b'Prek\xc4\x97 Tiek\xc4\x97jas'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1255',b'Please enter Item Code to get batch no',b'Pra\xc5\xa1ome \xc4\xafvesti Prek\xc4\x97s kodas gauti partij\xc4\x85 n\xc4\x97ra'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880',b'Please select a value for {0} quotation_to {1}',b'Pra\xc5\xa1ome pasirinkti vert\xc4\x99 u\xc5\xbe {0} quotation_to {1}'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419',b'No Items selected for transfer',b'Neleid\xc5\xbeiama perkelti element\xc5\xb3'
+b'apps/erpnext/erpnext/config/selling.py +46',b'All Addresses.',b'Visi adresai.'
+b'DocType: Company',b'Stock Settings',b'Akcij\xc5\xb3 Nustatymai'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +183',"b'Merging is only possible if following properties are same in both records. Is Group, Root Type, Company'","b'Sujungimas yra galimas tik tada, jei \xc5\xa1ie savyb\xc4\x97s yra tos pa\xc4\x8dios tiek \xc4\xafra\xc5\xa1\xc5\xb3. Ar grup\xc4\x97, \xc5\xa0akn\xc5\xb3 tipas, \xc4\xaemon\xc4\x97s'"
+b'DocType: Vehicle',b'Electric',b'elektros'
+b'DocType: Task',b'% Progress',b'% Progresas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123',b'Gain/Loss on Asset Disposal',b'Pelnas / nuostolis turto perdavimo'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117',b'Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.',b'Paskyros numeris s\xc4\x85skaitai {0} n\xc4\x97ra. <br> Tinkamai nustatykite savo s\xc4\x85skait\xc5\xb3 plan\xc4\x85.'
+b'DocType: Task',b'Depends on Tasks',b'Priklauso nuo U\xc5\xbeduotys'
+b'apps/erpnext/erpnext/config/selling.py +36',b'Manage Customer Group Tree.',b'Valdyti klient\xc5\xb3 grupei med\xc4\xaf.'
+b'DocType: Shopping Cart Settings',b'Attachments can be shown without enabling the shopping cart',b'Priedai gali b\xc5\xabti rodomas be leid\xc5\xbeianti krep\xc5\xa1elis'
+b'DocType: Normal Test Items',b'Result Value',b'Rezultato vert\xc4\x97'
+b'DocType: Hotel Room',b'Hotels',b'Vie\xc5\xa1bu\xc4\x8diai'
+b'DocType: Supplier Quotation',b'SQTN-',b'SQTN-'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22',b'New Cost Center Name',b'Nauja kaina centras vardas'
+b'DocType: Leave Control Panel',b'Leave Control Panel',b'Palikite Valdymo skydas'
+b'DocType: Project',b'Task Completion',b'u\xc5\xbeduotis u\xc5\xbebaigimas'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +22',b'Not in Stock',b'N\xc4\x97ra sand\xc4\x97lyje'
+b'DocType: Volunteer',b'Volunteer Skills',b'Savanori\xc5\xb3 \xc4\xafg\xc5\xabd\xc5\xbeiai'
+b'DocType: Appraisal',b'HR User',b'HR Vartotojas'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted',b'Mokes\xc4\x8diai ir rinkliavos I\xc5\xa1skaityta'
+b'apps/erpnext/erpnext/hooks.py +142',b'Issues',b'Problemos'
+b'apps/erpnext/erpnext/controllers/status_updater.py +12',b'Status must be one of {0}',b'Statusas turi b\xc5\xabti vienas i\xc5\xa1 {0}'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64',b'Reminder to update GSTIN Sent',b'Priminimas atnaujinti i\xc5\xa1si\xc5\xb3st\xc4\x85 GSTIN'
+b'DocType: Sales Invoice',b'Debit To',b'debeto'
+b'DocType: Restaurant Menu Item',b'Restaurant Menu Item',b'Restorano meniu punktas'
+b'DocType: Delivery Note',b'Required only for sample item.',b'Reikalinga tik imties elemento.'
+b'DocType: Stock Ledger Entry',b'Actual Qty After Transaction',b'Tikrasis Kiekis Po Sandorio'
+,b'Pending SO Items For Purchase Request',b'Kol SO daiktai \xc4\xafsigyti U\xc5\xbesisakyti'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35',b'Student Admissions',b'student\xc5\xb3 Pri\xc4\x97mimo'
+b'apps/erpnext/erpnext/accounts/party.py +388',b'{0} {1} is disabled',b'{0} {1} yra i\xc5\xa1jungtas'
+b'DocType: Supplier',b'Billing Currency',b'atsiskaitymo Valiuta'
+b'DocType: Sales Invoice',b'SINV-RET-',b'SINV-RET-'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200',b'Extra Large',b'Labai didelis'
+b'DocType: Crop',b'Scientific Name',b'Mokslinis vardas'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Leaves',b'I\xc5\xa1 viso lapai'
+b'DocType: Customer',"b'Reselect, if the chosen contact is edited after save'","b'I\xc5\xa1 naujo pasirinkite, jei pasirinktas kontaktas bus redaguojamas po \xc4\xafra\xc5\xa1ymo'"
+b'DocType: Consultation',b'In print',b'Spausdinti'
+,b'Profit and Loss Statement',b'Pelno ir nuostolio ataskaita'
+b'DocType: Bank Reconciliation Detail',b'Cheque Number',b'Komunalin\xc4\x97s Ta\xc5\xa1k\xc5\xb3'
+,b'Sales Browser',b'pardavim\xc5\xb3 nar\xc5\xa1ykl\xc4\x97'
+b'DocType: Journal Entry',b'Total Credit',b'Kreditai'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542',b'Warning: Another {0} # {1} exists against stock entry {2}',b'\xc4\xaesp\xc4\x97jimas: Kitas {0} # {1} egzistuoja nuo akcij\xc5\xb3 \xc4\xafra\xc5\xa1\xc4\x85 {2}'
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +66',b'Local',b'vietinis'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26',b'Loans and Advances (Assets)',b'Paskolos ir avansai (turtas)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12',b'Debtors',b'skolininkai'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199',b'Large',b'Didelis'
+b'DocType: Homepage Featured Product',b'Homepage Featured Product',b'Pagrindinis puslapis Teminiai Prek\xc4\x97s'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248',b'All Assessment Groups',b'Visi Vertinimo Grup\xc4\x97s'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15',b'New Warehouse Name',b'Naujas sand\xc4\x97lys Vardas'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +259',b'Total {0} ({1})',b'Viso {0} ({1})'
+b'DocType: C-Form Invoice Detail',b'Territory',b'teritorija'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151',b'Please mention no of visits required',b'Pamin\xc4\x97kite n\xc4\x97ra apsilankym\xc5\xb3 reikaling\xc5\xb3'
+b'DocType: Stock Settings',b'Default Valuation Method',b'Numatytasis vertinimo metodas'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26',b'Fee',b'Rinkliava'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +154',b'Update in progress. It might take a while.',b'Atnaujinimas vyksta. Tai gali u\xc5\xbetrukti.'
+b'DocType: Production Plan Item',b'Produced Qty',b'Pagamintas kiekis'
+b'DocType: Vehicle Log',b'Fuel Qty',b'kuro Kiekis'
+b'DocType: Stock Entry',b'Target Warehouse Name',b'Paskirties sand\xc4\x97lio pavadinimas'
+b'DocType: Work Order Operation',b'Planned Start Time',b'Planuojamas Prad\xc5\xbeios laikas'
+b'DocType: Course',b'Assessment',b'\xc4\xafvertinimas'
+b'DocType: Payment Entry Reference',b'Allocated',b'Paskirti'
+b'apps/erpnext/erpnext/config/accounts.py +267',b'Close Balance Sheet and book Profit or Loss.',b'U\xc5\xbedaryti Balansas ir knyga pelnas arba nuostolis.'
+b'DocType: Student Applicant',b'Application Status',b'parai\xc5\xa1kos b\xc5\xabsen\xc4\x85'
+b'DocType: Sensitivity Test Items',b'Sensitivity Test Items',b'Jautrumo testo elementai'
+b'DocType: Project Update',b'Project Update',b'Projekto atnaujinimas'
+b'DocType: Fees',b'Fees',b'Mokes\xc4\x8diai'
+b'DocType: Currency Exchange',b'Specify Exchange Rate to convert one currency into another',b'Nurodykite Valiut\xc5\xb3 kursai konvertuoti vien\xc4\x85 valiut\xc4\x85 \xc4\xaf kit\xc4\x85'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159',b'Quotation {0} is cancelled',b'Citata {0} at\xc5\xa1aukiamas'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119',b'Total Outstanding Amount',b'I\xc5\xa1 viso neapmok\xc4\x97ta suma'
+b'DocType: Sales Partner',b'Targets',b'tikslai'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54',b'Please register the SIREN number in the company information file',b'Pra\xc5\xa1ome \xc4\xafregistruoti SIREN numer\xc4\xaf bendrov\xc4\x97s informacijos byloje'
+b'DocType: Price List',b'Price List Master',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as magistras'
+b'DocType: GST Account',b'CESS Account',b'CESS s\xc4\x85skaita'
+b'DocType: Sales Person',b'All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.',"b'Visi pardavimo sandoriai gali b\xc5\xabti pa\xc5\xbeym\xc4\x97ti prie\xc5\xa1 kelis ** pardav\xc4\x97jai **, kad b\xc5\xabt\xc5\xb3 galima nustatyti ir steb\xc4\x97ti tikslus.'"
+,b'S.O. No.',b'SO Nr'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241',b'Please create Customer from Lead {0}',b'Pra\xc5\xa1ome sukurti klientui \xc5\xa0vinas {0}'
+b'apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3',b'Select Patient',b'Pasirinkite pacient\xc4\x85'
+b'DocType: Price List',b'Applicable for Countries',b'Taikoma \xc5\xa1ali\xc5\xb3'
+b'DocType: Supplier Scorecard Scoring Variable',b'Parameter Name',b'Parametro pavadinimas'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52',b'Student Group Name is mandatory in row {0}',b'Student\xc5\xb3 grup\xc4\x97s pavadinimas yra privalomas eil\xc4\x97s {0}'
+b'DocType: Homepage',b'Products to be shown on website homepage',b'Produktai turi b\xc5\xabti rodomas svetain\xc4\x97s puslapyje'
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13',b'This is a root customer group and cannot be edited.',b'Tai yra \xc5\xa1aknis klientas grup\xc4\x97 ir negali b\xc5\xabti pakeisti.'
+b'DocType: Student',b'AB-',b'AB-'
+b'DocType: POS Profile',b'Ignore Pricing Rule',b'Ignoruoti kainodaros taisykl\xc4\x97'
+b'DocType: Employee Education',b'Graduate',b'absolventas'
+b'DocType: Leave Block List',b'Block Days',b'Blokuoti dien\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83',"b'Shipping Address does not have country, which is required for this Shipping Rule'","b'Laivybos adresas neturi \xc5\xa1alies, kuri reikalinga \xc5\xa1iam siuntimo taisykl\xc4\x97m'"
+b'DocType: Journal Entry',b'Excise Entry',b'akcizo \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65',"b""Warning: Sales Order {0} already exists against Customer's Purchase Order {1}""",b'\xc4\xaesp\xc4\x97jimas: pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 {0} jau egzistuoja nuo Kliento U\xc5\xbesakymo {1}'
+b'DocType: Terms and Conditions',"b'Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.'","b'Standartin\xc4\x97s s\xc4\x85lygos, kurios gali b\xc5\xabti \xc4\xaftrauktos \xc4\xaf pardavimo ir pirkimo. Pavyzd\xc5\xbeiai: 1. galiojimas pasi\xc5\xablym\xc4\x85. 1. Mok\xc4\x97jimo s\xc4\x85lygos (i\xc5\xa1 anksto, kredito, dalis avanso ir tt). 1. Kas yra papildom\xc5\xb3 (arba tur\xc4\x97t\xc5\xb3 sumok\xc4\x97ti U\xc5\xbesakovui). 1. Saugumas / naudojimas \xc4\xafsp\xc4\x97jimo. 1. Garantija, jei toki\xc5\xb3 yra. 1. gr\xc4\x85\xc5\xbeinimo politik\xc4\x85. 1. Terminai laivybos, jei taikoma. 1. b\xc5\xabdus, kaip spr\xc4\x99sti gin\xc4\x8dus, civilin\xc4\x97s atsakomyb\xc4\x97s, atsakomyb\xc4\x97s ir tt 1. Adresas ir kontaktai J\xc5\xabs\xc5\xb3 \xc4\xafmon\xc4\x97je.'"
+b'DocType: Issue',b'Issue Type',b'Problemos tipas'
+b'DocType: Attendance',b'Leave Type',b'atostogos tipas'
+b'DocType: Purchase Invoice',b'Supplier Invoice Details',b'Tiek\xc4\x97jas S\xc4\x85skaitos informacija'
+b'DocType: Agriculture Task',b'Ignore holidays',b'Ignoruoti atostogas'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +233',"b""Expense / Difference account ({0}) must be a 'Profit or Loss' account""",b'Kompensuojamos / Skirtumas s\xc4\x85skaita ({0}) turi b\xc5\xabti &quot;pelnas arba nuostolis&quot; s\xc4\x85skaita'
+b'DocType: Project',b'Copied From',b'Nukopijuota i\xc5\xa1'
+b'DocType: Project',b'Copied From',b'Nukopijuota i\xc5\xa1'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340',b'Invoice already created for all billing hours',b'S\xc4\x85skaita fakt\xc5\xabra jau sukurta visoms atsiskaitymo valandoms'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96',b'Name error: {0}',b'Vardas klaida: {0}'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost',b'Ar yra finansin\xc4\x97s i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18',b'Attendance for employee {0} is already marked',b'Lankomumas darbuotojo {0} jau yra pa\xc5\xbeym\xc4\x97tas'
+b'DocType: Packing Slip',b'If more than one package of the same type (for print)',b'Jeigu yra daugiau nei vienas paketas tos pa\xc4\x8dios r\xc5\xab\xc5\xa1ies (spausdinimui)'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27',b'Please set default customer in Restaurant Settings',b'Nustatykite numatyt\xc4\x85j\xc4\xaf klient\xc4\x85 Restoran\xc5\xb3 nustatymuose'
+,b'Salary Register',b'Pajamos Registruotis'
+b'DocType: Warehouse',b'Parent Warehouse',b't\xc4\x97v\xc5\xb3 sand\xc4\x97lis'
+b'DocType: C-Form Invoice Detail',b'Net Total',b'grynasis I\xc5\xa1 viso'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +546',b'Default BOM not found for Item {0} and Project {1}',b'Numatyt\xc4\x85j\xc4\x85 BOM ne punkt\xc4\x85 rasti {0} ir projekto {1}'
+b'apps/erpnext/erpnext/config/hr.py +168',b'Define various loan types',b'Apibr\xc4\x97\xc5\xbeti \xc4\xafvairi\xc5\xb3 paskol\xc5\xb3 tip\xc5\xb3'
+b'DocType: Bin',b'FCFS Rate',b'FCFS Balsuok'
+b'DocType: Opening Invoice Creation Tool Item',b'Outstanding Amount',b'nesumok\xc4\x97tos sumos'
+b'apps/erpnext/erpnext/templates/generators/bom.html +71',b'Time(in mins)',b'Laikas (min)'
+b'DocType: Project Task',b'Working',b'darbo'
+b'DocType: Stock Ledger Entry',b'Stock Queue (FIFO)',b'Akcij\xc5\xb3 eil\xc4\x99 (FIFO)'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +127',b'Financial Year',b'Finansiniai metai'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46',b'{0} does not belong to Company {1}',b'{0} nepriklauso Company {1}'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66',b'Could not solve criteria score function for {0}. Make sure the formula is valid.',"b'Nepavyko spr\xc4\x99sti {0} kriterij\xc5\xb3 rezultat\xc5\xb3 funkcijos. \xc4\xaesitikinkite, kad formul\xc4\x97 galioja.'"
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122',b'Cost as on',b'Kainuoti apie'
+b'DocType: Healthcare Settings',b'Out Patient Settings',b'I\xc5\xa1eikite paciento nustatymus'
+b'DocType: Account',b'Round Off',b'suapvalinti'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259',b'Quantity must be positive',b'Kiekis turi b\xc5\xabti teigiamas'
+b'DocType: Material Request Plan Item',b'Requested Qty',b'pra\xc5\xa1oma Kiekis'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96',b'The fields From Shareholder and To Shareholder cannot be blank',b'Laukai i\xc5\xa1 akcininko ir akcininko negali b\xc5\xabti tu\xc5\xa1ti'
+b'DocType: Tax Rule',b'Use for Shopping Cart',b'Naudokite krep\xc5\xa1el\xc4\xaf'
+b'apps/erpnext/erpnext/controllers/item_variant.py +101',b'Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}',b'Vert\xc4\x97 {0} atributas {1} neegzistuoja taikomi tinkamos preki\xc5\xb3 ar paslaug\xc5\xb3 s\xc4\x85ra\xc5\xa1\xc4\x85 \xc4\xaeg\xc5\xabdis vertes punkte {2}'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79',b'Select Serial Numbers',b'Pasirinkite serijos numeriu'
+b'DocType: BOM Item',b'Scrap %',b'lau\xc5\xbeas%'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46',"b'Charges will be distributed proportionately based on item qty or amount, as per your selection'","b'Mokes\xc4\x8diai bus platinamas proporcingai remiantis punktas Kiekis arba sumos, kaip u\xc5\xbe savo pasirinkim\xc4\x85'"
+b'DocType: Maintenance Visit',b'Purposes',b'Tikslai'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112',b'Atleast one item should be entered with negative quantity in return document',b'Atleast vienas punktas turi b\xc5\xabti \xc4\xafra\xc5\xa1omas neigiamas kiekio gr\xc4\x85\xc5\xbeinimo dokument\xc4\x85'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71',"b'Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations'","b'Operacija {0} ilgiau nei bet kokiomis darbo valand\xc5\xb3 darbo vietos {1}, suskaidyti operacij\xc4\x85 \xc4\xaf keli\xc5\xb3 operacij\xc5\xb3'"
+b'DocType: Membership',b'Membership Status',b'Naryst\xc4\x97s statusas'
+,b'Requested',b'pra\xc5\xa1oma'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93',b'No Remarks',b'n\xc4\x97ra Pastabos'
+b'DocType: Asset',b'In Maintenance',b'Prie\xc5\xbei\xc5\xabra'
+b'DocType: Purchase Invoice',b'Overdue',b'pav\xc4\x97luotas'
+b'DocType: Account',b'Stock Received But Not Billed',"b'Vertybini\xc5\xb3 popieri\xc5\xb3 gaunamas, bet nereikia mok\xc4\x97ti'"
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +84',b'Root Account must be a group',b'\xc5\xa0akn\xc5\xb3 s\xc4\x85skaita turi b\xc5\xabti grup\xc4\x97'
+b'DocType: Drug Prescription',b'Drug Prescription',b'Narkotik\xc5\xb3 recepcija'
+b'DocType: Fees',b'FEE.',b'RINKLIAVA.'
+b'DocType: Employee Loan',b'Repaid/Closed',b'Gr\xc4\x85\xc5\xbeinama / U\xc5\xbedarymo'
+b'DocType: Item',b'Total Projected Qty',b'I\xc5\xa1 viso prognozuojama Kiekis'
+b'DocType: Monthly Distribution',b'Distribution Name',b'platinimo Vardas'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +477',"b'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'","b'Prek\xc4\x97s {0} ne\xc4\xafvertinta, kuri reikalinga apskaitos \xc4\xafra\xc5\xa1ams atlikti {1} {2}. Jei objektas sandoriuos kaip nulinis vertinimo koeficiento elementas {1}, pra\xc5\xa1ome pamin\xc4\x97ti tai {1} elemento lentel\xc4\x97je. Prie\xc5\xa1ingu atveju, sukurkite gaut\xc4\x85 atsargin\xc4\xaf sandor\xc4\xaf elementui arba pamin\xc4\x97kite vertinimo rodikl\xc4\xaf elemento \xc4\xafra\xc5\xa1e, tada pabandykite pateikti / at\xc5\xa1aukti \xc5\xa1\xc4\xaf \xc4\xafra\xc5\xa1\xc4\x85'"
+b'DocType: Course',b'Course Code',b'Dalyko kodas'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +337',b'Quality Inspection required for Item {0}',b'Kokyb\xc4\x97s inspekcija privalo u\xc5\xbe prek\xc4\x99 {0}'
+b'DocType: POS Settings',b'Use POS in Offline Mode',b'Naudokite POS neprisijungus'
+b'DocType: Supplier Scorecard',b'Supplier Variables',b'Tiek\xc4\x97jo kintamieji'
+b'DocType: Quotation',"b""Rate at which customer's currency is converted to company's base currency""","b'Norma, pagal kuri\xc4\x85 klientas valiuta yra konvertuojamos \xc4\xaf \xc4\xafmon\xc4\x97s bazine valiuta'"
+b'DocType: Purchase Invoice Item',b'Net Rate (Company Currency)',b'Grynoji pal\xc5\xabkan\xc5\xb3 normos (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Salary Detail',b'Condition and Formula Help',b'B\xc5\xabkl\xc4\x97 ir &quot;Formula Pagalba'
+b'apps/erpnext/erpnext/config/selling.py +105',b'Manage Territory Tree.',b'Tvarkyti Teritorija med\xc4\xaf.'
+b'DocType: Patient Service Unit',b'Patient Service Unit',b'Pacient\xc5\xb3 aptarnavimo skyrius'
+b'DocType: Journal Entry Account',b'Sales Invoice',b'pardavim\xc5\xb3 s\xc4\x85skaita fakt\xc5\xabra'
+b'DocType: Journal Entry Account',b'Party Balance',b'\xc5\xa1alis balansas'
+b'DocType: Cash Flow Mapper',b'Section Subtotal',b'Tarpin\xc4\x97 dalis'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +498',b'Please select Apply Discount On',b'Pra\xc5\xa1ome pasirinkti Taikyti nuolaid\xc4\x85'
+b'DocType: Stock Settings',b'Sample Retention Warehouse',b'M\xc4\x97ginio saugojimo sand\xc4\x97lis'
+b'DocType: Company',b'Default Receivable Account',b'Numatytasis Gautinos s\xc4\x85skaitos'
+b'DocType: Physician Schedule',b'Physician Schedule',b'Gydytojo tvarkara\xc5\xa1tis'
+b'DocType: Purchase Invoice',b'Deemed Export',b'Laikomas eksportas'
+b'DocType: Stock Entry',b'Material Transfer for Manufacture',b'Med\xc5\xbeiagos perne\xc5\xa1imas gamybai'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20',b'Discount Percentage can be applied either against a Price List or for all Price List.',b'Nuolaida procentas gali b\xc5\xabti taikomas bet prie\xc5\xa1 kainora\xc5\xa1tis arba vis\xc5\xb3 kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as.'
+b'DocType: Subscription',b'Half-yearly',b'Kart\xc4\x85 per pusmet\xc4\xaf'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407',b'Accounting Entry for Stock',b'Apskaitos \xc4\xafra\xc5\xa1as u\xc5\xbe Sand\xc4\x97lyje'
+b'DocType: Lab Test',b'LabTest Approver',b'&quot;LabTest&quot; patvirtintojai'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61',b'You have already assessed for the assessment criteria {}.',b'J\xc5\xabs jau \xc4\xafvertintas vertinimo kriterijus {}.'
+b'DocType: Vehicle Service',b'Engine Oil',b'Variklio alyva'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1005',b'Work Orders Created: {0}',b'Sukurtas darbo u\xc5\xbesakymas: {0}'
+b'DocType: Sales Invoice',b'Sales Team1',b'pardavim\xc5\xb3 team1'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +547',b'Item {0} does not exist',b'Prek\xc4\x97 {0} neegzistuoja'
+b'DocType: Sales Invoice',b'Customer Address',b'Klient\xc5\xb3 Adresas'
+b'DocType: Employee Loan',b'Loan Details',b'paskolos detal\xc4\x97s'
+b'DocType: Company',b'Default Inventory Account',b'Numatytasis Inventorius paskyra'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192',b'The folio numbers are not matching',b'Folio numeriai nesuderinami'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124',b'Row {0}: Completed Qty must be greater than zero.',b'Eilut\xc4\x97s {0}: baig\xc4\x97 Kiekis turi b\xc5\xabti didesn\xc4\x97 u\xc5\xbe nul\xc4\xaf.'
+b'DocType: Item Barcode',b'Barcode Type',b'Br\xc5\xabk\xc5\xa1ninio kodo tipas'
+b'DocType: Antibiotic',b'Antibiotic Name',b'Antibiotiko pavadinimas'
+b'DocType: Purchase Invoice',b'Apply Additional Discount On',b'B\xc5\xabti taikomos papildomos nuolaida'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66',b'Select Type...',b'Pasirinkite tip\xc4\x85 ...'
+b'DocType: Crop Cycle',b'A link to all the Land Units in which the Crop is growing',"b'Nuoroda \xc4\xaf visus \xc5\xbdem\xc4\x97s vienetus, kuriuose auga augalas'"
+b'DocType: Account',b'Root Type',b'\xc5\xa0akn\xc5\xb3 tipas'
+b'DocType: Item',b'FIFO',b'FIFO'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136',b'Row # {0}: Cannot return more than {1} for Item {2}',b'Eilut\xc4\x97s # {0}: negali gr\xc4\xaf\xc5\xbeti daugiau nei {1} u\xc5\xbe prek\xc4\x99 {2}'
+b'DocType: Item Group',b'Show this slideshow at the top of the page',b'Parodyti \xc5\xa1i\xc4\x85 demonstracij\xc4\x85 prie puslapio vir\xc5\xa1uje'
+b'DocType: BOM',b'Item UOM',b'Prek\xc4\x97 UOM'
+b'DocType: Sales Taxes and Charges',b'Tax Amount After Discount Amount (Company Currency)',"b'Mokes\xc4\x8di\xc5\xb3 suma, nuolaidos suma (\xc4\xaemon\xc4\x97s valiuta)'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177',b'Target warehouse is mandatory for row {0}',b'Tikslin\xc4\x97 sand\xc4\x97lis yra privalomas eil\xc4\x97s {0}'
+b'DocType: Cheque Print Template',b'Primary Settings',b'pirminiai nustatymai'
+b'DocType: Purchase Invoice',b'Select Supplier Address',b'Pasirinkite Tiek\xc4\x97jas Adresas'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397',b'Add Employees',b'Prid\xc4\x97ti Darbuotojai'
+b'DocType: Purchase Invoice Item',b'Quality Inspection',b'kokyb\xc4\x97s inspekcija'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196',b'Extra Small',b'Papildomas Ma\xc5\xbeas'
+b'DocType: Company',b'Standard Template',b'standartin\xc4\xaf \xc5\xa1ablon\xc4\x85'
+b'DocType: Training Event',b'Theory',b'teorija'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806',b'Warning: Material Requested Qty is less than Minimum Order Qty',b'\xc4\xaesp\xc4\x97jimas: Med\xc5\xbeiaga Pra\xc5\xa1oma Kiekis yra ma\xc5\xbeesnis nei minimalus u\xc5\xbesakymas Kiekis'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211',b'Account {0} is frozen',b'S\xc4\x85skaita {0} yra su\xc5\xa1aldyti'
+b'DocType: Company',b'Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.',"b'Juridinio asmens / Dukterin\xc4\x97 \xc4\xafmon\xc4\x97 su atskiru Chart s\xc4\x85skait\xc5\xb3, priklausan\xc4\x8di\xc5\xb3 organizacijos.'"
+b'DocType: Payment Request',b'Mute Email',b'Nutildyti pa\xc5\xa1tas'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29',"b'Food, Beverage & Tobacco'","b'Maistas, g\xc4\x97rimai ir tabako'"
+b'DocType: Account',b'Account Number',b'Paskyros numeris'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752',b'Can only make payment against unbilled {0}',b'Gali tik sumok\xc4\x97ti prie\xc5\xa1 Neapmokestinama {0}'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +102',b'Commission rate cannot be greater than 100',b'Komisinis mokestis gali b\xc5\xabti ne didesn\xc4\x97 kaip 100'
+b'DocType: Volunteer',b'Volunteer',b'Savanoris'
+b'DocType: Stock Entry',b'Subcontract',b'subrangos sutartys'
+b'apps/erpnext/erpnext/public/js/utils/party.js +166',b'Please enter {0} first',b'Pra\xc5\xa1ome \xc4\xafvesti {0} pirmas'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104',b'No replies from',b'N\xc4\x97ra atsakym\xc5\xb3'
+b'DocType: Work Order Operation',b'Actual End Time',b'Tikrasis Pabaigos laikas'
+b'DocType: Item',b'Manufacturer Part Number',b'Gamintojo kodas'
+b'DocType: Work Order Operation',b'Estimated Time and Cost',b'Numatoma trukm\xc4\x97 ir kaina'
+b'DocType: Bin',b'Bin',b'd\xc4\x97\xc5\xbe\xc4\x97'
+b'DocType: Crop',b'Crop Name',b'Paskirstymo pavadinimas'
+b'DocType: SMS Log',b'No of Sent SMS',b'N\xc4\x97ra i\xc5\xa1si\xc5\xb3st\xc5\xb3 SMS'
+b'DocType: Antibiotic',b'Healthcare Administrator',b'Sveikatos prie\xc5\xbei\xc5\xabros administratorius'
+b'apps/erpnext/erpnext/utilities/user_progress.py +47',b'Set a Target',b'Nustatykite tiksl\xc4\x85'
+b'DocType: Dosage Strength',b'Dosage Strength',b'Doz\xc4\x97s stiprumas'
+b'DocType: Account',b'Expense Account',b'Kompensuojamos paskyra'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49',b'Software',b'programin\xc4\x97 \xc4\xafranga'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203',b'Colour',b'Spalva'
+b'DocType: Assessment Plan Criteria',b'Assessment Plan Criteria',b'Vertinimo planas kriterijai'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +118',b'Expiry date is mandatory for selected item',b'Galiojimo data yra privaloma pasirinktam elementui'
+b'DocType: Supplier Scorecard Scoring Standing',b'Prevent Purchase Orders',b'U\xc5\xbekirsti keli\xc4\x85 pirkimo u\xc5\xbesakymams'
+b'apps/erpnext/erpnext/healthcare/setup.py +258',b'Susceptible',b'Jautrus'
+b'DocType: Patient Appointment',b'Scheduled',b'planuojama'
+b'apps/erpnext/erpnext/config/buying.py +18',b'Request for quotation.',b'U\xc5\xbeklausimas.'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13',"b'Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle'",b'Pra\xc5\xa1ome pasirinkti Element\xc4\x85 kur &quot;Ar riedmenys&quot; yra &quot;Ne&quot; ir &quot;Ar Pardavim\xc5\xb3 punktas&quot; yra &quot;Taip&quot; ir n\xc4\x97ra jokio kito Prek\xc4\x97s Rinkinys'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148',b'Select Customer',b'Pasirinkite klient\xc4\x85'
+b'DocType: Student Log',b'Academic',b'akademinis'
+b'DocType: Patient',b'Personal and Social History',b'Asmenin\xc4\x97 ir socialin\xc4\x97 istorija'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51',b'User {0} created',b'Naudotojas {0} suk\xc5\xabr\xc4\x97'
+b'DocType: Fee Schedule',b'Fee Breakup for each student',b'Mokes\xc4\x8dio pervir\xc5\xa1is kiekvienam studentui'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +541',b'Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2})',b'I\xc5\xa1 viso avansas ({0}) prie\xc5\xa1 ordino {1} negali b\xc5\xabti didesnis nei I\xc5\xa0 VISO ({2})'
+b'DocType: Sales Partner',b'Select Monthly Distribution to unevenly distribute targets across months.',b'Pasirinkite M\xc4\x97nesio pasiskirstymas \xc4\xaf netolygiai paskirstyti tikslus visoje m\xc4\x97nesius.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78',b'Change Code',b'Keisti kod\xc4\x85'
+b'DocType: Purchase Invoice Item',b'Valuation Rate',b'Vertinimo Balsuok'
+b'DocType: Stock Reconciliation',b'SR/',b'SR /'
+b'DocType: Vehicle',b'Diesel',b'dyzelinis'
+b'apps/erpnext/erpnext/stock/get_item_details.py +388',b'Price List Currency not selected',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as Valiuta nepasirinkote'
+b'DocType: Purchase Invoice',b'Availed ITC Cess',b'Pasinaudojo ITC Cess'
+,b'Student Monthly Attendance Sheet',b'Student\xc5\xb3 M\xc4\x97nesio Lankomumas lapas'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96',b'Shipping rule only applicable for Selling',b'Pristatymo taisykl\xc4\x97 taikoma tik Pardavimui'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30',b'Project Start Date',b'Projekto prad\xc5\xbeia'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23',b'Until',b'iki'
+b'DocType: Rename Tool',b'Rename Log',b'pervadinti Prisijungti'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Student\xc5\xb3 grup\xc4\x97 ar u\xc5\xbesi\xc4\x97mim\xc5\xb3 tvarkara\xc5\xa1tis yra privalomi'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Student\xc5\xb3 grup\xc4\x97 ar u\xc5\xbesi\xc4\x97mim\xc5\xb3 tvarkara\xc5\xa1tis yra privalomi'
+b'DocType: HR Settings',b'Maintain Billing Hours and Working Hours Same on Timesheet',b'I\xc5\xa1laikyti Atsiskaitymo valandas ir darbo valand\xc5\xb3 pat\xc4\xaf laiko apskaitos \xc5\xbeiniara\xc5\xa1tis'
+b'DocType: Maintenance Visit Purpose',b'Against Document No',b'Su dokument\xc5\xb3 Nr'
+b'DocType: BOM',b'Scrap',b'metalo lau\xc5\xbeas'
+b'apps/erpnext/erpnext/utilities/user_progress.py +217',b'Go to Instructors',b'Eiti instruktoriams'
+b'apps/erpnext/erpnext/config/selling.py +110',b'Manage Sales Partners.',b'Tvarkyti Pardavim\xc5\xb3 Partneriai.'
+b'DocType: Quality Inspection',b'Inspection Type',b'Patikrinimo tipas'
+b'DocType: Fee Validity',b'Visited yet',b'Aplank\xc4\x97 dar'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134',b'Warehouses with existing transaction can not be converted to group.',b'Sand\xc4\x97liai su esamais sandoris negali b\xc5\xabti konvertuojamos \xc4\xaf grup\xc4\x99.'
+b'DocType: Assessment Result Tool',b'Result HTML',b'rezultatas HTML'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35',b'Expires On',b'Baigia galioti'
+b'apps/erpnext/erpnext/utilities/activation.py +117',b'Add Students',b'Prid\xc4\x97ti Studentai'
+b'apps/erpnext/erpnext/public/js/utils.js +270',b'Please select {0}',b'Pra\xc5\xa1ome pasirinkti {0}'
+b'DocType: C-Form',b'C-Form No',b'C-formos N\xc4\x97ra'
+b'DocType: BOM',b'Exploded_items',b'Exploded_items'
+b'apps/erpnext/erpnext/utilities/user_progress.py +139',b'List your products or services that you buy or sell.',"b'Nurodykite savo produktus ar paslaugas, kurias perkate ar parduodate.'"
+b'DocType: Water Analysis',b'Storage Temperature',b'Laikymo temperat\xc5\xabra'
+b'DocType: Employee Attendance Tool',b'Unmarked Attendance',b'prie\xc5\xbei\xc5\xabros Lankomumas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137',b'Researcher',b'tyr\xc4\x97jas'
+b'DocType: Program Enrollment Tool Student',b'Program Enrollment Tool Student',b'Programos \xc4\xaera\xc5\xa1as \xc4\xafrankis Student\xc5\xb3'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16',b'Start date should be less than end date for task {0}',b'Prad\xc5\xbeios data turi b\xc5\xabti ma\xc5\xbeesn\xc4\x97 u\xc5\xbe u\xc5\xbeduoties pabaigos dat\xc4\x85 {0}'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25',b'Name or Email is mandatory',b'Vardas arba el privaloma'
+b'DocType: Member',b'MEM-',b'MEM-'
+b'DocType: Instructor',b'Instructor Log',b'Instruktori\xc5\xb3 \xc5\xbeurnalas'
+b'DocType: Purchase Order Item',b'Returned Qty',b'gr\xc4\xaf\xc5\xbeo Kiekis'
+b'DocType: Student',b'Exit',b'i\xc5\xa1eiti'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +156',b'Root Type is mandatory',b'\xc5\xa0akn\xc5\xb3 tipas yra privalomi'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29',b'Failed to install presets',b'Nepavyko \xc4\xafdiegti i\xc5\xa1 anksto nustatyt\xc5\xb3 nustatym\xc5\xb3'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44',"b'{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.'","b'{0} \xc5\xa1iuo metu turi {1} tiek\xc4\x97j\xc5\xb3 rezultat\xc5\xb3 kortel\xc4\x99, o \xc5\xa1io tiek\xc4\x97jo RFQ tur\xc4\x97t\xc5\xb3 b\xc5\xabti pateikiama atsargiai.'"
+b'DocType: Chapter',b'Non Profit Manager',b'Ne pelno administratorius'
+b'DocType: BOM',b'Total Cost(Company Currency)',b'I\xc5\xa1 viso i\xc5\xa1laid\xc5\xb3 (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315',b'Serial No {0} created',b'Serijos Nr {0} suk\xc5\xabr\xc4\x97'
+b'DocType: Homepage',b'Company Description for website homepage',b'\xc4\xaemon\xc4\x97s apra\xc5\xa1ymas interneto svetain\xc4\x97s pagrindiniame puslapyje'
+b'DocType: Item Customer Detail',"b'For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes'","b'D\xc4\x97l klient\xc5\xb3 patogumui, \xc5\xa1ie kodai gali b\xc5\xabti naudojami spausdinimo formatus, pavyzd\xc5\xbeiui, s\xc4\x85skaitose ir va\xc5\xbetara\xc5\xa1\xc4\x8diuose'"
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18',b'Suplier Name',b'suplier Vardas'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +174',b'Could not retrieve information for {0}.',b'Nepavyko gauti informacijos apie {0}.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134',b'Opening Entry Journal',b'Atidarymo leidinys'
+b'DocType: Sales Invoice',b'Time Sheet List',b'Laikas lapas s\xc4\x85ra\xc5\xa1as'
+b'DocType: Employee',b'You can enter any date manually',b'Galite \xc4\xafvesti bet kok\xc4\xaf dat\xc4\x85 rankiniu b\xc5\xabdu'
+b'DocType: Healthcare Settings',b'Result Printed',b'Rezultatas spausdintas'
+b'DocType: Asset Category Account',b'Depreciation Expense Account',b'Nusid\xc4\x97v\xc4\x97jimo s\xc4\x85naudos paskyra'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233',b'Probationary Period',b'Bandomasis laikotarpis'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32',b'View {0}',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti {0}'
+b'DocType: Customer Group',b'Only leaf nodes are allowed in transaction',b'Tik lap\xc5\xb3 mazgai leid\xc5\xbeiama sandorio'
+b'DocType: Project',b'Total Costing Amount (via Timesheets)',b'Bendra s\xc4\x85naud\xc5\xb3 suma (per laiko lapus)'
+b'DocType: Employee Advance',b'Expense Approver',b'Kompensuojamos Tvirtintojas'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136',b'Row {0}: Advance against Customer must be credit',b'Eilut\xc4\x97s {0}: I\xc5\xa1ankstinis prie\xc5\xa1 u\xc5\xbesakovui turi b\xc5\xabti kredito'
+b'DocType: Project',b'Hourly',b'Valand\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +89',b'Non-Group to Group',b'Ne grup\xc4\x97 \xc4\xaf grup\xc4\x99'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Partijos yra imperatyvaus eil\xc4\x97s {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Partijos yra imperatyvaus eil\xc4\x97s {0}'
+b'DocType: Purchase Receipt Item Supplied',b'Purchase Receipt Item Supplied',b'Pirkimo kvito punktas Pateikiamas'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'To Datetime',b'Nor\xc4\x97dami datetime'
+b'apps/erpnext/erpnext/config/selling.py +302',b'Logs for maintaining sms delivery status',b'R\xc4\x85stai i\xc5\xa1laikyti sms b\xc5\xabsenos'
+b'DocType: Accounts Settings',b'Make Payment via Journal Entry',b'Atlikti mok\xc4\x97jim\xc4\x85 per \xc5\xbeurnalo \xc4\xafra\xc5\xa1\xc4\x85'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +223',b'Printed On',b'Atspausdinta ant'
+b'DocType: Item',b'Inspection Required before Delivery',b'Patikrinimo Reikalinga prie\xc5\xa1 Pristatymas'
+b'DocType: Item',b'Inspection Required before Purchase',b'Patikrinimo Reikalinga prie\xc5\xa1 perkant'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93',b'Pending Activities',b'Kol veiklos'
+b'DocType: Patient Appointment',b'Reminded',b'Primena'
+b'DocType: Patient',b'PID-',b'PID-'
+b'DocType: Chapter Member',b'Chapter Member',b'Skyrius narys'
+b'DocType: Material Request Plan Item',b'Minimum Order Quantity',b'Minimalus U\xc5\xbesakymo Kiekis'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +106',b'Your Organization',b'J\xc5\xabs\xc5\xb3 organizacija'
+b'DocType: Fee Component',b'Fees Category',b'Mokes\xc4\x8diai Kategorija'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +134',b'Please enter relieving date.',b'Pra\xc5\xa1ome \xc4\xafvesti mal\xc5\xa1inan\xc4\x8di\xc5\xb3 dat\xc4\x85.'
+b'apps/erpnext/erpnext/controllers/trends.py +149',b'Amt',b'amt'
+b'DocType: Supplier Scorecard',b'Notify Employee',b'Prane\xc5\xa1ti darbuotojui'
+b'DocType: Opportunity',b'Enter name of campaign if source of enquiry is campaign',b'\xc4\xaeveskite vard\xc4\x85 kampanijos jei \xc5\xa1altinis tyrimo yra akcija'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38',b'Newspaper Publishers',b'laikra\xc5\xa1\xc4\x8di\xc5\xb3 leid\xc4\x97jai'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30',b'Select Fiscal Year',b'Pasirinkite finansiniai metai'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115',b'Expected Delivery Date should be after Sales Order Date',b'Laukiama pristatymo data tur\xc4\x97t\xc5\xb3 b\xc5\xabti pateikta po Pardavim\xc5\xb3 u\xc5\xbesakymo data'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42',b'Reorder Level',b'Pertvarkyti lygis'
+b'DocType: Company',b'Chart Of Accounts Template',b'S\xc4\x85skait\xc5\xb3 planas \xc5\xa0ablonas'
+b'DocType: Attendance',b'Attendance Date',b'lankomumas data'
+b'apps/erpnext/erpnext/stock/get_item_details.py +352',b'Item Price updated for {0} in Price List {1}',b'Prek\xc4\x97 Kaina atnaujintas {0} kainora\xc5\xa1tis {1}'
+b'DocType: Salary Structure',b'Salary breakup based on Earning and Deduction.',b'Pajamos Griauti remiantis u\xc5\xbedirbti ir atskait\xc4\x85.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +128',b'Account with child nodes cannot be converted to ledger',b'S\xc4\x85skaita su vaik\xc5\xb3 mazg\xc5\xb3 negali b\xc5\xabti konvertuojamos \xc4\xaf s\xc4\x85skait\xc5\xb3 knygos'
+b'DocType: Purchase Invoice Item',b'Accepted Warehouse',b'Priimamos sand\xc4\x97lis'
+b'DocType: Bank Reconciliation Detail',b'Posting Date',b'I\xc5\xa1siuntimo data'
+b'DocType: Item',b'Valuation Method',b'vertinimo metodas'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203',b'Mark Half Day',b'Pa\xc5\xbeym\xc4\x97ti Pus\xc4\x97 dienos'
+b'DocType: Sales Invoice',b'Sales Team',b'Sales Team'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87',b'Duplicate entry',b'pasikartojantis \xc4\xafra\xc5\xa1as'
+b'DocType: Program Enrollment Tool',b'Get Students',b'Gauk Studentai'
+b'DocType: Serial No',b'Under Warranty',b'pagal Garantija'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516',b'[Error]',b'[Klaida]'
+b'DocType: Sales Order',b'In Words will be visible once you save the Sales Order.',"b'\xc5\xbdod\xc5\xbeiais bus matomas, kai j\xc5\xabs i\xc5\xa1gelb\xc4\x97ti pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3.'"
+,b'Employee Birthday',b'Darbuotoj\xc5\xb3 Gimimo diena'
+b'apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14',b'Please select Completion Date for Completed Repair',b'Pra\xc5\xa1ome pasirinkti u\xc5\xbebaigto remonto u\xc5\xbebaigimo dat\xc4\x85'
+b'DocType: Student Batch Attendance Tool',b'Student Batch Attendance Tool',b'Student\xc5\xb3 Serija Lankomumas \xc4\xafrankis'
+b'apps/erpnext/erpnext/controllers/status_updater.py +213',b'Limit Crossed',b'riba Crossed'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22',b'Scheduled Upto',b'Suplanuotas iki'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55',b'Venture Capital',b'Venture Capital &quot;'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40',"b""An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.""",b'Akademinis terminas su \xc5\xa1ia &quot;Akademinio met\xc5\xb3&quot; {0} ir &quot;Terminas Vardas&quot; {1} jau egzistuoja. Pra\xc5\xa1ome pakeisti \xc5\xa1iuos \xc4\xafra\xc5\xa1us ir pabandykite dar kart\xc4\x85.'
+b'DocType: UOM',b'Must be Whole Number',b'Turi b\xc5\xabti sveikasis skai\xc4\x8dius'
+b'DocType: Leave Control Panel',b'New Leaves Allocated (In Days)',b'Nauj\xc5\xb3 lap\xc5\xb3 Pervedimai\xc4\xaf (dienomis)'
+b'DocType: Purchase Invoice',b'Invoice Copy',b's\xc4\x85skaitos kopij\xc4\x85'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49',b'Serial No {0} does not exist',b'Serijos Nr {0} neegzistuoja'
+b'DocType: Sales Invoice Item',b'Customer Warehouse (Optional)',b'Klient\xc5\xb3 Sand\xc4\x97lis (neprivalomas)'
+b'DocType: Pricing Rule',b'Discount Percentage',b'Nuolaida procentas'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51',b'Reserved for sub contracting',b'Rezervuota subrangovams'
+b'DocType: Payment Reconciliation Invoice',b'Invoice Number',b'S\xc4\x85skaitos numeris'
+b'DocType: Shopping Cart Settings',b'Orders',b'U\xc5\xbesakymai'
+b'DocType: Employee Leave Approver',b'Leave Approver',b'Palikite j\xc4\xaf patvirtinusio'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285',b'Please select a batch',b'Pra\xc5\xa1ome pasirinkti partij\xc4\x85'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalLib',b'JournalLib'
+b'DocType: Assessment Group',b'Assessment Group Name',b'Vertinimas Grup\xc4\x97s pavadinimas'
+b'DocType: Manufacturing Settings',b'Material Transferred for Manufacture',"b'Med\xc5\xbeiagos, perduotos gamybai'"
+b'DocType: Landed Cost Item',b'Receipt Document Type',b'Gavimas Dokumento tipas'
+b'DocType: Daily Work Summary Settings',b'Select Companies',b'Atrenkame \xc4\xafmones'
+b'DocType: Antibiotic',b'Healthcare',b'Sveikatos apsauga'
+b'DocType: Target Detail',b'Target Detail',b'Tikslin\xc4\x97 detal\xc4\x97s'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +65',b'Single Variant',b'Vienas variantas'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24',b'All Jobs',b'Visi Darbai'
+b'DocType: Sales Order',b'% of materials billed against this Sales Order',b'% med\xc5\xbeiag\xc5\xb3 yra pateiktos s\xc4\x85skaitos pagal \xc5\xa1\xc4\xaf Pardavimo U\xc5\xbesakym\xc4\x85'
+b'DocType: Program Enrollment',b'Mode of Transportation',b'Transporto re\xc5\xbeimas'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49',b'Period Closing Entry',b'Laikotarpis u\xc5\xbedarymas \xc4\xae\xc4\x97jimas'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72',b'Select Department...',b'Pasirinkite skyri\xc5\xb3 ...'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38',b'Cost Center with existing transactions can not be converted to group',b'Kaina centras su esamais sandoriai negali b\xc5\xabti konvertuojamos \xc4\xaf grup\xc4\x97s'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374',b'Amount {0} {1} {2} {3}',b'Suma {0} {1} {2} {3}'
+b'DocType: Account',b'Depreciation',b'amortizacija'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102',b'The number of shares and the share numbers are inconsistent',b'Akcij\xc5\xb3 skai\xc4\x8dius ir akcij\xc5\xb3 skai\xc4\x8dius yra nenuosekl\xc5\xabs'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49',b'Supplier(s)',b'Tiek\xc4\x97jas (-ai)'
+b'DocType: Employee Attendance Tool',b'Employee Attendance Tool',b'Darbuotoj\xc5\xb3 dalyvavimas \xc4\xafrankis'
+b'DocType: Guardian Student',b'Guardian Student',b'&quot;guardian&quot; Student\xc5\xb3'
+b'DocType: Supplier',b'Credit Limit',b'Kredito limitas'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Selling Price List Rate',b'Vidur. Pardavimo kain\xc5\xb3 s\xc4\x85ra\xc5\xa1o norma'
+b'DocType: Salary Component',b'Salary Component',b'Pajamos komponentas'
+b'apps/erpnext/erpnext/accounts/utils.py +495',b'Payment Entries {0} are un-linked',b'Apmok\xc4\x97jimo \xc4\xaera\xc5\xa1ai {0} yra JT susiet\xc5\xb3'
+b'DocType: GL Entry',b'Voucher No',b'Bon N\xc4\x97ra'
+,b'Lead Owner Efficiency',b'\xc5\xa0vinas Savininko efektyvumas'
+,b'Lead Owner Efficiency',b'\xc5\xa0vinas Savininko efektyvumas'
+b'DocType: Leave Allocation',b'Leave Allocation',b'Palikite paskirstymas'
+b'DocType: Payment Request',b'Recipient Message And Payment Details',b'Gav\xc4\x97jas prane\xc5\xa1im\xc4\x85 ir Mok\xc4\x97jimo informacija'
+b'DocType: Training Event',b'Trainer Email',b'treneris pa\xc5\xa1tas'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550',b'Material Requests {0} created',b'Med\xc5\xbeiaga Pra\xc5\xa1ymai {0} suk\xc5\xabr\xc4\x97'
+b'DocType: Restaurant Reservation',b'No of People',b'\xc5\xbdmoni\xc5\xb3 skai\xc4\x8dius'
+b'apps/erpnext/erpnext/config/selling.py +164',b'Template of terms or contract.',b'\xc5\xa0ablonas termin\xc5\xb3 ar sutarties.'
+b'DocType: Purchase Invoice',b'Address and Contact',b'Adresas ir kontaktai'
+b'DocType: Cheque Print Template',b'Is Account Payable',b'Ar s\xc4\x85skaita Mok\xc4\x97tinos sumos'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276',b'Stock cannot be updated against Purchase Receipt {0}',"b'Akcij\xc5\xb3, negali b\xc5\xabti atnaujintas prie\xc5\xa1 pirkimo kvito {0}'"
+b'DocType: Support Settings',b'Auto close Issue after 7 days',b'Auto arti i\xc5\xa1davimas po 7 dien\xc5\xb3'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71',"b'Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Palikite negali b\xc5\xabti skiriama iki {0}, kaip atostogos balansas jau perk\xc4\x97limo persiun\xc4\x8diami b\xc5\xabsimos atostogos paskirstymo \xc4\xafra\xc5\xa1o {1}'"
+b'apps/erpnext/erpnext/accounts/party.py +317',b'Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)',b'Pastaba: D\xc4\x97l / Nuoroda data vir\xc5\xa1ija leid\xc5\xbeiama klient\xc5\xb3 kredito dienas iki {0} dien\xc4\x85 (-ai)'
+b'apps/erpnext/erpnext/education/doctype/program/program.js +8',b'Student Applicant',b'Student\xc5\xb3 Parei\xc5\xa1k\xc4\x97jas'
+b'DocType: Purchase Invoice',b'ORIGINAL FOR RECIPIENT',b'Originalus GAV\xc4\x96JAS'
+b'DocType: Asset Category Account',b'Accumulated Depreciation Account',b'Sukauptas nusid\xc4\x97v\xc4\x97jimas paskyra'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11',b'This email is autogenerated',b'\xc5\xa0is el. Lai\xc5\xa1kas yra automati\xc5\xa1kai sukurtas'
+b'DocType: Stock Settings',b'Freeze Stock Entries',b'Freeze Akcij\xc5\xb3 \xc4\xafra\xc5\xa1ai'
+b'DocType: Program Enrollment',b'Boarding Student',b'internatin\xc4\x97 Student\xc5\xb3'
+b'DocType: Asset',b'Expected Value After Useful Life',b'Tikimasi Vert\xc4\x97 Po naudingo tarnavimo'
+b'DocType: Item',b'Reorder level based on Warehouse',b'Pertvarkyti lyg\xc4\xaf remiantis Warehouse'
+b'DocType: Activity Cost',b'Billing Rate',b'atsiskaitymo Balsuok'
+,b'Qty to Deliver',b'Kiekis pristatyti'
+,b'Stock Analytics',b'Akcij\xc5\xb3 Analytics &quot;'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523',b'Operations cannot be left blank',b'Operacijos negali b\xc5\xabti paliktas tu\xc5\xa1\xc4\x8dias'
+b'DocType: Maintenance Visit Purpose',b'Against Document Detail No',b'Su dokument\xc5\xb3 I\xc5\xa1samiau N\xc4\x97ra'
+b'apps/erpnext/erpnext/regional/__init__.py +11',b'Deletion is not permitted for country {0}',b'Pa\xc5\xa1alinti neleid\xc5\xbeiama \xc5\xa1aliai {0}'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110',b'Party Type is mandatory',b'\xc5\xa0alis tipas yra privalomi'
+b'DocType: Quality Inspection',b'Outgoing',b'i\xc5\xa1einantis'
+b'DocType: Material Request',b'Requested For',b'pra\xc5\xa1oma D\xc4\x97l'
+b'DocType: Quotation Item',b'Against Doctype',b'prie\xc5\xa1 DOCTYPE'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +404',b'{0} {1} is cancelled or closed',b'{0} {1} yra at\xc5\xa1auktas arba u\xc5\xbedarytas'
+b'DocType: Asset',b'Calculate Depreciation',b'Apskai\xc4\x8diuokite nusid\xc4\x97v\xc4\x97jim\xc4\x85'
+b'DocType: Delivery Note',b'Track this Delivery Note against any Project',b'Sekti \xc5\xa1i\xc4\x85 va\xc5\xbetara\xc5\xa1tyje prie\xc5\xa1 bet kok\xc4\xaf projekt\xc4\x85'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35',b'Net Cash from Investing',b'Grynieji pinig\xc5\xb3 srautai i\xc5\xa1 investicin\xc4\x97s'
+b'DocType: Work Order',b'Work-in-Progress Warehouse',b'Darbas-in-progress Warehouse'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111',b'Asset {0} must be submitted',b'Turto {0} turi b\xc5\xabti pateiktas'
+b'DocType: Fee Schedule Program',b'Total Students',b'I\xc5\xa1 viso student\xc5\xb3'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56',b'Attendance Record {0} exists against Student {1}',b'Lankomumas \xc4\xaera\xc5\xa1\xc5\xb3 {0} egzistuoja nuo Student\xc5\xb3 {1}'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354',b'Reference #{0} dated {1}',b'Nuoroda # {0} data {1}'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164',b'Depreciation Eliminated due to disposal of assets',b'Nusid\xc4\x97v\xc4\x97jimas Pa\xc5\xa1alintas d\xc4\x97l turto perleidimo'
+b'DocType: Member',b'Member',b'Narys'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15',b'Manage Addresses',b'tvarkyti adresai'
+b'DocType: Work Order Item',b'Work Order Item',b'Darbo u\xc5\xbesakymo elementas'
+b'DocType: Pricing Rule',b'Item Code',b'Prek\xc4\x97s kodas'
+b'DocType: Serial No',b'Warranty / AMC Details',b'Garantija / AMC detal\xc4\x97s'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',b'Pasirinkite studentai rankiniu veikla grind\xc5\xbeiamo grup\xc4\x97s'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',b'Pasirinkite studentai rankiniu veikla grind\xc5\xbeiamo grup\xc4\x97s'
+b'DocType: Journal Entry',b'User Remark',b'vartotojas Pastaba'
+b'DocType: Lead',b'Market Segment',b'Rinkos segmentas'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Manager',b'\xc5\xbdem\xc4\x97s \xc5\xabkio vadybininkas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966',b'Paid Amount cannot be greater than total negative outstanding amount {0}',b'Sumok\xc4\x97ta suma negali b\xc5\xabti didesn\xc4\x97 nei visos neigiamos nesumok\xc4\x97tos sumos {0}'
+b'DocType: Supplier Scorecard Period',b'Variables',b'Kintamieji'
+b'DocType: Employee Internal Work History',b'Employee Internal Work History',b'Darbuotoj\xc5\xb3 vidaus darbo Istorija'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249',b'Closing (Dr)',b'U\xc5\xbedarymo (dr)'
+b'DocType: Cheque Print Template',b'Cheque Size',b'Komunalin\xc4\x97s dydis'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232',b'Serial No {0} not in stock',b'Serijos Nr {0} n\xc4\x97ra sand\xc4\x97lyje'
+b'apps/erpnext/erpnext/config/selling.py +169',b'Tax template for selling transactions.',b'Mokes\xc4\x8di\xc5\xb3 \xc5\xa1ablonas pardavimo sandorius.'
+b'DocType: Sales Invoice',b'Write Off Outstanding Amount',b'Nura\xc5\xa1yti likutin\xc4\x99 sum\xc4\x85'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27',b'Account {0} does not match with Company {1}',b'S\xc4\x85skaita {0} nesutampa su kompanija {1}'
+b'DocType: Education Settings',b'Current Academic Year',b'Dabartinis akademiniai metai'
+b'DocType: Education Settings',b'Current Academic Year',b'Dabartinis akademiniai metai'
+b'DocType: Stock Settings',b'Default Stock UOM',b'Numatytasis sand\xc4\x97lyje UOM'
+b'DocType: Asset',b'Number of Depreciations Booked',b'U\xc5\xbesakytas skai\xc4\x8dius nuvertinimai'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +71',b'Qty Total',b'Kiekis I\xc5\xa1 viso'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32',b'Against Employee Loan: {0}',b'Prie\xc5\xa1 darbuotojo Loan: {0}'
+b'DocType: Landed Cost Item',b'Receipt Document',b'gavimas Dokument\xc5\xb3'
+b'DocType: Employee Education',b'School/University',b'Mokykla / Universitetas'
+b'DocType: Payment Request',b'Reference Details',b'nuoroda detal\xc4\x97s'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +56',b'Expected Value After Useful Life must be less than Gross Purchase Amount',b'Tikimasi Vert\xc4\x97 Po naudingo tarnavimo laik\xc4\x85 turi b\xc5\xabti ma\xc5\xbeesnis nei bendrojo pirkinio sumos'
+b'DocType: Sales Invoice Item',b'Available Qty at Warehouse',b'Turimas Kiekis \xc4\xaf sand\xc4\x97l\xc4\xaf'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Billed Amount',b'\xc4\xafvardintas suma'
+b'DocType: Share Transfer',b'(including)',b'(\xc4\xafskaitant)'
+b'DocType: Asset',b'Double Declining Balance',b'Dvivietis ma\xc5\xbe\xc4\x97jan\xc4\x8dio balanso'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180',b'Closed order cannot be cancelled. Unclose to cancel.',b'U\xc5\xbedaras nurodymas negali b\xc5\xabti at\xc5\xa1auktas. Atskleisti at\xc5\xa1aukti.'
+b'DocType: Student Guardian',b'Father',b't\xc4\x97vas'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +627',"b""'Update Stock' cannot be checked for fixed asset sale""","b'""Atnaujinti sand\xc4\x97l\xc4\xaf"" negali b\xc5\xabti patikrintas d\xc4\x97l ilgalaikio turto pardavimo.'"
+b'DocType: Bank Reconciliation',b'Bank Reconciliation',b'bankas suderinimas'
+b'DocType: Attendance',b'On Leave',b'atostogose'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7',b'Get Updates',b'Gaukite atnaujinimus'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96',b'{0} {1}: Account {2} does not belong to Company {3}',b'{0} {1}: S\xc4\x85skaitos {2} nepriklauso Company {3}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +397',b'Select at least one value from each of the attributes.',b'Pasirinkite bent vien\xc4\x85 vert\xc4\x99 i\xc5\xa1 kiekvieno atributo.'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166',b'Material Request {0} is cancelled or stopped',b'Med\xc5\xbeiaga Pra\xc5\xa1ymas {0} at\xc5\xa1auktas ar sustabdytas'
+b'apps/erpnext/erpnext/config/hr.py +314',b'Leave Management',b'Palikite valdymas'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +118',b'Group by Account',b'Grup\xc4\x97 s\xc4\x85skait\xc5\xb3'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21',b'Please select Employee',b'Pasirinkite darbuotoj\xc4\x85'
+b'DocType: Sales Order',b'Fully Delivered',b'pilnai Paskelbta'
+b'DocType: Lead',b'Lower Income',b'ma\xc5\xbeesnes pajamas'
+b'DocType: Restaurant Order Entry',b'Current Order',b'Dabartinis u\xc5\xbesakymas'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196',b'Source and target warehouse cannot be same for row {0}',b'Originalo ir vertimo sand\xc4\x97lis negali b\xc5\xabti vienodi eil\xc4\x97s {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243',"b'Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry'","b'Skirtumas paskyra turi b\xc5\xabti turto / \xc4\xafsipareigojim\xc5\xb3 tipo s\xc4\x85skaita, nes tai sand\xc4\x97lyje Susitaikymas yra atidarymas \xc4\xafra\xc5\xa1as'"
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107',b'Disbursed Amount cannot be greater than Loan Amount {0}',b'I\xc5\xa1mok\xc4\x97ta suma negali b\xc5\xabti didesnis nei paskolos suma {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +176',b'Go to Programs',b'Eikite \xc4\xaf &quot;Programos&quot;'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205',b'Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}',b'Eilut\xc4\x97 {0} # paskirstyta suma {1} negali b\xc5\xabti didesn\xc4\x97 nei nepageidaujama suma {2}'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89',b'Purchase Order number required for Item {0}',"b'Pirkimo u\xc5\xbesakymo numer\xc4\xaf, reikaling\xc4\x85 punkto {0}'"
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18',"b""'From Date' must be after 'To Date'""",b'&quot;Nuo data&quot; turi b\xc5\xabti po &quot;Iki datos&quot;'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39',b'Cannot change status as student {0} is linked with student application {1}',b'Nepavyksta pakeisti status\xc4\x85 kaip studentas {0} yra susij\xc4\x99s su studento taikymo {1}'
+b'DocType: Asset',b'Fully Depreciated',b'visi\xc5\xa1kai nusid\xc4\x97v\xc4\x97jusi'
+b'DocType: Item Barcode',b'UPC-A',b'UPC-A'
+,b'Stock Projected Qty',b'Akcij\xc5\xb3 Numatoma Kiekis'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444',b'Customer {0} does not belong to project {1}',b'Klient\xc5\xb3 {0} nepriklauso projekto {1}'
+b'DocType: Employee Attendance Tool',b'Marked Attendance HTML',b'Pa\xc5\xbeym\xc4\x97ti Lankomumas HTML'
+b'apps/erpnext/erpnext/utilities/activation.py +73',"b'Quotations are proposals, bids you have sent to your customers'","b'Citatos yra pasi\xc5\xablym\xc5\xb3, pasi\xc5\xablymai turite atsi\xc5\xb3sti savo klientams'"
+b'DocType: Sales Invoice',"b""Customer's Purchase Order""",b'Kliento U\xc5\xbesakymo'
+b'DocType: Consultation',b'Patient',b'Pacientas'
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47',b'Bypass credit check at Sales Order ',b'Atidaryti kredito patikr\xc4\x85 Pardavim\xc5\xb3 u\xc5\xbesakymas'
+b'DocType: Land Unit',b'Check if it is a hydroponic unit',"b'Patikrinkite, ar tai hidroponinis blokas'"
+b'apps/erpnext/erpnext/config/stock.py +109',b'Serial No and Batch',b'Serijos Nr paketais'
+b'DocType: Warranty Claim',b'From Company',b'i\xc5\xa1 Company'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52',b'Sum of Scores of Assessment Criteria needs to be {0}.',b'Suma balais vertinimo kriterijai turi b\xc5\xabti {0}.'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +77',b'Please set Number of Depreciations Booked',b'Pra\xc5\xa1ome nustatyti Ta\xc5\xa1k\xc5\xb3 nuvertinimai U\xc5\xbesakytas'
+b'DocType: Supplier Scorecard Period',b'Calculations',b'Skai\xc4\x8diavimai'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86',b'Value or Qty',b'Vert\xc4\x97 arba Kiekis'
+b'DocType: Payment Terms Template',b'Payment Terms',b'Mok\xc4\x97jimo s\xc4\x85lygos'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449',b'Productions Orders cannot be raised for:',b'Productions pavedimai negali b\xc5\xabti padidinta:'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Minute',b'Minut\xc4\x97'
+b'DocType: Purchase Invoice',b'Purchase Taxes and Charges',b'Pirkimo mokes\xc4\x8dius bei rinkliavas'
+b'DocType: Chapter',b'Meetup Embed HTML',b'&quot;Embedup&quot; HTML \xc4\xafvestis'
+b'apps/erpnext/erpnext/utilities/user_progress.py +121',b'Go to Suppliers',b'Eikite \xc4\xaf tiek\xc4\x97jus'
+,b'Qty to Receive',b'Kiekis Gavimo'
+b'DocType: Leave Block List',b'Leave Block List Allowed',b'Palikite Blokuoti s\xc4\x85ra\xc5\xa1as Leido'
+b'DocType: Grading Scale Interval',b'Grading Scale Interval',b'R\xc5\xab\xc5\xa1iavimas padalos'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49',b'Expense Claim for Vehicle Log {0}',b'Kompensuojamos Pra\xc5\xa1ymas Transporto Prisijungti {0}'
+b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Nuolaida (%) nuo Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as norma atsargos'
+b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Nuolaida (%) nuo Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as norma atsargos'
+b'apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59',b'All Warehouses',b'Visi Sand\xc4\x97liai'
+b'DocType: Sales Partner',b'Retailer',b'ma\xc5\xbemenininkas'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115',b'Credit To account must be a Balance Sheet account',b'Kreditas s\xc4\x85skaitos turi b\xc5\xabti balansas s\xc4\x85skaitos'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118',b'All Supplier Types',b'Visi Tiek\xc4\x97jo tipai'
+b'DocType: Donor',b'Donor',b'Donoras'
+b'DocType: Global Defaults',b'Disable In Words',b'I\xc5\xa1jungti \xc5\xbeod\xc5\xbeiais'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +60',b'Item Code is mandatory because Item is not automatically numbered',"b'Prek\xc4\x97s kodas yra privalomas, nes prek\xc4\x97s n\xc4\x97ra automati\xc5\xa1kai sunumeruoti'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98',b'Quotation {0} not of type {1}',b'Citata {0} n\xc4\x97ra tipo {1}'
+b'DocType: Maintenance Schedule Item',b'Maintenance Schedule Item',b'Prie\xc5\xbei\xc5\xabra Tvarkara\xc5\xa1tis punktas'
+b'DocType: Sales Order',b'%  Delivered',b'% Pristatyta'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.js +105',b'Please set the Email ID for the Student to send the Payment Request',"b'Nustatykite studento elektroninio pa\xc5\xa1to adres\xc4\x85, kad atsi\xc5\xb3stum\xc4\x97te mok\xc4\x97jimo u\xc5\xbeklaus\xc4\x85'"
+b'DocType: Patient',b'Medical History',b'Medicinos istorija'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157',b'Bank Overdraft Account',b'Bankas Overdraftas paskyra'
+b'DocType: Patient',b'Patient ID',b'Paciento ID'
+b'DocType: Physician Schedule',b'Schedule Name',b'Tvarkara\xc5\xa1\xc4\x8dio pavadinimas'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48',b'Make Salary Slip',b'Padaryti darbo u\xc5\xbemokest\xc4\xaf'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840',b'Add All Suppliers',b'Prid\xc4\x97ti visus tiek\xc4\x97jus'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94',b'Row #{0}: Allocated Amount cannot be greater than outstanding amount.',b'Eilut\xc4\x97 # {0}: Paskirstytas suma gali b\xc5\xabti ne didesnis nei likutin\xc4\x99 sum\xc4\x85.'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75',b'Browse BOM',b'\xc5\xbdmon\xc4\x97s BOM'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155',b'Secured Loans',b'u\xc5\xbetikrintos paskolos'
+b'DocType: Purchase Invoice',b'Edit Posting Date and Time',b'Redaguoti Siun\xc4\x8diamos data ir laikas'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101',b'Please set Depreciation related Accounts in Asset Category {0} or Company {1}',b'Pra\xc5\xa1ome nustatyti Nusid\xc4\x97v\xc4\x97jimas susijusias s\xc4\x85skaitas Turto kategorija {0} ar kompanija {1}'
+b'DocType: Lab Test Groups',b'Normal Range',b'Normalus diapazonas'
+b'DocType: Academic Term',b'Academic Year',b'Mokslo metai'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Available Selling',b'Galima parduoti'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169',b'Opening Balance Equity',b'Atidarymas Balansas Akcij\xc5\xb3'
+b'DocType: Lead',b'CRM',b'CRM'
+b'DocType: Purchase Invoice',b'N',b'N'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175',b'Remaining',b'lik\xc4\x99s'
+b'DocType: Appraisal',b'Appraisal',b'\xc4\xafvertinimas'
+b'DocType: Purchase Invoice',b'GST Details',b'GST duomenys'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156',b'Email sent to supplier {0}',b'Pa\xc5\xa1tas i\xc5\xa1si\xc5\xb3stas tiek\xc4\x97jo {0}'
+b'DocType: Item',b'Default Sales Unit of Measure',b'Numatytasis pardavim\xc5\xb3 matavimo vienetas'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9',b'Academic Year: ',b'Mokslo metai:'
+b'DocType: Opportunity',b'OPTY-',b'OPTY-'
+b'apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19',b'Date is repeated',b'Data kartojamas'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27',b'Authorized Signatory',b'\xc4\xaegaliotas signataras'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64',b'Create Fees',b'Sukurkite mokes\xc4\x8dius'
+b'DocType: Project',b'Total Purchase Cost (via Purchase Invoice)',b'Viso \xc4\xafsigijimo savikain\xc4\x85 (per pirkimo s\xc4\x85skaitoje fakt\xc5\xabroje)'
+b'DocType: Training Event',b'Start Time',b'Prad\xc5\xbeios laikas'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400',b'Select Quantity',b'Pasirinkite Kiekis'
+b'DocType: Customs Tariff Number',b'Customs Tariff Number',b'Muit\xc5\xb3 tarifo numeris'
+b'DocType: Patient Appointment',b'Patient Appointment',b'Paciento paskyrimas'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34',b'Approving Role cannot be same as role the rule is Applicable To',b'Patvirtinimo vaidmuo gali b\xc5\xabti ne tas pats kaip vaidmens taisykl\xc4\x97 yra taikoma'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64',b'Unsubscribe from this Email Digest',b'Atsisakyti \xc5\xa0is el.pa\xc5\xa1to Digest'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830',b'Get Suppliers By',b'Gaukite tiek\xc4\x97j\xc5\xb3'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173',b'{0} not found for Item {1}',b'{0} nerasta {1} elementui'
+b'apps/erpnext/erpnext/utilities/user_progress.py +197',b'Go to Courses',b'Eikite \xc4\xaf kursus'
+b'DocType: Accounts Settings',b'Show Inclusive Tax In Print',b'Rodyti inkliuzin\xc4\xaf mokest\xc4\xaf spausdinant'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17',"b'Bank Account, From Date and To Date are Mandatory'",b'Banko s\xc4\x85skaita nuo datos iki datos yra privaloma'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28',b'Message Sent',b'\xc5\xbdinut\xc4\x97 i\xc5\xa1si\xc5\xb3sta'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +98',b'Account with child nodes cannot be set as ledger',b'S\xc4\x85skaita su vaik\xc5\xb3 mazg\xc5\xb3 negali b\xc5\xabti nustatyti kaip knygoje'
+b'DocType: C-Form',b'II',b'II'
+b'DocType: Sales Invoice',"b""Rate at which Price list currency is converted to customer's base currency""","b'Norma, pagal kuri\xc4\x85 Kainora\xc5\xa1tis valiuta konvertuojama \xc4\xaf kliento bazine valiuta'"
+b'DocType: Purchase Invoice Item',b'Net Amount (Company Currency)',b'Grynasis kiekis (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Physician',b'Physician Schedules',b'Gydytojo tvarkara\xc5\xa1\xc4\x8diai'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215',b'Total advance amount cannot be greater than total sanctioned amount',b'Bendra avanso suma negali b\xc5\xabti didesn\xc4\x97 u\xc5\xbe vis\xc4\x85 sankcionuot\xc4\x85 sum\xc4\x85'
+b'DocType: Salary Slip',b'Hour Rate',b'valand\xc4\x85 grei\xc4\x8diu'
+b'DocType: Stock Settings',b'Item Naming By',b'Prek\xc4\x97 Pavadinim\xc5\xb3 Iki'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46',b'Another Period Closing Entry {0} has been made after {1}',b'Kitas Laikotarpis u\xc5\xbedarymas \xc4\xae\xc4\x97jimas {0} buvo padaryta po {1}'
+b'DocType: Work Order',b'Material Transferred for Manufacturing',"b'Med\xc5\xbeiagos, perduotos gamybos'"
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41',b'Account {0} does not exists',b'S\xc4\x85skaita {0} neegzistuoja'
+b'DocType: Project',b'Project Type',b'projekto tipas'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +153',b'Child Task exists for this Task. You can not delete this Task.',b'\xc5\xa0i u\xc5\xbeduotis yra vaiko u\xc5\xbeduotis. Negalite i\xc5\xa1trinti \xc5\xa1ios u\xc5\xbeduotys.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'DateLet',b'DateLet'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16',b'Either target qty or target amount is mandatory.',b'Bet tikslas Kiekis arba planuojama suma yra privalomas.'
+b'apps/erpnext/erpnext/config/projects.py +56',b'Cost of various activities',b'I\xc5\xa1laidos \xc4\xafvairiose veiklos'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60',"b'Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}'","b'Nustatymas \xc4\xafvyki\xc5\xb3 {0}, nes pridedamas prie \xc5\xbeemiau pardav\xc4\x97jai darbuotojas neturi naudotojo ID {1}'"
+b'DocType: Timesheet',b'Billing Details',b'Atsiskaitymo informacija'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163',b'Source and target warehouse must be different',b'Originalo ir vertimo sand\xc4\x97lis turi skirtis'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140',b'Payment Failed. Please check your GoCardless Account for more details',"b'Mok\xc4\x97jimas nepavyko. Pra\xc5\xa1ome patikrinti savo &quot;GoCardless&quot; s\xc4\x85skait\xc4\x85, kad gautum\xc4\x97te daugiau informacijos'"
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101',b'Not allowed to update stock transactions older than {0}',b'Neleid\xc5\xbeiama atnaujinti akcij\xc5\xb3 sandorius senesnis nei {0}'
+b'DocType: BOM',b'Inspection Required',b'Patikrinimo Reikalinga'
+b'DocType: Purchase Invoice Item',b'PR Detail',b'PR detal\xc4\x97s'
+b'DocType: Driving License Category',b'Class',b'Klas\xc4\x97'
+b'DocType: Sales Order',b'Fully Billed',b'pilnai \xc4\xaevardintas'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426',b'Work Order cannot be raised against a Item Template',b'Darb\xc5\xb3 u\xc5\xbesakymas negali b\xc5\xabti i\xc5\xa1keltas prie\xc5\xa1 elemento \xc5\xa1ablon\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101',b'Shipping rule only applicable for Buying',b'Pristatymo taisykl\xc4\x97 taikoma tik pirkimui'
+b'DocType: Vital Signs',b'BMI',b'KMI'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20',b'Cash In Hand',b'Grynieji pinigai kasoje'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137',b'Delivery warehouse required for stock item {0}',b'Pristatymas sand\xc4\x97lis reikalingas akcij\xc5\xb3 punkte {0}'
+b'DocType: Packing Slip',b'The gross weight of the package. Usually net weight + packaging material weight. (for print)',b'Bendras svoris pakuot\xc4\x97s. Paprastai neto mas\xc4\x97 + pakavimo med\xc5\xbeiagos svorio. (Spausdinimo)'
+b'DocType: Assessment Plan',b'Program',b'programa'
+b'DocType: Accounts Settings',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts',"b'Vartotojai, turintys \xc5\xa1\xc4\xaf vaidmen\xc4\xaf yra leid\xc5\xbeiama nustatyti \xc4\xaf\xc5\xa1aldytas s\xc4\x85skaitas ir sukurti / pakeisti apskaitos \xc4\xafra\xc5\xa1us prie\xc5\xa1 \xc4\xaf\xc5\xa1aldyt\xc5\xb3 s\xc4\x85skait\xc5\xb3'"
+b'DocType: Serial No',b'Is Cancelled',b'Ar at\xc5\xa1auktas'
+b'DocType: Student Group',b'Group Based On',b'Grup\xc4\x97 remiantis'
+b'DocType: Student Group',b'Group Based On',b'Grup\xc4\x97 remiantis'
+b'DocType: Journal Entry',b'Bill Date',b'Billas data'
+b'DocType: Healthcare Settings',b'Laboratory SMS Alerts',b'Laboratoriniai SMS persp\xc4\x97jimai'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20',"b'Service Item,Type,frequency and expense amount are required'","b'Paslaug\xc5\xb3 Punktas, tipas, da\xc5\xbenis ir i\xc5\xa1laid\xc5\xb3 suma yra privalomi'"
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45',"b'Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:'","b'Net jei yra keli kainodaros taisykl\xc4\x97s, kuri\xc5\xb3 did\xc5\xbeiausias prioritetas, tada \xc5\xa1ie vidiniai prioritetai taikomi:'"
+b'DocType: Plant Analysis Criteria',b'Plant Analysis Criteria',b'Augal\xc5\xb3 analiz\xc4\x97s kriterijai'
+b'DocType: Cheque Print Template',b'Cheque Height',b'Komunalin\xc4\x97s \xc5\xaagis'
+b'DocType: Supplier',b'Supplier Details',b'Tiek\xc4\x97jo informacija'
+b'DocType: Setup Progress',b'Setup Progress',b'&quot;Progress setup&quot;'
+b'DocType: Hub Settings',b'Publish Items to Hub',b'Publikuoti prek\xc4\x99 \xc4\xaf Hub'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35',b'From value must be less than to value in row {0}',b'Nuo vert\xc4\x97 turi b\xc5\xabti ma\xc5\xbeesn\xc4\x97 nei vert\xc4\x97s eil\xc4\x97s {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182',b'Wire Transfer',b'pavedimu'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92',b'Check all',b'Visk\xc4\x85 Patikrink'
+,b'Issued Items Against Work Order',b'I\xc5\xa1leisti daiktai prie\xc5\xa1 darbo tvark\xc4\x85'
+b'DocType: Vehicle Log',b'Invoice Ref',b'S\xc4\x85skaitos fakt\xc5\xabros Nuoroda'
+b'DocType: Company',b'Default Income Account',b'Numatytasis pajam\xc5\xb3 s\xc4\x85skaita'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32',b'Customer Group / Customer',b'Klient\xc5\xb3 grup\xc4\x97 / Klient\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37',b'Unclosed Fiscal Years Profit / Loss (Credit)',b'Neu\xc5\xbedara fiskalini\xc5\xb3 met\xc5\xb3 pelnas / nuostolis (kreditas)'
+b'DocType: Sales Invoice',b'Time Sheets',b'darbo laiko apskaitos \xc5\xbeiniara\xc5\xa1\xc4\x8diai'
+b'DocType: Lab Test Template',b'Change In Item',b'Pakeisti prek\xc4\x99'
+b'DocType: Payment Gateway Account',b'Default Payment Request Message',b'Numatyt\xc4\x85j\xc4\xaf mok\xc4\x97jimo pra\xc5\xa1ymas prane\xc5\xa1imas'
+b'DocType: Item Group',b'Check this if you want to show in website',"b'Pa\xc5\xbeym\xc4\x97kite, jei norite parodyti svetain\xc4\x97je'"
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338',b'Balance ({0})',b'Balansas ({0})'
+b'apps/erpnext/erpnext/config/accounts.py +134',b'Banking and Payments',b'Bankininkyst\xc4\x97 ir mok\xc4\x97jimai'
+,b'Welcome to ERPNext',b'Sveiki atvyk\xc4\x99 \xc4\xaf ERPNext'
+b'apps/erpnext/erpnext/config/learn.py +102',b'Lead to Quotation',b'\xc5\xa0vinas su citavimo'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34',b'Email Reminders will be sent to all parties with email contacts',b'Priminimai el. Pa\xc5\xa1tu bus i\xc5\xa1si\xc5\xb3sti visoms \xc5\xa1alims elektroniniu pa\xc5\xa1tu'
+b'DocType: Project',b'Twice Daily',b'Du kartus per par\xc4\x85'
+b'DocType: Patient',b'A Negative',b'Neigiamas'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +45',b'Nothing more to show.',b'Nieko daugiau parodyti.'
+b'DocType: Lead',b'From Customer',b'nuo Klientui'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +327',b'Calls',b'ragina'
+b'apps/erpnext/erpnext/utilities/user_progress.py +143',b'A Product',b'Produktas'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207',b'Batches',b'partijos'
+b'apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34',b'Make Fee Schedule',b'Padaryti mokest\xc4\xaf'
+b'DocType: Purchase Order Item Supplied',b'Stock UOM',b'akcij\xc5\xb3 UOM'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233',b'Purchase Order {0} is not submitted',b'Pirkimui u\xc5\xbesakyti {0} nebus pateiktas'
+b'DocType: Vital Signs',b'Normal reference range for an adult is 16\xe2\x80\x9320 breaths/minute (RCP 2012)',b'Suaugusioji normali referencin\xc4\x97 diapazona yra 16-20 kv\xc4\x97pavimo tak\xc5\xb3 per minut\xc4\x99 (RCP 2012)'
+b'DocType: Customs Tariff Number',b'Tariff Number',b'tarifas Ta\xc5\xa1k\xc5\xb3'
+b'DocType: Work Order Item',b'Available Qty at WIP Warehouse',b'Turimas Kiekis ne WIP Warehouse'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +39',b'Projected',b'prognozuojama'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222',b'Serial No {0} does not belong to Warehouse {1}',b'Serijos Nr {0} nepriklauso sand\xc4\x97lis {1}'
+b'apps/erpnext/erpnext/controllers/status_updater.py +177',b'Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0',b'Pastaba: sistema netikrins per pristatym\xc4\x85 ir per metu u\xc5\xbe prek\xc4\x99 {0} kaip kiekis ar visa suma yra 0'
+b'DocType: Notification Control',b'Quotation Message',b'citata prane\xc5\xa1imas'
+b'DocType: Employee Loan',b'Employee Loan Application',b'Darbuotoj\xc5\xb3 parai\xc5\xa1k\xc4\x85 paskolai gauti'
+b'DocType: Issue',b'Opening Date',b'atidarymo data'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86',b'Please save the patient first',b'Pirmiausia i\xc5\xa1saugokite pacient\xc4\x85'
+b'apps/erpnext/erpnext/education/api.py +80',b'Attendance has been marked successfully.',b'\xc5\xbdi\xc5\xabrov\xc5\xb3 buvo pa\xc5\xbeym\xc4\x97ta s\xc4\x97kmingai.'
+b'DocType: Program Enrollment',b'Public Transport',b'Vie\xc5\xa1asis transportas'
+b'DocType: Soil Texture',b'Silt Composition (%)',b'Stiklo sud\xc4\x97tis (%)'
+b'DocType: Journal Entry',b'Remark',b'pastaba'
+b'DocType: Healthcare Settings',b'Avoid Confirmation',b'Venkite patvirtinimo'
+b'DocType: Purchase Receipt Item',b'Rate and Amount',b'Norma ir dydis'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176',b'Account Type for {0} must be {1}',"b'S\xc4\x85skaitos tipas {0}, turi b\xc5\xabti {1}'"
+b'DocType: Healthcare Settings',b'Default income accounts to be used if not set in Physician to book Consultation charges.',"b'Numatytoji pajam\xc5\xb3 s\xc4\x85skaita, kuri turi b\xc5\xabti naudojama, jei nenustatyta Gydytojas, nor\xc4\x97damas u\xc5\xbesisakyti konsultacij\xc5\xb3 mokes\xc4\x8dius.'"
+b'apps/erpnext/erpnext/config/hr.py +55',b'Leaves and Holiday',b'Lapai ir poilsis'
+b'DocType: Education Settings',b'Current Academic Term',b'Dabartinis akademin\xc4\x97s terminas'
+b'DocType: Education Settings',b'Current Academic Term',b'Dabartinis akademin\xc4\x97s terminas'
+b'DocType: Sales Order',b'Not Billed',b'ne \xc4\xaevardintas'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76',b'Both Warehouse must belong to same Company',b'Tiek Sand\xc4\x97lis turi priklausyti pati bendrov\xc4\x97'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +34',b'No contacts added yet.',b'prid\xc4\x97jo dar neturi kontaktai.'
+b'DocType: Purchase Invoice Item',b'Landed Cost Voucher Amount',b'Nusileido kaina kupono suma'
+,b'Item Balance (Simple)',b'Prek\xc4\x97s balansas (paprastas)'
+b'apps/erpnext/erpnext/config/accounts.py +17',b'Bills raised by Suppliers.',b'Vekseliai i\xc5\xa1kelti tiek\xc4\x97j\xc5\xb3.'
+b'DocType: POS Profile',b'Write Off Account',b'Nura\xc5\xa1yti paskyr\xc4\x85'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Debit Note Amt',b'Debeto aviza Amt'
+b'apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5',b'Discount Amount',b'Nuolaida suma'
+b'DocType: Purchase Invoice',b'Return Against Purchase Invoice',b'Gr\xc4\xaf\xc5\xbeti Against pirkimo fakt\xc5\xabros'
+b'DocType: Item',b'Warranty Period (in days)',b'Garantinis laikotarpis (dienomis)'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61',b'Failed to set defaults',b'Nepavyko nustatyti numatytuosius nustatymus'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56',b'Relation with Guardian1',b'Ry\xc5\xa1ys su Guardian1'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +786',b'Please select BOM against item {0}',b'Pasirinkite BOM d\xc4\x97l elemento {0}'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18',b'Make Invoices',b'Padaryti s\xc4\x85skaitas fakt\xc5\xabras'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23',b'Net Cash from Operations',b'Grynieji pinig\xc5\xb3 srautai i\xc5\xa1 \xc4\xafprastin\xc4\x97s veiklos'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26',b'Item 4',b'4 punktas'
+b'DocType: Student Admission',b'Admission End Date',b'Pri\xc4\x97mimo Pabaigos data'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30',b'Sub-contracting',b'Subrangovai'
+b'DocType: Journal Entry Account',b'Journal Entry Account',b'Leidinys sumok\xc4\x97jimas'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3',b'Student Group',b'Student\xc5\xb3 grup\xc4\x97'
+b'DocType: Shopping Cart Settings',b'Quotation Series',b'citata serija'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57',"b'An item exists with same name ({0}), please change the item group name or rename the item'","b'Elementas egzistuoja to paties pavadinimo ({0}), pra\xc5\xa1ome pakeisti element\xc4\x85 grup\xc4\x97s pavadinim\xc4\x85 ar pervardyti element\xc4\x85'"
+b'DocType: Soil Analysis Criteria',b'Soil Analysis Criteria',b'Dirvo\xc5\xbeemio analiz\xc4\x97s kriterijai'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2041',b'Please select customer',b'Pra\xc5\xa1ome pasirinkti klientui'
+b'DocType: C-Form',b'I',b'a\xc5\xa1'
+b'DocType: Company',b'Asset Depreciation Cost Center',b'Turto nusid\xc4\x97v\xc4\x97jimo i\xc5\xa1laidos centras'
+b'DocType: Production Plan Sales Order',b'Sales Order Date',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 data'
+b'DocType: Sales Invoice Item',b'Delivered Qty',b'Paskelbta Kiekis'
+b'DocType: Assessment Plan',b'Assessment Plan',b'vertinimo planas'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90',b'Customer {0} is created.',b'Klientas {0} sukurtas.'
+b'DocType: Stock Settings',b'Limit Percent',b'riba procentais'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82',b' Currently no stock available in any warehouse',b'\xc5\xa0iuo metu n\xc4\x97ra nei viename sand\xc4\x97lyje.'
+,b'Payment Period Based On Invoice Date',b'Mok\xc4\x97jimo periodas remiantis s\xc4\x85skaitos fakt\xc5\xabros i\xc5\xa1ra\xc5\xa1ymo data'
+b'DocType: Sample Collection',b'No. of print',b'Spaudos numeris'
+b'DocType: Hotel Room Reservation Item',b'Hotel Room Reservation Item',b'Vie\xc5\xa1bu\xc4\x8dio kambario rezervavimo punktas'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58',b'Missing Currency Exchange Rates for {0}',b'Tr\xc5\xabksta Valiut\xc5\xb3 kursai u\xc5\xbe {0}'
+b'DocType: Health Insurance',b'Health Insurance Name',b'Sveikatos draudimo pavadinimas'
+b'DocType: Assessment Plan',b'Examiner',b'egzaminuotojas'
+b'DocType: Student',b'Siblings',b'broliai ir seserys'
+b'DocType: Journal Entry',b'Stock Entry',"b'atsarg\xc5\xb3,'"
+b'DocType: Payment Entry',b'Payment References',b'Apmok\xc4\x97jimo Nuorodos'
+b'DocType: C-Form',b'C-FORM-',"b', C-FORM-'"
+b'DocType: Vehicle',b'Insurance Details',b'draudimo detal\xc4\x97s'
+b'DocType: Account',b'Payable',b'mok\xc4\x97tinas'
+b'DocType: Share Balance',b'Share Type',b'Bendrinti tip\xc4\x85'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113',b'Please enter Repayment Periods',b'Pra\xc5\xa1ome \xc4\xafvesti gr\xc4\x85\xc5\xbeinimo terminams'
+b'apps/erpnext/erpnext/shopping_cart/cart.py +378',b'Debtors ({0})',b'Skolininkai ({0})'
+b'DocType: Pricing Rule',b'Margin',b'mar\xc5\xbea'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57',b'New Customers',b'Nauji klientai'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74',b'Gross Profit %',b'Bendrasis pelnas %'
+b'DocType: Appraisal Goal',b'Weightage (%)',b'Weightage (%)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +503',b'Change POS Profile',b'Keisti POS profil\xc4\xaf'
+b'DocType: Bank Reconciliation Detail',b'Clearance Date',b'S\xc4\x85skait\xc5\xb3 data'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7',b'Assessment Report',b'Vertinimo ataskaita'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +59',b'Gross Purchase Amount is mandatory',b'Pilna Pirkimo suma yra privalomi'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +95',b'Company name not same',b'\xc4\xaemon\xc4\x97s pavadinimas n\xc4\x97ra tas pats'
+b'DocType: Lead',b'Address Desc',b'Adresas desc'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113',b'Party is mandatory',b'\xc5\xa0alis yra privalomi'
+b'DocType: Journal Entry',b'JV-',b'JV-'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +712',b'Rows with duplicate due dates in other rows were found: {list}',b'Rastos su dviem egzemplioriais nurodyt\xc5\xb3 dat\xc5\xb3 kitose eilut\xc4\x97se buvo rasta: {list}'
+b'DocType: Topic',b'Topic Name',b'Temos pavadinimas'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37',b'Atleast one of the Selling or Buying must be selected',"b'Atleast vienas, pardavimas arba pirkimas turi b\xc5\xabti parenkamas'"
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290',b'Select an employee to get the employee advance.',"b'Pasirinkite darbuotoj\xc4\x85, kad darbuotojas gaut\xc5\xb3 anks\xc4\x8diau.'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56',b'Please select a valid Date',b'Pasirinkite teising\xc4\x85 dat\xc4\x85'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +36',b'Select the nature of your business.',b'Pasirinkite savo verslo pob\xc5\xabd\xc4\xaf.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +24',b'Please setup Employee Naming System in Human Resource &gt; HR Settings',b'Pra\xc5\xa1ome nustatyti darbuotoj\xc5\xb3 pavadinimo sistem\xc4\x85 \xc5\xbemogi\xc5\xa1k\xc5\xb3j\xc5\xb3 i\xc5\xa1tekli\xc5\xb3&gt; HR nustatymai'
+b'DocType: Lab Test Template',"b'Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.'","b'Vienintelis rezultatams, kuriems reikalingas tik vienas \xc4\xafvestis, rezultatas UOM ir normalioji vert\xc4\x97 <br> Sud\xc4\x97tis, skirta rezultatams, kuriems reikalingi keli \xc4\xafvesties laukai su atitinkamais \xc4\xafvyki\xc5\xb3 pavadinimais, rezultat\xc5\xb3 UOM ir normaliomis vert\xc4\x97mis <br> Apra\xc5\xa1omi bandymai, turintys kelet\xc4\x85 rezultat\xc5\xb3 sudedam\xc5\xb3j\xc5\xb3 dali\xc5\xb3 ir atitinkam\xc5\xb3 rezultat\xc5\xb3 \xc4\xafra\xc5\xa1ymo lauk\xc5\xb3. <br> Grupuojami bandymo \xc5\xa1ablonai, kurie yra kit\xc5\xb3 bandym\xc5\xb3 \xc5\xa1ablon\xc5\xb3 grup\xc4\x97. <br> Rezultat\xc5\xb3 n\xc4\x97ra, nes rezultat\xc5\xb3 n\xc4\x97ra. Be to, n\xc4\x97ra sukurtas laboratorinis testas. pvz. Sub-bandymai grupuotiems rezultatams.'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86',b'Row #{0}: Duplicate entry in References {1} {2}',b'Eilut\xc4\x97 # {0}: pasikartojantis \xc4\xafra\xc5\xa1as nuorodose {1} {2}'
+b'apps/erpnext/erpnext/config/manufacturing.py +57',b'Where manufacturing operations are carried.',b'Kur gamybos operacijos atliekamos.'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18',b'As Examiner',b'Kaip egzaminuotojas'
+b'DocType: Appointment Type',b'Default Duration',b'Numatytoji trukm\xc4\x97'
+b'DocType: Asset Movement',b'Source Warehouse',b'\xc5\xa1altinis sand\xc4\x97lis'
+b'DocType: Installation Note',b'Installation Date',b'\xc4\xaerengimas data'
+b'apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30',b'Share Ledger',b'Dalinkis &quot;Ledger&quot;'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +606',b'Row #{0}: Asset {1} does not belong to company {2}',b'Eilut\xc4\x97s # {0}: Turto {1} nepriklauso bendrovei {2}'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206',b'Sales Invoice {0} created',b'Sukurta pardavimo s\xc4\x85skait\xc4\x85 {0}'
+b'DocType: Employee',b'Confirmation Date',b'Patvirtinimas data'
+b'DocType: C-Form',b'Total Invoiced Amount',b'I\xc5\xa1 viso S\xc4\x85skaitoje suma'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50',b'Min Qty can not be greater than Max Qty',b'Min Kiekis negali b\xc5\xabti didesnis nei Max Kiekis'
+b'DocType: Soil Texture',b'Silty Clay',b'\xc5\xa0ilkinis molis'
+b'DocType: Account',b'Accumulated Depreciation',b'sukauptas nusid\xc4\x97v\xc4\x97jimas'
+b'DocType: Supplier Scorecard Scoring Standing',b'Standing Name',b'Nuolatinis vardas'
+b'DocType: Stock Entry',b'Customer or Supplier Details',b'Klientas ar tiek\xc4\x97jas detal\xc4\x97s'
+b'DocType: Employee Loan Application',b'Required by Date',b'Reikalauja data'
+b'DocType: Lead',b'Lead Owner',b'\xc5\xa0vinas autorius'
+b'DocType: Production Plan',b'Sales Orders Detail',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 detal\xc4\x97s'
+b'DocType: Bin',b'Requested Quantity',b'pra\xc5\xa1omam kiekiui'
+b'DocType: Patient',b'Marital Status',b'\xc5\xa0eimynin\xc4\x97 pad\xc4\x97tis'
+b'DocType: Stock Settings',b'Auto Material Request',b'Auto Med\xc5\xbeiaga Pra\xc5\xa1ymas'
+b'DocType: Delivery Note Item',b'Available Batch Qty at From Warehouse',b'Turimas Serija Kiekis ne i\xc5\xa1 sand\xc4\x97lio'
+b'DocType: Customer',b'CUST-',b'CUST-'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Idevise',b'Idevise'
+b'DocType: Salary Slip',b'Gross Pay - Total Deduction - Loan Repayment',b'Pilna darbo u\xc5\xbemokestis - I\xc5\xa1 viso i\xc5\xa1skai\xc4\x8diavimas - Paskol\xc5\xb3 gr\xc4\x85\xc5\xbeinimas'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29',b'Current BOM and New BOM can not be same',b'Dabartinis BOM ir Naujoji BOM negali b\xc5\xabti tas pats'
+b'apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47',b'Salary Slip ID',b'Pajamos Kuponas ID'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +118',b'Date Of Retirement must be greater than Date of Joining',b'Data nuo i\xc5\xa1\xc4\x97jimo \xc4\xaf pensij\xc4\x85 turi b\xc5\xabti didesnis nei \xc4\xafstoti data'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +68',b'Multiple Variants',b'Keli variantai'
+b'DocType: Sales Invoice',b'Against Income Account',b'Prie\xc5\xa1 pajam\xc5\xb3 s\xc4\x85skaita'
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +117',b'{0}% Delivered',b'{0}% Pristatyta'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107',b'Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).',b'Prek\xc4\x97 {0}: U\xc5\xbesakytas Kiekis {1} negali b\xc5\xabti ma\xc5\xbeesnis nei minimalus u\xc5\xbesakymo Kiekis {2} (apibr\xc4\x97\xc5\xbet\xc4\x85 punktas).'
+b'DocType: Monthly Distribution Percentage',b'Monthly Distribution Percentage',b'M\xc4\x97nesio pasiskirstymas procentais'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49',b'Please login as another user.',b'Pra\xc5\xa1au prisijungti kaip kitas vartotojas.'
+b'DocType: Daily Work Summary Group User',b'Daily Work Summary Group User',b'Dienos darbo santraukos grup\xc4\x97s naudotojas'
+b'DocType: Territory',b'Territory Targets',b'Teritorija tikslai'
+b'DocType: Soil Analysis',b'Ca/Mg',b'Ca / Mg'
+b'DocType: Delivery Note',b'Transporter Info',b'transporteris Informacija'
+b'apps/erpnext/erpnext/accounts/utils.py +502',b'Please set default {0} in Company {1}',b'Pra\xc5\xa1ome nustatyti numatyt\xc4\x85j\xc4\xaf {0} \xc4\xafmon\xc4\x97je {1}'
+b'DocType: Cheque Print Template',b'Starting position from top edge',b'Pradin\xc4\x97 pad\xc4\x97tis nuo vir\xc5\xa1aus'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33',b'Same supplier has been entered multiple times',b'Tas pats tiek\xc4\x97jas buvo \xc4\xafra\xc5\xa1ytas kelis kartus'
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152',b'Gross Profit / Loss',b'Bendrasis pelnas / nuostolis'
+,b'Warehouse wise Item Balance Age and Value',b'Sand\xc4\x97lis protingas Prek\xc4\x97s balansas Am\xc5\xbeius ir vert\xc4\x97'
+b'DocType: Purchase Order Item Supplied',b'Purchase Order Item Supplied',b'Pirkimui u\xc5\xbesakyti punktas Pateikiamas'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +94',b'Company Name cannot be Company',b'\xc4\xaemon\xc4\x97s pavadinimas negali b\xc5\xabti \xc4\xaemon\xc4\x97s'
+b'apps/erpnext/erpnext/config/setup.py +27',b'Letter Heads for print templates.',b'Lai\xc5\xa1kas vadovai d\xc4\x97l spausdinimo \xc5\xa1ablonus.'
+b'apps/erpnext/erpnext/config/setup.py +32',b'Titles for print templates e.g. Proforma Invoice.',b'Pavadinimus spausdinimo \xc5\xa1ablon\xc5\xb3 pvz i\xc5\xa1ankstinio mok\xc4\x97jimo s\xc4\x85skait\xc4\x85.'
+b'DocType: Program Enrollment',b'Walking',b'vaik\xc5\xa1\xc4\x8diojimas'
+b'DocType: Student Guardian',b'Student Guardian',b'Student\xc5\xb3 glob\xc4\x97jas'
+b'DocType: Member',b'Member Name',b'Nario vardas'
+b'DocType: Stock Settings',b'Use Naming Series',b'Naudokite vard\xc5\xb3 serij\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218',b'Valuation type charges can not marked as Inclusive',b'Vertinimo tipas mokes\xc4\x8diai negali pa\xc5\xbeym\xc4\x97ta kaip \xc4\xafskai\xc4\x8diuota'
+b'DocType: POS Profile',b'Update Stock',b'Atnaujinti sand\xc4\x97lyje'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'in the subscription',b'prenumeruojant'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100',b'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.',"b'\xc4\xaevair\xc5\xabs UOM daikt\xc5\xb3 bus neteisinga (i\xc5\xa1 viso) Grynasis svoris vert\xc4\x97s. \xc4\xaesitikinkite, kad grynasis svoris kiekvieno elemento yra toje pa\xc4\x8dioje UOM.'"
+b'DocType: Membership',b'Payment Details',b'Mok\xc4\x97jimo detal\xc4\x97s'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'BOM Rate',b'BOM Balsuok'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225',"b'Stopped Work Order cannot be cancelled, Unstop it first to cancel'","b'Sustabdyto darbo u\xc5\xbesakymas negali b\xc5\xabti at\xc5\xa1auktas. I\xc5\xa1junkite j\xc4\xaf i\xc5\xa1 prad\xc5\xbei\xc5\xb3, kad at\xc5\xa1auktum\xc4\x97te'"
+b'DocType: Asset',b'Journal Entry for Scrap',b'\xc5\xbdurnalo \xc4\xafra\xc5\xa1\xc4\x85 lau\xc5\xbeo'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83',b'Please pull items from Delivery Note',b'Pra\xc5\xa1ome traukti elementus i\xc5\xa1 va\xc5\xbetara\xc5\xa1tyje'
+b'apps/erpnext/erpnext/accounts/utils.py +472',b'Journal Entries {0} are un-linked',b'\xc5\xbdurnalas \xc4\xafra\xc5\xa1ai {0} yra JT susiet\xc5\xb3'
+b'apps/erpnext/erpnext/config/crm.py +92',"b'Record of all communications of type email, phone, chat, visit, etc.'","b'\xc4\xaera\xc5\xa1\xc5\xb3 vis\xc5\xb3 tipo pa\xc5\xa1tu, telefonu, pokalbiai, apsilankymo, ir tt ry\xc5\xa1i\xc5\xb3'"
+b'DocType: Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing',b'Tiek\xc4\x97jo rezultat\xc5\xb3 vertinimo lentel\xc4\x97'
+b'DocType: Manufacturer',b'Manufacturers used in Items',b'Gamintojai naudojami daiktai'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +170',b'Please mention Round Off Cost Center in Company',b'Pamin\xc4\x97kite suapvalinti s\xc4\x85naud\xc5\xb3 centro \xc4\xafmon\xc4\x97je'
+b'DocType: Purchase Invoice',b'Terms',b's\xc4\x85lygos'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10',b'Select Days',b'Pasirinkite dienas'
+b'DocType: Academic Term',b'Term Name',b'terminas Vardas'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332',b'Credit ({0})',b'Kreditas ({0})'
+b'DocType: Buying Settings',b'Purchase Order Required',b'Pirkimui u\xc5\xbesakyti Reikalinga'
+,b'Item-wise Sales History',b'Prek\xc4\x97 i\xc5\xa1mintingas Pardavim\xc5\xb3 istorija'
+b'DocType: Expense Claim',b'Total Sanctioned Amount',b'I\xc5\xa1 viso sankcijos suma'
+b'DocType: Land Unit',b'Land Unit',b'\xc5\xbdem\xc4\x97s vienetas'
+,b'Purchase Analytics',b'pirkimo Analytics &quot;'
+b'DocType: Sales Invoice Item',b'Delivery Note Item',b'Va\xc5\xbetara\xc5\xa1tis punktas'
+b'DocType: Asset Maintenance Log',b'Task',b'u\xc5\xbeduotis'
+b'DocType: Purchase Taxes and Charges',b'Reference Row #',b'Nuoroda eilut\xc4\x97 #'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76',b'Batch number is mandatory for Item {0}',b'Partijos numeris yra privalomas punktas {0}'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13',b'This is a root sales person and cannot be edited.',b'Tai yra \xc5\xa1akn\xc5\xb3 pardavimo asmuo ir negali b\xc5\xabti pakeisti.'
+b'DocType: Salary Detail',"b""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. ""","b'Jei pasirinkta, nenurodyti arba apskai\xc4\x8diuojama \xc5\xa1io komponento vert\xc4\x97 nebus prisidedama prie savo u\xc5\xbedarbio ar atskaitym\xc5\xb3. Ta\xc4\x8diau, tai vert\xc4\x97 gali b\xc5\xabti nurodoma kit\xc5\xb3 komponent\xc5\xb3, kurie gali b\xc5\xabti pridedamos arba atimamos.'"
+b'DocType: Salary Detail',"b""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. ""","b'Jei pasirinkta, nenurodyti arba apskai\xc4\x8diuojama \xc5\xa1io komponento vert\xc4\x97 nebus prisidedama prie savo u\xc5\xbedarbio ar atskaitym\xc5\xb3. Ta\xc4\x8diau, tai vert\xc4\x97 gali b\xc5\xabti nurodoma kit\xc5\xb3 komponent\xc5\xb3, kurie gali b\xc5\xabti pridedamos arba atimamos.'"
+b'DocType: Asset Settings',b'Number of Days in Fiscal Year',b'Dien\xc5\xb3 skai\xc4\x8dius fiskaliniais metais'
+,b'Stock Ledger',b'akcij\xc5\xb3 Ledgeris'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29',b'Rate: {0}',b'Balsuok: {0}'
+b'DocType: Company',b'Exchange Gain / Loss Account',b'Valiut\xc5\xb3 Pelnas / nuostolis paskyra'
+b'apps/erpnext/erpnext/config/hr.py +7',b'Employee and Attendance',b'Darbuotoj\xc5\xb3 ir lankymas'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93',b'Purpose must be one of {0}',b'Tikslas turi b\xc5\xabti vienas i\xc5\xa1 {0}'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100',b'Fill the form and save it',b'U\xc5\xbepildykite form\xc4\x85 ir i\xc5\xa1saugokite j\xc4\xaf'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26',b'Community Forum',b'Bendruomen\xc4\x97 Forumas'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Tikrasis Kiekis sand\xc4\x97lyje'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Tikrasis Kiekis sand\xc4\x97lyje'
+b'DocType: Homepage',"b'URL for ""All Products""'",b'URL &quot;Visi produktai&quot;'
+b'DocType: Leave Application',b'Leave Balance Before Application',b'Palikite balansas Prie\xc5\xa1 taikymas'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46',b'Send SMS',b'si\xc5\xb3sti SMS'
+b'DocType: Supplier Scorecard Criteria',b'Max Score',b'Did\xc5\xbeiausias balas'
+b'DocType: Cheque Print Template',b'Width of amount in word',b'Plotis suma \xc5\xbeod\xc5\xbeiu'
+b'DocType: Company',b'Default Letter Head',b'Numatytasis ra\xc5\xa1tas vadovas'
+b'DocType: Purchase Order',b'Get Items from Open Material Requests',b'Gauk daiktai i\xc5\xa1 atvir\xc5\xb3 Materiali\xc5\xb3j\xc5\xb3 Pra\xc5\xa1ymai'
+b'DocType: Hotel Room Amenity',b'Billable',b'Apmokestinama'
+b'DocType: Lab Test Template',b'Standard Selling Rate',b'Standartin\xc4\x97 pardavimo kurs\xc4\x85'
+b'DocType: Account',b'Rate at which this tax is applied',"b'Norma, kuri yra taikoma \xc5\xa1i mokes\xc4\x8di\xc5\xb3'"
+b'DocType: Cash Flow Mapper',b'Section Name',b'Skyriaus pavadinimas'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77',b'Reorder Qty',b'Pertvarkyti Kiekis'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28',b'Current Job Openings',b'Dabartinis darbas Angos'
+b'DocType: Company',b'Stock Adjustment Account',b'Vertybini\xc5\xb3 popieri\xc5\xb3 reguliavimas paskyra'
+b'apps/erpnext/erpnext/public/js/payment/pos_payment.html +17',b'Write Off',b'Nusira\xc5\xa1in\xc4\x97ti'
+b'DocType: Patient Service Unit',b'Allow Overlap',b'Leiskite persidengti'
+b'DocType: Timesheet Detail',b'Operation ID',b'operacija ID'
+b'DocType: Employee',"b'System User (login) ID. If set, it will become default for all HR forms.'","b'Sistemos vartotojas (Prisijunk) adresas. Jei nustatyta, ji taps nutyl\xc4\x97jim\xc4\x85 visiems HR formas.'"
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16',b'{0}: From {1}',b'{0}: Nuo {1}'
+b'DocType: Task',b'depends_on',b'priklauso nuo'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60',b'Queued for updating latest price in all Bill of Materials. It may take a few minutes.',b'Kvie\xc4\x8diame atnaujinti naujausi\xc4\x85 kain\xc4\x85 visame med\xc5\xbeiag\xc5\xb3 s\xc4\x85ra\xc5\xa1e. Tai gali u\xc5\xbetrukti kelias minutes.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26',"b""Name of new Account. Note: Please don't create accounts for Customers and Suppliers""",b'Pavadinimas nauj\xc4\x85 paskyr\xc4\x85. Pastaba: nekurkite s\xc4\x85skaitas klientai ir tiek\xc4\x97jai'
+b'apps/erpnext/erpnext/config/setup.py +37',b'Country wise default Address Templates',b'\xc5\xa0alis protinga numatytasis adresas \xc5\xa0ablonai'
+b'DocType: Water Analysis',b'Appearance',b'I\xc5\xa1vaizda'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Buying Price List Rate',b'Vidur. Pirkimo kain\xc5\xb3 s\xc4\x85ra\xc5\xa1o norma'
+b'DocType: Sales Order Item',b'Supplier delivers to Customer',b'Tiek\xc4\x97jas pristato Klientui'
+b'apps/erpnext/erpnext/config/non_profit.py +23',b'Member information.',b'Nario informacija.'
+b'apps/erpnext/erpnext/utilities/bot.py +34',b'[{0}](#Form/Item/{0}) is out of stock',b'[{0}] (# Forma / Prek\xc4\x97s / {0}) neb\xc4\x97ra sandelyje'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +58',b'Asset Maintenance',b'Turto prie\xc5\xbei\xc5\xabra'
+,b'Sales Payment Summary',b'Pardavim\xc5\xb3 mok\xc4\x97jimo suvestin\xc4\x97'
+b'DocType: Restaurant',b'Restaurant',b'Restoranas'
+b'apps/erpnext/erpnext/accounts/party.py +320',b'Due / Reference Date cannot be after {0}',b'D\xc4\x97l / Nuoroda data negali b\xc5\xabti po {0}'
+b'apps/erpnext/erpnext/config/setup.py +51',b'Data Import and Export',b'Duomen\xc5\xb3 importas ir eksportas'
+b'DocType: Patient',b'Account Details',b'I\xc5\xa1sami paskyros informacija'
+b'DocType: Crop',b'Materials Required',b'Reikalingos med\xc5\xbeiagos'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76',b'No students Found',b'Studentai Surasta'
+b'DocType: Medical Department',b'Medical Department',b'Medicinos skyrius'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Criteria',b'Tiek\xc4\x97jo vertinimo rezultat\xc5\xb3 vertinimo kriterijai'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55',b'Invoice Posting Date',b'S\xc4\x85skaita Siun\xc4\x8diamos data'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25',b'Sell',b'Parduoti'
+b'DocType: Purchase Invoice',b'Rounded Total',b'Suapvalinta bendra suma'
+b'DocType: Product Bundle',b'List items that form the package.',"b'S\xc4\x85ra\xc5\xa1as daikt\xc5\xb3, kurie sudaro paket\xc4\x85.'"
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39',b'Not permitted. Please disable the Test Template',b'Neleistina. Pra\xc5\xa1ome i\xc5\xa1jungti testo \xc5\xa1ablon\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26',b'Percentage Allocation should be equal to 100%',b'Procentas paskirstymas turi b\xc5\xabti lygus 100%'
+b'DocType: Crop Cycle',b'Linked Land Unit',b'Susijusios \xc5\xbeem\xc4\x97s vienetas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584',b'Please select Posting Date before selecting Party',b'Pra\xc5\xa1ome pasirinkti Skelbimo data prie\xc5\xa1 pasirinkdami \xc5\xa0aliai'
+b'DocType: Program Enrollment',b'School House',b'Mokykla Namas'
+b'DocType: Serial No',b'Out of AMC',b'I\xc5\xa1 AMC'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +82',b'Number of Depreciations Booked cannot be greater than Total Number of Depreciations',b'Ta\xc5\xa1k\xc5\xb3 nuvertinimai REZERVUOTA negali b\xc5\xabti didesnis nei bendras skai\xc4\x8dius nuvertinimai'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47',b'Make Maintenance Visit',b'Padaryti Prie\xc5\xbei\xc5\xabros vizitas'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +215',b'Please contact to the user who have Sales Master Manager {0} role',"b'Pra\xc5\xa1ome susisiekti su vartotojo, kuris turi pardavimo magistras Manager {0} vaidmen\xc4\xaf'"
+b'DocType: Company',b'Default Cash Account',b'Numatytasis pinig\xc5\xb3 s\xc4\x85skaitos'
+b'apps/erpnext/erpnext/config/accounts.py +62',b'Company (not Customer or Supplier) master.',b'\xc4\xaemon\xc4\x97s (ne klientas ar tiek\xc4\x97jas) meistras.'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6',b'This is based on the attendance of this Student',"b'Tai yra, remiantis \xc5\xa1io mokini\xc5\xb3 lankomum\xc4\x85'"
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178',b'No Students in',b'N\xc4\x97ra Studentai'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179',b'Add more items or open full form',b'Prid\xc4\x97ti daugiau element\xc5\xb3 arba atidaryti vis\xc4\x85 form\xc4\x85'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212',b'Delivery Notes {0} must be cancelled before cancelling this Sales Order',b'Pristatymo Pastabos {0} turi b\xc5\xabti at\xc5\xa1auktas prie\xc5\xa1 panaikinant \xc5\xa1\xc4\xaf pardavimo u\xc5\xbesakym\xc5\xb3'
+b'apps/erpnext/erpnext/utilities/user_progress.py +259',b'Go to Users',b'Eikite \xc4\xaf &quot;Vartotojai&quot;'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85',b'Paid amount + Write Off Amount can not be greater than Grand Total',b'Mokama suma + nura\xc5\xa1yti suma negali b\xc5\xabti didesn\xc4\x97 nei I\xc5\xa0 VISO'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78',b'{0} is not a valid Batch Number for Item {1}',b'{0} yra neteisingas SERIJOS NUMERIS u\xc5\xbe prek\xc4\x99 {1}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130',b'Note: There is not enough leave balance for Leave Type {0}',b'Pastaba: N\xc4\x97ra pakankamai atostogos balansas Palikti tipas {0}'
+b'apps/erpnext/erpnext/regional/india/utils.py +16',b'Invalid GSTIN or Enter NA for Unregistered',b'Neteisingas GSTIN ar \xc4\xaeveskite NA neregistruotas'
+b'DocType: Training Event',b'Seminar',b'seminaras'
+b'DocType: Program Enrollment Fee',b'Program Enrollment Fee',b'Programos Dalyvio mokestis'
+b'DocType: Item',b'Supplier Items',b'Tiek\xc4\x97jo daiktai'
+b'DocType: Opportunity',b'Opportunity Type',b'galimyb\xc4\x97 tipas'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16',b'New Company',b'nauja \xc4\xaemon\xc4\x97s'
+b'apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17',b'Transactions can only be deleted by the creator of the Company',b'Sandoriai gali b\xc5\xabti i\xc5\xa1braukta tik Bendrov\xc4\x97s k\xc5\xabr\xc4\x97jo'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +21',b'Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.',b'Neteisingas skai\xc4\x8dius did\xc5\xbei\xc4\x85j\xc4\x85 knyg\xc4\x85 \xc4\xaera\xc5\xa1ai nerasta. Galb\xc5\xabt pasirinkote neteising\xc4\x85 s\xc4\x85skait\xc4\x85 sandoryje.'
+b'DocType: Employee',b'Prefered Contact Email',b'Pageidaujamas Kontaktai El.pa\xc5\xa1tas'
+b'DocType: Cheque Print Template',b'Cheque Width',b'Komunalin\xc4\x97s Plotis'
+b'DocType: Selling Settings',b'Validate Selling Price for Item against Purchase Rate or Valuation Rate',b'Patvirtinti pardavimo kaina u\xc5\xbe prek\xc4\x99 prie\xc5\xa1 Pirkimo rodikliu Vertinimo koeficientas'
+b'DocType: Fee Schedule',b'Fee Schedule',b'mokestis Tvarkara\xc5\xa1tis'
+b'DocType: Hub Settings',b'Publish Availability',b'Paskelbti Prieinamumas'
+b'DocType: Company',b'Create Chart Of Accounts Based On',b'Sukurti s\xc4\x85skait\xc5\xb3 plan\xc4\x85 remiantis'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +91',b'Cannot convert it to non-group. Child Tasks exist.',b'Negalima konvertuoti \xc4\xaf ne grup\xc4\x99. Vaik\xc5\xb3 u\xc5\xbeduotys egzistuoja.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +112',b'Date of Birth cannot be greater than today.',b'Gimimo data negali b\xc5\xabti didesnis nei dabar.'
+,b'Stock Ageing',b'akcij\xc5\xb3 sen\xc4\x97jimas'
+b'apps/erpnext/erpnext/education/doctype/student/student.py +40',b'Student {0} exist against student applicant {1}',b'Student\xc5\xb3 {0} egzistuoja nuo studento parei\xc5\xa1k\xc4\x97jo {1}'
+b'DocType: Purchase Invoice',b'Rounding Adjustment (Company Currency)',b'Apvalinimo koregavimas (\xc4\xafmon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +39',b'Timesheet',b'darbo laiko apskaitos \xc5\xbeiniara\xc5\xa1tis'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243',b'Batch: ',b'Partija:'
+b'DocType: Volunteer',b'Afternoon',b'Popiet\xc4\x97'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +258',"b""{0} '{1}' is disabled""",b'{0} &quot;{1}&quot; yra i\xc5\xa1jungta'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13',b'Set as Open',b'Nustatyti kaip Open'
+b'DocType: Cheque Print Template',b'Scanned Cheque',b'Nuskaityti \xc4\x8dekis'
+b'DocType: Notification Control',b'Send automatic emails to Contacts on Submitting transactions.',"b'Si\xc5\xb3sti automatinius lai\xc5\xa1kus Kontaktai, kaip pateikti sandori\xc5\xb3.'"
+b'DocType: Timesheet',b'Total Billable Amount',b'I\xc5\xa1 viso Apmokestinama suma'
+b'DocType: Customer',b'Credit Limit and Payment Terms',b'Kredito limitas ir mok\xc4\x97jimo s\xc4\x85lygos'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20',b'Item 3',b'3 punktas'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6',b'Order Entry',b'U\xc5\xbesakymo \xc4\xafra\xc5\xa1as'
+b'DocType: Purchase Order',b'Customer Contact Email',b'Klient\xc5\xb3 Kontaktai El.pa\xc5\xa1tas'
+b'DocType: Warranty Claim',b'Item and Warranty Details',b'Punktas ir garantijos informacija'
+b'DocType: Chapter',b'Chapter Members',b'Skyrius nariai'
+b'DocType: Sales Team',b'Contribution (%)',b'Ind\xc4\x97lis (%)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +102',"b""Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified""",b'Pastaba: mok\xc4\x97jimo \xc4\xafra\xc5\xa1as nebus sukurtos nuo &quot;pinigais arba banko s\xc4\x85skaitos&quot; nebuvo nurodyta'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +70',b'Project {0} already exists',b'Projektas {0} jau egzistuoja'
+b'DocType: Medical Department',b'Nursing User',b'Slaugos naudotojas'
+b'DocType: Plant Analysis',b'Plant Analysis Criterias',b'Augal\xc5\xb3 analiz\xc4\x97s kriterijai'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239',b'Responsibilities',b'atsakomyb\xc4\x97'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125',b'Validity period of this quotation has ended.',b'Pasibaig\xc4\x97 \xc5\xa1ios citatos galiojimo laikotarpis.'
+b'DocType: Expense Claim Account',b'Expense Claim Account',b'Kompensuojamos Pretenzija paskyra'
+b'DocType: Accounts Settings',b'Allow Stale Exchange Rates',b'Leisti nejudan\xc4\x8dius valiut\xc5\xb3 keitimo kursus'
+b'DocType: Sales Person',b'Sales Person Name',b'Pardavim\xc5\xb3 Asmuo Vardas'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54',b'Please enter atleast 1 invoice in the table',b'Pra\xc5\xa1ome \xc4\xafvesti atleast 1 s\xc4\x85skait\xc4\x85 lentel\xc4\x97je'
+b'apps/erpnext/erpnext/utilities/user_progress.py +247',b'Add Users',b'Prid\xc4\x97ti Vartotojai'
+b'DocType: POS Item Group',b'Item Group',b'Prek\xc4\x97 grup\xc4\x97'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16',b'Student Group: ',b'Student\xc5\xb3 grup\xc4\x97:'
+b'DocType: Item',b'Safety Stock',b'saugos kodas'
+b'DocType: Healthcare Settings',b'Healthcare Settings',b'Sveikatos prie\xc5\xbei\xc5\xabros nustatymai'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +54',b'Progress % for a task cannot be more than 100.',b'Pa\xc5\xbeanga% u\xc5\xbeduoties negali b\xc5\xabti daugiau nei 100.'
+b'DocType: Stock Reconciliation Item',b'Before reconciliation',b'prie\xc5\xa1 susitaikymo'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12',b'To {0}',b'Nor\xc4\x97dami {0}'
+b'DocType: Purchase Invoice',b'Taxes and Charges Added (Company Currency)',b'Mokes\xc4\x8diai ir rinkliavos Prid\xc4\x97ta (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +476',b'Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable',b'Prek\xc4\x97 Mokes\xc4\x8di\xc5\xb3 eilut\xc4\x97 {0} turi atsi\xc5\xbevelgti tipo mokes\xc4\x8dio ar pajam\xc5\xb3 ar s\xc4\x85naud\xc5\xb3 arba Apmokestinimo'
+b'DocType: Sales Order',b'Partly Billed',b'dalinai \xc4\xaevardintas'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +43',b'Item {0} must be a Fixed Asset Item',b'Prek\xc4\x97 {0} turi b\xc5\xabti ilgalaikio turto'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +372',b'Make Variants',b'Padaryti variantus'
+b'DocType: Item',b'Default BOM',b'numatytasis BOM'
+b'DocType: Project',b'Total Billed Amount (via Sales Invoices)',b'Visa i\xc5\xa1leista suma (per pardavimo s\xc4\x85skaitas fakt\xc5\xabras)'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Debit Note Amount',b'Debeto Pastaba suma'
+b'DocType: Project Update',b'Not Updated',b'Neatnaujinta'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106',"b'There are inconsistencies between the rate, no of shares and the amount calculated'","b'Yra neatitikim\xc5\xb3 tarp normos, akcij\xc5\xb3 n\xc4\x97ra ir apskai\xc4\x8diuotos sumos'"
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +89',b'Please re-type company name to confirm',b'Pra\xc5\xa1ome i\xc5\xa1 naujo tipo \xc4\xafmon\xc4\x97s pavadinimas patvirtinti'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +216',b'Total Outstanding Amt',b'Visos negr\xc4\x85\xc5\xbeintos Amt'
+b'DocType: Journal Entry',b'Printing Settings',b'Spausdinimo nustatymai'
+b'DocType: Employee Advance',b'Advance Account',b'I\xc5\xa1ankstin\xc4\x97 s\xc4\x85skaita'
+b'DocType: Job Offer',b'Job Offer Terms',b'Darbo pasi\xc5\xablymo s\xc4\x85lygos'
+b'DocType: Sales Invoice',b'Include Payment (POS)',b'\xc4\xaetraukti mok\xc4\x97jim\xc4\x85 (POS)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292',b'Total Debit must be equal to Total Credit. The difference is {0}',b'I\xc5\xa1 viso debetas turi b\xc5\xabti lygus Kreditai. Skirtumas yra {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11',b'Automotive',b'Automobiliai'
+b'DocType: Vehicle',b'Insurance Company',b'Draudimo bendrov\xc4\x97'
+b'DocType: Asset Category Account',b'Fixed Asset Account',b'Ilgalaikio turto s\xc4\x85skaita'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414',b'Variable',b'kintamas'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47',b'From Delivery Note',b'Nuo va\xc5\xbetara\xc5\xa1tyje'
+b'DocType: Chapter',b'Members',b'Nariai'
+b'DocType: Student',b'Student Email Address',b'Student\xc5\xb3 elektroninio pa\xc5\xa1to adresas'
+b'DocType: Item',b'Hub Warehouse',b'&quot;Hub&quot; sand\xc4\x97lis'
+b'DocType: Assessment Plan',b'From Time',b'nuo Laikas'
+b'DocType: Hotel Settings',b'Hotel Settings',b'Vie\xc5\xa1bu\xc4\x8dio nustatymai'
+b'apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12',b'In Stock: ',b'Prekyboje:'
+b'DocType: Notification Control',b'Custom Message',b'Pasirinktinis prane\xc5\xa1imas'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33',b'Investment Banking',b'Investicin\xc4\x97s bankininkyst\xc4\x97s'
+b'DocType: Purchase Invoice',b'input',b'\xc4\xafvestis'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79',b'Cash or Bank Account is mandatory for making payment entry',b'Pinigais arba banko s\xc4\x85skaitos yra privalomas priimant mok\xc4\x97jimo \xc4\xafra\xc5\xa1\xc4\x85'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Student\xc5\xb3 Adresas'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Student\xc5\xb3 Adresas'
+b'DocType: Purchase Invoice',b'Price List Exchange Rate',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as Valiut\xc5\xb3 kursai'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +251',b'Account Number {0} already used in account {1}',"b'S\xc4\x85skaitos numeris {0}, jau naudojamas paskyroje {1}'"
+b'DocType: GoCardless Mandate',b'Mandate',b'Mandatas'
+b'DocType: POS Profile',b'POS Profile Name',b'POS profilio vardas'
+b'DocType: Hotel Room Reservation',b'Booked',b'Rezervuota'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxLib',b'CompAuxLib'
+b'DocType: Purchase Invoice Item',b'Rate',b'Kaina'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104',b'Intern',b'internas'
+b'DocType: Delivery Stop',b'Address Name',b'adresas pavadinimas'
+b'DocType: Stock Entry',b'From BOM',b'nuo BOM'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639',b'Splitting {0} units of {1}',b'Suskaidyti {0} vienet\xc5\xb3 {1}'
+b'DocType: Assessment Code',b'Assessment Code',b'vertinimas kodas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73',b'Basic',b'pagrindinis'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94',b'Stock transactions before {0} are frozen',b'Akcij\xc5\xb3 sandoriai iki {0} yra su\xc5\xa1aldyti'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219',"b""Please click on 'Generate Schedule'""",b'Pra\xc5\xa1ome spausti &quot;Generuoti grafik\xc4\x85&quot;'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122',b'Reference No is mandatory if you entered Reference Date',"b'Nuorodos Nr yra privaloma, jei \xc4\xafved\xc4\x97te Atskaitos data'"
+b'DocType: Bank Reconciliation Detail',b'Payment Document',b'mok\xc4\x97jimo dokument\xc4\x85'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37',b'Error evaluating the criteria formula',b'Klaida \xc4\xafvertinant kriterij\xc5\xb3 formul\xc4\x99'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +115',b'Date of Joining must be greater than Date of Birth',b'Stojant data turi b\xc5\xabti didesnis nei gimimo data'
+b'DocType: Salary Slip',b'Salary Structure',b'Pajamos strukt\xc5\xabra'
+b'DocType: Account',b'Bank',b'bankas'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9',b'Airline',b'Aviakompanija'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853',b'Issue Material',b'klausimas Med\xc5\xbeiaga'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'An error occured while creating recurring',b'Kuriant pakartotinai \xc4\xafvyko klaida'
+b'DocType: Material Request Item',b'For Warehouse',b'Sand\xc4\x97liavimo'
+b'DocType: Employee',b'Offer Date',b'Si\xc5\xablau data'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33',b'Quotations',b'citatos'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +735',b'You are in offline mode. You will not be able to reload until you have network.',"b'J\xc5\xabs esate neprisijung\xc4\x99. J\xc5\xabs negalite \xc4\xafkelti, kol turite tinkl\xc4\x85.'"
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47',b'No Student Groups created.',b'N\xc4\x97ra Student\xc5\xb3 grup\xc4\x97s sukurta.'
+b'DocType: Purchase Invoice Item',b'Serial No',b'Serijos Nr'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119',b'Monthly Repayment Amount cannot be greater than Loan Amount',b'M\xc4\x97nesio gr\xc4\x85\xc5\xbeinimo suma negali b\xc5\xabti didesn\xc4\x97 nei paskolos suma'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143',b'Please enter Maintaince Details first',b'Pra\xc5\xa1ome \xc4\xafvesti maintaince Details pirmas'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56',b'Row #{0}: Expected Delivery Date cannot be before Purchase Order Date',b'Eilut\xc4\x97 # {0}: laukiama pristatymo data negali b\xc5\xabti prie\xc5\xa1 Pirkimo u\xc5\xbesakymo dat\xc4\x85'
+b'DocType: Purchase Invoice',b'Print Language',b'Spausdinti kalba'
+b'DocType: Salary Slip',b'Total Working Hours',b'I\xc5\xa1 viso darbo valand\xc5\xb3'
+b'DocType: Sales Invoice',b'Customer PO Details',b'Kliento PO duomenys'
+b'DocType: Subscription',b'Next Schedule Date',b'Kitas tvarkara\xc5\xa1\xc4\x8dio data'
+b'DocType: Stock Entry',b'Including items for sub assemblies',b'\xc4\xaeskaitant daikt\xc5\xb3 sub asambl\xc4\x97jose'
+b'DocType: Opening Invoice Creation Tool Item',b'Temporary Opening Account',b'Laikina atidarymo s\xc4\x85skaita'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1964',b'Enter value must be positive',b'\xc4\xaeveskite vert\xc4\x97 turi b\xc5\xabti teigiamas'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446',b'All Territories',b'visos teritorijos'
+b'apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49',b'Add Multiple Tasks',b'Prid\xc4\x97ti kelis u\xc5\xbedavinius'
+b'DocType: Purchase Invoice',b'Items',b'Daiktai'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34',b'Student is already enrolled.',b'Student\xc5\xb3 jau mokosi.'
+b'DocType: Fiscal Year',b'Year Name',b'metai Vardas'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241',b'There are more holidays than working days this month.',b'Yra daugiau \xc5\xa1ven\xc4\x8di\xc5\xb3 nei darbo dienas \xc5\xa1\xc4\xaf m\xc4\x97nes\xc4\xaf.'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78',b'PDC/LC Ref',b'PDC / LC Nuoroda'
+b'DocType: Product Bundle Item',b'Product Bundle Item',b'Prek\xc4\x97s Rinkinys punktas'
+b'DocType: Sales Partner',b'Sales Partner Name',b'Partneriai pardavimo Vardas'
+b'apps/erpnext/erpnext/hooks.py +136',b'Request for Quotations',b'Pra\xc5\xa1ymas citatos'
+b'DocType: Payment Reconciliation',b'Maximum Invoice Amount',b'Maksimalus S\xc4\x85skaitos fakt\xc5\xabros suma'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Montantdevise',b'Montantdevise'
+b'apps/erpnext/erpnext/healthcare/setup.py +210',b'Haematology',b'Hematologija'
+b'DocType: Normal Test Items',b'Normal Test Items',b'Normal\xc5\xabs testo elementai'
+b'DocType: Student Language',b'Student Language',b'Student\xc5\xb3 kalba'
+b'apps/erpnext/erpnext/config/selling.py +23',b'Customers',b'klientai'
+b'DocType: Cash Flow Mapping',b'Is Working Capital',b'Ar apyvartinis kapitalas'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'U\xc5\xbesakymas / quot%'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'U\xc5\xbesakymas / quot%'
+b'apps/erpnext/erpnext/config/healthcare.py +25',b'Record Patient Vitals',b'\xc4\xaera\xc5\xa1ykite Pacient\xc5\xb3 Vital'
+b'DocType: Fee Schedule',b'Institution',b'institucija'
+b'DocType: Asset',b'Partially Depreciated',b'dalinai nud\xc4\x97vimas'
+b'DocType: Issue',b'Opening Time',b'atidarymo laikas'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89',b'From and To dates required',"b'I\xc5\xa1 ir \xc4\xaf datas, reikaling\xc5\xb3'"
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46',b'Securities & Commodity Exchanges',b'Vertybini\xc5\xb3 popieri\xc5\xb3 ir preki\xc5\xb3 bir\xc5\xbeose'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +689',"b""Default Unit of Measure for Variant '{0}' must be same as in Template '{1}'""","b'Numatytasis vienetas priemon\xc4\x97 variantas &quot;{0}&quot; turi b\xc5\xabti toks pat, kaip \xc5\xa0ablonas &quot;{1}&quot;'"
+b'DocType: Shipping Rule',b'Calculate Based On',b'Apskai\xc4\x8diuoti remiantis'
+b'DocType: Delivery Note Item',b'From Warehouse',b'i\xc5\xa1 sand\xc4\x97lio'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59',b'No employees for the mentioned criteria',b'N\xc4\x97 vienas i\xc5\xa1 min\xc4\x97t\xc5\xb3 kriterij\xc5\xb3 darbuotoj\xc5\xb3 n\xc4\x97ra'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955',b'No Items with Bill of Materials to Manufacture',"b'Neturite preki\xc5\xb3 su Bill i\xc5\xa1 med\xc5\xbeiag\xc5\xb3, Gamyba'"
+b'DocType: Hotel Settings',b'Default Customer',b'Numatytasis klientas'
+b'DocType: Assessment Plan',b'Supervisor Name',b'prie\xc5\xbei\xc5\xabros Vardas'
+b'DocType: Healthcare Settings',b'Do not confirm if appointment is created for the same day',"b'Nenurodykite, ar paskyrimas sukurtas t\xc4\x85 pa\xc4\x8di\xc4\x85 dien\xc4\x85'"
+b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Programos Pri\xc4\x97mimas kursai'
+b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Programos Pri\xc4\x97mimas kursai'
+b'DocType: Purchase Taxes and Charges',b'Valuation and Total',b'Vertinimas ir viso'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11',b'Scorecards',b'Rezultat\xc5\xb3 kortel\xc4\x97s'
+b'DocType: Tax Rule',b'Shipping City',b'Pristatymas Miestas'
+b'DocType: Notification Control',b'Customize the Notification',b'Tinkinti Prane\xc5\xa1imas'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24',b'Cash Flow from Operations',b'Pinig\xc5\xb3 srautai i\xc5\xa1 operacij\xc5\xb3'
+b'DocType: Purchase Invoice',b'Shipping Rule',b'Pristatymas taisykl\xc4\x97'
+b'DocType: Patient Relation',b'Spouse',b'Sutuoktinis'
+b'DocType: Lab Test Groups',b'Add Test',b'Prid\xc4\x97ti test\xc4\x85'
+b'DocType: Manufacturer',b'Limited to 12 characters',b'Ribojamas iki 12 simboli\xc5\xb3'
+b'DocType: Journal Entry',b'Print Heading',b'Spausdinti pozicijoje'
+b'apps/erpnext/erpnext/config/stock.py +146',b'Delivery Trip service tours to customers.',b'Pristatymas Kelioni\xc5\xb3 paslaug\xc5\xb3 turai klientams.'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57',b'Total cannot be zero',b'Bendras negali b\xc5\xabti nulis'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16',"b""'Days Since Last Order' must be greater than or equal to zero""","b'""Dienos nuo paskutinio u\xc5\xbesakymo"" turi b\xc5\xabti didesnis nei arba lygus nuliui'"
+b'DocType: Plant Analysis Criteria',b'Maximum Permissible Value',b'Did\xc5\xbeiausia leistina vert\xc4\x97'
+b'DocType: Journal Entry Account',b'Employee Advance',b'Darbuotojo i\xc5\xa1ankstinis mok\xc4\x97jimas'
+b'DocType: Payroll Entry',b'Payroll Frequency',b'Darbo u\xc5\xbemokes\xc4\x8dio Da\xc5\xbenio'
+b'DocType: Lab Test Template',b'Sensitivity',b'Jautrumas'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941',b'Raw Material',b'\xc5\xbealiava'
+b'DocType: Leave Application',b'Follow via Email',b'Sekite elektroniniu pa\xc5\xa1tu'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55',b'Plants and Machineries',b'Augalai ir i\xc5\xa1stumti'
+b'DocType: Purchase Taxes and Charges',b'Tax Amount After Discount Amount',"b'Mokes\xc4\x8di\xc5\xb3 suma, nuolaidos suma'"
+b'DocType: Daily Work Summary Settings',b'Daily Work Summary Settings',b'Dienos darbo santrauka Nustatymai'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +447',b'Please enter Reqd by Date',b'Pra\xc5\xa1ome \xc4\xafvesti reqd pagal dat\xc4\x85'
+b'DocType: Payment Entry',b'Internal Transfer',b'vidaus perk\xc4\x97limo'
+b'DocType: Asset Maintenance',b'Maintenance Tasks',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros u\xc5\xbeduotys'
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.py +19',b'Either target qty or target amount is mandatory',b'Bet tikslas Kiekis arba planuojama suma yra privalomi'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366',b'Please select Posting Date first',b'Pra\xc5\xa1ome pasirinkti Skelbimo data pirmas'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +209',b'Opening Date should be before Closing Date',b'Atidarymo data tur\xc4\x97t\xc5\xb3 b\xc5\xabti prie\xc5\xa1 u\xc5\xbedarant data'
+b'DocType: Leave Control Panel',b'Carry Forward',b'T\xc4\x99sti'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30',b'Cost Center with existing transactions can not be converted to ledger',b'Kaina centras su esamais sandoriai negali b\xc5\xabti konvertuojamos \xc4\xaf s\xc4\x85skait\xc5\xb3 knygos'
+b'DocType: Department',b'Days for which Holidays are blocked for this department.',"b'Dien\xc5\xb3, kuriomis \xc5\xa0vent\xc4\x97s blokuojami \xc5\xa1iame skyriuje.'"
+b'DocType: GoCardless Mandate',b'ERPNext Integrations',b'ERPNext integracija'
+b'DocType: Crop Cycle',b'Detected Disease',b'Aptikta liga'
+,b'Produced',b'pagamintas'
+b'DocType: Item',b'Item Code for Suppliers',b'Prek\xc4\x97s kodas tiek\xc4\x97jams'
+b'DocType: Issue',b'Raised By (Email)',b'I\xc5\xa1keltas (el)'
+b'DocType: Training Event',b'Trainer Name',b'treneris Vardas'
+b'DocType: Mode of Payment',b'General',b'bendras'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Paskutinis Bendravimas'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Paskutinis Bendravimas'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372',"b""Cannot deduct when category is for 'Valuation' or 'Valuation and Total'""","b'Negali atskaityti, kai kategorija skirta &quot;Vertinimo&quot; arba &quot;vertinimo ir viso&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234',b'Serial Nos Required for Serialized Item {0}',b'Eil\xc4\x97s Nr Reikalinga u\xc5\xbe Serijinis punkte {0}'
+b'apps/erpnext/erpnext/config/accounts.py +144',b'Match Payments with Invoices',b'Rungtyni\xc5\xb3 Mok\xc4\x97jimai s\xc4\x85skait\xc5\xb3 fakt\xc5\xabr\xc5\xb3'
+b'DocType: Journal Entry',b'Bank Entry',b'bankas \xc4\xafra\xc5\xa1as'
+b'DocType: Authorization Rule',b'Applicable To (Designation)',b'Taikoma (paskyrimas)'
+,b'Profitability Analysis',b'pelningumo analiz\xc4\x97'
+b'DocType: Fees',b'Student Email',b'Studento el. Pa\xc5\xa1tas'
+b'DocType: Supplier',b'Prevent POs',b'Neleisti PO'
+b'DocType: Patient',"b'Allergies, Medical and Surgical History'","b'Alergijos, medicinos ir chirurgijos istorija'"
+b'apps/erpnext/erpnext/templates/generators/item.html +77',b'Add to Cart',b'\xc4\xae krep\xc5\xa1el\xc4\xaf'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28',b'Group By',b'Grupuoti pagal'
+b'DocType: Guardian',b'Interests',b'Pom\xc4\x97giai'
+b'apps/erpnext/erpnext/config/accounts.py +298',b'Enable / disable currencies.',b'\xc4\xaejungti / i\xc5\xa1jungti valiutas.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105',b'Dr {0} on Half day Leave on {1}',b'Dr {0} per pus\xc4\x99 dienos I\xc5\xa1eiti {1}'
+b'DocType: Production Plan',b'Get Material Request',b'Gauk Material u\xc5\xbeklausa'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111',b'Postal Expenses',b'pa\xc5\xa1to i\xc5\xa1laidas'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Amt)',b'I\xc5\xa1 viso (Amt)'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26',b'Entertainment & Leisure',b'Pramogos ir poilsis'
+,b'Item Variant Details',b'Prek\xc4\x97s variantai'
+b'DocType: Quality Inspection',b'Item Serial No',b'Prek\xc4\x97 Serijos Nr'
+b'apps/erpnext/erpnext/utilities/activation.py +135',b'Create Employee Records',b'Sukurti darbuotoj\xc5\xb3 \xc4\xafra\xc5\xa1us'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Present',b'I\xc5\xa1 viso dabartis'
+b'apps/erpnext/erpnext/config/accounts.py +105',b'Accounting Statements',b'apskaitos ataskaitos'
+b'DocType: Drug Prescription',b'Hour',b'valanda'
+b'DocType: Restaurant Order Entry',b'Last Sales Invoice',b'Paskutin\xc4\x97 pardavimo s\xc4\x85skaita fakt\xc5\xabra'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +788',b'Please select Qty against item {0}',b'Pasirinkite kiek\xc4\xaf prie\xc5\xa1 element\xc4\x85 {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29',b'New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt',b'Nauja Serijos Nr negalite turime sand\xc4\x97lyje. Sand\xc4\x97li\xc5\xb3 turi nustatyti vertybini\xc5\xb3 popieri\xc5\xb3 atvykimo arba pirkimo kvito'
+b'DocType: Lead',b'Lead Type',b'\xc5\xa0vinas tipas'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114',b'You are not authorized to approve leaves on Block Dates',b'J\xc5\xabs nesate \xc4\xafgaliotas tvirtinti lapus Block Datos'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394',b'All these items have already been invoiced',b'Visi \xc5\xa1ie elementai jau buvo s\xc4\x85skaitoje'
+b'DocType: Company',b'Monthly Sales Target',b'M\xc4\x97nesio pardavimo tikslai'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37',b'Can be approved by {0}',b'Gali b\xc5\xabti patvirtintas {0}'
+b'DocType: Hotel Room',b'Hotel Room Type',b'Vie\xc5\xa1bu\xc4\x8dio kambario tipas'
+b'DocType: Item',b'Default Material Request Type',b'Numatytasis Med\xc5\xbeiaga Pra\xc5\xa1ymas tipas'
+b'DocType: Supplier Scorecard',b'Evaluation Period',b'Vertinimo laikotarpis'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13',b'Unknown',b'ne\xc5\xbeinomas'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954',b'Work Order not created',b'Darbo u\xc5\xbesakymas nerastas'
+b'DocType: Shipping Rule',b'Shipping Rule Conditions',b'Pristatymas taisykl\xc4\x97 s\xc4\x85lygos'
+b'DocType: Purchase Invoice',b'Export Type',b'Eksporto tipas'
+b'DocType: Salary Slip Loan',b'Salary Slip Loan',b'Atlyginimo paskolos paskola'
+b'DocType: BOM Update Tool',b'The new BOM after replacement',b'Naujas BOM po pakeitimo'
+,b'Point of Sale',b'Pardavimo punktas'
+b'DocType: Payment Entry',b'Received Amount',b'gautos sumos'
+b'DocType: Patient',b'Widow',b'Na\xc5\xa1l\xc4\x97'
+b'DocType: GST Settings',b'GSTIN Email Sent On',b'GSTIN pa\xc5\xa1tas I\xc5\xa1si\xc5\xb3sta'
+b'DocType: Program Enrollment',b'Pick/Drop by Guardian',b'Pasirinkite / U\xc5\xbesukite Guardian'
+b'DocType: Crop',b'Planting UOM',b'Sodinimas UOM'
+b'DocType: Account',b'Tax',b'mokestis'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45',b'Not Marked',b'ne\xc5\xbeymimi'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1',b'Opening Invoices Summary',b'S\xc4\x85skait\xc5\xb3 fakt\xc5\xabr\xc5\xb3 atidarymas santrauka'
+b'DocType: Education Settings',b'Education Manager',b'\xc5\xa0vietimo vadybininkas'
+b'DocType: Crop Cycle',b'The minimum length between each plant in the field for optimum growth',b'Ma\xc5\xbeiausias ilgis tarp kiekvieno augalo lauke optimaliam augimui'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Partijomis {0} Prek\xc4\x97 negali b\xc5\xabti atnaujintas naudojant Inventorinis susitaikymo, o ne naudoti Inventorinis \xc4\xafra\xc5\xa1\xc4\x85'"
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Partijomis {0} Prek\xc4\x97 negali b\xc5\xabti atnaujintas naudojant Inventorinis susitaikymo, o ne naudoti Inventorinis \xc4\xafra\xc5\xa1\xc4\x85'"
+b'DocType: Quality Inspection',b'Report Date',b'Ataskaitos data'
+b'DocType: Student',b'Middle Name',b'Antras vardas'
+b'DocType: C-Form',b'Invoices',b'S\xc4\x85skaitos'
+b'DocType: Water Analysis',b'Type of Sample',b'Pavyzd\xc5\xbeio tipas'
+b'DocType: Batch',b'Source Document Name',b'\xc5\xa0altinis Dokumento pavadinimas'
+b'DocType: Batch',b'Source Document Name',b'\xc5\xa0altinis Dokumento pavadinimas'
+b'DocType: Production Plan',b'Get Raw Materials For Production',b'Gauk \xc5\xbealiav\xc4\x85 gamybai'
+b'DocType: Job Opening',b'Job Title',b'Darbo pavadinimas'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84',"b'{0} indicates that {1} will not provide a quotation, but all items \\\n\t\t\t\t\thave been quoted. Updating the RFQ quote status.'","b'{0} rodo, kad {1} nepateiks citatos, bet visi daiktai \\ &quot;buvo cituoti. RFQ citatos statuso atnaujinimas.'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026',b'Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.',b'Did\xc5\xbeiausi m\xc4\x97giniai - {0} jau buvo i\xc5\xa1saugoti paketui {1} ir elementui {2} partijoje {3}.'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125',b'Please Set Supplier Type in Buying Settings.',b'Nurodykite tiek\xc4\x97jo tip\xc4\x85 pirkimo nustatymuose.'
+b'DocType: Manufacturing Settings',b'Update BOM Cost Automatically',b'Atnaujinti BOM kain\xc4\x85 automati\xc5\xa1kai'
+b'DocType: Lab Test',b'Test Name',b'Testo pavadinimas'
+b'apps/erpnext/erpnext/utilities/activation.py +99',b'Create Users',b'Sukurti Vartotojai'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Gram',b'gramas'
+b'DocType: Supplier Scorecard',b'Per Month',b'Per m\xc4\x97nes\xc4\xaf'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433',b'Quantity to Manufacture must be greater than 0.',"b'Kiekis, Gamyba turi b\xc5\xabti didesnis nei 0.'"
+b'DocType: Asset Settings',b'Calculate Prorated Depreciation Schedule Based on Fiscal Year',"b'Apskai\xc4\x8diuokite apskai\xc4\x8diuot\xc4\x85 nusid\xc4\x97v\xc4\x97jimo plan\xc4\x85, pagr\xc4\xafst\xc4\x85 fiskaliniais metais'"
+b'apps/erpnext/erpnext/config/maintenance.py +17',b'Visit report for maintenance call.',b'Aplankykite ataskait\xc4\x85 prie\xc5\xbei\xc5\xabros skambu\xc4\x8dio.'
+b'DocType: Stock Entry',b'Update Rate and Availability',b'Atnaujinti \xc4\xaevertinti ir prieinamumas'
+b'DocType: Stock Settings',b'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.',"b'Procentas jums leid\xc5\xbeiama gauti arba pristatyti daugiau prie\xc5\xa1 u\xc5\xbesakyto kiekio. Pavyzd\xc5\xbeiui: Jei u\xc5\xbesisak\xc4\x97te 100 vienet\xc5\xb3. ir j\xc5\xabs\xc5\xb3 pa\xc5\xa1alpa yra 10%, tada jums yra leid\xc5\xbeiama gauti 110 vienet\xc5\xb3.'"
+b'DocType: POS Customer Group',b'Customer Group',b'Klient\xc5\xb3 grup\xc4\x97'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217',b'Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs',b'Eilut\xc4\x97 # {0}: operacija {1} neu\xc5\xbepildyta u\xc5\xbe {2} gatav\xc5\xb3 preki\xc5\xb3 kiek\xc4\xaf darbo u\xc5\xbesakyme Nr. {3}. Atnaujinkite operacijos b\xc5\xabsen\xc4\x85 per laiko \xc5\xbeurnalus'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Nauja Serija kodas (neprivaloma)'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Nauja Serija kodas (neprivaloma)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201',b'Expense account is mandatory for item {0}',b'Kompensuojamos s\xc4\x85skaitos yra privalomas u\xc5\xbe prek\xc4\x99 {0}'
+b'DocType: BOM',b'Website Description',b'Interneto svetain\xc4\x97 Apra\xc5\xa1ymas'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47',b'Net Change in Equity',b'Grynasis pokytis nuosavo kapitalo'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +220',b'Please cancel Purchase Invoice {0} first',b'Pra\xc5\xa1ome anuliuoti s\xc4\x85skait\xc4\x85-fakt\xc5\xabr\xc4\x85 {0} pirmas'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43',"b'Email Address must be unique, already exists for {0}'","b'Pa\xc5\xa1to adresas turi b\xc5\xabti unikalus, jau egzistuoja {0}'"
+b'DocType: Serial No',b'AMC Expiry Date',b'AMC Galiojimo data'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880',b'Receipt',b'gavimas'
+,b'Sales Register',b'pardavim\xc5\xb3 Registruotis'
+b'DocType: Daily Work Summary Group',b'Send Emails At',b'Si\xc5\xb3sti lai\xc5\xa1kus \xc5\xa0iuo'
+b'DocType: Quotation',b'Quotation Lost Reason',b'Citata Pamir\xc5\xa1ote Prie\xc5\xbeastis'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381',b'Transaction reference no {0} dated {1}',b'Operacijos identifikacinis ne {0} data {1}'
+b'apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5',b'There is nothing to edit.',b'N\xc4\x97ra nieko keisti.'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116',b'Summary for this month and pending activities',b'Santrauka \xc5\xa1\xc4\xaf m\xc4\x97nes\xc4\xaf ir laukiant veikla'
+b'apps/erpnext/erpnext/utilities/user_progress.py +248',"b'Add users to your organization, other than yourself.'","b'Prid\xc4\x97kite naudotoj\xc5\xb3 prie savo organizacijos, i\xc5\xa1skyrus save.'"
+b'DocType: Customer Group',b'Customer Group Name',b'Klient\xc5\xb3 Grup\xc4\x97s pavadinimas'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +109',b'No Customers yet!',b'N\xc4\x97ra Klientai dar!'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +56',b'Cash Flow Statement',b'Pinig\xc5\xb3 sraut\xc5\xb3 ataskaita'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473',b'No material request created',b'Nepateiktas joki\xc5\xb3 svarbi\xc5\xb3 u\xc5\xbeklaus\xc5\xb3'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23',b'Loan Amount cannot exceed Maximum Loan Amount of {0}',b'Paskolos suma negali vir\xc5\xa1yti maksimalios paskolos sumos i\xc5\xa1 {0}'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22',b'License',b'licencija'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491',b'Please remove this Invoice {0} from C-Form {1}',b'Pra\xc5\xa1ome pa\xc5\xa1alinti \xc5\xa1ioje s\xc4\x85skaitoje fakt\xc5\xabroje {0} i\xc5\xa1 C formos {1}'
+b'DocType: Leave Control Panel',"b""Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year""","b'Pra\xc5\xa1ome pasirinkti perkelti skirtum\xc4\x85, jei taip pat norite \xc4\xaftraukti pra\xc4\x97jusius finansinius metus balanso palieka \xc5\xa1i\xc4\x85 fiskalini\xc5\xb3 met\xc5\xb3'"
+b'DocType: GL Entry',b'Against Voucher Type',b'Prie\xc5\xa1 \xc4\x8deki\xc5\xb3 tipas'
+b'DocType: Physician',b'Phone (R)',b'Telefonas (R)'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56',b'Time slots added',b'Laiko laiko intervalai pridedami'
+b'DocType: Item',b'Attributes',b'atributai'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31',b'Enable Template',b'\xc4\xaegalinti \xc5\xa1ablon\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226',b'Please enter Write Off Account',b'Pra\xc5\xa1ome \xc4\xafvesti nura\xc5\xa1yti paskyr\xc4\x85'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71',b'Last Order Date',b'Paskutin\xc4\x97 u\xc5\xbesakymo data'
+b'DocType: Patient',b'B Negative',b'B Neigiamas'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25',b'Maintenance Status has to be Cancelled or Completed to Submit',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros statusas turi b\xc5\xabti at\xc5\xa1auktas arba baigtas pateikti'
+b'DocType: Hotel Room',b'Hotel Room',b'Vie\xc5\xa1bu\xc4\x8dio kambarys'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47',b'Account {0} does not belongs to company {1}',b'S\xc4\x85skaita {0} n\xc4\x97ra siejamas su kompanijos {1}'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884',b'Serial Numbers in row {0} does not match with Delivery Note',b'Serijiniai numeriai {0} eil\xc4\x97s nesutampa su Va\xc5\xbetara\xc5\xa1tis'
+b'DocType: Student',b'Guardian Details',b'&quot;guardian&quot; informacija'
+b'DocType: C-Form',b'C-Form',b'C-Forma'
+b'apps/erpnext/erpnext/config/hr.py +18',b'Mark Attendance for multiple employees',b'Pa\xc5\xbeym\xc4\x97ti Dalyvavimas keli\xc5\xb3 darbuotoj\xc5\xb3'
+b'DocType: Agriculture Task',b'Start Day',b'Prad\xc5\xbeios diena'
+b'DocType: Vehicle',b'Chassis No',b'Va\xc5\xbeiuokl\xc4\x97s N\xc4\x97ra'
+b'DocType: Payment Request',b'Initiated',b'inicijuotas'
+b'DocType: Production Plan Item',b'Planned Start Date',b'Planuojama prad\xc5\xbeios data'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +618',b'Please select a BOM',b'Pasirinkite BOM'
+b'DocType: Purchase Invoice',b'Availed ITC Integrated Tax',b'Pasinaudojo ITC integruotu mokes\xc4\x8diu'
+b'DocType: Serial No',b'Creation Document Type',b'K\xc5\xabrimas Dokumento tipas'
+b'DocType: Project Task',b'View Timesheet',b'\xc5\xbdi\xc5\xabr\xc4\x97ti laiko juost\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54',b'End date must be greater than start date',b'Pabaigos data turi b\xc5\xabti didesn\xc4\x97 u\xc5\xbe prad\xc5\xbeios dat\xc4\x85'
+b'DocType: Leave Type',b'Is Encash',b'Ar inkasuoti'
+b'DocType: Leave Allocation',b'New Leaves Allocated',b'Nauj\xc5\xb3 lap\xc5\xb3 Paskirti'
+b'apps/erpnext/erpnext/controllers/trends.py +269',b'Project-wise data is not available for Quotation',b'Projekt\xc5\xb3 i\xc5\xa1mintingas duomenys n\xc4\x97ra prieinami Citata'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30',b'End on',b'Pabaiskite'
+b'DocType: Project',b'Expected End Date',b'Tikimasi Pabaigos data'
+b'DocType: Budget Account',b'Budget Amount',b'biud\xc5\xbeeto dydis'
+b'DocType: Donor',b'Donor Name',b'Donoro vardas'
+b'DocType: Appraisal Template',b'Appraisal Template Title',b'Vertinimas \xc5\xa0ablonas Pavadinimas'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39',"b""From Date {0} for Employee {1} cannot be before employee's joining Date {2}""",b'Nuo datos {0} Darbuotojo {1} gali b\xc5\xabti ne anks\xc4\x8diau darbuotojo jungianti data {2}'
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +29',b'Commercial',b'prekybos'
+b'DocType: Patient',b'Alcohol Current Use',b'Alkoholio vartojimas'
+b'DocType: Student Admission Program',b'Student Admission Program',b'Student\xc5\xb3 pri\xc4\x97mimo programa'
+b'DocType: Payment Entry',b'Account Paid To',b'S\xc4\x85skaita Paide'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24',b'Parent Item {0} must not be a Stock Item',b'T\xc4\x97v\xc5\xb3 {0} Prek\xc4\x97 turi b\xc5\xabti ne riedmenys'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466',b'Could not submit any Salary Slip <br>\\\n\t\t\tPossible reasons: <br>\\\n\t\t\t1. Net pay is less than 0. <br>\\\n\t\t\t2. Company Email Address specified in employee master is not valid. <br>',b'Nepavyko pateikti jokio atlyginimo u\xc5\xbemokes\xc4\x8dio <br> \\ Galimos prie\xc5\xbeastys: <br> \\ 1. Grynasis atlyginimas yra ma\xc5\xbeesnis nei 0. <br> \\ 2. \xc4\xaemon\xc4\x97s darbuotojo kapitono nurodytas \xc4\xafmon\xc4\x97s el. Pa\xc5\xa1to adresas negalioja. <br>'
+b'apps/erpnext/erpnext/config/selling.py +57',b'All Products or Services.',b'Visi produktus ar paslaugas.'
+b'DocType: Expense Claim',b'More Details',b'Daugiau informacijos'
+b'DocType: Supplier Quotation',b'Supplier Address',b'tiek\xc4\x97jas Adresas'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128',b'{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}',b'{0} biud\xc5\xbeetas paskyra {1} prie\xc5\xa1 {2} {3} yra {4}. Jis bus vir\xc5\xa1yti {5}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695',"b""Row {0}# Account must be of type 'Fixed Asset'""",b'Eilut\xc4\x97s {0} # s\xc4\x85skaita turi b\xc5\xabti tipo &quot;ilgalaikio turto&quot;'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Out Qty',b'i\xc5\xa1 Kiekis'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'and unchcked Disabled in the',b'ir nepakeista. I\xc5\xa1jungta'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41',b'Series is mandatory',b'Serija yra privalomi'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28',b'Financial Services',b'Finansin\xc4\x97s paslaugos'
+b'DocType: Student Sibling',b'Student ID',b'Studento pa\xc5\xbeym\xc4\x97jimas'
+b'apps/erpnext/erpnext/config/projects.py +51',b'Types of activities for Time Logs',b'Veiklos r\xc5\xab\xc5\xa1ys Time \xc4\xaera\xc5\xa1ai'
+b'DocType: Opening Invoice Creation Tool',b'Sales',b'pardavim\xc5\xb3'
+b'DocType: Stock Entry Detail',b'Basic Amount',b'bazinis dydis'
+b'DocType: Training Event',b'Exam',b'Egzaminas'
+b'DocType: Complaint',b'Complaint',b'Skundas'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462',b'Warehouse required for stock Item {0}',b'Sand\xc4\x97li\xc5\xb3 reikalingas akcij\xc5\xb3 punkte {0}'
+b'DocType: Leave Allocation',b'Unused leaves',b'nepanaudoti lapai'
+b'DocType: Patient',b'Alcohol Past Use',b'Alkoholio praeities vartojimas'
+b'DocType: Fertilizer Content',b'Fertilizer Content',b'Tr\xc4\x85\xc5\xa1\xc5\xb3 turinys'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187',b'Cr',b'kr'
+b'DocType: Project Update',b'Problematic/Stuck',b'Problema / pakimba'
+b'DocType: Tax Rule',b'Billing State',b'atsiskaitymo valstyb\xc4\x97'
+b'DocType: Share Transfer',b'Transfer',b'perk\xc4\x97limas'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252',b'Work Order {0} must be cancelled before cancelling this Sales Order',b'Darbo u\xc5\xbesakymas {0} turi b\xc5\xabti at\xc5\xa1auktas prie\xc5\xa1 at\xc5\xa1aukiant \xc5\xa1\xc4\xaf pardavimo u\xc5\xbesakym\xc4\x85'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917',b'Fetch exploded BOM (including sub-assemblies)',b'Paduok sprogo BOM (\xc4\xafskaitant mazgus)'
+b'DocType: Authorization Rule',b'Applicable To (Employee)',b'Taikoma (Darbuotoj\xc5\xb3)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +137',b'Due Date is mandatory',b'Terminas yra privalomi'
+b'apps/erpnext/erpnext/controllers/item_variant.py +82',b'Increment for Attribute {0} cannot be 0',b'Ta\xc5\xa1kinis atributas {0} negali b\xc5\xabti 0'
+b'apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19',b'Rooms Booked',b'Rezervuoti kambariai'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +57',b'Ends On date cannot be before Next Contact Date.',b'Baigiasi Nuo datos negali b\xc5\xabti prie\xc5\xa1 Next Contact Date.'
+b'DocType: Journal Entry',b'Pay To / Recd From',b'Apmok\xc4\x97ti / Recd Nuo'
+b'DocType: Naming Series',b'Setup Series',b'S\xc4\x85ranka serija'
+b'DocType: Payment Reconciliation',b'To Invoice Date',b'Nor\xc4\x97dami s\xc4\x85skaitos fakt\xc5\xabros i\xc5\xa1ra\xc5\xa1ymo data'
+b'DocType: Shareholder',b'Contact HTML',b'Susisiekite su HTML'
+b'apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19',b'Registration fee can not be Zero',b'Registracijos mokestis negali b\xc5\xabti lygus nuliui'
+b'DocType: Disease',b'Treatment Period',b'Gydymo laikotarpis'
+b'apps/erpnext/erpnext/education/api.py +338',b'Result already Submitted',b'Rezultatas jau pateiktas'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +169',b'Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied',b'Rezervuota sand\xc4\x97lis yra privalomas prek\xc4\x97ms {0} pristatytose \xc5\xbealiavose'
+,b'Inactive Customers',b'neaktyv\xc5\xabs Klientai'
+b'DocType: Student Admission Program',b'Maximum Age',b'Did\xc5\xbeiausias am\xc5\xbeius'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28',b'Please wait 3 days before resending the reminder.',"b'Pra\xc5\xa1ome palaukti 3 dienas, kol v\xc4\x97l persi\xc5\xb3site priminim\xc4\x85.'"
+b'DocType: Landed Cost Voucher',b'LCV',b'lengv\xc5\xb3j\xc5\xb3 komercini\xc5\xb3 automobili\xc5\xb3'
+b'DocType: Landed Cost Voucher',b'Purchase Receipts',b'pirkimo kvitai'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29',b'How Pricing Rule is applied?',b'Kaip kainodaros taisykl\xc4\x97 yra taikoma?'
+b'DocType: Stock Entry',b'Delivery Note No',b'Va\xc5\xbetara\xc5\xa1tis N\xc4\x97ra'
+b'DocType: Cheque Print Template',b'Message to show',b'\xc5\xbdinut\xc4\x97 rodoma'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +28',b'Retail',b'Ma\xc5\xbemenin\xc4\x97'
+b'DocType: Student Attendance',b'Absent',b'n\xc4\x97ra'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591',b'Product Bundle',b'Prek\xc4\x97s Rinkinys'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38',b'Unable to find score starting at {0}. You need to have standing scores covering 0 to 100',"b'Ne\xc4\xafmanoma rasti rezultato, pradedant {0}. Turite tur\xc4\x97ti stovin\xc4\x8dius balus, apiman\xc4\x8dius nuo 0 iki 100'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212',b'Row {0}: Invalid reference {1}',b'Eilut\xc4\x97s {0}: Neteisingas nuoroda {1}'
+b'DocType: Purchase Taxes and Charges Template',b'Purchase Taxes and Charges Template',b'Pirkimo mokes\xc4\x8dius bei rinkliavas \xc5\xa1ablon\xc4\x85'
+b'DocType: Timesheet',b'TS-',b'TS-'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61',b'{0} {1}: Either debit or credit amount is required for {2}',b'{0} {1}: Bet debeto ar kredito suma yra reikalingas {2}'
+b'DocType: GL Entry',b'Remarks',b'Pastabos'
+b'DocType: Hotel Room Amenity',b'Hotel Room Amenity',b'Vie\xc5\xa1bu\xc4\x8dio kambario patogumas'
+b'DocType: Payment Entry',b'Account Paid From',b'S\xc4\x85skaita mokama i\xc5\xa1'
+b'DocType: Purchase Order Item Supplied',b'Raw Material Item Code',b'\xc5\xbdaliav\xc5\xb3 punktas kodas'
+b'DocType: Task',b'Parent Task',b'T\xc4\x97v\xc5\xb3 u\xc5\xbeduotis'
+b'DocType: Journal Entry',b'Write Off Based On',b'Nura\xc5\xa1yti remiantis'
+b'apps/erpnext/erpnext/utilities/activation.py +65',b'Make Lead',b'Padaryti \xc5\xa0vinas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112',b'Print and Stationery',b'Spausdinti Kanceliarin\xc4\x97s'
+b'DocType: Stock Settings',b'Show Barcode Field',b'Rodyti Br\xc5\xabk\xc5\xa1ninis kodas laukas'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809',b'Send Supplier Emails',b'Si\xc5\xb3sti Tiek\xc4\x97jo lai\xc5\xa1kus'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96',"b'Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.'","b'Pajamos jau tvarkomi laikotarp\xc4\xaf tarp {0} ir {1}, palikite taikymo laikotarp\xc4\xaf negali b\xc5\xabti tarp \xc5\xa1ios datos interval\xc4\x85.'"
+b'DocType: Chapter Member',b'Leave Reason',b'Palikite Prie\xc5\xbeastis'
+b'DocType: Guardian Interest',b'Guardian Interest',b'glob\xc4\x97jas Pal\xc5\xabkanos'
+b'DocType: Volunteer',b'Availability',b'Prieinamumas'
+b'apps/erpnext/erpnext/config/accounts.py +319',b'Setup default values for POS Invoices',b'Nustatykite POS s\xc4\x85skait\xc5\xb3 fakt\xc5\xabr\xc5\xb3 numatytasis vertes'
+b'apps/erpnext/erpnext/config/hr.py +182',b'Training',b'mokymas'
+b'DocType: Project',b'Time to send',b'Laikas si\xc5\xb3sti'
+b'DocType: Timesheet',b'Employee Detail',b'Darbuotoj\xc5\xb3 detal\xc4\x97s'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 E-mail ID'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 E-mail ID'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68',"b""Next Date's day and Repeat on Day of Month must be equal""",b'B\xc5\xabsima data diena ir Pakartokite M\xc4\x97nesio diena turi b\xc5\xabti lygi'
+b'DocType: Lab Prescription',b'Test Code',b'Bandymo kodas'
+b'apps/erpnext/erpnext/config/website.py +11',b'Settings for website homepage',b'Nustatymai svetain\xc4\x97s puslapyje'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40',b'RFQs are not allowed for {0} due to a scorecard standing of {1}',"b'Parai\xc5\xa1kos d\xc4\x97l RFQ d\xc4\x97l {0} neleid\xc5\xbeiamos, nes rezultat\xc5\xb3 rodymas yra {1}'"
+b'DocType: Job Offer',b'Awaiting Response',b'Laukiama atsakymo'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60',b'Above',b'vir\xc5\xa1'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1466',b'Total Amount {0}',b'Bendra suma {0}'
+b'apps/erpnext/erpnext/controllers/item_variant.py +306',b'Invalid attribute {0} {1}',b'Neteisingas atributas {0} {1}'
+b'DocType: Supplier',b'Mention if non-standard payable account',"b'Pamin\xc4\x97kite, jei nestandartinis mokama s\xc4\x85skaita'"
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25',"b""Please select the assessment group other than 'All Assessment Groups'""",b'Pra\xc5\xa1ome pasirinkti kit\xc4\x85 nei &quot;vis\xc5\xb3 vertinimo grup\xc4\x97s&quot; \xc4\xafvertinimo grup\xc4\x97'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67',b'Row {0}: Cost center is required for an item {1}',b'Eilut\xc4\x97 {0}: reikalingas elementas {1}'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureDate',b'&quot;EcritureDate&quot;'
+b'DocType: Training Event Employee',b'Optional',b'Neprivaloma'
+b'DocType: Salary Slip',b'Earning & Deduction',b'Pelningiausi &amp; i\xc5\xa1skai\xc4\x8diavimas'
+b'DocType: Agriculture Analysis Criteria',b'Water Analysis',b'Vandens analiz\xc4\x97'
+b'DocType: Chapter',b'Region',b'regionas'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38',b'Optional. This setting will be used to filter in various transactions.',b'Neprivaloma. \xc5\xa0is nustatymas bus naudojami filtruoti \xc4\xafvairiais sandoriais.'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110',b'Negative Valuation Rate is not allowed',b'Neigiamas vertinimas Balsuok neleid\xc5\xbeiama'
+b'DocType: Holiday List',b'Weekly Off',b'Savait\xc4\x97s I\xc5\xa1jungtas'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7',b'Reload Linked Analysis',b'Atnaujinti susiet\xc4\x85 analiz\xc4\x99'
+b'DocType: Fiscal Year',"b'For e.g. 2012, 2012-13'","b'D\xc4\x97l pvz 2012, 2012-13'"
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96',b'Provisional Profit / Loss (Credit)',b'Laikinas Pelnas / nuostolis (kreditas)'
+b'DocType: Sales Invoice',b'Return Against Sales Invoice',b'Gr\xc4\xaf\xc5\xbeti Against pardavimo s\xc4\x85skaita-fakt\xc5\xabra'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32',b'Item 5',b'5 punktas'
+b'DocType: Serial No',b'Creation Time',b'Suk\xc5\xabrimo laikas'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62',b'Total Revenue',b'I\xc5\xa1 viso pajam\xc5\xb3'
+b'DocType: Patient',b'Other Risk Factors',b'Kiti rizikos veiksniai'
+b'DocType: Sales Invoice',b'Product Bundle Help',b'Prek\xc4\x97s Rinkinys Pagalba'
+,b'Monthly Attendance Sheet',b'M\xc4\x97nesio Lankomumas lapas'
+b'apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15',b'No record found',b'\xc4\xaera\xc5\xa1\xc5\xb3 rasta'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140',b'Cost of Scrapped Asset',b'I\xc5\xa1laidos metalo lau\xc5\xbe\xc4\x85 turto'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +236',b'{0} {1}: Cost Center is mandatory for Item {2}',b'{0} {1}: Kaina centras yra privalomas punktas {2}'
+b'DocType: Vehicle',b'Policy No',b'politikos N\xc4\x97ra'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686',b'Get Items from Product Bundle',b'Gauti prekes i\xc5\xa1 prek\xc4\x97 Bundle'
+b'DocType: Asset',b'Straight Line',b'Tiesi linija'
+b'DocType: Project User',b'Project User',b'Projekt\xc5\xb3 Vartotojas'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'skilimas'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'skilimas'
+b'DocType: GL Entry',b'Is Advance',b'Ar I\xc5\xa1ankstinis'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21',b'Attendance From Date and Attendance To Date is mandatory',b'Lankomumas I\xc5\xa1 data ir lankomumo data yra privalomi'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +156',"b""Please enter 'Is Subcontracted' as Yes or No""","b'Pra\xc5\xa1ome \xc4\xafvesti &quot;subrangos sutartis&quot;, nes taip ar ne'"
+b'DocType: Item',b'Default Purchase Unit of Measure',b'Numatytasis pirkimo vienetas'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Paskutinis Bendravimas data'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Paskutinis Bendravimas data'
+b'DocType: Sales Team',b'Contact No.',b'Kontaktin\xc4\x97 Nr'
+b'DocType: Bank Reconciliation',b'Payment Entries',b'Apmok\xc4\x97jimo \xc4\xafra\xc5\xa1ai'
+b'DocType: Land Unit',b'Land Unit Details',b'\xc5\xbdem\xc4\x97s vieneto detal\xc4\x97s'
+b'DocType: Land Unit',b'Latitude',b'Platuma'
+b'DocType: Work Order',b'Scrap Warehouse',b'lau\xc5\xbeas sand\xc4\x97lis'
+b'DocType: Work Order',b'Check if material transfer entry is not required',"b'Patikrinkite, ar med\xc5\xbeiaga perdavimo \xc4\xafra\xc5\xa1as nereikia'"
+b'DocType: Work Order',b'Check if material transfer entry is not required',"b'Patikrinkite, ar med\xc5\xbeiaga perdavimo \xc4\xafra\xc5\xa1as nereikia'"
+b'DocType: Program Enrollment Tool',b'Get Students From',b'Gauk Studentai i\xc5\xa1'
+b'apps/erpnext/erpnext/config/learn.py +263',b'Publish Items on Website',b'Paskelbti daiktai tinklalapyje'
+b'apps/erpnext/erpnext/utilities/activation.py +126',b'Group your students in batches',b'Grup\xc4\x97 j\xc5\xabs\xc5\xb3 mokiniai partijomis'
+b'DocType: Authorization Rule',b'Authorization Rule',b'autorizacija taisykl\xc4\x97'
+b'DocType: POS Profile',b'Offline POS Section',b'Offline POS skyrius'
+b'DocType: Sales Invoice',b'Terms and Conditions Details',b'Nuostatos ir s\xc4\x85lygos detal\xc4\x97s'
+b'apps/erpnext/erpnext/templates/generators/item.html +100',b'Specifications',b'specifikacija'
+b'DocType: Sales Taxes and Charges Template',b'Sales Taxes and Charges Template',b'Pardavim\xc5\xb3 Mokes\xc4\x8diai ir rinkliavos \xc5\xa0ablon\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68',b'Total (Credit)',b'I\xc5\xa1 viso (kredit\xc5\xb3)'
+b'DocType: Repayment Schedule',b'Payment Date',b'Mok\xc4\x97jimo diena'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Nauja Serija Kiekis'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Nauja Serija Kiekis'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10',b'Apparel & Accessories',b'Drabu\xc5\xbeiai ir aksesuarai'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91',b'Could not solve weighted score function. Make sure the formula is valid.',"b'Nepavyko i\xc5\xa1spr\xc4\x99sti svorio rezultat\xc5\xb3 funkcijos. \xc4\xaesitikinkite, kad formul\xc4\x97 galioja.'"
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67',b'Number of Order',b'Ta\xc5\xa1k\xc5\xb3 ordino'
+b'DocType: Item Group',b'HTML / Banner that will show on the top of product list.',"b'HTML / reklama, kuri parodys ant produkto s\xc4\x85ra\xc5\xa1o vir\xc5\xa1uje.'"
+b'DocType: Shipping Rule',b'Specify conditions to calculate shipping amount',b'Nurodykite s\xc4\x85lygas apskai\xc4\x8diuoti siuntimo sum\xc4\x85'
+b'DocType: Program Enrollment',"b""Institute's Bus""",b'Instituto autobusas'
+b'DocType: Accounts Settings',b'Role Allowed to Set Frozen Accounts & Edit Frozen Entries',b'Vaidmuo leid\xc5\xbeiama nustatyti u\xc5\xbe\xc5\xa1aldyt\xc5\xb3 s\xc4\x85skait\xc5\xb3 ir redaguoti \xc5\xa0aldyti \xc4\xafra\xc5\xa1ai'
+b'DocType: Supplier Scorecard Scoring Variable',b'Path',b'Kelias'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28',b'Cannot convert Cost Center to ledger as it has child nodes',"b'Negali konvertuoti Cost centr\xc4\x85 knygoje, nes ji turi vaik\xc5\xb3 mazgai'"
+b'DocType: Production Plan',b'Total Planned Qty',b'Bendras planuojamas kiekis'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68',b'Opening Value',b'atidarymo kaina'
+b'DocType: Salary Detail',b'Formula',b'formul\xc4\x97'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47',b'Serial #',b'Serijinis #'
+b'DocType: Lab Test Template',b'Lab Test Template',b'Laboratorijos bandymo \xc5\xa1ablonas'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +181',b'Sales Account',b'Pardavim\xc5\xb3 s\xc4\x85skaita'
+b'DocType: Purchase Invoice Item',b'Total Weight',b'Bendras svoris'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94',b'Commission on Sales',b'Komisija d\xc4\x97l pardavimo'
+b'DocType: Job Offer Term',b'Value / Description',b'Vert\xc4\x97 / Apra\xc5\xa1ymas'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +630',"b'Row #{0}: Asset {1} cannot be submitted, it is already {2}'","b'Eilut\xc4\x97s # {0}: Turto {1} negali b\xc5\xabti pateikti, tai jau {2}'"
+b'DocType: Tax Rule',b'Billing Country',b'atsiskaitymo \xc5\xa0alis'
+b'DocType: Purchase Order Item',b'Expected Delivery Date',b'Numatomas pristatymo datos'
+b'DocType: Restaurant Order Entry',b'Restaurant Order Entry',b'Restorano u\xc5\xbesakymo \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +134',b'Debit and Credit not equal for {0} #{1}. Difference is {2}.',b'Debeto ir kredito n\xc4\x97ra vienoda {0} # {1}. Skirtumas yra {2}.'
+b'DocType: Asset Maintenance Task',b'Assign To Name',b'Priskirti vardui'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98',b'Entertainment Expenses',b'Reprezentacin\xc4\x97s i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98',b'Make Material Request',b'Padaryti Material u\xc5\xbeklausa'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20',b'Open Item {0}',b'Atviras punktas {0}'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222',b'Sales Invoice {0} must be cancelled before cancelling this Sales Order',b'Pardavim\xc5\xb3 s\xc4\x85skaita fakt\xc5\xabra {0} turi b\xc5\xabti at\xc5\xa1auktas iki at\xc5\xa1aukti \xc5\xa1\xc4\xaf pardavimo u\xc5\xbesakym\xc5\xb3'
+b'DocType: Consultation',b'Age',b'am\xc5\xbeius'
+b'DocType: Sales Invoice Timesheet',b'Billing Amount',b'atsiskaitymo suma'
+b'DocType: Cash Flow Mapping',b'Select Maximum Of 1',b'Pasirinkite maksimal\xc5\xb3 i\xc5\xa1 1'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84',b'Invalid quantity specified for item {0}. Quantity should be greater than 0.',b'nurodyta u\xc5\xbe prek\xc4\x99 Neteisingas kiekis {0}. Kiekis tur\xc4\x97t\xc5\xb3 b\xc5\xabti didesnis nei 0.'
+b'DocType: Company',b'Default Employee Advance Account',b'Numatytasis darbuotojo i\xc5\xa1ankstinis s\xc4\x85skaita'
+b'apps/erpnext/erpnext/config/hr.py +60',b'Applications for leave.',b'Parai\xc5\xa1kos atostogas.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +164',b'Account with existing transaction can not be deleted',b'S\xc4\x85skaita su esamais sandoris negali b\xc5\xabti i\xc5\xa1brauktas'
+b'DocType: Vehicle',b'Last Carbon Check',b'Paskutinis Anglies Atvykimas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102',b'Legal Expenses',b'teisin\xc4\x97s i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140',b'Please select quantity on row ',b'Pra\xc5\xa1ome pasirinkti kiek\xc4\xaf ant eil\xc4\x97je'
+b'apps/erpnext/erpnext/config/accounts.py +277',b'Make Opening Sales and Purchase Invoices',b'Atlikti pardavimo ir pirkimo s\xc4\x85skaitas fakt\xc5\xabras'
+b'DocType: Purchase Invoice',b'Posting Time',b'Siun\xc4\x8diamos laikas'
+b'DocType: Timesheet',b'% Amount Billed',b'% Suma \xc4\xaevardintas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118',b'Telephone Expenses',b'telefono i\xc5\xa1laidas'
+b'DocType: Sales Partner',b'Logo',b'logotipas'
+b'DocType: Naming Series',b'Check this if you want to force the user to select a series before saving. There will be no default if you check this.',"b'Pa\xc5\xbeym\xc4\x97kite, jei norite priversti vartotoj\xc4\x85 prie\xc5\xa1 taupymo pasirinkti serij\xc4\x85. Nebus nutyl\xc4\x97jim\xc4\x85, jei jums patikrinti tai.'"
+b'apps/erpnext/erpnext/stock/get_item_details.py +131',b'No Item with Serial No {0}',b'N\xc4\x97ra Prek\xc4\x97 su Serijos Nr {0}'
+b'DocType: Email Digest',b'Open Notifications',b'Atviri Prane\xc5\xa1imai'
+b'DocType: Payment Entry',b'Difference Amount (Company Currency)',b'Skirtumas Suma (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79',b'Direct Expenses',b'tiesiogin\xc4\x97s i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60',b'New Customer Revenue',b'Naujas klientas pajamos'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119',b'Travel Expenses',b'Kelion\xc4\x97s i\xc5\xa1laidos'
+b'DocType: Maintenance Visit',b'Breakdown',b'Palau\xc5\xbeti'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50',b'Add custom field Subscription in the doctype {0}',b'Prid\xc4\x97ti priskirt\xc4\x85 lauko prenumerat\xc4\x85 doctype {0}'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +820',b'Account: {0} with currency: {1} can not be selected',b'S\xc4\x85skaita: {0} su valiutos: {1} negalima pasirinkti'
+b'DocType: Purchase Receipt Item',b'Sample Quantity',b'M\xc4\x97ginio kiekis'
+b'DocType: Manufacturing Settings',"b'Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.'","b'Atnaujinti BOM i\xc5\xa1laidas automati\xc5\xa1kai per planuotoj\xc4\x85, remiantis naujausiu \xc5\xbealiav\xc5\xb3 \xc4\xafvertinimo / kain\xc5\xb3 s\xc4\x85ra\xc5\xa1o norma / paskutine pirkimo norma.'"
+b'DocType: Bank Reconciliation Detail',b'Cheque Date',b'\xc4\x8dekis data'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +50',b'Account {0}: Parent account {1} does not belong to company: {2}',b'S\xc4\x85skaita {0}: T\xc4\x97v\xc5\xb3 s\xc4\x85skait\xc4\x85 {1} nepriklauso \xc4\xafmon\xc4\x97s: {2}'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +106',b'Successfully deleted all transactions related to this company!',"b'S\xc4\x97kmingai i\xc5\xa1trinta visus sandorius, susijusius su \xc5\xa1ios bendrov\xc4\x97s!'"
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27',b'As on Date',b'Kaip ir data'
+b'DocType: Appraisal',b'HR',b'HR'
+b'DocType: Program Enrollment',b'Enrollment Date',b'Pri\xc4\x97mimo data'
+b'DocType: Healthcare Settings',b'Out Patient SMS Alerts',b'I\xc5\xa1eina pacient\xc5\xb3 SMS persp\xc4\x97jimai'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100',b'Probation',b'i\xc5\xa1bandymas'
+b'apps/erpnext/erpnext/config/hr.py +115',b'Salary Components',b'Atlyginimo komponentai'
+b'DocType: Program Enrollment Tool',b'New Academic Year',b'Nauja akademiniai metai'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811',b'Return / Credit Note',b'Preki\xc5\xb3 gr\xc4\x85\xc5\xbeinimas / Kredito Pastaba'
+b'DocType: Stock Settings',b'Auto insert Price List rate if missing',"b'Automatinis \xc4\xafterpti Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as norma, jei tr\xc5\xabksta'"
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +117',b'Total Paid Amount',b'I\xc5\xa1 viso sumok\xc4\x97ta suma'
+b'DocType: GST Settings',b'B2C Limit',b'B2C riba'
+b'DocType: Work Order Item',b'Transferred Qty',b'perkelta Kiekis'
+b'apps/erpnext/erpnext/config/learn.py +11',b'Navigating',b'navigacija'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188',b'Planning',b'planavimas'
+b'DocType: Share Balance',b'Issued',b'i\xc5\xa1duotas'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14',b'Student Activity',b'Student\xc5\xb3 aktyvumas'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80',b'Supplier Id',b'tiek\xc4\x97jas ID'
+b'DocType: Payment Request',b'Payment Gateway Details',b'Mok\xc4\x97jimo \xc5\xa1liuzai detal\xc4\x97s'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276',b'Quantity should be greater than 0',b'Kiekis tur\xc4\x97t\xc5\xb3 b\xc5\xabti didesnis u\xc5\xbe 0'
+b'DocType: Journal Entry',b'Cash Entry',b'Pinigai \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17',"b""Child nodes can be only created under 'Group' type nodes""",b'Vaiko mazgai gali b\xc5\xabti kuriamos tik pagal &quot;grup\xc4\x97&quot; tipo mazg\xc5\xb3'
+b'DocType: Leave Application',b'Half Day Date',b'Pus\xc4\x97 dienos data'
+b'DocType: Academic Year',b'Academic Year Name',b'Akademiniai metai Vardas'
+b'DocType: Sales Partner',b'Contact Desc',b'Kontaktin\xc4\x97 Apra\xc5\xa1ymo'
+b'apps/erpnext/erpnext/config/hr.py +65',"b'Type of leaves like casual, sick etc.'","b'Tipas lap\xc5\xb3 kaip atsitiktinis, serga ir tt'"
+b'DocType: Email Digest',b'Send regular summary reports via Email.',b'Si\xc5\xb3sti reguliarius suvestines ataskaitas elektroniniu pa\xc5\xa1tu.'
+b'DocType: Payment Entry',b'PE-',b'PE-'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282',b'Please set default account in Expense Claim Type {0}',b'Pra\xc5\xa1ome nustatyti numatyt\xc4\x85j\xc4\x85 s\xc4\x85skait\xc4\x85 i\xc5\xa1laid\xc5\xb3 teiginio tipas {0}'
+b'DocType: Assessment Result',b'Student Name',b'Studento vardas'
+b'DocType: Brand',b'Item Manager',b'Prek\xc4\x97 direktorius'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143',b'Payroll Payable',b'Darbo u\xc5\xbemokes\xc4\x8dio Mok\xc4\x97tina'
+b'DocType: Buying Settings',b'Default Supplier Type',b'Numatytasis Tiek\xc4\x97jas tipas'
+b'DocType: Plant Analysis',b'Collection Datetime',b'Kolekcija Datetime'
+b'DocType: Work Order',b'Total Operating Cost',b'I\xc5\xa1 viso eksploatavimo i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171',b'Note: Item {0} entered multiple times',b'Pastaba: Prek\xc4\x97s {0} \xc4\xafvesta kelis kartus'
+b'apps/erpnext/erpnext/config/selling.py +41',b'All Contacts.',b'Visi kontaktai.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Company Abbreviation',b'\xc4\xaemon\xc4\x97s santrumpa'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47',b'User {0} does not exist',b'Vartotojas {0} neegzistuoja'
+b'DocType: Payment Term',b'Day(s) after invoice date',b'Diena (-os) po s\xc4\x85skaitos fakt\xc5\xabros datos'
+b'DocType: Payment Schedule',b'Payment Schedule',b'Mok\xc4\x97jimo planas'
+b'DocType: Subscription',b'SUB-',b'SUB-'
+b'DocType: Item Attribute Value',b'Abbreviation',b'santrumpa'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195',b'Payment Entry already exists',b'Mok\xc4\x97jimo \xc4\xafra\xc5\xa1as jau yra'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36',b'Not authroized since {0} exceeds limits',b'Ne authroized nuo {0} vir\xc5\xa1ija ribas'
+b'apps/erpnext/erpnext/config/hr.py +110',b'Salary template master.',b'Pajamos \xc5\xa1ablonas meistras.'
+b'apps/erpnext/erpnext/healthcare/setup.py +241',b'Pathology',b'Patologija'
+b'DocType: Restaurant Order Entry',b'Restaurant Table',b'Restorano stalas'
+b'DocType: Hotel Room',b'Hotel Manager',b'Vie\xc5\xa1bu\xc4\x8di\xc5\xb3 vadybininkas'
+b'DocType: Leave Type',b'Max Days Leave Allowed',b'Maksimalus dien\xc5\xb3 atostogas Leido'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63',b'Set Tax Rule for shopping cart',b'Nustatyti Mokes\xc4\x8di\xc5\xb3 taisykl\xc4\x97 krep\xc5\xa1el\xc4\xaf'
+b'DocType: Purchase Invoice',b'Taxes and Charges Added',b'Mokes\xc4\x8diai ir rinkliavos Prid\xc4\x97ta'
+,b'Sales Funnel',b'pardavim\xc5\xb3 piltuvas'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +49',b'Abbreviation is mandatory',b'Santrumpa yra privalomi'
+b'DocType: Project',b'Task Progress',b'u\xc5\xbeduotis pa\xc5\xbeanga'
+b'apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7',b'Cart',b'krep\xc5\xa1elis'
+,b'Qty to Transfer',b'Kiekis perkelti'
+b'apps/erpnext/erpnext/config/selling.py +13',b'Quotes to Leads or Customers.',b'Citatos klient\xc5\xb3 ar.'
+b'DocType: Stock Settings',b'Role Allowed to edit frozen stock',b'Vaidmuo leid\xc5\xbeiama redaguoti \xc5\xa1aldyt\xc4\x85 \xc5\xbealiav\xc4\x85'
+,b'Territory Target Variance Item Group-Wise',b'Teritorija Tikslin\xc4\x97 Dispersija punktas grup\xc4\x97-I\xc5\xa1min\xc4\x8dius'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143',b'All Customer Groups',b'Visi klient\xc5\xb3 grup\xc4\x97ms'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114',b'Accumulated Monthly',b'sukauptas M\xc4\x97nesio'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +781',b'{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.',b'{0} yra privalomas. Gal Valiut\xc5\xb3 \xc4\xafra\xc5\xa1as n\xc4\x97ra sukurtas {1} ir {2}.'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44',b'Tax Template is mandatory.',b'Mokes\xc4\x8di\xc5\xb3 \xc5\xa1ablonas yra privalomi.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +44',b'Account {0}: Parent account {1} does not exist',b'S\xc4\x85skaita {0}: T\xc4\x97v\xc5\xb3 s\xc4\x85skait\xc4\x85 {1} neegzistuoja'
+b'DocType: Purchase Invoice Item',b'Price List Rate (Company Currency)',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as greitis (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Products Settings',b'Products Settings',b'produktai Nustatymai'
+,b'Item Price Stock',b'Prek\xc4\x97s kaina akcij\xc5\xb3'
+b'DocType: Lab Prescription',b'Test Created',b'Testas sukurtas'
+b'DocType: Healthcare Settings',b'Custom Signature in Print',b'Pasirinktinis para\xc5\xa1as spausdinti'
+b'DocType: Account',b'Temporary',b'laikinas'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +107',b'Customer LPO No.',b'Kliento LPO Nr.'
+b'DocType: Program',b'Courses',b'kursai'
+b'DocType: Monthly Distribution Percentage',b'Percentage Allocation',b'procentas paskirstymas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128',b'Secretary',b'sekretorius'
+b'DocType: Global Defaults',"b""If disable, 'In Words' field will not be visible in any transaction""",b'Jei i\xc5\xa1jungti &quot;\xc5\xbeod\xc5\xbeiais&quot; srityje nebus matomas bet koks sandoris'
+b'DocType: Serial No',b'Distinct unit of an Item',b'Skirtingai vienetas element\xc4\x85'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Name',b'Kriterijos pavadinimas'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295',b'Please set Company',b'Pra\xc5\xa1ome nurodyti Company'
+b'DocType: Pricing Rule',b'Buying',b'pirkimas'
+b'apps/erpnext/erpnext/config/agriculture.py +24',b'Diseases & Fertilizers',b'Ligos ir tr\xc4\x85\xc5\xa1os'
+b'DocType: HR Settings',b'Employee Records to be created by',b'Darbuotoj\xc5\xb3 \xc4\xaera\xc5\xa1ai turi b\xc5\xabti sukurtas'
+b'DocType: Patient',b'AB Negative',b'AB Neigiamas'
+b'DocType: Sample Collection',b'SMPL-',b'SMPL-'
+b'DocType: POS Profile',b'Apply Discount On',b'Taikyti nuolaid\xc4\x85'
+b'DocType: Member',b'Membership Type',b'Naryst\xc4\x97s tipas'
+,b'Reqd By Date',b'Reqd Pagal dat\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140',b'Creditors',b'kreditoriai'
+b'DocType: Assessment Plan',b'Assessment Name',b'vertinimas Vardas'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94',b'Show PDC in Print',b'Rodyti PDC spausdintuvu'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97',b'Row # {0}: Serial No is mandatory',b'Eilut\xc4\x97s # {0}: Serijos Nr privaloma'
+b'DocType: Purchase Taxes and Charges',b'Item Wise Tax Detail',b'Prek\xc4\x97 I\xc5\xa1min\xc4\x8dius Mokes\xc4\x8di\xc5\xb3 detal\xc4\x97s'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13',b'Job Offer',b'Darbo pasi\xc5\xablymas'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Institute Abbreviation',b'institutas santrumpa'
+,b'Item-wise Price List Rate',b'Prek\xc4\x97 i\xc5\xa1mintingas Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as Balsuok'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082',b'Supplier Quotation',b'tiek\xc4\x97jas Citata'
+b'DocType: Quotation',b'In Words will be visible once you save the Quotation.',"b'\xc5\xbdod\xc5\xbeiais bus matomas, kai j\xc5\xabs i\xc5\xa1gelb\xc4\x97ti citatos.'"
+b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Kiekis ({0}) negali b\xc5\xabti i\xc5\xa1 eil\xc4\x97s frakcija {1}'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Kiekis ({0}) negali b\xc5\xabti i\xc5\xa1 eil\xc4\x97s frakcija {1}'
+b'DocType: Consultation',b'C-',b'C-'
+b'DocType: Attendance',b'ATT-',b'ATT-'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +492',b'Barcode {0} already used in Item {1}',b'Br\xc5\xabk\xc5\xa1ninis kodas {0} jau naudojamas prek\xc4\x97s {1}'
+b'apps/erpnext/erpnext/config/selling.py +86',b'Rules for adding shipping costs.',b'Taisykl\xc4\x97s pridedant siuntimo i\xc5\xa1laidas.'
+b'DocType: Hotel Room',b'Extra Bed Capacity',b'Papildomos lovos talpa'
+b'DocType: Item',b'Opening Stock',b'atidarymo sand\xc4\x97lyje'
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20',b'Customer is required',b'Klientas turi'
+b'DocType: Lab Test',b'Result Date',b'Rezultato data'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77',b'PDC/LC Date',b'PDC / LC data'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20',b'{0} is mandatory for Return',b'{0} yra privalomas Gr\xc4\xaf\xc5\xbeti'
+b'DocType: Purchase Order',b'To Receive',b'Gauti'
+b'apps/erpnext/erpnext/utilities/user_progress.py +252',b'user@example.com',b'user@example.com'
+b'DocType: Asset',b'Asset Owner',b'Turto savininkas'
+b'DocType: Employee',b'Personal Email',b'Asmeniniai pa\xc5\xa1tas'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57',b'Total Variance',b'I\xc5\xa1 viso Dispersija'
+b'DocType: Accounts Settings',"b'If enabled, the system will post accounting entries for inventory automatically.'","b'Jei \xc4\xafjungta, sistema bus po apskaitos \xc4\xafra\xc5\xa1us inventoriaus automati\xc5\xa1kai.'"
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15',b'Brokerage',b'tarpininkavimas'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195',b'Attendance for employee {0} is already marked for this day',b'Lankomumas u\xc5\xbe {0} darbuotojas jau yra pa\xc5\xbeym\xc4\x97tas \xc5\xa1iai dienai'
+b'DocType: Work Order Operation',"b""in Minutes\nUpdated via 'Time Log'""",b'minut\xc4\x97mis Atnaujinta per &quot;Time Prisijungti&quot;'
+b'DocType: Customer',b'From Lead',b'nuo \xc5\xa1vino'
+b'apps/erpnext/erpnext/config/manufacturing.py +13',b'Orders released for production.',b'U\xc5\xbesakymai i\xc5\xa1leido gamybai.'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +65',b'Select Fiscal Year...',b'Pasirinkite fiskalini\xc5\xb3 met\xc5\xb3 ...'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567',b'POS Profile required to make POS Entry',"b'POS profilis reikalaujama, kad POS \xc4\xafra\xc5\xa1\xc4\x85'"
+b'DocType: Program Enrollment Tool',b'Enroll Students',b'stoti Studentai'
+b'DocType: Lab Test',b'Approved Date',b'Patvirtinta data'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21',b'Standard Selling',b'Standartin\xc4\x97 Parduodami'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165',b'Atleast one warehouse is mandatory',b'Atleast vienas sand\xc4\x97lis yra privalomas'
+b'DocType: Serial No',b'Out of Warranty',b'I\xc5\xa1 Garantija'
+b'DocType: BOM Update Tool',b'Replace',b'pakeisti'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +42',b'No products found.',b'N\xc4\x97ra preki\xc5\xb3 nerasta.'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360',b'{0} against Sales Invoice {1}',b'{0} prie\xc5\xa1 pardavimo s\xc4\x85skaita-fakt\xc5\xabra {1}'
+b'DocType: Antibiotic',b'Laboratory User',b'Laboratorijos naudotojas'
+b'DocType: Sales Invoice',b'SINV-',b'SINV-'
+b'DocType: Request for Quotation Item',b'Project Name',b'projekto pavadinimas'
+b'DocType: Customer',b'Mention if non-standard receivable account',"b'Nurodyk, jei gautina nestandartinis s\xc4\x85skaita'"
+b'DocType: Journal Entry Account',b'If Income or Expense',b'Jei pajamos ar s\xc4\x85naudos'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288',b'Select interest income account in employee loan {0}',b'Pasirinkite pal\xc5\xabkan\xc5\xb3 pajam\xc5\xb3 s\xc4\x85skait\xc4\x85 darbuotojo paskoloje {0}'
+b'DocType: Work Order',b'Required Items',b'Reikalingi daiktai'
+b'DocType: Stock Ledger Entry',b'Stock Value Difference',b'Akcij\xc5\xb3 vert\xc4\x97s skirtumas'
+b'apps/erpnext/erpnext/config/learn.py +229',b'Human Resource',b'\xc5\xbdmogi\xc5\xa1kieji i\xc5\xa1tekliai'
+b'DocType: Payment Reconciliation Payment',b'Payment Reconciliation Payment',b'Mok\xc4\x97jimo Susitaikymas Mok\xc4\x97jimo'
+b'DocType: Disease',b'Treatment Task',b'Gydymo u\xc5\xbeduotis'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38',b'Tax Assets',b'mokes\xc4\x8dio turtas'
+b'DocType: BOM Item',b'BOM No',b'BOM N\xc4\x97ra'
+b'DocType: Instructor',b'INS/',b'IP /'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160',b'Journal Entry {0} does not have account {1} or already matched against other voucher',b'\xc5\xbdurnalo \xc4\xafra\xc5\xa1\xc4\x85 {0} neturi paskyros {1} arba jau suderinta su kit\xc5\xb3 kupon\xc4\x85'
+b'DocType: Item',b'Moving Average',b'slenkamasis vidurkis'
+b'DocType: BOM Update Tool',b'The BOM which will be replaced',b'BOM kuris bus pakeistas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46',b'Electronic Equipments',b'Elektroniniai \xc4\xafrengimai'
+b'DocType: Asset',b'Maintenance Required',b'Reikalinga technin\xc4\x97 prie\xc5\xbei\xc5\xabra'
+b'DocType: Account',b'Debit',b'debetas'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49',b'Leaves must be allocated in multiples of 0.5',"b'Lapai turi b\xc5\xabti skiriama kartotinus 0,5'"
+b'DocType: Work Order',b'Operation Cost',b'operacijos i\xc5\xa1laidas'
+b'apps/erpnext/erpnext/config/hr.py +29',b'Upload attendance from a .csv file',b'\xc4\xaekelti lankomum\xc4\x85 i\xc5\xa1 .csv fail\xc4\x85'
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45',b'Outstanding Amt',b'ne\xc4\xafvykdyti Amt'
+b'DocType: Sales Person',b'Set targets Item Group-wise for this Sales Person.',b'Nustatyti tikslai punktas grup\xc4\x97-protingas \xc5\xa1iam Pardavim\xc5\xb3 asmeniui.'
+b'DocType: Stock Settings',b'Freeze Stocks Older Than [Days]',b'Freeze Atsargos senesnis nei [diena]'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +600',b'Row #{0}: Asset is mandatory for fixed asset purchase/sale',b'Eilut\xc4\x97s # {0}: turtas yra privalomas ilgalaikio turto pirkimas / pardavimas'
+b'DocType: Asset Maintenance Team',b'Maintenance Team Name',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros komandos pavadinimas'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42',"b'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.'","b'Jei du ar daugiau Kainodaros taisykl\xc4\x97s yra rasta remiantis pirmiau min\xc4\x97t\xc5\xb3 s\xc4\x85lyg\xc5\xb3, pirmenyb\xc4\x97 taikoma. Prioritetas yra skai\xc4\x8dius nuo 0 iki 20, o numatytoji reik\xc5\xa1m\xc4\x97 yra nulis (tu\xc5\xa1\xc4\x8dias). Didesnis skai\xc4\x8dius rei\xc5\xa1kia, kad jis bus vir\xc5\xa1esn\xc4\x97s jei yra keli kainodaros taisykl\xc4\x97s, kuri\xc5\xb3 pa\xc4\x8diomis s\xc4\x85lygomis.'"
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197',"b""Customer is mandatory if 'Opportunity From' is selected as Customer""","b'Klientas yra privalomas, jei pasirinkta kaip &quot;Klientas&quot; i\xc5\xa1 &quot;Galimyb\xc4\x97s&quot;'"
+b'apps/erpnext/erpnext/controllers/trends.py +36',b'Fiscal Year: {0} does not exists',b'Fiskalin\xc4\x97 Metai: {0} neegzistuoja'
+b'DocType: Currency Exchange',b'To Currency',b'valiutos'
+b'DocType: Leave Block List',b'Allow the following users to approve Leave Applications for block days.',b'Leiskite \xc5\xa1ie vartotojai patvirtinti Leave Parai\xc5\xa1kos bendrosios dien\xc5\xb3.'
+b'apps/erpnext/erpnext/config/hr.py +137',b'Types of Expense Claim.',b'Tipai s\xc4\x85skaita reikalavim\xc4\x85.'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'Pardavimo norm\xc4\x85 punkto {0} yra ma\xc5\xbeesnis nei {1}. Pardavimo kursas tur\xc4\x97t\xc5\xb3 b\xc5\xabti atleast {2}'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'Pardavimo norm\xc4\x85 punkto {0} yra ma\xc5\xbeesnis nei {1}. Pardavimo kursas tur\xc4\x97t\xc5\xb3 b\xc5\xabti atleast {2}'
+b'DocType: Item',b'Taxes',b'Mokes\xc4\x8diai'
+b'DocType: Purchase Invoice',b'capital goods',b'kapitalo prek\xc4\x97s'
+b'DocType: Purchase Invoice Item',b'Weight Per Unit',b'Svoris vienetui'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344',b'Paid and Not Delivered',b'Mokama ir neparei\xc5\xa1k\xc4\x97'
+b'DocType: Project',b'Default Cost Center',b'Numatytasis Kaina centras'
+b'DocType: Bank Guarantee',b'End Date',b'pabaigos data'
+b'apps/erpnext/erpnext/config/stock.py +7',b'Stock Transactions',b'Akcij\xc5\xb3 sandoriai'
+b'DocType: Budget',b'Budget Accounts',b'Biud\xc5\xbeetin\xc4\x97se s\xc4\x85skaitose'
+b'DocType: Employee',b'Internal Work History',b'Vidaus darbo istorij\xc4\x85'
+b'DocType: Depreciation Schedule',b'Accumulated Depreciation Amount',b'Sukauptas nusid\xc4\x97v\xc4\x97jimas suma'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42',b'Private Equity',b'Private Equity &quot;'
+b'DocType: Supplier Scorecard Variable',b'Supplier Scorecard Variable',b'Tiek\xc4\x97jo rezultat\xc5\xb3 kortel\xc4\x97s kintamasis'
+b'DocType: Employee Loan',b'Fully Disbursed',b'visi\xc5\xa1kai i\xc5\xa1mok\xc4\x97ta'
+b'DocType: Employee Advance',b'Due Advance Amount',b'Preliminari suma'
+b'DocType: Maintenance Visit',b'Customer Feedback',b'Klient\xc5\xb3 Atsiliepimai'
+b'DocType: Account',b'Expense',b'i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54',b'Score cannot be greater than Maximum Score',b'Rezultatas gali b\xc5\xabti ne didesnis nei maksimalus \xc4\xafvertinimas'
+b'apps/erpnext/erpnext/utilities/user_progress.py +129',b'Customers and Suppliers',b'Klientai ir tiek\xc4\x97jai'
+b'DocType: Item Attribute',b'From Range',b'nuo spektrui'
+b'DocType: BOM',b'Set rate of sub-assembly item based on BOM',b'Nustatykite komponento surinkimo greit\xc4\xaf pagal BOM'
+b'DocType: Hotel Room Reservation',b'Invoiced',b'S\xc4\x85skaitos fakt\xc5\xabros'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98',b'Syntax error in formula or condition: {0}',b'Sintaks\xc4\x97s klaida formulei ar b\xc5\xabkl\xc4\x97s: {0}'
+b'DocType: Daily Work Summary Settings Company',b'Daily Work Summary Settings Company',b'Dienos darbo santrauka Nustatymai \xc4\xaemon\xc4\x97s'
+b'apps/erpnext/erpnext/stock/utils.py +125',b'Item {0} ignored since it is not a stock item',"b'Prek\xc4\x97 {0} ignoruojami, nes tai n\xc4\x97ra sand\xc4\x97lyje punktas'"
+b'DocType: Appraisal',b'APRSL',b'APRSL'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23',"b'To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.'","b'Nor\xc4\x97dami netaikoma kainodaros taisykl\xc4\x97 konkre\xc4\x8diu sandoriu, visos taikomos kainodaros taisykl\xc4\x97s turi b\xc5\xabti i\xc5\xa1jungta.'"
+b'DocType: Payment Term',b'Day(s) after the end of the invoice month',b'Diena (-os) po s\xc4\x85skaitos fakt\xc5\xabros m\xc4\x97nesio pabaigos'
+b'DocType: Assessment Group',b'Parent Assessment Group',b'T\xc4\x97v\xc5\xb3 vertinimas Grup\xc4\x97'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27',b'Jobs',b'Darbas'
+,b'Sales Order Trends',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 tendencijos'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51',"b""The 'From Package No.' field must neither be empty nor it's value less than 1.""",b'&quot;I\xc5\xa1 paketo Nr.&quot; laukas negali b\xc5\xabti tu\xc5\xa1\xc4\x8dias ir jo vert\xc4\x97 yra ma\xc5\xbeesn\xc4\x97 nei 1.'
+b'DocType: Employee',b'Held On',b'vyks'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36',b'Production Item',b'Gamybos punktas'
+,b'Employee Information',b'Darbuotoj\xc5\xb3 Informacija'
+b'DocType: Stock Entry Detail',b'Additional Cost',b'Papildoma Kaina'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48',"b'Can not filter based on Voucher No, if grouped by Voucher'","b'Negali filtruoti pagal lak\xc5\xa1to, jei grupuojamas kupon\xc4\x85'"
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918',b'Make Supplier Quotation',b'Padaryti Tiek\xc4\x97jo Citata'
+b'DocType: Quality Inspection',b'Incoming',b'\xc4\xafeinantis'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +70',b'Default tax templates for sales and purchase are created.',b'Sukuriami numatyti mokes\xc4\x8di\xc5\xb3 \xc5\xa1ablonai pardavimui ir pirkimui.'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57',b'Assessment Result record {0} already exists.',b'Vertinimo rezultat\xc5\xb3 \xc4\xafra\xc5\xa1as {0} jau egzistuoja.'
+b'DocType: BOM',b'Materials Required (Exploded)',"b'Med\xc5\xbeiag\xc5\xb3, reikaling\xc5\xb3 (I\xc5\xa1pjovin\xc4\x97)'"
+b'apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60',"b""Please set Company filter blank if Group By is 'Company'""","b'Pra\xc5\xa1ome nustatyti \xc4\xaemon\xc4\x97s filtruoti tu\xc5\xa1\xc4\x8dias, jei Grupuoti pagal tai &quot;kompanija&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66',b'Posting Date cannot be future date',b'Siun\xc4\x8diamos data negali b\xc5\xabti ateitis data'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102',b'Row # {0}: Serial No {1} does not match with {2} {3}',b'Eilut\xc4\x97s # {0}: Serijos Nr {1} nesutampa su {2} {3}'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'for generating the recurring',b'generuoti pasikartojan\xc4\x8dius'
+b'DocType: Stock Entry',b'Target Warehouse Address',b'Target Warehouse Address'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86',b'Casual Leave',b'Laisvalaikio atostogos'
+b'DocType: Agriculture Task',b'End Day',b'Pabaiga diena'
+b'DocType: Batch',b'Batch ID',b'Serija ID'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380',b'Note: {0}',b'Pastaba: {0}'
+,b'Delivery Note Trends',b'Va\xc5\xbetara\xc5\xa1tis tendencijos'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112',"b""This Week's Summary""",b'\xc5\xa0ios savait\xc4\x97s suvestin\xc4\x97'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22',b'In Stock Qty',b'Sand\xc4\x97lyje Kiekis'
+b'DocType: Delivery Trip',b'Calculate Estimated Arrival Times',b'Apskai\xc4\x8diuokite numatyt\xc4\x85 atvykimo laik\xc4\x85'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +113',b'Account: {0} can only be updated via Stock Transactions',b'S\xc4\x85skaita: {0} gali b\xc5\xabti atnaujintas tik per vertybini\xc5\xb3 popieri\xc5\xb3 sandori\xc5\xb3'
+b'DocType: Student Group Creation Tool',b'Get Courses',b'Gauk kursai'
+b'DocType: GL Entry',b'Party',b'\xc5\xa1alis'
+b'DocType: Healthcare Settings',b'Patient Name',b'Paciento vardas'
+b'DocType: Variant Field',b'Variant Field',b'Variantas laukas'
+b'DocType: Sales Order',b'Delivery Date',b'Pristatymo data'
+b'DocType: Opportunity',b'Opportunity Date',b'galimyb\xc4\x97 data'
+b'DocType: Employee',b'Health Insurance Provider',b'Sveikatos draudimo paslaug\xc5\xb3 teik\xc4\x97jas'
+b'DocType: Purchase Receipt',b'Return Against Purchase Receipt',b'Gr\xc4\xaf\xc5\xbeti Prie\xc5\xa1 pirkimo kvito'
+b'DocType: Water Analysis',b'Person Responsible',b'Atsakingas asmuo'
+b'DocType: Request for Quotation Item',b'Request for Quotation Item',b'U\xc5\xbeklausimas punktas'
+b'DocType: Purchase Order',b'To Bill',b'Bill'
+b'DocType: Material Request',b'% Ordered',b'% U\xc5\xbesakytas'
+b'DocType: Education Settings',"b'For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.'","b'Kurs\xc4\x85, pagr\xc4\xafst\xc4\x85 student\xc5\xb3 grup\xc4\x97s, kurso bus patvirtintas kiekvienas studentas i\xc5\xa1 u\xc5\xbeprogramuoto kursai programoje registracij\xc4\x85.'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103',b'Piecework',b'vienetin\xc4\xaf'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70',b'Avg. Buying Rate',b'Vid. Ie\xc5\xa1ko Balsuok'
+b'DocType: Share Balance',b'From No',b'I\xc5\xa1 Nr'
+b'DocType: Task',b'Actual Time (in Hours)',b'Tikrasis laikas (valandomis)'
+b'DocType: Employee',b'History In Company',b'Istorija Company'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270',b'New Message from {sender}',b'Nauja \xc5\xbeinut\xc4\x97 i\xc5\xa1 {siunt\xc4\x97jo}'
+b'DocType: Customer',b'Customer Primary Address',b'Pirminis kliento adresas'
+b'apps/erpnext/erpnext/config/learn.py +107',b'Newsletters',b'Naujien\xc5\xb3 prenumerata'
+b'DocType: Drug Prescription',b'Description/Strength',b'Apra\xc5\xa1ymas / stiprumas'
+b'DocType: Share Balance',b'Is Company',b'Yra kompanija'
+b'DocType: Stock Ledger Entry',b'Stock Ledger Entry',b'Akcij\xc5\xb3 Ledgeris \xc4\xafra\xc5\xa1as'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83',b'Same item has been entered multiple times',b'Tas pats daiktas buvo \xc4\xafvesta kelis kartus'
+b'DocType: Department',b'Leave Block List',b'Palikite Blokuoti s\xc4\x85ra\xc5\xa1as'
+b'DocType: Purchase Invoice',b'Tax ID',b'Mokes\xc4\x8di\xc5\xb3 ID'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192',b'Item {0} is not setup for Serial Nos. Column must be blank',b'Prek\xc4\x97 {0} n\xc4\x97ra setup Serijos Nr. Skiltis turi b\xc5\xabti tu\xc5\xa1\xc4\x8dias'
+b'DocType: Accounts Settings',b'Accounts Settings',b'S\xc4\x85skaitos Nustatymai'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11',b'Approve',b'patvirtinti'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69',"b'Malformatted address for {0}, please fix to continue.'","b'I\xc5\xa1kabodamas adresas {0}, pra\xc5\xa1ome i\xc5\xa1spr\xc4\x99sti, jei norite t\xc4\x99sti.'"
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28',"b'Number of new Account, it will be included in the account name as a prefix'","b'Naujos s\xc4\x85skaitos numeris, jis bus \xc4\xaftrauktas \xc4\xaf s\xc4\x85skaitos pavadinim\xc4\x85 kaip prefiks\xc4\x85'"
+b'DocType: Maintenance Team Member',b'Team Member',b'Komandos narys'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151',b'No Result to submit',b'N\xc4\x97ra rezultato pateikti'
+b'DocType: Customer',b'Sales Partner and Commission',b'Pardavim\xc5\xb3 partneris ir Komisija'
+b'DocType: Employee Loan',b'Rate of Interest (%) / Year',b'Pal\xc5\xabkan\xc5\xb3 norma (%) / metus'
+,b'Project Quantity',b'Projekt\xc5\xb3 Kiekis'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79',"b""Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'""","b'Viso {0} visoms prek\xc4\x97ms yra lygus nuliui, gali b\xc5\xabti, j\xc5\xabs tur\xc4\x97tum\xc4\x97te pakeisti &quot;Paskirstyti mokes\xc4\x8dius pagal&quot;'"
+b'DocType: Opportunity',b'To Discuss',b'Diskutuoti'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +377',b'{0} units of {1} needed in {2} to complete this transaction.',b'{0} vienetai {1} reikia {2} u\xc5\xbebaigti \xc5\xa1\xc4\xaf sandor\xc4\xaf.'
+b'DocType: Loan Type',b'Rate of Interest (%) Yearly',b'Pal\xc5\xabkan\xc5\xb3 norma (%) Metin\xc4\x97s'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71',b'Temporary Accounts',b'Laikinosios s\xc4\x85skaitos'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207',b'Black',b'juodas'
+b'DocType: BOM Explosion Item',b'BOM Explosion Item',b'BOM sprogimo punktas'
+b'DocType: Shareholder',b'Contact List',b'Kontakt\xc5\xb3 sara\xc5\xa1as'
+b'DocType: Account',b'Auditor',b'auditorius'
+b'DocType: Project',b'Frequency To Collect Progress',"b'Da\xc5\xbenumas, siekiant surinkti pa\xc5\xbeang\xc4\x85'"
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132',b'{0} items produced',b'{0} daiktai gaminami'
+b'apps/erpnext/erpnext/utilities/user_progress.py +58',b'Learn More',b'Su\xc5\xbeinoti daugiau'
+b'DocType: Cheque Print Template',b'Distance from top edge',b'Atstumas nuo vir\xc5\xa1utinio kra\xc5\xa1to'
+b'apps/erpnext/erpnext/stock/get_item_details.py +367',b'Price List {0} is disabled or does not exist',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as {0} yra i\xc5\xa1jungtas arba neegzistuoja'
+b'DocType: Purchase Invoice',b'Return',b'sugr\xc4\xaf\xc5\xbeimas'
+b'DocType: Pricing Rule',b'Disable',b'i\xc5\xa1jungti'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180',b'Mode of payment is required to make a payment',b'mok\xc4\x97jimo b\xc5\xabdas turi atlikti mok\xc4\x97jim\xc4\x85'
+b'DocType: Project Task',b'Pending Review',b'kol ap\xc5\xbevalga'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14',"b'Edit in full page for more options like assets, serial nos, batches etc.'","b'Visame puslapyje redaguokite daugiau pasirink\xc4\x8di\xc5\xb3, pvz., Turto, serijos numeri\xc5\xb3, siunt\xc5\xb3 ir pan.'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10',b'Appointments and Consultations',b'Paskyrimai ir konsultacijos'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41',b'{0} - {1} is not enrolled in the Batch {2}',b'{0} - {1} n\xc4\x97ra \xc4\xaftraukti \xc4\xaf Serij\xc4\x85 {2}'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113',"b'Asset {0} cannot be scrapped, as it is already {1}'","b'Turto {0} negali b\xc5\xabti sunaikintas, nes jis jau yra {1}'"
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77',b'Cheques Required',b'Reikalingi \xc4\x8dekiai'
+b'DocType: Task',b'Total Expense Claim (via Expense Claim)',b'Bendras i\xc5\xa1laid\xc5\xb3 pretenzija (per expense punkt\xc4\x85)'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177',b'Mark Absent',b'Pa\xc5\xbeym\xc4\x97ti N\xc4\x97ra'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40',b'Failed to setup company',b'Nepavyko nustatyti \xc4\xafmon\xc4\x97s'
+b'DocType: Asset Repair',b'Asset Repair',b'Turto remontas'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143',b'Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}',b'Eilut\xc4\x97s {0}: Valiuta BOM # {1} turi b\xc5\xabti lygus pasirinkta valiuta {2}'
+b'DocType: Journal Entry Account',b'Exchange Rate',b'Valiutos kursas'
+b'DocType: Patient',b'Additional information regarding the patient',b'Papildoma informacija apie pacient\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585',b'Sales Order {0} is not submitted',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 {0} nebus pateiktas'
+b'DocType: Homepage',b'Tag Line',b'Gair\xc4\x97 linija'
+b'DocType: Fee Component',b'Fee Component',b'mokestis komponentas'
+b'apps/erpnext/erpnext/config/hr.py +204',b'Fleet Management',b'laivyno valdymo'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080',b'Add items from',b'Prid\xc4\x97ti elementus i\xc5\xa1'
+b'apps/erpnext/erpnext/config/agriculture.py +7',b'Crops & Lands',b'Augalai ir \xc5\xbeem\xc4\x97s sklypai'
+b'DocType: Cheque Print Template',b'Regular',b'reguliarus'
+b'DocType: Fertilizer',b'Density (if liquid)',b'Tankis (jei skystis)'
+b'apps/erpnext/erpnext/education/doctype/course/course.py +20',b'Total Weightage of all Assessment Criteria must be 100%',b'I\xc5\xa1 viso weightage vis\xc5\xb3 vertinimo kriterijai turi b\xc5\xabti 100%'
+b'DocType: Purchase Order Item',b'Last Purchase Rate',b'Paskutinis u\xc5\xbesakymo kaina'
+b'DocType: Account',b'Asset',b'Turtas'
+b'DocType: Project Task',b'Task ID',b'u\xc5\xbeduoties ID'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84',b'Stock cannot exist for Item {0} since has variants',b'Akcij\xc5\xb3 negali egzistuoti u\xc5\xbe prek\xc4\x99 {0} nes turi variantus'
+b'DocType: Lab Test',b'Mobile',b'Mobilus'
+,b'Sales Person-wise Transaction Summary',b'Pardavim\xc5\xb3 Asmuo i\xc5\xa1mintingas Sandorio santrauka'
+b'DocType: Training Event',b'Contact Number',b'Kontaktinis telefono numeris'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73',b'Warehouse {0} does not exist',b'Sand\xc4\x97li\xc5\xb3 {0} neegzistuoja'
+b'DocType: Monthly Distribution',b'Monthly Distribution Percentages',b'M\xc4\x97nesio Paskirstymo Procentai'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +110',b'The selected item cannot have Batch',b'Pasirinktas elementas negali tur\xc4\x97ti Serija'
+b'DocType: Delivery Note',b'% of materials delivered against this Delivery Note',b'% med\xc5\xbeiag\xc5\xb3 pristatyta pagal \xc5\xa1i\xc4\x85 Pristatymo Pa\xc5\xbeym\xc4\x85'
+b'DocType: Asset Maintenance Log',b'Has Certificate',b'Turi sertifikat\xc4\x85'
+b'DocType: Project',b'Customer Details',b'klient\xc5\xb3 informacija'
+b'DocType: Asset',b'Check if Asset requires Preventive Maintenance or Calibration',"b'Patikrinkite, ar turtui reikalinga profilaktin\xc4\x97 prie\xc5\xbei\xc5\xabra ar kalibravimas'"
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +87',b'Company Abbreviation cannot have more than 5 characters',b'\xc4\xaemon\xc4\x97s santrumpa negali b\xc5\xabti daugiau nei 5 simboliai'
+b'DocType: Employee',b'Reports to',b'Prane\xc5\xa1ti'
+,b'Unpaid Expense Claim',b'Nemokamos i\xc5\xa1laid\xc5\xb3 Pretenzija'
+b'DocType: Payment Entry',b'Paid Amount',b'sumok\xc4\x97ta suma'
+b'apps/erpnext/erpnext/utilities/user_progress.py +158',b'Explore Sales Cycle',b'Nar\xc5\xa1yti pardavimo cikl\xc4\x85'
+b'DocType: Assessment Plan',b'Supervisor',b'vadovas'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869',b'Retention Stock Entry',b'Saugojimo atsargos \xc4\xafra\xc5\xa1as'
+,b'Available Stock for Packing Items',b'Turimas sand\xc4\x97lyje pakuoti prek\xc4\x97s'
+b'DocType: Item Variant',b'Item Variant',b'Prek\xc4\x97 variantas'
+,b'Work Order Stock Report',b'Darb\xc5\xb3 u\xc5\xbesakym\xc5\xb3 atsarg\xc5\xb3 ataskaita'
+b'DocType: Assessment Result Tool',b'Assessment Result Tool',b'Vertinimo rezultatas \xc4\xafrankis'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24',b'As Supervisor',b'Kaip vadovas'
+b'DocType: BOM Scrap Item',b'BOM Scrap Item',b'BOM lau\xc5\xbeas punktas'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +895',b'Submitted orders can not be deleted',b'Pateik\xc4\x97 u\xc5\xbesakymai negali b\xc5\xabti i\xc5\xa1trintas'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +114',"b""Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'""","b'S\xc4\x85skaitos likutis jau debeto, jums neleid\xc5\xbeiama nustatyti &quot;Balansas turi b\xc5\xabti&quot; kaip &quot;Kreditas&quot;'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118',b'Quality Management',b'kokyb\xc4\x97s valdymas'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +41',b'Item {0} has been disabled',b'Prek\xc4\x97 {0} buvo i\xc5\xa1jungta'
+b'DocType: Project',b'Total Billable Amount (via Timesheets)',b'Visa apmokestinamoji suma (per laiko lapus)'
+b'DocType: Agriculture Task',b'Previous Business Day',b'Ankstesne darbo diena'
+b'DocType: Employee Loan',b'Repay Fixed Amount per Period',b'Gr\xc4\x85\xc5\xbeinti fiksuotas dydis vienam laikotarpis'
+b'DocType: Employee',b'Health Insurance No',b'Sveikatos draudimas Nr'
+b'apps/erpnext/erpnext/buying/utils.py +47',b'Please enter quantity for Item {0}',b'Pra\xc5\xa1ome \xc4\xafvesti kiek\xc4\xaf punkte {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Credit Note Amt',b'Kredito Pastaba Amt'
+b'DocType: Employee External Work History',b'Employee External Work History',b'Darbuotoj\xc5\xb3 I\xc5\xa1orinis Darbo istorija'
+b'DocType: Opening Invoice Creation Tool',b'Purchase',b'pirkti'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Balance Qty',b'Balansas Kiekis'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20',b'Goals cannot be empty',b'Tikslai negali b\xc5\xabti tu\xc5\xa1\xc4\x8dias'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15',b'Enrolling students',b'\xc4\xaera\xc5\xa1yti studentus'
+b'DocType: Item Group',b'Parent Item Group',b'T\xc4\x97v\xc5\xb3 punktas grup\xc4\x97'
+b'DocType: Appointment Type',b'Appointment Type',b'Paskyrimo tipas'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21',b'{0} for {1}',b'{0} u\xc5\xbe {1}'
+b'DocType: Healthcare Settings',b'Valid number of days',b'Tinkamas dien\xc5\xb3 skai\xc4\x8dius'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +39',b'Cost Centers',b's\xc4\x85naud\xc5\xb3 centrams'
+b'DocType: Land Unit',b'Linked Plant Analysis',b'Susijusi augal\xc5\xb3 analiz\xc4\x97'
+b'DocType: Purchase Receipt',"b""Rate at which supplier's currency is converted to company's base currency""","b'Norma, pagal kuri\xc4\x85 tiek\xc4\x97jas valiuta yra konvertuojamos \xc4\xaf \xc4\xafmon\xc4\x97s bazine valiuta'"
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36',b'Row #{0}: Timings conflicts with row {1}',b'Eilut\xc4\x97s # {0}: laikus prie\xc5\xa1tarauja eil\xc4\x97s {1}'
+b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Leiskite Zero Vertinimo Balsuok'
+b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Leiskite Zero Vertinimo Balsuok'
+b'DocType: Training Event Employee',b'Invited',b'kvie\xc4\x8diami'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178',b'Multiple active Salary Structures found for employee {0} for the given dates',b'Keli darbuotojo {0} nerasta pagal nurodyt\xc4\x85 dat\xc5\xb3 aktyvi\xc5\xb3 Atlyginimo strukt\xc5\xabros'
+b'apps/erpnext/erpnext/config/accounts.py +308',b'Setup Gateway accounts.',b'Parametr\xc5\xb3 Gateway s\xc4\x85skaitos.'
+b'DocType: Employee',b'Employment Type',b'U\xc5\xbeimtumas tipas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42',b'Fixed Assets',b'Ilgalaikis turtas'
+b'DocType: Payment Entry',b'Set Exchange Gain / Loss',b'Nustatyti keitimo pelnas / nuostolis'
+,b'GST Purchase Register',"b'Paai\xc5\xa1k\xc4\x97jo, kad GST Pirkimo Registruotis'"
+,b'Cash Flow',b'Pinig\xc5\xb3 srautas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25',b'Combined invoice portion must equal 100%',b'Kombinuota s\xc4\x85skaitos fakt\xc5\xabros dalis turi b\xc5\xabti lygi 100%'
+b'DocType: Item Group',b'Default Expense Account',b'Numatytasis i\xc5\xa1laid\xc5\xb3 s\xc4\x85skaita'
+b'DocType: GST Account',b'CGST Account',b'CGST s\xc4\x85skaita'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53',b'Student Email ID',b'Student\xc5\xb3 E-mail ID'
+b'DocType: Employee',b'Notice (days)',b'Prane\xc5\xa1imas (dien\xc5\xb3)'
+b'DocType: Tax Rule',b'Sales Tax Template',b'Pardavimo mokestis \xc5\xa0ablono'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2510',b'Select items to save the invoice',b'Pasirinkite elementus i\xc5\xa1saugoti s\xc4\x85skait\xc4\x85 fakt\xc5\xabr\xc4\x85'
+b'DocType: Employee',b'Encashment Date',b'i\xc5\xa1gryninimo data'
+b'DocType: Training Event',b'Internet',b'internetas'
+b'DocType: Special Test Template',b'Special Test Template',b'Specialusis bandomasis \xc5\xa1ablonas'
+b'DocType: Account',b'Stock Adjustment',b'vertybini\xc5\xb3 popieri\xc5\xb3 reguliavimas'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34',b'Default Activity Cost exists for Activity Type - {0}',b'Numatytasis Veiklos s\xc4\x85naudos egzistuoja veiklos r\xc5\xab\xc5\xa1is - {0}'
+b'DocType: Work Order',b'Planned Operating Cost',b'Planuojamas eksploatavimo i\xc5\xa1laidos'
+b'DocType: Academic Term',b'Term Start Date',b'Kadencijos prad\xc5\xbeios data'
+b'apps/erpnext/erpnext/config/accounts.py +471',b'List of all share transactions',b'Vis\xc5\xb3 akcij\xc5\xb3 sandori\xc5\xb3 s\xc4\x85ra\xc5\xa1as'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'opp Grafas'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'opp Grafas'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244',b'Please find attached {0} #{1}',b'Pridedamas {0} # {1}'
+b'apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52',b'Average Rate',b'Vidutin\xc4\x97 norma'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +728',b'Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total',b'Bendra mok\xc4\x97jimo suma mok\xc4\x97jimo grafike turi b\xc5\xabti lygi Grand / Rounded Total'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34',b'Bank Statement balance as per General Ledger',b'Banko pa\xc5\xbeyma likutis vienam General Ledger'
+b'DocType: Job Applicant',b'Applicant Name',b'Vardas parei\xc5\xa1k\xc4\x97jas'
+b'DocType: Authorization Rule',b'Customer / Item Name',b'Klientas / Prek\xc4\x97s pavadinimas'
+b'DocType: Buying Settings',"b'If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt'","b'Jei \xc4\xafjungta, paskutiniai element\xc5\xb3 pirkimo duomenys nebus surinkti i\xc5\xa1 ankstesnio pirkimo u\xc5\xbesakymo ar pirkimo kvito'"
+b'DocType: Product Bundle',"b'Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials'","b'Kompleksin\xc4\x97 grup\xc4\x97 ** daiktai ** \xc4\xaf kit\xc4\x85 ** punkte **. Tai yra naudinga, jei j\xc5\xabs susiejimas tam tikr\xc4\x85 ** daiktai ** \xc4\xaf pakuot\xc4\x99 ir jums i\xc5\xa1laikyti atsargas supakuot\xc5\xb3 ** daiktai **, o ne agregatas ** Element\xc4\x85 **. Paketas ** Prek\xc4\x97s ** tur\xc4\x97s &quot;Ar riedmenys&quot;, kaip &quot;Ne&quot; ir &quot;Ar Pardavim\xc5\xb3 punktas&quot; kaip &quot;Taip&quot;. Pavyzd\xc5\xbeiui: jeigu j\xc5\xabs parduodate Ne\xc5\xa1iojamieji kompiuteriai ir kuprin\xc4\x97s atskirai ir turi ypating\xc4\x85 kain\xc4\x85, jei klientas perka tiek, tada Laptop + kuprin\xc4\x97 bus naujas produktas Rinkinys punktas. Pastaba: BOM = Bill of Materials'"
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42',b'Serial No is mandatory for Item {0}',b'Serijos Nr privaloma punkte {0}'
+b'DocType: Item Variant Attribute',b'Attribute',b'atributas'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43',b'Please specify from/to range',b'Pra\xc5\xa1ome nurodyti nuo / iki svyruoja'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28',b'Opening {0} Invoice created',b'Atidaryta {0} sukurta s\xc4\x85skaita'
+b'DocType: Serial No',b'Under AMC',b'pagal AMC'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55',b'Item valuation rate is recalculated considering landed cost voucher amount',b'Prek\xc4\x97 vertinimas norma perskai\xc4\x8diuojama atsi\xc5\xbevelgiant i\xc5\xa1krauti i\xc5\xa1laid\xc5\xb3 kvito sum\xc4\x85'
+b'apps/erpnext/erpnext/config/selling.py +153',b'Default settings for selling transactions.',b'Numatytieji nustatymai pardavimo sandorius.'
+b'DocType: Guardian',b'Guardian Of ',b'serg\xc4\x97tojos'
+b'DocType: Grading Scale Interval',b'Threshold',b'Slenkstis'
+b'DocType: BOM Update Tool',b'Current BOM',b'Dabartinis BOM'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32',b'Balance (Dr - Cr)',b'Balansas (dr - cr)'
+b'apps/erpnext/erpnext/public/js/utils.js +55',b'Add Serial No',b'Prid\xc4\x97ti Serijos Nr'
+b'DocType: Work Order Item',b'Available Qty at Source Warehouse',b'Turimas Kiekis prie \xc5\xa1altinio Warehouse'
+b'apps/erpnext/erpnext/config/support.py +22',b'Warranty',b'garantija'
+b'DocType: Purchase Invoice',b'Debit Note Issued',b'Debeto Pastaba I\xc5\xa1duotas'
+b'DocType: Work Order',b'Warehouses',b'Sand\xc4\x97liai'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18',b'{0} asset cannot be transferred',b'{0} turtas negali b\xc5\xabti perduotas'
+b'DocType: Hotel Room Pricing',b'Hotel Room Pricing',b'Vie\xc5\xa1bu\xc4\x8di\xc5\xb3 kain\xc5\xb3 nustatymas'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +80',b'This Item is a Variant of {0} (Template).',b'\xc5\xa0is elementas yra {0} (\xc5\xa1ablon\xc5\xb3) variantas.'
+b'DocType: Workstation',b'per hour',b'per valand\xc4\x85'
+b'apps/erpnext/erpnext/config/buying.py +7',b'Purchasing',b'Pirkimas'
+b'DocType: Announcement',b'Announcement',b'skelbimas'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84',b'Customer LPO',b'Kliento LPO'
+b'DocType: Education Settings',"b'For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.'","b'U\xc5\xbd SERIJ\xc5\xb2 remiantis student\xc5\xb3 grup\xc4\x99, studentas Serija bus patvirtintas kiekvienas studentas i\xc5\xa1 programos registracij\xc4\x85.'"
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50',b'Warehouse can not be deleted as stock ledger entry exists for this warehouse.',"b'Sand\xc4\x97li\xc5\xb3 negali b\xc5\xabti i\xc5\xa1brauktas, nes egzistuoja akcij\xc5\xb3 knygos \xc4\xafra\xc5\xa1as \xc5\xa1iame sand\xc4\x97lyje.'"
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +25',b'Distribution',b'pasiskirstymas'
+b'DocType: Expense Claim Advance',b'Expense Claim Advance',b'I\xc5\xa1ankstinio i\xc5\xa1laid\xc5\xb3 reikalavimas'
+b'DocType: Lab Test',b'Report Preference',b'Prane\xc5\xa1imo nuostatos'
+b'apps/erpnext/erpnext/config/non_profit.py +43',b'Volunteer information.',b'Savanorio informacija.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133',b'Project Manager',b'Projekto vadovas'
+,b'Quoted Item Comparison',b'Cituojamas punktas Palyginimas'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34',b'Overlap in scoring between {0} and {1}',b'Pervykimas ta\xc5\xa1k\xc5\xb3 tarp {0} ir {1}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114',b'Dispatch',b'i\xc5\xa1siuntimas'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74',b'Max discount allowed for item: {0} is {1}%',b'Maksimali nuolaida leid\xc5\xbeiama punktu: {0} yra {1}%'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176',b'Net Asset value as on',"b'Grynoji turto vert\xc4\x97, nuo'"
+b'DocType: Crop',b'Produce',b'Gaminti'
+b'DocType: Hotel Settings',b'Default Taxes and Charges',b'Numatytieji mokes\xc4\x8diai ir mokes\xc4\x8diai'
+b'DocType: Account',b'Receivable',b'gautinos'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308',b'Row #{0}: Not allowed to change Supplier as Purchase Order already exists',b'Eilut\xc4\x97s # {0}: Neleid\xc5\xbeiama keisti tiek\xc4\x97jo U\xc5\xbesakymo jau egzistuoja'
+b'DocType: Accounts Settings',b'Role that is allowed to submit transactions that exceed credit limits set.',"b'Vaidmen\xc4\xaf, kur\xc4\xaf leid\xc5\xbeiama pateikti sandorius, kurie vir\xc5\xa1ija nustatytus kredito limitus.'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +989',b'Select Items to Manufacture',b'Pasirinkite prek\xc4\x99 Gamyba'
+b'DocType: Delivery Stop',b'Delivery Stop',b'Pristatymas Stotel\xc4\x97'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +963',"b'Master data syncing, it might take some time'","b'Master Data sinchronizavim\xc4\x85, tai gali u\xc5\xbetrukti \xc5\xa1iek tiek laiko'"
+b'DocType: Item',b'Material Issue',b'med\xc5\xbeiaga i\xc5\xa1davimas'
+b'DocType: Employee Education',b'Qualification',b'kvalifikacija'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42',b'View Salary Slips',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti atlyginimus'
+b'DocType: Item Price',b'Item Price',b'Prek\xc4\x97 Kaina'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48',b'Soap & Detergent',"b'Muilas, skalbimo'"
+b'DocType: BOM',b'Show Items',b'Rodyti preki\xc5\xb3'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30',b'From Time cannot be greater than To Time.',b'Nuo laikas negali b\xc5\xabti didesnis nei laiko.'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92',b'Do you want to notify all the customers by email?',b'Ar norite prane\xc5\xa1ti visiems klientams elektroniniu pa\xc5\xa1tu?'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36',b'Motion Picture & Video',b'Filmavimo ir vaizdo'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5',b'Ordered',b'U\xc5\xbesakytas'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51',b'Resume',b'T\xc4\x99sti'
+b'DocType: Salary Detail',b'Component',b'Komponentas'
+b'DocType: Assessment Criteria',b'Assessment Criteria Group',b'Vertinimo kriterijai grup\xc4\x97'
+b'DocType: Healthcare Settings',b'Patient Name By',b'Paciento vardas'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +72',b'Opening Accumulated Depreciation must be less than equal to {0}',b'Atidarymo Sukauptas nusid\xc4\x97v\xc4\x97jimas turi b\xc5\xabti ma\xc5\xbeesnis arba lygus {0}'
+b'DocType: Warehouse',b'Warehouse Name',b'Sand\xc4\x97li\xc5\xb3 Vardas'
+b'DocType: Naming Series',b'Select Transaction',b'Pasirinkite Sandorio'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30',b'Please enter Approving Role or Approving User',b'Pra\xc5\xa1ome \xc4\xafvesti patvirtinimo vaidmuo arba patvirtinimo vartotoj\xc4\x85'
+b'DocType: Journal Entry',b'Write Off Entry',b'Nura\xc5\xa1yti \xc4\xafra\xc5\xa1\xc4\x85'
+b'DocType: BOM',b'Rate Of Materials Based On',b'Norma med\xc5\xbeiag\xc5\xb3 pagrindu'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21',b'Support Analtyics',b'paramos Analtyics'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102',b'Uncheck all',b'Nuimkite visus'
+b'DocType: POS Profile',b'Terms and Conditions',b'Terminai ir s\xc4\x85lygos'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49',b'To Date should be within the Fiscal Year. Assuming To Date = {0}',"b'Data turi b\xc5\xabti per finansinius metus. Darant prielaid\xc4\x85, kad Nor\xc4\x97dami data = {0}'"
+b'DocType: Employee',"b'Here you can maintain height, weight, allergies, medical concerns etc'","b'\xc4\x8cia galite i\xc5\xa1saugoti \xc5\xabg\xc4\xaf, svor\xc4\xaf, alergijos, medicinos problemas ir tt'"
+b'DocType: Leave Block List',b'Applies to Company',b'Taikoma Company'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231',b'Cannot cancel because submitted Stock Entry {0} exists',"b'Negali at\xc5\xa1aukti, nes pateiktas sand\xc4\x97lyje \xc4\xae\xc4\x97jimo {0} egzistuoja'"
+b'DocType: Employee Loan',b'Disbursement Date',b'i\xc5\xa1mok\xc4\x97jimas data'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80',"b""'Recipients' not specified""","b'""Gav\xc4\x97jai"" nenurodyti'"
+b'DocType: BOM Update Tool',b'Update latest price in all BOMs',b'Atnaujinkite naujausi\xc4\x85 kain\xc4\x85 visose BOM'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23',b'Medical Record',b'Medicininis \xc4\xafra\xc5\xa1as'
+b'DocType: Vehicle',b'Vehicle',b'transporto priemon\xc4\x97'
+b'DocType: Purchase Invoice',b'In Words',b'\xc5\xbdod\xc5\xbeiais'
+b'apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15',b'{0} must be submitted',b'{0} turi b\xc5\xabti pateiktas'
+b'DocType: POS Profile',b'Item Groups',b'Prek\xc4\x97 Grup\xc4\x97s'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +221',"b""Today is {0}'s birthday!""",b'\xc5\xa0iandien {0} gimtadienis!'
+b'DocType: Sales Order Item',b'For Production',b'gamybai'
+b'DocType: Payment Request',b'payment_url',b'payment_url'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186',b'Please add a Temporary Opening account in Chart of Accounts',b'Prid\xc4\x97kite laikin\xc4\x85j\xc4\x85 atidarymo s\xc4\x85skait\xc4\x85 s\xc4\x85skait\xc5\xb3 grafike'
+b'DocType: Customer',b'Customer Primary Contact',b'Pirmasis kliento kontaktas'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154',b'Period Closing Journal',b'Periodo u\xc5\xbedarymo leidinys'
+b'DocType: Project Task',b'View Task',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti U\xc5\xbeduotis'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'Opp / \xc5\xa0vinas%'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'Opp / \xc5\xa0vinas%'
+b'DocType: Material Request',b'MREQ-',b'MREQ-'
+b'DocType: Payment Schedule',b'Invoice Portion',b'S\xc4\x85skaita fakt\xc5\xabra porcija'
+,b'Asset Depreciations and Balances',b'Turto Nusid\xc4\x97v\xc4\x97jimas ir liku\xc4\x8diai'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370',b'Amount {0} {1} transferred from {2} to {3}',b'Suma {0} {1} perkeliamas i\xc5\xa1 {2} \xc4\xaf {3}'
+b'DocType: Sales Invoice',b'Get Advances Received',b'Gauti gaut\xc5\xb3 i\xc5\xa1ankstini\xc5\xb3'
+b'DocType: Email Digest',b'Add/Remove Recipients',b'\xc4\xaed\xc4\x97ti / pa\xc5\xa1alinti gav\xc4\x97jus'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19',"b""To set this Fiscal Year as Default, click on 'Set as Default'""","b'Nor\xc4\x97dami nustatyti \xc5\xa1i\xc4\x85 fiskalini\xc5\xb3 met\xc5\xb3 kaip numatyt\xc4\x85j\xc4\xaf, spustel\xc4\x97kite ant &quot;Set as Default&quot;'"
+b'DocType: Production Plan',b'Include Subcontracted Items',b'\xc4\xaetraukite subrangos elementus'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +220',b'Join',b'prisijungti'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21',b'Shortage Qty',b'tr\xc5\xabkumo Kiekis'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +672',b'Cannot change Variant properties after stock transction. You will have to make a new Item to do this.',"b'Negalima pakeisti variant\xc5\xb3 savybi\xc5\xb3 po atsarg\xc5\xb3 perk\xc4\x97limo. Nor\xc4\x97dami tai padaryti, tur\xc4\x97site padaryti nauj\xc4\x85 punkt\xc4\x85.'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +714',b'Item variant {0} exists with same attributes',b'Prek\xc4\x97 variantas {0} egzistuoja pa\xc4\x8di\xc5\xb3 savybi\xc5\xb3'
+b'DocType: Employee Loan',b'Repay from Salary',b'Gr\xc4\x85\xc5\xbeinti i\xc5\xa1 Pajamos'
+b'DocType: Leave Application',b'LAP/',b'juosmens /'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360',b'Requesting payment against {0} {1} for amount {2}',"b'Pra\xc5\xa1an\xc4\x8dioji mok\xc4\x97jim\xc4\x85 nuo {0} {1} u\xc5\xbe sum\xc4\x85, {2}'"
+b'DocType: Salary Slip',b'Salary Slip',b'Pajamos Kuponas'
+b'DocType: Lead',b'Lost Quotation',b'Pamir\xc5\xa1ote Citata'
+b'apps/erpnext/erpnext/utilities/user_progress.py +221',b'Student Batches',b'Student\xc5\xb3 partijos'
+b'DocType: Pricing Rule',b'Margin Rate or Amount',b'Mar\xc5\xbea norma arba suma'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48',"b""'To Date' is required""","b'""Iki data"" privalomas'"
+b'DocType: Packing Slip',"b'Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.'","b'Sukurti pakavimo lapelius paketai turi b\xc5\xabti pareik\xc5\xa1ta. Naudota prane\xc5\xa1ti pakuot\xc4\x97s numeris, pakuo\xc4\x8di\xc5\xb3 turin\xc4\xaf ir jo svor\xc4\xaf.'"
+b'DocType: Sales Invoice Item',b'Sales Order Item',b'Pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 punktas'
+b'DocType: Salary Slip',b'Payment Days',b'Atsiskaitymo diena'
+b'DocType: Stock Settings',b'Convert Item Description to Clean HTML',"b'Konvertuoti elemento apib\xc5\xabdinim\xc4\x85, norint i\xc5\xa1valyti HTML'"
+b'DocType: Patient',b'Dormant',b'neveikiantis'
+b'DocType: Salary Slip',b'Total Interest Amount',b'Bendra pal\xc5\xabkan\xc5\xb3 suma'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124',b'Warehouses with child nodes cannot be converted to ledger',b'Sand\xc4\x97liai su vaik\xc5\xb3 mazg\xc5\xb3 negali b\xc5\xabti konvertuojamos \xc4\xaf s\xc4\x85skait\xc5\xb3 knygos'
+b'DocType: BOM',b'Manage cost of operations',b'Tvarkyti i\xc5\xa1laidas operacijoms'
+b'DocType: Accounts Settings',b'Stale Days',b'Pasenusios dienos'
+b'DocType: Notification Control',"b'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.'","b'Kai bet kuri i\xc5\xa1 patikrint\xc5\xb3 sandori\xc5\xb3 &quot;Pateik\xc4\x97&quot;, elektroninio pa\xc5\xa1to I\xc5\xa1\xc5\xa1okantis automati\xc5\xa1kai atidaryti si\xc5\xb3sti el.lai\xc5\xa1k\xc4\x85 susijusios &quot;Kontaktai&quot; toje sandorio su sandoriu kaip pried\xc4\x85. Vartotojas gali arba negali si\xc5\xb3sti lai\xc5\xa1k\xc4\x85.'"
+b'apps/erpnext/erpnext/config/setup.py +14',b'Global Settings',b'Bendrosios nuostatos'
+b'DocType: Crop',b'Row Spacing UOM',b'Eilu\xc4\x8di\xc5\xb3 tarpas UOM'
+b'DocType: Assessment Result Detail',b'Assessment Result Detail',b'Vertinimo rezultatas detal\xc4\x97s'
+b'DocType: Employee Education',b'Employee Education',b'Darbuotoj\xc5\xb3 \xc5\xa0vietimas'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53',b'Duplicate item group found in the item group table',b'Dubliuoti punktas grup\xc4\x97 rastas daiktas grup\xc4\x97s lentel\xc4\x97je'
+b'DocType: Land Unit',b'Parent Land Unit',b'T\xc4\x97v\xc5\xb3 \xc5\xbeem\xc4\x97s skyrius'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1113',b'It is needed to fetch Item Details.',"b'Jis reikalingas, kad parsi\xc5\xb3sti I\xc5\xa1samesn\xc4\x97 informacija.'"
+b'DocType: Fertilizer',b'Fertilizer Name',b'Tr\xc4\x85\xc5\xa1\xc5\xb3 pavadinimas'
+b'DocType: Salary Slip',b'Net Pay',b'Grynasis darbo u\xc5\xbemokestis'
+b'DocType: Cash Flow Mapping Accounts',b'Account',b's\xc4\x85skaita'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217',b'Serial No {0} has already been received',b'Serijos Nr {0} jau gavo'
+,b'Requested Items To Be Transferred',b'Pageidaujami daiktai turi b\xc5\xabti perkeltos'
+b'DocType: Expense Claim',b'Vehicle Log',b'Automobilio Prisijungti'
+b'DocType: Vital Signs',b'Presence of a fever (temp &gt; 38.5 \xc2\xb0C/101.3 \xc2\xb0F or sustained temp &gt; 38 \xc2\xb0C/100.4 \xc2\xb0F)',"b'Kar\xc5\xa1\xc4\x8diavimas (temperat\xc5\xabra&gt; 38,5 \xc2\xb0 C / 101,3 \xc2\xb0 F arba i\xc5\xa1laikoma temperat\xc5\xabra&gt; 38 \xc2\xb0 C / 100,4 \xc2\xb0 F)'"
+b'DocType: Customer',b'Sales Team Details',b'Sales Team detal\xc4\x97s'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1352',b'Delete permanently?',b'I\xc5\xa1trinti visam laikui?'
+b'DocType: Expense Claim',b'Total Claimed Amount',b'I\xc5\xa1 viso ie\xc5\xa1kini\xc5\xb3 suma'
+b'apps/erpnext/erpnext/config/crm.py +17',b'Potential opportunities for selling.',b'Galimas galimyb\xc4\x97s pardavin\xc4\x97ti.'
+b'DocType: Shareholder',b'Folio no.',b'Folio Nr.'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246',b'Invalid {0}',b'Neteisingas {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90',b'Sick Leave',b'atostogos d\xc4\x97l ligos'
+b'DocType: Email Digest',b'Email Digest',b'pa\xc5\xa1tas Digest &quot;'
+b'DocType: Delivery Note',b'Billing Address Name',b'Atsiskaitymo Adresas Pavadinimas'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22',b'Department Stores',b'Universalin\xc4\x97s parduotuv\xc4\x97s'
+,b'Item Delivery Date',b'Prek\xc4\x97s pristatymo data'
+b'DocType: Production Plan',b'Material Requested',b'Pra\xc5\xa1oma med\xc5\xbeiaga'
+b'DocType: Warehouse',b'PIN',b'PIN kodas'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116',"b""Error '{0}' occured. Arguments {1}.""",b'Klaida &quot;{0}&quot; \xc4\xafvyko. Argumentai {1}.'
+b'DocType: Bin',b'Reserved Qty for sub contract',b'Rezervuota Kiekis pagal subrangos sutart\xc4\xaf'
+b'DocType: Patient Service Unit',b'Patinet Service Unit',b'Patinet aptarnavimo skyrius'
+b'DocType: Sales Invoice',b'Base Change Amount (Company Currency)',b'Bazin\xc4\x97 Pakeisti Suma (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304',b'No accounting entries for the following warehouses',b'Nieko apskaitos \xc4\xafra\xc5\xa1ai \xc5\xa1iuos sand\xc4\x97lius'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +95',b'Save the document first.',b'I\xc5\xa1saugoti dokument\xc4\x85 pirmas.'
+b'apps/erpnext/erpnext/shopping_cart/cart.py +74',b'Only {0} in stock for item {1}',b'Tik {0} prek\xc4\x97s vienetui {1}'
+b'DocType: Account',b'Chargeable',b'Apmokestinimo'
+b'DocType: Company',b'Change Abbreviation',b'Pakeisti santrumpa'
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66',b'Pay {0} {1}',b'Pay {0} {1}'
+b'DocType: Expense Claim Detail',b'Expense Date',b'Kompensuojamos data'
+b'DocType: Item',b'Max Discount (%)',b'Maksimali nuolaida (%)'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30',b'Credit Days cannot be a negative number',b'Kredit\xc5\xb3 dienos negali b\xc5\xabti neigiamas skai\xc4\x8dius'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70',b'Last Order Amount',b'Paskutin\xc4\x97 u\xc5\xbesakymo suma'
+b'DocType: Cash Flow Mapper',b'e.g Adjustments for:',"b'pvz., koregavimai:'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +275',"b' {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item'","b'{0} I\xc5\xa1saugoti pavyzd\xc4\xaf yra pagr\xc4\xafstas partija, pra\xc5\xa1ome patikrinti, ar turi partijos Nr, kad b\xc5\xabt\xc5\xb3 i\xc5\xa1saugotas prek\xc4\x97s pavyzdys'"
+b'DocType: Task',b'Is Milestone',b'Ar Milestone'
+b'DocType: Delivery Stop',b'Email Sent To',b'Pa\xc5\xa1tas siun\xc4\x8diami'
+b'DocType: Budget',b'Warn',b'\xc4\xafsp\xc4\x97ti'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81',b'Are you sure you want to unregister?',b'Ar tikrai norite atsisakyti registracijos?'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +797',b'All items have already been transferred for this Work Order.',b'Visi daiktai jau buvo perkelti u\xc5\xbe \xc5\xa1\xc4\xaf darbo u\xc5\xbesakym\xc4\x85.'
+b'DocType: Appraisal',"b'Any other remarks, noteworthy effort that should go in the records.'","b'Bet koks kitas pastabas, pa\xc5\xbeym\xc4\x97tina pastang\xc5\xb3, kad reikia eiti \xc4\xaf apskait\xc4\x85.'"
+b'DocType: Asset Maintenance',b'Manufacturing User',b'gamyba Vartotojas'
+b'DocType: Purchase Invoice',b'Raw Materials Supplied',b'\xc5\xbdaliavos Pateikiamas'
+b'DocType: C-Form',b'Series',b'serija'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282',b'Currency of the price list {0} must be {1} or {2}',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1o {0} valiuta turi b\xc5\xabti {1} arba {2}'
+b'DocType: Appraisal',b'Appraisal Template',b'vertinimas \xc5\xa0ablono'
+b'DocType: Soil Texture',b'Ternary Plot',b'Ternary Plot'
+b'DocType: Item Group',b'Item Classification',b'Prek\xc4\x97 klasifikavimas'
+b'DocType: Driver',b'License Number',b'Licencijos numeris'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131',b'Business Development Manager',b'Verslo pl\xc4\x97tros vadybininkas'
+b'DocType: Maintenance Visit Purpose',b'Maintenance Visit Purpose',b'Prie\xc5\xbei\xc5\xabra vizito tikslas'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19',b'Invoice Patient Registration',b'S\xc4\x85skaitos pacient\xc5\xb3 registracija'
+b'DocType: Crop',b'Period',b'laikotarpis'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27',b'General Ledger',b'Bendra Ledgeris'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33',b'Employee {0} on Leave on {1}',b'Darbuotoj\xc5\xb3 {0} atostogose d\xc4\x97l {1}'
+b'apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10',b'View Leads',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti laidai'
+b'DocType: Program Enrollment Tool',b'New Program',b'nauja programa'
+b'DocType: Item Attribute Value',b'Attribute Value',b'Pavadinimas Reik\xc5\xa1m\xc4\x97'
+,b'Itemwise Recommended Reorder Level',b'Itemwise Rekomenduojama Pertvarkyti lygis'
+b'DocType: Salary Detail',b'Salary Detail',b'Pajamos detal\xc4\x97s'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070',b'Please select {0} first',b'Pra\xc5\xa1ome pasirinkti {0} pirmas'
+b'DocType: Appointment Type',b'Physician',b'Gydytojas'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +872',b'Batch {0} of Item {1} has expired.',b'Serija {0} punkto {1} yra pasibaig\xc4\x99s.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11',b'Consultations',b'Konsultacijos'
+b'DocType: Sales Invoice',b'Commission',b'Komisija'
+b'apps/erpnext/erpnext/config/manufacturing.py +27',b'Time Sheet for manufacturing.',b'Laikas lapas gamybai.'
+b'apps/erpnext/erpnext/templates/pages/cart.html +37',b'Subtotal',b'Tarpin\xc4\x97 suma'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +18',b'GoCardless SEPA Mandate',b'&quot;GoCardless&quot; SEPA mandatas'
+b'DocType: Physician',b'Charges',b'Mokes\xc4\x8diai'
+b'DocType: Production Plan',b'Get Items For Work Order',b'Gauti daiktus darbui'
+b'DocType: Salary Detail',b'Default Amount',b'numatytasis dydis'
+b'DocType: Lab Test Template',b'Descriptive',b'Apib\xc5\xabdinamasis'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95',b'Warehouse not found in the system',b'Sand\xc4\x97li\xc5\xb3 nerastas sistemos'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115',"b""This Month's Summary""",b'\xc5\xa0io m\xc4\x97nesio suvestin\xc4\x97'
+b'DocType: Quality Inspection Reading',b'Quality Inspection Reading',b'Kokyb\xc4\x97s inspekcija skaitymas'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25',b'`Freeze Stocks Older Than` should be smaller than %d days.',"b'""U\xc5\xbe\xc5\xa1aldyti atsargas senesnes negu` tur\xc4\x97t\xc5\xb3 b\xc5\xabti ma\xc5\xbeesnis nei% d dien\xc5\xb3.'"
+b'DocType: Tax Rule',b'Purchase Tax Template',b'Pirkimo Mokes\xc4\x8di\xc5\xb3 \xc5\xa1ablon\xc4\x85'
+b'apps/erpnext/erpnext/utilities/user_progress.py +48',"b""Set a sales goal you'd like to achieve for your company.""","b'Nustatykite pardavimo tiksl\xc4\x85, kur\xc4\xaf norite pasiekti savo bendrovei.'"
+,b'Project wise Stock Tracking',b'Projekt\xc5\xb3 protinga sand\xc4\x97lyje sekimo'
+b'DocType: GST HSN Code',b'Regional',b'regioninis'
+b'apps/erpnext/erpnext/config/healthcare.py +40',b'Laboratory',b'Laboratorija'
+b'DocType: Stock Entry Detail',b'Actual Qty (at source/target)',b'Tikrasis Kiekis (bent \xc5\xa1altinio / target)'
+b'DocType: Item Customer Detail',b'Ref Code',b'teis\xc4\x97jas kodas'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75',b'Customer Group is Required in POS Profile',b'Klient\xc5\xb3 grup\xc4\x97 reikalinga POS profil\xc4\xaf'
+b'apps/erpnext/erpnext/config/hr.py +12',b'Employee records.',b'Darbuotoj\xc5\xb3 \xc4\xafra\xc5\xa1us.'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +98',b'Please set Next Depreciation Date',b'Pra\xc5\xa1ome nustatyti Kita nusid\xc4\x97v\xc4\x97jimo data'
+b'DocType: HR Settings',b'Payroll Settings',b'Payroll Nustatymai'
+b'apps/erpnext/erpnext/config/accounts.py +146',b'Match non-linked Invoices and Payments.',b'Rungtyni\xc5\xb3 nesusieti s\xc4\x85skait\xc5\xb3 fakt\xc5\xabr\xc5\xb3 ir mok\xc4\x97jim\xc5\xb3.'
+b'DocType: POS Settings',b'POS Settings',b'POS nustatymai'
+b'apps/erpnext/erpnext/templates/pages/cart.html +16',b'Place Order',b'Vieta U\xc5\xbesakyti'
+b'DocType: Email Digest',b'New Purchase Orders',b'Nauja U\xc5\xbesakym\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24',b'Root cannot have a parent cost center',b'\xc5\xa0akn\xc5\xb3 negali tur\xc4\x97ti t\xc4\x97v\xc5\xb3 ekonomin\xc4\xaf centr\xc4\x85'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +54',b'Select Brand...',b'Pasirinkite prek\xc4\x97s ...'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +32',b'Non Profit (beta)',b'Ne pelno (beta)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18',b'Training Events/Results',b'Mokymo Renginiai / Rezultatai'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152',b'Accumulated Depreciation as on',b'Sukauptas nusid\xc4\x97v\xc4\x97jimas nuo'
+b'DocType: Sales Invoice',b'C-Form Applicable',"b'C-formos, taikomos'"
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438',b'Operation Time must be greater than 0 for Operation {0}',b'Operacijos metu turi b\xc5\xabti didesnis nei 0 darbui {0}'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107',b'Warehouse is mandatory',b'Sand\xc4\x97li\xc5\xb3 yra privalomi'
+b'DocType: Shareholder',b'Address and Contacts',b'Adresas ir kontaktai'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67',b'Failed to create website',b'Nepavyko sukurti svetain\xc4\x97s'
+b'DocType: Soil Analysis',b'Mg/K',b'Mg / K'
+b'DocType: UOM Conversion Detail',b'UOM Conversion Detail',b'UOM konversijos detal\xc4\x97s'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924',b'Retention Stock Entry already created or Sample Quantity not provided',b'Sulaikymo atsarg\xc5\xb3 \xc4\xafra\xc5\xa1as jau sukurtas arba nepateiktas m\xc4\x97ginio kiekis'
+b'DocType: Program',b'Program Abbreviation',b'programos santrumpa'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52',b'Charges are updated in Purchase Receipt against each item',b'Mokes\xc4\x8diai yra atnaujinama pirkimo kvit\xc4\x85 su kiekvieno elemento'
+b'DocType: Warranty Claim',b'Resolved By',b'sprend\xc5\xbeiami'
+b'DocType: Bank Guarantee',b'Start Date',b'Prad\xc5\xbeios data'
+b'apps/erpnext/erpnext/config/hr.py +75',b'Allocate leaves for a period.',b'Skirti lapai laikotarpiui.'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42',b'Cheques and Deposits incorrectly cleared',b'\xc4\x8cekiai ir u\xc5\xbestatai neteisingai i\xc5\xa1valytas'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +46',b'Account {0}: You can not assign itself as parent account',b'S\xc4\x85skaita {0}: J\xc5\xabs negalite priskirti save kaip patronuojan\xc4\x8dios s\xc4\x85skait\xc4\x85'
+b'DocType: Purchase Invoice Item',b'Price List Rate',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as Balsuok'
+b'apps/erpnext/erpnext/utilities/activation.py +72',b'Create customer quotes',b'Sukurti klient\xc5\xb3 citatos'
+b'DocType: Item',"b'Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.'",b'Rodyti &quot;Sand\xc4\x97lyje&quot; arba &quot;n\xc4\x97ra sand\xc4\x97lyje&quot; remiantis sand\xc4\x97lyje turimus \xc5\xa1iame sand\xc4\x97l\xc4\xaf.'
+b'apps/erpnext/erpnext/config/manufacturing.py +38',b'Bill of Materials (BOM)',b'Bilis med\xc5\xbeiagos (BOM)'
+b'DocType: Item',b'Average time taken by the supplier to deliver',"b'Vidutinis laikas, per kur\xc4\xaf tiek\xc4\x97jas pateikia'"
+b'DocType: Sample Collection',b'Collected By',b'Surinkta'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35',b'Assessment Result',b'vertinimo rezultatas'
+b'DocType: Hotel Room Package',b'Hotel Room Package',b'Vie\xc5\xa1bu\xc4\x8dio kambari\xc5\xb3 paketas'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13',b'Hours',b'valandos'
+b'DocType: Project',b'Expected Start Date',"b'Tikimasi, prad\xc5\xbeios data'"
+b'DocType: Purchase Invoice',b'04-Correction in Invoice',b'04-taisymas s\xc4\x85skaitoje fakt\xc5\xabroje'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963',b'Work Order already created for all items with BOM',b'Darb\xc5\xb3 u\xc5\xbesakymas jau sukurtas visiems elementams su BOM'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +60',b'Variant Details Report',b'Variantas i\xc5\xa1samios ataskaitos'
+b'DocType: Setup Progress Action',b'Setup Progress Action',b'&quot;Progress&quot; veiksmo nustatymas'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36',b'Buying Price List',b'Pirkimo kainora\xc5\xa1tis'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49',b'Remove item if charges is not applicable to that item',b'Pa\xc5\xa1alinti element\xc4\x85 jei mokes\xc4\x8diai n\xc4\x97ra taikomi \xc5\xa1io elemento'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21',b'Please select Maintenance Status as Completed or remove Completion Date',b'Pasirinkite technin\xc4\x97s prie\xc5\xbei\xc5\xabros b\xc5\xabsen\xc4\x85 kaip u\xc5\xbebaigt\xc4\x85 arba pa\xc5\xa1alinkite u\xc5\xbebaigimo dat\xc4\x85'
+b'DocType: Supplier',b'Default Payment Terms Template',b'Numatytasis mok\xc4\x97jimo s\xc4\x85lyg\xc5\xb3 \xc5\xa1ablonas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34',b'Transaction currency must be same as Payment Gateway currency',"b'Operacijos valiuta turi b\xc5\xabti toks pat, kaip mok\xc4\x97jimo \xc5\xa1liuzai valiuta'"
+b'DocType: Payment Entry',b'Receive',b'gauti'
+b'apps/erpnext/erpnext/templates/pages/rfq.html +75',b'Quotations: ',b'citatos:'
+b'DocType: Maintenance Visit',b'Fully Completed',b'visi\xc5\xa1kai u\xc5\xbebaigtas'
+b'apps/erpnext/erpnext/projects/doctype/project/project_list.js +6',b'{0}% Complete',b'{0}% U\xc5\xbebaigta'
+b'DocType: Employee',b'Educational Qualification',b'edukacin\xc4\x97 kvalifikacija'
+b'DocType: Workstation',b'Operating Costs',b'Veiklos s\xc4\x85naudos'
+b'DocType: Budget',b'Action if Accumulated Monthly Budget Exceeded',"b'Veiksm\xc5\xb3, jei sukauptos m\xc4\x97nesio biud\xc5\xbeetas Vir\xc5\xa1ytas'"
+b'DocType: Subscription',b'Submit on creation',b'Pateikti steigti'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483',b'Currency for {0} must be {1}',b'Valiuta {0} turi b\xc5\xabti {1}'
+b'DocType: Asset',b'Disposal Date',b'Atliek\xc5\xb3 data'
+b'DocType: Daily Work Summary Settings',"b'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.'","b'Lai\xc5\xa1kai bus siun\xc4\x8diami \xc4\xaf visus aktyvius bendrov\xc4\x97s darbuotojams u\xc5\xbe tam tikr\xc4\x85 valand\xc4\x85, jei jie neturi atostog\xc5\xb3. Atsakym\xc5\xb3 santrauka bus i\xc5\xa1si\xc5\xb3stas vidurnakt\xc4\xaf.'"
+b'DocType: Employee Leave Approver',b'Employee Leave Approver',b'Darbuotoj\xc5\xb3 atostogos Tvirtintojas'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +510',b'Row {0}: An Reorder entry already exists for this warehouse {1}',b'Eilut\xc4\x97s {0}: an Pertvarkyti \xc4\xafra\xc5\xa1as jau yra \xc5\xa1iam sand\xc4\x97l\xc4\xaf {1}'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99',"b'Cannot declare as lost, because Quotation has been made.'","b'Negali paskelbti, kad prarastas, nes Citata buvo padaryta.'"
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16',b'Training Feedback',b'Mokymai Atsiliepimai'
+b'DocType: Supplier Scorecard Criteria',b'Supplier Scorecard Criteria',b'Tiek\xc4\x97jo rezultat\xc5\xb3 vertinimo kriterijai'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149',b'Please select Start Date and End Date for Item {0}',b'Pra\xc5\xa1ome pasirinkti prad\xc5\xbeios ir pabaigos data punkte {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55',b'Course is mandatory in row {0}',"b'\xc5\xbdinoma, yra privalomi eil\xc4\x97s {0}'"
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16',b'To date cannot be before from date',b'Iki \xc5\xa1iol gali b\xc5\xabti ne anks\xc4\x8diau i\xc5\xa1 dienos'
+b'DocType: Supplier Quotation Item',b'Prevdoc DocType',b'Prevdoc dokument\xc5\xb3 tipas'
+b'DocType: Cash Flow Mapper',b'Section Footer',b'Sekcijos pataisa'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +304',b'Add / Edit Prices',b'\xc4\xaed\xc4\x97ti / Redaguoti kainas'
+b'DocType: Batch',b'Parent Batch',b't\xc4\x97v\xc5\xb3 Serija'
+b'DocType: Batch',b'Parent Batch',b't\xc4\x97v\xc5\xb3 Serija'
+b'DocType: Cheque Print Template',b'Cheque Print Template',b'\xc4\x8cekis Spausdinti \xc5\xa0ablono'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36',b'Chart of Cost Centers',b'Schema s\xc4\x85naud\xc5\xb3 centrams'
+b'DocType: Lab Test Template',b'Sample Collection',b'Pavyzd\xc5\xbei\xc5\xb3 rinkinys'
+,b'Requested Items To Be Ordered',b'Pageidaujami Daiktai nurodoma padengti'
+b'apps/erpnext/erpnext/public/js/hub/hub_page.js +137',b'My Orders',b'Mano \xc4\xafsakymai'
+b'DocType: Price List',b'Price List Name',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as vardas'
+b'DocType: BOM',b'Manufacturing',b'gamyba'
+,b'Ordered Items To Be Delivered',b'U\xc5\xbesakytas prekes turi b\xc5\xabti pateikta'
+b'DocType: Account',b'Income',b'Pajamos'
+b'DocType: Industry Type',b'Industry Type',b'pramon\xc4\x97 tipas'
+b'apps/erpnext/erpnext/templates/includes/cart.js +150',b'Something went wrong!',b'Ka\xc5\xbekas atsitiko!'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105',b'Warning: Leave application contains following block dates',b'\xc4\xaesp\xc4\x97jimas: Palikite parai\xc5\xa1koje yra \xc5\xa1ie blokas datos'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275',b'Sales Invoice {0} has already been submitted',b'Pardavim\xc5\xb3 s\xc4\x85skaita fakt\xc5\xabra {0} jau buvo pateikta'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Score',b'rezultatas'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25',b'Fiscal Year {0} does not exist',b'Finansiniai metai {0} neegzistuoja'
+b'DocType: Asset Maintenance Log',b'Completion Date',b'u\xc5\xbebaigimo data'
+b'DocType: Purchase Invoice Item',b'Amount (Company Currency)',b'Suma (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture User',b'\xc5\xbdem\xc4\x97s \xc5\xabkio naudotojas'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38',b'Valid till date cannot be before transaction date',b'Galioja iki datos negali b\xc5\xabti prie\xc5\xa1 sandorio dat\xc4\x85'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +381',b'{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.',b'{0} vienetai {1} reikia {2} \xc4\xaf {3} {4} ir {5} u\xc5\xbebaigti \xc5\xa1\xc4\xaf sandor\xc4\xaf.'
+b'DocType: Fee Schedule',b'Student Category',b'Student\xc5\xb3 Kategorija'
+b'DocType: Announcement',b'Student',b'Studentas'
+b'apps/erpnext/erpnext/config/hr.py +238',b'Organization unit (department) master.',b'Organizavimo skyrius (departamentas) meistras.'
+b'DocType: Shipping Rule',b'Shipping Rule Type',b'Pristatymo taisykl\xc4\x97s tipas'
+b'apps/erpnext/erpnext/utilities/user_progress.py +239',b'Go to Rooms',b'Eikite \xc4\xaf kambarius'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75',b'Please enter message before sending',b'Pra\xc5\xa1ome \xc4\xafvesti \xc5\xbeinut\xc4\x99 prie\xc5\xa1 i\xc5\xa1siun\xc4\x8diant'
+b'DocType: Purchase Invoice',b'DUPLICATE FOR SUPPLIER',b'DUBLIKATAS tiek\xc4\x97jas'
+b'DocType: Email Digest',b'Pending Quotations',b'kol Citatos'
+b'apps/erpnext/erpnext/config/accounts.py +318',b'Point-of-Sale Profile',b'Point-of-Sale profilis'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25',b'{0} should be a value between 0 and 100',b'{0} tur\xc4\x97t\xc5\xb3 b\xc5\xabti vert\xc4\x97 nuo 0 iki 100'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +94',b'Next Depreciation Date cannot be before Available-for-use Date',b'Kitas Nusid\xc4\x97v\xc4\x97jimo data negali b\xc5\xabti ankstesn\xc4\x97 u\xc5\xbe Galimos naudojimo dat\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156',b'Unsecured Loans',b'neu\xc5\xbetikrintas paskolas'
+b'DocType: Cost Center',b'Cost Center Name',b'Kainuos centras vardas'
+b'DocType: Student',b'B+',b'B +'
+b'DocType: HR Settings',b'Max working hours against Timesheet',b'Maksimalus darbo laikas nuo laiko apskaitos \xc5\xbeiniara\xc5\xa1tis'
+b'DocType: Maintenance Schedule Detail',b'Scheduled Date',b'Numatoma data'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +214',b'Total Paid Amt',b'Vis\xc5\xb3 mokam\xc5\xb3 Amt'
+b'DocType: SMS Center',b'Messages greater than 160 characters will be split into multiple messages',b'\xc5\xbdinut\xc4\x97s didesnis nei 160 simboliai bus padalintas \xc4\xaf kelet\xc4\x85 prane\xc5\xa1im\xc5\xb3'
+b'DocType: Purchase Receipt Item',b'Received and Accepted',b'Gavo ir patvirtino'
+b'DocType: Hub Settings',b'Company and Seller Profile',b'\xc4\xaemon\xc4\x97s ir pardav\xc4\x97jo profilis'
+,b'GST Itemised Sales Register',"b'Paai\xc5\xa1k\xc4\x97jo, kad GST Detalios Pardavim\xc5\xb3 Registruotis'"
+b'DocType: Soil Texture',b'Silt Loam',b'Silt Loam'
+,b'Serial No Service Contract Expiry',b'Serijos Nr Paslaug\xc5\xb3 sutarties galiojimo pabaigos'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299',b'You cannot credit and debit same account at the same time',b'J\xc5\xabs negalite Kredito ir debeto pa\xc4\x8di\xc4\x85 s\xc4\x85skait\xc4\x85 tuo pa\xc4\x8diu metu'
+b'DocType: Vital Signs',"b""Adults' pulse rate is anywhere between 50 and 80 beats per minute.""",b'Suaugusi\xc5\xb3j\xc5\xb3 pulso da\xc5\xbenis yra nuo 50 iki 80 sm\xc5\xabgi\xc5\xb3 per minut\xc4\x99.'
+b'DocType: Naming Series',b'Help HTML',b'Pagalba HTML'
+b'DocType: Student Group Creation Tool',b'Student Group Creation Tool',b'Student\xc5\xb3 grup\xc4\x97 k\xc5\xabrimo \xc4\xafrankis'
+b'DocType: Item',b'Variant Based On',b'Variantas remiantis'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53',b'Total weightage assigned should be 100%. It is {0}',b'I\xc5\xa1 viso weightage priskirti turi b\xc5\xabti 100%. Ji yra {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +109',b'Your Suppliers',b'J\xc5\xabs\xc5\xb3 tiek\xc4\x97jai'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'Please correct the',b'Pra\xc5\xa1ome i\xc5\xa1taisyti'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80',b'Cannot set as Lost as Sales Order is made.',b'Negalima nustatyti kaip Pamir\xc5\xa1ote nes yra pagamintas pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3.'
+b'DocType: Request for Quotation Item',b'Supplier Part No',b'Tiek\xc4\x97jas partijos nr'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382',"b""Cannot deduct when category is for 'Valuation' or 'Vaulation and Total'""","b'Negali atskaityti, kai kategorija skirta &quot;Vertinimo&quot; arba &quot;Vaulation ir viso&quot;'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377',b'Received From',b'Gautas nuo'
+b'DocType: Lead',b'Converted',b'Perskai\xc4\x8diuotas'
+b'DocType: Item',b'Has Serial No',b'Turi Serijos Nr'
+b'DocType: Employee',b'Date of Issue',b'I\xc5\xa1leidimo data'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222',"b""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}""","b'Kaip u\xc5\xbe pirkimo parametrus, jei pirkimas \xc4\x8cekio Reikalinga == &quot;Taip&quot;, tada sukurti s\xc4\x85skait\xc4\x85-fakt\xc5\xabr\xc4\x85, vartotojo pirmiausia reikia sukurti pirkimo kvit\xc4\x85 u\xc5\xbe prek\xc4\x99 {0}'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167',b'Row #{0}: Set Supplier for item {1}',b'Eilut\xc4\x97s # {0}: Nustatykite Tiek\xc4\x97jas u\xc5\xbe prek\xc4\x99 {1}'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121',b'Row {0}: Hours value must be greater than zero.',b'Eilut\xc4\x97s {0}: valandos vert\xc4\x97 turi b\xc5\xabti didesn\xc4\x97 u\xc5\xbe nul\xc4\xaf.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +195',b'Website Image {0} attached to Item {1} cannot be found',b'Interneto svetain\xc4\x97 Paveiksl\xc4\x97lis {0} pridedamas prie punkto {1} negali b\xc5\xabti rastas'
+b'DocType: Issue',b'Content Type',b'turinio tipas'
+b'DocType: Asset',b'Assets',b'Turtas'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17',b'Computer',b'Kompiuteris'
+b'DocType: Item',b'List this Item in multiple groups on the website.',b'S\xc4\x85ra\xc5\xa1as \xc5\xa1\xc4\xaf Element\xc4\x85 keliomis grup\xc4\x97mis svetain\xc4\x97je.'
+b'DocType: Payment Term',b'Due Date Based On',b'Terminas pagr\xc4\xafstas'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82',b'Please set default customer group and territory in Selling Settings',b'Nustatykite numatytuosius klient\xc5\xb3 grup\xc4\x97s ir teritorijos nustatymus'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214',b'{0} {1} does not exist',b'{0} {1} neegzistuoja'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323',b'Please check Multi Currency option to allow accounts with other currency',b'Pra\xc5\xa1ome patikrinti Multi Valiuta galimyb\xc4\x99 leisti s\xc4\x85skaitas kita valiuta'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88',b'Item: {0} does not exist in the system',b'Punktas: {0} neegzistuoja sistemoje'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +106',b'You are not authorized to set Frozen value',b'J\xc5\xabs nesate \xc4\xafgaliotas nustatyti Frozen vert\xc4\x99'
+b'DocType: Payment Reconciliation',b'Get Unreconciled Entries',b'Gauk Unreconciled \xc4\xafra\xc5\xa1ai'
+b'DocType: Payment Reconciliation',b'From Invoice Date',b'I\xc5\xa1 s\xc4\x85skaitos fakt\xc5\xabros i\xc5\xa1ra\xc5\xa1ymo data'
+b'DocType: Healthcare Settings',b'Laboratory Settings',b'Laboratoriniai nustatymai'
+b'DocType: Patient Appointment',b'Service Unit',b'Aptarnavimo skyrius'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97',b'Successfully Set Supplier',b'S\xc4\x97kmingai nustatykite tiek\xc4\x97j\xc4\x85'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75',b'Leave Encashment',b'Palikite i\xc5\xa1gryninimo'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +114',b'What does it do?',b'K\xc4\x85 tai daro?'
+b'DocType: Crop',b'Byproducts',b'\xc5\xa0alutiniai produktai'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +84',b'To Warehouse',b'\xc4\xaf sand\xc4\x97l\xc4\xaf'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26',b'All Student Admissions',b'Visi Student\xc5\xb3 Pri\xc4\x97mimo'
+,b'Average Commission Rate',b'Vidutinis Komisija Balsuok'
+b'DocType: Share Balance',b'No of Shares',b'Akcij\xc5\xb3 skai\xc4\x8dius'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +448',"b""'Has Serial No' can not be 'Yes' for non-stock item""","b'""Turi serijin\xc4\xaf Nr."" negali b\xc5\xabti ""Taip"" , daiktui kurio n\xc4\x97ra sandelyje.'"
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59',b'Select Status',b'Pasirinkite b\xc5\xabsen\xc4\x85'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41',b'Attendance can not be marked for future dates',b'Dalyvavimas negali b\xc5\xabti \xc5\xbeenklinami ateities datas'
+b'DocType: Pricing Rule',b'Pricing Rule Help',b'Kainodaros taisykl\xc4\x97 Pagalba'
+b'DocType: School House',b'House Name',b'Namas Vardas'
+b'DocType: Fee Schedule',b'Total Amount per Student',b'Bendra suma studentui'
+b'DocType: Purchase Taxes and Charges',b'Account Head',b's\xc4\x85skaita vadovas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153',b'Electrical',b'elektros'
+b'apps/erpnext/erpnext/utilities/activation.py +100',b'Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts',b'Prid\xc4\x97ti j\xc5\xabs\xc5\xb3 organizacijos pails\xc4\x97ti kaip savo vartotojams. Taip pat galite prid\xc4\x97ti kvie\xc4\x8diame klientus \xc4\xaf j\xc5\xabs\xc5\xb3 portal\xc4\x85 pridedant juos nuo Kontaktai'
+b'DocType: Stock Entry',b'Total Value Difference (Out - In)',b'Viso vert\xc4\x97s skirtumas (i\xc5\xa1 - \xc4\xaf)'
+b'DocType: Grant Application',b'Requested Amount',b'Pra\xc5\xa1oma suma'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348',b'Row {0}: Exchange Rate is mandatory',b'Eilut\xc4\x97s {0}: Valiut\xc5\xb3 kursai yra privalomi'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27',b'User ID not set for Employee {0}',b'Vartotojo ID nenustatyti Darbuotojo {0}'
+b'DocType: Vehicle',b'Vehicle Value',b'Automobilio Vert\xc4\x97'
+b'DocType: Crop Cycle',b'Detected Diseases',b'Aptikta lig\xc5\xb3'
+b'DocType: Stock Entry',b'Default Source Warehouse',b'Numatytasis \xc5\xa0altinis sand\xc4\x97lis'
+b'DocType: Item',b'Customer Code',b'Kliento kodas'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +220',b'Birthday Reminder for {0}',b'Gimimo diena priminimas {0}'
+b'DocType: Asset Maintenance Task',b'Last Completion Date',b'Paskutin\xc4\x97 u\xc5\xbebaigimo data'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72',b'Days Since Last Order',b'Dienas nuo paskutin\xc4\x97 u\xc5\xbesakymo'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365',b'Debit To account must be a Balance Sheet account',b'Debeto s\xc4\x85skait\xc4\x85 turi b\xc5\xabti balansas s\xc4\x85skaitos'
+b'DocType: Buying Settings',b'Naming Series',b'Pavadinim\xc5\xb3 serija'
+b'DocType: GoCardless Settings',b'GoCardless Settings',b'&quot;GoCardless&quot; nustatymai'
+b'DocType: Leave Block List',b'Leave Block List Name',b'Palikite blokuojam\xc5\xb3 s\xc4\x85ra\xc5\xa1\xc4\x85 pavadinimas'
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14',b'Insurance Start date should be less than Insurance End date',b'Draudimo prad\xc5\xbeios data tur\xc4\x97t\xc5\xb3 b\xc5\xabti ne ma\xc5\xbeesn\xc4\x97 nei draudimo pabaigos data'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32',b'Stock Assets',b'Akcij\xc5\xb3 turtas'
+b'DocType: Restaurant',b'Active Menu',b'Aktyvus meniu'
+b'DocType: Target Detail',b'Target Qty',b'Tikslin\xc4\x97 Kiekis'
+b'DocType: Shopping Cart Settings',b'Checkout Settings',b'Vykdyti Nustatymai'
+b'DocType: Student Attendance',b'Present',b'Pateikti'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37',b'Delivery Note {0} must not be submitted',b'Va\xc5\xbetara\xc5\xa1tis {0} negali b\xc5\xabti pateikta'
+b'DocType: Notification Control',b'Sales Invoice Message',b'Pardavim\xc5\xb3 s\xc4\x85skaita fakt\xc5\xabra prane\xc5\xa1imas'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27',b'Closing Account {0} must be of type Liability / Equity',b'U\xc5\xbedarymo Naryst\xc4\x97 {0} turi b\xc5\xabti tipo atsakomyb\xc4\x97s / nuosavas kapitalas'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325',b'Salary Slip of employee {0} already created for time sheet {1}',b'Pajamos Kuponas darbuotojo {0} jau sukurta laiko lape {1}'
+b'DocType: Vehicle Log',b'Odometer',b'odometras'
+b'DocType: Production Plan Item',b'Ordered Qty',b'U\xc5\xbesakytas Kiekis'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +744',b'Item {0} is disabled',b'Prek\xc4\x97 {0} yra i\xc5\xa1jungtas'
+b'DocType: Stock Settings',b'Stock Frozen Upto',b'Akcij\xc5\xb3 \xc5\xa0aldyti upto'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930',b'BOM does not contain any stock item',b'BOM n\xc4\x97ra joki\xc5\xb3 akcij\xc5\xb3 element\xc4\x85'
+b'DocType: Chapter',b'Chapter Head',b'Skyrius vadovas'
+b'DocType: Payment Term',b'Month(s) after the end of the invoice month',b'M\xc4\x97nuo (-os) po s\xc4\x85skaitos fakt\xc5\xabros m\xc4\x97nesio pabaigos'
+b'apps/erpnext/erpnext/config/projects.py +24',b'Project activity / task.',b'Projekto veikla / u\xc5\xbeduotis.'
+b'DocType: Vehicle Log',b'Refuelling Details',b'Degal\xc5\xb3 detal\xc4\x97s'
+b'apps/erpnext/erpnext/config/hr.py +104',b'Generate Salary Slips',b'Sukurti apie atlyginim\xc5\xb3'
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25',b'Lab result datetime cannot be before testing datetime',b'Lab datetime rezultatas negali b\xc5\xabti prie\xc5\xa1 bandym\xc4\x85 datatime'
+b'DocType: POS Profile',b'Allow user to edit Discount',b'Leisti naudotojui redaguoti nuolaid\xc4\x85'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55',b'Get customers from',b'Gaukite klientus i\xc5\xa1'
+b'DocType: Purchase Invoice Item',b'Include Exploded Items',b'\xc4\xaetraukti sprogus elementus'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45',"b'Buying must be checked, if Applicable For is selected as {0}'","b'Ie\xc5\xa1ko turi b\xc5\xabti patikrinta, jei taikoma pasirinkta kaip {0}'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40',b'Discount must be less than 100',b'Nuolaida turi b\xc5\xabti ma\xc5\xbeesnis nei 100'
+b'DocType: Shipping Rule',b'Restrict to Countries',b'Apriboti \xc5\xa1alis'
+b'DocType: Purchase Invoice',b'Write Off Amount (Company Currency)',b'Nura\xc5\xa1yti suma (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Sales Invoice Timesheet',b'Billing Hours',b'Atsiskaitymo laikas'
+b'DocType: Project',b'Total Sales Amount (via Sales Order)',b'Bendra pardavimo suma (per pardavimo u\xc5\xbesakym\xc4\x85)'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +548',b'Default BOM for {0} not found',b'Numatytasis BOM u\xc5\xbe {0} nerastas'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +514',b'Row #{0}: Please set reorder quantity',b'Eilut\xc4\x97s # {0}: Pra\xc5\xa1ome nustatyti pertvarkyti kiek\xc4\xaf'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +20',b'Tap items to add them here',b'Bakstel\xc4\x97kite elementus \xc4\xaftraukti juos \xc4\x8dia'
+b'DocType: Fees',b'Program Enrollment',b'programos \xc4\xaera\xc5\xa1as'
+b'DocType: Share Transfer',b'To Folio No',b'Folio Nr'
+b'DocType: Landed Cost Voucher',b'Landed Cost Voucher',b'Nusileido kaina \xc4\x8dekis'
+b'apps/erpnext/erpnext/public/js/queries.js +39',b'Please set {0}',b'Pra\xc5\xa1ome nustatyti {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} yra neaktyvus studentas'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} yra neaktyvus studentas'
+b'DocType: Employee',b'Health Details',b'sveikatos informacija'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'Nor\xc4\x97dami sukurti mok\xc4\x97jimo pra\xc5\xa1ymas nuoroda dokumentas yra reikalingas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'Nor\xc4\x97dami sukurti mok\xc4\x97jimo pra\xc5\xa1ymas nuoroda dokumentas yra reikalingas'
+b'DocType: Soil Texture',b'Sandy Clay',b'Sm\xc4\x97lio molis'
+b'DocType: Grant Application',b'Assessment  Manager',b'Vertinimo vadovas'
+b'DocType: Payment Entry',b'Allocate Payment Amount',b'Skirti mok\xc4\x97jimo suma'
+b'DocType: Employee External Work History',b'Salary',b'atlyginimas'
+b'DocType: Serial No',b'Delivery Document Type',b'Pristatymas Dokumento tipas'
+b'DocType: Sales Order',b'Partly Delivered',b'dalinai Paskelbta'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48',b'Item Code &gt; Item Group &gt; Brand',b'Prek\xc4\x97s kodas&gt; Prek\xc4\x97s grup\xc4\x97&gt; Gamintojas'
+b'DocType: Item Variant Settings',b'Do not update variants on save',b'Negalima atnaujinti i\xc5\xa1saugojimo variant\xc5\xb3'
+b'DocType: Email Digest',b'Receivables',b'gautinos sumos'
+b'DocType: Lead Source',b'Lead Source',b'\xc5\xa0vinas \xc5\xa0altinis'
+b'DocType: Customer',b'Additional information regarding the customer.',b'Papildoma informacija apie klientui.'
+b'DocType: Quality Inspection Reading',b'Reading 5',b'Skaitymas 5'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236',"b'{0} {1} is associated with {2}, but Party Account is {3}'","b'{0} {1} susij\xc4\x99s su {2}, bet \xc5\xa1alies s\xc4\x85skaita {3}'"
+b'apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7',b'View Lab Tests',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti laboratorijos bandymus'
+b'DocType: Purchase Invoice',b'Y',b'Y'
+b'DocType: Maintenance Visit',b'Maintenance Date',b'prie\xc5\xbei\xc5\xabra data'
+b'DocType: Purchase Invoice Item',b'Rejected Serial No',b'Atmesta Serijos Nr'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82',b'Year start date or end date is overlapping with {0}. To avoid please set company',b'Met\xc5\xb3 prad\xc5\xbeios dat\xc4\x85 arba pabaigos data sutampa su {0}. Nor\xc4\x97dami i\xc5\xa1vengti nustatykite \xc4\xafmon\xc4\x99'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +122',b'Please mention the Lead Name in Lead {0}',b'Pra\xc5\xa1ome pamin\xc4\x97ti \xc5\xa1vino pavadinim\xc4\x85 pirmaujan\xc4\x8dioje {0}'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156',b'Start date should be less than end date for Item {0}',b'Prad\xc5\xbeios data tur\xc4\x97t\xc5\xb3 b\xc5\xabti ma\xc5\xbeesnis nei pabaigos datos punkte {0}'
+b'DocType: Item',"b'Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.'","b'Pavyzdys:. ABCD ##### Jei serija yra nustatytas ir Serijos Nr nepamin\xc4\x97tas sandorius, tada automatinis serijos numeris bus sukurta remiantis \xc5\xa1ios serijos. Jei norite visada ai\xc5\xa1kiai pamin\xc4\x97ti eil\xc4\x97s numeriai \xc5\xa1i\xc4\x85 prek\xc4\x99 n\xc4\x97ra. Palikite \xc5\xa1\xc4\xaf lauk\xc4\x85 tu\xc5\xa1\xc4\x8di\xc4\x85.'"
+b'DocType: Upload Attendance',b'Upload Attendance',b'\xc4\xaekelti Lankomumas'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +579',b'BOM and Manufacturing Quantity are required',b'BOM ir gamyba Kiekis yra privalomi'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50',b'Ageing Range 2',b'Sen\xc4\x97jimas klas\xc4\x97s 2'
+b'DocType: SG Creation Tool Course',b'Max Strength',b'Maksimali j\xc4\x97ga'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28',b'Installing presets',b'I\xc5\xa1 anksto \xc4\xafdiegti'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85',b'No Delivery Note selected for Customer {}',b'Kliento pasirinkta pristatymo pastaba ()'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25',b'BOM replaced',b'BOM pakeisti'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052',b'Select Items based on Delivery Date',b'Pasirinkite elementus pagal pristatymo dat\xc4\x85'
+b'DocType: Grant Application',b'Has any past Grant Record',b'Turi bet kok\xc4\xaf ankstesn\xc4\xaf &quot;Grant Record&quot;'
+,b'Sales Analytics',b'pardavim\xc5\xb3 Analytics &quot;'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127',b'Available {0}',b'Turimas {0}'
+,b'Prospects Engaged But Not Converted',b'Perspektyvos U\xc5\xbesiima Bet nevirsta'
+,b'Prospects Engaged But Not Converted',b'Perspektyvos U\xc5\xbesiima Bet nevirsta'
+b'DocType: Manufacturing Settings',b'Manufacturing Settings',b'Gamybos Nustatymai'
+b'apps/erpnext/erpnext/config/setup.py +56',b'Setting up Email',b'\xc4\xaesteigti pa\xc5\xa1tu'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57',b'Guardian1 Mobile No',b'Guardian1 Mobilus N\xc4\x97ra'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106',b'Please enter default currency in Company Master',b'Pra\xc5\xa1ome \xc4\xafvesti numatytasis valiuta \xc4\xafmon\xc4\x97je Master'
+b'DocType: Stock Entry Detail',b'Stock Entry Detail',b'Akcij\xc5\xb3 \xc4\xafra\xc5\xa1o informacij\xc4\x85'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109',b'Daily Reminders',b'Dienos Priminimai'
+b'DocType: Products Settings',b'Home Page is Products',b'Titulinis puslapis yra Produktai'
+,b'Asset Depreciation Ledger',b'Turto nusid\xc4\x97v\xc4\x97jimas Ledgeris'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91',b'Tax Rule Conflicts with {0}',b'Mokes\xc4\x8di\xc5\xb3 taisykl\xc4\x97 prie\xc5\xa1tarauja {0}'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25',b'New Account Name',b'Nauja S\xc4\x85skaitos pavadinimas'
+b'DocType: Purchase Invoice Item',b'Raw Materials Supplied Cost',b'\xc5\xbdaliavos Pateikiamas Kaina'
+b'DocType: Selling Settings',b'Settings for Selling Module',b'Nustatymai parduoti modulis'
+b'DocType: Hotel Room Reservation',b'Hotel Room Reservation',b'Vie\xc5\xa1bu\xc4\x8di\xc5\xb3 kambario rezervacija'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115',b'Customer Service',b'Klient\xc5\xb3 aptarnavimas'
+b'DocType: BOM',b'Thumbnail',b'Miniati\xc5\xabra'
+b'DocType: Item Customer Detail',b'Item Customer Detail',b'Prek\xc4\x97 Klient\xc5\xb3 detal\xc4\x97s'
+b'apps/erpnext/erpnext/config/hr.py +50',b'Offer candidate a Job.',b'Si\xc5\xablau kandidatas darb\xc4\x85.'
+b'DocType: Notification Control',b'Prompt for Email on Submission of',b'Klausti Email pateikus'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88',b'Total allocated leaves are more than days in the period',b'I\xc5\xa1 viso skiriami lapai yra daugiau nei laikotarpio dien\xc5\xb3'
+b'DocType: Land Unit',b'Linked Soil Analysis',b'Susijusi dirvo\xc5\xbeemio analiz\xc4\x97'
+b'DocType: Pricing Rule',b'Percentage',b'procentas'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70',b'Item {0} must be a stock Item',b'Prek\xc4\x97 {0} turi b\xc5\xabti akcij\xc5\xb3 punktas'
+b'DocType: Manufacturing Settings',b'Default Work In Progress Warehouse',b'Numatytasis nebaigtos Warehouse'
+b'apps/erpnext/erpnext/config/accounts.py +288',b'Default settings for accounting transactions.',b'Numatytieji nustatymai apskaitos operacij\xc5\xb3.'
+b'DocType: Maintenance Visit',b'MV',b'V.'
+b'DocType: Restaurant',b'Default Tax Template',b'Numatytas mokes\xc4\x8dio \xc5\xa1ablonas'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66',b'{0} Students have been enrolled',b'{0} \xc4\xaestojo mokiniai'
+b'DocType: Fees',b'Student Details',b'Studento duomenys'
+b'DocType: Purchase Invoice Item',b'Stock Qty',b'akcij\xc5\xb3 Kiekis'
+b'DocType: Purchase Invoice Item',b'Stock Qty',b'akcij\xc5\xb3 Kiekis'
+b'DocType: Employee Loan',b'Repayment Period in Months',b'Gr\xc4\x85\xc5\xbeinimo laikotarpis m\xc4\x97nesiais'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26',b'Error: Not a valid id?',b'Klaida: Negaliojantis tapatyb\xc4\x97s?'
+b'DocType: Naming Series',b'Update Series Number',b'Atnaujinti serijos numeris'
+b'DocType: Account',b'Equity',b'teisingumas'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78',"b""{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry""",b'{0} {1}: &quot;Pelno ir nuostolio&quot; tipo s\xc4\x85skaita {2} neleid\xc5\xbeiama atidarymas \xc4\xafra\xc5\xa1\xc4\x85'
+b'DocType: Sales Order',b'Printing Details',b'Spausdinimo detal\xc4\x97s'
+b'DocType: Task',b'Closing Date',b'Pabaigos data'
+b'DocType: Sales Order Item',b'Produced Quantity',b'pagamintas kiekis'
+b'DocType: Timesheet',b'Work Detail',b'Darbo detal\xc4\x97s'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126',b'Engineer',b'in\xc5\xbeinierius'
+b'DocType: Journal Entry',b'Total Amount Currency',b'Bendra suma Valiuta'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38',b'Search Sub Assemblies',b'Paie\xc5\xa1ka Sub Agregatai'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171',b'Item Code required at Row No {0}',b'Prek\xc4\x97s kodas reikalaujama Row Nr {0}'
+b'DocType: GST Account',b'SGST Account',b'SGST s\xc4\x85skaita'
+b'apps/erpnext/erpnext/utilities/user_progress.py +154',b'Go to Items',b'Eiti \xc4\xaf elementus'
+b'DocType: Sales Partner',b'Partner Type',b'partnerio tipas'
+b'DocType: Purchase Taxes and Charges',b'Actual',b'faktinis'
+b'DocType: Restaurant Menu',b'Restaurant Manager',b'Restorano vadybininkas'
+b'DocType: Authorization Rule',b'Customerwise Discount',b'Customerwise nuolaida'
+b'apps/erpnext/erpnext/config/projects.py +46',b'Timesheet for tasks.',b'Lap\xc4\x85 u\xc5\xbeduotims.'
+b'DocType: Purchase Invoice',b'Against Expense Account',b'Prie\xc5\xa1 neskai\xc4\x8diuojantiems'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282',b'Installation Note {0} has already been submitted',b'\xc4\xaerengimas Pastaba {0} jau buvo pateikta'
+b'DocType: Bank Reconciliation',b'Get Payment Entries',b'Gauk Apmok\xc4\x97jimas \xc4\xafra\xc5\xa1ai'
+b'DocType: Quotation Item',b'Against Docname',b'prie\xc5\xa1 DOCNAME'
+b'DocType: SMS Center',b'All Employee (Active)',b'Viskas Darbuotoj\xc5\xb3 (aktyvus)'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9',b'View Now',b'per\xc5\xbei\xc5\xabr\xc4\x97ti Dabar'
+b'DocType: BOM',b'Raw Material Cost',b'\xc5\xbdaliav\xc5\xb3 kaina'
+b'DocType: Item Reorder',b'Re-Order Level',b'Re \xc4\xafsakymu lygis'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +54',b'Gantt Chart',b'Ganto diagramos'
+b'DocType: Crop Cycle',b'Cycle Type',b'Ciklo tipas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99',b'Part-time',b'Neakivaizdin\xc4\x97s'
+b'DocType: Employee',b'Applicable Holiday List',b'Taikoma Atostog\xc5\xb3 s\xc4\x85ra\xc5\xa1as'
+b'DocType: Employee',b'Cheque',b'Tikrinti'
+b'DocType: Training Event',b'Employee Emails',b'Darbuotoj\xc5\xb3 el. Lai\xc5\xa1kai'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60',b'Series Updated',b'serija Atnaujinta'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +159',b'Report Type is mandatory',b'Ataskaitos tipas yra privalomi'
+b'DocType: Item',b'Serial Number Series',b'Eil\xc4\x97s numeris serija'
+b'apps/erpnext/erpnext/buying/utils.py +68',b'Warehouse is mandatory for stock Item {0} in row {1}',b'Sand\xc4\x97li\xc5\xb3 yra privalomas akcij\xc5\xb3 punkte {0} i\xc5\xa1 eil\xc4\x97s {1}'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45',b'Retail & Wholesale',b'Ma\xc5\xbemenin\xc4\x97 prekyba ir didmenin\xc4\x97 prekyba'
+b'DocType: Issue',b'First Responded On',b'Pirma atsak\xc4\x97'
+b'DocType: Website Item Group',b'Cross Listing of Item in multiple groups',"b'Kry\xc5\xbeius, s\xc4\x85ra\xc5\xa1as element\xc4\x85 keli\xc5\xb3 grupi\xc5\xb3'"
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90',b'Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}',b'Fiskalin\xc4\x97 met\xc5\xb3 prad\xc5\xbeios data ir fiskalini\xc5\xb3 met\xc5\xb3 pabaigos data jau nustatyta fiskaliniais metais {0}'
+b'DocType: Projects Settings',b'Ignore User Time Overlap',b'Ignoruoti naudotojo laiko dubliavim\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113',b'Clearance Date updated',b'Atnaujintas klirensas data'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Splitas Serija'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Splitas Serija'
+b'DocType: Stock Settings',b'Batch Identification',b'Partijos identifikavimas'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132',b'Successfully Reconciled',b's\xc4\x97kmingai Suderinta'
+b'DocType: Request for Quotation Supplier',b'Download PDF',b'atsisi\xc5\xb3sti PDF'
+b'DocType: Work Order',b'Planned End Date',b'Planuojamas Pabaigos data'
+b'DocType: Shareholder',b'Hidden list maintaining the list of contacts linked to Shareholder',b'Pasl\xc4\x97ptas s\xc4\x85ra\xc5\xa1as palaikydamas su akcininku susietus kontaktus'
+b'apps/erpnext/erpnext/config/non_profit.py +63',b'Donor Type information.',b'Donoro tipo informacija.'
+b'DocType: Request for Quotation',b'Supplier Detail',b'tiek\xc4\x97jas detal\xc4\x97s'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100',b'Error in formula or condition: {0}',b'Klaida formul\xc4\x99 ar b\xc5\xabkl\xc4\x97s: {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +99',b'Invoiced Amount',b'S\xc4\x85skaitoje suma'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47',b'Criteria weights must add up to 100%',b'Kriterij\xc5\xb3 svoriai turi sudaryti iki 100%'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7',b'Attendance',b'lankomumas'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +115',b'Stock Items',b'atsargos'
+b'DocType: BOM',b'Materials',b'med\xc5\xbeiagos'
+b'DocType: Leave Block List',"b'If not checked, the list will have to be added to each Department where it has to be applied.'","b'Jei nepa\xc5\xbeym\xc4\x97ta, s\xc4\x85ra\xc5\xa1as turi b\xc5\xabti pridedamas prie kiekvieno padalinio, kuriame jis turi b\xc5\xabti taikomas.'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111',b'Creating {0}',b'K\xc5\xabrimas {0}'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28',b'Source and Target Warehouse cannot be same',b'Originalo ir vertimo Sand\xc4\x97lis negali b\xc5\xabti tas pats'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586',b'Posting date and posting time is mandatory',b'Siun\xc4\x8diamos dat\xc4\x85 ir paskelbimo laik\xc4\x85 yra privalomas'
+b'apps/erpnext/erpnext/config/buying.py +76',b'Tax template for buying transactions.',b'Mokes\xc4\x8di\xc5\xb3 \xc5\xa1ablonas pirkti sandorius.'
+,b'Item Prices',b'Prek\xc4\x97 Kainos'
+b'DocType: Purchase Order',b'In Words will be visible once you save the Purchase Order.',"b'\xc5\xbdod\xc5\xbeiais bus matomas, kai j\xc5\xabs i\xc5\xa1gelb\xc4\x97ti pirkimo pavedimu.'"
+b'DocType: Period Closing Voucher',b'Period Closing Voucher',b'Laikotarpis u\xc5\xbedarymas \xc4\x8dekis'
+b'DocType: Consultation',b'Review Details',b'Per\xc5\xbei\xc5\xabr\xc4\x97ti detales'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185',b'The shareholder does not belong to this company',b'Akcininkas n\xc4\x97ra \xc5\xa1ios bendrov\xc4\x97s narys'
+b'DocType: Dosage Form',b'Dosage Form',b'Dozavimo forma'
+b'apps/erpnext/erpnext/config/selling.py +67',b'Price List master.',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as meistras.'
+b'DocType: Task',b'Review Date',b'per\xc5\xbei\xc5\xabros data'
+b'DocType: Company',b'Series for Asset Depreciation Entry (Journal Entry)',b'Turto nusid\xc4\x97v\xc4\x97jimo \xc4\xafra\xc5\xa1as (\xc5\xbeurnalo \xc4\xafra\xc5\xa1as)'
+b'DocType: Membership',b'Member Since',b'Narys nuo'
+b'DocType: Purchase Invoice',b'Advance Payments',b'i\xc5\xa1ankstiniai mok\xc4\x97jimai'
+b'DocType: Purchase Taxes and Charges',b'On Net Total',b'D\xc4\x97l grynuosius'
+b'apps/erpnext/erpnext/controllers/item_variant.py +92',b'Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}',b'Vert\xc4\x97 Attribute {0} turi b\xc5\xabti intervale {1} ir {2} \xc4\xaf \xc5\xbeingsniais {3} u\xc5\xbe prek\xc4\x99 {4}'
+b'DocType: Restaurant Reservation',b'Waitlisted',b'Waitlisted'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +124',b'Currency can not be changed after making entries using some other currency',"b'Valiuta negali b\xc5\xabti pakeistas po to, kai \xc4\xafra\xc5\xa1us naudojant kai kita valiuta'"
+b'DocType: Shipping Rule',b'Fixed',b'Fiksuotas'
+b'DocType: Vehicle Service',b'Clutch Plate',b'Sankabos diskas'
+b'DocType: Company',b'Round Off Account',b'Suapvalinti paskyr\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93',b'Administrative Expenses',b'administracin\xc4\x97s i\xc5\xa1laidos'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18',b'Consulting',b'konsultavimas'
+b'DocType: Customer Group',b'Parent Customer Group',b'T\xc4\x97v\xc5\xb3 Klient\xc5\xb3 grup\xc4\x97'
+b'DocType: Journal Entry',b'Subscription',b'Prenumerata'
+b'DocType: Purchase Invoice',b'Contact Email',b'kontaktinis elektroninio pa\xc5\xa1to adresas'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11',b'Fee Creation Pending',b'Mokes\xc4\x8dio k\xc5\xabrimas laukiamas'
+b'DocType: Appraisal Goal',b'Score Earned',b'balas u\xc5\xbedirbo'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241',b'Notice Period',b'\xc4\xafsp\xc4\x97jimo terminas'
+b'DocType: Asset Category',b'Asset Category Name',b'Turto Kategorijos pavadinimas'
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.js +13',b'This is a root territory and cannot be edited.',b'Tai yra \xc5\xa1aknis teritorijoje ir negali b\xc5\xabti pakeisti.'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5',b'New Sales Person Name',b'Nauja pardavim\xc5\xb3 asmuo Vardas'
+b'DocType: Packing Slip',b'Gross Weight UOM',b'Bendras svoris UOM'
+b'DocType: Asset Maintenance Task',b'Preventive Maintenance',b'Profilaktin\xc4\x97 prie\xc5\xbei\xc5\xabra'
+b'DocType: Delivery Note Item',b'Against Sales Invoice',b'Prie\xc5\xa1 pardavimo s\xc4\x85skaita-fakt\xc5\xabra'
+b'DocType: Purchase Invoice',b'07-Others',b'07-Kiti'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151',b'Please enter serial numbers for serialized item ',b'Pra\xc5\xa1ome \xc4\xafvesti serijinius numerius serializowanej prek\xc4\x99'
+b'DocType: Bin',b'Reserved Qty for Production',b'Reserved Kiekis d\xc4\x97l gamybos'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureNum',b'EcritureNum'
+b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. ""","b'Palikite nepa\xc5\xbeym\xc4\x97t\xc4\x85 jei nenorite atsi\xc5\xbevelgti \xc4\xaf partij\xc4\x85, o tod\xc4\x97l kurs\xc5\xb3 pagr\xc4\xafstas grupes.'"
+b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. ""","b'Palikite nepa\xc5\xbeym\xc4\x97t\xc4\x85 jei nenorite atsi\xc5\xbevelgti \xc4\xaf partij\xc4\x85, o tod\xc4\x97l kurs\xc5\xb3 pagr\xc4\xafstas grupes.'"
+b'DocType: Asset',b'Frequency of Depreciation (Months)',b'Da\xc5\xbenio nusid\xc4\x97v\xc4\x97jimo (m\xc4\x97nesiais)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500',b'Credit Account',b'Kreditin\xc4\x97 s\xc4\x85skaita'
+b'DocType: Landed Cost Item',b'Landed Cost Item',b'Nusileido Kaina punktas'
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57',b'Show zero values',b'Rodyti nulines vertes'
+b'DocType: BOM',b'Quantity of item obtained after manufacturing / repacking from given quantities of raw materials',b'Kiekis objekto gauti po gamybos / perpakavimas i\xc5\xa1 pateikt\xc5\xb3 \xc5\xbealiav\xc5\xb3 kiekius'
+b'DocType: Lab Test',b'Test Group',b'Bandymo grup\xc4\x97'
+b'DocType: Payment Reconciliation',b'Receivable / Payable Account',b'Gautinos / mok\xc4\x97tinos s\xc4\x85skaitos'
+b'DocType: Delivery Note Item',b'Against Sales Order Item',b'Pagal Pardavimo U\xc5\xbesakymo Objekt\xc4\x85'
+b'DocType: Company',b'Company Logo',b'\xc4\xaemon\xc4\x97s logotipas'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +709',b'Please specify Attribute Value for attribute {0}',b'Pra\xc5\xa1ome nurodyti \xc4\xaeg\xc5\xabdis po\xc5\xbeymio reik\xc5\xa1m\xc4\x99 {0}'
+b'DocType: Item',b'Default Warehouse',b'numatytasis sand\xc4\x97lis'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45',b'Budget cannot be assigned against Group Account {0}',b'Biud\xc5\xbeetas negali b\xc5\xabti skiriamas prie\xc5\xa1 grup\xc4\x97s s\xc4\x85skaitoje {0}'
+b'DocType: Healthcare Settings',b'Patient Registration',b'Paciento registracija'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22',b'Please enter parent cost center',b'Pra\xc5\xa1ome \xc4\xafvesti patronuojanti ka\xc5\xa1t\xc5\xb3 centr\xc4\x85'
+b'DocType: Delivery Note',b'Print Without Amount',b'Spausdinti Be Suma'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57',b'Depreciation Date',b'Nusid\xc4\x97v\xc4\x97jimas data'
+,b'Work Orders in Progress',b'Darb\xc5\xb3 u\xc5\xbesakymai vyksta'
+b'DocType: Issue',b'Support Team',b'Palaikymo komanda'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36',b'Expiry (In Days)',b'Galiojimo (dienomis)'
+b'DocType: Appraisal',b'Total Score (Out of 5)',b'I\xc5\xa1 viso balas (i\xc5\xa1 5)'
+b'DocType: Fee Structure',b'FS.',b'FS.'
+b'DocType: Student Attendance Tool',b'Batch',b'Partija'
+b'DocType: Donor',b'Donor Type',b'Donoro tipas'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +27',b'Balance',b'balansas'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66',b'Please select the Company',b'Pasirinkite bendrov\xc4\x99'
+b'DocType: Room',b'Seating Capacity',b'S\xc4\x97dim\xc5\xb3 viet\xc5\xb3 skai\xc4\x8dius'
+b'DocType: Issue',b'ISS-',b'ISS-'
+b'DocType: Lab Test Groups',b'Lab Test Groups',b'Laboratorijos test\xc5\xb3 grup\xc4\x97s'
+b'DocType: Project',b'Total Expense Claim (via Expense Claims)',b'Bendras i\xc5\xa1laid\xc5\xb3 pretenzija (per i\xc5\xa1laid\xc5\xb3 parai\xc5\xa1kos)'
+b'DocType: GST Settings',b'GST Summary',"b'Paai\xc5\xa1k\xc4\x97jo, kad GST santrauka'"
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16',b'Please enable default incoming account before creating Daily Work Summary Group',"b'Prie\xc5\xa1 kurdami dienos darbo santrauk\xc5\xb3 grup\xc4\x99, \xc4\xafjunkite numatyt\xc4\x85j\xc4\x85 prisijungian\xc4\x8di\xc4\x85 paskyr\xc4\x85'"
+b'DocType: Assessment Result',b'Total Score',b'Galutinis rezultatas'
+b'DocType: Journal Entry',b'Debit Note',b'debeto aviza'
+b'DocType: Stock Entry',b'As per Stock UOM',b'Kaip per vertybini\xc5\xb3 popieri\xc5\xb3 UOM'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7',b'Not Expired',b'n\xc4\x97ra pasibaig\xc4\x99s'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49',b'ValidDate',b'Galiojanti data'
+b'DocType: Student Log',b'Achievement',b'Pasiekimas'
+b'DocType: Batch',b'Source Document Type',b'\xc5\xa0altinis Dokumento tipas'
+b'DocType: Batch',b'Source Document Type',b'\xc5\xa0altinis Dokumento tipas'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24',b'Following course schedules were created',b'Buvo sukurti kurs\xc5\xb3 tvarkara\xc5\xa1\xc4\x8diai'
+b'DocType: Journal Entry',b'Total Debit',b'I\xc5\xa1 viso Debeto'
+b'DocType: Manufacturing Settings',b'Default Finished Goods Warehouse',b'Numatytieji gatav\xc5\xb3 preki\xc5\xb3 sand\xc4\x97lis'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108',b'Please select Patient',b'Pasirinkite pacient\xc4\x85'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76',b'Sales Person',b'Pardav\xc4\x97jas'
+b'DocType: Hotel Room Package',b'Amenities',b'Patogumai'
+b'apps/erpnext/erpnext/config/accounts.py +233',b'Budget and Cost Center',b'Biud\xc5\xbeeto ir i\xc5\xa1laid\xc5\xb3 centras'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65',b'Multiple default mode of payment is not allowed',b'Kelis numatytasis mok\xc4\x97jimo b\xc5\xabdas neleid\xc5\xbeiamas'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',b'for the',b'u\xc5\xbe'
+,b'Appointment Analytics',b'Paskyrim\xc5\xb3 analiz\xc4\x97'
+b'DocType: Vehicle Service',b'Half Yearly',b'pusme\xc4\x8dio'
+b'DocType: Lead',b'Blog Subscriber',b'Dienora\xc5\xa1tis abonento'
+b'DocType: Guardian',b'Alternate Number',b'pakaitinis Ta\xc5\xa1k\xc5\xb3'
+b'DocType: Healthcare Settings',b'Consultations in valid days',b'Konsultacijos galiojan\xc4\x8diomis dienomis'
+b'DocType: Assessment Plan Criteria',b'Maximum Score',b'Maksimalus balas'
+b'apps/erpnext/erpnext/config/setup.py +83',b'Create rules to restrict transactions based on values.',"b'Sukurti taisykles, siekdama apriboti sandorius, pagr\xc4\xafstus vertybes.'"
+b'DocType: Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts',b'Pinig\xc5\xb3 sraut\xc5\xb3 \xc5\xbeem\xc4\x97lapi\xc5\xb3 s\xc4\x85skaitos'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49',b' Group Roll No',b'Grup\xc4\x97s sal\xc4\x97s Nr.'
+b'DocType: Batch',b'Manufacturing Date',b'Pagaminimo data'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9',b'Fee Creation Failed',b'Mokes\xc4\x8dio suk\xc5\xabrimas nepavyko'
+b'DocType: Opening Invoice Creation Tool',b'Create Missing Party',b'Sukurti tr\xc5\xabkstam\xc4\x85 vakar\xc4\x97l\xc4\xaf'
+b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',"b'Palikite tu\xc5\xa1\xc4\x8di\xc4\x85, jei j\xc5\xabs padarote student\xc5\xb3 grupes per metus'"
+b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',"b'Palikite tu\xc5\xa1\xc4\x8di\xc4\x85, jei j\xc5\xabs padarote student\xc5\xb3 grupes per metus'"
+b'DocType: HR Settings',"b'If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day'","b'Jei pa\xc5\xbeym\xc4\x97ta, viso n\xc4\x97ra. darbo dien\xc5\xb3 bus atostog\xc5\xb3, o tai suma\xc5\xbeins Atlyginimas diena vert\xc4\x99'"
+b'DocType: Purchase Invoice',b'Total Advance',b'I\xc5\xa1 viso I\xc5\xa1ankstinis'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27',b'Change Template Code',b'Pakeisti \xc5\xa1ablono kod\xc4\x85'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23',b'The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.',b'Kadencijos pabaigos data negali b\xc5\xabti v\xc4\x97lesn\xc4\x97 nei kadencijos prad\xc5\xbeioje data. I\xc5\xa1taisykite datas ir bandykite dar kart\xc4\x85.'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'quot Grafas'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'quot Grafas'
+,b'BOM Stock Report',b'BOM sand\xc4\x97lyje ataskaita'
+b'DocType: Stock Reconciliation Item',b'Quantity Difference',b'kiekis skirtumas'
+b'DocType: Employee Advance',b'EA-',b'EA-'
+b'DocType: Opportunity Item',b'Basic Rate',b'bazinis tarifas'
+b'DocType: GL Entry',b'Credit Amount',b'kredito suma'
+b'DocType: Cheque Print Template',b'Signatory Position',b'signataras pozicijos'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173',b'Set as Lost',b'Nustatyti kaip Lost'
+b'DocType: Timesheet',b'Total Billable Hours',b'I\xc5\xa1 viso apmokamas valandas'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4',b'Payment Receipt Note',b'Mok\xc4\x97jimo kvit\xc4\x85 Pastaba'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6',b'This is based on transactions against this Customer. See timeline below for details',b'Tai grind\xc5\xbeiama sandori\xc5\xb3 at\xc5\xbevilgiu \xc5\xa1is klientas. \xc5\xbdi\xc5\xabr\xc4\x97ti grafikas \xc5\xbeemiau detales'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162',b'Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2}',b'Eilut\xc4\x97s {0}: Paskirti suma {1} turi b\xc5\xabti ma\xc5\xbeesnis arba lygus Mok\xc4\x97jimo Entry suma {2}'
+b'DocType: Program Enrollment Tool',b'New Academic Term',b'Naujas akademinis terminas'
+,b'Course wise Assessment Report',b'\xc5\xbdinoma protinga vertinimo ataskaita'
+b'DocType: Purchase Invoice',b'Availed ITC State/UT Tax',b'Pasinaudojo ITC valstyb\xc4\x97s / UT mokes\xc4\x8diu'
+b'DocType: Tax Rule',b'Tax Rule',b'mokes\xc4\x8di\xc5\xb3 taisykl\xc4\x97'
+b'DocType: Selling Settings',b'Maintain Same Rate Throughout Sales Cycle',b'I\xc5\xa1laikyti t\xc4\x85 pat\xc4\xaf tarif\xc4\x85 Kiaurai pardavimo cikl\xc4\x85'
+b'DocType: Manufacturing Settings',b'Plan time logs outside Workstation Working Hours.',b'Planuokite laik\xc4\x85 r\xc4\x85st\xc5\xb3 lauko Workstation &quot;darbo valandomis.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115',b'Dr {0} does not have a Physician Schedule. Add it in Physician master',b'Dr {0} neturi gydytojo tvarkara\xc5\xa1\xc4\x8dio. Prid\xc4\x97kite j\xc4\xaf gydytojo kapitale'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +98',b'Customers in Queue',b'Klientai eil\xc4\x97je'
+b'DocType: Driver',b'Issuing Date',b'I\xc5\xa1leidimo data'
+b'DocType: Student',b'Nationality',b'Tautyb\xc4\x97'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109',b'Submit this Work Order for further processing.',b'Pateikite \xc5\xa1\xc4\xaf darbo u\xc5\xbesakym\xc4\x85 tolimesniam apdorojimui.'
+,b'Items To Be Requested',"b'Daiktai, kuri\xc5\xb3 bus pra\xc5\xa1oma'"
+b'DocType: Purchase Order',b'Get Last Purchase Rate',b'Gauk paskutin\xc4\xaf pirkin\xc4\xaf Balsuok'
+b'DocType: Company',b'Company Info',b'\xc4\xaemon\xc4\x97s informacija'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1385',b'Select or add new customer',b'Pasirinkite arba prid\xc4\x97ti nauj\xc5\xb3 klient\xc5\xb3'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173',b'Cost center is required to book an expense claim',b'Kaina centras privalo u\xc5\xbesakyti s\xc4\x85naudomis pretenzij\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9',b'Application of Funds (Assets)',b'Taikymas l\xc4\x97\xc5\xa1os (turtas)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6',b'This is based on the attendance of this Employee',"b'Tai yra, remiantis \xc5\xa1io darbuotojo dalyvavimo'"
+b'DocType: Assessment Result',b'Summary',b'Santrauka'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112',b'Mark Attendance',b'Pa\xc5\xbeym\xc4\x97ti lankomum\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494',b'Debit Account',b'debeto s\xc4\x85skaita'
+b'DocType: Fiscal Year',b'Year Start Date',b'Met\xc5\xb3 prad\xc5\xbeios data'
+b'DocType: Attendance',b'Employee Name',b'Darbuotojo vardas'
+b'DocType: Restaurant Order Entry Item',b'Restaurant Order Entry Item',b'Restorano u\xc5\xbesakymo \xc4\xafra\xc5\xa1as'
+b'DocType: Purchase Invoice',b'Rounded Total (Company Currency)',b'Suapvalinti I\xc5\xa1 viso (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +96',b'Cannot covert to Group because Account Type is selected.',"b'Negalima pasl\xc4\x97ptas \xc4\xaf grup\xc4\x99, nes s\xc4\x85skaitos tipas yra pasirinktas.'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260',b'{0} {1} has been modified. Please refresh.',b'{0} {1} buvo pakeistas. Pra\xc5\xa1ome atnaujinti.'
+b'DocType: Leave Block List',b'Stop users from making Leave Applications on following days.',b'Stop vartotojus nuo pri\xc4\x97mimo pra\xc5\xa1ym\xc5\xb3 \xc4\xafstoti \xc4\xaf \xc5\xa1i\xc5\xb3 dien\xc5\xb3.'
+b'DocType: Asset Maintenance Team',b'Maintenance Team Members',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros komandos nariai'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63',b'Purchase Amount',b'pirkimo suma'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261',b'Supplier Quotation {0} created',b'Tiek\xc4\x97jas Citata {0} suk\xc5\xabr\xc4\x97'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +103',b'End Year cannot be before Start Year',b'Pabaiga metai bus ne anks\xc4\x8diau prad\xc5\xbeios metus'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234',b'Employee Benefits',b'I\xc5\xa1mokos darbuotojams'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264',b'Packed quantity must equal quantity for Item {0} in row {1}',b'Supakuotas kiekis turi vienodas kiekis u\xc5\xbe prek\xc4\x99 {0} i\xc5\xa1 eil\xc4\x97s {1}'
+b'DocType: Work Order',b'Manufactured Qty',b'pagaminta Kiekis'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78',"b""The shares don't exist with the {0}""",b'Akcijos neegzistuoja {0}'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64',b'Invoice Created',b'Sukurta s\xc4\x85skaita'
+b'DocType: Asset',b'Out of Order',b'Neveikia'
+b'DocType: Purchase Receipt Item',b'Accepted Quantity',b'Priimamos Kiekis'
+b'DocType: Projects Settings',b'Ignore Workstation Time Overlap',b'Ignoruoti darbo vietos laiko dubliavim\xc4\x85'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +242',b'Please set a default Holiday List for Employee {0} or Company {1}',b'Pra\xc5\xa1ome nustatyti numatyt\xc4\x85j\xc4\xaf Atostog\xc5\xb3 s\xc4\x85ra\xc5\xa1as Darbuotojo {0} arba \xc4\xaemon\xc4\x97s {1}'
+b'apps/erpnext/erpnext/accounts/party.py +30',b'{0}: {1} does not exists',b'{0}: {1} neegzistuoja'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76',b'Select Batch Numbers',b'Pasirinkite partij\xc5\xb3 numeriai'
+b'apps/erpnext/erpnext/config/accounts.py +12',b'Bills raised to Customers.',b'Vekseliai i\xc5\xa1kelti \xc4\xaf klientams.'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Project Id',b'Projekt\xc5\xb3 ID'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534',b'Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}',b'Eilut\xc4\x97s N\xc4\x97ra {0}: suma negali b\xc5\xabti didesn\xc4\x97 nei Kol Suma prie\xc5\xa1 expense punkt\xc4\x85 {1}. Kol suma yra {2}'
+b'DocType: Patient Service Unit',b'Medical Administrator',b'Medicinos administratorius'
+b'DocType: Assessment Plan',b'Schedule',b'grafikas'
+b'DocType: Account',b'Parent Account',b't\xc4\x97v\xc5\xb3 paskyra'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266',b'Available',b'pasiekiamas'
+b'DocType: Quality Inspection Reading',b'Reading 3',b'Skaitymas 3'
+b'DocType: Stock Entry',b'Source Warehouse Address',b'\xc5\xa0altinio sand\xc4\x97lio adresas'
+,b'Hub',b'\xc4\xafvor\xc4\x97'
+b'DocType: GL Entry',b'Voucher Type',b'Bon tipas'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1717',b'Price List not found or disabled',b'Kain\xc5\xb3 s\xc4\x85ra\xc5\xa1as nerastas arba i\xc5\xa1jungtas'
+b'DocType: Student Applicant',b'Approved',b'patvirtinta'
+b'apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15',b'Price',b'kaina'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267',"b""Employee relieved on {0} must be set as 'Left'""",b'Darbuotoj\xc5\xb3 atleid\xc5\xbeiamas nuo {0} turi b\xc5\xabti nustatyti kaip &quot;Left&quot;'
+b'DocType: Hub Settings',b'Last Sync On',b'Paskutin\xc4\x97 sinchronizacija \xc4\xafjungta'
+b'DocType: Guardian',b'Guardian',b'glob\xc4\x97jas'
+b'DocType: Opening Invoice Creation Tool',b'Create missing customer or supplier.',b'Sukurkite tr\xc5\xabkstam\xc4\x85 klient\xc4\x85 ar tiek\xc4\x97j\xc4\x85.'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42',b'Appraisal {0} created for Employee {1} in the given date range',b'Vertinimas {0} sukurtas darbuotojo {1} konkre\xc4\x8dioje dat'
+b'DocType: Academic Term',b'Education',b'\xc5\xa1vietimas'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +89',b'Del',b'del'
+b'DocType: Selling Settings',b'Campaign Naming By',b'Kampanija \xc4\xafvardijimas Iki'
+b'DocType: Employee',b'Current Address Is',b'Dabartinis adresas'
+b'apps/erpnext/erpnext/utilities/user_progress.py +51',b'Monthly Sales Target (',b'M\xc4\x97nesio pardavimo tikslai ('
+b'DocType: Physician Service Unit Schedule',b'Physician Service Unit Schedule',b'Gydytojo tarnybos tarnybos tvarkara\xc5\xa1tis'
+b'apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9',b'modified',b'keistas'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43',"b""Optional. Sets company's default currency, if not specified.""","b'Neprivaloma. Nustato \xc4\xafmon\xc4\x97s numatytasis valiuta, jeigu nenurodyta.'"
+b'DocType: Sales Invoice',b'Customer GSTIN',b'Klient\xc5\xb3 GSTIN'
+b'DocType: Crop Cycle',"b""List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ""","b'Lauke aptikt\xc5\xb3 lig\xc5\xb3 s\xc4\x85ra\xc5\xa1as. Pasirinkus, jis bus automati\xc5\xa1kai prid\xc4\x97ti u\xc5\xbeduo\xc4\x8di\xc5\xb3 s\xc4\x85ra\xc5\xa1\xc4\x85 kovai su liga'"
+b'DocType: Asset Repair',b'Repair Status',b'Taisykl\xc4\x97s b\xc5\xabkl\xc4\x97'
+b'apps/erpnext/erpnext/config/accounts.py +67',b'Accounting journal entries.',b'Apskaitos \xc5\xbeurnalo \xc4\xafra\xc5\xa1ai.'
+b'DocType: Delivery Note Item',b'Available Qty at From Warehouse',b'Turimas Kiekis ne i\xc5\xa1 sand\xc4\x97lio'
+b'DocType: POS Profile',b'Account for Change Amount',b'S\xc4\x85skaita u\xc5\xbe poky\xc4\x8dio sum\xc4\x85'
+b'DocType: Purchase Invoice',b'input service',b'\xc4\xafvesties paslauga'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217',b'Row {0}: Party / Account does not match with {1} / {2} in {3} {4}',b'Eilut\xc4\x97s {0}: \xc5\xa0alis / S\xc4\x85skaita nesutampa su {1} / {2} \xc4\xaf {3} {4}'
+b'DocType: Maintenance Team Member',b'Maintenance Team Member',b'Technin\xc4\x97s prie\xc5\xbei\xc5\xabros komandos narys'
+b'DocType: Agriculture Analysis Criteria',b'Soil Analysis',b'Dirvo\xc5\xbeemio analiz\xc4\x97'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13',b'Course Code: ',b'Modulio kodas:'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240',b'Please enter Expense Account',b'Pra\xc5\xa1ome \xc4\xafvesti s\xc4\x85skaita paskyr\xc4\x85'
+b'DocType: Account',b'Stock',b'i\xc5\xa1tekliai'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095',"b'Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry'","b'Eilut\xc4\x97s # {0}: Informacinis dokumentas tipas turi b\xc5\xabti vienas i\xc5\xa1 pirkimo tvarka, pirkimo s\xc4\x85skaitoje fakt\xc5\xabroje ar \xc5\xbeurnalo \xc4\xafra\xc5\xa1\xc4\x85'"
+b'DocType: Employee',b'Current Address',b'Dabartinis adresas'
+b'DocType: Item',"b'If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified'","b'Jei elementas yra kito elemento, tada apra\xc5\xa1ymas, vaizdo, kainodara, mokes\xc4\x8diai ir tt bus nustatytas nuo \xc5\xa1ablono variantas, nebent ai\xc5\xa1kiai nurodyta'"
+b'DocType: Serial No',b'Purchase / Manufacture Details',b'Pirkimas / Gamyba detal\xc4\x97s'
+b'DocType: Assessment Group',b'Assessment Group',b'vertinimo grup\xc4\x97'
+b'apps/erpnext/erpnext/config/stock.py +329',b'Batch Inventory',b'Serija Inventorius'
+b'DocType: Employee',b'Contract End Date',b'Sutarties pabaigos data'
+b'DocType: Sales Order',b'Track this Sales Order against any Project',b'Sekti \xc5\xa1i\xc4\x85 pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 prie\xc5\xa1 bet kok\xc4\xaf projekt\xc4\x85'
+b'DocType: Sales Invoice Item',b'Discount and Margin',b'Nuolaida ir Mar\xc5\xbea'
+b'DocType: Lab Test',b'Prescription',b'Receptas'
+b'DocType: Project',b'Second Email',b'Antrasis el. Pa\xc5\xa1tas'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111',b'Not Available',b'Nepasiekiamas'
+b'DocType: Pricing Rule',b'Min Qty',b'min Kiekis'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36',b'Disable Template',b'I\xc5\xa1jungti \xc5\xa1ablon\xc4\x85'
+b'DocType: GL Entry',b'Transaction Date',b'Operacijos data'
+b'DocType: Production Plan Item',b'Planned Qty',b'Planuojamas Kiekis'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121',b'Total Tax',b'I\xc5\xa1 viso Mokes\xc4\x8di\xc5\xb3'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204',b'For Quantity (Manufactured Qty) is mandatory',b'D\xc4\x97l Kiekis (Pagaminta Kiekis) yra privalomi'
+b'DocType: Stock Entry',b'Default Target Warehouse',b'Numatytasis Tikslin\xc4\x97 sand\xc4\x97lis'
+b'DocType: Purchase Invoice',b'Net Total (Company Currency)',b'Grynasis viso (\xc4\xaemon\xc4\x97s valiuta)'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14',b'The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.',b'Dienos iki met\xc5\xb3 pabaigos data negali b\xc5\xabti v\xc4\x97lesn\xc4\x97 nei met\xc5\xb3 prad\xc5\xbeioje data. I\xc5\xa1taisykite datas ir bandykite dar kart\xc4\x85.'
+b'DocType: Notification Control',b'Purchase Receipt Message',b'Pirkimo kvito prane\xc5\xa1imas'
+b'DocType: BOM',b'Scrap Items',b'lau\xc5\xbeas daiktai'
+b'DocType: Work Order',b'Actual Start Date',b'Tikrasis prad\xc5\xbeios data'
+b'DocType: Sales Order',b'% of materials delivered against this Sales Order',b'% med\xc5\xbeiag\xc5\xb3 pristatyta pagal \xc5\xa1\xc4\xaf Pardavimo U\xc5\xbesakym\xc4\x85'
+b'apps/erpnext/erpnext/config/manufacturing.py +18',b'Generate Material Requests (MRP) and Work Orders.',b'Sukurkite med\xc5\xbeiag\xc5\xb3 pra\xc5\xa1ymus (MRP) ir darbo u\xc5\xbesakymus.'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62',b'Set default mode of payment',b'Nustatykite numatyt\xc4\x85 mok\xc4\x97jimo b\xc5\xabd\xc4\x85'
+b'DocType: Grant Application',b'Withdrawn',b'panaikintas'
+b'DocType: Hub Settings',b'Hub Settings',b'Hub Nustatymai'
+b'DocType: Project',b'Gross Margin %',"b'Bendroji mar\xc5\xbea,%'"
+b'DocType: BOM',b'With Operations',b'su operacij\xc5\xb3'
+b'apps/erpnext/erpnext/accounts/party.py +259',b'Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.',b'Apskaitos \xc4\xafra\xc5\xa1ai jau buvo padaryta valiuta {0} kompanijai {1}. Pra\xc5\xa1ome pasirinkti gautinai ar mok\xc4\x97tinai sumai s\xc4\x85skait\xc4\x85 valiuta {0}.'
+b'DocType: Asset',b'Is Existing Asset',b'Ar turimo turto'
+b'DocType: Salary Detail',b'Statistical Component',b'Statistiniai komponentas'
+b'DocType: Salary Detail',b'Statistical Component',b'Statistiniai komponentas'
+b'DocType: Warranty Claim',b'If different than customer address',"b'Jei kitoks, nei klient\xc5\xb3 adres\xc4\x85'"
+b'DocType: Purchase Invoice',b'Without Payment of Tax',b'Nemokant mokes\xc4\x8dio'
+b'DocType: BOM Operation',b'BOM Operation',b'BOM operacija'
+b'apps/erpnext/erpnext/config/stock.py +141',b'Fulfilment',b'\xc4\xaevykdymas'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Amount',b'D\xc4\x97l ankstesn\xc4\x97s eil\xc4\x97s Suma'
+b'DocType: Item',b'Has Expiry Date',b'Turi galiojimo dat\xc4\x85'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +282',b'Transfer Asset',b'perduoto turto'
+b'DocType: POS Profile',b'POS Profile',b'POS profilis'
+b'DocType: Training Event',b'Event Name',b'\xc4\xaevykio pavadinimas'
+b'DocType: Physician',b'Phone (Office)',b'Telefonas (biuras)'
+b'apps/erpnext/erpnext/hooks.py +151',b'Admission',b'pri\xc4\x97mimas'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29',b'Admissions for {0}',b'Pri\xc4\x97mimo d\xc4\x97l {0}'
+b'apps/erpnext/erpnext/config/accounts.py +257',"b'Seasonality for setting budgets, targets etc.'","b'Sezoni\xc5\xa1kumas nustatymo biud\xc5\xbeetai, tikslai ir tt'"
+b'DocType: Supplier Scorecard Scoring Variable',b'Variable Name',b'Kintamasis pavadinimas'
+b'apps/erpnext/erpnext/stock/get_item_details.py +144',"b'Item {0} is a template, please select one of its variants'","b'Prek\xc4\x97 {0} yra \xc5\xa1ablonas, pra\xc5\xa1ome pasirinkti vien\xc4\x85 i\xc5\xa1 jo variantai'"
+b'DocType: Asset',b'Asset Category',b'turto Kategorija'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31',b'Net pay cannot be negative',b'Neto darbo u\xc5\xbemokestis negali b\xc5\xabti neigiamas'
+b'DocType: Purchase Order',b'Advance Paid',b'sumok\xc4\x97to avanso'
+b'DocType: Item',b'Item Tax',b'Prek\xc4\x97 Mokes\xc4\x8di\xc5\xb3'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883',b'Material to Supplier',"b'Med\xc5\xbeiaga, i\xc5\xa1 Tiek\xc4\x97jui'"
+b'DocType: Soil Texture',b'Loamy Sand',b'Gluosni\xc5\xb3 sm\xc4\x97lis'
+b'DocType: Production Plan',b'Material Request Planning',b'Med\xc5\xbeiag\xc5\xb3 u\xc5\xbeklausos planavimas'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +638',b'Excise Invoice',b'akcizo S\xc4\x85skaita'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16',b'Treshold {0}% appears more than once',b'Treshold {0}% atrodo daugiau nei vien\xc4\x85 kart\xc4\x85'
+b'DocType: Expense Claim',b'Employees Email Id',b'Darbuotojai elektroninio pa\xc5\xa1to numeris'
+b'DocType: Employee Attendance Tool',b'Marked Attendance',b'Pa\xc5\xbeym\xc4\x97ti Lankomumas'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138',b'Current Liabilities',b'Dabartiniai \xc4\xafsipareigojimai'
+b'apps/erpnext/erpnext/config/selling.py +297',b'Send mass SMS to your contacts',b'Si\xc5\xb3sti mas\xc4\x97s SMS \xc4\xaf j\xc5\xabs\xc5\xb3 kontaktus'
+b'DocType: Patient',b'A Positive',b'Teigiamas'
+b'DocType: Program',b'Program Name',b'programos pavadinimas'
+b'DocType: Purchase Taxes and Charges',b'Consider Tax or Charge for',b'Apsvarstykite mokest\xc4\xaf arba rinkliav\xc4\x85 u\xc5\xbe'
+b'DocType: Driver',b'Driving License Category',b'Vairuotojo pa\xc5\xbeym\xc4\x97jimo kategorija'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158',b'No Reference',b'Nr nuorodos'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57',b'Actual Qty is mandatory',b'Tikrasis Kiekis yra privalomi'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',"b'{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.'","b'{0} \xc5\xa1iuo metu turi {1} tiek\xc4\x97j\xc5\xb3 rezultat\xc5\xb3 kortel\xc4\x99, o \xc5\xa1io tiek\xc4\x97jo pirkimo u\xc5\xbesakymai tur\xc4\x97t\xc5\xb3 b\xc5\xabti i\xc5\xa1duodami atsargiai.'"
+b'DocType: Asset Maintenance Team',b'Asset Maintenance Team',b'Turto prie\xc5\xbei\xc5\xabros komanda'
+b'DocType: Employee Loan',b'Loan Type',b'paskolos tipas'
+b'DocType: Scheduling Tool',b'Scheduling Tool',b'planavimas \xc4\xafrankis'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180',b'Credit Card',b'Kreditin\xc4\x97 kortel\xc4\x97'
+b'DocType: BOM',b'Item to be manufactured or repacked',b'Prek\xc4\x97 turi b\xc5\xabti pagaminti arba perpakuoti'
+b'DocType: Employee Education',b'Major/Optional Subjects',b'Pagrindin\xc4\x97s / Laisvai pasirenkami dalykai'
+b'DocType: Sales Invoice Item',b'Drop Ship',b'Drop Ship'
+b'DocType: Driver',b'Suspended',b'Sustabdyta'
+b'DocType: Training Event',b'Attendees',b'Dalyviai'
+b'DocType: Employee',"b'Here you can maintain family details like name and occupation of parent, spouse and children'","b'\xc4\x8cia galite i\xc5\xa1saugoti \xc5\xa1eimos detal\xc4\x97s, pavyzd\xc5\xbeiui, pavadinim\xc4\x85 ir okupacijos patronuojan\xc4\x8di\xc4\x85 \xc4\xafmon\xc4\x99, sutuoktiniui ir vaikams'"
+b'DocType: Academic Term',b'Term End Date',b'Kadencijos pabaigos data'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted (Company Currency)',b'Mokes\xc4\x8diai ir rinkliavos I\xc5\xa1skaityta (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Item Group',b'General Settings',b'Bendrieji nustatymai'
+b'apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23',b'From Currency and To Currency cannot be same',b'Nuo Valiuta ir valiutos negali b\xc5\xabti tas pats'
+b'DocType: Stock Entry',b'Repack',b'I\xc5\xa1 naujo supakuokite'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6',b'You must Save the form before proceeding',b'J\xc5\xabs turite i\xc5\xa1gelb\xc4\x97ti prie\xc5\xa1 t\xc4\x99sdami form\xc4\x85'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113',b'Please select the Company first',b'Pirmiausia pasirinkite kompanij\xc4\x85'
+b'DocType: Item Attribute',b'Numeric Values',b'reik\xc5\xa1mes'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +56',b'Attach Logo',b'prisegti logotipas'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +51',b'Stock Levels',b'atsarg\xc5\xb3 kiekis'
+b'DocType: Customer',b'Commission Rate',b'Komisija Balsuok'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +505',b'Make Variant',b'Padaryti variantas'
+b'apps/erpnext/erpnext/config/hr.py +87',b'Block leave applications by department.',b'Blokuoti atostog\xc5\xb3 pra\xc5\xa1ymai departamento.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155',"b'Payment Type must be one of Receive, Pay and Internal Transfer'",b'Mok\xc4\x97jimo tipas turi b\xc5\xabti vienas i\xc5\xa1 Gauti Pay ir vidaus perk\xc4\x97limo'
+b'apps/erpnext/erpnext/config/selling.py +184',b'Analytics',b'Google Analytics'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25',b'Cart is Empty',b'Krep\xc5\xa1elis tu\xc5\xa1\xc4\x8dias'
+b'DocType: Vehicle',b'Model',b'Modelis'
+b'DocType: Work Order',b'Actual Operating Cost',b'Tikrasis eksploatavimo i\xc5\xa1laidos'
+b'DocType: Payment Entry',b'Cheque/Reference No',b'\xc4\x8cekis / Nuorodos Nr'
+b'DocType: Soil Texture',b'Clay Loam',b'Clay Loam'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +81',b'Root cannot be edited.',b'\xc5\xa0akn\xc5\xb3 negali b\xc5\xabti redaguojami.'
+b'DocType: Item',b'Units of Measure',b'Matavimo vienetai'
+b'DocType: Manufacturing Settings',b'Allow Production on Holidays',b'Leiskite gamyba \xc5\xa0vent\xc4\x97s'
+b'DocType: Sales Invoice',"b""Customer's Purchase Order Date""",b'Kliento U\xc5\xbesakymo data'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163',b'Capital Stock',b'Kapitalas'
+b'DocType: Shopping Cart Settings',b'Show Public Attachments',b'Rodyti Vie\xc5\xa1ieji Priedai'
+b'DocType: Packing Slip',b'Package Weight Details',b'Pakuot\xc4\x97s svoris detal\xc4\x97s'
+b'DocType: Restaurant Reservation',b'Reservation Time',b'Rezervacijos laikas'
+b'DocType: Payment Gateway Account',b'Payment Gateway Account',b'Mok\xc4\x97jimo \xc5\xa1liuzai paskyra'
+b'DocType: Shopping Cart Settings',b'After payment completion redirect user to selected page.',b'Po mok\xc4\x97jimo pabaigos nukreipti vartotoj\xc4\x85 \xc4\xaf pasirinktame puslapyje.'
+b'DocType: Company',b'Existing Company',b'Esama \xc4\xaemon\xc4\x97s'
+b'DocType: Healthcare Settings',b'Result Emailed',b'Rezultatas i\xc5\xa1si\xc5\xb3stas el. Pa\xc5\xa1tu'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +87',"b'Tax Category has been changed to ""Total"" because all the Items are non-stock items'","b'Mokes\xc4\x8di\xc5\xb3 Kategorija buvo pakeistas \xc4\xaf &quot;Total&quot;, nes visi daiktai yra ne atsargos'"
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103',b'Please select a csv file',b'Pra\xc5\xa1ome pasirinkti CSV fail\xc4\x85'
+b'DocType: Student Leave Application',b'Mark as Present',b'\xc5\xbdym\xc4\x97ti kaip dabartis'
+b'DocType: Supplier Scorecard',b'Indicator Color',b'Rodiklio spalva'
+b'DocType: Purchase Order',b'To Receive and Bill',b'Gauti ir Bill'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +445',b'Row #{0}: Reqd by Date cannot be before Transaction Date',b'Eilut\xc4\x97 # {0}: Reqd pagal dat\xc4\x85 negali b\xc5\xabti prie\xc5\xa1 Transakcijos dat\xc4\x85'
+b'apps/erpnext/erpnext/templates/pages/home.html +14',b'Featured Products',b'Pana\xc5\xa1\xc5\xabs produktai'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136',b'Designer',b'dizaineris'
+b'apps/erpnext/erpnext/config/selling.py +163',b'Terms and Conditions Template',b'Terminai ir s\xc4\x85lygos \xc5\xa0ablono'
+b'DocType: Serial No',b'Delivery Details',b'Pristatymo informacija'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495',b'Cost Center is required in row {0} in Taxes table for type {1}',b'Kaina centras reikalingas eil\xc4\x97s {0} mokes\xc4\x8di\xc5\xb3 lentel\xc4\x97 tipo {1}'
+b'DocType: Program',b'Program Code',b'programos kodas'
+b'DocType: Terms and Conditions',b'Terms and Conditions Help',b'Terminai ir s\xc4\x85lygos Pagalba'
+,b'Item-wise Purchase Register',b'Prek\xc4\x97 i\xc5\xa1mintingas pirkimas Registruotis'
+b'DocType: Driver',b'Expiry Date',b'Galiojimo data'
+b'DocType: Healthcare Settings',b'Employee name and designation in print',b'Darbuotojo vardas ir pavard\xc4\x97 spaudoje'
+,b'accounts-browser',b's\xc4\x85skaitos-nar\xc5\xa1ykl\xc4\x97'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368',b'Please select Category first',b'Pra\xc5\xa1ome pasirinkti Kategorija pirmas'
+b'apps/erpnext/erpnext/config/projects.py +13',b'Project master.',b'Projekt\xc5\xb3 meistras.'
+b'apps/erpnext/erpnext/controllers/status_updater.py +212',"b'To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.'","b'Leisti per s\xc4\x85skait\xc5\xb3 arba per u\xc5\xbesakym\xc4\x85, atnaujinti &quot;pa\xc5\xa1alpa&quot; sand\xc4\x97lyje nustatymus arba element\xc4\x85.'"
+b'DocType: Global Defaults',b'Do not show any symbol like $ etc next to currencies.',b'Nerodyti kaip $ ir tt simbolis \xc5\xa1alia valiutomis.'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431',b' (Half Day)',b'(Pus\xc4\x97 dienos)'
+b'DocType: Payment Term',b'Credit Days',b'kredito dien\xc5\xb3'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145',b'Please select Patient to get Lab Tests',"b'Pra\xc5\xa1ome pasirinkti &quot;Pacientas&quot;, kad gautum\xc4\x97te &quot;Lab&quot; testus'"
+b'apps/erpnext/erpnext/utilities/activation.py +128',b'Make Student Batch',b'Padaryti Student\xc5\xb3 Serija'
+b'DocType: Fee Schedule',b'FRQ.',b'FRQ.'
+b'DocType: Leave Type',b'Is Carry Forward',b'Ar perkelti'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841',b'Get Items from BOM',b'Gauti prekes i\xc5\xa1 BOM'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Lead Time Days',b'\xc5\xa0vinas Laikas dienas'
+b'DocType: Cash Flow Mapping',b'Is Income Tax Expense',b'Yra pajam\xc5\xb3 mokes\xc4\x8dio s\xc4\x85naudos'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +621',b'Row #{0}: Posting Date must be same as purchase date {1} of asset {2}',b'Eilut\xc4\x97s # {0}: Siun\xc4\x8diamos data turi b\xc5\xabti tokia pati kaip pirkimo datos {1} Turto {2}'
+b'DocType: Program Enrollment',"b""Check this if the Student is residing at the Institute's Hostel.""","b'Pa\xc5\xbeym\xc4\x97kite, jei tas studentas gyvena institute bendrabutyje.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125',b'Please enter Sales Orders in the above table',b'Pra\xc5\xa1ome \xc4\xafvesti pardavim\xc5\xb3 u\xc5\xbesakym\xc5\xb3 pirmiau pateiktoje lentel\xc4\x97je'
+,b'Stock Summary',b'akcij\xc5\xb3 santrauka'
+b'apps/erpnext/erpnext/config/assets.py +54',b'Transfer an asset from one warehouse to another',b'Perduoti turt\xc4\x85 i\xc5\xa1 vieno sand\xc4\x97lio \xc4\xaf kit\xc4\x85'
+b'DocType: Vehicle',b'Petrol',b'benzinas'
+b'apps/erpnext/erpnext/config/learn.py +217',b'Bill of Materials',b'S\xc4\x85mata'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105',b'Row {0}: Party Type and Party is required for Receivable / Payable account {1}',b'Eilut\xc4\x97s {0}: \xc5\xa0alis tipas ir partijos reikalingas gautinos / mok\xc4\x97tinos s\xc4\x85skaitos {1}'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94',b'Ref Date',b'teis\xc4\x97jas data'
+b'DocType: Employee',b'Reason for Leaving',b'I\xc5\xa1vykimo prie\xc5\xbeastis'
+b'DocType: BOM Operation',b'Operating Cost(Company Currency)',b'Operacin\xc4\x97 Kaina (\xc4\xaemon\xc4\x97s valiuta)'
+b'DocType: Employee Loan Application',b'Rate of Interest',b'Pal\xc5\xabkan\xc5\xb3 norma'
+b'DocType: Expense Claim Detail',b'Sanctioned Amount',b'sankcijos suma'
+b'DocType: Item',b'Shelf Life In Days',b'Tinkamumo laikas dienomis'
+b'DocType: GL Entry',b'Is Opening',b'Ar atidarymas'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196',b'Row {0}: Debit entry can not be linked with a {1}',b'Eilut\xc4\x97s {0}: debeto \xc4\xafra\xc5\xa1\xc4\x85 negali b\xc5\xabti susieta su {1}'
+b'DocType: Journal Entry',b'Subscription Section',b'Prenumeratos skyrius'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +177',b'Account {0} does not exist',b'S\xc4\x85skaita {0} neegzistuoja'
+b'DocType: Training Event',b'Training Program',b'Treniravimosi programa'
+b'DocType: Account',b'Cash',b'pinigai'
+b'DocType: Employee',b'Short biography for website and other publications.',b'Trumpa biografija interneto svetain\xc4\x97s ir kit\xc5\xb3 leidini\xc5\xb3.'
