DocType: Employee,Salary Mode,Mode paga
DocType: Patient,Divorced,I divorcuar
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Lejoni Pika për të shtuar disa herë në një transaksion
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Cancel materiale Vizitoni {0} para se anulimi këtë kërkuar garancinë
apps/erpnext/erpnext/config/education.py +118,Assessment Reports,Raportet e Vlerësimit
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Consumer Products
DocType: Purchase Receipt,Subscription Detail,Detaji i Abonimit
DocType: Supplier Scorecard,Notify Supplier,Njoftoni Furnizuesin
DocType: Item,Customer Items,Items të konsumatorëve
DocType: Project,Costing and Billing,Kushton dhe Faturimi
apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Llogaria {0}: llogari Parent {1} nuk mund të jetë libri
DocType: Item,Publish Item to hub.erpnext.com,Publikojë pika për hub.erpnext.com
apps/erpnext/erpnext/config/setup.py +88,Email Notifications,Njoftime Email
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,vlerësim
DocType: Item,Default Unit of Measure,Gabim Njësia e Masës
DocType: SMS Center,All Sales Partner Contact,Të gjitha Sales Partner Kontakt
DocType: Employee,Leave Approvers,Lini Aprovuesit
DocType: Sales Partner,Dealer,Tregtar
DocType: Work Order,WO-,WO-
DocType: Consultation,Investigations,hetimet
DocType: Restaurant Order Entry,Click Enter To Add,Kliko Enter To Add
DocType: Employee,Rented,Me qira
DocType: Purchase Order,PO-,poli-
DocType: Vehicle Service,Mileage,Largësi
apps/erpnext/erpnext/assets/doctype/asset/asset.js +253,Do you really want to scrap this asset?,A jeni të vërtetë doni për të hequr këtë pasuri?
DocType: Drug Prescription,Update Schedule,Orari i azhurnimit
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Zgjidh Default Furnizuesi
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Valuta është e nevojshme për Lista Çmimi {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Do të llogaritet në transaksion.
DocType: Purchase Order,Customer Contact,Customer Contact
DocType: Patient Appointment,Check availability,Kontrolloni disponueshmërinë
DocType: Job Applicant,Job Applicant,Job Aplikuesi
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Kjo është e bazuar në transaksionet kundër këtij Furnizuesi. Shih afat kohor më poshtë për detaje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Legal
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Tatimi aktual lloji nuk mund të përfshihen në normë Item në rresht {0}
DocType: Bank Guarantee,Customer,Klient
DocType: Purchase Receipt Item,Required By,Kërkohet nga
DocType: Delivery Note,Return Against Delivery Note,Kthehu Kundër dorëzimit Shënim
DocType: Purchase Order,% Billed,% Faturuar
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Exchange Rate duhet të jetë i njëjtë si {0} {1} ({2})
DocType: Sales Invoice,Customer Name,Emri i Klientit
DocType: Vehicle,Natural Gas,Gazit natyror
apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Llogari bankare nuk mund të quhet si {0}
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Kokat (ose grupe) kundër të cilit Hyrjet e kontabilitetit janë bërë dhe bilancet janë të mirëmbajtura.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Shquar për {0} nuk mund të jetë më pak se zero ({1})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348,There are no submitted Salary Slips to process.,Nuk ka skeda të pagave të paraqitura për t&#39;u përpunuar.
DocType: Manufacturing Settings,Default 10 mins,Default 10 minuta
DocType: Leave Type,Leave Type Name,Lini Lloji Emri
apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Trego të hapur
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Është e nevojshme që sot të merret vetë ky veprim për ato që përmenden më sipër
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156,Series Updated Successfully,Seria Përditësuar sukses
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,arkë
DocType: Pricing Rule,Apply On,Apliko On
DocType: Item Price,Multiple Item prices.,Çmimet shumta artikull.
,Purchase Order Items To Be Received,Items Rendit Blerje të pranohen
DocType: SMS Center,All Supplier Contact,Të gjitha Furnizuesi Kontakt
DocType: Support Settings,Support Settings,Cilësimet mbështetje
apps/erpnext/erpnext/projects/doctype/project/project.py +75,Expected End Date can not be less than Expected Start Date,Pritet Data e Përfundimit nuk mund të jetë më pak se sa pritej Data e fillimit
apps/erpnext/erpnext/utilities/transaction_base.py +121,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Norma duhet të jetë i njëjtë si {1}: {2} ({3} / {4})
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241,New Leave Application,New Pushimi Aplikimi
,Batch Item Expiry Status,Batch Item Status skadimit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Draft Bank
DocType: Membership,membership validaty section,seksioni validaty anëtarësimit
DocType: Mode of Payment Account,Mode of Payment Account,Mënyra e Llogarisë Pagesave
DocType: Consultation,Consultation,këshillim
DocType: Accounts Settings,Show Payment Schedule in Print,Trego orarin e pagesës në Print
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Shitjet dhe Kthimet
apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Shfaq Variantet
DocType: Academic Term,Academic Term,Term akademik
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,material
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Marrja e faqes
DocType: Opening Invoice Creation Tool Item,Quantity,Sasi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Llogaritë tabelë nuk mund të jetë bosh.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Kredi (obligimeve)
DocType: Employee Education,Year of Passing,Viti i kalimit
DocType: Item,Country of Origin,Vendi i origjinës
DocType: Soil Texture,Soil Texture Criteria,Kriteret e Cilësi të Tokës
apps/erpnext/erpnext/templates/includes/product_page.js +25,In Stock,Në magazinë
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Detajet e Fillimit të Kontaktit
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Çështjet e hapura
DocType: Production Plan Item,Production Plan Item,Prodhimit Plani i artikullit
apps/erpnext/erpnext/hr/doctype/employee/employee.py +150,User {0} is already assigned to Employee {1},Përdoruesi {0} është caktuar tashmë për punonjësit {1}
DocType: Lab Test Groups,Add new line,Shto një rresht të ri
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Kujdes shëndetësor
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Vonesa në pagesa (ditë)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Kushtet e Pagesës Detailin e Modelit
DocType: Hotel Room Reservation,Guest Name,Emri i mysafirit
DocType: Lab Prescription,Lab Prescription,Kërkimi i laboratorit
,Delay Days,Vonesa Ditët
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,shpenzimeve të shërbimit
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899,Serial Number: {0} is already referenced in Sales Invoice: {1},Numri Serial: {0} është referuar tashmë në shitje Faturë: {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889,Invoice,Faturë
DocType: Purchase Invoice Item,Item Weight Details,Pesha Detajet e artikullit
DocType: Asset Maintenance Log,Periodicity,Periodicitet
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Viti Fiskal {0} është e nevojshme
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Distanca minimale midis rreshtave të bimëve për rritje optimale
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Mbrojtje
DocType: Salary Component,Abbr,Abbr
DocType: Appraisal Goal,Score (0-5),Rezultati (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,Row {0}: {1} {2} does not match with {3},Row {0}: {1} {2} nuk përputhet me {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77,Row # {0}:,Row # {0}:
DocType: Timesheet,Total Costing Amount,Total Shuma kushton
DocType: Delivery Note,Vehicle No,Automjeteve Nuk ka
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163,Please select Price List,"Ju lutem, përzgjidhni Lista e Çmimeve"
DocType: Accounts Settings,Currency Exchange Settings,Cilësimet e këmbimit valutor
apps/erpnext/erpnext/public/js/hub/hub_factory.js +61,Please check your network connection.,Kontrollo lidhjen tënde të rrjetit.
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: dokument Pagesa është e nevojshme për të përfunduar trasaction
DocType: Work Order Operation,Work In Progress,Punë në vazhdim
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Ju lutemi zgjidhni data
DocType: Daily Work Summary Group,Holiday List,Festa Lista
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Llogaritar
DocType: Hub Settings,Selling Price List,Lista e Çmimeve të Shitjes
DocType: Patient,Tobacco Current Use,Përdorimi aktual i duhanit
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Shitja e normës
DocType: Cost Center,Stock User,Stock User
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Company,Phone No,Telefoni Asnjë
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239,New {0}: #{1},New {0}: # {1}
DocType: Delivery Trip,Initial Email Notification Sent,Dërgimi fillestar i email-it është dërguar
,Sales Partners Commission,Shitjet Partnerët Komisioni
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Purchase Invoice,Rounding Adjustment,Rregullimi i rrumbullakosjes
apps/erpnext/erpnext/setup/doctype/company/company.py +46,Abbreviation cannot have more than 5 characters,Shkurtesa nuk mund të ketë më shumë se 5 karaktere
DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Orari Orari Orari i kohës
DocType: Payment Request,Payment Request,Kërkesë Pagesa
DocType: Asset,Value After Depreciation,Vlera Pas Zhvlerësimi
DocType: Student,O+,O +
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,i lidhur
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,date Pjesëmarrja nuk mund të jetë më pak se data bashkuar punëmarrësit
DocType: Grading Scale,Grading Scale Name,Nota Scale Emri
DocType: Subscription,Repeat on Day,Përsëriteni Ditën
apps/erpnext/erpnext/accounts/doctype/account/account.js +37,This is a root account and cannot be edited.,Kjo është një llogari rrënjë dhe nuk mund të redaktohen.
DocType: Sales Invoice,Company Address,adresa e kompanise
DocType: BOM,Operations,Operacionet
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Nuk mund të vendosni autorizim në bazë të zbritje për {0}
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Bashkangjit CSV fotografi me dy kolona, njëra për emrin e vjetër dhe një për emrin e ri"
apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} ne asnje vitit aktiv Fiskal.
DocType: Packed Item,Parent Detail docname,Docname prind Detail
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}",Referenca: {0} Artikull Code: {1} dhe klientit: {2}
apps/erpnext/erpnext/utilities/user_progress.py +146,Kg,Kg
apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Hapja për një punë.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114,BOM is not specified for subcontracting item {0} at row {1},BOM nuk është specifikuar për nënkontraktimin e sendit {0} në rreshtin {1}
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Rezultati i paraqitur
DocType: Item Attribute,Increment,Rritje
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Intervalin kohor
apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Warehouse...,Zgjidh Magazina ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Reklamat
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Njëjta kompani është futur më shumë se një herë
DocType: Patient,Married,I martuar
apps/erpnext/erpnext/accounts/party.py +41,Not permitted for {0},Nuk lejohet për {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Të marrë sendet nga
DocType: Price List,Price Not UOM Dependant,Çmimi nuk është UOM i varur
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467,Stock cannot be updated against Delivery Note {0},Stock nuk mund të rifreskohet kundër dorëzimit Shënim {0}
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Product {0}
apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Nuk ka artikuj të listuara
DocType: Asset Repair,Error Description,Përshkrimi i gabimit
DocType: Payment Reconciliation,Reconcile,Pajtojë
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Ushqimore
DocType: Quality Inspection Reading,Reading 1,Leximi 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Fondet pensionale
apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,Zhvlerësimi Date tjetër nuk mund të jetë më parë data e blerjes
DocType: Crop,Perennial,gjithëvjetor
DocType: Consultation,Consultation Date,Data e konsultimit
DocType: Accounts Settings,Use Custom Cash Flow Format,Përdorni Custom Flow Format Custom
DocType: SMS Center,All Sales Person,Të gjitha Person Sales
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Shpërndarja mujore ** ju ndihmon të shpërndani Buxhetore / Target gjithë muaj nëse keni sezonalitetit në biznesin tuaj.
apps/erpnext/erpnext/accounts/page/pos/pos.js +1753,Not items found,Nuk sende gjetur
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184,Salary Structure Missing,Struktura Paga Missing
DocType: Lead,Person Name,Emri personi
DocType: Sales Invoice Item,Sales Invoice Item,Item Shitjet Faturë
DocType: Account,Credit,Kredi
DocType: POS Profile,Write Off Cost Center,Shkruani Off Qendra Kosto
apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",p.sh. &quot;Shkolla fillore&quot; ose &quot;University&quot;
apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Stock Raportet
DocType: Warehouse,Warehouse Detail,Magazina Detail
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Term End Date nuk mund të jetë më vonë se Data Year fund të vitit akademik në të cilin termi është i lidhur (Viti Akademik {}). Ju lutem, Korrigjo datat dhe provoni përsëri."
apps/erpnext/erpnext/stock/doctype/item/item.py +269,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;A është e aseteve fikse&quot; nuk mund të jetë e pakontrolluar, pasi ekziston rekord Pasurive ndaj artikullit"
DocType: Delivery Trip,Departure Time,Koha e Nisjes
DocType: Vehicle Service,Brake Oil,Brake Oil
DocType: Tax Rule,Tax Type,Lloji Tatimore
,Completed Work Orders,Urdhrat e Kompletuara të Punës
apps/erpnext/erpnext/controllers/taxes_and_totals.py +581,Taxable Amount,Shuma e tatueshme
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Ju nuk jeni i autorizuar për të shtuar ose shënimet e para përditësim {0}
DocType: BOM,Item Image (if not slideshow),Item Image (nëse nuk Slideshow)
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Ore Rate / 60) * aktuale Operacioni Koha
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Rreshti # {0}: Referenca Lloji i Dokumentit duhet të jetë një nga Kërkesat e Shpenzimeve ose Hyrja në Regjistrim
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975,Select BOM,Zgjidh BOM
DocType: SMS Log,SMS Log,SMS Identifikohu
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Kostoja e Artikujve dorëzohet
apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Menaxhoni shumën paraprake që i jepet punonjësit
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Festa në {0} nuk është në mes Nga Data dhe To Date
DocType: Student Log,Student Log,Student Identifikohu
apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Modelet e renditjes së furnizuesit.
DocType: Lead,Interested,I interesuar
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216,Opening,Hapje
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Nga {0} në {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234,Program: ,program:
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Dështoi në vendosjen e taksave
DocType: Item,Copy From Item Group,Kopje nga grupi Item
DocType: Delivery Trip,Delivery Notification,Njoftimi i Dorëzimit
DocType: Journal Entry,Opening Entry,Hyrja Hapja
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Llogaria Pay Vetëm
DocType: Employee Loan,Repay Over Number of Periods,Paguaj Over numri i periudhave
DocType: Stock Entry,Additional Costs,Kostot shtesë
apps/erpnext/erpnext/accounts/doctype/account/account.py +138,Account with existing transaction can not be converted to group.,Llogaria me transaksion ekzistuese nuk mund të konvertohet në grup.
DocType: Lead,Product Enquiry,Produkt Enquiry
DocType: Education Settings,Validate Batch for Students in Student Group,Vlereso Batch për Studentët në Grupin e Studentëve
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Nuk ka rekord leje gjetur për punonjës {0} për {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Ju lutemi shkruani kompani parë
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365,Please select Company first,Ju lutemi zgjidhni kompania e parë
DocType: Employee Education,Under Graduate,Nën diplomuar
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Target Në
DocType: BOM,Total Cost,Kostoja Totale
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Journal Entry Account,Employee Loan,Kredi punonjës
DocType: Fee Schedule,Send Payment Request Email,Dërgoni Email Kërkesën për Pagesë
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268,Item {0} does not exist in the system or has expired,Item {0} nuk ekziston në sistemin apo ka skaduar
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Real Estate
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Deklarata e llogarisë
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmaceutike
DocType: Purchase Invoice Item,Is Fixed Asset,Është i aseteve fikse
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +313,"Available qty is {0}, you need {1}","Qty në dispozicion është {0}, ju duhet {1}"
DocType: Expense Claim Detail,Claim Amount,Shuma Claim
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +679,Work Order has been {0},Rendi i punës ka qenë {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Grupi i konsumatorëve Duplicate gjenden në tabelën e grupit cutomer
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Furnizuesi Lloji / Furnizuesi
DocType: Naming Series,Prefix,Parashtesë
apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Vendi i ngjarjes
DocType: Asset Settings,Asset Settings,Cilësimet e Aseteve
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Harxhuese
DocType: Student,B-,B-
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +140,Successfully unregistered.,S&#39;aktivizohet me sukses.
DocType: Assessment Result,Grade,Gradë
DocType: Restaurant Table,No of Seats,Jo e Vendeve
DocType: Subscription,"To add dynamic subject, use jinja tags like

<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Për të shtuar lëndë dinamike, përdorni etiketat jinja si <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
DocType: Sales Invoice Item,Delivered By Supplier,Dorëzuar nga furnizuesi
DocType: Asset Maintenance Task,Asset Maintenance Task,Detyra e mirëmbajtjes së aseteve
DocType: SMS Center,All Contact,Të gjitha Kontakt
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Annual Salary,Paga vjetore
DocType: Daily Work Summary,Daily Work Summary,Daily Përmbledhje Work
DocType: Period Closing Voucher,Closing Fiscal Year,Mbyllja e Vitit Fiskal
apps/erpnext/erpnext/accounts/party.py +392,{0} {1} is frozen,{0} {1} është e ngrirë
apps/erpnext/erpnext/setup/doctype/company/company.py +140,Please select Existing Company for creating Chart of Accounts,"Ju lutem, përzgjidhni kompanie ekzistuese për krijimin Skemën e Kontabilitetit"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Stock Shpenzimet
apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Zgjidhni Target Magazina
apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Zgjidhni Target Magazina
apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Ju lutemi shkruani Preferred miqve
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 Hyrja
DocType: Journal Entry Account,Credit in Company Currency,Kreditit në kompanisë Valuta
DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
DocType: Delivery Note,Installation Status,Instalimi Statusi
DocType: BOM,Quality Inspection Template,Modeli i Inspektimit të Cilësisë
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}",A doni për të rinovuar pjesëmarrjen? <br> Prezent: {0} \ <br> Mungon: {1}
apps/erpnext/erpnext/controllers/buying_controller.py +350,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Pranuar + Refuzuar Qty duhet të jetë e barabartë me sasinë e pranuara për Item {0}
DocType: Request for Quotation,RFQ-,RFQ-
DocType: Item,Supply Raw Materials for Purchase,Furnizimit të lëndëve të para për Blerje
DocType: Agriculture Analysis Criteria,Fertilizer,pleh
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152,At least one mode of payment is required for POS invoice.,Të paktën një mënyra e pagesës është e nevojshme për POS faturë.
DocType: Products Settings,Show Products as a List,Shfaq Produkte si një Lista
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +574,Item {0} is not active or end of life has been reached,Item {0} nuk është aktiv apo fundi i jetës është arritur
DocType: Student Admission Program,Minimum Age,Mosha minimale
apps/erpnext/erpnext/utilities/user_progress.py +190,Example: Basic Mathematics,Shembull: Matematikë themelore
DocType: Customer,Primary Address,Adresa Primare
DocType: Production Plan,Material Request Detail,Detaji i Kërkesës Materiale
DocType: Selling Settings,Default Quotation Validity Days,Ditët e vlefshmërisë së çmimeve të çmimeve
apps/erpnext/erpnext/controllers/accounts_controller.py +802,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Të përfshijnë tatimin në rresht {0} në shkallën Item, taksat në rreshtat {1} duhet të përfshihen edhe"
apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Cilësimet për HR Module
DocType: SMS Center,SMS Center,SMS Center
DocType: Sales Invoice,Change Amount,Ndryshimi Shuma
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Vendosni vlerën e faturave për B2C. B2CL dhe B2CS llogariten bazuar në vlerën e faturës.
DocType: BOM Update Tool,New BOM,Bom i ri
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Trego vetëm POS
DocType: Driver,Driving License Categories,Kategoritë e Licencës së Drejtimit
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Ju lutemi shkruani datën e dorëzimit
DocType: Depreciation Schedule,Make Depreciation Entry,Bëni Amortizimi Hyrja
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Kërkesë Type
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17,Make Employee,bëni punonjës
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Transmetimi
apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Modaliteti i konfigurimit të POS (Online / Offline)
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Çaktivizon krijimin e regjistrave të kohës ndaj urdhrave të punës. Operacionet nuk do të gjurmohen kundër Rendit Punë
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Ekzekutim
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Detajet e operacioneve të kryera.
DocType: Asset Maintenance Log,Maintenance Status,Mirëmbajtja Statusi
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Detajet e Anëtarësimit
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Furnizuesi është i detyruar kundrejt llogarisë pagueshme {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Artikuj dhe Çmimeve
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Gjithsej orë: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Nga Data duhet të jetë brenda vitit fiskal. Duke supozuar Nga Data = {0}
DocType: Drug Prescription,Interval,interval
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253,Preference,preferencë
DocType: Grant Application,Individual,Individ
DocType: Academic Term,Academics User,akademikët User
DocType: Cheque Print Template,Amount In Figure,Shuma Në Figurën
DocType: Employee Loan Application,Loan Info,kredi Info
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plani për vizita të mirëmbajtjes.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Periudha e rezultateve të furnitorit
DocType: Share Transfer,Share Transfer,Transferimi i aksioneve
DocType: POS Profile,Customer Groups,Grupet e konsumatorëve
apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Pasqyrat financiare
DocType: Guardian,Students,studentët
apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Rregullat për aplikimin e çmimeve dhe zbritje.
DocType: Daily Work Summary,Daily Work Summary Group,Grupi Përmbledhës i Punës Ditore
DocType: Physician Schedule,Time Slots,Hapat e kohës
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Lista çmimi duhet të jetë i zbatueshëm për blerjen ose shitjen e
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Data Instalimi nuk mund të jetë para datës së dorëzimit për pika {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Zbritje në listën e çmimeve Norma (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Modeli i artikullit
apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,biokimi
DocType: Job Offer,Select Terms and Conditions,Zgjidhni Termat dhe Kushtet
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Out Value,Vlera out
DocType: Woocommerce Settings,Woocommerce Settings,Cilësimet e Woocommerce
DocType: Production Plan,Sales Orders,Sales Urdhërat
DocType: Purchase Taxes and Charges,Valuation,Vlerësim
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +394,Set as Default,Vendosur si default
DocType: Production Plan,PLN-,PLN-
,Purchase Order Trends,Rendit Blerje Trendet
apps/erpnext/erpnext/utilities/user_progress.py +78,Go to Customers,Shkoni tek Konsumatorët
DocType: Hotel Room Reservation,Late Checkin,Kontroll i vonuar
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Kërkesa për kuotim mund të arrihen duke klikuar në linkun e mëposhtëm
apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Alokimi i lë për vitin.
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Kursi Krijimi Tool
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +315,Insufficient Stock,Stock pamjaftueshme
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Planifikimi Disable kapaciteteve dhe Ndjekja Koha
DocType: Email Digest,New Sales Orders,Shitjet e reja Urdhërat
DocType: Bank Guarantee,Bank Account,Llogarisë Bankare
DocType: Leave Type,Allow Negative Balance,Lejo bilancit negativ
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Ju nuk mund të fshini llojin e projektit &#39;Jashtë&#39;
apps/erpnext/erpnext/public/js/utils.js +194,Select Alternate Item,Zgjidh artikullin alternativ
DocType: Employee,Create User,Krijo përdoruesin
DocType: Selling Settings,Default Territory,Gabim Territorit
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televizion
DocType: Work Order Operation,Updated via 'Time Log',Përditësuar nëpërmjet &#39;Koha Identifikohu &quot;
apps/erpnext/erpnext/controllers/taxes_and_totals.py +430,Advance amount cannot be greater than {0} {1},shuma paraprakisht nuk mund të jetë më i madh se {0} {1}
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,JournalCode
DocType: Naming Series,Series List for this Transaction,Lista Seria për këtë transaksion
DocType: Company,Enable Perpetual Inventory,Aktivizo Inventari Përhershëm
DocType: Company,Default Payroll Payable Account,Default Payroll Llogaria e pagueshme
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Update Email Group
DocType: Sales Invoice,Is Opening Entry,Është Hapja Hyrja
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Nëse nuk kontrollohet, artikulli nuk do të shfaqet në Faturën e Shitjes, por mund të përdoret në krijimin e testeve në grup."
DocType: Customer Group,Mention if non-standard receivable account applicable,Përmend në qoftë se jo-standarde llogari të arkëtueshme të zbatueshme
DocType: Course Schedule,Instructor Name,instruktor Emri
DocType: Supplier Scorecard,Criteria Setup,Vendosja e kritereve
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206,For Warehouse is required before Submit,Për Magazina është e nevojshme para se të Submit
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Marrë më
DocType: Sales Partner,Reseller,Reseller
DocType: Codification Table,Medical Code,Kodi mjekësor
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Ju lutemi shkruani Company
DocType: Delivery Note Item,Against Sales Invoice Item,Kundër Item Shitjet Faturë
DocType: Agriculture Analysis Criteria,Linked Doctype,Doktrup i lidhur
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44,Net Cash from Financing,Paraja neto nga Financimi
apps/erpnext/erpnext/accounts/page/pos/pos.js +2371,"LocalStorage is full , did not save","LocalStorage është e plotë, nuk ka shpëtuar"
DocType: Lead,Address & Contact,Adresa &amp; Kontakt
DocType: Leave Allocation,Add unused leaves from previous allocations,Shtoni gjethe të papërdorura nga alokimet e mëparshme
DocType: Sales Partner,Partner website,website partner
DocType: Restaurant Order Entry,Add Item,Shto Item
DocType: Lab Test,Custom Result,Rezultati personal
DocType: Delivery Stop,Contact Name,Kontakt Emri
DocType: Course Assessment Criteria,Course Assessment Criteria,Kriteret e vlerësimit kurs
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Tax Id: ,Identiteti i taksave:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216,Student ID: ,Student ID:
DocType: POS Customer Group,POS Customer Group,POS Group Customer
DocType: Land Unit,Land Unit describing various land assets,Njësia e Tokës që përshkruan pasuritë e ndryshme të tokës
DocType: Cheque Print Template,Line spacing for amount in words,Hapësira Line për shumën në fjalë
DocType: Vehicle,Additional Details,Detaje shtesë
apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Nuk ka përshkrim dhënë
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Kërkesë për blerje.
DocType: Lab Test,Submitted Date,Data e Dërguar
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Kjo është e bazuar në Fletët Koha krijuara kundër këtij projekti
,Open Work Orders,Urdhërat e Hapur të Punës
DocType: Payment Term,Credit Months,Muajt e Kredisë
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Pay Net nuk mund të jetë më pak se 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","Për të ndaluar dërgimin e njoftimeve të përsëritura të gabimit nga sistemi, ne kemi kontrolluar fushën e Kufizuar në pajtim"
apps/erpnext/erpnext/hr/doctype/employee/employee.py +122,Relieving Date must be greater than Date of Joining,Lehtësimin Data duhet të jetë më i madh se data e bashkimit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240,Leaves per Year,Lë në vit
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.,Row {0}: Ju lutem kontrolloni &#39;A Advance&#39; kundër llogaria {1} në qoftë se kjo është një hyrje paraprakisht.
apps/erpnext/erpnext/stock/utils.py +219,Warehouse {0} does not belong to company {1},Magazina {0} nuk i përkasin kompanisë {1}
DocType: Email Digest,Profit & Loss,Fitimi dhe Humbja
apps/erpnext/erpnext/utilities/user_progress.py +147,Litre,Litra
DocType: Task,Total Costing Amount (via Time Sheet),Total Kostoja Shuma (via Koha Sheet)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76,Please setup Students under Student Groups,Ju lutemi të organizoni Studentët nën Grupet Studentore
DocType: Item Website Specification,Item Website Specification,Item Faqja Specifikimi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449,Leave Blocked,Lini Blocked
apps/erpnext/erpnext/stock/doctype/item/item.py +740,Item {0} has reached its end of life on {1},Item {0} ka arritur në fund të saj të jetës në {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83,Bank Entries,Banka Entries
DocType: Crop,Annual,Vjetor
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Pajtimi Item
DocType: Stock Entry,Sales Invoice No,Shitjet Faturë Asnjë
DocType: Material Request Item,Min Order Qty,Rendit min Qty
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Kursi Group Student Krijimi Tool
DocType: Lead,Do Not Contact,Mos Kontaktoni
apps/erpnext/erpnext/utilities/user_progress.py +210,People who teach at your organisation,Njerëzit të cilët japin mësim në organizatën tuaj
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Software Developer
DocType: Item,Minimum Order Qty,Minimale Rendit Qty
DocType: Pricing Rule,Supplier Type,Furnizuesi Type
DocType: Course Scheduling Tool,Course Start Date,Sigurisht Data e fillimit
,Student Batch-Wise Attendance,Batch-Wise Student Pjesëmarrja
DocType: POS Profile,Allow user to edit Rate,Lejo përdoruesit për të redaktuar Vlerësoni
DocType: Item,Publish in Hub,Publikojë në Hub
DocType: Student Admission,Student Admission,Pranimi Student
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +762,Item {0} is cancelled,Item {0} është anuluar
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064,Material Request,Kërkesë materiale
DocType: Bank Reconciliation,Update Clearance Date,Update Pastrimi Data
,GSTR-2,GSTR-2
DocType: Item,Purchase Details,Detajet Blerje
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +448,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Item {0} nuk u gjet në &#39;e para materiale të furnizuara &quot;tryezë në Rendit Blerje {1}
DocType: Salary Slip,Total Principal Amount,Shuma Totale Totale
DocType: Student Guardian,Relation,Lidhje
DocType: Student Guardian,Mother,nënë
DocType: Restaurant Reservation,Reservation End Time,Koha e përfundimit të rezervimit
DocType: Crop,Biennial,dyvjeçar
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Urdhra të konfirmuara nga konsumatorët.
DocType: Purchase Receipt Item,Rejected Quantity,Sasi të refuzuar
apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Kërkesa për pagesë {0} u krijua
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Open Orders,Urdhërat e Hapur
apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Ndjeshmëri e ulët
DocType: Notification Control,Notification Control,Kontrolli Njoftim
apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Ju lutemi konfirmoni sapo të keni përfunduar trajnimin tuaj
DocType: Lead,Suggestions,Sugjerime
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Item buxhetet Grupi-i mençur në këtë territor. Ju gjithashtu mund të përfshijë sezonalitetin duke vendosur të Shpërndarjes.
DocType: Payment Term,Payment Term Name,Emri i Termit të Pagesës
DocType: Healthcare Settings,Create documents for sample collection,Krijo dokumente për mbledhjen e mostrave
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Pagesës kundër {0} {1} nuk mund të jetë më i madh se Outstanding Sasia {2}
DocType: Shareholder,Address HTML,Adresa HTML
DocType: Lead,Mobile No.,Mobile Nr
DocType: Maintenance Schedule,Generate Schedule,Generate Orari
DocType: Purchase Invoice Item,Expense Head,Shpenzim Shef
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138,Please select Charge Type first,"Ju lutem, përzgjidhni Ngarkesa Lloji i parë"
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.. ","Ju mund të përcaktoni të gjitha detyrat që duhet të kryhen për këtë kulture këtu. Fusha ditore përdoret për të përmendur ditën në të cilën duhet kryer detyra, 1 është dita e parë, etj."
DocType: Student Group Student,Student Group Student,Student Group Student
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Fundit
DocType: Asset Maintenance Task,2 Yearly,2 vjetore
DocType: Education Settings,Education Settings,Cilësimet e edukimit
DocType: Vehicle Service,Inspection,inspektim
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Email Digest,New Quotations,Citate të reja
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Emails paga shqip për punonjës të bazuar në email preferuar zgjedhur në punonjësi
DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,Aprovuesi i parë Leave në listë do të jetë vendosur si default Leave aprovuesi
DocType: Tax Rule,Shipping County,Shipping County
apps/erpnext/erpnext/config/desktop.py +167,Learn,Mëso
DocType: Asset,Next Depreciation Date,Zhvlerësimi Data Next
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Aktiviteti Kosto për punonjës
DocType: Accounts Settings,Settings for Accounts,Cilësimet për Llogaritë
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673,Supplier Invoice No exists in Purchase Invoice {0},Furnizuesi Fatura Nuk ekziston në Blerje Faturë {0}
apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Manage shitjes person Tree.
DocType: Job Applicant,Cover Letter,Cover Letter
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Çeqet e papaguara dhe Depozitat për të pastruar
DocType: Item,Synced With Hub,Synced Me Hub
DocType: Driver,Fleet Manager,Fleet Menaxher
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} nuk mund të jetë negative për artikull {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +86,Wrong Password,Gabuar Fjalëkalimi
DocType: Item,Variant Of,Variant i
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406,Completed Qty can not be greater than 'Qty to Manufacture',Kompletuar Qty nuk mund të jetë më i madh se &quot;Qty për Prodhimi&quot;
DocType: Period Closing Voucher,Closing Account Head,Mbyllja Shef Llogaria
DocType: Employee,External Work History,Historia e jashtme
apps/erpnext/erpnext/projects/doctype/task/task.py +111,Circular Reference Error,Qarkorja Referenca Gabim
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206,Student Report Card,Kartela e Raportimit të Studentëve
DocType: Appointment Type,Is Inpatient,Është pacient
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Emri Guardian1
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Me fjalë (eksport) do të jetë i dukshëm një herë ju ruani notën shpërndarëse.
DocType: Cheque Print Template,Distance from left edge,Largësia nga buzë e majtë
apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} njësitë e [{1}] (# Forma / Item / {1}) gjenden në [{2}] (# Forma / Magazina / {2})
DocType: Lead,Industry,Industri
DocType: Employee,Job Profile,Profile Job
DocType: BOM Item,Rate & Amount,Rate &amp; Shuma
apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Kjo bazohet në transaksione kundër kësaj kompanie. Shiko detajet më poshtë për detaje
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Njoftojë me email për krijimin e kërkesës automatike materiale
apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,i qëndrueshëm
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Ju lutemi përcaktoni vlerën e dhomës së hotelit në {}
DocType: Journal Entry,Multi Currency,Multi Valuta
DocType: Opening Invoice Creation Tool,Invoice Type,Lloji Faturë
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939,Delivery Note,Ofrimit Shënim
DocType: Consultation,Encounter Impression,Impresioni i takimit
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Ngritja Tatimet
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Kostoja e asetit të shitur
DocType: Volunteer,Morning,mëngjes
apps/erpnext/erpnext/accounts/utils.py +345,Payment Entry has been modified after you pulled it. Please pull it again.,"Pagesa Hyrja është ndryshuar, pasi që ju nxorrën atë. Ju lutemi të tërheqë atë përsëri."
DocType: Program Enrollment Tool,New Student Batch,Grupi i ri i Studentëve
apps/erpnext/erpnext/stock/doctype/item/item.py +479,{0} entered twice in Item Tax,{0} hyrë dy herë në Tatimin Item
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Përmbledhje për këtë javë dhe aktivitete në pritje
DocType: Student Applicant,Admitted,pranuar
DocType: Workstation,Rent Cost,Qira Kosto
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Shuma Pas Zhvlerësimi
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Ardhshme Ngjarje Kalendari
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Atributet variant
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,"Ju lutem, përzgjidhni muaji dhe viti"
DocType: Employee,Company Email,Kompania Email
DocType: GL Entry,Debit Amount in Account Currency,Shuma Debi në llogarinë në valutë
DocType: Supplier Scorecard,Scoring Standings,Renditja e rezultateve
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Vlera Order
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Vlera Order
apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Bank / Cash transaksionet kundër partisë apo për transferimin e brendshëm
DocType: Shipping Rule,Valid for Countries,I vlefshëm për vendet
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,Ky artikull është një Template dhe nuk mund të përdoret në transaksionet. Atribute pika do të kopjohet gjatë në variantet nëse nuk është vendosur &quot;Jo Copy &#39;
DocType: Grant Application,Grant Application,Aplikimi i Grantit
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Rendit Gjithsej konsideruar
apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Përcaktimi Punonjës (p.sh. CEO, drejtor etj)."
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Shkalla në të cilën Valuta Customer është konvertuar në bazë monedhën klientit
DocType: Course Scheduling Tool,Course Scheduling Tool,Sigurisht caktimin Tool
apps/erpnext/erpnext/controllers/accounts_controller.py +623,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Blerje Fatura nuk mund të bëhet kundër një aktiv ekzistues {1}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257,[Urgent] Error while creating recurring %s for %s,[Urgjent] Gabim gjatë krijimit të përsëritjes% s për% s
DocType: Land Unit,LInked Analysis,LInked Analiza
DocType: Item Tax,Tax Rate,Shkalla e tatimit
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73,Application period cannot be across two allocation records,Periudha e aplikimit nuk mund të jetë në të dy regjistrimet e shpërndarjes
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} ndarë tashmë për punonjësit {1} për periudhën {2} në {3}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,Purchase Invoice {0} is already submitted,Blerje Fatura {0} është dorëzuar tashmë
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92,Row # {0}: Batch No must be same as {1} {2},Row # {0}: Batch Nuk duhet të jetë i njëjtë si {1} {2}
DocType: Material Request Plan Item,Material Request Plan Item,Plani i Kërkesës Materiale Plani
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Convert për të jo-Group
DocType: Project Update,Good/Steady,Mirë / Steady
DocType: C-Form Invoice Detail,Invoice Date,Data e faturës
DocType: GL Entry,Debit Amount,Shuma Debi
apps/erpnext/erpnext/accounts/party.py +248,There can only be 1 Account per Company in {0} {1},Nuk mund të jetë vetëm 1 Llogaria për Kompaninë në {0} {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,Ju lutem shikoni shtojcën
DocType: Purchase Order,% Received,% Marra
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Krijo Grupet Student
DocType: Volunteer,Weekends,fundjavë
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +125,Credit Note Amount,Credit Note Shuma
DocType: Setup Progress Action,Action Document,Dokumenti i Veprimit
DocType: Chapter Member,Website URL,Website URL
,Finished Goods,Mallrat përfunduar
DocType: Delivery Note,Instructions,Udhëzime
DocType: Quality Inspection,Inspected By,Inspektohen nga
DocType: Asset Maintenance Log,Maintenance Type,Mirëmbajtja Type
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} nuk është i regjistruar në lëndës {2}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225,Student Name: ,Emri i studentit:
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serial Asnjë {0} nuk i përket dorëzimit Shënim {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97,"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Duket të ketë një problem me konfigurimin GoCardless të serverit. Mos u shqetësoni, në rast të dështimit, shuma do të kthehet në llogarinë tuaj."
apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Shto Items
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Item Cilësia Inspektimi Parametri
DocType: Depreciation Schedule,Schedule Date,Orari Data
apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Fitimet, Zbritjet dhe komponentëve të tjerë e pagave"
DocType: Packed Item,Packed Item,Item mbushur
DocType: Job Offer Term,Job Offer Term,Afati i ofertës së punës
apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Default settings për blerjen e transaksioneve.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Kosto Aktiviteti ekziston për punonjësit {0} kundër Aktivizimi Tipi - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Fushë e detyrueshme - Get Studentët nga
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Fushë e detyrueshme - Get Studentët nga
DocType: Program Enrollment,Enrolled courses,kurse regjistruar
DocType: Program Enrollment,Enrolled courses,kurse regjistruar
DocType: Currency Exchange,Currency Exchange,Currency Exchange
DocType: Opening Invoice Creation Tool Item,Item Name,Item Emri
DocType: Authorization Rule,Approving User  (above authorized value),Miratimi përdoruesin (mbi vlerën e autorizuar)
DocType: Email Digest,Credit Balance,Bilanci krediti
DocType: Employee,Widowed,Ve
DocType: Request for Quotation,Request for Quotation,Kërkesa për kuotim
DocType: Healthcare Settings,Require Lab Test Approval,Kërkoni miratimin e testit të laboratorit
DocType: Salary Slip Timesheet,Working Hours,Orari i punës
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +66,Total Outstanding,Gjithsej Outstanding
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Ndryshimi filluar / numrin e tanishëm sekuencë e një serie ekzistuese.
DocType: Dosage Strength,Strength,Forcë
apps/erpnext/erpnext/accounts/page/pos/pos.js +1534,Create a new Customer,Krijo një klient i ri
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.","Nëse Rregullat shumta Çmimeve të vazhdojë të mbizotërojë, përdoruesit janë të kërkohet për të vendosur përparësi dorë për të zgjidhur konfliktin."
apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Krijo urdhëron Blerje
,Purchase Register,Blerje Regjistrohu
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116,Patient not found,Pacienti nuk u gjet
DocType: Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,Akuzat e aplikueshme
DocType: Workstation,Consumable Cost,Kosto harxhuese
DocType: Purchase Receipt,Vehicle Date,Data e Automjeteve
DocType: Student Log,Medical,Mjekësor
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Reason for losing,Arsyeja për humbjen
apps/erpnext/erpnext/accounts/doctype/account/account.js +46,Update Account Number,Përditëso numrin e llogarisë
apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Lead Owner cannot be same as the Lead,Owner Lead nuk mund të jetë i njëjtë si Lead
apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,Shuma e ndarë nuk mund të më e madhe se shuma e parregulluara
DocType: Announcement,Receiver,marrës
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation është i mbyllur në datat e mëposhtme sipas Holiday Lista: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Mundësitë
DocType: Lab Test Template,Single,I vetëm
DocType: Salary Slip,Total Loan Repayment,Ripagimi Total Loan
DocType: Account,Cost of Goods Sold,Kostoja e mallrave të shitura
DocType: Subscription,Yearly,Vjetor
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,Ju lutemi shkruani Qendra Kosto
DocType: Drug Prescription,Dosage,dozim
DocType: Journal Entry Account,Sales Order,Sales Order
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Avg. Shitja Rate
DocType: Assessment Plan,Examiner Name,Emri Examiner
DocType: Lab Test Template,No Result,asnjë Rezultat
DocType: Purchase Invoice Item,Quantity and Rate,Sasia dhe Rate
DocType: Delivery Note,% Installed,% Installed
apps/erpnext/erpnext/utilities/user_progress.py +230,Classrooms/ Laboratories etc where lectures can be scheduled.,"Klasat / laboratore etj, ku mësimi mund të jenë të planifikuara."
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Ju lutem shkruani emrin e kompanisë e parë
DocType: Purchase Invoice,Supplier Name,Furnizuesi Emri
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Lexoni Manualin ERPNext
DocType: Purchase Invoice,01-Sales Return,01-Kthimi i shitjeve
DocType: Account,Is Group,Është grup
DocType: Email Digest,Pending Purchase Orders,Në pritje urdhëron Blerje
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatikisht Set Serial Nos bazuar në FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Kontrolloni Furnizuesi faturës Numri Unike
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Detajet e Fillores
DocType: Vehicle Service,Oil Change,Ndryshimi Oil
DocType: Asset Maintenance Log,Asset Maintenance Log,Regjistri i mirëmbajtjes së aseteve
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',&quot;Për Rasti Nr &#39; nuk mund të jetë më pak se &quot;nga rasti nr &#39;
DocType: Chapter,Non Profit,Non Profit
DocType: Production Plan,Not Started,Nuk ka filluar
DocType: Lead,Channel Partner,Channel Partner
DocType: Account,Old Parent,Vjetër Parent
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Fushë e detyrueshme - Viti akademik
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Fushë e detyrueshme - Viti akademik
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220,{0} {1} is not associated with {2} {3},{0} {1} nuk është i lidhur me {2} {3}
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Rregulloje tekstin hyrës që shkon si një pjesë e asaj email. Secili transaksion ka një tekst të veçantë hyrëse.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176,Please set default payable account for the company {0},Ju lutemi të vendosur llogari parazgjedhur pagueshëm për kompaninë {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +553,Transaction not allowed against stopped Work Order {0},Transaksioni nuk lejohet kundër urdhrit të ndaluar të punës {0}
DocType: Setup Progress Action,Min Doc Count,Min Dokumenti i Numrit
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Konfigurimet Global për të gjitha proceset e prodhimit.
DocType: Accounts Settings,Accounts Frozen Upto,Llogaritë ngrira Upto
DocType: SMS Log,Sent On,Dërguar në
apps/erpnext/erpnext/stock/doctype/item/item.py +700,Attribute {0} selected multiple times in Attributes Table,Atribut {0} zgjedhur disa herë në atributet Tabelën
DocType: HR Settings,Employee record is created using selected field. ,Rekord punonjës është krijuar duke përdorur fushën e zgjedhur.
DocType: Sales Order,Not Applicable,Nuk aplikohet
apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Mjeshtër pushime.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Çështja e hapjes së faturës
DocType: Request for Quotation Item,Required Date,Data e nevojshme
DocType: Delivery Note,Billing Address,Faturimi Adresa
DocType: BOM,Costing,Kushton
DocType: Tax Rule,Billing County,County Billing
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Nëse kontrolluar, shuma e taksave do të konsiderohen si të përfshirë tashmë në Printo Tarifa / Shuma Shtyp"
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,Mesazh për Furnizuesin
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40,Work Order,Rradhe pune
DocType: Driver,DRIVER-.#####,DRIVER -. #####
DocType: Sales Invoice,Total Qty,Gjithsej Qty
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
DocType: Item,Show in Website (Variant),Show në Website (Variant)
DocType: Employee,Health Concerns,Shqetësimet shëndetësore
DocType: Payroll Entry,Select Payroll Period,Zgjidhni Periudha Payroll
DocType: Purchase Invoice,Unpaid,I papaguar
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Rezervuar për shitje
DocType: Packing Slip,From Package No.,Nga Paketa nr
DocType: Item Attribute,To Range,Në rang
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Të letrave me vlerë dhe depozita
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","Nuk mund të ndryshojë metodën e vlerësimit, pasi ka transaksione kundër disa artikuj që nuk kanë se është metodë e vlerësimit"
DocType: Student Report Generation Tool,Attended by Parents,Të ndjekur nga Prindërit
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Gjithsej lë alokuara është i detyrueshëm
DocType: Patient,AB Positive,AB Pozitiv
DocType: Job Opening,Description of a Job Opening,Përshkrimi i një Hapja Job
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Pending activities for today,Aktivitetet në pritje për sot
apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Pjesëmarrja rekord.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Komponenti Paga për pasqyrë e mungesave pagave bazë.
DocType: Sales Order Item,Used for Production Plan,Përdoret për Planin e prodhimit
DocType: Employee Loan,Total Payment,Pagesa Total
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,Cannot cancel transaction for Completed Work Order.,Nuk mund të anulohet transaksioni për Urdhrin e Përfunduar të Punës.
DocType: Manufacturing Settings,Time Between Operations (in mins),Koha Midis Operacioneve (në minuta)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132,{0} {1} is cancelled so the action cannot be completed,{0} {1} është anuluar në mënyrë veprimi nuk mund të përfundojë
DocType: Customer,Buyer of Goods and Services.,Blerësi i mallrave dhe shërbimeve.
DocType: Journal Entry,Accounts Payable,Llogaritë e pagueshme
DocType: Patient,Allergies,Alergjia
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33,The selected BOMs are not for the same item,Të BOM përzgjedhur nuk janë për të njëjtin artikull
DocType: Supplier Scorecard Standing,Notify Other,Njoftoni Tjeter
DocType: Vital Signs,Blood Pressure (systolic),Presioni i gjakut (systolic)
DocType: Pricing Rule,Valid Upto,Valid Upto
DocType: Training Event,Workshop,punishte
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Paralajmëroni Urdhërat e Blerjes
apps/erpnext/erpnext/utilities/user_progress.py +67,List a few of your customers. They could be organizations or individuals.,Lista disa nga klientët tuaj. Ata mund të jenë organizata ose individë.
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Pjesë mjaftueshme për të ndërtuar
DocType: POS Profile User,POS Profile User,Profili i POS-ut
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Të ardhurat direkte
DocType: Patient Appointment,Date TIme,Data Përmbledhje
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,"Can not filter based on Account, if grouped by Account","Nuk mund të filtruar në bazë të llogarisë, në qoftë se të grupuara nga Llogaria"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Zyrtar Administrativ
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Vendosja e kompanisë dhe taksave
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,"Ju lutem, përzgjidhni Course"
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,"Ju lutem, përzgjidhni Course"
DocType: Codification Table,Codification Table,Tabela e kodifikimit
DocType: Timesheet Detail,Hrs,orë
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349,Please select Company,"Ju lutem, përzgjidhni Company"
DocType: Stock Entry Detail,Difference Account,Llogaria Diferenca
DocType: Purchase Invoice,Supplier GSTIN,furnizuesi GSTIN
apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Nuk mund detyrë afër sa detyra e saj të varur {0} nuk është e mbyllur.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,Ju lutem shkruani Magazina për të cilat do të ngrihen materiale Kërkesë
DocType: Work Order,Additional Operating Cost,Shtesë Kosto Operative
DocType: Lab Test Template,Lab Routine,Rutina e laboratorit
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kozmetikë
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Ju lutemi zgjidhni Datën e Përfundimit për Mirëmbajtjen e Mbaruar të Mirëmbajtjes së Aseteve
apps/erpnext/erpnext/stock/doctype/item/item.py +552,"To merge, following properties must be same for both items","Të bashkojë, pronat e mëposhtme duhet të jenë të njëjta për të dy artikujve"
DocType: Shipping Rule,Net Weight,Net Weight
DocType: Employee,Emergency Phone,Urgjencës Telefon
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} nuk ekziston.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,blej
,Serial No Warranty Expiry,Serial No Garanci Expiry
DocType: Sales Invoice,Offline POS Name,Offline POS Emri
apps/erpnext/erpnext/utilities/user_progress.py +180,Student Application,Aplikimi i studentëve
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Ju lutemi të përcaktuar klasën për Prag 0%
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Ju lutemi të përcaktuar klasën për Prag 0%
DocType: Sales Order,To Deliver,Për të ofruar
DocType: Purchase Invoice Item,Item,Artikull
apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Ndjeshmëri e lartë
apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Informacione Lloji Vullnetar.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Modeli i përcaktimit të rrjedhës së parasë së gatshme
apps/erpnext/erpnext/accounts/page/pos/pos.js +2551,Serial no item cannot be a fraction,Serial asnjë artikull nuk mund të jetë një pjesë
DocType: Journal Entry,Difference (Dr - Cr),Diferenca (Dr - Cr)
DocType: Account,Profit and Loss,Fitimi dhe Humbja
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104,"Not permitted, configure Lab Test Template as required","Nuk lejohet, konfiguroni Lab Test Template sipas kërkesës"
DocType: Patient,Risk Factors,Faktoret e rrezikut
DocType: Patient,Occupational Hazards and Environmental Factors,Rreziqet në punë dhe faktorët mjedisorë
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +279,Stock Entries already created for Work Order ,Regjistrimet e aksioneve tashmë të krijuara për Rendit të Punës
DocType: Vital Signs,Respiratory rate,Shkalla e frymëmarrjes
apps/erpnext/erpnext/config/stock.py +338,Managing Subcontracting,Menaxhimi Nënkontraktimi
DocType: Vital Signs,Body Temperature,Temperatura e trupit
DocType: Project,Project will be accessible on the website to these users,Projekti do të jetë në dispozicion në faqen e internetit të këtyre përdoruesve
DocType: Detected Disease,Disease,sëmundje
apps/erpnext/erpnext/config/projects.py +29,Define Project type.,Përcaktoni llojin e Projektit.
DocType: Supplier Scorecard,Weighting Function,Funksioni i peshimit
DocType: Physician,OP Consulting Charge,Ngarkimi OP Consulting
apps/erpnext/erpnext/utilities/user_progress.py +28,Setup your ,Setup your
DocType: Student Report Generation Tool,Show Marks,Trego Markat
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Shkalla në të cilën listë Çmimi monedhës është konvertuar në monedhën bazë kompanisë
apps/erpnext/erpnext/setup/doctype/company/company.py +70,Account {0} does not belong to company: {1},Llogaria {0} nuk i përkasin kompanisë: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +52,Abbreviation already used for another company,Shkurtesa e përdorur tashmë për një kompani tjetër
DocType: Selling Settings,Default Customer Group,Gabim Grupi Klientit
DocType: Asset Repair,ARLOG-,ARLOG-
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Nëse disable, fushë &quot;rrumbullakosura Totali i &#39;nuk do të jenë të dukshme në çdo transaksion"
DocType: BOM,Operating Cost,Kosto Operative
DocType: Crop,Produced Items,Artikujt e prodhuar
DocType: Sales Order Item,Gross Profit,Fitim bruto
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Rritja nuk mund të jetë 0
DocType: Company,Delete Company Transactions,Fshij Transaksionet Company
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Reference No and Reference Date is mandatory for Bank transaction,I Referencës dhe Referenca Date është e detyrueshme për transaksion Bank
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Add / Edit taksat dhe tatimet
DocType: Payment Entry Reference,Supplier Invoice No,Furnizuesi Fatura Asnjë
DocType: Territory,For reference,Për referencë
DocType: Healthcare Settings,Appointment Confirmation,Konfirmimi i Emërimit
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Nuk mund të fshini serial {0}, ashtu siç është përdorur në transaksionet e aksioneve"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256,Closing (Cr),Mbyllja (Cr)
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Përshëndetje
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Leviz Item
DocType: Serial No,Warranty Period (Days),Garanci Periudha (ditë)
DocType: Installation Note Item,Installation Note Item,Instalimi Shënim Item
DocType: Production Plan Item,Pending Qty,Në pritje Qty
DocType: Budget,Ignore,Injoroj
apps/erpnext/erpnext/accounts/party.py +396,{0} {1} is not active,{0} {1} nuk është aktiv
DocType: Woocommerce Settings,Freight and Forwarding Account,Llogaria e mallrave dhe përcjelljes
apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Dimensionet kontrolloni Setup për printim
DocType: Salary Slip,Salary Slip Timesheet,Paga Slip pasqyrë e mungesave
apps/erpnext/erpnext/controllers/buying_controller.py +161,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Furnizuesi Magazina i detyrueshëm për të nën-kontraktuar Blerje marrjes
DocType: Pricing Rule,Valid From,Valid Nga
DocType: Sales Invoice,Total Commission,Komisioni i përgjithshëm
DocType: Pricing Rule,Sales Partner,Sales Partner
apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Të gjitha tabelat e rezultateve të furnizuesit.
DocType: Buying Settings,Purchase Receipt Required,Pranimi Blerje kërkuar
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +228,Target warehouse in row {0} must be same as Work Order,Magazina e synuar në rresht {0} duhet të jetë e njëjtë me rendin e punës
apps/erpnext/erpnext/stock/doctype/item/item.py +155,Valuation Rate is mandatory if Opening Stock entered,Vlerësimi Vlerësoni është i detyrueshëm në qoftë Hapja Stock hyrë
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143,No records found in the Invoice table,Nuk u gjetën në tabelën Faturë të dhënat
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34,Please select Company and Party Type first,"Ju lutem, përzgjidhni kompanisë dhe Partisë Lloji i parë"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Tashmë vendosni parazgjedhjen në pozicionin {0} për përdoruesin {1}, me mirësi default me aftësi të kufizuara"
apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Financiare / vit kontabilitetit.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Vlerat e akumuluara
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Na vjen keq, Serial Nos nuk mund të bashkohen"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Territori kërkohet në Profilin e POS
DocType: Supplier,Prevent RFQs,Parandalimi i RFQ-ve
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Bëni Sales Order
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Lëshimi i pagës i paraqitur për periudhën nga {0} në {1}
DocType: Project Task,Project Task,Projekti Task
,Lead Id,Lead Id
DocType: C-Form Invoice Detail,Grand Total,Grand Total
DocType: Assessment Plan,Course,kurs
DocType: Timesheet,Payslip,payslip
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Item Shporta
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Fiskale Viti Data e Fillimit nuk duhet të jetë më i madh se vitin fiskal End Date
DocType: Issue,Resolution,Zgjidhje
DocType: C-Form,IV,IV
apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Dorëzuar: {0}
DocType: Expense Claim,Payable Account,Llogaria e pagueshme
DocType: Payment Entry,Type of Payment,Lloji i Pagesës
DocType: Sales Order,Billing and Delivery Status,Faturimi dhe dorëzimit Statusi
DocType: Job Applicant,Resume Attachment,Resume Attachment
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Konsumatorët të përsëritur
DocType: Leave Control Panel,Allocate,Alokimi
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Krijo Variant
DocType: Sales Invoice,Shipping Bill Date,Data e Dërgesës së Transportit
DocType: Production Plan,Production Plan,Plani i prodhimit
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Hapja e Faturave të Faturës
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853,Sales Return,Shitjet Kthehu
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,Shënim: gjethet total alokuara {0} nuk duhet të jetë më pak se gjethet e miratuara tashmë {1} për periudhën
,Total Stock Summary,Total Stock Përmbledhje
DocType: Announcement,Posted By,postuar Nga
DocType: Item,Delivered by Supplier (Drop Ship),Dorëzuar nga Furnizuesi (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Mesazhi i konfirmimit
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Baza e të dhënave të konsumatorëve potencial.
DocType: Authorization Rule,Customer or Item,Customer ose Item
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Baza e të dhënave të konsumatorëve.
DocType: Quotation,Quotation To,Citat Për
DocType: Lead,Middle Income,Të ardhurat e Mesme
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228,Opening (Cr),Hapja (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +872,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.,Default njësinë e matjes për artikullit {0} nuk mund të ndryshohet drejtpërdrejt sepse ju keni bërë tashmë një transaksioni (et) me një tjetër UOM. Ju do të duhet për të krijuar një artikull të ri për të përdorur një Default ndryshme UOM.
apps/erpnext/erpnext/accounts/utils.py +349,Allocated amount can not be negative,Shuma e ndarë nuk mund të jetë negative
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Ju lutemi të vendosur Kompaninë
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Ju lutemi të vendosur Kompaninë
DocType: Share Balance,Share Balance,Bilanci i aksioneve
DocType: Purchase Order Item,Billed Amt,Faturuar Amt
DocType: Training Result Employee,Training Result Employee,Rezultati Training punonjës
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Një Magazina logjik kundër të cilit janë bërë të hyra të aksioneve.
DocType: Repayment Schedule,Principal Amount,shumën e principalit
DocType: Employee Loan Application,Total Payable Interest,Interesi i përgjithshëm për t&#39;u paguar
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57,Total Outstanding: {0},Totali Outstanding: {0}
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Sales Fatura pasqyrë e mungesave
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Referenca Nuk &amp; Referenca Data është e nevojshme për {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Zgjidhni Pagesa Llogaria për të bërë Banka Hyrja
DocType: Hotel Settings,Default Invoice Naming Series,Seria e emërtimit të faturës së parazgjedhur
apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Krijo dhënat e punonjësve për të menaxhuar gjethe, pretendimet e shpenzimeve dhe pagave"
DocType: Restaurant Reservation,Restaurant Reservation,Rezervim Restoranti
DocType: Land Unit,Land Unit Name,Emri i Njësisë së Tokës
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Propozimi Shkrimi
DocType: Payment Entry Deduction,Payment Entry Deduction,Pagesa Zbritja Hyrja
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Mbarimi
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Njoftoni Konsumatorët përmes Email-it
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Një person tjetër Sales {0} ekziston me të njëjtin id punonjës
DocType: Employee Advance,Claimed Amount,Shuma e kërkuar
apps/erpnext/erpnext/config/education.py +180,Masters,Masters
DocType: Assessment Plan,Maximum Assessment Score,Vlerësimi maksimal Score
apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Datat e transaksionit Update Banka
apps/erpnext/erpnext/config/projects.py +41,Time Tracking,Koha Tracking
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,Duplicate TRANSPORTUESIT
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Rresht {0} # Vlera e paguar nuk mund të jetë më e madhe se shuma e parapaguar e kërkuar
DocType: Fiscal Year Company,Fiscal Year Company,Fiskale Viti i kompanisë
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Training Event,Conference,konferencë
DocType: Timesheet,Billed,Faturuar
DocType: Batch,Batch Description,Batch Përshkrim
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Krijimi i grupeve të studentëve
apps/erpnext/erpnext/accounts/utils.py +720,"Payment Gateway Account not created, please create one manually.","Pagesa Gateway Llogaria nuk është krijuar, ju lutemi krijoni një të tillë me dorë."
DocType: Supplier Scorecard,Per Year,Në vit
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Nuk ka të drejtë për pranim në këtë program sipas DOB
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kodi i artikullit&gt; Grupi i artikullit&gt; Markë
DocType: Sales Invoice,Sales Taxes and Charges,Shitjet Taksat dhe Tarifat
DocType: Employee,Organization Profile,Organizata Profilin
DocType: Vital Signs,Height (In Meter),Lartësia (në metër)
DocType: Student,Sibling Details,Details vëlla
DocType: Vehicle Service,Vehicle Service,Shërbimi Vehicle
apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Automatikisht shkakton kërkesa reagime në bazë të kushteve.
DocType: Employee,Reason for Resignation,Arsyeja për dorëheqjen
apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Template për vlerësimit të punës.
DocType: Sales Invoice,Credit Note Issued,Credit Note Hedhur në qarkullim
DocType: Project Task,Weight,peshë
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Fatura / Journal Hyrja Detajet
apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; nuk është në Vitin Fiskal {2}
DocType: Buying Settings,Settings for Buying Module,Cilësimet për Blerja Module
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Asset {0} nuk i përkasin kompanisë {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Ju lutemi shkruani vërtetim Blerje parë
DocType: Buying Settings,Supplier Naming By,Furnizuesi Emërtimi By
DocType: Activity Type,Default Costing Rate,Default kushton Vlerësoni
DocType: Maintenance Schedule,Maintenance Schedule,Mirëmbajtja Orari
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.","Pastaj Çmimeve Rregullat janë filtruar në bazë të konsumatorëve, Grupi Customer, Territorit, Furnizuesin, Furnizuesi Lloji, fushatën, Sales Partner etj"
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29,Net Change in Inventory,Ndryshimi neto në Inventarin
apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Menaxhimi Loan punonjës
DocType: Employee,Passport Number,Pasaporta Numri
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Raporti me Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Menaxher
DocType: Payment Entry,Payment From / To,Pagesa nga /
apps/erpnext/erpnext/selling/doctype/customer/customer.py +170,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Kufiri i ri i kredisë është më pak se shuma aktuale të papaguar për konsumatorin. kufiri i kreditit duhet të jetë atleast {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Vendosni llogarinë në Depo {0}
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,&quot;Bazuar Në &#39;dhe&#39; Grupit nga &#39;nuk mund të jetë e njëjtë
DocType: Sales Person,Sales Person Targets,Synimet Sales Person
DocType: Installation Note,IN-,NË-
DocType: Work Order Operation,In minutes,Në minuta
DocType: Issue,Resolution Date,Rezoluta Data
DocType: Lab Test Template,Compound,kompleks
DocType: Student Batch Name,Batch Name,Batch Emri
DocType: Fee Validity,Max number of visit,Numri maksimal i vizitës
,Hotel Room Occupancy,Perdorimi i dhomes se hotelit
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358,Timesheet created:,Pasqyrë e mungesave krijuar:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931,Please set default Cash or Bank account in Mode of Payment {0},Ju lutemi të vendosur Cash parazgjedhur apo llogari bankare në mënyra e pagesës {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,regjistroj
DocType: GST Settings,GST Settings,GST Settings
DocType: Selling Settings,Customer Naming By,Emërtimi Customer Nga
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Do të tregojë nxënësin si të pranishme në Student Raporti mujor Pjesëmarrja
DocType: Depreciation Schedule,Depreciation Amount,Amortizimi Shuma
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Convert të Grupit
DocType: Delivery Trip,TOUR-.#####,TOUR -. #####
DocType: Activity Cost,Activity Type,Aktiviteti Type
DocType: Request for Quotation,For individual supplier,Për furnizuesit individual
DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Vlerësoni (Company Valuta)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Shuma Dorëzuar
apps/erpnext/erpnext/healthcare/doctype/physician/physician_dashboard.py +14,Lab Tests,Testet e laboratorit
DocType: Quotation Item,Item Balance,Item Balance
DocType: Sales Invoice,Packing List,Lista paketim
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Blerje Urdhërat jepet Furnizuesit.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Botime
DocType: Accounts Settings,Report Settings,Cilësimet e raportit
DocType: Activity Cost,Projects User,Projektet i përdoruesit
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40,Consumed,Konsumuar
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0}: {1} nuk u gjet në detaje Fatura tryezë
DocType: Asset,Asset Owner Company,Shoqëria Pronar i Pasurisë
DocType: Company,Round Off Cost Center,Rrumbullakët Off Qendra Kosto
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Mirëmbajtja Vizitoni {0} duhet të anulohet para se anulimi këtë Radhit Sales
DocType: Asset Maintenance Log,AML-,AML-
DocType: Item,Material Transfer,Transferimi materiale
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Nuk mund të gjente rrugën
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221,Opening (Dr),Hapja (Dr)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Timestamp postimi duhet të jetë pas {0}
apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Për të bërë dokumente të përsëritura
,GST Itemised Purchase Register,GST e detajuar Blerje Regjistrohu
DocType: Course Scheduling Tool,Reschedule,riskedulimin
DocType: Employee Loan,Total Interest Payable,Interesi i përgjithshëm për t&#39;u paguar
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Taksat zbarkoi Kosto dhe Tarifat
DocType: Work Order Operation,Actual Start Time,Aktuale Koha e fillimit
DocType: BOM Operation,Operation Time,Operacioni Koha
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +337,Finish,fund
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +422,Base,bazë
DocType: Timesheet,Total Billed Hours,Orët totale faturuara
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1553,Write Off Amount,Shkruani Off Shuma
DocType: Leave Block List Allow,Allow User,Lejojë përdoruesin
DocType: Journal Entry,Bill No,Bill Asnjë
DocType: Company,Gain/Loss Account on Asset Disposal,Llogaria Gain / Humbja në hedhjen e Aseteve
DocType: Vehicle Log,Service Details,Details shërbimit
DocType: Vehicle Log,Service Details,Details shërbimit
DocType: Subscription,Quarterly,Tremujor
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47,EcritureLib,EcritureLib
DocType: Lab Test Template,Grouped,grupuar
DocType: Selling Settings,Delivery Note Required,Ofrimit Shënim kërkuar
DocType: Bank Guarantee,Bank Guarantee Number,Bank Numri Guarantee
DocType: Bank Guarantee,Bank Guarantee Number,Bank Numri Guarantee
DocType: Assessment Criteria,Assessment Criteria,Kriteret e vlerësimit
DocType: BOM Item,Basic Rate (Company Currency),Norma bazë (Kompania Valuta)
DocType: Student Attendance,Student Attendance,Pjesëmarrja Student
DocType: Sales Invoice Timesheet,Time Sheet,Koha Sheet
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush të lëndëve të para në bazë të
DocType: Sales Invoice,Port Code,Kodi Port
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957,Reserve Warehouse,Magazina Rezervë
DocType: Lead,Lead is an Organization,Udhëheqësi është një organizatë
DocType: Guardian Interest,Interest,interes
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Sales para
DocType: Instructor Log,Other Details,Detaje të tjera
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
DocType: Lab Test,Test Template,Template Test
DocType: Restaurant Order Entry Item,Served,Served
apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Informacioni i kapitullit.
DocType: Account,Accounts,Llogaritë
DocType: Vehicle,Odometer Value (Last),Vlera rrugëmatës (i fundit)
apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Modelet e kritereve të rezultateve të ofruesve.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Marketing
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303,Payment Entry is already created,Pagesa Hyrja është krijuar tashmë
DocType: Request for Quotation,Get Suppliers,Merrni Furnizuesit
DocType: Purchase Receipt Item Supplied,Current Stock,Stock tanishme
apps/erpnext/erpnext/controllers/accounts_controller.py +610,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Asset {1} nuk lidhet me pikën {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +404,Preview Salary Slip,Preview Paga Shqip
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Llogaria {0} ka hyrë disa herë
DocType: Account,Expenses Included In Valuation,Shpenzimet e përfshira në Vlerësimit
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,Ju mund të rinovoni vetëm nëse anëtarësimi juaj mbaron brenda 30 ditëve
DocType: Land Unit,Longitude,gjatësi
,Absent Student Report,Mungon Raporti Student
DocType: Crop,Crop Spacing UOM,Spastrimi i drithrave UOM
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Përzgjidhni vetëm nëse keni skedarë të dokumentit Cash Flow Mapper
DocType: Email Digest,Next email will be sent on:,Email ardhshëm do të dërgohet në:
DocType: Supplier Scorecard,Per Week,Në javë
apps/erpnext/erpnext/stock/doctype/item/item.py +666,Item has variants.,Item ka variante.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Student Gjithsej
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Item {0} nuk u gjet
DocType: Bin,Stock Value,Stock Vlera
apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Kompania {0} nuk ekziston
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} ka vlefshmërinë e tarifës deri në {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54,Tree Type,Tree Type
DocType: BOM Explosion Item,Qty Consumed Per Unit,Qty konsumuar për njësi
DocType: GST Account,IGST Account,Llogaria IGST
DocType: Serial No,Warranty Expiry Date,Garanci Data e skadimit
DocType: Material Request Item,Quantity and Warehouse,Sasia dhe Magazina
DocType: Hub Settings,Unregister,unregister
DocType: Sales Invoice,Commission Rate (%),Vlerësoni komision (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,"Ju lutem, përzgjidhni Program"
DocType: Project,Estimated Cost,Kostoja e vlerësuar
DocType: Purchase Order,Link to material requests,Link të kërkesave materiale
DocType: Hub Settings,Publish,publikoj
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Hapësirës ajrore
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
DocType: Journal Entry,Credit Card Entry,Credit Card Hyrja
apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Company dhe Llogaritë
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,In Value,në Vlera
DocType: Asset Settings,Depreciation Options,Opsionet e zhvlerësimit
apps/erpnext/erpnext/utilities/transaction_base.py +35,Invalid Posting Time,Koha e pavlefshme e regjistrimit
DocType: Lead,Campaign Name,Emri fushatë
DocType: Hotel Room,Capacity,kapacitet
DocType: Selling Settings,Close Opportunity After Days,Mbylle Opportunity pas ditë
,Reserved,I rezervuar
DocType: Driver,License Details,Detajet e Licencës
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85,The field From Shareholder cannot be blank,Fusha Nga Aksionari nuk mund të jetë bosh
DocType: Purchase Order,Supply Raw Materials,Furnizimit të lëndëve të para
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Pasuritë e tanishme
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +133,{0} is not a stock Item,{0} nuk është një gjendje Item
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',Ju lutemi ndani komentet tuaja në trajnim duke klikuar në &#39;Trajnimi i Feedback&#39; dhe pastaj &#39;New&#39;
DocType: Mode of Payment Account,Default Account,Gabim Llogaria
apps/erpnext/erpnext/stock/doctype/item/item.py +273,Please select Sample Retention Warehouse in Stock Settings first,Ju lutemi zgjidhni Sample Retention Warehouse në Stock Settings për herë të parë
DocType: Payment Entry,Received Amount (Company Currency),Shuma e marrë (Company Valuta)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,"Lead duhet të vendosen, nëse Opportunity është bërë nga Lead"
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136,Payment Cancelled. Please check your GoCardless Account for more details,Pagesa u anulua. Kontrollo llogarinë tënde GoCardless për më shumë detaje
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,"Ju lutem, përzgjidhni ditë javore jashtë"
DocType: Patient,O Negative,O Negative
DocType: Work Order Operation,Planned End Time,Planifikuar Fundi Koha
,Sales Person Target Variance Item Group-Wise,Sales Person i synuar Varianca Item Grupi i urti
apps/erpnext/erpnext/accounts/doctype/account/account.py +93,Account with existing transaction cannot be converted to ledger,Llogaria me transaksion ekzistues nuk mund të konvertohet në Ledger
apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Detajet e tipit të anëtarësisë
DocType: Delivery Note,Customer's Purchase Order No,Konsumatorit Blerje Rendit Jo
DocType: Budget,Budget Against,Kundër buxheti
DocType: Employee,Cell Number,Numri Cell
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Nuk ka punonjës për kriteret e dhëna. Kontrolloni që Slipet e pagave nuk janë krijuar.
apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Kërkesat Auto Materiale Generated
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,I humbur
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,Ju nuk mund të hyjë kupon aktual në &quot;Kundër Journal hyrjes &#39;kolonë
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Rezervuar për prodhimin
DocType: Soil Texture,Sand,rërë
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energji
DocType: Opportunity,Opportunity From,Opportunity Nga
apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Deklarata mujore e pagave.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Rreshti {0}: {1} Numrat serialë të kërkuar për artikullin {2}. Ju keni dhënë {3}.
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Zgjidh një tabelë
DocType: BOM,Website Specifications,Specifikimet Website
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} është një adresë e pavlefshme email në &#39;Përfituesit&#39;
DocType: Special Test Items,Particulars,Të dhënat
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Nga {0} nga lloji {1}
DocType: Warranty Claim,CI-,Pri-
apps/erpnext/erpnext/controllers/buying_controller.py +316,Row {0}: Conversion Factor is mandatory,Row {0}: Konvertimi Faktori është e detyrueshme
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}","Rregullat e çmimeve të shumta ekziston me kritere të njëjta, ju lutemi të zgjidhur konfliktin duke caktuar prioritet. Rregullat Çmimi: {0}"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519,Cannot deactivate or cancel BOM as it is linked with other BOMs,Nuk mund të çaktivizuar ose të anulojë bom si ajo është e lidhur me BOM-in e tjera
DocType: Asset,Maintenance,Mirëmbajtje
DocType: Item Attribute Value,Item Attribute Value,Item atribut Vlera
apps/erpnext/erpnext/projects/doctype/project/project.py +406,Please Update your Project Status,Ju lutemi ndryshoni statusin e projektit
DocType: Item,Maximum sample quantity that can be retained,Sasia maksimale e mostrës që mund të ruhet
DocType: Project Update,How is the Project Progressing Right Now?,Si po përparon projekti tani?
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +459,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},{0} # Njësia {1} nuk mund të transferohet më shumë se {2} kundër Urdhëresës së Blerjes {3}
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Shitjet fushata.
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117,Make Timesheet,bëni pasqyrë e mungesave
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.","Template Standard taksave që mund të aplikohet për të gjitha shitjet e transaksionet. Kjo template mund të përmbajë listë të krerëve të taksave si dhe kokat e tjera të shpenzimeve / të ardhurave si &quot;tregtar&quot;, &quot;Sigurimi&quot;, &quot;Trajtimi&quot; etj #### Shënim norma e tatimit që ju të përcaktuar këtu do të jetë norma standarde e taksave për të gjithë ** Items **. Nëse ka Items ** ** që kanë norma të ndryshme, ato duhet të shtohet në ** Item Tatimit ** Tabela në ** Item ** zotit. #### Përshkrimi i Shtyllave 1. Llogaritja Type: - Kjo mund të jetë në ** neto totale ** (që është shuma e shumës bazë). - ** Në rreshtit të mëparshëm totalit / Shuma ** (për taksat ose tarifat kumulative). Në qoftë se ju zgjidhni këtë opsion, tatimi do të aplikohet si një përqindje e rreshtit të mëparshëm (në tabelën e taksave) shumën apo total. - ** ** Aktuale (siç u përmend). 2. Llogaria Udhëheqës: Libri Llogaria nën të cilat kjo taksë do të jetë e rezervuar 3. Qendra Kosto: Nëse tatimi i / Akuza është një ardhura (si anijet) ose shpenzime ajo duhet të jetë e rezervuar ndaj Qendrës kosto. 4. Përshkrimi: Përshkrimi i tatimit (që do të shtypen në faturat / thonjëza). 5. Rate: Shkalla tatimore. 6. Shuma: Shuma Tatimore. 7. Gjithsej: totale kumulative në këtë pikë. 8. Shkruani Row: Nëse në bazë të &quot;rreshtit të mëparshëm Total&quot; ju mund të zgjidhni numrin e rreshtit të cilat do të merren si bazë për këtë llogaritje (default është rreshtit të mëparshëm). 9. A është kjo Tatimore të përfshira në normën bazë ?: Në qoftë se ju kontrolloni këtë, kjo do të thotë se kjo taksë nuk do të shfaqet nën tryezë pika, por do të përfshihen në normën bazë në tabelën kryesore tuaj pika. Kjo është e dobishme kur ju doni të japë një çmim të sheshtë (përfshirëse e të gjitha taksat) çmimin për konsumatorët."
DocType: Employee,Bank A/C No.,Banka A / C Nr
DocType: Bank Guarantee,Project,Projekt
DocType: Quality Inspection Reading,Reading 7,Leximi 7
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,Urdhërohet pjesërisht
DocType: Lab Test,Lab Test,Test Lab
DocType: Student Report Generation Tool,Student Report Generation Tool,Gjenerimi i Raportit të Studentëve
DocType: Expense Claim Detail,Expense Claim Type,Shpenzimet e kërkesës Lloji
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Default settings për Shportë
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27,Add Timeslots,Shto Timeslots
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset braktiset via Journal Hyrja {0}
DocType: Employee Loan,Interest Income Account,Llogaria ardhurat nga interesi
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Thirrja e Shqyrtimit të dërguar
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Bioteknologji
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Shpenzimet Zyra Mirëmbajtja
apps/erpnext/erpnext/utilities/user_progress.py +54,Go to ,Shko te
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Ngritja llogari PE
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,Ju lutemi shkruani pika e parë
DocType: Asset Repair,Downtime,kohë joproduktive
DocType: Account,Liability,Detyrim
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Shuma e sanksionuar nuk mund të jetë më e madhe se shuma e kërkesës në Row {0}.
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Academic Term: ,Termi akademik:
DocType: Salary Detail,Do not include in total,Mos përfshini në total
DocType: Company,Default Cost of Goods Sold Account,Gabim Kostoja e mallrave të shitura Llogaria
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1177,Sample quantity {0} cannot be more than received quantity {1},Sasia e mostrës {0} nuk mund të jetë më e madhe sesa {1}
apps/erpnext/erpnext/stock/get_item_details.py +369,Price List not selected,Lista e Çmimeve nuk zgjidhet
DocType: Employee,Family Background,Historiku i familjes
DocType: Request for Quotation Supplier,Send Email,Dërgo Email
apps/erpnext/erpnext/stock/doctype/item/item.py +228,Warning: Invalid Attachment {0},Warning: Attachment Invalid {0}
DocType: Item,Max Sample Quantity,Sasi Maksimale e mostrës
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766,No Permission,Nuk ka leje
apps/erpnext/erpnext/public/js/hub/hub_form.js +351,Quote Requested,Cito kërkohet
DocType: Vital Signs,Heart Rate / Pulse,Shkalla e zemrës / Pulsi
DocType: Company,Default Bank Account,Gabim Llogarisë Bankare
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59,"To filter based on Party, select Party Type first","Për të filtruar në bazë të Partisë, Partia zgjidhni llojin e parë"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"&#39;Update Stock &quot;nuk mund të kontrollohet, sepse sendet nuk janë dorëzuar nëpërmjet {0}"
DocType: Vehicle,Acquisition Date,Blerja Data
apps/erpnext/erpnext/utilities/user_progress.py +146,Nos,Nos
DocType: Item,Items with higher weightage will be shown higher,Gjërat me weightage më të lartë do të tregohet më e lartë
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Testet Lab dhe Shenjat Vital
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Detail Banka Pajtimit
apps/erpnext/erpnext/controllers/accounts_controller.py +614,Row #{0}: Asset {1} must be submitted,Row # {0}: Asset {1} duhet të dorëzohet
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Asnjë punonjës gjetur
DocType: Subscription,Stopped,U ndal
DocType: Item,If subcontracted to a vendor,Në qoftë se nënkontraktuar për një shitës
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Grupi Student është përditësuar tashmë.
apps/erpnext/erpnext/config/projects.py +18,Project Update.,Përditësimi i projektit.
DocType: SMS Center,All Customer Contact,Të gjitha Customer Kontakt
DocType: Land Unit,Tree Details,Tree Details
DocType: Training Event,Event Status,Status Event
DocType: Volunteer,Availability Timeslot,Koha e disponueshmërisë
,Support Analytics,Analytics Mbështetje
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365,"If you have any questions, please get back to us.","Nëse keni ndonjë pyetje, ju lutem të kthehet tek ne."
DocType: Cash Flow Mapper,Cash Flow Mapper,Fluksi i rrjedhës së parasë
DocType: Item,Website Warehouse,Website Magazina
DocType: Payment Reconciliation,Minimum Invoice Amount,Shuma minimale Faturë
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Qendra Kosto {2} nuk i përkasin kompanisë {3}
apps/erpnext/erpnext/utilities/user_progress.py +92,Upload your letter head (Keep it web friendly as 900px by 100px),Ngarko kokën tënde me shkronja (Mbani atë në internet si 900px me 100px)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Llogaria {2} nuk mund të jetë një 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,Item Row {IDX}: {} {DOCTYPE docname} nuk ekziston në më sipër &#39;{DOCTYPE}&#39; tabelë
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295,Timesheet {0} is already completed or cancelled,Pasqyrë e mungesave {0} është përfunduar tashmë ose anuluar
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Nuk ka detyrat
DocType: Item Variant Settings,Copy Fields to Variant,Kopjoni Fushat në Variant
DocType: Asset,Opening Accumulated Depreciation,Hapja amortizimi i akumuluar
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Rezultati duhet të jetë më pak se ose e barabartë me 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Program Regjistrimi Tool
apps/erpnext/erpnext/config/accounts.py +335,C-Form records,Të dhënat C-Forma
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73,The shares already exist,Aksionet tashmë ekzistojnë
apps/erpnext/erpnext/config/selling.py +316,Customer and Supplier,Customer dhe Furnizues
DocType: Email Digest,Email Digest Settings,Email Settings Digest
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367,Thank you for your business!,Ju faleminderit për biznesin tuaj!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Mbështetje pyetje nga konsumatorët.
DocType: Setup Progress Action,Action Doctype,Veprimi Doctype
DocType: HR Settings,Retirement Age,Daljes në pension Age
DocType: Bin,Moving Average Rate,Moving norma mesatare
DocType: Production Plan,Select Items,Zgjidhni Items
DocType: Share Transfer,To Shareholder,Për Aksionarin
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},"{0} kundër Bill {1} {2}, datë"
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Institution,Institucioni i instalimit
DocType: Program Enrollment,Vehicle/Bus Number,Vehicle / Numri Bus
apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Orari i kursit
DocType: Request for Quotation Supplier,Quote Status,Statusi i citatit
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
DocType: Maintenance Visit,Completion Status,Përfundimi Statusi
DocType: Daily Work Summary Group,Select Users,Zgjidh Përdoruesit
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Çmimi i dhomës së hotelit
DocType: HR Settings,Enter retirement age in years,Shkruani moshën e pensionit në vitet
DocType: Crop,Target Warehouse,Target Magazina
DocType: Payroll Employee Detail,Payroll Employee Detail,Detajet e punonjësve të pagave
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select a warehouse,"Ju lutem, përzgjidhni një depo"
DocType: Cheque Print Template,Starting location from left edge,Duke filluar vend nga buzë e majtë
DocType: Item,Allow over delivery or receipt upto this percent,Lejo mbi ofrimin ose pranimin upto këtë qind
DocType: Stock Entry,STE-,STE-
DocType: Upload Attendance,Import Attendance,Pjesëmarrja e importit
apps/erpnext/erpnext/public/js/pos/pos.html +124,All Item Groups,Të gjitha Item Grupet
apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Automatikisht shkruaj mesazh për dorëzimin e transaksioneve.
DocType: Work Order,Item To Manufacture,Item Për Prodhimi
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} statusi është {2}
DocType: Water Analysis,Collection Temperature ,Temperatura e mbledhjes
DocType: Employee,Provide Email Address registered in company,Sigurojë Adresa Email i regjistruar në kompaninë
DocType: Shopping Cart Settings,Enable Checkout,Aktivizo Checkout
apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Blerje Rendit për Pagesa
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Projektuar Qty
DocType: Sales Invoice,Payment Due Date,Afati i pageses
DocType: Drug Prescription,Interval UOM,Interval UOM
DocType: Customer,"Reselect, if the chosen address is edited after save","Reselect, nëse adresa e zgjedhur është redaktuar pas ruajtjes"
apps/erpnext/erpnext/stock/doctype/item/item.js +544,Item Variant {0} already exists with same attributes,Item Varianti {0} tashmë ekziston me atributet e njëjta
DocType: Item,Hub Publishing Details,Detajet e botimit të Hub
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +123,'Opening',&quot;Hapja&quot;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Hapur për të bërë
DocType: Notification Control,Delivery Note Message,Ofrimit Shënim Mesazh
DocType: Lab Test Template,Result Format,Formati i rezultatit
DocType: Expense Claim,Expenses,Shpenzim
DocType: Item Variant Attribute,Item Variant Attribute,Item Varianti Atributi
,Purchase Receipt Trends,Trendet Receipt Blerje
DocType: Payroll Entry,Bimonthly,dy herë në muaj
DocType: Vehicle Service,Brake Pad,Brake Pad
DocType: Fertilizer,Fertilizer Contents,Përmbajtja e plehut
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Hulumtim dhe Zhvillim
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Shuma për Bill
DocType: Company,Registration Details,Detajet e regjistrimit
DocType: Timesheet,Total Billed Amount,Shuma totale e faturuar
DocType: Item Reorder,Re-Order Qty,Re-Rendit Qty
DocType: Leave Block List Date,Leave Block List Date,Dërgo Block Lista Data
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94,BOM #{0}: Raw material cannot be same as main Item,BOM {{0}: Materiali i papërpunuar nuk mund të jetë i njëjtë me artikullin kryesor
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,Akuzat totale të zbatueshme në Blerje tryezë Receipt artikujt duhet të jetë i njëjtë si Total taksat dhe tarifat
DocType: Sales Team,Incentives,Nxitjet
DocType: SMS Log,Requested Numbers,Numrat kërkuara
DocType: Volunteer,Evening,mbrëmje
DocType: Customer,Bypass credit limit check at Sales Order,Kufizo limitin e kreditit në Urdhërin e Shitjes
apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Vlerësimit të performancës.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Duke bërë të mundur &#39;Përdorimi për Shportë&#39;, si Shporta është aktivizuar dhe duhet të ketë të paktën një Rule Tax per Shporta"
apps/erpnext/erpnext/controllers/accounts_controller.py +412,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Pagesa Hyrja {0} është e lidhur kundrejt Rendit {1}, kontrolloni nëse ajo duhet të largohen sa më parë në këtë faturë."
DocType: Sales Invoice Item,Stock Details,Stock Detajet
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Vlera e Projektit
apps/erpnext/erpnext/config/selling.py +326,Point-of-Sale,Point-of-Sale
DocType: Fee Schedule,Fee Creation Status,Statusi i Krijimit të Tarifave
DocType: Vehicle Log,Odometer Reading,Leximi rrugëmatës
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'","Bilanci i llogarisë tashmë në kredi, ju nuk jeni i lejuar për të vendosur &quot;Bilanci Must Be &#39;si&#39; Debitimit &#39;"
DocType: Account,Balance must be,Bilanci duhet të jetë
DocType: Hub Settings,Publish Pricing,Publikimi i Çmimeve
DocType: Notification Control,Expense Claim Rejected Message,Shpenzim Kërkesa Refuzuar mesazh
,Available Qty,Qty në dispozicion
DocType: Purchase Taxes and Charges,On Previous Row Total,Në Previous Row Total
DocType: Purchase Invoice Item,Rejected Qty,refuzuar Qty
DocType: Setup Progress Action,Action Field,Fusha e Veprimit
DocType: Healthcare Settings,Manage Customer,Menaxho Klientin
DocType: Delivery Trip,Delivery Stops,Dorëzimi ndalon
DocType: Salary Slip,Working Days,Ditët e punës
DocType: Serial No,Incoming Rate,Hyrëse Rate
DocType: Packing Slip,Gross Weight,Peshë Bruto
,Final Assessment Grades,Notat e vlerësimit përfundimtar
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +60,Enable Hub,Aktivizo Hub
apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,Emri i kompanisë suaj për të cilën ju jeni të vendosur këtë sistem.
DocType: HR Settings,Include holidays in Total no. of Working Days,Përfshijnë pushimet në total nr. i ditëve të punës
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Instaloni Institutin tuaj në ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Analiza e bimëve
DocType: Job Applicant,Hold,Mbaj
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +128,Alternate Item,Pika Alternative
DocType: Project Update,Progress Details,Detajet e progresit
DocType: Employee,Date of Joining,Data e Bashkimi
DocType: Naming Series,Update Series,Update Series
DocType: Supplier Quotation,Is Subcontracted,Është nënkontraktuar
DocType: Restaurant Table,Minimum Seating,Vendndodhja minimale
DocType: Item Attribute,Item Attribute Values,Vlerat Item ia atribuojnë
DocType: Examination Result,Examination Result,Ekzaminimi Result
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845,Purchase Receipt,Pranimi Blerje
,Received Items To Be Billed,Items marra Për të faturohet
apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Kursi i këmbimit të monedhës mjeshtër.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,Reference Doctype must be one of {0},Referenca DOCTYPE duhet të jetë një nga {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,Filtër Totali Zero Qty
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341,Unable to find Time Slot in the next {0} days for Operation {1},Në pamundësi për të gjetur vend i caktuar kohë në {0} ditëve të ardhshme për funksionimin {1}
DocType: Work Order,Plan material for sub-assemblies,Materiali plan për nën-kuvendet
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Sales Partners dhe Territori
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +601,BOM {0} must be active,BOM {0} duhet të jetë aktiv
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414,No Items available for transfer,Asnjë artikull në dispozicion për transferim
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218,Closing (Opening + Total),Mbyllja (Hapja + Gjithsej)
DocType: Journal Entry,Depreciation Entry,Zhvlerësimi Hyrja
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Please select the document type first,Ju lutem zgjidhni llojin e dokumentit të parë
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Anuloje Vizitat Materiale {0} para anulimit të kësaj vizite Mirëmbajtja
DocType: Crop Cycle,ISO 8016 standard,ISO 8016 standard
DocType: Pricing Rule,Rate or Discount,Rate ose zbritje
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serial Asnjë {0} nuk i përkasin Item {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Kerkohet Qty
apps/erpnext/erpnext/public/js/hub/hub_listing.js +58,Favourites,Favoritet
DocType: Hub Settings,Custom Data,Të Dhënat Custom
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126,Warehouses with existing transaction can not be converted to ledger.,Depot me transaksion ekzistues nuk mund të konvertohet në librin.
DocType: Bank Reconciliation,Total Amount,Shuma totale
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Botime Internet
DocType: Prescription Duration,Number,numër
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Krijimi i {0} faturës
DocType: Medical Code,Medical Code Standard,Kodi i Mjekësisë Standard
DocType: Soil Texture,Clay Composition (%),Përbërja e argjilës (%)
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Ju lutemi ruani para se të caktoni detyrën.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74,Balance Value,Vlera e bilancit
DocType: Lab Test,Lab Technician,Teknik i laboratorit
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Lista Sales Çmimi
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.","Nëse kontrollohet, një klient do të krijohet, i mapuar tek Pacienti. Faturat e pacientit do të krijohen kundër këtij klienti. Ju gjithashtu mund të zgjidhni Klientin ekzistues gjatë krijimit të pacientit."
DocType: Bank Reconciliation,Account Currency,Llogaria Valuta
DocType: Lab Test,Sample ID,Shembull i ID
apps/erpnext/erpnext/accounts/general_ledger.py +167,Please mention Round Off Account in Company,Ju lutemi të përmendim rrumbullohem Llogari në Kompaninë
DocType: Purchase Receipt,Range,Varg
DocType: Supplier,Default Payable Accounts,Default Llogaritë e pagueshme
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Punonjës {0} nuk është aktiv apo nuk ekziston
DocType: Fee Structure,Components,komponentet
DocType: Item Barcode,Item Barcode,Item Barkodi
DocType: Woocommerce Settings,Endpoints,endpoints
apps/erpnext/erpnext/assets/doctype/asset/asset.py +329,Please enter Asset Category in Item {0},Ju lutem shkruani Pasurive Kategoria në pikën {0}
apps/erpnext/erpnext/stock/doctype/item/item.py +661,Item Variants {0} updated,Item Variantet {0} përditësuar
DocType: Quality Inspection Reading,Reading 6,Leximi 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","për tu gjeneruar. Nëse vonohet, do të duhet të ndryshoni manualisht fushën &quot;Repeat on Day of Month&quot; të kësaj"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961,Cannot {0} {1} {2} without any negative outstanding invoice,"Nuk mund {0} {1} {2}, pa asnjë faturë negative shquar"
DocType: Share Transfer,From Folio No,Nga Folio Nr
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Blerje Faturë Advance
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Row {0}: Hyrja e kredisë nuk mund të jetë i lidhur me një {1}
apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Të përcaktojë buxhetin për një vit financiar.
DocType: Lead,LEAD-,plumb
DocType: Employee,Permanent Address Is,Adresa e përhershme është
DocType: Work Order Operation,Operation completed for how many finished goods?,Operacioni përfundoi për mënyrën se si shumë mallra të gatshme?
DocType: Payment Terms Template,Payment Terms Template,Modeli i kushteve të pagesës
apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Markë
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Lejo Konsumimin e Shumëfishtë të Materialeve
DocType: Employee,Exit Interview Details,Detajet Dil Intervista
DocType: Item,Is Purchase Item,Është Blerje Item
DocType: Journal Entry Account,Purchase Invoice,Blerje Faturë
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Lejo konsumimin e shumëfishtë të materialit kundrejt një porosi pune
DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail Asnjë
apps/erpnext/erpnext/accounts/page/pos/pos.js +789,New Sales Invoice,Sales New Fatura
DocType: Stock Entry,Total Outgoing Value,Vlera Totale largohet
DocType: Physician,Appointments,emërimet
apps/erpnext/erpnext/public/js/account_tree_grid.js +223,Opening Date and Closing Date should be within same Fiscal Year,Hapja Data dhe Data e mbylljes duhet të jetë brenda të njëjtit vit fiskal
DocType: Lead,Request for Information,Kërkesë për Informacion
,LeaderBoard,Fituesit
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Shkalla me margjinë (Valuta e kompanisë)
apps/erpnext/erpnext/accounts/page/pos/pos.js +802,Sync Offline Invoices,Sync Offline Faturat
DocType: Payment Request,Paid,I paguar
DocType: Program Fee,Program Fee,Tarifa program
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.","Replace a BOM të veçantë në të gjitha BOMs të tjera, ku ajo është përdorur. Ai do të zëvendësojë lidhjen e vjetër të BOM, do të përditësojë koston dhe do të rigjenerojë tabelën &quot;BOM Shpërthimi&quot; sipas BOM-it të ri. Gjithashtu përditëson çmimin e fundit në të gjitha BOM-et."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447,The following Work Orders were created:,Janë krijuar urdhërat e mëposhtëm të punës:
DocType: Salary Slip,Total in words,Gjithsej në fjalë
DocType: Material Request Item,Lead Time Date,Lead Data Koha
,Employee Advance Summary,Përmbledhje Advance Employee
DocType: Asset,Available-for-use Date,Data e disponueshme për përdorim
DocType: Guardian,Guardian Name,Emri Guardian
DocType: Cheque Print Template,Has Print Format,Ka Print Format
DocType: Employee Loan,Sanctioned,sanksionuar
apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,është i detyrueshëm. Ndoshta rekord Currency Exchange nuk është krijuar për
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +151,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Ju lutem specifikoni Serial Jo për Item {1}
DocType: Crop Cycle,Crop Cycle,Cikli i kulturave
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.","Për sendet e &#39;Produkt Bundle&#39;, depo, pa serial dhe Serisë Nuk do të konsiderohet nga &#39;Paketimi listë&#39; tryezë. Nëse Magazina dhe Serisë Nuk janë të njëjta për të gjitha sendet e paketimit për çdo send &#39;produkt Bundle&#39;, këto vlera mund të futen në tabelën kryesore Item, vlerat do të kopjohet në &#39;Paketimi listë&#39; tryezë."
DocType: Student Admission,Publish on website,Publikojë në faqen e internetit
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Furnizuesi Data e faturës nuk mund të jetë më i madh se mbi postimet Data
DocType: Purchase Invoice Item,Purchase Order Item,Rendit Blerje Item
DocType: Agriculture Task,Agriculture Task,Detyra e Bujqësisë
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Të ardhurat indirekte
DocType: Student Attendance Tool,Student Attendance Tool,Pjesëmarrja Student Tool
DocType: Restaurant Menu,Price List (Auto created),Lista e çmimeve (krijuar automatikisht)
DocType: Cheque Print Template,Date Settings,Data Settings
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Grindje
,Company Name,Emri i kompanisë
DocType: SMS Center,Total Message(s),Përgjithshme mesazh (s)
DocType: Share Balance,Purchased,blerë
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Riemërto vlerën e atributit në atributin e elementit
DocType: Purchase Invoice,Additional Discount Percentage,Përqindja shtesë Discount
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Shiko një listë të të gjitha ndihmë videot
DocType: Agriculture Analysis Criteria,Soil Texture,Cilësi e tokës
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Zgjidh llogaria kreu i bankës ku kontrolli ishte depozituar.
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Lejo përdoruesit të redaktoni listën e çmimeve Vlerësoni në transaksionet
DocType: Pricing Rule,Max Qty,Max Qty
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25,Print Report Card,Kartela e Raportimit të Printimit
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","Row {0}: Fatura {1} është i pavlefshëm, ajo mund të anulohet / nuk ekziston. \ Ju lutem shkruani një faturë e vlefshme"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Pagesa kundër Sales / Rendit Blerje gjithmonë duhet të shënohet si më parë
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Kimik
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Default Llogaria bankare / Cash do të rifreskohet automatikisht në Paga Journal hyrjes kur ky modalitet zgjidhet.
DocType: BOM,Raw Material Cost(Company Currency),Raw Material Kosto (Company Valuta)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: norma nuk mund të jetë më e madhe se norma e përdorur në {1} {2}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: norma nuk mund të jetë më e madhe se norma e përdorur në {1} {2}
apps/erpnext/erpnext/utilities/user_progress.py +147,Meter,metër
DocType: Workstation,Electricity Cost,Kosto të energjisë elektrike
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23,Lab testing datetime cannot be before collection datetime,Datetime testimi i laboratorit nuk mund të jetë para datës së grumbullimit
DocType: HR Settings,Don't send Employee Birthday Reminders,Mos dërgoni punonjës Ditëlindja Përkujtesat
DocType: Expense Claim,Total Advance Amount,Shuma totale e parapagimit
DocType: Delivery Stop,Estimated Arrival,Arritja e parashikuar
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Save Settings,Ruaj cilësimet
DocType: Delivery Stop,Notified by Email,Njoftuar me Email
DocType: Item,Inspection Criteria,Kriteret e Inspektimit
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Transferuar
DocType: BOM Website Item,BOM Website Item,BOM Website Item
apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Ngarko kokën tuaj letër dhe logo. (Ju mund të modifikoni ato më vonë).
DocType: Timesheet Detail,Bill,Fature
apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date is entered as past date,Zhvlerësimi Date tjetër është futur si datë të fundit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,E bardhë
DocType: SMS Center,All Lead (Open),Të gjitha Lead (Open)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +310,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: Qty nuk është në dispozicion për {4} në depo {1} të postimi kohën e hyrjes ({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.,Ju mund të zgjidhni vetëm një maksimum prej një opsioni nga lista e kutive të zgjedhjes.
DocType: Purchase Invoice,Get Advances Paid,Get Paid Përparimet
DocType: Item,Automatically Create New Batch,Automatikisht Krijo grumbull të ri
DocType: Item,Automatically Create New Batch,Automatikisht Krijo grumbull të ri
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635,Assigning {0} to {1} (row {2}),Caktimi i {0} në {1} (rreshti {2})
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Make ,Bëj
DocType: Student Admission,Admission Start Date,Pranimi Data e fillimit
DocType: Journal Entry,Total Amount in Words,Shuma totale në fjalë
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Punonjës i ri
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.,Pati një gabim. Një arsye e mundshme mund të jetë që ju nuk e keni ruajtur formën. Ju lutemi te kontaktoni support@erpnext.com nëse problemi vazhdon.
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Shporta ime
apps/erpnext/erpnext/controllers/selling_controller.py +130,Order Type must be one of {0},Rendit Lloji duhet të jetë një nga {0}
DocType: Lead,Next Contact Date,Tjetër Kontakt Data
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Hapja Qty
DocType: Healthcare Settings,Appointment Reminder,Kujtesë për Emër
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478,Please enter Account for Change Amount,"Ju lutem, jepni llogari për Ndryshim Shuma"
DocType: Program Enrollment Tool Student,Student Batch Name,Student Batch Emri
DocType: Consultation,Doctor,mjek
DocType: Holiday List,Holiday List Name,Festa Lista Emri
DocType: Repayment Schedule,Balance Loan Amount,Bilanci Shuma e Kredisë
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Orari i kursit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Stock Options,Stock Options
DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Çaktivizo marrjen e Detajet e fundit të Blerjes në Rendit Blerje
DocType: Journal Entry Account,Expense Claim,Shpenzim Claim
apps/erpnext/erpnext/assets/doctype/asset/asset.js +267,Do you really want to restore this scrapped asset?,A jeni të vërtetë doni për të rivendosur këtë pasuri braktiset?
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +402,Qty for {0},Qty për {0}
DocType: Leave Application,Leave Application,Lini Aplikimi
DocType: Patient,Patient Relation,Lidhja e pacientit
apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Lini Alokimi Tool
DocType: Item,Hub Category to Publish,Kategoria Hub për Publikim
DocType: Leave Block List,Leave Block List Dates,Dërgo Block Lista Datat
DocType: Sales Invoice,Billing Address GSTIN,Adresa e Faturimit GSTIN
DocType: Assessment Plan,Evaluate,vlerësoj
DocType: Workstation,Net Hour Rate,Shkalla neto Ore
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Kosto zbarkoi Blerje Receipt
DocType: Company,Default Terms,Kushtet Default
DocType: Supplier Scorecard Period,Criteria,kriteret
DocType: Packing Slip Item,Packing Slip Item,Paketimi Shqip Item
DocType: Purchase Invoice,Cash/Bank Account,Cash / Llogarisë Bankare
apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Ju lutem specifikoni një {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,Removed items with no change in quantity or value.,Artikuj hequr me asnjë ndryshim në sasi ose në vlerë.
DocType: Delivery Note,Delivery To,Ofrimit të
apps/erpnext/erpnext/stock/doctype/item/item.js +415,Variant creation has been queued.,Krijimi i variantit ka qenë në radhë.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Përmbledhje e punës për {0}
apps/erpnext/erpnext/stock/doctype/item/item.py +696,Attribute table is mandatory,Tabela atribut është i detyrueshëm
DocType: Production Plan,Get Sales Orders,Get Sales urdhëron
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68,{0} can not be negative,{0} nuk mund të jetë negative
DocType: Training Event,Self-Study,Self-Study
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27,Soil compositions do not add up to 100,Përbërjet e tokës nuk shtojnë deri në 100
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +567,Discount,Zbritje
DocType: Membership,Membership,Anëtarësia
DocType: Asset,Total Number of Depreciations,Numri i përgjithshëm i nënçmime
DocType: Sales Invoice Item,Rate With Margin,Shkalla me diferencë
DocType: Sales Invoice Item,Rate With Margin,Shkalla me diferencë
DocType: Workstation,Wages,Pagat
DocType: Asset Maintenance,Maintenance Manager Name,Emri Menaxheri i Mirëmbajtjes
DocType: Agriculture Task,Urgent,Urgjent
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Ju lutem specifikoni një ID te vlefshme Row për rresht {0} në tryezë {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Nuk mund të gjeni ndryshore:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +807,Please select a field to edit from numpad,Ju lutemi zgjidhni një fushë për të redaktuar nga numpad
apps/erpnext/erpnext/stock/doctype/item/item.py +264,Cannot be a fixed asset item as Stock Ledger is created.,Nuk mund të jetë një element i aseteve fikse si Ledger Stock është krijuar.
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Shko në Desktop dhe të fillojë përdorimin ERPNext
DocType: Item,Manufacturer,Prodhues
DocType: Landed Cost Item,Purchase Receipt Item,Blerje Pranimi i artikullit
DocType: Purchase Receipt,PREC-RET-,Preç-RET-
DocType: POS Profile,Sales Invoice Payment,Sales Pagesa e faturave
DocType: Quality Inspection Template,Quality Inspection Template Name,Emri i modelit të inspektimit të cilësisë
DocType: Project,First Email,Emaili i Parë
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervuar Magazina në Sales Order / Finished mallrave Magazina
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Shuma Shitja
DocType: Repayment Schedule,Interest Amount,Shuma e interesit
DocType: Serial No,Creation Document No,Krijimi Dokumenti Asnjë
DocType: Share Transfer,Issue,Çështje
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,të dhëna
DocType: Asset,Scrapped,braktiset
DocType: Purchase Invoice,Returns,Kthim
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42,WIP Warehouse,WIP Magazina
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serial Asnjë {0} është nën kontratë të mirëmbajtjes upto {1}
apps/erpnext/erpnext/config/hr.py +35,Recruitment,rekrutim
DocType: Lead,Organization Name,Emri i Organizatës
DocType: Tax Rule,Shipping State,Shteti Shipping
,Projected Quantity as Source,Sasia e parashikuar si Burimi
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Item duhet të shtohen duke përdorur &#39;të marrë sendet nga blerjen Pranimet&#39; button
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858,Delivery Trip,Udhëtimi i udhëtimit
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Lloji i transferimit
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Shitjet Shpenzimet
DocType: Consultation,Diagnosis,diagnozë
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Blerja Standard
DocType: GL Entry,Against,Kundër
DocType: Item,Default Selling Cost Center,Gabim Qendra Shitja Kosto
apps/erpnext/erpnext/public/js/pos/pos.html +85,Disc,disk
DocType: Sales Partner,Implementation Partner,Partner Zbatimi
apps/erpnext/erpnext/accounts/page/pos/pos.js +1624,ZIP Code,Kodi Postal
apps/erpnext/erpnext/controllers/selling_controller.py +252,Sales Order {0} is {1},Sales Order {0} është {1}
DocType: Opportunity,Contact Info,Informacionet Kontakt
apps/erpnext/erpnext/config/stock.py +323,Making Stock Entries,Marrja e aksioneve Entries
DocType: Packing Slip,Net Weight UOM,Net Weight UOM
DocType: Item,Default Supplier,Gabim Furnizuesi
DocType: Manufacturing Settings,Over Production Allowance Percentage,Mbi prodhimin Allowance Përqindja
DocType: Employee Loan,Repayment Schedule,sHLYERJES
DocType: Shipping Rule Condition,Shipping Rule Condition,Rregulla Transporti Kushti
DocType: Holiday List,Get Weekly Off Dates,Merr e pushimit javor Datat
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,End Date nuk mund të jetë më pak se Data e fillimit
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337,Invoice can't be made for zero billing hour,Faturë nuk mund të bëhet për zero orë faturimi
DocType: Sales Person,Select company name first.,Përzgjidh kompani emri i parë.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +182,Email sent to {0},Email dërguar për {0}
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Kuotimet e marra nga furnizuesit.
apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Replace BOM dhe update çmimin e fundit në të gjitha BOMs
apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},Për {0} | {1} {2}
DocType: Delivery Trip,Driver Name,Emri i shoferit
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Mesatare Moshë
DocType: Education Settings,Attendance Freeze Date,Pjesëmarrja Freeze Data
DocType: Education Settings,Attendance Freeze Date,Pjesëmarrja Freeze Data
apps/erpnext/erpnext/utilities/user_progress.py +110,List a few of your suppliers. They could be organizations or individuals.,Lista disa nga furnizuesit tuaj. Ata mund të jenë organizata ose individë.
apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Shiko të gjitha Produktet
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Lead Minimumi moshes (ditë)
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Lead Minimumi moshes (ditë)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60,All BOMs,Të gjitha BOM
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Hotel Dhoma të tipit {0} nuk janë në dispozicion në {1}
DocType: Patient,Default Currency,Gabim Valuta
DocType: Expense Claim,From Employee,Nga punonjësi
DocType: Driver,Cellphone Number,Numri i celularit
DocType: Project,Monitor Progress,Monitorimi i progresit
apps/erpnext/erpnext/controllers/accounts_controller.py +472,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Kujdes: Sistemi nuk do të kontrollojë overbilling që shuma për Item {0} në {1} është zero
DocType: Journal Entry,Make Difference Entry,Bëni Diferenca Hyrja
DocType: Upload Attendance,Attendance From Date,Pjesëmarrja Nga Data
DocType: Appraisal Template Goal,Key Performance Area,Key Zona Performance
DocType: Program Enrollment,Transportation,Transport
apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,Atributi i pavlefshëm
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240,{0} {1} must be submitted,{0} {1} duhet të dorëzohet
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},Sasia duhet të jetë më e vogël se ose e barabartë me {0}
DocType: SMS Center,Total Characters,Totali Figurë
DocType: Employee Advance,Claimed,pretenduar
DocType: Crop,Row Spacing,Hapësira e Rreshtit
apps/erpnext/erpnext/controllers/buying_controller.py +165,Please select BOM in BOM field for Item {0},"Ju lutem, përzgjidhni bom në fushën BOM për Item {0}"
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +22,There isn't any item variant for the selected item,Nuk ka asnjë variant të artikullit për artikullin e zgjedhur
DocType: C-Form Invoice Detail,C-Form Invoice Detail,Detail C-Forma Faturë
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Pagesa Pajtimi Faturë
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38,Contribution %,Kontributi%
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}","Sipas Settings Blerja në qoftë Rendit Blerje Kërkohet == &#39;PO&#39;, pastaj për krijimin Blerje Faturën, përdoruesi duhet të krijoni Rendit Blerje parë për pikën {0}"
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Numrat e regjistrimit kompani për referencë tuaj. Numrat e taksave etj
DocType: Sales Partner,Distributor,Shpërndarës
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Shporta Transporti Rregulla
apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Ju lutemi të vendosur &#39;Aplikoni Discount shtesë në&#39;
,Ordered Items To Be Billed,Items urdhëruar të faturuar
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Nga një distancë duhet të jetë më pak se në rang
DocType: Global Defaults,Global Defaults,Defaults Global
apps/erpnext/erpnext/projects/doctype/project/project.py +230,Project Collaboration Invitation,Bashkëpunimi Project Ftesë
DocType: Salary Slip,Deductions,Zbritjet
DocType: Leave Allocation,LAL/,LAL /
DocType: Setup Progress Action,Action Name,Emri i Veprimit
apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,fillimi Year
apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},Para 2 shifrat e GSTIN duhet të përputhen me numrin e Shtetit {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +75,PDC/LC,PDC / LC
DocType: Purchase Invoice,Start date of current invoice's period,Data e fillimit të periudhës së fatura aktual
DocType: Salary Slip,Leave Without Pay,Lini pa pagesë
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385,Capacity Planning Error,Kapaciteti Planifikimi Gabim
,Trial Balance for Party,Bilanci gjyqi për Partinë
DocType: Lead,Consultant,Konsulent
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356,Parents Teacher Meeting Attendance,Pjesëmarrja e Mësimdhënësve të Prindërve
DocType: Salary Slip,Earnings,Fitim
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +483,Finished Item {0} must be entered for Manufacture type entry,Mbaroi Item {0} duhet të jetë hyrë në për hyrje të tipit Prodhimi
apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Hapja Bilanci Kontabilitet
,GST Sales Register,GST Sales Regjistrohu
DocType: Sales Invoice Advance,Sales Invoice Advance,Shitjet Faturë Advance
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Asgjë për të kërkuar
apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Zgjidh Domains tuaj
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Një tjetër rekord i buxhetit &#39;{0}&#39; ekziston kundër {1} &#39;{2}&#39; për vitin fiskal {3}
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Fushat do të kopjohen vetëm në kohën e krijimit.
DocType: Setup Progress Action,Domains,Fushat
apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date','Data e Fillimit' nuk mund të jetë më i madh se 'Data e Mbarimit'
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Drejtuesit
DocType: Cheque Print Template,Payer Settings,Cilësimet paguesit
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""","Kjo do t&#39;i bashkëngjitet Kodit Pika e variant. Për shembull, në qoftë se shkurtim juaj është &quot;SM&quot;, dhe kodin pika është &quot;T-shirt&quot;, kodi pika e variantit do të jetë &quot;T-shirt-SM&quot;"
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Neto Pay (me fjalë) do të jetë i dukshëm një herë ju ruani gabim pagave.
DocType: Purchase Invoice,Is Return,Është Kthimi
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,Caution,Kujdes
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17,Start day is greater than end day in task '{0}',Dita e fillimit është më e madhe se dita e mbarimit në detyrë &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815,Return / Debit Note,Kthimi / Debiti Note
DocType: Price List Country,Price List Country,Lista e Çmimeve Vendi
DocType: Item,UOMs,UOMs
apps/erpnext/erpnext/stock/utils.py +212,{0} valid serial nos for Item {1},{0} nos vlefshme serik për Item {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Kodi artikull nuk mund të ndryshohet për të Serial Nr
DocType: Purchase Invoice Item,UOM Conversion Factor,UOM Konvertimi Faktori
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Ju lutemi shkruani kodin Item për të marrë Numri i Serisë
DocType: Stock Settings,Default Item Group,Gabim Item Grupi
DocType: Employee Loan,Partially Disbursed,lëvrohet pjesërisht
apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Dhënia e informacionit.
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Bazës së të dhënave Furnizuesi.
DocType: Account,Balance Sheet,Bilanci i gjendjes
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750,Cost Center For Item with Item Code ',Qendra Kosto Per Item me Kodin Item &quot;
DocType: Fee Validity,Valid Till,E vlefshme deri
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Takimi Mësues i Prindërve Gjithsej
apps/erpnext/erpnext/accounts/page/pos/pos.js +2512,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Mode pagesa nuk është i konfiguruar. Ju lutem kontrolloni, nëse llogaria është vendosur në Mode të pagesave ose në POS Profilin."
apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Same artikull nuk mund të futen shumë herë.
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","Llogaritë e mëtejshme mund të bëhen në bazë të grupeve, por hyra mund të bëhet kundër jo-grupeve"
DocType: Lead,Lead,Lead
DocType: Email Digest,Payables,Pagueshme
DocType: Course,Course Intro,Sigurisht Intro
apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Stock Hyrja {0} krijuar
apps/erpnext/erpnext/controllers/buying_controller.py +322,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Refuzuar Qty nuk mund të futen në Blerje Kthim
apps/erpnext/erpnext/stock/doctype/item/item.js +182,Changing Customer Group for the selected Customer is not allowed.,Ndryshimi i Grupit të Klientit për Klientin e përzgjedhur nuk është i lejuar.
,Purchase Order Items To Be Billed,Items Rendit Blerje Për të faturohet
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63,Updating estimated arrival times.,Përditësimi i afatit të mbërritjes.
DocType: Program Enrollment Tool,Enrollment Details,Detajet e Regjistrimit
DocType: Purchase Invoice Item,Net Rate,Net Rate
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152,Please select a customer,Ju lutemi zgjidhni një klient
DocType: Purchase Invoice Item,Purchase Invoice Item,Blerje Item Faturë
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,Stock Ledger Hyrje dhe GL Entries janë reposted për Pranimeve zgjedhura Blerje
DocType: Student Report Generation Tool,Assessment Terms,Termat e Vlerësimit
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Pika 1
DocType: Holiday,Holiday,Festë
DocType: Support Settings,Close Issue After Days,Mbylle Issue pas ditë
DocType: Leave Control Panel,Leave blank if considered for all branches,Lini bosh nëse konsiderohet për të gjitha degët
DocType: Bank Guarantee,Validity in Days,Vlefshmëria në Ditët
DocType: Bank Guarantee,Validity in Days,Vlefshmëria në Ditët
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-formë nuk është i zbatueshëm për Faturë: {0}
DocType: Payment Reconciliation,Unreconciled Payment Details,Detajet e pagesës Unreconciled
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Aktiviteti Anëtar
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Rendit Count
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Rendit Count
DocType: Global Defaults,Current Fiscal Year,Vitin aktual fiskal
DocType: Purchase Order,Group same items,Grupi njëjta artikuj
DocType: Purchase Invoice,Disable Rounded Total,Disable rrumbullakosura Total
DocType: Employee Loan Application,Repayment Info,Info Ripagimi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,&quot;Hyrjet&quot; nuk mund të jetë bosh
DocType: Maintenance Team Member,Maintenance Role,Roli i Mirëmbajtjes
apps/erpnext/erpnext/utilities/transaction_base.py +92,Duplicate row {0} with same {1},Duplicate rresht {0} me të njëjtën {1}
,Trial Balance,Bilanci gjyqi
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443,Fiscal Year {0} not found,Viti Fiskal {0} nuk u gjet
apps/erpnext/erpnext/config/hr.py +309,Setting up Employees,Ngritja Punonjësit
DocType: Sales Order,SO-,KËSHTU QË-
DocType: Hotel Room Reservation,Hotel Reservation User,Përdoruesi i Rezervimit të Hoteleve
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158,Please select prefix first,"Ju lutem, përzgjidhni prefiks parë"
DocType: Student,O-,O-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Hulumtim
DocType: Maintenance Visit Purpose,Work Done,Punën e bërë
apps/erpnext/erpnext/controllers/item_variant.py +35,Please specify at least one attribute in the Attributes table,Ju lutem specifikoni të paktën një atribut në tabelë Atributet
DocType: Announcement,All Students,Të gjitha Studentët
apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,{0} artikull duhet të jetë një element jo-aksioneve
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Shiko Ledger
DocType: Grading Scale,Intervals,intervalet
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Hershme
apps/erpnext/erpnext/stock/doctype/item/item.py +526,"An Item Group exists with same name, please change the item name or rename the item group","Një Grup Item ekziston me të njëjtin emër, ju lutemi të ndryshojë emrin pika ose riemërtoj grupin pika"
DocType: Crop Cycle,Less than a year,Më pak se një vit
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +104,Rest Of The World,Pjesa tjetër e botës
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Item {0} nuk mund të ketë Serisë
DocType: Crop,Yield UOM,Yield UOM
,Budget Variance Report,Buxheti Varianca Raport
DocType: Salary Slip,Gross Pay,Pay Bruto
DocType: Item,Is Item from Hub,Është pika nga Hub
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Activity Type is mandatory.,Row {0}: Aktiviteti lloji është i detyrueshëm.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Dividentët e paguar
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Ledger Kontabilitet
DocType: Stock Reconciliation,Difference Amount,Shuma Diferenca
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Dr {0} on Leave on {1},Dr {0} në Lini në {1}
DocType: Purchase Invoice,Reverse Charge,Ngarkesa e kundërt
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Fitime të mbajtura
DocType: Purchase Invoice,05-Change in POS,05-Ndryshimi në POS
DocType: Vehicle Log,Service Detail,Detail shërbimit
DocType: BOM,Item Description,Përshkrimi i artikullit
DocType: Student Sibling,Student Sibling,Student vëlla
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18,Payment Mode,Mode Pagesa
DocType: Purchase Invoice,Supplied Items,Artikujve të furnizuara
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Vendosni një menu aktive për restorantin {0}
DocType: Student,STUD.,Kurvar.
DocType: Work Order,Qty To Manufacture,Qty Për Prodhimi
DocType: Email Digest,New Income,Të ardhurat e re
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Ruajtja njëjtin ritëm gjatë gjithë ciklit të blerjes
DocType: Opportunity Item,Opportunity Item,Mundësi Item
,Student and Guardian Contact Details,Student dhe Guardian Detajet e Kontaktit
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,Row {0}: Për të furnizuesit {0} Adresa Email është e nevojshme për të dërguar një email
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Hapja e përkohshme
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +9,View Hub,Shiko Qendrën
,Employee Leave Balance,Punonjës Pushimi Bilanci
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Gjendjen e llogarisë {0} duhet të jetë gjithmonë {1}
DocType: Patient Appointment,More Info,More Info
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Vlerësoni Vlerësimi nevojshme për Item në rresht {0}
DocType: Supplier Scorecard,Scorecard Actions,Veprimet Scorecard
apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Masters in Computer Science,Shembull: Master në Shkenca Kompjuterike
DocType: Purchase Invoice,Rejected Warehouse,Magazina refuzuar
DocType: GL Entry,Against Voucher,Kundër Bonon
DocType: Item,Default Buying Cost Center,Gabim Qendra Blerja Kosto
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.","Për të marrë më të mirë nga ERPNext, ne ju rekomandojmë që të marrë disa kohë dhe të shikojnë këto video ndihmë."
apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,në
DocType: Supplier Quotation Item,Lead Time in days,Lead Koha në ditë
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70,Accounts Payable Summary,Llogaritë e pagueshme Përmbledhje
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326,Payment of salary from {0} to {1},Pagesa e pagës nga {0} në {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Nuk është i autorizuar për të redaktuar Llogari ngrirë {0}
DocType: Journal Entry,Get Outstanding Invoices,Get Faturat e papaguara
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84,Sales Order {0} is not valid,Sales Order {0} nuk është e vlefshme
DocType: Supplier Scorecard,Warn for new Request for Quotations,Paralajmëroni për Kërkesë të re për Kuotime
apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,urdhrat e blerjes t&#39;ju ndihmuar të planit dhe të ndjekin deri në blerjet tuaja
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Recetat e testit të laboratorit
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}",totale sasia Çështja / Transfer {0} në materiale Kërkesë {1} \ nuk mund të jetë më e madhe se sasia e kërkuar {2} për pikën {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,I vogël
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Hapja e artikullit të krijimit të faturës
DocType: Education Settings,Employee Number,Numri punonjës
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Rast No (s) në përdorim. Provoni nga Rasti Nr {0}
DocType: Project,% Completed,% Kompletuar
,Invoiced Amount (Exculsive Tax),Shuma e faturuar (Tax Exculsive)
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Item 2
DocType: Supplier,SUPP-,SUPP-
DocType: Training Event,Training Event,Event Training
DocType: Item,Auto re-order,Auto ri-qëllim
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Gjithsej Arritur
DocType: Employee,Place of Issue,Vendi i lëshimit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Kontratë
DocType: Plant Analysis,Laboratory Testing Datetime,Datat e testimit laboratorik
DocType: Email Digest,Add Quote,Shto Citim
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1145,UOM coversion factor required for UOM: {0} in Item: {1},Faktori UOM Coversion nevojshme për UOM: {0} në Item: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Shpenzimet indirekte
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +110,Row {0}: Qty is mandatory,Row {0}: Qty është e detyrueshme
DocType: Agriculture Analysis Criteria,Agriculture,Bujqësi
apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Master Data,Sync Master Data
DocType: Asset Repair,Repair Cost,Kostoja e riparimit
apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,Produktet ose shërbimet tuaja
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Dështoi të identifikohej
DocType: Special Test Items,Special Test Items,Artikujt e veçantë të testimit
DocType: Mode of Payment,Mode of Payment,Mënyra e pagesës
apps/erpnext/erpnext/stock/doctype/item/item.py +202,Website Image should be a public file or website URL,Faqja Image duhet të jetë një file publik ose URL website
DocType: Student Applicant,AP,AP
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.,Ky është një grup artikull rrënjë dhe nuk mund të redaktohen.
DocType: Journal Entry Account,Purchase Order,Rendit Blerje
DocType: Vehicle,Fuel UOM,Fuel UOM
DocType: Warehouse,Warehouse Contact Info,Magazina Kontaktimit
DocType: Payment Entry,Write Off Difference Amount,Shkruaj Off Diferenca Shuma
DocType: Volunteer,Volunteer Name,Emri Vullnetar
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: email Punonjësi nuk gjendet, kështu nuk email dërguar"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Rregullimi i transportit nuk zbatohet për vendin {0}
DocType: Item,Foreign Trade Details,Jashtëm Details Tregtisë
,Assessment Plan Status,Statusi i Planit të Vlerësimit
DocType: Email Digest,Annual Income,Të ardhurat vjetore
DocType: Serial No,Serial No Details,Serial No Detajet
DocType: Purchase Invoice Item,Item Tax Rate,Item Tax Rate
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89,Please select Physician and Date,Ju lutemi zgjidhni Mjek dhe Data
DocType: Student Group Student,Group Roll Number,Grupi Roll Number
DocType: Student Group Student,Group Roll Number,Grupi Roll Number
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry","Për {0}, vetëm llogaritë e kreditit mund të jetë i lidhur kundër një tjetër hyrje debiti"
apps/erpnext/erpnext/projects/doctype/project/project.py +84,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Total i të gjitha peshave duhet të jetë detyrë 1. Ju lutemi të rregulluar peshat e të gjitha detyrave të Projektit në përputhje me rrethanat
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588,Delivery Note {0} is not submitted,Ofrimit Shënim {0} nuk është dorëzuar
apps/erpnext/erpnext/stock/get_item_details.py +148,Item {0} must be a Sub-contracted Item,Item {0} duhet të jetë një nënkontraktohet Item
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Pajisje kapitale
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.","Rregulla e Çmimeve është zgjedhur për herë të parë në bazë të &quot;Apliko në &#39;fushë, të cilat mund të jenë të artikullit, Grupi i artikullit ose markë."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246,Please set the Item Code first,Ju lutemi të vendosni fillimisht Kodin e Artikullit
DocType: Item,ITEM-,ITEM-
apps/erpnext/erpnext/controllers/selling_controller.py +123,Total allocated percentage for sales team should be 100,Gjithsej përqindje ndarë për shitjet e ekipit duhet të jetë 100
DocType: Sales Invoice Item,Edit Description,Ndrysho Përshkrimi
DocType: Antibiotic,Antibiotic,antibiotik
,Team Updates,Ekipi Updates
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912,For Supplier,Për Furnizuesin
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Vendosja Tipi Llogarisë ndihmon në zgjedhjen e kësaj llogarie në transaksionet.
DocType: Purchase Invoice,Grand Total (Company Currency),Grand Total (Kompania Valuta)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Krijo Print Format
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Tarifa e krijuar
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},A nuk gjeni ndonjë artikull të quajtur {0}
DocType: Supplier Scorecard Criteria,Criteria Formula,Formula e kritereve
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Total Outgoing,Largohet Total
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""",Nuk mund të jetë vetëm një Transporti Rregulla Kushti me 0 ose vlerë bosh për &quot;vlerës&quot;
DocType: Authorization Rule,Transaction,Transaksion
DocType: Patient Appointment,Duration,kohëzgjatje
apps/erpnext/erpnext/controllers/status_updater.py +160,"For an item {0}, quantity must be positive number","Për një artikull {0}, sasia duhet të jetë numër pozitiv"
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Shënim: Ky Qendra Kosto është një grup. Nuk mund të bëjë shënimet e kontabilitetit kundër grupeve.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53,Child warehouse exists for this warehouse. You can not delete this warehouse.,depo Child ekziston për këtë depo. Ju nuk mund të fshini këtë depo.
DocType: Item,Website Item Groups,Faqja kryesore Item Grupet
DocType: Purchase Invoice,Total (Company Currency),Total (Kompania Valuta)
DocType: Daily Work Summary Group,Reminder,Reminder
apps/erpnext/erpnext/stock/utils.py +207,Serial number {0} entered more than once,Numri serik {0} hyrë më shumë se një herë
DocType: Journal Entry,Journal Entry,Journal Hyrja
DocType: Expense Claim Advance,Unclaimed amount,Shuma e pakthyeshme
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148,{0} items in progress,{0} artikuj në progres
DocType: Workstation,Workstation Name,Workstation Emri
DocType: Grading Scale Interval,Grade Code,Kodi Grade
DocType: POS Item Group,POS Item Group,POS Item Group
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Email Digest:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +23,Alternative item must not be same as item code,Elementi alternativ nuk duhet të jetë i njëjtë me kodin e artikullit
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +617,BOM {0} does not belong to Item {1},BOM {0} nuk i përket Item {1}
DocType: Sales Partner,Target Distribution,Shpërndarja Target
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Finalizimi i vlerësimit të përkohshëm
DocType: Salary Slip,Bank Account No.,Llogarisë Bankare Nr
DocType: Naming Series,This is the number of the last created transaction with this prefix,Ky është numri i transaksionit të fundit të krijuar me këtë prefiks
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)
","Mund të përdoren variablat e vlerësimit, si dhe: {total_score} (rezultati total nga ajo periudhë), {period_number} (numri i periudhave të ditës së sotme)"
DocType: Quality Inspection Reading,Reading 8,Leximi 8
DocType: Sales Partner,Agent,Agjent
DocType: Purchase Invoice,Taxes and Charges Calculation,Taksat dhe Tarifat Llogaritja
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Zhvlerësimi Book Asset Hyrja Automatikisht
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Zhvlerësimi Book Asset Hyrja Automatikisht
DocType: BOM Operation,Workstation,Workstation
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Kërkesë për Kuotim Furnizuesit
DocType: Healthcare Settings,Registration Message,Mesazhi i regjistrimit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Hardware
DocType: Prescription Dosage,Prescription Dosage,Dozimi i recetës
DocType: Attendance,HR Manager,Menaxher HR
apps/erpnext/erpnext/accounts/party.py +175,Please select a Company,Ju lutem zgjidhni një Company
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilegj Leave
DocType: Purchase Invoice,Supplier Invoice Date,Furnizuesi Data e faturës
DocType: Asset Settings,This value is used for pro-rata temporis calculation,Kjo vlerë përdoret për llogaritjen pro-rata temporis
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Ju duhet të mundësojnë Shporta
DocType: Payment Entry,Writeoff,Writeoff
DocType: Stock Settings,Naming Series Prefix,Emërtimi i Prefixit të Serive
DocType: Appraisal Template Goal,Appraisal Template Goal,Vlerësimi Template Qëllimi
DocType: Salary Component,Earning,Fituar
DocType: Supplier Scorecard,Scoring Criteria,Kriteret e shënimit
DocType: Purchase Invoice,Party Account Currency,Llogaria parti Valuta
,BOM Browser,Bom Browser
apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Ju lutemi update statusin tuaj për këtë ngjarje trajnimi
DocType: Item Barcode,EAN,EAN
DocType: Purchase Taxes and Charges,Add or Deduct,Shto ose Zbres
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Kushtet e mbivendosjes gjenden në mes:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Kundër Fletoren Hyrja {0} është përshtatur tashmë kundër një kupon tjetër
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Vlera Totale Rendit
apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Ushqim
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57,Ageing Range 3,Gama plakjen 3
DocType: Maintenance Schedule Item,No of Visits,Nr i vizitave
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Mirëmbajtja Shtojca {0} ekziston kundër {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,studenti regjistrimit
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Monedhën e llogarisë Mbyllja duhet të jetë {0}
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Shuma e pikëve për të gjitha qëllimet duhet të jetë 100. Kjo është {0}
DocType: Project,Start and End Dates,Filloni dhe Fundi Datat
,Delivered Items To Be Billed,Items dorëzohet për t&#39;u faturuar
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Hapur BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Depo nuk mund të ndryshohet për të Serial Nr
DocType: Authorization Rule,Average Discount,Discount mesatar
DocType: Project Update,Great/Quickly,Madhe / shpejt
DocType: Purchase Invoice Item,UOM,UOM
DocType: Rename Tool,Utilities,Shërbime komunale
DocType: POS Profile,Accounting,Llogaritje
DocType: Employee,EMP/,EMP /
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +138,Please select batches for batched item ,"Ju lutem, përzgjidhni tufa për artikull në pako"
DocType: Asset,Depreciation Schedules,Oraret e amortizimit
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192,Following accounts might be selected in GST Settings:,Llogaritë pasuese mund të zgjidhen në cilësimet e GST:
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70,Application period cannot be outside leave allocation period,Periudha e aplikimit nuk mund të jetë periudhë ndarja leje jashtë
DocType: Activity Cost,Projects,Projektet
DocType: Payment Request,Transaction Currency,Transaction Valuta
apps/erpnext/erpnext/controllers/buying_controller.py +31,From {0} | {1} {2},Nga {0} | {1} {2}
apps/erpnext/erpnext/public/js/hub/hub_listing.js +341,Removed from Favourites,Hequr nga Preferencat
DocType: Work Order Operation,Operation Description,Operacioni Përshkrim
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.,Nuk mund të ndryshojë fiskale Viti Fillimit Data dhe viti fiskal End Date herë Viti fiskal është ruajtur.
DocType: Quotation,Shopping Cart,Karrocat
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Avg Daily Outgoing,Avg Daily largohet
DocType: POS Profile,Campaign,Fushatë
DocType: Supplier,Name and Type,Emri dhe lloji i
DocType: Physician,Contacts and Address,Kontaktet dhe Adresa
DocType: Purchase Invoice,Contact Person,Personi kontaktues
apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date',&quot;Pritet Data e Fillimit &#39;nuk mund të jetë më i madh se&quot; Data e Përfundimit e pritshme&#39;
DocType: Course Scheduling Tool,Course End Date,Sigurisht End Date
DocType: Holiday List,Holidays,Pushime
DocType: Sales Order Item,Planned Quantity,Sasia e planifikuar
DocType: Purchase Invoice Item,Item Tax Amount,Shuma Tatimore Item
DocType: Water Analysis,Water Analysis Criteria,Kriteret e analizës së ujit
DocType: Item,Maintain Stock,Ruajtja Stock
DocType: Employee,Prefered Email,i preferuar Email
DocType: Student Admission,Eligibility and Details,Pranueshmëria dhe Detajet
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38,Net Change in Fixed Asset,Ndryshimi neto në aseteve fikse
DocType: Leave Control Panel,Leave blank if considered for all designations,Lini bosh nëse konsiderohet për të gjitha përcaktimeve
apps/erpnext/erpnext/controllers/accounts_controller.py +808,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Ngarkesa e tipit &#39;aktuale&#39; në rresht {0} nuk mund të përfshihen në Item Rate
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +403,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Nga datetime
DocType: Email Digest,For Company,Për Kompaninë
apps/erpnext/erpnext/config/support.py +17,Communication log.,Log komunikimi.
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.","Kërkesë për Kuotim është me aftësi të kufizuara për qasje nga portali, për më shumë konfigurimet e portalit kontrollit."
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Rezultati i rezultatit të furnitorit që shënon variablën
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Blerja Shuma
DocType: Sales Invoice,Shipping Address Name,Transporti Adresa Emri
DocType: Material Request,Terms and Conditions Content,Termat dhe Kushtet Përmbajtja
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Kishte gabime në krijimin e orarit të lëndëve
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581,cannot be greater than 100,nuk mund të jetë më i madh se 100
apps/erpnext/erpnext/stock/doctype/item/item.py +752,Item {0} is not a stock Item,Item {0} nuk është një gjendje Item
DocType: Maintenance Visit,Unscheduled,Paplanifikuar
DocType: Employee,Owned,Pronësi
DocType: Salary Detail,Depends on Leave Without Pay,Varet në pushim pa pagesë
DocType: Pricing Rule,"Higher the number, higher the priority","Më i lartë numri, më i lartë prioriteti"
,Purchase Invoice Trends,Blerje Trendet Faturë
DocType: Employee,Better Prospects,Perspektivë më të mirë
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","Rresht # {0}: The batch {1} ka vetëm {2} Qty. Ju lutem zgjidhni një tjetër grumbull cila ka {3} Qty në dispozicion ose ndarë rresht në rreshta të shumta, për të ofruar / çështje nga tufa të shumta"
DocType: Vehicle,License Plate,Targë
DocType: Appraisal,Goals,Qëllimet
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +357,Select POS Profile,Zgjidh Profilin e POS
DocType: Warranty Claim,Warranty / AMC Status,Garanci / AMC Statusi
,Accounts Browser,Llogaritë Browser
DocType: Payment Entry Reference,Payment Entry Reference,Pagesa Reference Hyrja
DocType: GL Entry,GL Entry,GL Hyrja
DocType: HR Settings,Employee Settings,Cilësimet e punonjësve
,Batch-Wise Balance History,Batch-urti Historia Bilanci
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,cilësimet e printimit përditësuar në format përkatëse të shtypura
DocType: Package Code,Package Code,Kodi paketë
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Nxënës
DocType: Purchase Invoice,Company GSTIN,Company GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,Negative Quantity is not allowed,Sasi negativ nuk është e lejuar
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",Detaje taksave tryezë sforcuar nga mjeshtri pika si një varg dhe të depozituara në këtë fushë. Përdoret për taksat dhe tatimet
DocType: Supplier Scorecard Period,SSC-,SSC-
apps/erpnext/erpnext/hr/doctype/employee/employee.py +160,Employee cannot report to himself.,Punonjësi nuk mund të raportojnë për veten e tij.
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Në qoftë se llogaria është e ngrirë, shënimet janë të lejuar për përdoruesit të kufizuara."
DocType: Email Digest,Bank Balance,Bilanci bankë
apps/erpnext/erpnext/accounts/party.py +240,Accounting Entry for {0}: {1} can only be made in currency: {2},Hyrja Kontabiliteti për {0}: {1} mund të bëhen vetëm në monedhën: {2}
DocType: Job Opening,"Job profile, qualifications required etc.","Profili i punës, kualifikimet e nevojshme etj"
DocType: Journal Entry Account,Account Balance,Bilanci i llogarisë
apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Rregulla taksë për transaksionet.
DocType: Rename Tool,Type of document to rename.,Lloji i dokumentit për të riemërtoni.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Customer është i detyruar kundrejt llogarisë arkëtueshme {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Totali Taksat dhe Tarifat (Kompania Valuta)
DocType: Weather,Weather Parameter,Parametri i motit
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Trego P &amp; L bilancet pambyllur vitit fiskal
apps/erpnext/erpnext/public/js/hub/hub_form.js +336,Request a Quote,Të kërkojë një kuotë
DocType: Lab Test Template,Collection Details,Detajet e mbledhjes
DocType: POS Profile,Allow Print Before Pay,Lejo Printim Para Pagimit
DocType: Land Unit,Linked Soil Texture,Lidhur me strukturën e tokës
DocType: Shipping Rule,Shipping Account,Llogaria anijeve
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Llogaria {2} është joaktiv
apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Bëni Sales urdhëron për të ndihmuar ju planifikoni punën tuaj dhe të japë në kohë
DocType: Quality Inspection,Readings,Lexime
DocType: Stock Entry,Total Additional Costs,Gjithsej kosto shtesë
DocType: Course Schedule,SH,SH
DocType: BOM,Scrap Material Cost(Company Currency),Kosto skrap Material (Company Valuta)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Kuvendet Nën
DocType: Asset,Asset Name,Emri i Aseteve
DocType: Project,Task Weight,Task Pesha
DocType: Shipping Rule Condition,To Value,Të vlerës
DocType: Asset Movement,Stock Manager,Stock Menaxher
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +211,Source warehouse is mandatory for row {0},Depo Burimi është i detyrueshëm për rresht {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Termi i pagesës në rresht {0} është ndoshta një kopje.
apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Bujqësia (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863,Packing Slip,Shqip Paketimi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Zyra Qira
apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Setup SMS settings portë
DocType: Disease,Common Name,Emer i perbashket
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Import dështoi!
apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Ka adresë shtuar ende.
DocType: Workstation Working Hour,Workstation Working Hour,Workstation orë pune
DocType: Vital Signs,Blood Pressure,Presioni i gjakut
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Analist
DocType: Item,Inventory,Inventar
DocType: Item,Sales Details,Shitjet Detajet
DocType: Quality Inspection,QI-,QI-
DocType: Opportunity,With Items,Me Items
DocType: Asset Maintenance,Maintenance Team,Ekipi i Mirëmbajtjes
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,Në Qty
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Vlereso regjistruar Kursin për Studentët në Grupin e Studentëve
DocType: Notification Control,Expense Claim Rejected,Shpenzim Kërkesa Refuzuar
DocType: Item,Item Attribute,Item Attribute
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Qeveri
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Expense Kërkesa {0} ekziston për Log automjeteve
apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Emri Institute
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Ju lutemi shkruani shlyerjes Shuma
apps/erpnext/erpnext/config/stock.py +313,Item Variants,Variantet pika
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Sherbime
DocType: HR Settings,Email Salary Slip to Employee,Email Paga Slip për të punësuarit
DocType: Cost Center,Parent Cost Center,Qendra prind Kosto
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Select Possible Supplier,Zgjidhni mundshëm Furnizuesi
DocType: Sales Invoice,Source,Burim
DocType: Customer,"Select, to make the customer searchable with these fields","Përzgjidhni, për ta bërë konsumatorin të kërkueshëm me këto fusha"
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Shfaq të mbyllura
DocType: Leave Type,Is Leave Without Pay,Lini është pa pagesë
apps/erpnext/erpnext/stock/doctype/item/item.py +261,Asset Category is mandatory for Fixed Asset item,Asset Kategoria është i detyrueshëm për artikull Aseteve Fikse
DocType: Fee Validity,Fee Validity,Vlefshmëria e tarifës
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,Nuk u gjetën në tabelën e Pagesave të dhënat
apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Kjo {0} konfliktet me {1} për {2} {3}
DocType: Student Attendance Tool,Students HTML,studentët HTML
DocType: POS Profile,Apply Discount,aplikoni Discount
DocType: GST HSN Code,GST HSN Code,GST Code HSN
DocType: Employee External Work History,Total Experience,Përvoja Total
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Projektet e hapura
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295,Packing Slip(s) cancelled,Paketimi Shqip (s) anulluar
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36,Cash Flow from Investing,Cash Flow nga Investimi
DocType: Program Course,Program Course,Kursi program
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Mallrave dhe Forwarding Pagesat
DocType: Homepage,Company Tagline for website homepage,Kompania Tagline për faqen e internetit
DocType: Item Group,Item Group Name,Item Emri i Grupit
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Marrë
DocType: Student,Date of Leaving,Datën e largimit
DocType: Pricing Rule,For Price List,Për listën e çmimeve
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Ekzekutiv Kërko
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Vendosja e parazgjedhjeve
apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Krijo kryeson
DocType: Maintenance Schedule,Schedules,Oraret
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +472,POS Profile is required to use Point-of-Sale,Profil POS duhet të përdorë Point-of-Sale
DocType: Purchase Invoice Item,Net Amount,Shuma neto
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} nuk ka qenë i paraqitur në mënyrë veprimi nuk mund të përfundojë
DocType: Purchase Order Item Supplied,BOM Detail No,Bom Detail Asnjë
DocType: Landed Cost Voucher,Additional Charges,akuza të tjera
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Shtesë Shuma Discount (Valuta Company)
DocType: Supplier Scorecard,Supplier Scorecard,Nota e Furnizuesit
DocType: Plant Analysis,Result Datetime,Rezultat Datetime
,Support Hour Distribution,Shpërndarja e orëve të mbështetjes
DocType: Maintenance Visit,Maintenance Visit,Mirëmbajtja Vizitoni
DocType: Student,Leaving Certificate Number,Lënia Certifikata Numri
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58,"Appointment cancelled, Please review and cancel the invoice {0}","Emërimi u anulua, Ju lutem shqyrtoni dhe anuloni faturën {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Batch dispozicion Qty në Magazina
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Update Print Format
DocType: Landed Cost Voucher,Landed Cost Help,Zbarkoi Kosto Ndihmë
DocType: Purchase Invoice,Select Shipping Address,Zgjidh Shipping Adresa
DocType: Timesheet Detail,Expected Hrs,Orët e pritshme
apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Detajet e Memphership
DocType: Leave Block List,Block Holidays on important days.,Festat bllok në ditë të rëndësishme.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220,Please input all required Result Value(s),Futni të gjitha vlerat (et) e kërkuara të rezultatit
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106,Accounts Receivable Summary,Llogaritë Arkëtueshme Përmbledhje
DocType: Employee Loan,Monthly Repayment Amount,Shuma mujore e pagesës
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Hapja e faturave
apps/erpnext/erpnext/hr/doctype/employee/employee.py +196,Please set User ID field in an Employee record to set Employee Role,Ju lutemi të vendosur User fushë ID në një rekord të Punonjësve të vendosur Roli punonjës
DocType: UOM,UOM Name,Emri UOM
DocType: GST HSN Code,HSN Code,Kodi HSN
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39,Contribution Amount,Shuma Kontribut
DocType: Purchase Invoice,Shipping Address,Transporti Adresa
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.,Ky mjet ju ndihmon për të rinovuar ose të rregulluar sasinë dhe vlerësimin e aksioneve në sistemin. Ajo është përdorur zakonisht për të sinkronizuar vlerat e sistemit dhe çfarë në të vërtetë ekziston në depo tuaj.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Me fjalë do të jetë i dukshëm një herë ju ruani notën shpërndarëse.
DocType: Expense Claim,EXP,EXP
apps/erpnext/erpnext/erpnext_integrations/connectors/woocommerce_connection.py +21,Unverified Webhook Data,Të dhënat e verifikuara të Webhook
DocType: Water Analysis,Container,enë
apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} shfaqet disa herë në rresht {2} dhe {3}
DocType: Item Alternative,Two-way,Me dy kalime
DocType: Project,Day to Send,Dita për të dërguar
DocType: Healthcare Settings,Manage Sample Collection,Menaxho mbledhjen e mostrave
DocType: Production Plan,Ignore Existing Ordered Quantity,Ignore sasinë e porositur ekzistuese
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66,Please set the series to be used.,Ju lutem vendosni serinë që do të përdoret.
DocType: Patient,Tobacco Past Use,Përdorimi i Kaluar i Duhanit
DocType: Sales Invoice Item,Brand Name,Brand Name
DocType: Purchase Receipt,Transporter Details,Detajet Transporter
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55,User {0} is already assigned to Physician {1},Përdoruesi {0} është caktuar tashmë tek Mjeku {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2696,Default warehouse is required for selected item,depo Default është e nevojshme për pika të zgjedhura
apps/erpnext/erpnext/utilities/user_progress.py +146,Box,Kuti
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038,Possible Supplier,mundur Furnizuesi
DocType: Budget,Monthly Distribution,Shpërndarja mujore
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Marresit Lista është e zbrazët. Ju lutem krijoni Marresit Lista
apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Shëndetësia (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Prodhimit Plani Rendit Sales
DocType: Sales Partner,Sales Partner Target,Sales Partner Target
DocType: Loan Type,Maximum Loan Amount,Shuma maksimale e kredisë
DocType: Pricing Rule,Pricing Rule,Rregulla e Çmimeve
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Numri Duplicate roll për nxënës {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Numri Duplicate roll për nxënës {0}
DocType: Budget,Action if Annual Budget Exceeded,Veprimi në qoftë Buxheti vjetor Tejkaluar
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Kërkesë materiale për të blerë Radhit
DocType: Shopping Cart Settings,Payment Success URL,Pagesa Suksesi URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: kthye Item {1} nuk ekziston në {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,Llogaritë bankare
,Bank Reconciliation Statement,Deklarata Banka Pajtimit
DocType: Consultation,Medical Coding,Kodifikimi mjekësor
DocType: Healthcare Settings,Reminder Message,Mesazhi i kujtesës
,Lead Name,Emri Lead
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/config/stock.py +318,Opening Stock Balance,Hapja Stock Bilanci
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} duhet të shfaqen vetëm një herë
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Lë alokuar sukses për {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Asnjë informacion që të dal
DocType: Shipping Rule Condition,From Value,Nga Vlera
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +655,Manufacturing Quantity is mandatory,Prodhim Sasia është e detyrueshme
DocType: Employee Loan,Repayment Method,Metoda Ripagimi
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Nëse zgjidhet, faqja Faqja do të jetë paracaktuar Item Grupi për faqen e internetit"
DocType: Quality Inspection Reading,Reading 4,Leximi 4
apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Kërkesat për shpenzimet e kompanisë.
apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Studentët janë në zemër të sistemit, shtoni të gjithë studentët tuaj"
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: date Pastrimi {1} nuk mund të jetë para datës çek {2}
DocType: Asset Maintenance Task,Certificate Required,Certifikata e kërkuar
DocType: Company,Default Holiday List,Default Festa Lista
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196,Row {0}: From Time and To Time of {1} is overlapping with {2},Row {0}: Nga kohë dhe për kohën e {1} është mbivendosje me {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Stock Detyrimet
DocType: Purchase Invoice,Supplier Warehouse,Furnizuesi Magazina
DocType: Opportunity,Contact Mobile No,Kontaktoni Mobile Asnjë
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +403,Select Company,Zgjidh kompanisë
,Material Requests for which Supplier Quotations are not created,Kërkesat materiale për të cilat Kuotimet Furnizuesi nuk janë krijuar
DocType: Student Report Generation Tool,Print Section,Seksioni i Printimit
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.,Përdoruesi {0} nuk ka ndonjë Profil POS të parazgjedhur. Kontrolloni Default në Row {1} për këtë Përdorues.
DocType: Student Group,Set 0 for no limit,Set 0 për pa limit
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Dita (s) në të cilin ju po aplikoni për leje janë festa. Ju nuk duhet të aplikoni për leje.
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,Rreshti {idx}: {field} kërkohet për të krijuar Faturat e Hapjes {invoice_type}
DocType: Customer,Primary Address and Contact Detail,Adresa Fillestare dhe Detajet e Kontaktit
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Ridergo Pagesa Email
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Detyra e re
DocType: Consultation,Appointment,takim
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Bëni Kuotim
apps/erpnext/erpnext/config/education.py +230,Other Reports,Raportet tjera
apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Ju lutem zgjidhni të paktën një domain.
DocType: Dependent Task,Dependent Task,Detyra e varur
apps/erpnext/erpnext/stock/doctype/item/item.py +444,Conversion factor for default Unit of Measure must be 1 in row {0},Faktori i konvertimit për Njësinë e parazgjedhur të Masës duhet të jetë 1 në rreshtin e {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188,Leave of type {0} cannot be longer than {1},Pushimi i tipit {0} nuk mund të jetë më i gjatë se {1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Provoni planifikimin e operacioneve për ditë X paraprakisht.
DocType: HR Settings,Stop Birthday Reminders,Stop Ditëlindja Harroni
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Ju lutemi të vendosur Default Payroll Llogaria e pagueshme në Kompaninë {0}
DocType: SMS Center,Receiver List,Marresit Lista
apps/erpnext/erpnext/accounts/page/pos/pos.js +1094,Search Item,Kërko Item
DocType: Payment Schedule,Payment Amount,Shuma e pagesës
DocType: Patient Appointment,Referring Physician,Mjeku referues
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Shuma konsumuar
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100,Net Change in Cash,Ndryshimi neto në para të gatshme
DocType: Assessment Plan,Grading Scale,Scale Nota
apps/erpnext/erpnext/stock/doctype/item/item.py +438,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Njësia e masës {0} ka hyrë më shumë se një herë në Konvertimi Faktori Tabelën
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +665,Already completed,përfunduar tashmë
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Stock In Hand
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Importi i suksesshëm!
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Kërkesa pagesa tashmë ekziston {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Kostoja e Artikujve emetuara
DocType: Physician,Hospital,spital
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +406,Quantity must not be more than {0},Sasia nuk duhet të jetë më shumë se {0}
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Previous Viti financiar nuk është e mbyllur
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +68,Age (Days),Mosha (ditë)
DocType: Quotation Item,Quotation Item,Citat Item
DocType: Customer,Customer POS Id,Customer POS Id
DocType: Account,Account Name,Emri i llogarisë
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Nga Data nuk mund të jetë më i madh se deri më sot
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serial No {0} sasi {1} nuk mund të jetë një pjesë
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +96,Please enter Woocommerce Server URL,Ju lutemi shkruani URL Woocommerce Server
apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Furnizuesi Lloji mjeshtër.
DocType: Purchase Order Item,Supplier Part Number,Furnizuesi Pjesa Numër
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Shkalla e konvertimit nuk mund të jetë 0 ose 1
DocType: Share Balance,To No,Për Nr
DocType: Subscription,Reference Document,Dokumenti Referenca
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229,{0} {1} is cancelled or stopped,{0} {1} është anuluar ose ndaluar
DocType: Accounts Settings,Credit Controller,Kontrolluesi krediti
DocType: Grant Application,Applicant Type,Lloji i aplikantit
DocType: Purchase Invoice,03-Deficiency in services,03-Mangësi në shërbime
DocType: Delivery Note,Vehicle Dispatch Date,Automjeteve Dërgimi Data
DocType: Healthcare Settings,Default Medical Code Standard,Standardi i Kodit të Mjekësisë Default
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,Blerje Pranimi {0} nuk është dorëzuar
DocType: Company,Default Payable Account,Gabim Llogaria pagueshme
apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Cilësimet për internet shopping cart tilla si rregullat e transportit detar, lista e çmimeve etj"
apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% faturuar
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Qty rezervuara
DocType: Party Account,Party Account,Llogaria Partia
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Burimeve Njerëzore
DocType: Lead,Upper Income,Të ardhurat e sipërme
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,hedh poshtë
DocType: Journal Entry Account,Debit in Company Currency,Debit në kompanisë Valuta
DocType: BOM Item,BOM Item,Bom Item
DocType: Appraisal,For Employee,Për punonjësit
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Bëni disbursimi Hyrja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Row {0}: Advance kundër Furnizuesit duhet të debiti
DocType: Company,Default Values,Vlerat Default
DocType: Membership,INR,INR
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frekuencë} Digest
DocType: Expense Claim,Total Amount Reimbursed,Shuma totale rimbursohen
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Kjo është e bazuar në shkrimet kundër këtij automjeteve. Shih afat kohor më poshtë për detaje
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Kundër Furnizuesin Fatura {0} datë {1}
DocType: Customer,Default Price List,E albumit Lista e Çmimeve
apps/erpnext/erpnext/assets/doctype/asset/asset.py +322,Asset Movement record {0} created,Rekord Lëvizja Asset {0} krijuar
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,Ju nuk mund të fshini Viti Fiskal {0}. Viti Fiskal {0} është vendosur si default në Settings Global
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Një klient me të njëjtin emër tashmë ekziston
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?,Kjo do të paraqesë Slipin e Pagave dhe do të krijojë regjistrimin e përhershëm të ditarit. A doni të vazhdoni?
DocType: Purchase Invoice,Total Net Weight,Pesha totale neto
DocType: Purchase Order,Order Confirmation No,Konfirmimi i Urdhrit Nr
DocType: Purchase Invoice,Eligibility For ITC,Pranueshmëria Për ITC
DocType: Journal Entry,Entry Type,Hyrja Lloji
,Customer Credit Balance,Bilanci Customer Credit
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28,Net Change in Accounts Payable,Ndryshimi neto në llogaritë e pagueshme
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,EcritureLet,EcritureLet
apps/erpnext/erpnext/selling/doctype/customer/customer.py +209,Credit limit has been crossed for customer {0} ({1}/{2}),Limiti i kredisë është kaluar për konsumatorin {0} ({1} / {2})
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Customer kërkohet për &#39;Customerwise Discount &quot;
apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Update pagesës datat bankare me revista.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,çmimi
DocType: Quotation,Term Details,Detajet Term
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Nuk mund të regjistrohen më shumë se {0} nxënësve për këtë grup të studentëve.
apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),Totali (pa Tatimore)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Numërimi Lead
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Numërimi Lead
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} duhet të jetë më i madh se 0
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30,Stock Available,Në dispozicion
DocType: Manufacturing Settings,Capacity Planning For (Days),Planifikimi i kapaciteteve për (ditë)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Prokurimit
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66,None of the items have any change in quantity or value.,Asnjë nga pikat ketë ndonjë ndryshim në sasi ose vlerë.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Fushë e detyrueshme - Program
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Fushë e detyrueshme - Program
DocType: Special Test Template,Result Component,Komponenti i rezultatit
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garanci Claim
,Lead Details,Detajet Lead
DocType: Volunteer,Availability and Skills,Disponueshmëria dhe Aftësitë
DocType: Salary Slip,Loan repayment,shlyerjen e kredisë
DocType: Purchase Invoice,End date of current invoice's period,Data e fundit e periudhës së fatura aktual
DocType: Pricing Rule,Applicable For,Të zbatueshme për
DocType: Lab Test,Technician Name,Emri Teknik
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Shkëput Pagesa mbi anulimin e Faturë
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Leximi aktuale Odometer hyrë duhet të jetë më i madh se fillestare automjeteve rrugëmatës {0}
DocType: Restaurant Reservation,No Show,Asnjë shfaqje
DocType: Shipping Rule Country,Shipping Rule Country,Rregulla Shipping Vendi
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Lini dhe Pjesëmarrja
DocType: Maintenance Visit,Partially Completed,Kompletuar Pjesërisht
apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Ndjeshmëri e moderuar
DocType: Leave Type,Include holidays within leaves as leaves,Përfshijnë pushimet brenda lë si gjethe
DocType: Sales Invoice,Packed Items,Items të mbushura
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garanci Padia kundër Serial Nr
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +209,'Total',&quot;Total&quot;
DocType: Shopping Cart Settings,Enable Shopping Cart,Aktivizo Shporta
DocType: Employee,Permanent Address,Adresa e përhershme
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Advance paguar kundër {0} {1} nuk mund të jetë më e madhe \ se Grand Total {2}
DocType: Consultation,Medication,mjekim
DocType: Production Plan,Include Non Stock Items,Përfshirja e Items Non Stock
DocType: Project Update,Challenging/Slow,Sfiduese / Slow
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Ju lutemi zgjidhni kodin pika
DocType: Student Sibling,Studying in Same Institute,Studimi në njëjtën Institutin
DocType: Territory,Territory Manager,Territori Menaxher
DocType: Packed Item,To Warehouse (Optional),Për Magazina (Fakultativ)
DocType: GST Settings,GST Accounts,Llogaritë GST
DocType: Payment Entry,Paid Amount (Company Currency),Paid Shuma (Kompania Valuta)
DocType: Purchase Invoice,Additional Discount,Discount shtesë
DocType: Selling Settings,Selling Settings,Shitja Settings
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +110,Confirm Action,Konfirmo veprimin
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Auctions Online
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,Please specify either Quantity or Valuation Rate or both,Ju lutem specifikoni ose Sasia apo vlerësimin Vlerësoni apo të dyja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,përmbushje
apps/erpnext/erpnext/templates/generators/item.html +82,View in Cart,Shiko në Shportë
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Shpenzimet e marketingut
,Item Shortage Report,Item Mungesa Raport
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Nuk mund të krijohen kritere standarde. Ju lutemi riemërtoni kriteret
apps/erpnext/erpnext/stock/doctype/item/item.js +311,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Pesha është përmendur, \ nJu lutemi të përmendim &quot;Weight UOM&quot; shumë"
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Kërkesa material përdoret për të bërë këtë Stock Hyrja
apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Zhvlerësimi Data Next është i detyrueshëm për pasuri të re
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Sigurisht veçantë bazuar Grupi për çdo Batch
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Sigurisht veçantë bazuar Grupi për çdo Batch
apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Njësi e vetme e një artikulli.
DocType: Fee Category,Fee Category,Tarifa Kategoria
DocType: Agriculture Task,Next Business Day,Dita e ardhshme e punës
DocType: Drug Prescription,Dosage by time interval,Dozimi sipas intervalit kohor
DocType: Cash Flow Mapper,Section Header,Seksioni Shembull
,Student Fee Collection,Tarifa Student Collection
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24,Appointment Duration (mins),Kohëzgjatja e takimit (minuta)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Bëni hyrje të kontabilitetit për çdo veprim Stock
DocType: Leave Allocation,Total Leaves Allocated,Totali Lë alokuar
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Magazina kërkohet në radhë nr {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +145,Please enter valid Financial Year Start and End Dates,Ju lutem shkruani Viti Financiar i vlefshëm Start dhe Datat Fundi
DocType: Employee,Date Of Retirement,Data e daljes në pension
DocType: Upload Attendance,Get Template,Get Template
DocType: Material Request,Transferred,transferuar
DocType: Vehicle,Doors,Dyer
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +116,ERPNext Setup Complete!,ERPNext Setup Complete!
DocType: Healthcare Settings,Collect Fee for Patient Registration,Mblidhni Tarifën për Regjistrimin e Pacientëve
apps/erpnext/erpnext/stock/doctype/item/item.py +678,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Nuk mund të ndryshojë Atributet pas transaksionit të aksioneve. Bëni një artikull të ri dhe transferoni stokun në artikullin e ri
DocType: Course Assessment Criteria,Weightage,Weightage
DocType: Purchase Invoice,Tax Breakup,Breakup Tax
DocType: Packing Slip,PS-,PS-
DocType: Member,Non Profit Member,Anëtar Jo Profit
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}: Qendra Kosto është e nevojshme për &quot;Fitimi dhe Humbja &#39;llogarisë {2}. Ju lutemi të ngritur një qendër me kosto të paracaktuar për kompaninë.
DocType: Payment Schedule,Payment Term,Kushtet e pagesës
apps/erpnext/erpnext/selling/doctype/customer/customer.py +160,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Një grup të konsumatorëve ekziston me të njëjtin emër, ju lutem të ndryshojë emrin Customer ose riemërtoni grup të konsumatorëve"
DocType: Land Unit,Area,zonë
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Kontakti i ri
DocType: Territory,Parent Territory,Territori prind
DocType: Purchase Invoice,Place of Supply,Vendi i furnizimit
DocType: Quality Inspection Reading,Reading 2,Leximi 2
DocType: Stock Entry,Material Receipt,Pranimi materiale
DocType: Homepage,Products,Produkte
DocType: Announcement,Instructor,instruktor
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +95,Select Item (optional),Zgjidh artikullin (opsional)
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Orari i tarifave Grupi i Studentëve
DocType: Student,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Nëse ky artikull ka variante, atëherë ajo nuk mund të zgjidhen në shitje urdhrat etj"
DocType: Lead,Next Contact By,Kontakt Next By
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325,Quantity required for Item {0} in row {1},Sasia e nevojshme për Item {0} në rresht {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45,Warehouse {0} can not be deleted as quantity exists for Item {1},Magazina {0} nuk mund të fshihet si ekziston sasia e artikullit {1}
DocType: Quotation,Order Type,Rendit Type
,Item-wise Sales Register,Pika-mençur Sales Regjistrohu
DocType: Asset,Gross Purchase Amount,Shuma Blerje Gross
apps/erpnext/erpnext/utilities/user_progress.py +39,Opening Balances,Hapjet e hapjes
DocType: Asset,Depreciation Method,Metoda e amortizimit
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,A është kjo Tatimore të përfshira në normën bazë?
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Target Total
DocType: Soil Texture,Sand Composition (%),Përbërja e rërës (%)
DocType: Job Applicant,Applicant for a Job,Aplikuesi për një punë
DocType: Production Plan Material Request,Production Plan Material Request,Prodhimi Plan Material Request
DocType: Stock Reconciliation,Reconciliation JSON,Pajtimi JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Shumë kolona. Eksportit raportin dhe të shtypura duke përdorur një aplikim spreadsheet.
DocType: Purchase Invoice Item,Batch No,Batch Asnjë
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Lejo Sales shumta urdhra kundër Rendit Blerje një konsumatorit
DocType: Student Group Instructor,Student Group Instructor,Grupi Student Instruktor
DocType: Student Group Instructor,Student Group Instructor,Grupi Student Instruktor
DocType: Grant Application,Assessment  Mark (Out of 10),Vlerësimi Mark (Nga 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile No
apps/erpnext/erpnext/setup/doctype/company/company.py +218,Main,Kryesor
apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Variant
DocType: Naming Series,Set prefix for numbering series on your transactions,Prefiksi vendosur për numëron seri mbi transaksionet tuaja
DocType: Employee Attendance Tool,Employees HTML,punonjësit HTML
apps/erpnext/erpnext/stock/doctype/item/item.py +458,Default BOM ({0}) must be active for this item or its template,Gabim BOM ({0}) duhet të jetë aktiv për këtë artikull ose template saj
DocType: Employee,Leave Encashed?,Dërgo arkëtuar?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Opportunity Nga fushë është e detyrueshme
DocType: Email Digest,Annual Expenses,Shpenzimet vjetore
DocType: Item,Variants,Variantet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1149,Make Purchase Order,Bëni Rendit Blerje
DocType: SMS Center,Send To,Send To
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,There is not enough leave balance for Leave Type {0},Nuk ka bilanc mjaft leje për pushim Lloji {0}
DocType: Payment Reconciliation Payment,Allocated amount,Shuma e ndarë
DocType: Sales Team,Contribution to Net Total,Kontributi në Net Total
DocType: Sales Invoice Item,Customer's Item Code,Item Kodi konsumatorit
DocType: Stock Reconciliation,Stock Reconciliation,Stock Pajtimit
DocType: Territory,Territory Name,Territori Emri
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204,Work-in-Progress Warehouse is required before Submit,Puna në progres Magazina është e nevojshme para se të Submit
apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Aplikuesi për një punë.
DocType: Purchase Order Item,Warehouse and Reference,Magazina dhe Referenca
DocType: Supplier,Statutory info and other general information about your Supplier,Info Statutore dhe informacione të tjera të përgjithshme në lidhje me furnizuesit tuaj
DocType: Item,Serial Nos and Batches,Serial Nr dhe Batches
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Grupi Student Forca
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Grupi Student Forca
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261,Against Journal Entry {0} does not have any unmatched {1} entry,Kundër Fletoren Hyrja {0} nuk ka asnjë pashoq {1} hyrje
apps/erpnext/erpnext/config/hr.py +142,Appraisals,vlerësime
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Ngjarje Trajnimi
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Duplicate Serial Asnjë hyrë për Item {0}
apps/erpnext/erpnext/config/selling.py +179,Track Leads by Lead Source.,Rruga kryeson nga burimi kryesor.
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Një kusht për Sundimin Shipping
apps/erpnext/erpnext/hr/doctype/employee/employee.py +168,Please enter ,Ju lutemi shkruani
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Mirëmbajtja e regjistrit
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236,Please set filter based on Item or Warehouse,Ju lutemi të vendosur filtër në bazë të artikullit ose Magazina
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Pesha neto i kësaj pakete. (Llogaritet automatikisht si shumë të peshës neto të artikujve)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +815,Discount amount cannot be greater than 100%,Shuma e zbritjes nuk mund të jetë më e madhe se 100%
DocType: Sales Order,To Deliver and Bill,Për të ofruar dhe Bill
DocType: Student Group,Instructors,instruktorët
DocType: GL Entry,Credit Amount in Account Currency,Shuma e kredisë në llogari në monedhë të
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +604,BOM {0} must be submitted,BOM {0} duhet të dorëzohet
apps/erpnext/erpnext/config/accounts.py +460,Share Management,Menaxhimi i aksioneve
DocType: Authorization Control,Authorization Control,Kontrolli Autorizimi
apps/erpnext/erpnext/controllers/buying_controller.py +333,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Rejected Magazina është e detyrueshme kundër Item refuzuar {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Payment,Pagesa
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}.","Magazina {0} nuk është e lidhur me ndonjë llogari, ju lutemi të përmendim llogari në procesverbal depo apo vendosur llogari inventarit parazgjedhur në kompaninë {1}."
apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Menaxho urdhërat tuaj
DocType: Work Order Operation,Actual Time and Cost,Koha aktuale dhe kostos
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},Kërkesa material i maksimumi {0} mund të jetë bërë për Item {1} kundër Sales Rendit {2}
DocType: Crop,Crop Spacing,Hapësira e prerjes
DocType: Course,Course Abbreviation,Shkurtesa Course
DocType: Student Leave Application,Student Leave Application,Student Leave Aplikimi
DocType: Item,Will also apply for variants,Gjithashtu do të aplikojë për variantet
apps/erpnext/erpnext/assets/doctype/asset/asset.py +217,"Asset cannot be cancelled, as it is already {0}","Asset nuk mund të anulohet, pasi ajo tashmë është {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},I punësuar {0} në gjysmë ditë në {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Orët totale të punës nuk duhet të jetë më e madhe se sa orë pune max {0}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Në
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Artikuj Bundle në kohën e shitjes.
DocType: Material Request Plan Item,Actual Qty,Aktuale Qty
DocType: Sales Invoice Item,References,Referencat
DocType: Quality Inspection Reading,Reading 10,Leximi 10
DocType: Item,Barcodes,barcodes
DocType: Hub Category,Hub Node,Hub Nyja
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Ju keni hyrë artikuj kopjuar. Ju lutemi të ndrequr dhe provoni përsëri.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Koleg
DocType: Asset Movement,Asset Movement,Lëvizja e aseteve
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +550,Work Order {0} must be submitted,Urdhri i punës {0} duhet të dorëzohet
apps/erpnext/erpnext/accounts/page/pos/pos.js +2210,New Cart,Shporta e re
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Item {0} nuk është një Item serialized
DocType: SMS Center,Create Receiver List,Krijo Marresit Lista
DocType: Vehicle,Wheels,rrota
DocType: Packing Slip,To Package No.,Për paketën Nr
DocType: Patient Relation,Family,familje
DocType: Production Plan,Material Requests,Kërkesat materiale
DocType: Warranty Claim,Issue Date,Çështja Data
DocType: Activity Cost,Activity Cost,Kosto Aktiviteti
DocType: Sales Invoice Timesheet,Timesheet Detail,Detail pasqyrë e mungesave
DocType: Purchase Receipt Item Supplied,Consumed Qty,Konsumuar Qty
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekomunikacionit
apps/erpnext/erpnext/accounts/party.py +263,Billing currency must be equal to either default company's currency or party account currency,Monedha e faturimit duhet të jetë e barabartë me monedhën e parave të kompanisë ose monedhën e llogarisë së partisë
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Tregon se paketa është pjesë e këtij ofrimit (Vetëm draft)
DocType: Soil Texture,Loam,tokë pjellore
apps/erpnext/erpnext/controllers/accounts_controller.py +707,Row {0}: Due Date cannot be before posting date,Rreshti {0}: Data e duhur nuk mund të jetë para datës së postimit
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Kryej pagesa Hyrja
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Sasia e artikullit {0} duhet të jetë më pak se {1}
,Sales Invoice Trends,Shitjet Trendet faturave
DocType: Leave Application,Apply / Approve Leaves,Aplikoni / Miratimi Leaves
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Për
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',Mund t&#39;i referohet rresht vetëm nëse tipi është ngarkuar &quot;Për Previous Shuma Row &#39;ose&#39; Previous Row Total&quot;
DocType: Sales Order Item,Delivery Warehouse,Ofrimit Magazina
apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Pema e Qendrave te Kostos financiare.
DocType: Serial No,Delivery Document No,Ofrimit Dokumenti Asnjë
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Ju lutemi të vendosur &#39;Gain llogari / humbje neto nga shitja aseteve&#39; në kompaninë {0}
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Të marrë sendet nga Pranimeve Blerje
DocType: Serial No,Creation Date,Krijimi Data
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Item {0} shfaqet herë të shumta në Çmimi Lista {1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Selling must be checked, if Applicable For is selected as {0}","Shitja duhet të kontrollohet, nëse është e aplikueshme për të është zgjedhur si {0}"
DocType: Production Plan Material Request,Material Request Date,Material Kërkesa Date
DocType: Purchase Order Item,Supplier Quotation Item,Citat Furnizuesi Item
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +181,Material Consumption is not set in Manufacturing Settings.,Konsumi i materialit nuk është vendosur në Cilësimet e Prodhimtaria.
DocType: Student,Student Mobile Number,Student Mobile Number
DocType: Item,Has Variants,Ka Variantet
apps/erpnext/erpnext/controllers/accounts_controller.py +488,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Nuk mund të mbivlerësohet për Item {0} në rresht {1} më shumë se {2}. Për të lejuar mbi-faturimin, ju lutemi vendosni në Settings Stock"
apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Përditësoni përgjigjen
apps/erpnext/erpnext/public/js/utils.js +374,You have already selected items from {0} {1},Ju keni zgjedhur tashmë artikuj nga {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Emri i Shpërndarjes Mujore
apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Grumbull ID është i detyrueshëm
apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Grumbull ID është i detyrueshëm
DocType: Sales Person,Parent Sales Person,Shitjet prind Person
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100,The seller and the buyer cannot be the same,Shitësi dhe blerësi nuk mund të jenë të njëjta
DocType: Project,Collect Progress,Mblidhni progresin
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Zgjidhni programin e parë
DocType: Patient Appointment,Patient Age,Mosha e pacientit
apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Menaxhimi i Projekteve
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +224,Serial no {0} has been already returned,Serial no {0} është kthyer tashmë
DocType: Supplier,Supplier of Goods or Services.,Furnizuesi i mallrave ose shërbimeve.
DocType: Budget,Fiscal Year,Viti Fiskal
DocType: Asset Maintenance Log,Planned,planifikuar
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,Llogaritë e llogarive të arkëtueshme që do të përdoren nëse nuk vendosen në pacient për të rezervuar akuzat e Konsultimit.
DocType: Vehicle Log,Fuel Price,Fuel Price
DocType: Budget,Budget,Buxhet
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65,Set Open,Cakto hapur
apps/erpnext/erpnext/stock/doctype/item/item.py +258,Fixed Asset Item must be a non-stock item.,Fixed Item Aseteve duhet të jetë një element jo-aksioneve.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Buxheti nuk mund të caktohet {0} kundër, pasi kjo nuk është një llogari të ardhura ose shpenzime"
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Arritur
DocType: Student Admission,Application Form Route,Formular Aplikimi Route
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Territori / Customer
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,Dërgo Lloji {0} nuk mund të ndahen pasi ajo është lënë pa paguar
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},Row {0}: Shuma e ndarë {1} duhet të jetë më pak se ose e barabartë me shumën e faturës papaguar {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,Me fjalë do të jetë i dukshëm një herë ju ruani Sales Faturë.
DocType: Lead,Follow Up,Ndiqe
DocType: Item,Is Sales Item,Është Item Sales
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Item Group Tree
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Item {0} nuk është setup për Serial Nr. Kontrolloni mjeshtër Item
DocType: Maintenance Visit,Maintenance Time,Mirëmbajtja Koha
,Amount to Deliver,Shuma për të Ofruar
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335,Same item has been entered multiple times. {0},Artikulli i njëjtë është futur disa herë. {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 Data e fillimit nuk mund të jetë më herët se Year Data e fillimit të vitit akademik në të cilin termi është i lidhur (Viti Akademik {}). Ju lutem, Korrigjo datat dhe provoni përsëri."
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190,There were errors.,Ka pasur gabime.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166,Employee {0} has already applied for {1} between {2} and {3} : ,Punonjësi {0} ka aplikuar për {1} mes {2} dhe {3}:
DocType: Guardian,Guardian Interests,Guardian Interesat
DocType: Naming Series,Current Value,Vlera e tanishme
apps/erpnext/erpnext/controllers/accounts_controller.py +273,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,vite të shumta fiskale ekzistojnë për datën {0}. Ju lutemi të vënë kompaninë në vitin fiskal
DocType: Education Settings,Instructor Records to be created by,Regjistruesi i instruktorit të krijohet nga
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} krijuar
DocType: GST Account,GST Account,Llogari GST
DocType: Delivery Note Item,Against Sales Order,Kundër Sales Rendit
,Serial No Status,Serial Asnjë Statusi
DocType: Payment Entry Reference,Outstanding,i shquar
DocType: Supplier,Warn POs,Paralajmëro në PS
,Daily Timesheet Summary,Daily Përmbledhje pasqyrë e mungesave
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}","Row {0}: Për të vendosur {1} periodiciteti, dallimi në mes të dhe në datën \ duhet të jetë më e madhe se ose e barabartë me {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Kjo është e bazuar në lëvizjen e aksioneve. Shih {0} për detaje
DocType: Pricing Rule,Selling,Shitja
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392,Amount {0} {1} deducted against {2},Shuma {0} {1} zbritur kundër {2}
DocType: Employee,Salary Information,Informacione paga
DocType: Sales Person,Name and Employee ID,Emri dhe punonjës ID
apps/erpnext/erpnext/accounts/party.py +308,Due Date cannot be before Posting Date,Për shkak Data nuk mund të jetë para se të postimi Data
DocType: Website Item Group,Website Item Group,Faqja kryesore Item Grupi
apps/erpnext/erpnext/public/js/hub/hub_listing.js +339,Added to Favourites,Shtuar te Favoritet
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Asnjë pagë pagese nuk është paraqitur për kriteret e përzgjedhura më lartë OSE paga e pagës tashmë e dorëzuar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Detyrat dhe Taksat
DocType: Projects Settings,Projects Settings,Projekte Cilësimet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Ju lutem shkruani datën Reference
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} shënimet e pagesës nuk mund të filtrohen nga {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tabela për çështje që do të shfaqet në Web Site
DocType: Purchase Order Item Supplied,Supplied Qty,Furnizuar Qty
DocType: Purchase Order Item,Material Request Item,Materiali Kërkesë Item
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Pema e sendit grupeve.
DocType: Production Plan,Total Produced Qty,Totali i Prodhimit
DocType: Payroll Entry,Get Employee Details,Merrni Detajet e Punonjësve
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,"Nuk mund t&#39;i referohet numrit rresht më të madhe se, ose të barabartë me numrin e tanishëm rresht për këtë lloj Ngarkesa"
DocType: Asset,Sold,i shitur
,Item-wise Purchase History,Historia Blerje pika-mençur
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Ju lutem klikoni në &quot;Generate&quot; Listën për të shkoj të marr Serial Asnjë shtuar për Item {0}
DocType: Account,Frozen,I ngrirë
DocType: Sales Invoice Payment,Base Amount (Company Currency),Base Shuma (Company Valuta)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928,Raw Materials,"Lende e pare, lende e paperpunuar"
DocType: Payment Reconciliation Payment,Reference Row,Reference Row
DocType: Installation Note,Installation Time,Instalimi Koha
DocType: Sales Invoice,Accounting Details,Detajet Kontabilitet
apps/erpnext/erpnext/setup/doctype/company/company.js +113,Delete all the Transactions for this Company,Fshij gjitha transaksionet për këtë kompani
DocType: Patient,O Positive,O Pozitive
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investimet
DocType: Issue,Resolution Details,Rezoluta Detajet
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,alokimet
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Kriteret e pranimit
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Ju lutemi shkruani Kërkesat materiale në tabelën e mësipërme
DocType: Item Attribute,Attribute Name,Atribut Emri
DocType: BOM,Show In Website,Shfaq Në Website
DocType: Shopping Cart Settings,Show Quantity in Website,Trego sasia në faqen
DocType: Employee Loan Application,Total Payable Amount,Shuma totale e pagueshme
DocType: Task,Expected Time (in hours),Koha pritet (në orë)
DocType: Item Reorder,Check in (group),Kontrolloni në (grupi)
DocType: Soil Texture,Silt,baltë
,Qty to Order,Qty të Rendit
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Kreu Llogaria nën pasiv ose kapital, në të cilën Fitimi / Humbja do të jetë e rezervuar"
apps/erpnext/erpnext/config/projects.py +36,Gantt chart of all tasks.,Grafiku Gantt e të gjitha detyrave.
DocType: Opportunity,Mins to First Response,Minuta për Përgjigje Parë
DocType: Pricing Rule,Margin Type,margin Lloji
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} orë
DocType: Course,Default Grading Scale,Default Nota Scale
DocType: Appraisal,For Employee Name,Për Emri punonjës
DocType: Holiday List,Clear Table,Tabela e qartë
DocType: Woocommerce Settings,Tax Account,Llogaria Tatimore
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119,Available slots,Hapësirat e disponueshme
DocType: C-Form Invoice Detail,Invoice No,Fatura Asnjë
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363,Make Payment,Bëj pagesën
DocType: Room,Room Name,Room Emri
DocType: Prescription Duration,Prescription Duration,Kohëzgjatja e recetës
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Lini nuk mund të zbatohet / anulohet {0} para, si bilanci leja ka qenë tashmë copë dërgohet në regjistrin e ardhshëm alokimit Pushimi {1}"
DocType: Activity Cost,Costing Rate,Kushton Rate
apps/erpnext/erpnext/config/selling.py +234,Customer Addresses And Contacts,Adresat dhe kontaktet Customer
,Campaign Efficiency,Efikasiteti fushatë
,Campaign Efficiency,Efikasiteti fushatë
DocType: Discussion,Discussion,diskutim
DocType: Payment Entry,Transaction ID,ID Transaction
DocType: Volunteer,Anytime,Kurdo
DocType: Patient,Surgical History,Historia kirurgjikale
DocType: Employee,Resignation Letter Date,Dorëheqja Letër Data
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Rregullat e Çmimeve të filtruar më tej në bazë të sasisë.
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127,Not Set,Nuk është caktuar
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Ju lutemi të vendosur datën e bashkuar për të punësuar {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Ju lutemi të vendosur datën e bashkuar për të punësuar {0}
DocType: Task,Total Billing Amount (via Time Sheet),Total Shuma Faturimi (via Koha Sheet)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Përsëriteni ardhurat Klientit
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
DocType: Chapter,Chapter,kapitull
apps/erpnext/erpnext/utilities/user_progress.py +146,Pair,Palë
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Llogaria e parazgjedhur do të përditësohet automatikisht në POS Fatura kur kjo mënyrë të përzgjidhet.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970,Select BOM and Qty for Production,Zgjidhni bom dhe Qty për Prodhimin
DocType: Asset,Depreciation Schedule,Zhvlerësimi Orari
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Adresat Sales partner dhe Kontakte
DocType: Bank Reconciliation Detail,Against Account,Kundër Llogaria
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Half Day Date should be between From Date and To Date,Half Data Day duhet të jetë midis Nga Data dhe deri më sot
DocType: Maintenance Schedule Detail,Actual Date,Aktuale 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.,Vendosni Qendrën e Kostos së Parazgjedhur në {0} kompani.
DocType: Item,Has Batch No,Ka Serisë Asnjë
apps/erpnext/erpnext/public/js/utils.js +106,Annual Billing: {0},Faturimi vjetore: {0}
apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Mallrat dhe Shërbimet Tatimore (GST India)
DocType: Delivery Note,Excise Page Number,Akciza Faqja Numër
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227,"Company, From Date and To Date is mandatory","Kompania, Nga Data dhe deri më sot është e detyrueshme"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Merrni nga Konsultimi
DocType: Asset,Purchase Date,Blerje Date
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +33,Could not generate Secret,Nuk mund të gjenerohej Sekreti
DocType: Volunteer,Volunteer Type,Lloji vullnetar
DocType: Student,Personal Details,Detajet personale
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Ju lutemi të vendosur &#39;të mjeteve Qendra Amortizimi Kosto&#39; në Kompaninë {0}
,Maintenance Schedules,Mirëmbajtja Oraret
DocType: Task,Actual End Date (via Time Sheet),Aktuale End Date (via Koha Sheet)
DocType: Soil Texture,Soil Type,Lloji i dheut
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387,Amount {0} {1} against {2} {3},Shuma {0} {1} kundër {2} {3}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,New Message,Mesazh i ri
,Quotation Trends,Kuotimit Trendet
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160,Item Group not mentioned in item master for item {0},Grupi pika nuk përmendet në pikën për të zotëruar pikën {0}
DocType: GoCardless Mandate,GoCardless Mandate,Mandati i GoCardless
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368,Debit To account must be a Receivable account,Debiti te llogaria duhet të jetë një llogari të arkëtueshme
DocType: Shipping Rule,Shipping Amount,Shuma e anijeve
DocType: Supplier Scorecard Period,Period Score,Vota e periudhës
apps/erpnext/erpnext/utilities/user_progress.py +66,Add Customers,Shto Konsumatorët
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Në pritje Shuma
DocType: Lab Test Template,Special,i veçantë
DocType: Purchase Order Item Supplied,Conversion Factor,Konvertimi Faktori
DocType: Purchase Order,Delivered,Dorëzuar
,Vehicle Expenses,Shpenzimet automjeteve
DocType: Serial No,Invoice Details,detajet e faturës
DocType: Grant Application,Show on Website,Trego në Website
apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,Expected value after useful life must be greater than or equal to {0},Vlera e pritshme pas jetës së dobishme duhet të jetë më e madhe se ose e barabartë me {0}
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Filloni
DocType: Hub Category,Hub Category,Kategoria Hub
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Numri i Automjeteve
DocType: Employee Loan,Loan Amount,Shuma e kredisë
DocType: Student Report Generation Tool,Add Letterhead,Shto me shkronja
DocType: Program Enrollment,Self-Driving Vehicle,Self-Driving automjeteve
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Përputhësi i rezultatit të furnitorit
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Bill e materialeve nuk u gjet për pika {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,Gjithsej gjethet e ndara {0} nuk mund të jetë më pak se gjethet tashmë të miratuara {1} për periudhën
DocType: Journal Entry,Accounts Receivable,Llogaritë e arkëtueshme
,Supplier-Wise Sales Analytics,Furnizuesi-i mençur Sales Analytics
DocType: Purchase Invoice,Availed ITC Central Tax,Availed ITC Tax Qendrore
DocType: Salary Structure,Select employees for current Salary Structure,Zgjidh punonjës për strukturën e tanishme të pagave
DocType: Sales Invoice,Company Address Name,Adresa e Kompanisë Emri
DocType: Work Order,Use Multi-Level BOM,Përdorni Multi-Level bom
DocType: Bank Reconciliation,Include Reconciled Entries,Përfshini gjitha pajtuar
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Kursi Parent (Lini bosh, në qoftë se kjo nuk është pjesë e mëmë natyrisht)"
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Kursi Parent (Lini bosh, në qoftë se kjo nuk është pjesë e mëmë natyrisht)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,Lini bosh nëse konsiderohet për të gjitha llojet e punonjësve
DocType: Landed Cost Voucher,Distribute Charges Based On,Shpërndarjen Akuzat Bazuar Në
DocType: Projects Settings,Timesheets,timesheets
DocType: HR Settings,HR Settings,HR Cilësimet
DocType: Salary Slip,net pay info,info net pay
DocType: Woocommerce Settings,Enable Sync,Aktivizo sinkronizimin
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Kjo vlerë përditësohet në Listën e Çmimeve të Shitjes së Parazgjedhur.
DocType: Email Digest,New Expenses,Shpenzimet e reja
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +101,PDC/LC Amount,Vlera PDC / LC
DocType: Shareholder,Shareholder,aksionari
DocType: Purchase Invoice,Additional Discount Amount,Shtesë Shuma Discount
DocType: Cash Flow Mapper,Position,pozitë
DocType: Patient,Patient Details,Detajet e pacientit
DocType: Patient,B Positive,B Pozitiv
apps/erpnext/erpnext/controllers/accounts_controller.py +596,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Qty duhet të jetë 1, pasi pika është një pasuri fikse. Ju lutem përdorni rresht të veçantë për Qty shumëfishtë."
DocType: Leave Block List Allow,Leave Block List Allow,Dërgo Block Lista Lejoni
apps/erpnext/erpnext/setup/doctype/company/company.py +317,Abbr can not be blank or space,Abbr nuk mund të jetë bosh ose hapësirë
DocType: Patient Medical Record,Patient Medical Record,Regjistrimi mjekësor pacient
apps/erpnext/erpnext/accounts/doctype/account/account.js +62,Group to Non-Group,Grup për jo-Group
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Sportiv
DocType: Loan Type,Loan Name,kredi Emri
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Gjithsej aktuale
DocType: Lab Test UOM,Test UOM,Test UOM
DocType: Student Siblings,Student Siblings,Vëllai dhe motra e studentëve
apps/erpnext/erpnext/utilities/user_progress.py +146,Unit,Njësi
apps/erpnext/erpnext/stock/get_item_details.py +138,Please specify Company,Ju lutem specifikoni Company
,Customer Acquisition and Loyalty,Customer Blerja dhe Besnik
DocType: Asset Maintenance Task,Maintenance Task,Detyra e mirëmbajtjes
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118,Please set B2C Limit in GST Settings.,Vendosni Limit B2C në Cilësimet GST.
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Magazina ku ju jeni mbajtjen e aksioneve të artikujve refuzuar
DocType: Work Order,Skip Material Transfer,Kalo Material Transferimi
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,Në pamundësi për të gjetur kursin e këmbimit për {0} në {1} për datën kyçe {2}. Ju lutem të krijuar një rekord Currency Exchange dorë
DocType: POS Profile,Price List,Tarifë
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} është tani default Viti Fiskal. Ju lutemi të rifreskoni shfletuesin tuaj për ndryshim të hyjnë në fuqi.
apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Kërkesat e shpenzimeve
DocType: Issue,Support,Mbështetje
,BOM Search,Bom Kërko
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Kostoja totale e materialit të konsumuar (nëpërmjet regjistrimit të stoqeve)
DocType: Hub Settings,Company Registered,Regjistri i kompanisë
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publikoni &quot;Në Stock&quot; ose &quot;Not in Stock&quot; në Hub bazuar në stokun në dispozicion në këtë depo.
DocType: Vehicle,Fuel Type,Fuel Lloji
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Ju lutem specifikoni monedhës në Kompaninë
DocType: Workstation,Wages per hour,Rrogat në orë
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},Bilanci aksioneve në Serisë {0} do të bëhet negative {1} për Item {2} në {3} Magazina
apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Pas kërkesave materiale janë ngritur automatikisht bazuar në nivelin e ri të rendit zërit
DocType: Email Digest,Pending Sales Orders,Në pritje Sales urdhëron
apps/erpnext/erpnext/controllers/accounts_controller.py +312,Account {0} is invalid. Account Currency must be {1},Llogari {0} është i pavlefshëm. Llogaria Valuta duhet të jetë {1}
DocType: Employee,Create User Permission,Krijo lejen e përdoruesit
DocType: Healthcare Settings,Remind Before,Kujtoj Para
apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Faktori UOM Konvertimi është e nevojshme në rresht {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Reference Lloji i dokumentit duhet të jetë një nga Sales Rendit, Sales Fatura ose Journal Entry"
DocType: Salary Component,Deduction,Zbritje
DocType: Item,Retain Sample,Mbajeni mostër
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Row {0}: Nga koha dhe në kohë është i detyrueshëm.
DocType: Stock Reconciliation Item,Amount Difference,shuma Diferenca
apps/erpnext/erpnext/stock/get_item_details.py +356,Item Price added for {0} in Price List {1},Item Çmimi shtuar për {0} në çmim Lista {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Ju lutemi shkruani punonjës Id i këtij personi të shitjes
DocType: Territory,Classification of Customers by region,Klasifikimi i Konsumatorëve sipas rajonit
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +78,In Production,Në prodhim
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65,Difference Amount must be zero,Dallimi Shuma duhet të jetë zero
DocType: Project,Gross Margin,Marzhi bruto
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61,Please enter Production Item first,Ju lutemi shkruani Prodhimi pikën e parë
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Llogaritur Banka bilanci Deklarata
DocType: Normal Test Template,Normal Test Template,Modeli i Testimit Normal
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,përdorues me aftësi të kufizuara
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919,Quotation,Citat
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984,Cannot set a received RFQ to No Quote,Nuk mund të caktohet një RFQ e pranuar në asnjë kuotë
DocType: Quotation,QTN-,QTN-
DocType: Salary Slip,Total Deduction,Zbritje Total
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18,Select an account to print in account currency,Zgjidh një llogari për të shtypur në monedhën e llogarisë
,Production Analytics,Analytics prodhimit
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Kjo bazohet në transaksione kundër këtij Pacienti. Shiko detajet më poshtë për detaje
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204,Cost Updated,Kosto Përditësuar
DocType: Patient,Date of Birth,Data e lindjes
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133,Item {0} has already been returned,Item {0} tashmë është kthyer
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Viti Fiskal ** përfaqëson një viti financiar. Të gjitha shënimet e kontabilitetit dhe transaksionet tjera të mëdha janë gjurmuar kundër Vitit Fiskal ** **.
DocType: Opportunity,Customer / Lead Address,Customer / Adresa Lead
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Vendosja e Scorecard Furnizues
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Emri i Planit të Vlerësimit
DocType: Work Order Operation,Work Order Operation,Operacioni i Rendit të Punës
apps/erpnext/erpnext/stock/doctype/item/item.py +233,Warning: Invalid SSL certificate on attachment {0},Warning: certifikatë SSL Invalid në shtojcën {0}
apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Çon ju ndihmojë të merrni të biznesit, shtoni të gjitha kontaktet tuaja dhe më shumë si çon tuaj"
DocType: Work Order Operation,Actual Operation Time,Aktuale Operacioni Koha
DocType: Authorization Rule,Applicable To (User),Për të zbatueshme (User)
DocType: Purchase Taxes and Charges,Deduct,Zbres
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Job Description,Përshkrimi i punës
DocType: Student Applicant,Applied,i aplikuar
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Re-open,Ri-hapur
DocType: Sales Invoice Item,Qty as per Stock UOM,Qty sipas Stock UOM
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Emri Guardian2
DocType: Purchase Invoice,02-Post Sale Discount,02-Shitje zbritje
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Karaktere speciale përveç &quot;-&quot; &quot;.&quot;, &quot;#&quot;, dhe &quot;/&quot; nuk lejohet në emërtimin seri"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Mbani gjurmët e Fushatave Sales. Mbani gjurmët e kryeson, citatet, Sales Rendit etj nga Fushata për të vlerësuar kthimit mbi investimin."
,SO Qty,SO Qty
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91,The field To Shareholder cannot be blank,Fusha Për Aksionarin nuk mund të jetë bosh
DocType: Guardian,Work Address,puna Adresa
DocType: Appraisal,Calculate Total Score,Llogaritur Gjithsej Vota
DocType: Health Insurance,Health Insurance,Sigurim shëndetsor
DocType: Asset Repair,Manufacturing Manager,Prodhim Menaxher
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serial Asnjë {0} është nën garanci upto {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Vlera minimale e lejueshme
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,Përdoruesi {0} tashmë ekziston
apps/erpnext/erpnext/hooks.py +109,Shipments,Dërgesat
DocType: Payment Entry,Total Allocated Amount (Company Currency),Gjithsej shuma e akorduar (Company Valuta)
DocType: Purchase Order Item,To be delivered to customer,Që do të dërgohen për të klientit
DocType: BOM,Scrap Material Cost,Scrap Material Kosto
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +233,Serial No {0} does not belong to any Warehouse,Serial Asnjë {0} nuk i përkasin ndonjë Magazina
DocType: Grant Application,Email Notification Sent,Njoftimi me email u dërgua
DocType: Purchase Invoice,In Words (Company Currency),Me fjalë (Kompania Valuta)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018,"Item Code, warehouse, quantity are required on row","Kodi i artikullit, depoja, sasia kërkohet në radhë"
DocType: Pricing Rule,Supplier,Furnizuesi
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Shfaq Detajet e Pagesës
DocType: Consultation,Consultation Time,Koha e konsultimit
DocType: C-Form,Quarter,Çerek
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Shpenzimet Ndryshme
DocType: Global Defaults,Default Company,Gabim i kompanisë
apps/erpnext/erpnext/controllers/stock_controller.py +227,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Shpenzim apo llogari Diferenca është e detyrueshme për Item {0} si ndikon vlerën e përgjithshme e aksioneve
DocType: Payment Request,PR,PR
DocType: Cheque Print Template,Bank Name,Emri i Bankës
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30,-Above,-Siper
DocType: Employee Loan,Employee Loan Account,Llogaria Loan punonjës
DocType: Leave Application,Total Leave Days,Ditët Totali i pushimeve
DocType: Email Digest,Note: Email will not be sent to disabled users,Shënim: Email nuk do të dërgohet për përdoruesit me aftësi të kufizuara
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Numri i bashkëveprimit
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Numri i bashkëveprimit
apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Cilësimet e variantit të artikullit
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37,Select Company...,Zgjidh kompanisë ...
DocType: Leave Control Panel,Leave blank if considered for all departments,Lini bosh nëse konsiderohet për të gjitha departamentet
apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Llojet e punësimit (, kontratë të përhershme, etj intern)."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,{0} is mandatory for Item {1},{0} është e detyrueshme për Item {1}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"Item {0}: {1} qty produced, ","Produkti {0}: {1} qty prodhuar,"
DocType: Payroll Entry,Fortnightly,dyjavor
DocType: Currency Exchange,From Currency,Nga Valuta
DocType: Vital Signs,Weight (In Kilogram),Pesha (në kilogram)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",kapitujt / emri i kapitullit lënë boshin automatikisht të vendosur pas ruajtjes së kapitullit.
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Please set GST Accounts in GST Settings,Vendosni Llogaritë GST në Cilësimet GST
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31,Type of Business,Lloj i biznesit
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Ju lutem, përzgjidhni Shuma e ndarë, tip fature, si dhe numrin e faturës në atleast një rresht"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Kostoja e blerjes së Re
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35,All tasks for the detected diseases were imported,Të gjitha detyrat për sëmundjet e zbuluara janë importuar
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Rendit Shitjet e nevojshme për Item {0}
DocType: Grant Application,Grant Description,Përshkrimi i Grantit
DocType: Purchase Invoice Item,Rate (Company Currency),Shkalla (Kompania Valuta)
DocType: Student Guardian,Others,Të tjerët
DocType: Payment Entry,Unallocated Amount,Shuma pashpërndarë
apps/erpnext/erpnext/templates/includes/product_page.js +91,Cannot find a matching Item. Please select some other value for {0}.,Nuk mund të gjeni një përputhen Item. Ju lutem zgjidhni një vlerë tjetër {0} për.
DocType: POS Profile,Taxes and Charges,Taksat dhe Tarifat
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Një produkt apo një shërbim që është blerë, shitur apo mbajtur në magazinë."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Nuk ka përditësime më shumë
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,Nuk mund të zgjidhni llojin e ngarkuar si &quot;Për Shuma Previous Row &#39;ose&#39; Në Previous Row Total&quot; për rreshtin e parë
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Kjo mbulon të gjitha tabelat e rezultateve të lidhura me këtë Setup
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Child Item nuk duhet të jetë një Bundle Product. Ju lutemi të heq arikullin &#39;{0}&#39; dhe për të shpëtuar
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Bankar
apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Shto timesheets
DocType: Vehicle Service,Service Item,Shërbimi Item
DocType: Bank Guarantee,Bank Guarantee,garanci bankare
DocType: Bank Guarantee,Bank Guarantee,garanci bankare
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Ju lutem klikoni në &quot;Generate&quot; Listën për të marrë orarin
DocType: Bin,Ordered Quantity,Sasi të Urdhërohet
apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""",p.sh. &quot;Ndërtimi mjetet për ndërtuesit&quot;
DocType: Grading Scale,Grading Scale Intervals,Intervalet Nota Scale
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Fitimi për vitin
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}: Accounting Hyrja për {2} mund të bëhet vetëm në monedhën: {3}
DocType: Fee Schedule,In Process,Në Procesin
DocType: Authorization Rule,Itemwise Discount,Itemwise Discount
apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Pema e llogarive financiare.
DocType: Cash Flow Mapping,Cash Flow Mapping,Mapping Flow Flow
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} kundër Sales Rendit {1}
DocType: Account,Fixed Asset,Aseteve fikse
apps/erpnext/erpnext/config/stock.py +328,Serialized Inventory,Inventar serialized
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,Emailja nuk gjendet në kontaktin e parazgjedhur
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +23,Generate Secret,Gjeni sekret
DocType: Employee Loan,Account Info,Llogaria Info
DocType: Activity Type,Default Billing Rate,Default Faturimi Vlerësoni
DocType: Fees,Include Payment,Përfshi Pagesën
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} grupeve studentore krijuar.
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} grupeve studentore krijuar.
DocType: Sales Invoice,Total Billing Amount,Shuma totale Faturimi
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Programi në Strukturën e Tarifave dhe Grupi Studentor {0} janë të ndryshme.
DocType: Fee Schedule,Receivable Account,Llogaria e arkëtueshme
apps/erpnext/erpnext/controllers/accounts_controller.py +618,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} është tashmë {2}
DocType: Quotation Item,Stock Balance,Stock Bilanci
apps/erpnext/erpnext/config/selling.py +321,Sales Order to Payment,Rendit Shitjet për Pagesa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,CEO
DocType: Purchase Invoice,With Payment of Tax,Me pagesën e tatimit
DocType: Expense Claim Detail,Expense Claim Detail,Shpenzim Kërkesa Detail
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,Tri kopje për furnizuesit
DocType: Land Unit,Is Container,Është kontejner
DocType: Crop Cycle,This will be day 1 of the crop cycle,Kjo do të jetë dita e 1 e ciklit të kulturave
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871,Please select correct account,"Ju lutem, përzgjidhni llogarinë e saktë"
DocType: Purchase Invoice Item,Weight UOM,Pesha UOM
apps/erpnext/erpnext/config/accounts.py +466,List of available Shareholders with folio numbers,Lista e Aksionarëve në dispozicion me numra foli
DocType: Salary Structure Employee,Salary Structure Employee,Struktura Paga e punonjësve
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Trego atributet e variantit
DocType: Student,Blood Group,Grup gjaku
DocType: Course,Course Name,Emri i kursit
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Përdoruesit të cilët mund të miratojë aplikacione të lënë një punonjës të veçantë për
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Zyra Pajisje
DocType: Purchase Invoice Item,Qty,Qty
DocType: Fiscal Year,Companies,Kompanitë
DocType: Supplier Scorecard,Scoring Setup,Vendosja e programit
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronikë
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326,Debit ({0}),Debiti ({0})
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Ngritja materiale Kërkesë kur bursës arrin nivel të ri-rendit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Me kohë të plotë
DocType: Payroll Entry,Employees,punonjësit
DocType: Employee,Contact Details,Detajet Kontakt
DocType: C-Form,Received Date,Data e marra
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Nëse keni krijuar një template standarde në shitje taksave dhe detyrimeve Stampa, përzgjidh njërin dhe klikoni mbi butonin më poshtë."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Shuma Basic (Company Valuta)
DocType: Student,Guardians,Guardians
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13,Payment Confirmation,Konfirmim pagese
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Çmimet nuk do të shfaqet në qoftë Lista Çmimi nuk është vendosur
DocType: Stock Entry,Total Incoming Value,Vlera Totale hyrëse
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To is required,Debi Për të është e nevojshme
apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets ndihmojë për të mbajtur gjurmët e kohës, kostos dhe faturimit për Aktivitetet e kryera nga ekipi juaj"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Blerje Lista e Çmimeve
apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Modelet e variablave të rezultateve të rezultateve të furnizuesit.
DocType: Job Offer Term,Offer Term,Term Oferta
DocType: Asset,Quality Manager,Menaxheri Cilësia
DocType: Job Applicant,Job Opening,Hapja Job
DocType: Payment Reconciliation,Payment Reconciliation,Pajtimi Pagesa
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,"Ju lutem, përzgjidhni emrin incharge personi"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Teknologji
DocType: Hub Settings,Unregister from Hub,Çregjistro nga Hub
apps/erpnext/erpnext/public/js/utils.js +108,Total Unpaid: {0},Total papaguar: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Website Operacioni
DocType: Supplier Scorecard,Supplier Score,Rezultati i Furnizuesit
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +225,Total Invoiced Amt,Gjithsej faturuara Amt
DocType: Supplier,Warn RFQs,Paralajmëroj RFQ-të
DocType: BOM,Conversion Rate,Shkalla e konvertimit
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Product Kërko
DocType: Assessment Plan,To Time,Për Koha
DocType: Authorization Rule,Approving Role (above authorized value),Miratimi Rolit (mbi vlerën e autorizuar)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Kredia për llogari duhet të jetë një llogari e pagueshme
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Ju lutemi zgjidhni Pranimin e Studentit i cili është i detyrueshëm për aplikantin e paguar të studentëve
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355,BOM recursion: {0} cannot be parent or child of {2},BOM recursion: {0} nuk mund të jetë prindi ose fëmija i {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +36,Please select a Price List to publish pricing,Ju lutemi zgjidhni listën e çmimeve për të publikuar çmimet
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Lista e buxhetit
DocType: Work Order Operation,Completed Qty,Kompletuar Qty
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry","Për {0}, vetëm llogaritë e debitit mund të jetë i lidhur kundër një tjetër hyrjes krediti"
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Lista e Çmimeve {0} është me aftësi të kufizuara
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Row {0}: Kompletuar Qty nuk mund të jetë më shumë se {1} për funksionimin {2}
DocType: Manufacturing Settings,Allow Overtime,Lejo jashtë orarit
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serialized Item {0} nuk mund të përditësohet duke përdorur Stock pajtimit, ju lutem, përdorni Stock Hyrja"
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serialized Item {0} nuk mund të përditësohet duke përdorur Stock pajtimit, ju lutem, përdorni Stock Hyrja"
DocType: Training Event Employee,Training Event Employee,Trajnimi Event punonjës
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1189,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Mostrat maksimale - {0} mund të ruhen për Serinë {1} dhe Pikën {2}.
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7,Add Time Slots,Shtoni Vendndodhjet e Kohës
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Numrat Serial nevojshme për Item {1}. Ju keni dhënë {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Shkalla aktuale Vlerësimi
DocType: Training Event,Advance,avancoj
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,për të bërë përsëritje përsëri.
apps/erpnext/erpnext/config/erpnext_integrations.py +13,GoCardless payment gateway settings,Cilësimet e portës së pagesës GoCardless
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Exchange Gain / Humbje
DocType: Opportunity,Lost Reason,Humbur Arsyeja
apps/erpnext/erpnext/controllers/accounts_controller.py +265,Row #{0}: Account {1} does not belong to company {2},Rreshti # {0}: Llogaria {1} nuk i përket kompanisë {2}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},E pamundur për të gjetur DocType {0}
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Adresa e re
DocType: Quality Inspection,Sample Size,Shembull Madhësi
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Ju lutemi shkruani Dokumenti Marrjes
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Të gjitha sendet janë tashmë faturohen
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',Ju lutem specifikoni një të vlefshme &#39;nga rasti Jo&#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,Qendrat e mëtejshme e kostos mund të bëhet në bazë të Grupeve por hyra mund të bëhet kundër jo-grupeve
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Përdoruesit dhe Lejet
DocType: Vehicle Log,VLOG.,Vlog.
DocType: Branch,Branch,Degë
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Përmbushja e përdoruesit
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Printime dhe quajtur
DocType: Company,Total Monthly Sales,Shitjet mujore totale
DocType: Agriculture Analysis Criteria,Weather,mot
DocType: Bin,Actual Quantity,Sasia aktuale
DocType: Shipping Rule,example: Next Day Shipping,shembull: Transporti Dita e ardhshme
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serial Asnjë {0} nuk u gjet
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291,Subscription has been {0},Abonimi ka qenë {0}
DocType: Fee Schedule Program,Fee Schedule Program,Programi i Programit të Tarifave
DocType: Fee Schedule Program,Student Batch,Batch Student
apps/erpnext/erpnext/utilities/activation.py +119,Make Student,bëni Student
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
apps/erpnext/erpnext/projects/doctype/project/project.py +218,You have been invited to collaborate on the project: {0},Ju keni qenë të ftuar për të bashkëpunuar në këtë projekt: {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157,Physician not available on {0},Mjeku nuk është i disponueshëm në {0}
DocType: Leave Block List Date,Block Date,Data bllok
DocType: Crop,Crop,prodhim
DocType: Purchase Receipt,Supplier Delivery Note,Shënimi i dorëzimit të furnitorit
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Apliko tani
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Sasia aktual {0} / pritje Sasia {1}
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Sasia aktual {0} / pritje Sasia {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
DocType: Sales Order,Not Delivered,Jo Dorëzuar
,Bank Clearance Summary,Pastrimi Përmbledhje Banka
apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Krijuar dhe menaxhuar digests ditore, javore dhe mujore email."
DocType: Appraisal Goal,Appraisal Goal,Vlerësimi Qëllimi
apps/erpnext/erpnext/public/js/hub/hub_form.js +420,Suggest Category?,Sugjerojeni kategorinë?
DocType: Stock Reconciliation Item,Current Amount,Shuma e tanishme
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,Ndërtesat
DocType: Fee Schedule,Fee Structure,Struktura Fee
DocType: Timesheet Detail,Costing Amount,Kushton Shuma
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Furnizuesi&gt; Lloji i Furnizuesit
DocType: Student Admission Program,Application Fee,Tarifë aplikimi
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52,Submit Salary Slip,Submit Kuponi pagave
apps/erpnext/erpnext/controllers/selling_controller.py +137,Maxiumm discount for Item {0} is {1}%,Zbritje Maxiumm për Item {0} është {1}%
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Importi në Bulk
DocType: Sales Partner,Address & Contacts,Adresa dhe Kontaktet
DocType: SMS Log,Sender Name,Sender Emri
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriteret e Analizës së Bujqësisë
DocType: POS Profile,[Select],[Zgjidh]
DocType: Vital Signs,Blood Pressure (diastolic),Presioni i gjakut (diastolik)
DocType: SMS Log,Sent To,Dërguar në
DocType: Agriculture Task,Holiday Management,Menaxhimi i Festave
DocType: Payment Request,Make Sales Invoice,Bëni Sales Faturë
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,Programe
apps/erpnext/erpnext/crm/doctype/lead/lead.py +53,Next Contact Date cannot be in the past,Next Kontakt Data nuk mund të jetë në të kaluarën
DocType: Company,For Reference Only.,Vetëm për referencë.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112,Physician {0} not available on {1},Mjeku {0} nuk është i disponueshëm në {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2577,Select Batch No,Zgjidh Batch No
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61,Invalid {0}: {1},Invalid {0}: {1}
,GSTR-1,GSTR-1
DocType: Purchase Invoice,PINV-RET-,PINV-RET-
DocType: Fee Validity,Reference Inv,Referenca Inv
DocType: Sales Invoice Advance,Advance Amount,Advance Shuma
DocType: Manufacturing Settings,Capacity Planning,Planifikimi i kapacitetit
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Rregullimi i rrumbullakosjes (Valuta e kompanisë
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,&#39;Nga Data &quot;është e nevojshme
DocType: Journal Entry,Reference Number,Numri i referencës
DocType: Employee,Employment Details,Detajet e punësimit
DocType: Employee,New Workplace,New Workplace
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +330,Material Consumption,Konsumi material
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Bëje si Mbyllur
apps/erpnext/erpnext/stock/get_item_details.py +127,No Item with Barcode {0},Nuk ka artikull me Barkodi {0}
DocType: Normal Test Items,Require Result Value,Kërkoni vlerën e rezultatit
DocType: Item,Show a slideshow at the top of the page,Tregojnë një Slideshow në krye të faqes
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532,Boms,BOM
apps/erpnext/erpnext/stock/doctype/item/item.py +162,Stores,Dyqane
DocType: Project Type,Projects Manager,Projektet Menaxher
DocType: Serial No,Delivery Time,Koha e dorëzimit
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33,Ageing Based On,Plakjen Bazuar Në
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61,Appointment cancelled,Emërimi u anulua
DocType: Item,End of Life,Fundi i jetës
apps/erpnext/erpnext/demo/setup/setup_data.py +331,Travel,Udhëtim
DocType: Student Report Generation Tool,Include All Assessment Group,Përfshini të gjithë Grupin e Vlerësimit
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,No active or default Salary Structure found for employee {0} for the given dates,Asnjë Struktura aktiv apo Paga parazgjedhur gjetur për punonjës {0} për të dhënë data
DocType: Leave Block List,Allow Users,Lejojnë përdoruesit
DocType: Purchase Order,Customer Mobile No,Customer Mobile Asnjë
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Periodik
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Detajet e modelit të përcaktimit të fluksit monetar
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Track ardhurat veçantë dhe shpenzimet për verticals produkt apo ndarjet.
DocType: Rename Tool,Rename Tool,Rename Tool
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Update Kosto
DocType: Item Reorder,Item Reorder,Item reorder
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +473,Show Salary Slip,Trego Paga Shqip
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849,Transfer Material,Material Transferimi
DocType: Fees,Send Payment Request,Dërgo Kërkesën për Pagesë
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Specifikoni operacionet, koston operative dhe të japë një operacion i veçantë nuk ka për operacionet tuaja."
DocType: Water Analysis,Origin,origjinë
apps/erpnext/erpnext/controllers/status_updater.py +204,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Ky dokument është mbi kufirin nga {0} {1} për pika {4}. A jeni duke bërë një tjetër {3} kundër të njëjtit {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js +1155,Please set recurring after saving,Ju lutemi të vendosur përsëritur pas kursimit
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769,Select change amount account,Llogaria Shuma Zgjidh ndryshim
DocType: Purchase Invoice,Price List Currency,Lista e Çmimeve Valuta
DocType: Naming Series,User must always select,Përdoruesi duhet të zgjidhni gjithmonë
DocType: Stock Settings,Allow Negative Stock,Lejo Negativ Stock
DocType: Installation Note,Installation Note,Instalimi Shënim
DocType: Soil Texture,Clay,Argjila
DocType: Topic,Topic,temë
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45,Cash Flow from Financing,Cash Flow nga Financimi
DocType: Budget Account,Budget Account,Llogaria buxheti
DocType: Quality Inspection,Verified By,Verifikuar nga
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.","Nuk mund të ndryshojë monedhën parazgjedhje kompanisë, sepse ka transaksione ekzistuese. Transaksionet duhet të anulohet për të ndryshuar monedhën default."
DocType: Cash Flow Mapping,Is Income Tax Liability,A është përgjegjësia e tatimit mbi të ardhurat
DocType: Grading Scale Interval,Grade Description,Grade Përshkrimi
DocType: Stock Entry,Purchase Receipt No,Pranimi Blerje Asnjë
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Kaparosje
DocType: Sales Invoice, Shipping Bill Number,Numër i llogarisë së transportit
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Gjurmimi
DocType: Asset Maintenance Log,Actions performed,Veprimet e kryera
DocType: Cash Flow Mapper,Section Leader,Drejtuesi i Seksionit
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Burimi i Fondeve (obligimeve) të papaguara
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +473,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Sasia në rresht {0} ({1}) duhet të jetë e njëjtë me sasinë e prodhuar {2}
DocType: Supplier Scorecard Scoring Standing,Employee,Punonjës
DocType: Asset Repair,Failure Date,Data e dështimit
DocType: Sample Collection,Collected Time,Koha e mbledhur
DocType: Company,Sales Monthly History,Historia mujore e shitjeve
DocType: Asset Maintenance Task,Next Due Date,Data e ardhshme e afatit
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +240,Select Batch,Zgjidh Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} është faturuar plotësisht
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31,Vital Signs,Shenja jete
DocType: Training Event,End Time,Fundi Koha
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Paga Struktura Active {0} gjetur për punonjës {1} për të dhënë datat
DocType: Payment Entry,Payment Deductions or Loss,Zbritjet e pagesës ose Loss
DocType: Soil Analysis,Soil Analysis Criterias,Kriteret e Analizës së Tokës
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Kushtet e kontratës standarde për shitje ose blerje.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +114,Group by Voucher,Grupi nga Bonon
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233,Are you sure you want to cancel this appointment?,Je i sigurt që dëshiron ta anulosh këtë takim?
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Paketa e Çmimeve të Dhomës së Hotelit
apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Sales tubacionit
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Ju lutemi të vendosur llogarinë e paracaktuar në Paga Komponentin {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Kerkohet Në
DocType: Rename Tool,File to Rename,Paraqesë për Rename
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},"Ju lutem, përzgjidhni bom për Item në rresht {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},Llogaria {0} nuk përputhet me Kompaninë {1} në Mode e Llogarisë: {2}
apps/erpnext/erpnext/controllers/buying_controller.py +480,Specified BOM {0} does not exist for Item {1},Specifikuar BOM {0} nuk ekziston për Item {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301,Course: ,Kursi:
DocType: Soil Texture,Sandy Loam,Loam Sandy
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Mirëmbajtja Orari {0} duhet të anulohet para se anulimi këtë Radhit Sales
DocType: POS Profile,Applicable for Users,E aplikueshme për përdoruesit
DocType: Notification Control,Expense Claim Approved,Shpenzim Kërkesa Miratuar
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Work Orders created,Nuk u krijua urdhër pune
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Slip Paga e punonjësit të {0} krijuar tashmë për këtë periudhë
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Farmaceutike
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Kostoja e artikujve të blerë
DocType: Selling Settings,Sales Order Required,Sales Rendit kërkuar
DocType: Purchase Invoice,Credit To,Kredia për
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,Kryeson Active / Konsumatorët
DocType: Employee Education,Post Graduate,Post diplomuar
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Mirëmbajtja Orari Detail
DocType: Supplier Scorecard,Warn for new Purchase Orders,Paralajmëroni për Urdhërat e reja të Blerjes
DocType: Quality Inspection Reading,Reading 9,Leximi 9
DocType: Supplier,Is Frozen,Është ngrira
apps/erpnext/erpnext/stock/utils.py +224,Group node warehouse is not allowed to select for transactions,depo nyje Group nuk është e lejuar për të zgjedhur për transaksionet
DocType: Buying Settings,Buying Settings,Blerja Cilësimet
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM Jo për një artikull përfundoi mirë
DocType: Upload Attendance,Attendance To Date,Pjesëmarrja në datën
DocType: Request for Quotation Supplier,No Quote,Asnjë citim
DocType: Warranty Claim,Raised By,Ngritur nga
DocType: Payment Gateway Account,Payment Account,Llogaria e pagesës
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909,Please specify Company to proceed,Ju lutemi specifikoni kompanisë për të vazhduar
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27,Net Change in Accounts Receivable,Ndryshimi neto në llogarive të arkëtueshme
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Kompensues Off
DocType: Job Offer,Accepted,Pranuar
DocType: Grant Application,Organization,organizatë
DocType: Grant Application,Organization,organizatë
DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
DocType: SG Creation Tool Course,Student Group Name,Emri Group Student
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Shfaq pamje të eksploduar
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Krijimi i Tarifave
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.,Ju lutem sigurohuni që ju me të vërtetë dëshironi të fshini të gjitha transaksionet për këtë kompani. Të dhënat tuaja mjeshtër do të mbetet ashtu siç është. Ky veprim nuk mund të zhbëhet.
apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Rezultatet e kërkimit
DocType: Room,Room Number,Numri Room
apps/erpnext/erpnext/utilities/transaction_base.py +107,Invalid reference {0} {1},Referenca e pavlefshme {0} {1}
DocType: Shipping Rule,Shipping Rule Label,Rregulla Transporti Label
DocType: Journal Entry Account,Payroll Entry,Hyrja në listën e pagave
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75,View Fees Records,Shikoni Regjistrimet e Tarifave
apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Bëni modelin e taksave
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Forumi User
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319,Raw Materials cannot be blank.,Lëndëve të para nuk mund të jetë bosh.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498,"Could not update stock, invoice contains drop shipping item.","Nuk mund të rinovuar aksioneve, fatura përmban anijeve rënie artikull."
DocType: Lab Test Sample,Lab Test Sample,Shembulli i testit të laboratorit
DocType: Item Variant Settings,Allow Rename Attribute Value,Lejo rinumërimin e vlerës së atributeve
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491,Quick Journal Entry,Quick Journal Hyrja
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,Ju nuk mund të ndryshoni normës nëse bom përmendur agianst çdo send
DocType: Restaurant,Invoice Series Prefix,Prefiksi i Serisë së Faturës
DocType: Employee,Previous Work Experience,Përvoja e mëparshme e punës
DocType: Stock Entry,For Quantity,Për Sasia
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Ju lutem shkruani e planifikuar Qty për Item {0} në rresht {1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93,Google Maps integration is not enabled,Integrimi i Google Maps nuk është i aktivizuar
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} nuk është dorëzuar
DocType: Member,Membership Expiry Date,Data e skadimit të anëtarësisë
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131,{0} must be negative in return document,{0} duhet të jetë negative në dokumentin e kthimit
,Minutes to First Response for Issues,Minuta për Përgjigje e parë për Çështje
DocType: Purchase Invoice,Terms and Conditions1,Termat dhe Conditions1
apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,Emri i institutit për të cilat ju jeni të vendosur deri këtë sistem.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Rregjistrimi kontabël ngrirë deri në këtë datë, askush nuk mund të bëjë / modifikoj hyrjen përveç rolit të specifikuar më poshtë."
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Ju lutemi ruani dokumentin para se të gjeneruar orar të mirëmbajtjes
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Çmimi i fundit i përditësuar në të gjitha BOM
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Statusi i Projektit
DocType: UOM,Check this to disallow fractions. (for Nos),Kontrolloni këtë për të moslejuar fraksionet. (Për Nos)
DocType: Student Admission Program,Naming Series (for Student Applicant),Emërtimi Series (për Student Aplikantit)
DocType: Delivery Note,Transporter Name,Transporter Emri
DocType: Authorization Rule,Authorized Value,Vlera e autorizuar
DocType: BOM,Show Operations,Shfaq Operacionet
,Minutes to First Response for Opportunity,Minuta për Përgjigje e parë për Opportunity
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Gjithsej Mungon
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +995,Item or Warehouse for row {0} does not match Material Request,Item ose Magazina për rresht {0} nuk përputhet Materiale Kërkesë
apps/erpnext/erpnext/config/stock.py +195,Unit of Measure,Njësia e Masës
DocType: Fiscal Year,Year End Date,Viti End Date
DocType: Task Depends On,Task Depends On,Detyra varet
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026,Opportunity,Mundësi
DocType: Operation,Default Workstation,Gabim Workstation
DocType: Notification Control,Expense Claim Approved Message,Shpenzim Kërkesa Miratuar mesazh
DocType: Payment Entry,Deductions or Loss,Zbritjet apo Humbje
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} është i mbyllur
DocType: Email Digest,How frequently?,Sa shpesh?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55,Total Collected: {0},Totali i mbledhur: {0}
DocType: Purchase Receipt,Get Current Stock,Get Stock aktual
DocType: Purchase Invoice,ineligible,i papërshtatshëm
apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Pema e Bill e materialeve
DocType: Student,Joining Date,Bashkimi me Date
,Employees working on a holiday,Punonjës që punojnë në një festë
DocType: Share Balance,Current State,Gjendja e tanishme
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark pranishëm
DocType: Share Transfer,From Shareholder,Nga Aksionari
DocType: Project,% Complete Method,% Complete Metoda
apps/erpnext/erpnext/healthcare/setup.py +181,Drug,drogë
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Data e fillimit të mirëmbajtjes nuk mund të jetë para datës së dorëzimit për Serial Nr {0}
DocType: Work Order,Actual End Date,Aktuale End Date
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Është Rregullimi i Kostos Financiare
DocType: BOM,Operating Cost (Company Currency),Kosto Operative (Company Valuta)
DocType: Purchase Invoice,PINV-,PINV-
DocType: Authorization Rule,Applicable To (Role),Për të zbatueshme (Roli)
DocType: BOM Update Tool,Replace BOM,Replace BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kodi {0} tashmë ekziston
DocType: Employee Advance,Purpose,Qëllim
DocType: Company,Fixed Asset Depreciation Settings,Fixed Asset Settings zhvlerësimit
DocType: Item,Will also apply for variants unless overrridden,Gjithashtu do të aplikojë për variantet nëse overrridden
DocType: Purchase Invoice,Advances,Përparimet
DocType: Work Order,Manufacture against Material Request,Prodhimi kundër kërkesës materiale
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Assessment Group: ,Grupi i Vlerësimit:
DocType: Item Reorder,Request for,Kërkesë për
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Miratimi përdoruesin nuk mund të jetë i njëjtë si përdorues rregulli është i zbatueshëm për
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Norma bazë (sipas Stock UOM)
DocType: SMS Log,No of Requested SMS,Nr i SMS kërkuar
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246,Leave Without Pay does not match with approved Leave Application records,Dërgo Pa Paguhet nuk përputhet me të dhënat Leave Aplikimi miratuara
DocType: Campaign,Campaign-.####,Fushata -. ####
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Hapat e ardhshëm
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796,Please supply the specified items at the best possible rates,Ju lutemi të furnizimit me artikuj të specifikuara në normat më të mirë të mundshme
DocType: Membership,USD,USD
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Bëni Faturë
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +102,Remaining Balance,Bilanci i mbetur
DocType: Selling Settings,Auto close Opportunity after 15 days,Auto Opportunity afër pas 15 ditësh
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}.,Urdhërat e blerjes nuk janë të lejuara për {0} për shkak të një pozicioni të rezultateve të {1}.
apps/erpnext/erpnext/stock/doctype/item/item.py +498,Barcode {0} is not a valid {1} code,Barkodi {0} nuk është një kod valid {1}
apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,Fundi Viti
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot /% Lead
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot /% Lead
apps/erpnext/erpnext/hr/doctype/employee/employee.py +125,Contract End Date must be greater than Date of Joining,Kontrata Data e përfundimit duhet të jetë më i madh se data e bashkimit
DocType: Driver,Driver,shofer
DocType: Vital Signs,Nutrition Values,Vlerat e të ushqyerit
DocType: Lab Test Template,Is billable,Është e pagueshme
DocType: Delivery Note,DN-,DN-
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Një shpërndarës i palës së tretë / tregtari / komision agjent / degë / reseller që shet produkte kompani për një komision.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} kundër Rendit Blerje {1}
DocType: Patient,Patient Demographics,Demografia e pacientëve
DocType: Task,Actual Start Date (via Time Sheet),Aktuale Start Date (via Koha Sheet)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Kjo është një website shembull auto-generated nga ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43,Ageing Range 1,Gama plakjen 1
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212,Total advance amount cannot be greater than total claimed amount,Shuma totale e paradhënies nuk mund të jetë më e madhe se shuma totale e kërkuar
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.","Template Standard taksave që mund të aplikohet për të gjitha transaksionet e blerjes. Kjo template mund të përmbajë listë të krerëve të taksave si dhe kokat e tjera të shpenzimeve, si &quot;tregtar&quot;, &quot;Sigurimi&quot;, &quot;Trajtimi&quot; etj #### Shënim norma e tatimit që ju të përcaktuar këtu do të jetë norma standarde e taksave për të gjitha ** Items * *. Nëse ka Items ** ** që kanë norma të ndryshme, ato duhet të shtohet në ** Item Tatimit ** Tabela në ** Item ** zotit. #### Përshkrimi i Shtyllave 1. Llogaritja Type: - Kjo mund të jetë në ** neto totale ** (që është shuma e shumës bazë). - ** Në rreshtit të mëparshëm totalit / Shuma ** (për taksat ose tarifat kumulative). Në qoftë se ju zgjidhni këtë opsion, tatimi do të aplikohet si një përqindje e rreshtit të mëparshëm (në tabelën e taksave) shumën apo total. - ** ** Aktuale (siç u përmend). 2. Llogaria Udhëheqës: Libri Llogaria nën të cilat kjo taksë do të jetë e rezervuar 3. Qendra Kosto: Nëse tatimi i / Akuza është një ardhura (si anijet) ose shpenzime ajo duhet të jetë e rezervuar ndaj Qendrës kosto. 4. Përshkrimi: Përshkrimi i tatimit (që do të shtypen në faturat / thonjëza). 5. Rate: Shkalla tatimore. 6. Shuma: Shuma Tatimore. 7. Gjithsej: totale kumulative në këtë pikë. 8. Shkruani Row: Nëse në bazë të &quot;rreshtit të mëparshëm Total&quot; ju mund të zgjidhni numrin e rreshtit të cilat do të merren si bazë për këtë llogaritje (default është rreshtit të mëparshëm). 9. Konsideroni tatim apo detyrim per: Në këtë seksion ju mund të specifikoni nëse taksa / çmimi është vetëm për vlerësimin (jo një pjesë e totalit) apo vetëm për totalin (nuk shtojnë vlerën e sendit), ose për të dyja. 10. Add ose Zbres: Nëse ju dëshironi të shtoni ose të zbres tatimin."
DocType: Homepage,Homepage,Faqe Hyrëse
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68,Select Physician...,Zgjidh mjekun ...
apps/erpnext/erpnext/public/js/hub/hub_listing.js +606,Back to Products,Kthehu tek Produktet
DocType: Grant Application,Grant Application Details ,Detajet e Aplikimit të Grantit
DocType: Stock Entry Detail,Original Item,Origjinal
DocType: Purchase Receipt Item,Recd Quantity,Recd Sasia
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Records tarifë Krijuar - {0}
DocType: Asset Category Account,Asset Category Account,Asset Kategoria Llogaria
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,Row #{0} (Payment Table): Amount must be positive,Rreshti # {0} (Tabela e Pagesës): Shuma duhet të jetë pozitive
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteNum,CompteNum
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Nuk mund të prodhojë më shumë Item {0} se sasia Sales Rendit {1}
apps/erpnext/erpnext/stock/doctype/item/item.js +391,Select Attribute Values,Zgjidhni vlerat e atributeve
DocType: Purchase Invoice,Reason For Issuing document,Arsyeja për lëshimin e dokumentit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Stock Hyrja {0} nuk është dorëzuar
DocType: Payment Reconciliation,Bank / Cash Account,Llogarisë Bankare / Cash
apps/erpnext/erpnext/crm/doctype/lead/lead.py +47,Next Contact By cannot be same as the Lead Email Address,Next kontaktoni me nuk mund të jetë i njëjtë si adresë Lead Email
DocType: Tax Rule,Billing City,Faturimi i qytetit
DocType: Asset,Manual,udhëzues
DocType: Salary Component Account,Salary Component Account,Llogaria Paga Komponenti
DocType: Global Defaults,Hide Currency Symbol,Fshih Valuta size
apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informacioni i donatorëve.
apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","psh Banka, Cash, Credit Card"
DocType: Lead Source,Source Name,burimi Emri
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Tensioni normal i pushimit të gjakut në një të rritur është afërsisht 120 mmHg systolic, dhe 80 mmHg diastolic, shkurtuar &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","Vendosni artikujt e afatit të ruajtjes në ditë, për të vendosur skadimin e bazuar në data e prodhimit dhe vetë jetës"
DocType: Journal Entry,Credit Note,Credit Shënim
DocType: Projects Settings,Ignore Employee Time Overlap,Ignore kohëzgjatja e punonjësve
DocType: Warranty Claim,Service Address,Shërbimi Adresa
DocType: Asset Maintenance Task,Calibration,kalibrim
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97,{0} is a company holiday,{0} është një festë e kompanisë
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Furnitures dhe Regjistrimet
DocType: Item,Manufacture,Prodhim
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Company,Kompani e konfigurimit
,Lab Test Report,Raporti i testimit të laboratorit
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Ju lutem dorëzimit Shënim parë
DocType: Student Applicant,Application Date,Application Data
DocType: Salary Detail,Amount based on formula,Shuma e bazuar në formulën
DocType: Purchase Invoice,Currency and Price List,Valuta dhe Lista e Çmimeve
DocType: Opportunity,Customer / Lead Name,Customer / Emri Lead
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115,Clearance Date not mentioned,Pastrimi Data nuk përmendet
apps/erpnext/erpnext/config/manufacturing.py +7,Production,Prodhim
DocType: Guardian,Occupation,profesion
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Row {0}: Filloni Data duhet të jetë përpara End Date
DocType: Crop,Planting Area,Sipërfaqja e mbjelljes
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Gjithsej (Qty)
DocType: Installation Note Item,Installed Qty,Instaluar Qty
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Kjo mund të jetë për shkak të disa adresave të pavlefshme të
apps/erpnext/erpnext/utilities/user_progress.py +31,You added ,Ju shtuar
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,Rezultati Training
DocType: Purchase Invoice,Is Paid,është Paid
DocType: Salary Structure,Total Earning,Fituar Total
DocType: Purchase Receipt,Time at which materials were received,Koha në të cilën janë pranuar materialet e
DocType: Products Settings,Products per Page,Produktet per
DocType: Stock Ledger Entry,Outgoing Rate,Largohet Rate
apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Mjeshtër degë organizatë.
apps/erpnext/erpnext/controllers/accounts_controller.py +313, or ,ose
DocType: Sales Order,Billing Status,Faturimi Statusi
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Raportoni një çështje
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Shpenzimet komunale
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Mbi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Ditari Hyrja {1} nuk ka llogari {2} ose tashmë krahasohen kundër një kupon
DocType: Supplier Scorecard Criteria,Criteria Weight,Pesha e kritereve
DocType: Buying Settings,Default Buying Price List,E albumit Lista Blerja Çmimi
DocType: Payroll Entry,Salary Slip Based on Timesheet,Slip Paga Bazuar në pasqyrë e mungesave
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43,Buying Rate,Shkalla e Blerjes
DocType: Notification Control,Sales Order Message,Sales Rendit Mesazh
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Set Vlerat Default si Company, Valuta, vitin aktual fiskal, etj"
DocType: Payment Entry,Payment Type,Lloji Pagesa
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,"Ju lutem, përzgjidhni një grumbull për pika {0}. Në pamundësi për të gjetur një grumbull të vetme që përmbush këtë kërkesë"
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,"Ju lutem, përzgjidhni një grumbull për pika {0}. Në pamundësi për të gjetur një grumbull të vetme që përmbush këtë kërkesë"
DocType: Hub Category,Parent Category,Kategoria e prindërve
DocType: Payroll Entry,Select Employees,Zgjidhni Punonjësit
DocType: Opportunity,Potential Sales Deal,Shitjet e mundshme marrëveshjen
DocType: Complaint,Complaints,Ankese
DocType: Payment Entry,Cheque/Reference Date,Çek / Reference Data
DocType: Purchase Invoice,Total Taxes and Charges,Totali Taksat dhe Tarifat
DocType: Employee,Emergency Contact,Urgjencës Kontaktoni
DocType: Bank Reconciliation Detail,Payment Entry,pagesa Hyrja
,sales-browser,Shitjet-browser
apps/erpnext/erpnext/accounts/doctype/account/account.js +73,Ledger,Libër i llogarive
DocType: Patient Medical Record,PMR-,PMR-
DocType: Drug Prescription,Drug Code,Kodi i drogës
DocType: Target Detail,Target  Amount,Target Shuma
DocType: POS Profile,Print Format for Online,Formati i Printimit për Online
DocType: Shopping Cart Settings,Shopping Cart Settings,Cilësimet Shporta
DocType: Journal Entry,Accounting Entries,Entries Kontabilitetit
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.","Nëse Rregullimi i Përcaktuar i Çmimeve është bërë për &#39;Rate&#39;, ajo do të mbishkruajë Listën e Çmimeve. Norma e çmimeve të tarifës është norma përfundimtare, kështu që nuk duhet të aplikohet ulje e mëtejshme. Prandaj, në transaksione si Sales Order, Order Purchase etc, do të kërkohet në fushën &#39;Rate&#39;, në vend të &#39;Rate Rate Rate&#39; fushë."
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicate Hyrja. Ju lutem kontrolloni Autorizimi Rregulla {0}
DocType: Journal Entry Account,Reference Due Date,Data e duhur e referimit
DocType: Purchase Order,Ref SQ,Ref SQ
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Dokumenti Pranimi duhet të dorëzohet
DocType: Purchase Invoice Item,Received Qty,Marrë Qty
DocType: Stock Entry Detail,Serial No / Batch,Serial No / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Nuk është paguar dhe nuk dorëzohet
DocType: Product Bundle,Parent Item,Item prind
DocType: Account,Account Type,Lloji i Llogarisë
DocType: Delivery Note,DN-RET-,DN-RET-
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Nuk ka fletë kohë
DocType: GoCardless Mandate,GoCardless Customer,Klientë GoCardless
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,"Dërgo Type {0} nuk mund të kryejë, përcillet"
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',Mirëmbajtja Orari nuk është krijuar për të gjitha sendet. Ju lutem klikoni në &quot;Generate Listën &#39;
,To Produce,Për të prodhuar
apps/erpnext/erpnext/config/hr.py +93,Payroll,Payroll
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","Për rresht {0} në {1}. Të përfshijnë {2} në shkallën Item, {3} duhet të përfshihen edhe rreshtave"
DocType: Patient Service Unit,Parent Service Unit,Njësia e Shërbimit të Prindërve
apps/erpnext/erpnext/utilities/activation.py +101,Make User,bëni përdoruesin
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikimi i paketës për shpërndarjen (për shtyp)
DocType: Bin,Reserved Quantity,Sasia e rezervuara
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Ju lutemi shkruani adresën vlefshme email
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Ju lutemi shkruani adresën vlefshme email
DocType: Volunteer Skill,Volunteer Skill,Aftësi vullnetare
DocType: Bank Reconciliation,Include POS Transactions,Përfshi transaksione POS
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +797,Please select an item in the cart,Ju lutemi zgjidhni një artikull në karrocë
DocType: Landed Cost Voucher,Purchase Receipt Items,Items Receipt Blerje
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Format customizing
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,arrear
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Zhvlerësimi Shuma gjatë periudhës
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,template me aftësi të kufizuara nuk duhet të jetë template parazgjedhur
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314,For row {0}: Enter planned qty,Për rresht {0}: Shkruani Qty planifikuar
DocType: Shareholder,SH-,sh-
DocType: Account,Income Account,Llogaria ardhurat
DocType: Payment Request,Amount in customer's currency,Shuma në monedhë të klientit
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825,Delivery,Ofrimit të
DocType: Volunteer,Weekdays,gjatë ditëve të javës
DocType: Stock Reconciliation Item,Current Qty,Qty tanishme
DocType: Restaurant Menu,Restaurant Menu,Menuja e Restorantit
apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,prev
DocType: Appraisal Goal,Key Responsibility Area,Key Zona Përgjegjësia
apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Mallrat e studentëve të ju ndihmojë të gjetur frekuentimit, vlerësimet dhe tarifat për studentët"
DocType: Payment Entry,Total Allocated Amount,Shuma totale e alokuar
apps/erpnext/erpnext/setup/doctype/company/company.py +151,Set default inventory account for perpetual inventory,Bëje llogari inventarit parazgjedhur për inventarit të përhershëm
DocType: Item Reorder,Material Request Type,Material Type Kërkesë
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Dërgo Grant Rishikimi Email
apps/erpnext/erpnext/accounts/page/pos/pos.js +848,"LocalStorage is full, did not save","LocalStorage është e plotë, nuk ka shpëtuar"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM Konvertimi Faktori është i detyrueshëm
apps/erpnext/erpnext/utilities/user_progress.py +235,Room Capacity,Kapaciteti i dhomës
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +28,Already record exists for the item {0},Tashmë ekziston regjistri për artikullin {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +28,Ref,Ref
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Taksa e regjistrimit
DocType: Budget,Cost Center,Qendra Kosto
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +46,Voucher #,Kupon #
DocType: Notification Control,Purchase Order Message,Rendit Blerje mesazh
DocType: Tax Rule,Shipping Country,Shipping Vendi
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Fshih Id Tatimore e konsumatorit nga transaksionet e shitjeve
DocType: Upload Attendance,Upload HTML,Ngarko HTML
DocType: Employee,Relieving Date,Lehtësimin 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.","Rregulla e Çmimeve është bërë për të prishësh LISTA E ÇMIMEVE / definojnë përqindje zbritje, në bazë të disa kritereve."
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Magazina mund të ndryshohet vetëm përmes Stock Hyrja / dorëzimit Shënim / Pranimi Blerje
DocType: Employee Education,Class / Percentage,Klasa / Përqindja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Shef i Marketingut dhe Shitjes
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Tatimi mbi të ardhurat
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Track kryeson nga Industrisë Type.
apps/erpnext/erpnext/utilities/user_progress.py +101,Go to Letterheads,Shkoni te Letrat me Letër
DocType: Item Supplier,Item Supplier,Item Furnizuesi
apps/erpnext/erpnext/public/js/controllers/transaction.js +1256,Please enter Item Code to get batch no,Ju lutemi shkruani Kodin artikull për të marrë grumbull asnjë
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880,Please select a value for {0} quotation_to {1},"Ju lutem, përzgjidhni një vlerë për {0} quotation_to {1}"
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419,No Items selected for transfer,Asnjë artikull i përzgjedhur për transferim
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Të gjitha adresat.
DocType: Company,Stock Settings,Stock Cilësimet
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","Shkrirja është e mundur vetëm nëse prona e mëposhtme janë të njëjta në të dy regjistrat. Është Grupi, Root Type, Kompania"
DocType: Vehicle,Electric,elektrik
DocType: Task,% Progress,% Progress
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Gain / Humbja në hedhjen e Aseteve
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +21,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Në tabelën e mëposhtme do të përzgjidhen vetëm Aplikuesi i Studentit me statusin &quot;Miratuar&quot;.
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.,Numri i llogarisë për llogarinë {0} nuk është në dispozicion. <br> Ju lutemi konfiguroni saktë skedën e llogarive tuaja.
DocType: Task,Depends on Tasks,Varet Detyrat
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Manage grup të konsumatorëve Tree.
DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Attachments mund të tregohet pa mundësuar karrocat
DocType: Normal Test Items,Result Value,Rezultati Vlera
DocType: Hotel Room,Hotels,Hotels
DocType: Supplier Quotation,SQTN-,SQTN-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Qendra Kosto New Emri
DocType: Leave Control Panel,Leave Control Panel,Lini Control Panel
DocType: Project,Task Completion,Task Përfundimi
apps/erpnext/erpnext/templates/includes/product_page.js +22,Not in Stock,Jo në magazinë
DocType: Volunteer,Volunteer Skills,Aftësitë vullnetare
DocType: Appraisal,HR User,HR User
DocType: Purchase Invoice,Taxes and Charges Deducted,Taksat dhe Tarifat zbritet
apps/erpnext/erpnext/hooks.py +142,Issues,Çështjet
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Statusi duhet të jetë një nga {0}
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Kujtesë për të rifreskuar dërgimin e GSTIN
DocType: Sales Invoice,Debit To,Debi Për
DocType: Restaurant Menu Item,Restaurant Menu Item,Menyja e Restorantit
DocType: Delivery Note,Required only for sample item.,Kërkohet vetëm për pika të mostrës.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Qty aktual Pas Transaksionit
,Pending SO Items For Purchase Request,Në pritje SO artikuj për Kërkesë Blerje
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Pranimet e studentëve
apps/erpnext/erpnext/accounts/party.py +388,{0} {1} is disabled,{0} {1} është me aftësi të kufizuara
DocType: Supplier,Billing Currency,Faturimi Valuta
DocType: Sales Invoice,SINV-RET-,SINV-RET-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Shumë i madh
DocType: Crop,Scientific Name,Emer shkencor
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,gjithsej Leaves
DocType: Customer,"Reselect, if the chosen contact is edited after save","Reselect, nëse kontakti i zgjedhur është redaktuar pas ruajtjes"
DocType: Consultation,In print,Ne printim
,Profit and Loss Statement,Fitimi dhe Humbja Deklarata
DocType: Bank Reconciliation Detail,Cheque Number,Numri çek
,Sales Browser,Shitjet Browser
DocType: Journal Entry,Total Credit,Gjithsej Credit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Warning: Një tjetër {0} # {1} ekziston kundër hyrjes aksioneve {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Lokal
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Kreditë dhe paradhëniet (aktiveve)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Debitorët
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,I madh
DocType: Homepage Featured Product,Homepage Featured Product,Homepage Featured Product
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248,All Assessment Groups,Të gjitha grupet e vlerësimit
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,New Magazina Emri
apps/erpnext/erpnext/accounts/report/financial_statements.py +259,Total {0} ({1}),Total {0} ({1})
DocType: C-Form Invoice Detail,Territory,Territor
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Ju lutemi përmendni i vizitave të kërkuara
DocType: Stock Settings,Default Valuation Method,Gabim Vlerësimi Metoda
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,tarifë
apps/erpnext/erpnext/setup/doctype/company/company.js +154,Update in progress. It might take a while.,Përditësohet në progres. Mund të duhet një kohë.
DocType: Production Plan Item,Produced Qty,Prodhuar Qty
DocType: Vehicle Log,Fuel Qty,Fuel Qty
DocType: Stock Entry,Target Warehouse Name,Emri i magazinës së synuar
DocType: Work Order Operation,Planned Start Time,Planifikuar Koha e fillimit
DocType: Course,Assessment,vlerësim
DocType: Payment Entry Reference,Allocated,Ndarë
apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Mbylle Bilanci dhe Fitimi libër ose humbja.
DocType: Student Applicant,Application Status,aplikimi Status
DocType: Sensitivity Test Items,Sensitivity Test Items,Artikujt e testimit të ndjeshmërisë
DocType: Project Update,Project Update,Përditësimi i projektit
DocType: Fees,Fees,tarifat
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Specifikoni Exchange Rate për të kthyer një monedhë në një tjetër
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Citat {0} është anuluar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +126,Total Outstanding Amount,Shuma totale Outstanding
DocType: Sales Partner,Targets,Synimet
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,Regjistro numrin e SIREN në dosjen e informacionit të kompanisë
DocType: Price List,Price List Master,Lista e Çmimeve Master
DocType: GST Account,CESS Account,Llogaria CESS
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Gjitha Shitjet Transaksionet mund të tagged kundër shumta ** Personat Sales ** në mënyrë që ju mund të vendosni dhe monitoruar objektivat.
,S.O. No.,SO Nr
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Ju lutem të krijuar Customer nga Lead {0}
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Zgjidh Patient
DocType: Price List,Applicable for Countries,Të zbatueshme për vendet
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Emri i parametrit
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Student Group Emri është i detyrueshëm në rresht {0}
DocType: Homepage,Products to be shown on website homepage,Produktet që do të shfaqet në faqen e internetit
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Ky është një grup të konsumatorëve rrënjë dhe nuk mund të redaktohen.
DocType: Student,AB-,barkut
DocType: POS Profile,Ignore Pricing Rule,Ignore Rregulla e Çmimeve
DocType: Employee Education,Graduate,I diplomuar
DocType: Leave Block List,Block Days,Ditët Blloku
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Adresa e transportit nuk ka vend, i cili kërkohet për këtë Rregull të Transportit"
DocType: Journal Entry,Excise Entry,Akciza Hyrja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Kujdes: Sales Order {0} ekziston kundër Rendit Blerje Klientit {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.","Termave dhe Kushteve Standarde që mund të shtohet për shitjet dhe blerjet. Shembuj: 1. Vlefshmëria e ofertës. 1. Kushtet e pagesës (më parë, me kredi, paradhënie pjesë etj). 1. Çfarë është shtesë (ose që duhet paguar nga konsumatori). 1. Siguria / përdorimin paralajmërim. 1. Garanci nëse ka ndonjë. 1. Kthim Politikën. 1. Kushtet e anijeve, nëse zbatohen. 1. Mënyrat e adresimit të kontesteve, dëmshpërblim, përgjegjësi, etj 1. Adresa e Kontaktit e kompanisë tuaj."
DocType: Issue,Issue Type,Lloji i emetimit
DocType: Attendance,Leave Type,Lini Type
DocType: Purchase Invoice,Supplier Invoice Details,Furnizuesi Fatura Detajet
DocType: Agriculture Task,Ignore holidays,Injoroni pushimet
apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Llogari shpenzim / Diferenca ({0}) duhet të jetë një llogari &quot;fitimit ose humbjes &#39;
DocType: Project,Copied From,kopjuar nga
DocType: Project,Copied From,kopjuar nga
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340,Invoice already created for all billing hours,Fatura tashmë është krijuar për të gjitha orët e faturimit
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Emri error: {0}
DocType: Cash Flow Mapping,Is Finance Cost,Është kostoja e financimit
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Pjesëmarrja për punonjës {0} është shënuar tashmë
DocType: Packing Slip,If more than one package of the same type (for print),Nëse më shumë se një paketë të të njëjtit lloj (për shtyp)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Vendosni klientin e parazgjedhur në Cilësimet e Restorantit
,Salary Register,Paga Regjistrohu
DocType: Warehouse,Parent Warehouse,Magazina Parent
DocType: C-Form Invoice Detail,Net Total,Net Total
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +570,Default BOM not found for Item {0} and Project {1},Default BOM nuk u gjet për Item {0} dhe Project {1}
apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Përcaktojnë lloje të ndryshme të kredive
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Shuma Outstanding
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Koha (në minuta)
DocType: Project Task,Working,Punës
DocType: Stock Ledger Entry,Stock Queue (FIFO),Stock Radhë (FIFO)
apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Viti financiar
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} nuk i përkasin kompanisë {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.,Nuk mund të zgjidhet funksioni i rezultateve të kritereve për {0}. Sigurohuni që formula është e vlefshme.
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Të kushtojë sa më
DocType: Healthcare Settings,Out Patient Settings,Nga cilësimet e pacientit
DocType: Account,Round Off,Rrumbullohem
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +263,Quantity must be positive,Sasia duhet të jetë pozitive
DocType: Material Request Plan Item,Requested Qty,Kërkohet Qty
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96,The fields From Shareholder and To Shareholder cannot be blank,Fushat nga Aksionari dhe Aksionari nuk mund të jenë të zbrazëta
DocType: Tax Rule,Use for Shopping Cart,Përdorni për Shopping Cart
apps/erpnext/erpnext/controllers/item_variant.py +101,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Vlera {0} për atribut {1} nuk ekziston në listën e artikullit vlefshme atribut Vlerat për Item {2}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Zgjidh numrat serik
DocType: BOM Item,Scrap %,Scrap%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Akuzat do të shpërndahen në mënyrë proporcionale në bazë të Qty pika ose sasi, si për zgjedhjen tuaj"
DocType: Maintenance Visit,Purposes,Qëllimet
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112,Atleast one item should be entered with negative quantity in return document,Atleast një artikull duhet të lidhet me sasinë negativ në dokumentin e kthimit
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","Operacioni {0} gjatë se çdo orë në dispozicion të punës në workstation {1}, prishen operacionin në operacione të shumta"
DocType: Membership,Membership Status,Statusi i Anëtarësimit
,Requested,Kërkuar
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Asnjë Vërejtje
DocType: Asset,In Maintenance,Në Mirëmbajtje
DocType: Purchase Invoice,Overdue,I vonuar
DocType: Account,Stock Received But Not Billed,Stock Marrë Por Jo faturuar
apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root Account must be a group,Root Llogaria duhet të jetë një grup i
DocType: Drug Prescription,Drug Prescription,Prescription e drogës
DocType: Fees,FEE.,FEE.
DocType: Employee Loan,Repaid/Closed,Paguhet / Mbyllur
DocType: Item,Total Projected Qty,Total projektuar Qty
DocType: Monthly Distribution,Distribution Name,Emri shpërndarja
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","Shkalla e vlerësimit nuk është gjetur për Item {0}, e cila kërkohet të bëjë shënime të kontabilitetit për {1} {2}. Nëse artikulli është duke u kryer si një zë zero vlerësimi në {1}, ju lutemi përmendni atë në tabelën {1} Item. Përndryshe, ju lutemi krijoni një transaksion të aksioneve në hyrje për artikullin ose përmendni normën e vlerësimit në regjistrin e artikullit dhe pastaj provoni paraqitjen / anulimin e këtij hyrjes"
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vendosni Serinë Naming për {0} nëpërmjet Setup&gt; Settings&gt; Naming Series
DocType: Course,Course Code,Kodi Kursi
apps/erpnext/erpnext/controllers/stock_controller.py +337,Quality Inspection required for Item {0},Inspektimi Cilësia e nevojshme për Item {0}
DocType: POS Settings,Use POS in Offline Mode,Përdorni POS në modalitetin Offline
DocType: Supplier Scorecard,Supplier Variables,Variablat e Furnizuesit
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Shkalla në të cilën konsumatori e valutës është e konvertuar në monedhën bazë kompanisë
DocType: Purchase Invoice Item,Net Rate (Company Currency),Net Rate (Kompania Valuta)
DocType: Salary Detail,Condition and Formula Help,Gjendja dhe Formula Ndihmë
apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Manage Territorit Tree.
DocType: Patient Service Unit,Patient Service Unit,Njësia e Shërbimit të Pacientëve
DocType: Journal Entry Account,Sales Invoice,Shitjet Faturë
DocType: Journal Entry Account,Party Balance,Bilanci i Partisë
DocType: Cash Flow Mapper,Section Subtotal,Seksioni Nëntotali
apps/erpnext/erpnext/accounts/page/pos/pos.js +498,Please select Apply Discount On,"Ju lutem, përzgjidhni Aplikoni zbritje në"
DocType: Stock Settings,Sample Retention Warehouse,Depoja e mbajtjes së mostrës
DocType: Company,Default Receivable Account,Gabim Llogaria Arkëtueshme
DocType: Physician Schedule,Physician Schedule,Orari i mjekut
DocType: Purchase Invoice,Deemed Export,Shqyrtuar Eksport
DocType: Stock Entry,Material Transfer for Manufacture,Transferimi materiale për Prodhimin
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.,Përqindja zbritje mund të aplikohet ose ndaj një listë të çmimeve apo për të gjithë listën e çmimeve.
DocType: Subscription,Half-yearly,Gjashtëmujor
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,Accounting Entry for Stock,Hyrja kontabilitetit për magazinë
DocType: Lab Test,LabTest Approver,Aprovuesi i LabTest
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61,You have already assessed for the assessment criteria {}.,Ju kanë vlerësuar tashmë me kriteret e vlerësimit {}.
DocType: Vehicle Service,Engine Oil,Vaj makine
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1006,Work Orders Created: {0},Rendi i punës i krijuar: {0}
DocType: Sales Invoice,Sales Team1,Shitjet Team1
apps/erpnext/erpnext/stock/doctype/item/item.py +547,Item {0} does not exist,Item {0} nuk ekziston
DocType: Sales Invoice,Customer Address,Customer Adresa
DocType: Employee Loan,Loan Details,kredi Details
DocType: Company,Default Inventory Account,Llogaria Default Inventar
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192,The folio numbers are not matching,Numrat e folio nuk përputhen
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Row {0}: Kompletuar Qty duhet të jetë më e madhe se zero.
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262,Payment Request for {0},Kërkesa për pagesë për {0}
DocType: Item Barcode,Barcode Type,Tipi i Barcode
DocType: Antibiotic,Antibiotic Name,Emri i Antibiotikut
DocType: Purchase Invoice,Apply Additional Discount On,Aplikoni shtesë zbritje në
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66,Select Type...,Zgjidh Type ...
DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Një lidhje me të gjitha Njësitë Tokësore në të cilat Pri rritet
DocType: Account,Root Type,Root Type
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: nuk mund të kthehet më shumë se {1} për Item {2}
DocType: Item Group,Show this slideshow at the top of the page,Trego këtë slideshow në krye të faqes
DocType: BOM,Item UOM,Item UOM
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Shuma e taksave Pas Shuma ulje (Kompania Valuta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217,Target warehouse is mandatory for row {0},Depo objektiv është i detyrueshëm për rresht {0}
DocType: Cheque Print Template,Primary Settings,Parametrat kryesore
DocType: Purchase Invoice,Select Supplier Address,Zgjidh Furnizuesi Adresa
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +407,Add Employees,Shto Punonjës
DocType: Purchase Invoice Item,Quality Inspection,Cilësia Inspektimi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Extra Vogla
DocType: Company,Standard Template,Template standard
DocType: Training Event,Theory,teori
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806,Warning: Material Requested Qty is less than Minimum Order Qty,Warning: Materiali kërkuar Qty është më pak se minimale Rendit Qty
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Llogaria {0} është ngrirë
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Personit juridik / subsidiare me një tabelë të veçantë e llogarive i përkasin Organizatës.
DocType: Payment Request,Mute Email,Mute Email
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Ushqim, Pije &amp; Duhani"
DocType: Account,Account Number,Numri i llogarisë
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752,Can only make payment against unbilled {0},Vetëm mund të bëni pagesën kundër pafaturuar {0}
apps/erpnext/erpnext/controllers/selling_controller.py +102,Commission rate cannot be greater than 100,Shkalla e Komisionit nuk mund të jetë më e madhe se 100
DocType: Volunteer,Volunteer,vullnetar
DocType: Stock Entry,Subcontract,Nënkontratë
apps/erpnext/erpnext/public/js/utils/party.js +166,Please enter {0} first,Ju lutem shkruani {0} parë
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,Nuk ka përgjigje nga
DocType: Work Order Operation,Actual End Time,Aktuale Fundi Koha
DocType: Item,Manufacturer Part Number,Prodhuesi Pjesa Numër
DocType: Work Order Operation,Estimated Time and Cost,Koha e vlerësuar dhe Kosto
DocType: Bin,Bin,Bin
DocType: Crop,Crop Name,Emri i farërave
DocType: SMS Log,No of Sent SMS,Nr i SMS dërguar
DocType: Antibiotic,Healthcare Administrator,Administrator i Shëndetësisë
apps/erpnext/erpnext/utilities/user_progress.py +47,Set a Target,Vendosni një Target
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ju lutem vendosni numrat e numrave për Pjesëmarrjen përmes Setup&gt; Seritë e Numërimit
DocType: Dosage Strength,Dosage Strength,Forca e dozimit
DocType: Account,Expense Account,Llogaria shpenzim
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Program
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Ngjyra
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteret plan vlerësimi
apps/erpnext/erpnext/stock/doctype/batch/batch.py +118,Expiry date is mandatory for selected item,Data e skadencës është e detyrueshme për artikullin e zgjedhur
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Parandalimi i urdhrave të blerjes
apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,i prekshëm
DocType: Patient Appointment,Scheduled,Planifikuar
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Kërkesa për kuotim.
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","Ju lutem zgjidhni Item ku &quot;A Stock Pika&quot; është &quot;Jo&quot; dhe &quot;është pika e shitjes&quot; është &quot;Po&quot;, dhe nuk ka asnjë tjetër Bundle Produktit"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Zgjidh Klientin
DocType: Student Log,Academic,Akademik
DocType: Patient,Personal and Social History,Historia personale dhe sociale
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,Përdoruesi {0} krijoi
DocType: Fee Schedule,Fee Breakup for each student,Shkëputja e taksës për secilin nxënës
apps/erpnext/erpnext/controllers/accounts_controller.py +541,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Gjithsej paraprakisht ({0}) kundër Rendit {1} nuk mund të jetë më e madhe se Grand Total ({2})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Zgjidh Shpërndarja mujore të pabarabartë shpërndarë objektiva të gjithë muajve.
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Ndrysho kodin
DocType: Purchase Invoice Item,Valuation Rate,Vlerësimi Rate
DocType: Stock Reconciliation,SR/,SR /
DocType: Vehicle,Diesel,naftë
apps/erpnext/erpnext/stock/get_item_details.py +388,Price List Currency not selected,Lista e Çmimeve Valuta nuk zgjidhet
DocType: Purchase Invoice,Availed ITC Cess,Availed ITC Cess
,Student Monthly Attendance Sheet,Student Pjesëmarrja mujore Sheet
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Rregullat e transportit të aplikueshme vetëm për shitjen
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Projekti Data e Fillimit
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +30,Until,Deri
DocType: Rename Tool,Rename Log,Rename Kyçu
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Grupi Student ose Course Orari është i detyrueshëm
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Grupi Student ose Course Orari është i detyrueshëm
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Ruajtur Orari Faturimi dhe orarit të punës njëjtën gjë në pasqyrë e mungesave
DocType: Maintenance Visit Purpose,Against Document No,Kundër Dokumentin Nr
DocType: BOM,Scrap,copëz
apps/erpnext/erpnext/utilities/user_progress.py +217,Go to Instructors,Shkoni te Instruktorët
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Manage Shitje Partnerët.
DocType: Quality Inspection,Inspection Type,Inspektimi Type
DocType: Fee Validity,Visited yet,Vizita ende
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134,Warehouses with existing transaction can not be converted to group.,Depot me transaksion ekzistues nuk mund të konvertohet në grup.
DocType: Assessment Result Tool,Result HTML,Rezultati HTML
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Skadon ne
apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Shto Studentët
apps/erpnext/erpnext/public/js/utils.js +412,Please select {0},"Ju lutem, përzgjidhni {0}"
DocType: C-Form,C-Form No,C-Forma Nuk ka
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/utilities/user_progress.py +139,List your products or services that you buy or sell.,Listoni produktet ose shërbimet që bleni ose sillni.
DocType: Water Analysis,Storage Temperature,Temperatura e magazinimit
DocType: Employee Attendance Tool,Unmarked Attendance,Pjesëmarrja pashënuar
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Studiues
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Regjistrimi Tool Student
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Data e fillimit duhet të jetë më pak se data e përfundimit të detyrës {0}
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Emri ose adresa është e detyrueshme
DocType: Member,MEM-,pjesëtare
DocType: Instructor,Instructor Log,Regjistri i instruktorit
DocType: Purchase Order Item,Returned Qty,U kthye Qty
DocType: Student,Exit,Dalje
apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Root Lloji është i detyrueshëm
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Dështoi në instalimin e paravendave
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} aktualisht ka një {1} Scorecard të Furnizuesit, dhe RFQ-të për këtë furnizues duhet të lëshohen me kujdes."
DocType: Chapter,Non Profit Manager,Menaxheri i Jofitimit
DocType: BOM,Total Cost(Company Currency),Kosto totale (Company Valuta)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +321,Serial No {0} created,Serial Asnjë {0} krijuar
DocType: Homepage,Company Description for website homepage,Përshkrimi i kompanisë për faqen e internetit
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Për komoditetin e klientëve, këto kode mund të përdoren në formate të shtypura si faturat dhe ofrimit të shënimeve"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Emri suplier
apps/erpnext/erpnext/accounts/report/financial_statements.py +174,Could not retrieve information for {0}.,Nuk mundi të gjente informacion për {0}.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134,Opening Entry Journal,Hapja e Ditarit të Hyrjes
DocType: Sales Invoice,Time Sheet List,Ora Lista Sheet
DocType: Employee,You can enter any date manually,Ju mund të hyjë në çdo datë me dorë
DocType: Healthcare Settings,Result Printed,Rezultati Printuar
DocType: Asset Category Account,Depreciation Expense Account,Llogaria Zhvlerësimi Shpenzimet
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233,Probationary Period,Periudha provuese
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Shiko {0}
DocType: Customer Group,Only leaf nodes are allowed in transaction,Vetëm nyjet fletë janë të lejuara në transaksion
DocType: Project,Total Costing Amount (via Timesheets),Shuma totale e kostos (përmes Timesheets)
DocType: Employee Advance,Expense Approver,Shpenzim aprovuesi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Row {0}: Advance kundër Customer duhet të jetë krediti
DocType: Project,Hourly,çdo orë
apps/erpnext/erpnext/accounts/doctype/account/account.js +83,Non-Group to Group,Non-Group Grupit
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Grumbull është i detyrueshëm në rradhë {0}
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Grumbull është i detyrueshëm në rradhë {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Fatura Blerje Item furnizuar
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Për datetime
apps/erpnext/erpnext/config/selling.py +302,Logs for maintaining sms delivery status,Shkrime për ruajtjen e statusit të dorëzimit SMS
DocType: Accounts Settings,Make Payment via Journal Entry,Të bëjë pagesën përmes Journal Hyrja
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +235,Printed On,Shtypur On
DocType: Item,Inspection Required before Delivery,Inspektimi i nevojshëm para dorëzimit
DocType: Item,Inspection Required before Purchase,Inspektimi i nevojshëm para se Blerja
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Aktivitetet në pritje
DocType: Patient Appointment,Reminded,kujtoi
DocType: Patient,PID-,PID-
DocType: Chapter Member,Chapter Member,Anëtar i Kapitullit
DocType: Material Request Plan Item,Minimum Order Quantity,Sasia minimale e porosisë
apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Organizata juaj
DocType: Fee Component,Fees Category,tarifat Category
apps/erpnext/erpnext/hr/doctype/employee/employee.py +135,Please enter relieving date.,Ju lutemi të hyrë në lehtësimin datën.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Sasia
DocType: Supplier Scorecard,Notify Employee,Njoftoni punonjësin
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Shkruani emrin e fushatës nëse burimi i hetimit është fushatë
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Gazeta Botuesit
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Zgjidh Viti Fiskal
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Data e dorëzimit të pritshëm duhet të jetë pas datës së porosisë së shitjes
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Reorder Level,Reorder Niveli
DocType: Company,Chart Of Accounts Template,Chart e Llogarive Stampa
DocType: Attendance,Attendance Date,Pjesëmarrja Data
apps/erpnext/erpnext/stock/get_item_details.py +352,Item Price updated for {0} in Price List {1},Item Çmimi përditësuar për {0} në çmimore {1}
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Shpërbërjes paga në bazë të fituar dhe zbritje.
apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Account with child nodes cannot be converted to ledger,Llogaria me nyje fëmijëve nuk mund të konvertohet në Ledger
DocType: Purchase Invoice Item,Accepted Warehouse,Magazina pranuar
DocType: Bank Reconciliation Detail,Posting Date,Posting Data
DocType: Item,Valuation Method,Vlerësimi Metoda
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Gjysma Dita
DocType: Sales Invoice,Sales Team,Sales Ekipi
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Duplicate entry,Hyrja Duplicate
DocType: Program Enrollment Tool,Get Students,Get Studentët
DocType: Serial No,Under Warranty,Nën garanci
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516,[Error],[Gabim]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,Me fjalë do të jetë i dukshëm një herë ju ruani Rendit Sales.
,Employee Birthday,Punonjës Ditëlindja
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Ju lutemi zgjidhni Data e Përfundimit për Riparimin e Përfunduar
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Student Batch Pjesëmarrja Tool
apps/erpnext/erpnext/controllers/status_updater.py +213,Limit Crossed,Limit Kaloi
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Planifikuar Upto
DocType: Woocommerce Settings,Secret,sekret
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Venture Capital
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Një term akademike me këtë &#39;vitin akademik&#39; {0} dhe &#39;Term Emri&#39; {1} ekziston. Ju lutemi të modifikojë këto të hyra dhe të provoni përsëri.
DocType: UOM,Must be Whole Number,Duhet të jetë numër i plotë
DocType: Leave Control Panel,New Leaves Allocated (In Days),Lë të reja alokuara (në ditë)
DocType: Purchase Invoice,Invoice Copy,fatura Copy
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serial Asnjë {0} nuk ekziston
DocType: Sales Invoice Item,Customer Warehouse (Optional),Magazina Customer (Fakultativ)
DocType: Pricing Rule,Discount Percentage,Përqindja Discount
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Rezervuar për nën-kontraktim
DocType: Payment Reconciliation Invoice,Invoice Number,Numri i faturës
DocType: Shopping Cart Settings,Orders,Urdhërat
DocType: Employee Leave Approver,Leave Approver,Lini aprovuesi
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +314,Please select a batch,"Ju lutem, përzgjidhni një grumbull"
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,Emri Grupi i Vlerësimit
DocType: Manufacturing Settings,Material Transferred for Manufacture,Material Transferuar për Prodhime
DocType: Landed Cost Item,Receipt Document Type,Pranimi Lloji Document
DocType: Daily Work Summary Settings,Select Companies,Zgjidh Kompanitë
DocType: Antibiotic,Healthcare,Kujdesit shëndetësor
DocType: Target Detail,Target Detail,Detail Target
apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Varianti i vetëm
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Të gjitha Jobs
DocType: Sales Order,% of materials billed against this Sales Order,% E materialeve faturuar kundër këtij Rendit Shitje
DocType: Program Enrollment,Mode of Transportation,Mode e Transportit
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Periudha Mbyllja Hyrja
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72,Select Department...,Zgjidh Departamentin ...
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Qendra Kosto me transaksionet ekzistuese nuk mund të konvertohet në grup
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} {2} {3},Shuma {0} {1} {2} {3}
DocType: Account,Depreciation,Amortizim
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102,The number of shares and the share numbers are inconsistent,Numri i aksioneve dhe numri i aksioneve nuk janë në përputhje
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Furnizuesi (s)
DocType: Employee Attendance Tool,Employee Attendance Tool,Punonjës Pjesëmarrja Tool
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Limit Credit
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Avg. Selling Price List Rate,Avg. Shitja e Çmimit të Çmimeve të Listës
DocType: Salary Component,Salary Component,Paga Komponenti
apps/erpnext/erpnext/accounts/utils.py +490,Payment Entries {0} are un-linked,Entries pagesës {0} janë të pa-lidhur
DocType: GL Entry,Voucher No,Voucher Asnjë
,Lead Owner Efficiency,Efikasiteti Lead Owner
,Lead Owner Efficiency,Efikasiteti Lead Owner
DocType: Leave Allocation,Leave Allocation,Lini Alokimi
DocType: Payment Request,Recipient Message And Payment Details,Marrësi Message Dhe Detajet e pagesës
DocType: Training Event,Trainer Email,trajner Email
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Kërkesat Materiale {0} krijuar
DocType: Restaurant Reservation,No of People,Jo e njerëzve
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Template i termave apo kontrate.
DocType: Purchase Invoice,Address and Contact,Adresa dhe Kontakt
DocType: Cheque Print Template,Is Account Payable,Është Llogaria e pagueshme
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Stock nuk mund të rifreskohet kundër marrjes Blerje {0}
DocType: Support Settings,Auto close Issue after 7 days,Auto Issue ngushtë pas 7 ditësh
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}","Lënë nuk mund të ndahen përpara {0}, si bilanci leja ka qenë tashmë copë dërgohet në regjistrin e ardhshëm alokimit Pushimi {1}"
apps/erpnext/erpnext/accounts/party.py +317,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Shënim: Për shkak / Data Referenca kalon lejuar ditët e kreditit të konsumatorëve nga {0} ditë (s)
apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Student Aplikuesi
DocType: Hub Tracked Item,Hub Tracked Item,Objekti i artikullit të përgjuar
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL për RECIPIENT
DocType: Asset Category Account,Accumulated Depreciation Account,Llogaria akumuluar Zhvlerësimi
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Kjo email është autogenerated
DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Entries
DocType: Program Enrollment,Boarding Student,Boarding Student
DocType: Asset,Expected Value After Useful Life,Vlera e pritshme pas së dobishme
DocType: Item,Reorder level based on Warehouse,Niveli Reorder bazuar në Magazina
DocType: Activity Cost,Billing Rate,Rate Faturimi
,Qty to Deliver,Qty të Dorëzojë
,Stock Analytics,Stock Analytics
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523,Operations cannot be left blank,Operacionet nuk mund të lihet bosh
DocType: Maintenance Visit Purpose,Against Document Detail No,Kundër Document Detail Jo
apps/erpnext/erpnext/regional/__init__.py +11,Deletion is not permitted for country {0},Largimi nuk lejohet për shtetin {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110,Party Type is mandatory,Lloji Party është e detyrueshme
DocType: Quality Inspection,Outgoing,Largohet
DocType: Material Request,Requested For,Kërkuar Për
DocType: Quotation Item,Against Doctype,Kundër DOCTYPE
apps/erpnext/erpnext/controllers/buying_controller.py +420,{0} {1} is cancelled or closed,{0} {1} është anuluar apo të mbyllura
DocType: Asset,Calculate Depreciation,Llogaritni Zhvlerësimin
DocType: Delivery Note,Track this Delivery Note against any Project,Përcjell këtë notën shpërndarëse kundër çdo Projektit
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35,Net Cash from Investing,Paraja neto nga Investimi
DocType: Work Order,Work-in-Progress Warehouse,Puna në progres Magazina
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} duhet të dorëzohet
DocType: Fee Schedule Program,Total Students,Studentët Gjithsej
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Pjesëmarrja Record {0} ekziston kundër Student {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Referenca # {0} datë {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Zhvlerësimi Eliminuar shkak të dispozicion të aseteve
DocType: Member,Member,anëtar
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Manage Adresat
DocType: Work Order Item,Work Order Item,Artikulli i Renditjes së Punës
DocType: Pricing Rule,Item Code,Kodi i artikullit
DocType: Serial No,Warranty / AMC Details,Garanci / AMC Detajet
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Zgjidh studentët me dorë për aktivitetin bazuar Grupit
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Zgjidh studentët me dorë për aktivitetin bazuar Grupit
DocType: Journal Entry,User Remark,Përdoruesi Vërejtje
DocType: Lead,Market Segment,Segmenti i Tregut
DocType: Agriculture Analysis Criteria,Agriculture Manager,Menaxheri i Bujqësisë
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966,Paid Amount cannot be greater than total negative outstanding amount {0},Shuma e paguar nuk mund të jetë më e madhe se shuma totale negative papaguar {0}
DocType: Supplier Scorecard Period,Variables,Variablat
DocType: Employee Internal Work History,Employee Internal Work History,Punonjës historia e Brendshme
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249,Closing (Dr),Mbyllja (Dr)
DocType: Cheque Print Template,Cheque Size,Çek Size
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +238,Serial No {0} not in stock,Serial Asnjë {0} nuk në magazinë
apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Template taksave për shitjen e transaksioneve.
DocType: Sales Invoice,Write Off Outstanding Amount,Shkruani Off Outstanding Shuma
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Llogaria {0} nuk përputhet me Kompaninë {1}
DocType: Education Settings,Current Academic Year,Aktual akademik Year
DocType: Stock Settings,Default Stock UOM,Gabim Stock UOM
DocType: Asset,Number of Depreciations Booked,Numri i nënçmime rezervuar
apps/erpnext/erpnext/public/js/pos/pos.html +71,Qty Total,Qty Total
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Kundër Huazim e punonjësve: {0}
DocType: Landed Cost Item,Receipt Document,Dokumenti Receipt
DocType: Employee Education,School/University,Shkolla / Universiteti
DocType: Payment Request,Reference Details,Referenca Detajet
apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Expected Value After Useful Life must be less than Gross Purchase Amount,Vlera e pritshme Pas së dobishme duhet të jetë më pak se bruto Blerje Shuma
DocType: Sales Invoice Item,Available Qty at Warehouse,Qty në dispozicion në magazinë
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Shuma e faturuar
DocType: Share Transfer,(including),(Duke përfshirë)
DocType: Asset,Double Declining Balance,Dyfishtë rënie Balance
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,mënyrë të mbyllura nuk mund të anulohet. Hap për të anulluar.
DocType: Student Guardian,Father,Atë
apps/erpnext/erpnext/controllers/accounts_controller.py +627,'Update Stock' cannot be checked for fixed asset sale,&#39;Update Stock&#39; nuk mund të kontrollohet për shitjen e aseteve fikse
DocType: Bank Reconciliation,Bank Reconciliation,Banka Pajtimit
DocType: Attendance,On Leave,Në ikje
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Get Updates
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Llogaria {2} nuk i përkasin kompanisë {3}
apps/erpnext/erpnext/stock/doctype/item/item.js +397,Select at least one value from each of the attributes.,Zgjidhni të paktën një vlerë nga secili prej atributeve.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166,Material Request {0} is cancelled or stopped,Materiali Kërkesë {0} është anuluar ose ndërprerë
apps/erpnext/erpnext/config/hr.py +314,Leave Management,Lini Menaxhimi
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +120,Group by Account,Grupi nga Llogaria
apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21,Please select Employee,Ju lutemi zgjidhni Punonjësin
DocType: Sales Order,Fully Delivered,Dorëzuar plotësisht
DocType: Lead,Lower Income,Të ardhurat më të ulëta
DocType: Restaurant Order Entry,Current Order,Rendi aktual
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Source and target warehouse cannot be same for row {0},Burimi dhe depo objektiv nuk mund të jetë i njëjtë për të rresht {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","Llogaria ndryshim duhet të jetë një llogari lloj Aseteve / Detyrimeve, pasi kjo Stock Pajtimi është një Hyrja Hapja"
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Shuma e disbursuar nuk mund të jetë më e madhe se: Kredia {0}
apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Programs,Shkoni te Programet
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Rresht {0} # Shuma e alokuar {1} nuk mund të jetë më e madhe se shuma e pakushtuar {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Blerje numrin urdhër që nevojitet për artikullit {0}
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',&#39;Nga Data &quot;duhet të jetë pas&quot; deri më sot &quot;
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Nuk mund të ndryshojë statusin si nxënës {0} është e lidhur me aplikimin e studentëve {1}
DocType: Asset,Fully Depreciated,amortizuar plotësisht
DocType: Item Barcode,UPC-A,UPC-A
,Stock Projected Qty,Stock Projektuar Qty
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444,Customer {0} does not belong to project {1},Customer {0} nuk i përket projektit {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Pjesëmarrja e shënuar HTML
apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Citate janë propozimet, ofertat keni dërguar për klientët tuaj"
DocType: Sales Invoice,Customer's Purchase Order,Rendit Blerje konsumatorit
DocType: Consultation,Patient,pacient
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Kontrolli i kredisë së anashkaluar në Urdhrin e shitjes
DocType: Land Unit,Check if it is a hydroponic unit,Kontrolloni nëse është njësi hidroponike
apps/erpnext/erpnext/config/stock.py +113,Serial No and Batch,Pa serial dhe Batch
DocType: Warranty Claim,From Company,Nga kompanisë
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Shuma e pikëve të kritereve të vlerësimit të nevojave të jetë {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Ju lutemi të vendosur Numri i nënçmime rezervuar
DocType: Supplier Scorecard Period,Calculations,llogaritjet
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86,Value or Qty,Vlera ose Qty
DocType: Payment Terms Template,Payment Terms,Kushtet e pagesës
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449,Productions Orders cannot be raised for:,Urdhërat Productions nuk mund të ngrihen për:
apps/erpnext/erpnext/utilities/user_progress.py +147,Minute,Minutë
apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Ju lutem vendosni Sistemin e Emërimit të Punonjësve në Burimet Njerëzore&gt; Cilësimet e HR
DocType: Purchase Invoice,Purchase Taxes and Charges,Blerje taksat dhe tatimet
DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
apps/erpnext/erpnext/utilities/user_progress.py +121,Go to Suppliers,Shko tek Furnizuesit
,Qty to Receive,Qty të marrin
DocType: Leave Block List,Leave Block List Allowed,Dërgo Block Lista Lejohet
DocType: Grading Scale Interval,Grading Scale Interval,Nota Scale Interval
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Kërkesa Expense për Automjeteve Identifikohu {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Discount (%) në listën e çmimeve të votuarat vetëm me Margjina
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Discount (%) në listën e çmimeve të votuarat vetëm me Margjina
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Të gjitha Depot
DocType: Sales Partner,Retailer,Shitës me pakicë
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Kredi në llogarinë duhet të jetë një llogari Bilanci i Gjendjes
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118,All Supplier Types,Gjitha llojet Furnizuesi
DocType: Donor,Donor,dhurues
DocType: Global Defaults,Disable In Words,Disable Në fjalë
apps/erpnext/erpnext/stock/doctype/item/item.py +60,Item Code is mandatory because Item is not automatically numbered,Kodi i artikullit është i detyrueshëm për shkak Item nuk është numëruar në mënyrë automatike
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Citat {0} nuk e tipit {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Orari Mirëmbajtja Item
DocType: Sales Order,%  Delivered,% Dorëzuar
apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Ju lutemi vendosni ID Email për Studentin për të dërguar Kërkesën e Pagesës
DocType: Patient,Medical History,Histori mjekesore
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Llogaria Overdraft Banka
DocType: Patient,Patient ID,ID e pacientit
DocType: Physician Schedule,Schedule Name,Orari Emri
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +49,Make Salary Slip,Bëni Kuponi pagave
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840,Add All Suppliers,Shto të Gjithë Furnizuesit
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Shuma e ndarë nuk mund të jetë më e madhe se shuma e papaguar.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Shfleto bom
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Kredi të siguruara
DocType: Purchase Invoice,Edit Posting Date and Time,Edit Posting Data dhe Koha
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Ju lutemi të vendosur Llogaritë zhvlerësimit lidhur në Kategorinë Aseteve {0} ose kompanisë {1}
DocType: Lab Test Groups,Normal Range,Gama normale
DocType: Academic Term,Academic Year,Vit akademik
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Available Selling,Shitja në dispozicion
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Hapja Bilanci ekuitetit
DocType: Lead,CRM,CRM
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,mbetur
DocType: Appraisal,Appraisal,Vlerësim
DocType: Purchase Invoice,GST Details,Detajet e GST
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},Email dërguar për furnizuesit {0}
DocType: Item,Default Sales Unit of Measure,Njësia e shitjes së paracaktuar të masës
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Academic Year: ,Vit akademik:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +19,Not allow to set alternative item for the item {0},Mos lejoni të vendosni elementin alternativ për artikullin {0}
DocType: Opportunity,OPTY-,OPTY-
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Data përsëritet
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Nënshkrues i autorizuar
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64,Create Fees,Krijo tarifa
DocType: Project,Total Purchase Cost (via Purchase Invoice),Gjithsej Kosto Blerje (nëpërmjet Blerje Faturës)
DocType: Training Event,Start Time,Koha e fillimit
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +421,Select Quantity,Zgjidh Sasia
DocType: Customs Tariff Number,Customs Tariff Number,Numri Tarifa doganore
DocType: Patient Appointment,Patient Appointment,Emërimi i pacientit
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Miratimi Rolit nuk mund të jetë i njëjtë si rolin rregulli është i zbatueshëm për
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Çabonoheni nga ky Dërgoje Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830,Get Suppliers By,Merrni Furnizuesit Nga
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173,{0} not found for Item {1},{0} nuk u gjet për Item {1}
apps/erpnext/erpnext/utilities/user_progress.py +197,Go to Courses,Shkoni në Kurse
DocType: Accounts Settings,Show Inclusive Tax In Print,Trego taksën përfshirëse në shtyp
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory","Llogaria bankare, nga data dhe deri në datën janë të detyrueshme"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Mesazh dërguar
apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Account with child nodes cannot be set as ledger,Llogari me nyje të fëmijëve nuk mund të vendosen si librit
DocType: C-Form,II,II
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Shkalla në të cilën listë Çmimi monedhës është konvertuar në bazë monedhën klientit
DocType: Purchase Invoice Item,Net Amount (Company Currency),Shuma neto (Kompania Valuta)
DocType: Physician,Physician Schedules,Oraret e mjekut
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215,Total advance amount cannot be greater than total sanctioned amount,Shuma totale e paradhënies nuk mund të jetë më e madhe se shuma totale e sanksionuar
DocType: Salary Slip,Hour Rate,Ore Rate
DocType: Stock Settings,Item Naming By,Item Emërtimi By
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Një tjetër Periudha Mbyllja Hyrja {0} është bërë pas {1}
DocType: Work Order,Material Transferred for Manufacturing,Materiali Transferuar për Prodhim
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41,Account {0} does not exists,Llogaria {0} nuk ekziston
DocType: Project,Project Type,Lloji i projektit
apps/erpnext/erpnext/projects/doctype/task/task.py +153,Child Task exists for this Task. You can not delete this Task.,Detyra e fëmijës ekziston për këtë detyrë. Nuk mund ta fshish këtë detyrë.
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.,Ose Qty objektiv ose objektiv shuma është e detyrueshme.
apps/erpnext/erpnext/config/projects.py +56,Cost of various activities,Kosto e aktiviteteve të ndryshme
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}","Vendosja Ngjarje për {0}, pasi që punonjësit e bashkangjitur më poshtë Personave Sales nuk ka një ID User {1}"
DocType: Timesheet,Billing Details,detajet e faturimit
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,Source and target warehouse must be different,Burimi dhe depo objektiv duhet të jetë i ndryshëm
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140,Payment Failed. Please check your GoCardless Account for more details,Pagesa dështoi. Kontrollo llogarinë tënde GoCardless për më shumë detaje
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Nuk lejohet të përtërini transaksioneve të aksioneve të vjetër se {0}
DocType: BOM,Inspection Required,Kerkohet Inspektimi
DocType: Purchase Invoice Item,PR Detail,PR Detail
DocType: Driving License Category,Class,klasë
DocType: Sales Order,Fully Billed,Faturuar plotësisht
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426,Work Order cannot be raised against a Item Template,Rendi i punës nuk mund të ngrihet kundër një modeli artikull
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Rregullimi i transportit është i zbatueshëm vetëm për Blerjen
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Para në dorë
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Depo ofrimit të nevojshme për pikën e aksioneve {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Pesha bruto e paketës. Zakonisht pesha neto + paketimin pesha materiale. (Për shtyp)
DocType: Assessment Plan,Program,program
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Përdoruesit me këtë rol janë të lejuara për të ngritur llogaritë ngrirë dhe për të krijuar / modifikuar shënimet e kontabilitetit kundrejt llogarive të ngrira
apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Ju lutemi vendosni Sistemin e Emërimit të Instruktorit në Arsim&gt; Cilësimet e Arsimit
DocType: Serial No,Is Cancelled,Është anuluar
DocType: Student Group,Group Based On,Grupi i bazuar në
DocType: Student Group,Group Based On,Grupi i bazuar në
DocType: Journal Entry,Bill Date,Bill Data
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratori SMS alarme
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Shërbimi Item, Lloji, frekuenca dhe sasia shpenzimet janë të nevojshme"
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:","Edhe në qoftë se ka rregulla të shumta çmimeve me prioritet më të lartë, prioritetet e brendshme atëherë në vijim aplikohen:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kriteret e analizës së bimëve
DocType: Cheque Print Template,Cheque Height,Çek Lartësia
DocType: Supplier,Supplier Details,Detajet Furnizuesi
DocType: Setup Progress,Setup Progress,Progresi i konfigurimit
DocType: Hub Settings,Publish Items to Hub,Botojë artikuj për Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Nga Vlera duhet të jetë më pak se të vlerës në rresht {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Wire Transfer
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,kontrollo të gjitha
,Issued Items Against Work Order,Lëshuar Artikuj Kundër Rendit Punë
DocType: Vehicle Log,Invoice Ref,faturë Ref
DocType: Company,Default Income Account,Llogaria e albumit ardhurat
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Grupi Customer / Customer
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Pambyllur fiskale Years Fitimi / Humbja (Credit)
DocType: Sales Invoice,Time Sheets,Sheets Koha
DocType: Lab Test Template,Change In Item,Ndrysho artikullin
DocType: Payment Gateway Account,Default Payment Request Message,Default kërkojë pagesën mesazh
DocType: Item Group,Check this if you want to show in website,Kontrolloni këtë në qoftë se ju doni të tregojnë në faqen e internetit
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338,Balance ({0}),Bilanci ({0})
apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bankar dhe i Pagesave
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +99,Please enter API Consumer Key,Ju lutemi shkruani Key Consumer Key
,Welcome to ERPNext,Mirë se vini në ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Lead për Kuotim
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,Reminders Email do të dërgohen në të gjitha palët me kontaktet e-mail
DocType: Project,Twice Daily,Dy here ne dite
DocType: Patient,A Negative,Një Negativ
apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Asgjë më shumë për të treguar.
DocType: Lead,From Customer,Nga Klientit
apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Telefonatat
apps/erpnext/erpnext/utilities/user_progress.py +143,A Product,Një produkt
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +233,Batches,tufa
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Bëni Orarin e Tarifave
DocType: Purchase Order Item Supplied,Stock UOM,Stock UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Blerje Rendit {0} nuk është dorëzuar
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Sasia normale e referencës për një të rritur është 16-20 fryma / minutë (RCP 2012)
DocType: Customs Tariff Number,Tariff Number,Numri Tarifa
DocType: Work Order Item,Available Qty at WIP Warehouse,Qty në dispozicion në WIP Magazina
apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Projektuar
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +228,Serial No {0} does not belong to Warehouse {1},Serial Asnjë {0} nuk i përkasin Magazina {1}
apps/erpnext/erpnext/controllers/status_updater.py +177,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Shënim: Sistemi nuk do të kontrollojë mbi-ofrimit dhe mbi-prenotim për Item {0} si sasi apo shumë është 0
DocType: Notification Control,Quotation Message,Citat Mesazh
DocType: Employee Loan,Employee Loan Application,Punonjës Loan Application
DocType: Issue,Opening Date,Hapja Data
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86,Please save the patient first,Ju lutemi ruani pacientin së pari
apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Pjesëmarrja është shënuar sukses.
DocType: Program Enrollment,Public Transport,Transporti publik
DocType: Soil Texture,Silt Composition (%),Përbërja (%)
DocType: Journal Entry,Remark,Vërejtje
DocType: Healthcare Settings,Avoid Confirmation,Shmangni konfirmimin
DocType: Purchase Receipt Item,Rate and Amount,Shkalla dhe Shuma
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176,Account Type for {0} must be {1},Lloji i llogarisë për {0} duhet të jetë {1}
DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Llogaritë e të ardhurave me vonesë do të përdoren nëse nuk vendosen në mjek për të rezervuar akuzat e konsultimit.
apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Lë dhe Festa
DocType: Education Settings,Current Academic Term,Term aktual akademik
DocType: Education Settings,Current Academic Term,Term aktual akademik
DocType: Sales Order,Not Billed,Jo faturuar
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76,Both Warehouse must belong to same Company,Të dyja Magazina duhet t&#39;i përkasë njëjtës kompani
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Nuk ka kontakte të shtuar ende.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Kosto zbarkoi Voucher Shuma
,Item Balance (Simple),Bilanci i artikullit (I thjeshtë)
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Faturat e ngritura nga furnizuesit.
DocType: POS Profile,Write Off Account,Shkruani Off Llogari
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +227,Debit Note Amt,Debit Shënim AMT
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Shuma Discount
DocType: Purchase Invoice,Return Against Purchase Invoice,Kthehu kundër Blerje Faturë
DocType: Item,Warranty Period (in days),Garanci Periudha (në ditë)
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Dështoi në përcaktimin e parazgjedhjeve
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Raporti me Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +791,Please select BOM against item {0},Ju lutem zgjidhni BOM kundër sendit {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Bëni faturat
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Cash from Operations,Paraja neto nga operacionet
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Pika 4
DocType: Student Admission,Admission End Date,Pranimi End Date
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Nënkontraktimi
DocType: Journal Entry Account,Journal Entry Account,Llogaria Journal Hyrja
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Grupi Student
DocType: Shopping Cart Settings,Quotation Series,Citat Series
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","Një artikull ekziston me të njëjtin emër ({0}), ju lutemi të ndryshojë emrin e grupit pika ose riemërtoj pika"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriteret e Analizës së Tokës
apps/erpnext/erpnext/accounts/page/pos/pos.js +2037,Please select customer,Ju lutemi zgjidhni klientit
DocType: C-Form,I,unë
DocType: Company,Asset Depreciation Cost Center,Asset Center Zhvlerësimi Kostoja
DocType: Production Plan Sales Order,Sales Order Date,Sales Order Data
DocType: Sales Invoice Item,Delivered Qty,Dorëzuar Qty
DocType: Assessment Plan,Assessment Plan,Plani i vlerësimit
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Klienti {0} është krijuar.
DocType: Stock Settings,Limit Percent,Limit Percent
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Aktualisht nuk ka të aksioneve në dispozicion në ndonjë depo
,Payment Period Based On Invoice Date,Periudha e pagesës bazuar në datën Faturë
DocType: Sample Collection,No. of print,Numri i printimit
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Rezervimi i dhomës së hotelit
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Missing Currency Exchange Rates për {0}
DocType: Health Insurance,Health Insurance Name,Emri i Sigurimit Shëndetësor
DocType: Assessment Plan,Examiner,pedagog
DocType: Student,Siblings,Vëllezërit e motrat
DocType: Journal Entry,Stock Entry,Stock Hyrja
DocType: Payment Entry,Payment References,Referencat e pagesës
DocType: C-Form,C-FORM-,C-pritet të marrin
DocType: Vehicle,Insurance Details,Details Insurance
DocType: Account,Payable,Për t&#39;u paguar
DocType: Share Balance,Share Type,Lloji i aksioneve
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Ju lutemi shkruani Periudhat Ripagimi
apps/erpnext/erpnext/shopping_cart/cart.py +378,Debtors ({0}),Debitorët ({0})
DocType: Pricing Rule,Margin,diferencë
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Klientët e Rinj
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Bruto% Fitimi
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +512,Change POS Profile,Ndrysho Profilin e POS
DocType: Bank Reconciliation Detail,Clearance Date,Pastrimi Data
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Raporti i Vlerësimit
apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Gross Shuma Blerje është i detyrueshëm
apps/erpnext/erpnext/setup/doctype/company/company.js +95,Company name not same,Emri i kompanisë nuk është i njëjtë
DocType: Lead,Address Desc,Adresuar Përshkrimi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113,Party is mandatory,Partia është e detyrueshme
DocType: Journal Entry,JV-,JV-
apps/erpnext/erpnext/controllers/accounts_controller.py +714,Rows with duplicate due dates in other rows were found: {list},Rreshtat me datat e dyfishta të gjetjeve në rreshta të tjerë u gjetën: {list}
DocType: Topic,Topic Name,Topic Emri
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,Atleast one of the Selling or Buying must be selected,Atleast një nga shitjen apo blerjen duhet të zgjidhen
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290,Select an employee to get the employee advance.,Përzgjidhni një punonjës që të merrni punonjësin përpara.
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Zgjidh një datë të vlefshme
apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Zgjidhni natyrën e biznesit tuaj.
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.","I vetëm për rezultatet që kërkojnë vetëm një input të vetëm, rezultati UOM dhe vlera normale <br> Përzierje për rezultate që kërkojnë fusha të shumëfishta të futjes me emrat e ngjarjeve korresponduese, rezultatet UOM dhe vlerat normale <br> Përshkruese për testet të cilat kanë përbërës të shumëfishtë të rezultateve dhe fusha korresponduese të rezultateve. <br> Grupuar për modelet e testimit të cilat janë një grup i modeleve të testeve të tjera. <br> Asnjë rezultat për testime pa rezultate. Gjithashtu, nuk është krijuar asnjë Test Lab. psh. Nën testet për rezultatet e grupuara."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86,Row #{0}: Duplicate entry in References {1} {2},Rresht # {0}: Dublikoje hyrja në Referencat {1} {2}
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Ku operacionet prodhuese janë kryer.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Si Ekzaminues
DocType: Appointment Type,Default Duration,Kohëzgjatja e vonuar
DocType: Asset Movement,Source Warehouse,Burimi Magazina
DocType: Installation Note,Installation Date,Instalimi Data
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Libri i aksioneve
apps/erpnext/erpnext/controllers/accounts_controller.py +606,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} nuk i përkasin kompanisë {2}
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Fatura Sales {0} krijuar
DocType: Employee,Confirmation Date,Konfirmimi Data
DocType: C-Form,Total Invoiced Amount,Shuma totale e faturuar
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50,Min Qty can not be greater than Max Qty,Min Qty nuk mund të jetë më i madh se Max Qty
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Account,Accumulated Depreciation,Zhvlerësimi i akumuluar
DocType: Supplier Scorecard Scoring Standing,Standing Name,Emri i Përhershëm
DocType: Stock Entry,Customer or Supplier Details,Customer ose Furnizuesi Detajet
DocType: Employee Loan Application,Required by Date,Kërkohet nga Data
DocType: Lead,Lead Owner,Lead Owner
DocType: Production Plan,Sales Orders Detail,Detajet e porosive të shitjeve
DocType: Bin,Requested Quantity,kërkohet Sasia
DocType: Patient,Marital Status,Statusi martesor
DocType: Stock Settings,Auto Material Request,Auto materiale Kërkesë
DocType: Woocommerce Settings,API consumer secret,Sekreti i konsumatorit API
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Në dispozicion Qty Batch në nga depo
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,Gross Pay - Zbritja Total - shlyerjen e kredisë
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29,Current BOM and New BOM can not be same,BOM aktuale dhe të reja bom nuk mund të jetë e njëjtë
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47,Salary Slip ID,Paga Slip ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,Date Of Retirement must be greater than Date of Joining,Data e daljes në pension duhet të jetë më i madh se data e bashkimit
apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Variante të shumëfishta
DocType: Sales Invoice,Against Income Account,Kundër llogarisë së të ardhurave
apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Dorëzuar
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).,Item {0}: Qty Urdhërohet {1} nuk mund të jetë më pak se Qty mënyrë minimale {2} (përcaktuar në pikën).
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mujor Përqindja e shpërndarjes
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +62,Please login as another user.,Ju lutemi identifikohuni si një përdorues tjetër.
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Përdoruesi i grupit të punës së përditshme
DocType: Territory,Territory Targets,Synimet Territory
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Delivery Note,Transporter Info,Transporter Informacion
apps/erpnext/erpnext/accounts/utils.py +497,Please set default {0} in Company {1},Ju lutemi të vendosur parazgjedhur {0} në Kompaninë {1}
DocType: Cheque Print Template,Starting position from top edge,pozicion nga buzë të lartë duke filluar
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33,Same supplier has been entered multiple times,Same furnizuesi është lidhur shumë herë
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Fitimi bruto / Humbja
,Warehouse wise Item Balance Age and Value,Magazina e mençur Item Balance Age and Value
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Blerje Rendit Item furnizuar
apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Emri i kompanisë nuk mund të jetë i kompanisë
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Kryetarët letër për të shtypura templates.
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Titujt për shtypura templates p.sh. ProFORMA faturë.
DocType: Program Enrollment,Walking,ecje
DocType: Student Guardian,Student Guardian,Guardian Student
DocType: Member,Member Name,Emri i Anëtarit
DocType: Stock Settings,Use Naming Series,Përdorni Serinë Naming
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Akuzat lloj vlerësimi nuk mund të shënuar si gjithëpërfshirës
DocType: POS Profile,Update Stock,Update Stock
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,në abonim
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.,UOM ndryshme për sendet do të çojë në të gabuar (Total) vlerën neto Pesha. Sigurohuni që pesha neto e çdo send është në të njëjtën UOM.
DocType: Membership,Payment Details,Detajet e pagesës
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,Bom Rate
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Ndalohet Rendi i Punës nuk mund të anulohet, të anullohet së pari të anulohet"
DocType: Asset,Journal Entry for Scrap,Journal Hyrja për skrap
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Ju lutemi të tërheqë sendet nga i dorëzimit Shënim
apps/erpnext/erpnext/accounts/utils.py +467,Journal Entries {0} are un-linked,Journal Entries {0} janë të pa-lidhura
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Rekord të të gjitha komunikimeve të tipit mail, telefon, chat, vizita, etj"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Rezultati i rezultatit të furnitorit
DocType: Manufacturer,Manufacturers used in Items,Prodhuesit e përdorura në artikujt
apps/erpnext/erpnext/accounts/general_ledger.py +170,Please mention Round Off Cost Center in Company,Ju lutemi të përmendim Round Off Qendra kushtojë në Kompaninë
DocType: Purchase Invoice,Terms,Kushtet
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10,Select Days,Zgjidhni Ditët
DocType: Academic Term,Term Name,Term Emri
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332,Credit ({0}),Kredia ({0})
DocType: Buying Settings,Purchase Order Required,Blerje urdhër që nevojitet
apps/erpnext/erpnext/public/js/projects/timer.js +5,Timer,kohëmatës
,Item-wise Sales History,Pika-mençur Historia Sales
DocType: Expense Claim,Total Sanctioned Amount,Shuma totale e sanksionuar
DocType: Land Unit,Land Unit,Njësia e Tokës
,Purchase Analytics,Analytics Blerje
DocType: Sales Invoice Item,Delivery Note Item,Ofrimit Shënim Item
DocType: Asset Maintenance Log,Task,Detyrë
DocType: Purchase Taxes and Charges,Reference Row #,Referenca Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Numri i Batch është i detyrueshëm për Item {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Ky është një person i shitjes rrënjë dhe nuk mund të redaktohen.
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. ","Nëse zgjedhur, vlera të specifikuara ose të llogaritur në këtë komponent nuk do të kontribuojë në të ardhurat ose zbritjeve. Megjithatë, kjo është vlera mund të referohet nga komponentët e tjerë që mund të shtohen ose zbriten."
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. ","Nëse zgjedhur, vlera të specifikuara ose të llogaritur në këtë komponent nuk do të kontribuojë në të ardhurat ose zbritjeve. Megjithatë, kjo është vlera mund të referohet nga komponentët e tjerë që mund të shtohen ose zbriten."
DocType: Asset Settings,Number of Days in Fiscal Year,Numri i ditëve në vit fiskal
,Stock Ledger,Stock Ledger
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Shkalla: {0}
DocType: Company,Exchange Gain / Loss Account,Exchange Gain / Humbja e llogarisë
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Punonjës dhe Pjesëmarrja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +105,Purpose must be one of {0},Qëllimi duhet të jetë një nga {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Fill the form and save it,Plotësoni formularin dhe për të shpëtuar atë
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forumi Komuniteti
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Qty aktuale në magazinë
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Qty aktuale në magazinë
DocType: Homepage,"URL for ""All Products""",URL për &quot;Të gjitha Produktet&quot;
DocType: Leave Application,Leave Balance Before Application,Dërgo Bilanci para aplikimit
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,Dërgo SMS
DocType: Supplier Scorecard Criteria,Max Score,Pikët maksimale
DocType: Cheque Print Template,Width of amount in word,Gjerësia e shumës në fjalë
DocType: Company,Default Letter Head,Default Letër Shef
DocType: Purchase Order,Get Items from Open Material Requests,Të marrë sendet nga kërkesat Hapur Materiale
DocType: Hotel Room Amenity,Billable,Billable
DocType: Lab Test Template,Standard Selling Rate,Standard Shitja Vlerësoni
DocType: Account,Rate at which this tax is applied,Shkalla në të cilën kjo taksë aplikohet
DocType: Cash Flow Mapper,Section Name,Emri i seksionit
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77,Reorder Qty,Reorder Qty
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Hapje e tanishme e punës
DocType: Company,Stock Adjustment Account,Llogaria aksioneve Rregullimit
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Shkruani Off
DocType: Patient Service Unit,Allow Overlap,Lejo mbivendosjen
DocType: Timesheet Detail,Operation ID,Operacioni ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Përdoruesi i Sistemit (login) ID. Nëse vendosur, ajo do të bëhet e parazgjedhur për të gjitha format e burimeve njerëzore."
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Nga {1}
DocType: Task,depends_on,depends_on
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.,Në pritje për përditësimin e çmimit të fundit në të gjitha dokumentet e materialeve. Mund të duhen disa minuta.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Emri i llogarisë së re. Shënim: Ju lutem mos krijoni llogari për klientët dhe furnizuesit
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Klienti&gt; Grupi i Klientit&gt; Territori
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Shteti parazgjedhur i mençur Adresa Templates
DocType: Water Analysis,Appearance,shfaqje
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Avg. Buying Price List Rate,Avg. Blerja e çmimit të listës së çmimeve
DocType: Sales Order Item,Supplier delivers to Customer,Furnizuesi jep Klientit
apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Informacioni i anëtarit.
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Forma / Item / {0}) është nga të aksioneve
apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Mirëmbajtja e aseteve
,Sales Payment Summary,Përmbledhje e Shitjeve të Pagesave
DocType: Restaurant,Restaurant,Restorant
DocType: Woocommerce Settings,API consumer key,Çelësi i konsumatorit API
apps/erpnext/erpnext/accounts/party.py +320,Due / Reference Date cannot be after {0},Për shkak / Referenca Data nuk mund të jetë pas {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Importi dhe Eksporti i të dhënave
DocType: Patient,Account Details,detajet e llogarise
DocType: Crop,Materials Required,Materialet e kërkuara
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Nuk studentët Found
DocType: Medical Department,Medical Department,Departamenti i Mjekësisë
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kriteret e Shënimit të Rezultatit të Furnizuesit
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Fatura Posting Data
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,shes
DocType: Purchase Invoice,Rounded Total,Rrumbullakuar Total
DocType: Product Bundle,List items that form the package.,Artikuj lista që formojnë paketë.
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39,Not permitted. Please disable the Test Template,Nuk lejohet. Ju lutemi disable Template Test
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Alokimi përqindje duhet të jetë e barabartë me 100%
DocType: Crop Cycle,Linked Land Unit,Njësia e lidhur tokësore
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,"Ju lutem, përzgjidhni datën e postimit para se të zgjedhur Partinë"
DocType: Program Enrollment,School House,School House
DocType: Serial No,Out of AMC,Nga AMC
apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Numri i nënçmime rezervuar nuk mund të jetë më e madhe se Total Numri i nënçmime
DocType: Purchase Order,Order Confirmation Date,Data e konfirmimit të rendit
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Bëni Mirëmbajtja vizitë
apps/erpnext/erpnext/selling/doctype/customer/customer.py +215,Please contact to the user who have Sales Master Manager {0} role,Ju lutem kontaktoni për përdoruesit të cilët kanë Sales Master Menaxher {0} rol
DocType: Company,Default Cash Account,Gabim Llogaria Cash
apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Kompani (jo Customer ose Furnizuesi) mjeshtër.
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Kjo është e bazuar në pjesëmarrjen e këtij Student
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Nuk ka Studentët në
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179,Add more items or open full form,Shto artikuj më shumë apo formë të hapur të plotë
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Shënime ofrimit {0} duhet të anulohet para se anulimi këtë Radhit Sales
apps/erpnext/erpnext/utilities/user_progress.py +259,Go to Users,Shko te Përdoruesit
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Shuma e paguar + anullojë Shuma nuk mund të jetë më i madh se Grand Total
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} nuk është një numër i vlefshëm Batch për Item {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130,Note: There is not enough leave balance for Leave Type {0},Shënim: Nuk ka bilanc mjaft leje për pushim Lloji {0}
apps/erpnext/erpnext/regional/india/utils.py +16,Invalid GSTIN or Enter NA for Unregistered,GSTIN pavlefshme ose Shkruani NA për paregjistruar
DocType: Training Event,Seminar,seminar
DocType: Program Enrollment Fee,Program Enrollment Fee,Program Tarifa Regjistrimi
DocType: Item,Supplier Items,Items Furnizuesi
DocType: Opportunity,Opportunity Type,Mundësi Type
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Kompania e re
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Transaksionet mund të fshihet vetëm nga krijuesi i kompanisë
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.,Numri i pasaktë i Librit Kryesor Entries gjetur. Ju mund të keni zgjedhur një Llogari gabuar në transaksion.
DocType: Employee,Prefered Contact Email,I preferuar Kontaktoni Email
DocType: Cheque Print Template,Cheque Width,Gjerësia çek
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Vlereso Shitja Çmimi për artikullin kundër Blerje votuarat vetëm ose të votuarat Vlerësimit
DocType: Fee Schedule,Fee Schedule,Orari Tarifa
DocType: Hub Settings,Publish Availability,Publikimi i Disponueshmëria
DocType: Company,Create Chart Of Accounts Based On,Krijoni planin kontabël në bazë të
apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Nuk mund të konvertohet në jo-grup. Detyrat e fëmijëve ekzistojnë.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date of Birth cannot be greater than today.,Data e lindjes nuk mund të jetë më e madhe se sa sot.
,Stock Ageing,Stock plakjen
apps/erpnext/erpnext/education/doctype/student/student.py +40,Student {0} exist against student applicant {1},Student {0} ekzistojnë kundër aplikantit studentore {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Rregullimi i Llogaritjeve (Valuta e Kompanisë)
apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,pasqyrë e mungesave
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243,Batch: ,Batch:
DocType: Volunteer,Afternoon,pasdite
apps/erpnext/erpnext/controllers/accounts_controller.py +258,{0} '{1}' is disabled,{0} &#39;{1}&#39; është me aftësi të kufizuara
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Bëje si Open
DocType: Cheque Print Template,Scanned Cheque,skanuar çek
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Dërgo email automatike në Kontaktet për transaksionet Dorëzimi.
DocType: Timesheet,Total Billable Amount,Shuma totale billable
DocType: Customer,Credit Limit and Payment Terms,Kufizimet e kredisë dhe kushtet e pagesës
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Pika 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Rendit Hyrja
DocType: Purchase Order,Customer Contact Email,Customer Contact Email
DocType: Warranty Claim,Item and Warranty Details,Pika dhe Garanci Details
DocType: Chapter,Chapter Members,Anëtarët e Kapitullit
DocType: Sales Team,Contribution (%),Kontributi (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +102,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Shënim: Pagesa Hyrja nuk do të jetë krijuar që nga &#39;Cash ose Llogarisë Bankare &quot;nuk ishte specifikuar
apps/erpnext/erpnext/projects/doctype/project/project.py +70,Project {0} already exists,Projekti {0} tashmë ekziston
DocType: Medical Department,Nursing User,Përdorues i Infermierisë
DocType: Plant Analysis,Plant Analysis Criterias,Kriteret e Analizës së Bimëve
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Responsibilities,Përgjegjësitë
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Periudha e vlefshmërisë së këtij citati ka përfunduar.
DocType: Expense Claim Account,Expense Claim Account,Llogaria Expense Kërkesa
DocType: Accounts Settings,Allow Stale Exchange Rates,Lejoni shkëmbimin e stale të këmbimit
DocType: Sales Person,Sales Person Name,Sales Person Emri
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Ju lutemi shkruani atleast 1 faturën në tryezë
apps/erpnext/erpnext/utilities/user_progress.py +247,Add Users,Shto Përdoruesit
DocType: POS Item Group,Item Group,Grupi i artikullit
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Student Group: ,Grupi Studentor:
apps/erpnext/erpnext/public/js/hub/hub_listing.js +388,Select Country,Zgjidh Shtetin
DocType: Item,Safety Stock,Siguria Stock
DocType: Healthcare Settings,Healthcare Settings,Cilësimet e kujdesit shëndetësor
apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,Progresi% për një detyrë nuk mund të jetë më shumë se 100.
DocType: Stock Reconciliation Item,Before reconciliation,Para se të pajtimit
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Për {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Taksat dhe Tarifat Shtuar (Kompania Valuta)
apps/erpnext/erpnext/stock/doctype/item/item.py +476,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Row Tatimore pika {0} duhet të keni një llogari te tipit Tatimit ose e ardhur ose shpenzim ose ngarkimit
DocType: Sales Order,Partly Billed,Faturuar Pjesërisht
apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} duhet të jetë një artikull Fixed Asset
apps/erpnext/erpnext/stock/doctype/item/item.js +372,Make Variants,Bëni variantet
DocType: Item,Default BOM,Gabim bom
DocType: Project,Total Billed Amount (via Sales Invoices),Shuma Totale e Faturuar (përmes Faturat e Shitjes)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +125,Debit Note Amount,Debit Shënim Shuma
DocType: Project Update,Not Updated,Nuk është përditësuar
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106,"There are inconsistencies between the rate, no of shares and the amount calculated","Ka mospërputhje në mes të normës, jo të aksioneve dhe shumës së llogaritur"
apps/erpnext/erpnext/setup/doctype/company/company.js +89,Please re-type company name to confirm,Ju lutem ri-lloj emri i kompanisë për të konfirmuar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +228,Total Outstanding Amt,Outstanding Amt Total
DocType: Journal Entry,Printing Settings,Printime Cilësimet
DocType: Employee Advance,Advance Account,Llogaria paraprake
DocType: Job Offer,Job Offer Terms,Termat e ofertës së punës
DocType: Sales Invoice,Include Payment (POS),Përfshijnë Pagesa (POS)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Debiti i përgjithshëm duhet të jetë e barabartë me totalin e kredisë. Dallimi është {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Automobilistik
DocType: Vehicle,Insurance Company,Kompania e sigurimeve
DocType: Asset Category Account,Fixed Asset Account,Llogaria Fixed Asset
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +424,Variable,variabël
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Nga dorëzim Shënim
DocType: Chapter,Members,Anëtarët
DocType: Student,Student Email Address,Student Email Adresa
DocType: Item,Hub Warehouse,Magazina Hub
DocType: Assessment Plan,From Time,Nga koha
DocType: Hotel Settings,Hotel Settings,Rregullimet e hotelit
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Në magazinë:
DocType: Notification Control,Custom Message,Custom Mesazh
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investimeve Bankare
DocType: Purchase Invoice,input,të dhëna
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Cash ose Banka Llogaria është e detyrueshme për të bërë hyrjen e pagesës
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Adresa Student
DocType: Purchase Invoice,Price List Exchange Rate,Lista e Çmimeve Exchange Rate
apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Numri i llogarisë {0} që përdoret tashmë në llogarinë {1}
DocType: GoCardless Mandate,Mandate,mandat
DocType: POS Profile,POS Profile Name,Emri i Profilit POS
DocType: Hotel Room Reservation,Booked,i rezervuar
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxLib,CompAuxLib
DocType: Purchase Invoice Item,Rate,Normë
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Mjek praktikant
DocType: Delivery Stop,Address Name,adresa Emri
DocType: Stock Entry,From BOM,Nga bom
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639,Splitting {0} units of {1},Ndarja e {0} njësive të {1}
DocType: Assessment Code,Assessment Code,Kodi i vlerësimit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Themelor
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Transaksionet e aksioneve para {0} janë të ngrira
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Ju lutem klikoni në &quot;Generate Listën &#39;
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,"Referenca Nuk është e detyrueshme, nëse keni hyrë Reference Data"
DocType: Bank Reconciliation Detail,Payment Document,Dokumenti pagesa
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Gabim gjatë vlerësimit të formulës së kritereve
apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Date of Joining must be greater than Date of Birth,Data e bashkuar duhet të jetë më i madh se Data e lindjes
DocType: Salary Slip,Salary Structure,Struktura e pagave
DocType: Account,Bank,Banka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Linjë ajrore
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853,Issue Material,Materiali çështje
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Ndodhi një gabim gjatë krijimit të përsëritjes
DocType: Material Request Item,For Warehouse,Për Magazina
DocType: Employee,Offer Date,Oferta Data
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Citate
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.,Ju jeni në offline mode. Ju nuk do të jetë në gjendje për të rifreskoni deri sa të ketë rrjet.
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Nuk Grupet Student krijuar.
DocType: Purchase Invoice Item,Serial No,Serial Asnjë
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Shuma mujore e pagesës nuk mund të jetë më e madhe se Shuma e Kredisë
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Ju lutemi shkruani maintaince Detaje parë
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Rreshti # {0}: Data e pritshme e dorëzimit nuk mund të jetë para datës së porosisë së blerjes
DocType: Purchase Invoice,Print Language,Print Gjuha
DocType: Salary Slip,Total Working Hours,Gjithsej Orari i punës
DocType: Sales Invoice,Customer PO Details,Detajet e Klientit
DocType: Subscription,Next Schedule Date,Data e ardhshme e orarit
DocType: Stock Entry,Including items for sub assemblies,Duke përfshirë edhe artikuj për nën kuvendet
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Llogaria e hapjes së përkohshme
apps/erpnext/erpnext/accounts/page/pos/pos.js +1964,Enter value must be positive,Shkruani Vlera duhet të jetë pozitiv
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446,All Territories,Të gjitha Territoret
apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49,Add Multiple Tasks,Shto detyra të shumëfishta
DocType: Purchase Invoice,Items,Artikuj
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,Studenti është regjistruar tashmë.
DocType: Fiscal Year,Year Name,Viti Emri
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241,There are more holidays than working days this month.,Ka më shumë pushimet sesa ditëve pune këtë muaj.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +100,PDC/LC Ref,PDC / LC Ref
DocType: Product Bundle Item,Product Bundle Item,Produkt Bundle Item
DocType: Sales Partner,Sales Partner Name,Emri Sales Partner
apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Kërkesën për kuotimin
DocType: Payment Reconciliation,Maximum Invoice Amount,Shuma maksimale Faturë
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,hematologjisë
DocType: Normal Test Items,Normal Test Items,Artikujt e Testimit Normal
DocType: Student Language,Student Language,Student Gjuha
apps/erpnext/erpnext/config/selling.py +23,Customers,Klientët
DocType: Cash Flow Mapping,Is Working Capital,Është Kapitali Punues
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Order / Quot%
apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Regjistro Pacientët e Vazhdueshëm
DocType: Fee Schedule,Institution,institucion
DocType: Asset,Partially Depreciated,amortizuar pjesërisht
DocType: Issue,Opening Time,Koha e hapjes
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89,From and To dates required,Nga dhe në datat e kërkuara
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Letrave me Vlerë dhe Shkëmbimeve të Mallrave
apps/erpnext/erpnext/stock/doctype/item/item.py +689,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Default njësinë e matjes për Varianti &#39;{0}&#39; duhet të jetë i njëjtë si në Template &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Llogaritur bazuar në
DocType: Delivery Note Item,From Warehouse,Nga Magazina
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Asnjë punonjës për kriteret e përmendura
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955,No Items with Bill of Materials to Manufacture,Nuk Items me faturën e materialeve të Prodhimi
DocType: Hotel Settings,Default Customer,Customer Default
DocType: Assessment Plan,Supervisor Name,Emri Supervisor
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Mos konfirmoni nëse emërimi është krijuar për të njëjtën ditë
DocType: Program Enrollment Course,Program Enrollment Course,Program Regjistrimi Kursi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +165,Make Sample Retention Stock Entry,Bëni regjistrimin e stoqeve të mostrës
DocType: Purchase Taxes and Charges,Valuation and Total,Vlerësimi dhe Total
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Scorecards
DocType: Employee,This will restrict user access to other employee records,Kjo do të kufizojë qasjen e përdoruesit në të dhënat e punonjësve të tjerë
DocType: Tax Rule,Shipping City,Shipping Qyteti
DocType: Notification Control,Customize the Notification,Customize Njoftimin
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Cash Flow from Operations,Cash Flow nga operacionet
DocType: Purchase Invoice,Shipping Rule,Rregulla anijeve
DocType: Patient Relation,Spouse,bashkëshort
DocType: Lab Test Groups,Add Test,Shto Test
DocType: Manufacturer,Limited to 12 characters,Kufizuar në 12 karaktere
DocType: Journal Entry,Print Heading,Printo Kreu
apps/erpnext/erpnext/config/stock.py +150,Delivery Trip service tours to customers.,Shërbimet e udhëtimit të udhëtimit për klientët.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Gjithsej nuk mund të jetë zero
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,&quot;Ditët Që Rendit Fundit&quot; duhet të jetë më e madhe se ose e barabartë me zero
DocType: Plant Analysis Criteria,Maximum Permissible Value,Vlera maksimale e lejuar
DocType: Journal Entry Account,Employee Advance,Advance punonjës
DocType: Payroll Entry,Payroll Frequency,Payroll Frekuenca
DocType: Lab Test Template,Sensitivity,ndjeshmëri
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941,Raw Material,Raw Material
DocType: Leave Application,Follow via Email,Ndiqni nëpërmjet Email
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Bimët dhe makineri
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Shuma e taksave Pas Shuma ulje
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Daily Settings Përmbledhje Work
apps/erpnext/erpnext/controllers/buying_controller.py +463,Please enter Reqd by Date,Ju lutemi shkruani Reqd by Date
DocType: Payment Entry,Internal Transfer,Transfer të brendshme
DocType: Asset Maintenance,Maintenance Tasks,Detyrat e Mirmbajtjes
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Ose Qty objektiv ose shuma e synuar është e detyrueshme
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Posting Date first,"Ju lutem, përzgjidhni datën e postimit parë"
apps/erpnext/erpnext/public/js/account_tree_grid.js +209,Opening Date should be before Closing Date,Hapja Data duhet të jetë para datës së mbylljes
DocType: Leave Control Panel,Carry Forward,Bart
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Qendra Kosto me transaksionet ekzistuese nuk mund të konvertohet në Ledger
DocType: Department,Days for which Holidays are blocked for this department.,Ditë për të cilat Festat janë bllokuar për këtë departament.
DocType: GoCardless Mandate,ERPNext Integrations,Integrimet ERPNext
DocType: Crop Cycle,Detected Disease,Zbulohet Sëmundja
,Produced,Prodhuar
DocType: Item,Item Code for Suppliers,Item Kodi për Furnizuesit
DocType: Issue,Raised By (Email),Ngritur nga (Email)
DocType: Training Event,Trainer Name,Emri trajner
DocType: Mode of Payment,General,I përgjithshëm
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Komunikimi i fundit
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Nuk mund të zbres kur kategori është për &#39;vlerësimit&#39; ose &#39;Vlerësimit dhe Total &quot;
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +240,Serial Nos Required for Serialized Item {0},Serial Nos kërkuar për Item serialized {0}
apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Pagesat ndeshje me faturat
DocType: Journal Entry,Bank Entry,Banka Hyrja
DocType: Authorization Rule,Applicable To (Designation),Për të zbatueshme (Përcaktimi)
,Profitability Analysis,Analiza e profitabilitetit
DocType: Fees,Student Email,Student Email
DocType: Supplier,Prevent POs,Parandalimi i ZP-ve
DocType: Patient,"Allergies, Medical and Surgical History","Alergji, histori mjekësore dhe kirurgjikale"
apps/erpnext/erpnext/templates/generators/item.html +77,Add to Cart,Futeni në kosh
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Grupi Nga
DocType: Guardian,Interests,interesat
apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Enable / disable monedhave.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105,Dr {0} on Half day Leave on {1},Dr {0} në Ditën e Gjashtë Ditëve në {1}
DocType: Production Plan,Get Material Request,Get materiale Kërkesë
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Shpenzimet postare
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Gjithsej (Amt)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Entertainment &amp; Leisure
,Item Variant Details,Detajet e variantit të artikullit
DocType: Quality Inspection,Item Serial No,Item Nr Serial
apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Krijo Records punonjësve
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,I pranishëm Total
apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Deklaratat e kontabilitetit
DocType: Drug Prescription,Hour,Orë
DocType: Restaurant Order Entry,Last Sales Invoice,Fatura e shitjeve të fundit
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +793,Please select Qty against item {0},Ju lutem zgjidhni Qty kundër sendit {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,Jo i ri Serial nuk mund të ketë depo. Magazina duhet të përcaktohen nga Bursa e hyrjes ose marrjes Blerje
DocType: Lead,Lead Type,Lead Type
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114,You are not authorized to approve leaves on Block Dates,Ju nuk jeni i autorizuar të miratojë lë në datat Block
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394,All these items have already been invoiced,Të gjitha këto objekte janë tashmë faturohen
DocType: Company,Monthly Sales Target,Synimi i shitjeve mujore
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Mund të miratohet nga {0}
DocType: Hotel Room,Hotel Room Type,Lloji i dhomës së hotelit
DocType: Item,Default Material Request Type,Default Kërkesa Tipe Materiali
DocType: Supplier Scorecard,Evaluation Period,Periudha e vlerësimit
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,I panjohur
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954,Work Order not created,Rendi i punës nuk është krijuar
DocType: Shipping Rule,Shipping Rule Conditions,Shipping Rregulla Kushte
DocType: Purchase Invoice,Export Type,Lloji i eksportit
DocType: Salary Slip Loan,Salary Slip Loan,Kredia për paga
DocType: BOM Update Tool,The new BOM after replacement,BOM ri pas zëvendësimit
,Point of Sale,Pika e Shitjes
DocType: Payment Entry,Received Amount,Shuma e marrë
DocType: Patient,Widow,e ve
DocType: GST Settings,GSTIN Email Sent On,GSTIN Email dërguar më
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / rënie nga Guardian
DocType: Crop,Planting UOM,Mbjellja e UOM
DocType: Account,Tax,Tatim
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,i pashënuar
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Përmbledhja e hapjes së faturave
DocType: Education Settings,Education Manager,Menaxher i Arsimit
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Gjatësia minimale në mes të çdo impianti në fushë për rritje optimale
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Batched Item {0} nuk mund të përditësohet duke përdorur Stock pajtimit, në vend që të përdorin Stock Hyrja"
DocType: Quality Inspection,Report Date,Raporti Data
DocType: Student,Middle Name,emri i dytë
DocType: C-Form,Invoices,Faturat
DocType: Water Analysis,Type of Sample,Lloji i mostrës
DocType: Batch,Source Document Name,Dokumenti Burimi Emri
DocType: Production Plan,Get Raw Materials For Production,Merrni lëndë të para për prodhim
DocType: Job Opening,Job Title,Titulli Job
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} tregon se {1} nuk do të japë një kuotim, por të gjitha artikujt \ janë cituar. Përditësimi i statusit të kuotës RFQ."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1184,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Mostrat maksimale - {0} tashmë janë ruajtur për Serinë {1} dhe Pikën {2} në Serinë {3}.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Type in Buying Settings.,Vendosni llojin e furnizuesit në parametrat e blerjes.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Përditëso Kostoja e BOM-it automatikisht
DocType: Lab Test,Test Name,Emri i testit
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Krijo Përdoruesit
apps/erpnext/erpnext/utilities/user_progress.py +147,Gram,gram
DocType: Supplier Scorecard,Per Month,Në muaj
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433,Quantity to Manufacture must be greater than 0.,Sasi të Prodhimi duhet të jetë më e madhe se 0.
DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Llogarit skemën e zhvlerësimit të shtrirë në bazë të vitit fiskal
apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Vizitoni raport për thirrjen e mirëmbajtjes.
DocType: Stock Entry,Update Rate and Availability,Update Vlerësoni dhe Disponueshmëria
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.,"Përqindja ju keni të drejtë për të marrë ose të japë më shumë kundër sasi të urdhëruar. Për shembull: Nëse ju keni urdhëruar 100 njësi. dhe Allowance juaj është 10%, atëherë ju keni të drejtë për të marrë 110 njësi."
DocType: POS Customer Group,Customer Group,Grupi Klientit
apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),New ID Batch (Fakultativ)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Llogari shpenzim është i detyrueshëm për pikën {0}
DocType: BOM,Website Description,Website Përshkrim
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47,Net Change in Equity,Ndryshimi neto në ekuitetit
apps/erpnext/erpnext/assets/doctype/asset/asset.py +220,Please cancel Purchase Invoice {0} first,Ju lutemi anuloni Blerje Faturën {0} parë
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","Adresa Email duhet të jetë unike, tashmë ekziston për {0}"
DocType: Serial No,AMC Expiry Date,AMC Data e Mbarimit
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880,Receipt,Faturë
,Sales Register,Shitjet Regjistrohu
DocType: Daily Work Summary Group,Send Emails At,Dërgo email Në
DocType: Quotation,Quotation Lost Reason,Citat Humbur Arsyeja
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381,Transaction reference no {0} dated {1},reference Transaction asnjë {0} datë {1}
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Nuk ka asgjë për të redaktuar.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +499,Form View,Shiko formularin
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Përmbledhje për këtë muaj dhe aktivitetet në pritje
apps/erpnext/erpnext/utilities/user_progress.py +248,"Add users to your organization, other than yourself.","Shtojini përdoruesit në organizatën tuaj, përveç vetes."
DocType: Customer Group,Customer Group Name,Emri Grupi Klientit
apps/erpnext/erpnext/public/js/pos/pos.html +109,No Customers yet!,Nuk ka Konsumatorët akoma!
apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Pasqyra Cash Flow
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473,No material request created,Asnjë kërkesë materiale nuk është krijuar
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Sasia huaja nuk mund të kalojë sasi maksimale huazimin e {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Liçensë
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491,Please remove this Invoice {0} from C-Form {1},Ju lutem hiqni këtë Faturë {0} nga C-Form {1}
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Ju lutem, përzgjidhni Mbaj përpara në qoftë se ju të dëshironi që të përfshijë bilancit vitit të kaluar fiskal lë të këtij viti fiskal"
DocType: GL Entry,Against Voucher Type,Kundër Voucher Type
DocType: Physician,Phone (R),Telefoni (R)
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56,Time slots added,Hapat e kohës shtohen
DocType: Item,Attributes,Atributet
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Aktivizo modelin
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,"Ju lutem, jepini të anullojë Llogari"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Rendit fundit Date
DocType: Patient,B Negative,B Negative
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Statusi i mirëmbajtjes duhet të anulohet ose të përfundohet për t&#39;u dërguar
DocType: Hotel Room,Hotel Room,Dhome hoteli
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Llogaria {0} nuk i takon kompanisë {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884,Serial Numbers in row {0} does not match with Delivery Note,Numrat serial në rresht {0} nuk përputhet me shpërndarjen Note
DocType: Student,Guardian Details,Guardian Details
DocType: C-Form,C-Form,C-Forma
apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Pjesëmarrja për të punësuarit të shumta
DocType: Agriculture Task,Start Day,Filloni Ditën
DocType: Vehicle,Chassis No,Shasia No
DocType: Payment Request,Initiated,Iniciuar
DocType: Production Plan Item,Planned Start Date,Planifikuar Data e Fillimit
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +622,Please select a BOM,Ju lutem zgjidhni një BOM
DocType: Purchase Invoice,Availed ITC Integrated Tax,Availed ITC Integrated Tax
DocType: Serial No,Creation Document Type,Krijimi Dokumenti Type
DocType: Project Task,View Timesheet,Shiko pamjen time
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Data e përfundimit duhet të jetë më e madhe se data e fillimit
DocType: Leave Type,Is Encash,Është marr me para në dorë
DocType: Leave Allocation,New Leaves Allocated,Gjethet e reja të alokuar
apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Të dhënat Project-i mençur nuk është në dispozicion për Kuotim
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Mbarojeni
DocType: Project,Expected End Date,Pritet Data e Përfundimit
DocType: Budget Account,Budget Amount,Shuma buxheti
DocType: Donor,Donor Name,Emri i donatorit
DocType: Appraisal Template,Appraisal Template Title,Vlerësimi Template Titulli
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},Nga Data {0} për Employee {1} nuk mund të jetë para Data bashkuar punonjësit {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Komercial
DocType: Patient,Alcohol Current Use,Përdorimi aktual i alkoolit
DocType: Student Admission Program,Student Admission Program,Programi i pranimit të studentëve
DocType: Payment Entry,Account Paid To,Llogaria Paid To
DocType: Item Alternative,Alternative Item Name,Emri i artikullit alternativ
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Prind Item {0} nuk duhet të jetë një Stock Item
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466,"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>",Nuk mund të paraqiste ndonjë gabim pagese <br> \ Arsyet e mundshme: <br> \ 1. Pagesa neto është më e vogël se 0. <br> \ 2. Adresa e emailit e kompanisë e përcaktuar në zotëruesin e punonjësve nuk është e vlefshme. <br>
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Të gjitha prodhimet ose shërbimet.
DocType: Expense Claim,More Details,Më shumë detaje
DocType: Supplier Quotation,Supplier Address,Furnizuesi Adresa
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} Buxheti për Llogarinë {1} kundër {2} {3} është {4}. Ajo do të kalojë nga {5}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695,Row {0}# Account must be of type 'Fixed Asset',Row {0} # Llogaria duhet të jenë të tipit &quot;Asset fikse &#39;
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Nga Qty
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,dhe unchcked Disabled në
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41,Series is mandatory,Seria është i detyrueshëm
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Shërbimet Financiare
DocType: Student Sibling,Student ID,ID Student
apps/erpnext/erpnext/public/js/hub/hub_form.js +445,Supplier Email,Email Furnizues
apps/erpnext/erpnext/config/projects.py +51,Types of activities for Time Logs,Llojet e aktiviteteve për Koha Shkrime
DocType: Opening Invoice Creation Tool,Sales,Shitjet
DocType: Stock Entry Detail,Basic Amount,Shuma bazë
DocType: Training Event,Exam,Provimi
DocType: Complaint,Complaint,ankim
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462,Warehouse required for stock Item {0},Magazina e nevojshme për aksioneve Item {0}
DocType: Leave Allocation,Unused leaves,Gjethet e papërdorura
DocType: Patient,Alcohol Past Use,Përdorimi i mëparshëm i alkoolit
DocType: Fertilizer Content,Fertilizer Content,Përmbajtja e plehut
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187,Cr,Cr
DocType: Project Update,Problematic/Stuck,Problematike / Stuck
DocType: Tax Rule,Billing State,Shteti Faturimi
DocType: Share Transfer,Transfer,Transferim
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Work Order {0} must be cancelled before cancelling this Sales Order,Urdhri i Punës {0} duhet të anulohet para se të anulohet ky Urdhër Shitje
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917,Fetch exploded BOM (including sub-assemblies),Fetch bom shpërtheu (përfshirë nën-kuvendet)
DocType: Authorization Rule,Applicable To (Employee),Për të zbatueshme (punonjës)
apps/erpnext/erpnext/controllers/accounts_controller.py +137,Due Date is mandatory,Për shkak Data është e detyrueshme
apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Rritja për Atributit {0} nuk mund të jetë 0
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Dhomat e rezervuara
apps/erpnext/erpnext/crm/doctype/lead/lead.py +57,Ends On date cannot be before Next Contact Date.,Fundi Në datën nuk mund të jetë përpara datës së ardhshme të kontaktit.
DocType: Journal Entry,Pay To / Recd From,Për të paguar / Recd Nga
DocType: Naming Series,Setup Series,Setup Series
DocType: Payment Reconciliation,To Invoice Date,Në faturën Date
DocType: Shareholder,Contact HTML,Kontakt HTML
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Tarifa e regjistrimit nuk mund të jetë Zero
DocType: Disease,Treatment Period,Periudha e Trajtimit
apps/erpnext/erpnext/education/api.py +338,Result already Submitted,Rezultati është paraqitur
apps/erpnext/erpnext/controllers/buying_controller.py +170,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Magazina e rezervuar është e detyrueshme për artikullin {0} në lëndët e para të furnizuara
,Inactive Customers,Konsumatorët jo aktive
DocType: Student Admission Program,Maximum Age,Mosha maksimale
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,Ju lutemi prisni 3 ditë para se të dërgoni përkujtuesin.
DocType: Landed Cost Voucher,LCV,LCV
DocType: Landed Cost Voucher,Purchase Receipts,Pranimet Blerje
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Si Rregulla e Çmimeve aplikohet?
DocType: Stock Entry,Delivery Note No,Ofrimit Shënim Asnjë
DocType: Cheque Print Template,Message to show,Mesazhi për të treguar
apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Me pakicë
DocType: Student Attendance,Absent,Që mungon
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Bundle produkt
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,Nuk mund të gjej rezultatin duke filluar nga {0}. Duhet të kesh pikët e qendrës që mbulojnë 0 deri në 100
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Row {0}: referencë Invalid {1}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Blerje taksat dhe tatimet Template
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}: Ose debiti ose shuma e kredisë është e nevojshme për {2}
DocType: GL Entry,Remarks,Vërejtje
DocType: Hotel Room Amenity,Hotel Room Amenity,Salla e hotelit
DocType: Payment Entry,Account Paid From,Llogaria e paguar nga
DocType: Purchase Order Item Supplied,Raw Material Item Code,Raw Material Item Code
DocType: Task,Parent Task,Detyra e Prindit
DocType: Journal Entry,Write Off Based On,Shkruani Off bazuar në
apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,bëni Lead
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Print dhe Stationery
DocType: Stock Settings,Show Barcode Field,Trego Barcode Field
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809,Send Supplier Emails,Dërgo email furnizuesi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Paga përpunuar tashmë për periudhën ndërmjet {0} dhe {1}, Lini periudha e aplikimit nuk mund të jetë në mes të këtyre datave."
DocType: Chapter Member,Leave Reason,Lëreni Arsyen
DocType: Guardian Interest,Guardian Interest,Guardian Interesi
DocType: Volunteer,Availability,disponueshmëri
apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Vendosni vlerat e parazgjedhur për faturat POS
apps/erpnext/erpnext/config/hr.py +182,Training,stërvitje
DocType: Project,Time to send,Koha për të dërguar
DocType: Timesheet,Employee Detail,Detail punonjës
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Dita datën tjetër dhe përsëritet në ditën e Muajit duhet të jetë e barabartë
DocType: Lab Prescription,Test Code,Kodi i Testimit
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Parametrat për faqen e internetit
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},Kerkesat e kerkesave nuk lejohen per {0} per shkak te nje standarti te rezultateve te {1}
DocType: Job Offer,Awaiting Response,Në pritje të përgjigjes
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +82,Above,Sipër
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1489,Total Amount {0},Shuma totale {0}
apps/erpnext/erpnext/controllers/item_variant.py +306,Invalid attribute {0} {1},atribut i pavlefshëm {0} {1}
DocType: Supplier,Mention if non-standard payable account,Përmend në qoftë se llogaria jo-standarde pagueshme
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',Ju lutemi zgjidhni grupin e vlerësimit të tjera se &quot;të gjitha grupet e vlerësimit &#39;
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Rresht {0}: Qendra kosto është e nevojshme për një artikull {1}
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureDate,EcritureDate
apps/erpnext/erpnext/healthcare/doctype/physician/physician_dashboard.py +6,This is based on transactions against this Physician.,Kjo bazohet në transaksione kundër këtij Mjeku.
DocType: Training Event Employee,Optional,fakultativ
DocType: Salary Slip,Earning & Deduction,Fituar dhe Zbritje
DocType: Agriculture Analysis Criteria,Water Analysis,Analiza e ujit
DocType: Chapter,Region,Rajon
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Fakultative. Ky rregullim do të përdoret për të filtruar në transaksionet e ndryshme.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110,Negative Valuation Rate is not allowed,Negativ Rate Vlerësimi nuk është e lejuar
DocType: Holiday List,Weekly Off,Weekly Off
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Rifresko Analizimin e Lidhur
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Për shembull 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Fitimi / Humbja e Përkohshme (Credit)
DocType: Sales Invoice,Return Against Sales Invoice,Kthehu kundër Sales Faturë
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Pika 5
DocType: Serial No,Creation Time,Krijimi Koha
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Të ardhurat totale
DocType: Patient,Other Risk Factors,Faktorë të tjerë të rrezikut
DocType: Sales Invoice,Product Bundle Help,Produkt Bundle Ndihmë
,Monthly Attendance Sheet,Mujore Sheet Pjesëmarrja
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15,No record found,Nuk ka Record gjetur
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Kostoja e asetit braktiset
apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Qendra Kosto është e detyrueshme për Item {2}
DocType: Vehicle,Policy No,Politika No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686,Get Items from Product Bundle,Të marrë sendet nga Bundle produktit
DocType: Asset,Straight Line,Vijë e drejtë
DocType: Project User,Project User,User Project
apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,Split,ndarje
DocType: GL Entry,Is Advance,Është Advance
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Pjesëmarrja Nga Data dhe Pjesëmarrja deri më sot është e detyrueshme
apps/erpnext/erpnext/controllers/buying_controller.py +157,Please enter 'Is Subcontracted' as Yes or No,Ju lutemi shkruani &#39;është nënkontraktuar&#39; si Po apo Jo
DocType: Item,Default Purchase Unit of Measure,Njësia e Blerjes së Parazgjedhur të Masës
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Data e fundit Komunikimi
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Data e fundit Komunikimi
DocType: Sales Team,Contact No.,Kontakt Nr
DocType: Bank Reconciliation,Payment Entries,Entries pagesës
DocType: Land Unit,Land Unit Details,Detajet e Njësisë së Tokës
DocType: Land Unit,Latitude,gjerësi
DocType: Work Order,Scrap Warehouse,Scrap Magazina
DocType: Work Order,Check if material transfer entry is not required,Kontrolloni nëse hyrja transferimi material nuk është e nevojshme
DocType: Program Enrollment Tool,Get Students From,Get Studentët nga
apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,Publikojnë artikuj në faqen
apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Grupi nxënësit tuaj në tufa
DocType: Authorization Rule,Authorization Rule,Rregulla Autorizimi
DocType: POS Profile,Offline POS Section,POS Seksioni Offline
DocType: Sales Invoice,Terms and Conditions Details,Termat dhe Kushtet Detajet
apps/erpnext/erpnext/templates/generators/item.html +100,Specifications,Specifikimet
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Shitjet Taksat dhe Tarifat Stampa
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Total (Credit)
DocType: Repayment Schedule,Payment Date,Data e pagesës
apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,New Batch Qty
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Veshmbathje &amp; Aksesorë
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.,Nuk mund të zgjidhej funksioni i rezultateve të peshuara. Sigurohuni që formula është e vlefshme.
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Numri i Rendit
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner që do të tregojnë në krye të listës së produktit.
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Specifikoni kushtet për të llogaritur shumën e anijeve
DocType: Program Enrollment,Institute's Bus,Autobus i Institutit
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Roli i lejohet të Accounts ngrirë dhe Edit ngrira gjitha
DocType: Supplier Scorecard Scoring Variable,Path,Rrugë
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,Nuk mund të konvertohet Qendra Kosto të librit si ajo ka nyje fëmijë
DocType: Production Plan,Total Planned Qty,Totali i planifikuar
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,Opening Value,Vlera e hapjes
DocType: Salary Detail,Formula,formulë
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +48,Serial #,Serial #
DocType: Lab Test Template,Lab Test Template,Modeli i testimit të laboratorit
apps/erpnext/erpnext/setup/doctype/company/company.py +181,Sales Account,Llogaria e Shitjes
DocType: Purchase Invoice Item,Total Weight,Pesha Totale
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Komisioni për Shitje
DocType: Job Offer Term,Value / Description,Vlera / Përshkrim
apps/erpnext/erpnext/controllers/accounts_controller.py +630,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} nuk mund të paraqitet, ajo është tashmë {2}"
DocType: Tax Rule,Billing Country,Faturimi Vendi
DocType: Purchase Order Item,Expected Delivery Date,Pritet Data e dorëzimit
DocType: Restaurant Order Entry,Restaurant Order Entry,Regjistrimi i Restorantit
apps/erpnext/erpnext/accounts/general_ledger.py +134,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debi dhe Kredi jo të barabartë për {0} # {1}. Dallimi është {2}.
DocType: Asset Maintenance Task,Assign To Name,Cakto për emrin
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Shpenzimet Argëtim
DocType: Hub Settings,Enabled Users,Përdoruesit e lejuar
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +99,Make Material Request,Bëni materiale Kërkesë
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Hapur Artikull {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Shitjet Faturë {0} duhet të anulohet para anulimit këtë Radhit Sales
DocType: Consultation,Age,Moshë
DocType: Sales Invoice Timesheet,Billing Amount,Shuma Faturimi
DocType: Cash Flow Mapping,Select Maximum Of 1,Përzgjedh maksimumin e 1
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Sasia e pavlefshme specifikuar për pika {0}. Sasia duhet të jetë më i madh se 0.
DocType: Company,Default Employee Advance Account,Llogaria paraprake e punonjësve
apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Aplikimet për leje.
apps/erpnext/erpnext/accounts/doctype/account/account.py +164,Account with existing transaction can not be deleted,Llogaria me transaksion ekzistues nuk mund të fshihet
DocType: Vehicle,Last Carbon Check,Last Kontrolloni Carbon
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Shpenzimet ligjore
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +145,Please select quantity on row ,Ju lutemi zgjidhni sasinë në rresht
apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Bëni hapjen e shitjeve dhe blerjeve të faturave
DocType: Purchase Invoice,Posting Time,Posting Koha
DocType: Timesheet,% Amount Billed,% Shuma faturuar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Shpenzimet telefonike
DocType: Sales Partner,Logo,Logo
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Kontrolloni këtë në qoftë se ju doni për të detyruar përdoruesit për të zgjedhur një seri përpara se të kryeni. Nuk do të ketë parazgjedhur në qoftë se ju kontrolloni këtë.
apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Serial No {0},Nuk ka artikull me Serial Nr {0}
DocType: Email Digest,Open Notifications,Njoftimet Hapur
DocType: Payment Entry,Difference Amount (Company Currency),Dallimi Shuma (Company Valuta)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Shpenzimet direkte
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Të ardhurat New Customer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Shpenzimet e udhëtimit
DocType: Maintenance Visit,Breakdown,Avari
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Shto fushën me parapagesë në doktorin {0}
apps/erpnext/erpnext/controllers/accounts_controller.py +822,Account: {0} with currency: {1} can not be selected,Llogaria: {0} me monedhën: {1} nuk mund të zgjidhen
DocType: Purchase Receipt Item,Sample Quantity,Sasia e mostrës
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Përditësimi i çmimit BOM automatikisht nëpërmjet Planifikuesit, bazuar në normën e fundit të vlerësimit / normën e çmimeve / normën e fundit të blerjes së lëndëve të para."
DocType: Bank Reconciliation Detail,Cheque Date,Çek Data
apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Llogaria {0}: llogari Parent {1} nuk i përkasin kompanisë: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +106,Successfully deleted all transactions related to this company!,Sukses të fshihen të gjitha transaksionet që lidhen me këtë kompani!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,As on Date,Si në Data
DocType: Appraisal,HR,HR
DocType: Program Enrollment,Enrollment Date,regjistrimi Date
DocType: Healthcare Settings,Out Patient SMS Alerts,Nga paralajmërimet e pacientit me SMS
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Provë
apps/erpnext/erpnext/config/hr.py +115,Salary Components,Komponentet e pagave
DocType: Program Enrollment Tool,New Academic Year,New Year akademik
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811,Return / Credit Note,Kthimi / Credit Note
DocType: Stock Settings,Auto insert Price List rate if missing,Auto insert Shkalla Lista e Çmimeve nëse mungon
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +124,Total Paid Amount,Gjithsej shuma e paguar
DocType: GST Settings,B2C Limit,Kufizimi B2C
DocType: Work Order Item,Transferred Qty,Transferuar Qty
apps/erpnext/erpnext/config/learn.py +11,Navigating,Vozitja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Planifikim
DocType: Share Balance,Issued,Lëshuar
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Aktiviteti Student
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Furnizuesi Id
DocType: Payment Request,Payment Gateway Details,Pagesa Gateway Details
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276,Quantity should be greater than 0,Sasia duhet të jetë më e madhe se 0
DocType: Journal Entry,Cash Entry,Hyrja Cash
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,nyjet e fëmijëve mund të krijohen vetëm me nyje të tipit &#39;Grupit&#39;
DocType: Leave Application,Half Day Date,Half Day Date
DocType: Academic Year,Academic Year Name,Emri akademik Year
DocType: Sales Partner,Contact Desc,Kontakt Përshkrimi
apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Lloji i lë si rastësor, të sëmurë etj"
DocType: Email Digest,Send regular summary reports via Email.,Dërgo raporte të rregullta përmbledhje nëpërmjet Email.
DocType: Payment Entry,PE-,pe-
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282,Please set default account in Expense Claim Type {0},Ju lutemi të vendosur llogarinë e paracaktuar në Expense kërkesën Lloji {0}
DocType: Assessment Result,Student Name,Emri i studentit
DocType: Brand,Item Manager,Item Menaxher
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Payroll pagueshme
DocType: Buying Settings,Default Supplier Type,Gabim Furnizuesi Type
DocType: Plant Analysis,Collection Datetime,Data e mbledhjes
DocType: Work Order,Total Operating Cost,Gjithsej Kosto Operative
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Shënim: Item {0} hyrë herë të shumta
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Të gjitha kontaktet.
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Shkurtesa kompani
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47,User {0} does not exist,Përdoruesi {0} nuk ekziston
DocType: Payment Term,Day(s) after invoice date,Ditë (a) pas datës së faturës
DocType: Payment Schedule,Payment Schedule,Orari i pagesës
DocType: Subscription,SUB-,nën-
DocType: Item Attribute Value,Abbreviation,Shkurtim
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195,Payment Entry already exists,Pagesa Hyrja tashmë ekziston
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Jo Authroized që nga {0} tejkalon kufijtë
apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Mjeshtër paga template.
apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,patologji
DocType: Restaurant Order Entry,Restaurant Table,Tavolina e restorantit
DocType: Hotel Room,Hotel Manager,Menaxheri i Hotelit
DocType: Leave Type,Max Days Leave Allowed,Max Ditët Pushimi Lejohet
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Set Rregulla Taksa për shopping cart
DocType: Purchase Invoice,Taxes and Charges Added,Taksat dhe Tarifat Shtuar
,Sales Funnel,Gyp Sales
apps/erpnext/erpnext/setup/doctype/company/company.py +49,Abbreviation is mandatory,Shkurtim është i detyrueshëm
DocType: Project,Task Progress,Task Progress
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Qerre
,Qty to Transfer,Qty të transferojë
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Kuotat për kryeson apo klientët.
DocType: Stock Settings,Role Allowed to edit frozen stock,Roli i lejuar për të redaktuar aksioneve të ngrirë
,Territory Target Variance Item Group-Wise,Territori i synuar Varianca Item Grupi i urti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Të gjitha grupet e konsumatorëve
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,akumuluar mujore
apps/erpnext/erpnext/controllers/accounts_controller.py +783,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} është i detyrueshëm. Ndoshta rekord Currency Exchange nuk është krijuar për {1} të {2}.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44,Tax Template is mandatory.,Template tatimi është i detyrueshëm.
apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Llogaria {0}: llogari Parent {1} nuk ekziston
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Lista e Çmimeve Rate (Kompania Valuta)
DocType: Products Settings,Products Settings,Produkte Settings
,Item Price Stock,Çmimi i Artikullit
DocType: Lab Prescription,Test Created,Krijuar test
DocType: Healthcare Settings,Custom Signature in Print,Nënshkrimi me porosi në shtyp
DocType: Account,Temporary,I përkohshëm
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +114,Customer LPO No.,LPO Nr. I Klientit
DocType: Program,Courses,kurse
DocType: Monthly Distribution Percentage,Percentage Allocation,Alokimi Përqindja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Sekretar
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Nëse disable, &quot;me fjalë&quot; fushë nuk do të jetë i dukshëm në çdo transaksion"
DocType: Serial No,Distinct unit of an Item,Njësi të dallueshme nga një artikull
DocType: Supplier Scorecard Criteria,Criteria Name,Emri i kritereve
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295,Please set Company,Ju lutemi të vendosur Company
DocType: Pricing Rule,Buying,Blerje
apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Sëmundjet dhe plehrat
DocType: HR Settings,Employee Records to be created by,Të dhënat e punonjësve që do të krijohet nga
DocType: Patient,AB Negative,AB Negative
DocType: Sample Collection,SMPL-,SMPL-
DocType: POS Profile,Apply Discount On,Aplikoni zbritje në
DocType: Member,Membership Type,Lloji i Anëtarësimit
,Reqd By Date,Reqd By Date
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Kreditorët
DocType: Assessment Plan,Assessment Name,Emri i vlerësimit
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94,Show PDC in Print,Shfaq PDC në Print
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97,Row # {0}: Serial No is mandatory,Row # {0}: Asnjë Serial është i detyrueshëm
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Item Tatimore urti Detail
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Job Offer,Ofertë pune
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Shkurtesa Institute
,Item-wise Price List Rate,Pika-mençur Lista e Çmimeve Rate
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082,Supplier Quotation,Furnizuesi Citat
DocType: Quotation,In Words will be visible once you save the Quotation.,Me fjalë do të jetë i dukshëm një herë ju ruani Kuotim.
apps/erpnext/erpnext/utilities/transaction_base.py +164,Quantity ({0}) cannot be a fraction in row {1},Sasi ({0}) nuk mund të jetë një pjesë në rradhë {1}
DocType: Consultation,C-,C-
DocType: Attendance,ATT-,ATT-
apps/erpnext/erpnext/stock/doctype/item/item.py +492,Barcode {0} already used in Item {1},Barkodi {0} përdorur tashmë në pikën {1}
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Rregullat për të shtuar shpenzimet e transportit detar.
DocType: Hotel Room,Extra Bed Capacity,Kapaciteti shtesë shtrati
DocType: Item,Opening Stock,hapja Stock
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Konsumatorit është e nevojshme
DocType: Lab Test,Result Date,Data e Rezultatit
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +99,PDC/LC Date,Data PDC / LC
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} është e detyrueshme për Kthim
DocType: Purchase Order,To Receive,Për të marrë
apps/erpnext/erpnext/utilities/user_progress.py +252,user@example.com,user@example.com
DocType: Asset,Asset Owner,Pronar i aseteve
DocType: Employee,Personal Email,Personale Email
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Ndryshimi Total
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Nëse aktivizuar, sistemi do të shpallë shënimet e kontabilitetit për inventarizimin automatikisht."
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Brokerimi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195,Attendance for employee {0} is already marked for this day,Pjesëmarrja për {0} punonjësi është shënuar tashmë për këtë ditë
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",në minuta Përditësuar nëpërmjet &#39;Koha Identifikohu &quot;
DocType: Customer,From Lead,Nga Lead
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Urdhërat lëshuar për prodhim.
apps/erpnext/erpnext/public/js/account_tree_grid.js +65,Select Fiscal Year...,Zgjidh Vitin Fiskal ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567,POS Profile required to make POS Entry,POS Profilin nevojshme për të bërë POS Hyrja
DocType: Program Enrollment Tool,Enroll Students,regjistrohen Studentët
DocType: Lab Test,Approved Date,Data e Aprovuar
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Shitja Standard
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +205,Atleast one warehouse is mandatory,Atleast një depo është e detyrueshme
DocType: Serial No,Out of Warranty,Nga Garanci
DocType: BOM Update Tool,Replace,Zëvendësoj
apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Nuk ka produkte gjet.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} kundër Shitjeve Faturës {1}
DocType: Antibiotic,Laboratory User,Përdoruesi i Laboratorit
DocType: Sales Invoice,SINV-,SINV-
DocType: Request for Quotation Item,Project Name,Emri i Projektit
DocType: Customer,Mention if non-standard receivable account,Përmend në qoftë se jo-standarde llogari të arkëtueshme
DocType: Journal Entry Account,If Income or Expense,Nëse të ardhura ose shpenzime
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288,Select interest income account in employee loan {0},Zgjidh llogarinë e të ardhurave nga interesi në kredinë e punonjësve {0}
DocType: Work Order,Required Items,Items kërkuara
DocType: Stock Ledger Entry,Stock Value Difference,Vlera e aksioneve Diferenca
apps/erpnext/erpnext/config/learn.py +229,Human Resource,Burimeve Njerëzore
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Pajtimi Pagesa Pagesa
DocType: Disease,Treatment Task,Detyra e Trajtimit
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Pasuritë tatimore
DocType: BOM Item,BOM No,Bom Asnjë
DocType: Instructor,INS/,INS /
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,Journal Hyrja {0} nuk ka llogari {1} ose tashmë krahasohen me kupon tjetër
DocType: Item,Moving Average,Moving Mesatare
DocType: BOM Update Tool,The BOM which will be replaced,BOM i cili do të zëvendësohet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,Pajisje elektronike
DocType: Asset,Maintenance Required,Kërkohet Mirëmbajtja
DocType: Account,Debit,Debi
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,Lë duhet të ndahen në shumëfisha e 0.5
DocType: Work Order,Operation Cost,Operacioni Kosto
apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Ngarko pjesëmarrjen nga një skedar CSV
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Amt Outstanding
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Caqet e përcaktuara Item Grupi-mençur për këtë person të shitjes.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Stoqet Freeze vjetër se [Ditët]
apps/erpnext/erpnext/controllers/accounts_controller.py +600,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset është e detyrueshme për të aseteve fikse blerje / shitje
DocType: Asset Maintenance Team,Maintenance Team Name,Emri i ekipit të mirëmbajtjes
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.","Nëse dy ose më shumë Rregullat e Çmimeve janë gjetur në bazë të kushteve të mësipërme, Prioritet është aplikuar. Prioritet është një numër mes 0 deri ne 20, ndërsa vlera e parazgjedhur është zero (bosh). Numri më i lartë do të thotë se do të marrë përparësi nëse ka rregulla të shumta çmimeve me kushte të njëjta."
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,Klienti është i detyrueshëm nëse &quot;Mundësi Nga&quot; zgjidhet si Klient
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Viti Fiskal: {0} nuk ekziston
DocType: Currency Exchange,To Currency,Për të Valuta
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Lejo përdoruesit e mëposhtme të miratojë Dërgo Aplikacione për ditë bllok.
apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Llojet e shpenzimeve kërkesës.
apps/erpnext/erpnext/controllers/selling_controller.py +148,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Shitjen e normës për elementit {0} është më e ulët se saj {1}. Shitja e normës duhet të jetë atleast {2}
DocType: Item,Taxes,Tatimet
DocType: Purchase Invoice,capital goods,mallra kapitale
DocType: Purchase Invoice Item,Weight Per Unit,Pesha për njësi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Paguar dhe nuk dorëzohet
DocType: Project,Default Cost Center,Qendra Kosto e albumit
DocType: Bank Guarantee,End Date,End Date
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Transaksionet e aksioneve
DocType: Budget,Budget Accounts,Llogaritë e buxhetit
DocType: Employee,Internal Work History,Historia e brendshme
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Akumuluar Shuma Zhvlerësimi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Ekuiteti privat
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Vleresimi i rezultateve te furnitorit
DocType: Employee Loan,Fully Disbursed,lëvrohet plotësisht
DocType: Employee Advance,Due Advance Amount,Shuma e duhur paraprake
DocType: Maintenance Visit,Customer Feedback,Feedback Customer
DocType: Account,Expense,Shpenzim
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54,Score cannot be greater than Maximum Score,Rezultati nuk mund të jetë më e madhe se rezultatin maksimal
apps/erpnext/erpnext/utilities/user_progress.py +129,Customers and Suppliers,Konsumatorët dhe Furnizuesit
DocType: Item Attribute,From Range,Nga Varg
DocType: BOM,Set rate of sub-assembly item based on BOM,Cakto shkallën e artikullit të nën-montimit bazuar në BOM
DocType: Hotel Room Reservation,Invoiced,faturuar
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},gabim sintakse në formulën ose kushte: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Puna Daily Settings Përmbledhje Company
apps/erpnext/erpnext/stock/utils.py +125,Item {0} ignored since it is not a stock item,Item {0} injoruar pasi ajo nuk është një artikull të aksioneve
DocType: Appraisal,APRSL,APRSL
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.","Për të nuk zbatohet Rregulla e Çmimeve në një transaksion të caktuar, të gjitha rregullat e aplikueshme çmimeve duhet të jetë me aftësi të kufizuara."
DocType: Payment Term,Day(s) after the end of the invoice month,Ditë (a) pas përfundimit të muajit të faturës
DocType: Assessment Group,Parent Assessment Group,Parent Group Vlerësimit
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Jobs
,Sales Order Trends,Sales Rendit Trendet
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.,&#39;Nga Paketa Nr&#39; fusha nuk duhet të jetë as bosh as vlera e saj më e vogël se 1.
DocType: Employee,Held On,Mbajtur më
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36,Production Item,Prodhimi Item
,Employee Information,Informacione punonjës
DocType: Stock Entry Detail,Additional Cost,Kosto shtesë
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48,"Can not filter based on Voucher No, if grouped by Voucher","Nuk mund të filtruar në bazë të Voucher Jo, qoftë të grupuara nga Bonon"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918,Make Supplier Quotation,Bëjnë Furnizuesi Kuotim
DocType: Quality Inspection,Incoming,Hyrje
apps/erpnext/erpnext/setup/doctype/company/company.js +70,Default tax templates for sales and purchase are created.,Modelet e taksave të parazgjedhur për shitje dhe blerje krijohen.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57,Assessment Result record {0} already exists.,Regjistrimi i rezultatit të rezultatit {0} tashmë ekziston.
DocType: BOM,Materials Required (Exploded),Materialet e nevojshme (Shpërtheu)
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',Ju lutemi të vendosur Company filtër bosh nëse Group By është &#39;Company&#39;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Posting Data nuk mund të jetë data e ardhmja
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: serial {1} nuk përputhet me {2} {3}
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,për gjenerimin e përsëritjes
DocType: Stock Entry,Target Warehouse Address,Adresën e Objektit të Objektit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Lini Rastesishme
DocType: Agriculture Task,End Day,Dita e Fundit
DocType: Batch,Batch ID,ID Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Shënim: {0}
,Delivery Note Trends,Trendet ofrimit Shënim
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Përmbledhja e kësaj jave
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Në modelet Qty
DocType: Delivery Trip,Calculate Estimated Arrival Times,Llogarit kohët e arritura të mbërritjes
apps/erpnext/erpnext/accounts/general_ledger.py +113,Account: {0} can only be updated via Stock Transactions,Llogaria: {0} mund të përditësuar vetëm përmes aksionare transaksionet
DocType: Student Group Creation Tool,Get Courses,Get Kurse
DocType: GL Entry,Party,Parti
DocType: Healthcare Settings,Patient Name,Emri i pacientit
DocType: Variant Field,Variant Field,Fusha e variantit
DocType: Sales Order,Delivery Date,Ofrimit Data
DocType: Opportunity,Opportunity Date,Mundësi Data
DocType: Employee,Health Insurance Provider,Ofruesi i Sigurimeve Shëndetësore
DocType: Purchase Receipt,Return Against Purchase Receipt,Kthehu përkundrejt marrjes Blerje
DocType: Water Analysis,Person Responsible,Personi përgjegjës
DocType: Request for Quotation Item,Request for Quotation Item,Kërkesë për Kuotim Item
DocType: Purchase Order,To Bill,Për Bill
DocType: Material Request,% Ordered,% Urdhërohet
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Për Grupin bazuar Course Studentëve, kursi do të miratohet për çdo student nga kurset e regjistruar në programin e regjistrimit."
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Punë me copë
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Avg. Blerja Rate
DocType: Share Balance,From No,Nga Nr
DocType: Task,Actual Time (in Hours),Koha aktuale (në orë)
DocType: Employee,History In Company,Historia Në kompanisë
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,New Message from {sender},Mesazh i ri nga {sender}
DocType: Customer,Customer Primary Address,Adresa Primare e Klientit
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Buletinet
DocType: Drug Prescription,Description/Strength,Përshkrimi / Forca
DocType: Share Balance,Is Company,Është kompania
DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Hyrja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Same artikull është futur disa herë
DocType: Department,Leave Block List,Lini Blloko Lista
DocType: Purchase Invoice,Tax ID,ID e taksave
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Item {0} nuk është setup për Serial Nr. Kolona duhet të jetë bosh
DocType: Accounts Settings,Accounts Settings,Llogaritë Settings
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,miratoj
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69,"Malformatted address for {0}, please fix to continue.","Adresa pa format malformues për {0}, fillo të vazhdosh."
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","Numri i llogarisë së re, do të përfshihet në emrin e llogarisë si një prefiks"
DocType: Maintenance Team Member,Team Member,Anëtar i ekipit
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Asnjë rezultat për të paraqitur
DocType: Customer,Sales Partner and Commission,Sales Partner dhe Komisioni
DocType: Employee Loan,Rate of Interest (%) / Year,Norma e interesit (%) / Viti
,Project Quantity,Sasia Project
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'","Total {0} për të gjitha sendet është zero, mund të jetë që ju duhet të ndryshojë &quot;Shpërndani akuzat Bazuar On &#39;"
DocType: Opportunity,To Discuss,Për të diskutuar
apps/erpnext/erpnext/stock/stock_ledger.py +377,{0} units of {1} needed in {2} to complete this transaction.,{0} njësitë e {1} nevojshme në {2} për të përfunduar këtë transaksion.
DocType: Loan Type,Rate of Interest (%) Yearly,Norma e interesit (%) vjetore
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Llogaritë e përkohshme
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,E zezë
DocType: BOM Explosion Item,BOM Explosion Item,Bom Shpërthimi i artikullit
DocType: Shareholder,Contact List,Lista e Kontakteve
DocType: Account,Auditor,Revizor
DocType: Project,Frequency To Collect Progress,Frekuenca për të mbledhur progresin
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132,{0} items produced,{0} artikuj prodhuara
apps/erpnext/erpnext/utilities/user_progress.py +58,Learn More,Mëso më shumë
DocType: Cheque Print Template,Distance from top edge,Largësia nga buzë të lartë
apps/erpnext/erpnext/stock/get_item_details.py +367,Price List {0} is disabled or does not exist,Lista e Çmimeve {0} është me aftësi të kufizuara ose nuk ekziston
DocType: Purchase Invoice,Return,Kthimi
DocType: Pricing Rule,Disable,Disable
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180,Mode of payment is required to make a payment,Mënyra e pagesës është e nevojshme për të bërë një pagesë
DocType: Project Task,Pending Review,Në pritje Rishikimi
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Modifiko në faqen e plotë për më shumë opsione si asetet, numrat serial, batch etj."
apps/erpnext/erpnext/healthcare/doctype/physician/physician_dashboard.py +10,Appointments and Consultations,Emërimet dhe konsultimet
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nuk është i regjistruar në grumbull {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} nuk mund të braktiset, pasi ajo është tashmë {1}"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +84,Cheques Required,Verifikimet e kërkuara
DocType: Task,Total Expense Claim (via Expense Claim),Gjithsej Kërkesa shpenzimeve (nëpërmjet shpenzimeve Kërkesës)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Mungon
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Dështoi në konfigurimin e kompanisë
DocType: Asset Repair,Asset Repair,Riparimi i aseteve
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Row {0}: Valuta e BOM # {1} duhet të jetë e barabartë me monedhën e zgjedhur {2}
DocType: Journal Entry Account,Exchange Rate,Exchange Rate
DocType: Patient,Additional information regarding the patient,Informacione shtesë lidhur me pacientin
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585,Sales Order {0} is not submitted,Sales Order {0} nuk është dorëzuar
DocType: Homepage,Tag Line,tag Line
DocType: Fee Component,Fee Component,Komponenti Fee
apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Menaxhimi Fleet
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080,Add items from,Shto artikuj nga
apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Bimët dhe tokat
DocType: Cheque Print Template,Regular,i rregullt
DocType: Fertilizer,Density (if liquid),Dendësia (nëse është e lëngshme)
apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Weightage i përgjithshëm i të gjitha kriteret e vlerësimit duhet të jetë 100%
DocType: Purchase Order Item,Last Purchase Rate,Rate fundit Blerje
DocType: Account,Asset,Pasuri
DocType: Project Task,Task ID,Detyra ID
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Stock nuk mund të ekzistojë për Item {0} pasi ka variante
DocType: Lab Test,Mobile,i lëvizshëm
,Sales Person-wise Transaction Summary,Sales Person-i mençur Përmbledhje Transaction
DocType: Training Event,Contact Number,Numri i kontaktit
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73,Warehouse {0} does not exist,Magazina {0} nuk ekziston
DocType: Monthly Distribution,Monthly Distribution Percentages,Përqindjet mujore Shpërndarjes
apps/erpnext/erpnext/stock/doctype/batch/batch.py +110,The selected item cannot have Batch,Elementi i përzgjedhur nuk mund të ketë Serisë
DocType: Delivery Note,% of materials delivered against this Delivery Note,% E materialeve dorëzuar kundër këtij notën shpërndarëse
DocType: Asset Maintenance Log,Has Certificate,Ka certifikatë
DocType: Project,Customer Details,Detajet e klientit
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Kontrolloni nëse Aseti kërkon mirëmbajtje parandaluese ose kalibrim
apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,Shkurtimi i kompanisë nuk mund të ketë më shumë se 5 karaktere
DocType: Employee,Reports to,Raportet për
,Unpaid Expense Claim,Papaguar shpenzimeve Kërkesa
DocType: Payment Entry,Paid Amount,Paid Shuma
apps/erpnext/erpnext/utilities/user_progress.py +158,Explore Sales Cycle,Eksploro Cikullin e Shitjes
DocType: Assessment Plan,Supervisor,mbikëqyrës
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869,Retention Stock Entry,Regjistrimi i aksioneve mbajtëse
,Available Stock for Packing Items,Stock dispozicion për Items Paketimi
DocType: Item Variant,Item Variant,Item Variant
,Work Order Stock Report,Raporti i Renditjes së Rendit të Punës
DocType: Assessment Result Tool,Assessment Result Tool,Vlerësimi Rezultati Tool
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Si Supervizor
apps/erpnext/erpnext/public/js/hub/hub_form.js +376,Suggest Category,Sugjerojeni Kategorinë
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
apps/erpnext/erpnext/accounts/page/pos/pos.js +895,Submitted orders can not be deleted,urdhërat e dorëzuara nuk mund të fshihet
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'","Bilanci i llogarisë tashmë në Debitimit, ju nuk jeni i lejuar për të vendosur &quot;Bilanci Must Be &#39;si&#39; Credit&quot;"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Menaxhimit të Cilësisë
apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,{0} artikull ka qenë me aftësi të kufizuara
DocType: Project,Total Billable Amount (via Timesheets),Shuma totale e faturimit (përmes Timesheets)
DocType: Agriculture Task,Previous Business Day,Dita e mëparshme e punës
DocType: Employee Loan,Repay Fixed Amount per Period,Paguaj shuma fikse për një periudhë
DocType: Employee,Health Insurance No,Sigurimi Shëndetësor nr
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Ju lutemi shkruani sasine e artikullit {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +227,Credit Note Amt,Credit Note Amt
DocType: Employee External Work History,Employee External Work History,Punonjës historia e jashtme
DocType: Opening Invoice Creation Tool,Purchase,Blerje
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Bilanci Qty
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Qëllimet nuk mund të jetë bosh
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,Enrolling students,Regjistrimi i studentëve
DocType: Item Group,Parent Item Group,Grupi prind Item
DocType: Appointment Type,Appointment Type,Lloji i takimit
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} për {1}
DocType: Healthcare Settings,Valid number of days,Numri i ditëve të vlefshme
apps/erpnext/erpnext/setup/doctype/company/company.js +39,Cost Centers,Qendrat e kostos
DocType: Land Unit,Linked Plant Analysis,Analizë e bimëve të lidhur
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Shkalla në të cilën furnizuesit e valutës është e konvertuar në monedhën bazë kompanisë
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: konfliktet timings me radhë {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Lejo Zero Vlerësimit Vlerësoni
DocType: Training Event Employee,Invited,Të ftuar
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178,Multiple active Salary Structures found for employee {0} for the given dates,Multiple Strukturat aktive pagave gjetur për punonjës {0} për të dhënë data
apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Setup Llogaritë Gateway.
DocType: Employee,Employment Type,Lloji Punësimi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Mjetet themelore
DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange Gain / Humbje
,GST Purchase Register,GST Blerje Regjistrohu
,Cash Flow,Cash Flow
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Pjesa e kombinuar e faturës duhet të jetë e barabartë me 100%
DocType: Item Group,Default Expense Account,Llogaria e albumit shpenzimeve
DocType: GST Account,CGST Account,Llogaria CGST
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student Email ID
DocType: Employee,Notice (days),Njoftim (ditë)
DocType: Tax Rule,Sales Tax Template,Template Sales Tax
apps/erpnext/erpnext/accounts/page/pos/pos.js +2506,Select items to save the invoice,Zgjidhni artikuj për të shpëtuar faturën
DocType: Employee,Encashment Date,Arkëtim Data
DocType: Training Event,Internet,internet
DocType: Special Test Template,Special Test Template,Modeli i Testimit Special
DocType: Account,Stock Adjustment,Stock Rregullimit
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Kosto e albumit Aktiviteti ekziston për Aktivizimi Tipi - {0}
DocType: Work Order,Planned Operating Cost,Planifikuar Kosto Operative
DocType: Academic Term,Term Start Date,Term Data e fillimit
apps/erpnext/erpnext/config/accounts.py +471,List of all share transactions,Lista e të gjitha transaksioneve të aksioneve
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244,Please find attached {0} #{1},Ju lutem gjeni bashkangjitur {0} # {1}
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Norma mesatare
apps/erpnext/erpnext/controllers/accounts_controller.py +730,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Shuma totale e pagesës në orarin e pagesës duhet të jetë e barabartë me grandin / totalin e rrumbullakët
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Balanca Deklarata Banka sipas Librit Kryesor
DocType: Job Applicant,Applicant Name,Emri i aplikantit
DocType: Authorization Rule,Customer / Item Name,Customer / Item Emri
DocType: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Nëse aktivizohet, detajet e fundit të blerjes së artikujve nuk do të tërhiqen nga urdhri i blerjes së mëparshme ose faturën e blerjes"
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","Grupi agregat i Artikujve ** ** në një tjetër Item ** **. Kjo është e dobishme në qoftë se ju jeni të bundling një disa sendeve të caktuara ** ** në një paketë dhe të mbajë aksioneve të ** Artikujve mbushur ** dhe jo agregat ** Item **. Paketa ** Item ** do të ketë &quot;A Stock Item&quot; si &quot;Jo&quot; dhe &quot;është pika e shitjes&quot; si &quot;Po&quot;. Për shembull: Nëse ju jeni shitur laptopë dhe Backpacks veç e veç dhe të ketë një çmim të veçantë, nëse klienti blen dy, atëherë Laptop + Backpack do të jetë një i ri Bundle Produkt artikullit. Shënim: bom = Bill e materialeve"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Asnjë Serial është i detyrueshëm për Item {0}
DocType: Item Variant Attribute,Attribute,Atribut
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Ju lutemi specifikoni nga / në varg
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Hapja e {0} Faturave të krijuara
DocType: Serial No,Under AMC,Sipas AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Shkalla e vlerësimit Item rillogaritet duke marrë parasysh ul sasinë kuponave kosto
apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Default settings për shitjen e transaksioneve.
DocType: Guardian,Guardian Of ,kujdestar i
DocType: Grading Scale Interval,Threshold,prag
DocType: BOM Update Tool,Current BOM,Bom aktuale
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32,Balance (Dr - Cr),Bilanci (Dr - Cr)
apps/erpnext/erpnext/public/js/utils.js +55,Add Serial No,Shto Jo Serial
DocType: Work Order Item,Available Qty at Source Warehouse,Qty në dispozicion në burim Magazina
apps/erpnext/erpnext/config/support.py +22,Warranty,garanci
DocType: Purchase Invoice,Debit Note Issued,Debit Note Hedhur në qarkullim
DocType: Work Order,Warehouses,Depot
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aktiv nuk mund të transferohet
DocType: Hotel Room Pricing,Hotel Room Pricing,Çmimi i dhomës së hotelit
apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Ky Artikull është një variant i {0} (Shabllon).
DocType: Workstation,per hour,në orë
apps/erpnext/erpnext/config/buying.py +7,Purchasing,blerje
DocType: Announcement,Announcement,njoftim
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +106,Customer LPO,LPO e konsumatorit
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Për Grupin Batch bazuar Studentëve, grupi i Studentëve do të miratohet për çdo student nga Regjistrimi Programit."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Depo nuk mund të fshihet si ekziston hyrja aksioneve librit për këtë depo.
apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Shpërndarje
DocType: Expense Claim Advance,Expense Claim Advance,Kërkesa e Shpenzimit të Shpenzimeve
DocType: Lab Test,Report Preference,Preferencë e raportit
apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Informacione vullnetare.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Menaxher i Projektit
,Quoted Item Comparison,Cituar Item Krahasimi
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Mbivendosja në pikët midis {0} dhe {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Dërgim
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74,Max discount allowed for item: {0} is {1}%,Max zbritje lejohet për artikull: {0} është {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Vlera neto e aseteve si në
DocType: Crop,Produce,prodhoj
DocType: Hotel Settings,Default Taxes and Charges,Taksat dhe tarifat Default
DocType: Account,Receivable,Arkëtueshme
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Nuk lejohet të ndryshojë Furnizuesit si Urdhër Blerje tashmë ekziston
DocType: Stock Entry,Material Consumption for Manufacture,Konsumi material për prodhim
DocType: Item Alternative,Alternative Item Code,Kodi Alternativ i Artikullit
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Roli që i lejohet të paraqesë transaksionet që tejkalojnë limitet e kreditit përcaktuara.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +990,Select Items to Manufacture,Zgjidhni Items të Prodhimi
DocType: Delivery Stop,Delivery Stop,Dorëzimi i ndalimit
apps/erpnext/erpnext/accounts/page/pos/pos.js +963,"Master data syncing, it might take some time","Master dhënat syncing, ajo mund të marrë disa kohë"
DocType: Item,Material Issue,Materiali Issue
DocType: Employee Education,Qualification,Kualifikim
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42,View Salary Slips,Shihni pagat e pagave
DocType: Item Price,Item Price,Item Çmimi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Sapun dhe detergjent
DocType: BOM,Show Items,Shfaq Items
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Nga koha nuk mund të jetë më i madh se në kohë.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92,Do you want to notify all the customers by email?,A doni të njoftoni të gjithë klientët me email?
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Motion Picture &amp; Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Urdhërohet
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Vazhdoj
DocType: Hub Settings,Hub Username,Hub Emri i përdoruesit
DocType: Salary Detail,Component,komponent
DocType: Assessment Criteria,Assessment Criteria Group,Kriteret e vlerësimit Group
DocType: Healthcare Settings,Patient Name By,Emri i pacientit nga
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accrual Journal Entry for salaries from {0} to {1},Hyrja në Regjistrimin Përgjegjës për pagat nga {0} në {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Hapja amortizimi i akumuluar duhet të jetë më pak se e barabartë me {0}
DocType: Warehouse,Warehouse Name,Magazina Emri
DocType: Naming Series,Select Transaction,Përzgjedhjen e transaksioneve
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Ju lutemi shkruani Miratimi Roli ose Miratimi përdoruesin
DocType: Journal Entry,Write Off Entry,Shkruani Off Hyrja
DocType: BOM,Rate Of Materials Based On,Shkalla e materialeve në bazë të
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Analtyics Mbështetje
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Uncheck gjitha
DocType: POS Profile,Terms and Conditions,Termat dhe Kushtet
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Deri më sot duhet të jetë brenda vitit fiskal. Duke supozuar në datën = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Këtu ju mund të mbajë lartësia, pesha, alergji, shqetësimet mjekësore etj"
DocType: Leave Block List,Applies to Company,Zbatohet për Kompaninë
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231,Cannot cancel because submitted Stock Entry {0} exists,"Nuk mund të anulojë, sepse paraqitet Stock Hyrja {0} ekziston"
DocType: Employee Loan,Disbursement Date,disbursimi Date
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&#39;Përfituesit&#39; nuk janë të specifikuara
DocType: BOM Update Tool,Update latest price in all BOMs,Përditësoni çmimin e fundit në të gjitha BOM-et
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23,Medical Record,Regjistri mjekësor
DocType: Vehicle,Vehicle,automjet
DocType: Purchase Invoice,In Words,Me fjalë të
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} duhet të dorëzohet
DocType: POS Profile,Item Groups,Grupet artikull
apps/erpnext/erpnext/hr/doctype/employee/employee.py +222,Today is {0}'s birthday!,Sot është {0} &#39;s ditëlindjen!
DocType: Sales Order Item,For Production,Për Prodhimit
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,Ju lutemi të shtoni një llogari të Hapjes së Përkohshme në Kartën e Llogarive
DocType: Customer,Customer Primary Contact,Kontakti Primar i Klientit
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154,Period Closing Journal,Ditari i mbylljes së periudhës
DocType: Project Task,View Task,Shiko Task
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead%
DocType: Material Request,MREQ-,MREQ-
DocType: Payment Schedule,Invoice Portion,Pjesa e faturës
,Asset Depreciations and Balances,Nënçmime aseteve dhe Bilancet
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370,Amount {0} {1} transferred from {2} to {3},Shuma {0} {1} transferuar nga {2} të {3}
DocType: Sales Invoice,Get Advances Received,Get Përparimet marra
DocType: Email Digest,Add/Remove Recipients,Add / Remove Recipients
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Për të vendosur këtë vit fiskal si default, klikoni mbi &#39;Bëje si Default&#39;"
DocType: Production Plan,Include Subcontracted Items,Përfshini artikujt e nënkontraktuar
apps/erpnext/erpnext/projects/doctype/project/project.py +220,Join,bashkohem
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Mungesa Qty
apps/erpnext/erpnext/stock/doctype/item/item.py +672,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Nuk mund të ndryshojë pronat e variantit pas transakcionit të stoqeve. Ju do të keni për të bërë një artikull të ri për ta bërë këtë.
apps/erpnext/erpnext/stock/doctype/item/item.py +714,Item variant {0} exists with same attributes,Item variant {0} ekziston me atributet e njëjta
DocType: Employee Loan,Repay from Salary,Paguajë nga paga
DocType: Leave Application,LAP/,LAP /
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360,Requesting payment against {0} {1} for amount {2},Kerkuar pagesën kundër {0} {1} për sasi {2}
DocType: Salary Slip,Salary Slip,Shqip paga
DocType: Lead,Lost Quotation,Lost Citat
apps/erpnext/erpnext/utilities/user_progress.py +221,Student Batches,Grupet e Studentëve
DocType: Pricing Rule,Margin Rate or Amount,Margin Vlerësoni ose Shuma
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,&quot;Deri më sot&quot; është e nevojshme
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generate paketim rrëshqet për paketat që do të dërgohen. Përdoret për të njoftuar numrin paketë, paketë përmbajtjen dhe peshën e saj."
DocType: Sales Invoice Item,Sales Order Item,Sales Rendit Item
DocType: Salary Slip,Payment Days,Ditët e pagesës
DocType: Stock Settings,Convert Item Description to Clean HTML,Convert Item Description për të pastruar HTML
DocType: Patient,Dormant,në gjumë
DocType: Salary Slip,Total Interest Amount,Shuma totale e interesit
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124,Warehouses with child nodes cannot be converted to ledger,Depot me nyjet e fëmijëve nuk mund të konvertohet në Ledger
DocType: BOM,Manage cost of operations,Menaxhuar koston e operacioneve
DocType: Accounts Settings,Stale Days,Ditët Stale
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.","Kur ndonjë nga transaksionet e kontrolluara janë &quot;Dërguar&quot;, një email pop-up u hap automatikisht për të dërguar një email tek të lidhur &quot;Kontakt&quot; në këtë transaksion, me transaksionin si një shtojcë. Ky përdorues mund ose nuk mund të dërgoni email."
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Cilësimet globale
DocType: Crop,Row Spacing UOM,Rreshtimi i rreshtit UOM
DocType: Assessment Result Detail,Assessment Result Detail,Vlerësimi Rezultati Detail
DocType: Employee Education,Employee Education,Arsimimi punonjës
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Grupi Duplicate artikull gjenden në tabelën e grupit artikull
DocType: Land Unit,Parent Land Unit,Njësia e tokës parësore
apps/erpnext/erpnext/public/js/controllers/transaction.js +1114,It is needed to fetch Item Details.,Është e nevojshme për të shkoj të marr dhëna të artikullit.
DocType: Fertilizer,Fertilizer Name,Emri i plehut
DocType: Salary Slip,Net Pay,Pay Net
DocType: Cash Flow Mapping Accounts,Account,Llogari
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serial Asnjë {0} tashmë është marrë
,Requested Items To Be Transferred,Items kërkuar të transferohet
DocType: Expense Claim,Vehicle Log,Vehicle Identifikohu
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),Prania e etheve (temp&gt; 38.5 ° C / 101.3 ° F ose temperatura e qëndrueshme&gt; 38 ° C / 100.4 ° F)
DocType: Customer,Sales Team Details,Detajet shitjet e ekipit
apps/erpnext/erpnext/accounts/page/pos/pos.js +1352,Delete permanently?,Fshini përgjithmonë?
DocType: Expense Claim,Total Claimed Amount,Shuma totale Pohoi
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Mundësi potenciale për të shitur.
DocType: Shareholder,Folio no.,Folio nr.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246,Invalid {0},Invalid {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Pushimi mjekësor
DocType: Email Digest,Email Digest,Email Digest
DocType: Delivery Note,Billing Address Name,Faturimi Adresa Emri
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Dyqane
,Item Delivery Date,Data e dorëzimit të artikullit
DocType: Production Plan,Material Requested,Materiali i kerkuar
DocType: Warehouse,PIN,GJILPËRË
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116,Error '{0}' occured. Arguments {1}.,Gabim &#39;{0}&#39; ndodhi. Argumente {1}.
DocType: Bin,Reserved Qty for sub contract,Qty i rezervuar për nën kontratë
DocType: Patient Service Unit,Patinet Service Unit,Njësia e Shërbimit Patinet
DocType: Sales Invoice,Base Change Amount (Company Currency),Base Ndryshimi Shuma (Company Valuta)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Nuk ka hyrje të kontabilitetit për magazinat e mëposhtme
apps/erpnext/erpnext/projects/doctype/project/project.js +95,Save the document first.,Ruaj dokumentin e parë.
apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},Vetëm {0} në magazinë për artikullin {1}
DocType: Account,Chargeable,I dënueshëm
DocType: Company,Change Abbreviation,Ndryshimi Shkurtesa
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66,Pay {0} {1},Paguaj {0} {1}
DocType: Expense Claim Detail,Expense Date,Shpenzim Data
DocType: Item,Max Discount (%),Max Discount (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Ditët e kredisë nuk mund të jenë një numër negativ
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Shuma Rendit Fundit
DocType: Cash Flow Mapper,e.g Adjustments for:,p.sh. Rregullimet për:
apps/erpnext/erpnext/stock/doctype/item/item.py +275," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Retain Sample është i bazuar në grumbull, ju lutemi kontrolloni Keni Jo Serinë për të mbajtur mostrën e sendit"
DocType: Task,Is Milestone,A Milestone
DocType: Delivery Stop,Email Sent To,Email Sent To
DocType: Budget,Warn,Paralajmëroj
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +108,Are you sure you want to unregister?,Je i sigurt që dëshiron të çregjistrosh?
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +926,All items have already been transferred for this Work Order.,Të gjitha sendet tashmë janë transferuar për këtë Rendit të Punës.
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Çdo vërejtje të tjera, përpjekje të përmendet se duhet të shkoni në të dhënat."
DocType: Asset Maintenance,Manufacturing User,Prodhim i përdoruesit
DocType: Purchase Invoice,Raw Materials Supplied,Lëndëve të para furnizuar
DocType: C-Form,Series,Seri
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282,Currency of the price list {0} must be {1} or {2},Valuta e listës së çmimeve {0} duhet të jetë {1} ose {2}
DocType: Appraisal,Appraisal Template,Vlerësimi Template
DocType: Soil Texture,Ternary Plot,Komplot tresh
DocType: Item Group,Item Classification,Klasifikimi i artikullit
DocType: Driver,License Number,Numri i licencës
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Zhvillimin e Biznesit Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Mirëmbajtja Vizitoni Qëllimi
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Regjistrimi i Faturës së Pacientëve
DocType: Crop,Period,Periudhë
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27,General Ledger,Përgjithshëm Ledger
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},I punësuar {0} për të lënë në {1}
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Shiko kryeson
DocType: Program Enrollment Tool,New Program,Program i ri
DocType: Item Attribute Value,Attribute Value,Atribut Vlera
,Itemwise Recommended Reorder Level,Itemwise Recommended reorder Niveli
DocType: Salary Detail,Salary Detail,Paga Detail
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070,Please select {0} first,"Ju lutem, përzgjidhni {0} parë"
DocType: Appointment Type,Physician,mjek
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1005,Batch {0} of Item {1} has expired.,Batch {0} i artikullit {1} ka skaduar.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,konsultimet
DocType: Sales Invoice,Commission,Komision
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nuk mund të jetë më i madh se sasia e planifikuar ({2}) në Urdhërin e Punës {3}
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Sheet Koha për prodhimin.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Nëntotali
apps/erpnext/erpnext/config/erpnext_integrations.py +18,GoCardless SEPA Mandate,Mandati i SEPA për GoCardless
DocType: Physician,Charges,akuzat
DocType: Production Plan,Get Items For Work Order,Merrni artikujt për porosinë e punës
DocType: Salary Detail,Default Amount,Gabim Shuma
DocType: Lab Test Template,Descriptive,përshkrues
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,Magazina nuk gjendet ne sistem
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Përmbledhje këtij muaji
DocType: Quality Inspection Reading,Quality Inspection Reading,Inspektimi Leximi Cilësia
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,`Ngrij Stoqet me te vjetra se` duhet të jetë më e vogël se% d ditë.
DocType: Tax Rule,Purchase Tax Template,Blerje Template Tatimore
apps/erpnext/erpnext/utilities/user_progress.py +48,Set a sales goal you'd like to achieve for your company.,Vendosni një qëllim të shitjes që dëshironi të arrini për kompaninë tuaj.
,Project wise Stock Tracking,Projekti Ndjekja mençur Stock
DocType: GST HSN Code,Regional,rajonal
apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,laborator
DocType: Stock Entry Detail,Actual Qty (at source/target),Sasia aktuale (në burim / objektiv)
DocType: Item Customer Detail,Ref Code,Kodi ref
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Grupi i Konsumatorëve kërkohet në Profilin e POS
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Të dhënat punonjës.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Please set Next Depreciation Date,Ju lutemi të vendosur Date Amortizimi tjetër
DocType: HR Settings,Payroll Settings,Listën e pagave Cilësimet
apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Përputhje për Faturat jo-lidhura dhe pagesat.
DocType: POS Settings,POS Settings,POS Settings
apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Vendi Renditja
DocType: Email Digest,New Purchase Orders,Blerje porositë e reja
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Rrënjë nuk mund të ketë një qendër me kosto prind
apps/erpnext/erpnext/public/js/stock_analytics.js +54,Select Brand...,Zgjidh Markë ...
apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Jo fitim (beta)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Ngjarjet / rezultateve të trajnimit
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Amortizimin e akumuluar si në
DocType: Sales Invoice,C-Form Applicable,C-Formulari i zbatueshëm
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438,Operation Time must be greater than 0 for Operation {0},Operacioni Koha duhet të jetë më e madhe se 0 për Operacionin {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107,Warehouse is mandatory,Magazina është e detyrueshme
DocType: Shareholder,Address and Contacts,Adresa dhe Kontakte
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Dështoi në krijimin e faqes së internetit
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM Konvertimi Detail
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924,Retention Stock Entry already created or Sample Quantity not provided,Regjistrimi i aksioneve të mbajtjes tashmë të krijuar ose Sasia e mostrës nuk është dhënë
DocType: Program,Program Abbreviation,Shkurtesa program
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Akuzat janë përditësuar në pranimin Blerje kundër çdo send
DocType: Warranty Claim,Resolved By,Zgjidhen nga
DocType: Bank Guarantee,Start Date,Data e Fillimit
apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Alokimi i lë për një periudhë.
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Çeqet dhe Depozitat pastruar gabimisht
apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Llogaria {0}: Ju nuk mund të caktojë veten si llogari prind
DocType: Purchase Invoice Item,Price List Rate,Lista e Çmimeve Rate
apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Krijo kuotat konsumatorëve
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Trego &quot;Në magazinë&quot; ose &quot;Jo në magazinë&quot; në bazë të aksioneve në dispozicion në këtë depo.
apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Bill e materialeve (BOM)
DocType: Item,Average time taken by the supplier to deliver,Koha mesatare e marra nga furnizuesi për të ofruar
DocType: Sample Collection,Collected By,Mbledhur nga
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,Rezultati i vlerësimit
DocType: Hotel Room Package,Hotel Room Package,Paketa e dhomës së hotelit
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Orë
DocType: Project,Expected Start Date,Pritet Data e Fillimit
DocType: Purchase Invoice,04-Correction in Invoice,04-Korrigjimi në Faturë
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963,Work Order already created for all items with BOM,Rendi i punës i krijuar për të gjitha artikujt me BOM
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Raportet e variantit
DocType: Setup Progress Action,Setup Progress Action,Aksioni i progresit të instalimit
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Lista e Çmimeve të Blerjes
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Hiq pika në qoftë se akuza nuk është i zbatueshëm për këtë artikull
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Ju lutem zgjidhni Statusin e Mirëmbajtjes si Komplet ose hiqni Datën e Përfundimit
DocType: Supplier,Default Payment Terms Template,Modeli i parazgjedhur i pagesave
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Monedha transaksion duhet të jetë i njëjtë si pagesë Gateway valutë
DocType: Payment Entry,Receive,Merre
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Citate:
DocType: Maintenance Visit,Fully Completed,Përfunduar Plotësisht
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Complete
DocType: Employee,Educational Qualification,Kualifikimi arsimor
DocType: Workstation,Operating Costs,Shpenzimet Operative
DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Veprimi në qoftë akumuluar tejkaluar buxhetin mujor
DocType: Subscription,Submit on creation,Submit në krijimin
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483,Currency for {0} must be {1},Monedhë për {0} duhet të jetë {1}
DocType: Asset,Disposal Date,Shkatërrimi Date
DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","Email do të dërgohet të gjithë të punësuarve aktive e shoqërisë në orë të caktuar, në qoftë se ata nuk kanë pushim. Përmbledhje e përgjigjeve do të dërgohet në mesnatë."
DocType: Employee Leave Approver,Employee Leave Approver,Punonjës Pushimi aprovuesi
apps/erpnext/erpnext/stock/doctype/item/item.py +510,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Një hyrje Reorder tashmë ekziston për këtë depo {1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Nuk mund të deklarojë si të humbur, sepse Kuotim i është bërë."
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Feedback Training
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kriteret e Scorecard Furnizuesit
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},"Ju lutem, përzgjidhni Data e Fillimit Data e Përfundimit Kohëzgjatja për Item {0}"
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Kursi është i detyrueshëm në rresht {0}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Deri më sot nuk mund të jetë e para nga data e
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DOCTYPE
DocType: Cash Flow Mapper,Section Footer,Seksioni i faqes
apps/erpnext/erpnext/stock/doctype/item/item.js +304,Add / Edit Prices,Add / Edit Çmimet
DocType: Batch,Parent Batch,Batch Parent
DocType: Cheque Print Template,Cheque Print Template,Çek Print Template
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Grafiku i Qendrave te Kostos
DocType: Lab Test Template,Sample Collection,Sample Collection
,Requested Items To Be Ordered,Items kërkuar të Urdhërohet
DocType: Price List,Price List Name,Lista e Çmimeve Emri
DocType: BOM,Manufacturing,Prodhim
,Ordered Items To Be Delivered,Items urdhëroi që do të dërgohen
DocType: Account,Income,Të ardhura
DocType: Industry Type,Industry Type,Industria Type
apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Diçka shkoi keq!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105,Warning: Leave application contains following block dates,Warning: Lini aplikimi përmban datat e mëposhtme bllok
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275,Sales Invoice {0} has already been submitted,Shitjet Faturë {0} tashmë është dorëzuar
DocType: Supplier Scorecard Scoring Criteria,Score,rezultat
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Viti Fiskal {0} nuk ekziston
DocType: Asset Maintenance Log,Completion Date,Data e përfundimit
DocType: Purchase Invoice Item,Amount (Company Currency),Shuma (Kompania Valuta)
DocType: Agriculture Analysis Criteria,Agriculture User,Përdoruesi i Bujqësisë
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,E vlefshme deri në datën nuk mund të jetë para datës së transaksionit
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} njësitë e {1} nevojshme në {2} në {3} {4} për {5} për të përfunduar këtë transaksion.
DocType: Fee Schedule,Student Category,Student Category
DocType: Announcement,Student,student
apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Njësia Organizata (departamenti) mjeshtër.
DocType: Shipping Rule,Shipping Rule Type,Lloji Rregullave të Transportit
apps/erpnext/erpnext/utilities/user_progress.py +239,Go to Rooms,Shkoni në Dhoma
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Ju lutem shkruani mesazhin para se të dërgonte
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,Duplicate Furnizuesi
DocType: Email Digest,Pending Quotations,Në pritje Citate
apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-Sale Profilin
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25,{0} should be a value between 0 and 100,{0} duhet të jetë një vlerë midis 0 dhe 100
apps/erpnext/erpnext/assets/doctype/asset/asset.py +94,Next Depreciation Date cannot be before Available-for-use Date,Data tjetër e zhvlerësimit nuk mund të jetë para datës së disponueshme për përdorim
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Kredi pasiguruar
DocType: Cost Center,Cost Center Name,Kosto Emri Qendra
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Max orarit të punës kundër pasqyrë e mungesave
DocType: Maintenance Schedule Detail,Scheduled Date,Data e planifikuar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +226,Total Paid Amt,Totale e paguar Amt
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Mesazhet më të mëdha se 160 karaktere do të ndahet në mesazhe të shumta
DocType: Purchase Receipt Item,Received and Accepted,Marrë dhe pranuar
DocType: Hub Settings,Company and Seller Profile,Profili i Kompanisë dhe Shitësit
,GST Itemised Sales Register,GST e detajuar Sales Regjistrohu
DocType: Soil Texture,Silt Loam,Pjellë e zhytur
,Serial No Service Contract Expiry,Serial Asnjë Shërbimit Kontratë Expiry
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Ju nuk mund të kreditit dhe debitit njëjtën llogari në të njëjtën kohë
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Shkalla e rritjes së të rriturve është diku midis 50 dhe 80 rrahje në minutë.
DocType: Naming Series,Help HTML,Ndihmë HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Krijimi Tool
DocType: Item,Variant Based On,Variant i bazuar në
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Weightage Gjithsej caktuar duhet të jetë 100%. Kjo është {0}
apps/erpnext/erpnext/utilities/user_progress.py +109,Your Suppliers,Furnizuesit tuaj
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Ju lutem korrigjoni
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Nuk mund të vendosur si Humbur si Sales Order është bërë.
DocType: Request for Quotation Item,Supplier Part No,Furnizuesi Part No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Nuk mund të zbres kur kategori është për &#39;vlerësimin&#39; ose &#39;Vaulation dhe Total &quot;
apps/erpnext/erpnext/public/js/hub/hub_form.js +197,Anonymous,anonim
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377,Received From,Marrë nga
DocType: Lead,Converted,Konvertuar
DocType: Item,Has Serial No,Nuk ka Serial
DocType: Employee,Date of Issue,Data e lëshimit
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}","Sipas Settings Blerja nëse blerja Reciept Required == &#39;PO&#39;, pastaj për krijimin Blerje Faturën, përdoruesi duhet të krijoni Marrjes blerjen e parë për pikën {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Row # {0}: Furnizuesi Set për pika {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Row {0}: Hours Vlera duhet të jetë më e madhe se zero.
apps/erpnext/erpnext/stock/doctype/item/item.py +195,Website Image {0} attached to Item {1} cannot be found,Faqja Image {0} bashkangjitur në pikën {1} nuk mund të gjendet
DocType: Issue,Content Type,Përmbajtja Type
DocType: Asset,Assets,asetet
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Kompjuter
DocType: Item,List this Item in multiple groups on the website.,Lista këtë artikull në grupe të shumta në faqen e internetit.
DocType: Payment Term,Due Date Based On,Datë e bazuar në bazë
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,Please set default customer group and territory in Selling Settings,Ju lutemi vendosni grupin e parazgjedhur të konsumatorëve dhe territorin në Cilësimet e shitjes
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214,{0} {1} does not exist,{0} {1} nuk ekziston
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,Ju lutem kontrolloni opsionin Multi Valuta për të lejuar llogaritë me valutë tjetër
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88,Item: {0} does not exist in the system,Item: {0} nuk ekziston në sistemin
apps/erpnext/erpnext/accounts/doctype/account/account.py +106,You are not authorized to set Frozen value,Ju nuk jeni i autorizuar për të vendosur vlerën e ngrira
DocType: Payment Reconciliation,Get Unreconciled Entries,Get Unreconciled Entries
DocType: Payment Reconciliation,From Invoice Date,Nga Faturë Data
DocType: Healthcare Settings,Laboratory Settings,Cilësimet laboratorike
DocType: Patient Appointment,Service Unit,Njësia e Shërbimit
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Vendosni me sukses Furnizuesin
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Lini arkëtim
apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Çfarë do të bëni?
DocType: Crop,Byproducts,derivateve të tjerë
apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,Për Magazina
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Të gjitha Pranimet e studentëve
,Average Commission Rate,Mesatare Rate Komisioni
DocType: Share Balance,No of Shares,Jo të aksioneve
apps/erpnext/erpnext/stock/doctype/item/item.py +448,'Has Serial No' can not be 'Yes' for non-stock item,&#39;Nuk ka Serial&#39; nuk mund të jetë &#39;Po&#39; për jo-aksioneve artikull
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59,Select Status,Zgjidh statusin
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Pjesëmarrja nuk mund të shënohet për datat e ardhshme
DocType: Pricing Rule,Pricing Rule Help,Rregulla e Çmimeve Ndihmë
DocType: School House,House Name,Emri House
DocType: Fee Schedule,Total Amount per Student,Shuma totale për student
DocType: Purchase Taxes and Charges,Account Head,Shef llogari
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Elektrik
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,Shto pjesën tjetër të organizatës suaj si përdoruesit e juaj. Ju gjithashtu mund të shtoni ftojë konsumatorët për portalin tuaj duke shtuar ato nga Kontaktet
DocType: Stock Entry,Total Value Difference (Out - In),Gjithsej Diferenca Vlera (Out - In)
DocType: Grant Application,Requested Amount,Shuma e Kërkuar
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Row {0}: Exchange Rate është i detyrueshëm
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},Përdoruesi ID nuk është caktuar për punonjësit {0}
DocType: Vehicle,Vehicle Value,Vlera automjeteve
DocType: Crop Cycle,Detected Diseases,Sëmundjet e zbuluara
DocType: Stock Entry,Default Source Warehouse,Gabim Burimi Magazina
DocType: Item,Customer Code,Kodi Klientit
apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Birthday Reminder for {0},Vërejtje ditëlindjen për {0}
DocType: Asset Maintenance Task,Last Completion Date,Data e përfundimit të fundit
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Ditët Që Rendit Fundit
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365,Debit To account must be a Balance Sheet account,Debi Për shkak duhet të jetë një llogari Bilanci i Gjendjes
DocType: Buying Settings,Naming Series,Emërtimi Series
DocType: GoCardless Settings,GoCardless Settings,Cilësimet GoCardless
DocType: Leave Block List,Leave Block List Name,Dërgo Block Lista Emri
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,date Insurance Fillimi duhet të jetë më pak se data Insurance Fund
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Pasuritë e aksioneve
DocType: Restaurant,Active Menu,Meny aktiv
DocType: Target Detail,Target Qty,Target Qty
DocType: Shopping Cart Settings,Checkout Settings,Cilësimet Checkout
DocType: Student Attendance,Present,I pranishëm
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Ofrimit Shënim {0} nuk duhet të dorëzohet
DocType: Notification Control,Sales Invoice Message,Mesazh Shitjet Faturë
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Llogarisë {0} Mbyllja duhet të jetë e tipit me Përgjegjësi / ekuitetit
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325,Salary Slip of employee {0} already created for time sheet {1},Paga Slip nga punonjësi {0} krijuar tashmë për fletë kohë {1}
DocType: Vehicle Log,Odometer,rrugëmatës
DocType: Production Plan Item,Ordered Qty,Urdhërohet Qty
apps/erpnext/erpnext/stock/doctype/item/item.py +744,Item {0} is disabled,Item {0} është me aftësi të kufizuara
DocType: Stock Settings,Stock Frozen Upto,Stock ngrira Upto
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930,BOM does not contain any stock item,BOM nuk përmban ndonjë artikull aksioneve
DocType: Chapter,Chapter Head,Kreu i Kapitullit
DocType: Payment Term,Month(s) after the end of the invoice month,Muaj (a) pas përfundimit të muajit të faturës
apps/erpnext/erpnext/config/projects.py +24,Project activity / task.,Aktiviteti i projekt / detyra.
DocType: Vehicle Log,Refuelling Details,Details Rimbushja
apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Generate paga rrëshqet
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25,Lab result datetime cannot be before testing datetime,Data e rezultatit të laboratorit nuk mund të jetë para testimit të datetime
DocType: POS Profile,Allow user to edit Discount,Lejo përdoruesin të redaktojë zbritje
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55,Get customers from,Merrni klientët nga
DocType: Purchase Invoice Item,Include Exploded Items,Përfshirja e artikujve të eksploduar
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45,"Buying must be checked, if Applicable For is selected as {0}","Blerja duhet të kontrollohet, nëse është e aplikueshme për të është zgjedhur si {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Discount duhet të jetë më pak se 100
DocType: Shipping Rule,Restrict to Countries,Kufizo vendet
DocType: Purchase Invoice,Write Off Amount (Company Currency),Shkruaj Off Shuma (Kompania Valuta)
DocType: Sales Invoice Timesheet,Billing Hours,faturimit Hours
DocType: Project,Total Sales Amount (via Sales Order),Shuma totale e shitjeve (me anë të shitjes)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +572,Default BOM for {0} not found,BOM Default për {0} nuk u gjet
apps/erpnext/erpnext/stock/doctype/item/item.py +514,Row #{0}: Please set reorder quantity,Row # {0}: Ju lutemi të vendosur sasinë Reorder
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Prekni për të shtuar artikuj tyre këtu
DocType: Fees,Program Enrollment,program Regjistrimi
DocType: Share Transfer,To Folio No,Për Folio Nr
DocType: Landed Cost Voucher,Landed Cost Voucher,Zbarkoi Voucher Kosto
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Ju lutemi të vendosur {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} është nxënës joaktiv
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} është nxënës joaktiv
DocType: Employee,Health Details,Detajet Shëndeti
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Për të krijuar një kërkesë për pagesë dokument reference është e nevojshme
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Për të krijuar një kërkesë për pagesë dokument reference është e nevojshme
DocType: Soil Texture,Sandy Clay,Sandy Balta
DocType: Grant Application,Assessment  Manager,Menaxheri i Vlerësimit
DocType: Payment Entry,Allocate Payment Amount,Alokimi Shuma e pagesës
DocType: Employee External Work History,Salary,Rrogë
DocType: Serial No,Delivery Document Type,Ofrimit Dokumenti Type
DocType: Sales Order,Partly Delivered,Dorëzuar Pjesërisht
DocType: Item Variant Settings,Do not update variants on save,Mos update variante për të shpëtuar
DocType: Email Digest,Receivables,Arkëtueshme
DocType: Lead Source,Lead Source,Burimi Lead
DocType: Customer,Additional information regarding the customer.,Informacion shtesë në lidhje me konsumatorin.
DocType: Quality Inspection Reading,Reading 5,Leximi 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} është i lidhur me {2}, por Llogaria e Partisë është {3}"
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Shiko testet laboratorike
DocType: Hub Users,Hub Users,Përdoruesit Hub
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Mirëmbajtja Data
DocType: Purchase Invoice Item,Rejected Serial No,Refuzuar Nuk Serial
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,Viti data e fillimit ose data fundi mbivendosje me {0}. Për të shmangur ju lutem kompaninë vendosur
apps/erpnext/erpnext/selling/doctype/customer/customer.py +122,Please mention the Lead Name in Lead {0},Ju lutemi të përmendni Emrin Lead në Lead {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Data e fillimit duhet të jetë më pak se data përfundimtare e artikullit {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.","Shembull:. ABCD ##### Nëse seri është vendosur dhe nuk Serial nuk është përmendur në transaksione, numri atëherë automatike serial do të krijohet në bazë të kësaj serie. Nëse ju gjithmonë doni të në mënyrë eksplicite përmend Serial Nos për këtë artikull. lënë bosh këtë."
DocType: Upload Attendance,Upload Attendance,Ngarko Pjesëmarrja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +616,BOM and Manufacturing Quantity are required,BOM dhe Prodhim Sasi janë të nevojshme
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50,Ageing Range 2,Gama plakjen 2
DocType: SG Creation Tool Course,Max Strength,Max Forca
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Instalimi i paravendosjeve
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85,No Delivery Note selected for Customer {},Nuk ka Shënim për Dorëzim të zgjedhur për Klientin {}
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25,BOM replaced,Bom zëvendësohet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1053,Select Items based on Delivery Date,Zgjedhni artikujt bazuar në Datën e Dorëzimit
DocType: Grant Application,Has any past Grant Record,Ka ndonjë të kaluar Grant Record
,Sales Analytics,Sales Analytics
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127,Available {0},Në dispozicion {0}
,Prospects Engaged But Not Converted,Perspektivat angazhuar Por Jo konvertuar
,Prospects Engaged But Not Converted,Perspektivat angazhuar Por Jo konvertuar
DocType: Manufacturing Settings,Manufacturing Settings,Prodhim Cilësimet
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Ngritja me e-mail
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Ju lutem shkruani monedhën parazgjedhje në kompaninë Master
DocType: Stock Entry Detail,Stock Entry Detail,Stock Hyrja Detail
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Harroni të Përditshëm
DocType: Products Settings,Home Page is Products,Faqja Kryesore është Produkte
,Asset Depreciation Ledger,Zhvlerësimi i aseteve Ledger
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91,Tax Rule Conflicts with {0},Konfliktet Rregulla tatimor me {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,New Emri i llogarisë
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Kosto të lëndëve të para furnizuar
DocType: Selling Settings,Settings for Selling Module,Cilësimet për shitjen Module
DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervimi i dhomës së hotelit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Shërbimi ndaj klientit
DocType: BOM,Thumbnail,Thumbnail
DocType: Item Customer Detail,Item Customer Detail,Item Detail Klientit
apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Oferta kandidat a Job.
DocType: Notification Control,Prompt for Email on Submission of,Prompt për Dërgoje në dorëzimin e
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Gjithsej gjethet e ndara janë më shumë se ditë në periudhën
DocType: Land Unit,Linked Soil Analysis,Analizë e Lidhjeve të Tokës
DocType: Pricing Rule,Percentage,përqindje
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Item {0} duhet të jetë një gjendje Item
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Default Puna Në Magazina Progresit
apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Default settings për transaksionet e kontabilitetit.
DocType: Maintenance Visit,MV,MV
DocType: Restaurant,Default Tax Template,Modeli Tatimor i Parazgjedhur
DocType: Fees,Student Details,Detajet e Studentit
DocType: Purchase Invoice Item,Stock Qty,Stock Qty
DocType: Purchase Invoice Item,Stock Qty,Stock Qty
DocType: Employee Loan,Repayment Period in Months,Afati i pagesës në muaj
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Gabim: Nuk është një ID të vlefshme?
DocType: Naming Series,Update Series Number,Update Seria Numri
DocType: Account,Equity,Barazia
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;Fitimi dhe Humbja &#39;lloji i llogarisë {2} nuk lejohen në Hapja Hyrja
DocType: Sales Order,Printing Details,Shtypi Detajet
DocType: Task,Closing Date,Data e mbylljes
DocType: Sales Order Item,Produced Quantity,Sasia e prodhuar
DocType: Timesheet,Work Detail,Detajet e punës
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Inxhinier
DocType: Journal Entry,Total Amount Currency,Total Shuma Valuta
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Kuvendet Kërko Nën
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Kodi i artikullit kërkohet në radhë nr {0}
DocType: GST Account,SGST Account,Llogari SGST
apps/erpnext/erpnext/utilities/user_progress.py +154,Go to Items,Shko te artikujt
DocType: Sales Partner,Partner Type,Lloji Partner
DocType: Purchase Taxes and Charges,Actual,Aktual
DocType: Restaurant Menu,Restaurant Manager,Menaxheri i Restorantit
DocType: Authorization Rule,Customerwise Discount,Customerwise Discount
apps/erpnext/erpnext/config/projects.py +46,Timesheet for tasks.,Pasqyrë e mungesave për detyra.
DocType: Purchase Invoice,Against Expense Account,Kundër Llogaria shpenzimeve
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282,Installation Note {0} has already been submitted,Instalimi Shënim {0} tashmë është dorëzuar
DocType: Bank Reconciliation,Get Payment Entries,Get Entries pagesës
DocType: Quotation Item,Against Docname,Kundër Docname
DocType: SMS Center,All Employee (Active),Të gjitha Punonjës (Aktive)
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Shiko Tani
DocType: BOM,Raw Material Cost,Raw Material Kosto
DocType: Woocommerce Settings,Woocommerce Server URL,URL e Woocommerce Server
DocType: Item Reorder,Re-Order Level,Re-Rendit nivel
apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,Gantt Chart
DocType: Crop Cycle,Cycle Type,Lloji i ciklit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Me kohë të pjesshme
DocType: Employee,Applicable Holiday List,Zbatueshme Lista Holiday
DocType: Employee,Cheque,Çek
DocType: Training Event,Employee Emails,E-mail punonjësish
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60,Series Updated,Seria Përditësuar
apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Report Type is mandatory,Raporti Lloji është i detyrueshëm
DocType: Item,Serial Number Series,Serial Number Series
apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Depoja është e detyrueshme për aksioneve Item {0} në rresht {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Shitje me pakicë dhe shumicë
DocType: Issue,First Responded On,Së pari u përgjigj më
DocType: Website Item Group,Cross Listing of Item in multiple groups,Kryqi Listimi i artikullit në grupe të shumta
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},Viti Fiskal Data e Fillimit dhe Viti Fiskal Fundi Data e janë vendosur tashmë në vitin fiskal {0}
DocType: Projects Settings,Ignore User Time Overlap,Injoroni Mbivendosjen e Kohës së Përdoruesit
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113,Clearance Date updated,Pastrimi Date updated
apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Batch Split
apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Batch Split
DocType: Stock Settings,Batch Identification,Identifikimi i Serisë
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,Harmonizuar me sukses
DocType: Request for Quotation Supplier,Download PDF,Shkarko PDF
DocType: Work Order,Planned End Date,Planifikuar Data e Përfundimit
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Lista fshehur duke ruajtur listën e kontakteve të lidhura me Aksionarin
apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informacioni mbi tipin e donatorit.
DocType: Request for Quotation,Supplier Detail,furnizuesi Detail
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Error ne formulen ose gjendje: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +106,Invoiced Amount,Shuma e faturuar
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Peshat e kriterit duhet të shtojnë deri në 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Pjesëmarrje
apps/erpnext/erpnext/public/js/pos/pos.html +115,Stock Items,Stock Items
DocType: BOM,Materials,Materiale
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Nëse nuk kontrollohet, lista do të duhet të shtohet për çdo Departamentit ku ajo duhet të zbatohet."
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111,Creating {0},Krijimi i {0}
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Burimi dhe Target Warehouse nuk mund të jetë e njëjtë
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +628,Posting date and posting time is mandatory,Postimi datën dhe postimi kohë është i detyrueshëm
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Template taksave për blerjen e transaksioneve.
,Item Prices,Çmimet pika
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,Me fjalë do të jetë i dukshëm një herë ju ruani qëllim blerjen.
DocType: Woocommerce Settings,Endpoint,Pika e fundit
DocType: Period Closing Voucher,Period Closing Voucher,Periudha Voucher Mbyllja
DocType: Consultation,Review Details,Detajet e shqyrtimit
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185,The shareholder does not belong to this company,Aksioneri nuk i përket kësaj kompanie
DocType: Dosage Form,Dosage Form,Formulari i Dozimit
apps/erpnext/erpnext/config/selling.py +67,Price List master.,Lista e Çmimeve mjeshtër.
DocType: Task,Review Date,Data shqyrtim
DocType: BOM,Allow Alternative Item,Lejo artikullin alternativ
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Seria për Shënimin e Zhvlerësimit të Aseteve (Hyrja e Gazetës)
DocType: Membership,Member Since,Anëtar që prej
DocType: Purchase Invoice,Advance Payments,Pagesat e paradhënies
DocType: Purchase Taxes and Charges,On Net Total,On Net Total
apps/erpnext/erpnext/controllers/item_variant.py +92,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vlera për atribut {0} duhet të jetë brenda intervalit {1} të {2} në increments e {3} për Item {4}
DocType: Restaurant Reservation,Waitlisted,e konfirmuar
apps/erpnext/erpnext/accounts/doctype/account/account.py +124,Currency can not be changed after making entries using some other currency,"Valuta nuk mund të ndryshohet, pasi duke e bërë shënimet duke përdorur disa valutë tjetër"
DocType: Shipping Rule,Fixed,fiks
DocType: Vehicle Service,Clutch Plate,Plate Clutch
DocType: Company,Round Off Account,Rrumbullakët Off Llogari
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Shpenzimet administrative
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Këshillues
DocType: Customer Group,Parent Customer Group,Grupi prind Klientit
DocType: Journal Entry,Subscription,abonim
DocType: Purchase Invoice,Contact Email,Kontakti Email
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Krijimi i tarifës në pritje
DocType: Appraisal Goal,Score Earned,Vota fituara
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241,Notice Period,Periudha Njoftim
DocType: Asset Category,Asset Category Name,Asset Category Emri
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Kjo është një territor rrënjë dhe nuk mund të redaktohen.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Emri i ri Sales Person
DocType: Packing Slip,Gross Weight UOM,Bruto Pesha UOM
DocType: Asset Maintenance Task,Preventive Maintenance,Mirëmbajtje parandaluese
DocType: Delivery Note Item,Against Sales Invoice,Kundër Sales Faturës
DocType: Purchase Invoice,07-Others,07-Të tjerët
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +156,Please enter serial numbers for serialized item ,Ju lutem shkruani numrat serik për artikull serialized
DocType: Bin,Reserved Qty for Production,Rezervuar Qty për Prodhimin
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. ,Dërgo pakontrolluar në qoftë se ju nuk doni të marrin në konsideratë duke bërë grumbull grupet kurs të bazuar.
DocType: Asset,Frequency of Depreciation (Months),Frekuenca e Zhvlerësimit (Muaj)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500,Credit Account,Llogaria e Kredisë
DocType: Landed Cost Item,Landed Cost Item,Kosto zbarkoi Item
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Trego zero vlerat
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Sasia e sendit të marra pas prodhimit / ripaketimin nga sasi të caktuara të lëndëve të para
DocType: Lab Test,Test Group,Grupi i Testimeve
DocType: Payment Reconciliation,Receivable / Payable Account,Arkëtueshme / pagueshme Llogaria
DocType: Delivery Note Item,Against Sales Order Item,Kundër Sales Rendit Item
DocType: Hub Settings,Company Logo,Logo e kompanisë
apps/erpnext/erpnext/stock/doctype/item/item.py +709,Please specify Attribute Value for attribute {0},Ju lutem specifikoni atribut Vlera për atribut {0}
DocType: Item,Default Warehouse,Gabim Magazina
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Buxheti nuk mund të caktohet kundër Llogaria Grupit {0}
DocType: Healthcare Settings,Patient Registration,Regjistrimi i pacientit
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Ju lutemi shkruani qendra kosto prind
DocType: Delivery Note,Print Without Amount,Print Pa Shuma
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,Zhvlerësimi Date
,Work Orders in Progress,Rendi i punës në vazhdim
DocType: Issue,Support Team,Mbështetje Ekipi
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Skadimit (në ditë)
DocType: Appraisal,Total Score (Out of 5),Rezultati i përgjithshëm (nga 5)
DocType: Fee Structure,FS.,FS.
DocType: Student Attendance Tool,Batch,Grumbull
DocType: Donor,Donor Type,Lloji i donatorit
apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Ekuilibër
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Ju lutemi zgjidhni Kompaninë
DocType: Room,Seating Capacity,Seating Kapaciteti
DocType: Issue,ISS-,ISS-
DocType: Lab Test Groups,Lab Test Groups,Grupet e Testimit Lab
DocType: Project,Total Expense Claim (via Expense Claims),Gjithsej Kërkesa shpenzimeve (nëpërmjet kërkesave shpenzime)
DocType: GST Settings,GST Summary,GST Përmbledhje
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,Aktivizo llogarinë hyrëse të parazgjedhur para se të krijosh Grupin e përmbledhur të punës ditore
DocType: Assessment Result,Total Score,Total Score
DocType: Journal Entry,Debit Note,Debiti Shënim
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +102,Please enter API Consumer Secret,Ju lutemi shkruani API Consumer Secret
DocType: Stock Entry,As per Stock UOM,Sipas Stock UOM
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Jo Skaduar
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49,ValidDate,ValidDate
DocType: Student Log,Achievement,arritje
DocType: Batch,Source Document Type,Burimi Lloji i dokumentit
DocType: Batch,Source Document Type,Burimi Lloji i dokumentit
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Pas orarit të kurseve u krijuan
DocType: Journal Entry,Total Debit,Debiti i përgjithshëm
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Default përfunduara Mallra Magazina
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108,Please select Patient,Ju lutemi zgjidhni Patient
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Sales Person
DocType: Hotel Room Package,Amenities,pajisje
apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Buxheti dhe Qendra Kosto
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Mënyra e parazgjedhur e pagesës nuk lejohet
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,për
,Appointment Analytics,Analiza e emërimeve
DocType: Vehicle Service,Half Yearly,Gjysma vjetore
DocType: Lead,Blog Subscriber,Blog Subscriber
DocType: Guardian,Alternate Number,Numri Alternate
DocType: Healthcare Settings,Consultations in valid days,Konsultimet në ditë të vlefshme
DocType: Assessment Plan Criteria,Maximum Score,Maximum Score
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Krijo rregulla për të kufizuar transaksionet në bazë të vlerave.
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Llogaritë e përcaktimit të rrjedhës së parasë së gatshme
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupi Roll No
DocType: Batch,Manufacturing Date,Date e prodhimit
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Krijimi i taksës dështoi
DocType: Opening Invoice Creation Tool,Create Missing Party,Krijoni Partinë e Zhdukur
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Lini bosh në qoftë se ju bëni studentëve grupet në vit
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Nëse kontrolluar, Gjithsej nr. i ditëve të punës do të përfshijë pushimet, dhe kjo do të zvogëlojë vlerën e pagave Per Day"
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +25,"Apps using current key won't be able to access, are you sure?","Aplikacionet që përdorin çelësin aktual nuk do të jenë në gjendje të hyjnë, jeni i sigurt?"
DocType: Purchase Invoice,Total Advance,Advance Total
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Ndrysho kodin e modelit
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.,"Term End Date nuk mund të jetë më herët se data e fillimit Term. Ju lutem, Korrigjo datat dhe provoni përsëri."
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,quot Count
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,quot Count
,BOM Stock Report,BOM Stock Raporti
DocType: Stock Reconciliation Item,Quantity Difference,sasia Diferenca
DocType: Employee Advance,EA-,EA-
DocType: Opportunity Item,Basic Rate,Norma bazë
DocType: GL Entry,Credit Amount,Shuma e kreditit
DocType: Cheque Print Template,Signatory Position,Pozita nënshkruese
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173,Set as Lost,Bëje si Lost
DocType: Timesheet,Total Billable Hours,Gjithsej orëve billable
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Pagesa Pranimi Shënim
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Kjo është e bazuar në transaksionet kundër këtij Klientit. Shih afat kohor më poshtë për detaje
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},Row {0}: Shuma e alokuar {1} duhet të jetë më pak se ose e barabartë me shumën e pagesës Hyrja {2}
DocType: Program Enrollment Tool,New Academic Term,Term i ri akademik
,Course wise Assessment Report,Raporti i Vlerësimit kurs i mençur
DocType: Purchase Invoice,Availed ITC State/UT Tax,Availed ITC State / UT Tax
DocType: Tax Rule,Tax Rule,Rregulla Tatimore
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Ruajtja njëjtin ritëm Gjatë gjithë Sales Cikli
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planifikoni kohë shkrimet jashtë orarit Workstation punës.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} nuk ka një orar të mjekut. Shtoni në Master
apps/erpnext/erpnext/public/js/pos/pos.html +98,Customers in Queue,Konsumatorët në radhë
DocType: Driver,Issuing Date,Data e lëshimit
DocType: Student,Nationality,kombësi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109,Submit this Work Order for further processing.,Dorëzoni këtë Urdhër të Punës për përpunim të mëtejshëm.
,Items To Be Requested,Items të kërkohet
DocType: Purchase Order,Get Last Purchase Rate,Get fundit Blerje Vlerësoni
DocType: Company,Company Info,Company Info
apps/erpnext/erpnext/accounts/page/pos/pos.js +1385,Select or add new customer,Zgjidhni ose shtoni klient të ri
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173,Cost center is required to book an expense claim,Qendra Kosto është e nevojshme për të librit një kërkesë shpenzimeve
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplikimi i mjeteve (aktiveve)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Kjo është e bazuar në pjesëmarrjen e këtij punonjësi
DocType: Assessment Result,Summary,përmbledhje
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Pjesëmarrja e Markut
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494,Debit Account,Llogaria Debiti
DocType: Fiscal Year,Year Start Date,Viti Data e Fillimit
DocType: Attendance,Employee Name,Emri punonjës
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Produkti i Renditjes
DocType: Purchase Invoice,Rounded Total (Company Currency),Harmonishëm Total (Kompania Valuta)
apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Cannot covert to Group because Account Type is selected.,Nuk mund të fshehta të grupit për shkak Tipi Llogarisë është zgjedhur.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} është modifikuar. Ju lutem refresh.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Stop përdoruesit nga bërja Dërgo Aplikacione në ditët në vijim.
DocType: Asset Maintenance Team,Maintenance Team Members,Anëtarët e ekipit të mirëmbajtjes
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Shuma Blerje
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Furnizuesi Citat {0} krijuar
apps/erpnext/erpnext/accounts/report/financial_statements.py +103,End Year cannot be before Start Year,Fundi Viti nuk mund të jetë para se të fillojë Vitit
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Employee Benefits,Përfitimet e Punonjësve
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264,Packed quantity must equal quantity for Item {0} in row {1},Sasia e mbushur duhet të barabartë sasi për Item {0} në rresht {1}
DocType: Work Order,Manufactured Qty,Prodhuar Qty
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78,The shares don't exist with the {0},Aksionet nuk ekzistojnë me {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Fatura u krijua
DocType: Asset,Out of Order,Jashtë përdorimit
DocType: Purchase Receipt Item,Accepted Quantity,Sasi të pranuar
DocType: Projects Settings,Ignore Workstation Time Overlap,Ignore Time Workstation Mbivendosje
apps/erpnext/erpnext/hr/doctype/employee/employee.py +243,Please set a default Holiday List for Employee {0} or Company {1},Ju lutemi të vendosur një default Holiday Lista për punonjësit {0} ose Company {1}
apps/erpnext/erpnext/accounts/party.py +30,{0}: {1} does not exists,{0}: {1} nuk ekziston
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Zgjidh Batch Numbers
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Faturat e ngritura për të Konsumatorëve.
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Projekti 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},Row Asnjë {0}: Shuma nuk mund të jetë më e madhe se pritje Shuma kundër shpenzimeve sipas Pretendimit {1}. Në pritje Shuma është {2}
DocType: Patient Service Unit,Medical Administrator,Administrator Mjekësor
DocType: Assessment Plan,Schedule,Orar
DocType: Account,Parent Account,Llogaria prind
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +295,Available,Në dispozicion
DocType: Quality Inspection Reading,Reading 3,Leximi 3
DocType: Stock Entry,Source Warehouse Address,Adresa e Burimeve të Burimeve
DocType: GL Entry,Voucher Type,Voucher Type
apps/erpnext/erpnext/accounts/page/pos/pos.js +1717,Price List not found or disabled,Lista e Çmimeve nuk u gjet ose me aftësi të kufizuara
DocType: Student Applicant,Approved,I miratuar
apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Çmim
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267,Employee relieved on {0} must be set as 'Left',Punonjës lirohet për {0} duhet të jetë vendosur si &#39;majtë&#39;
DocType: Hub Settings,Last Sync On,Sinjali i fundit në
DocType: Guardian,Guardian,kujdestar
DocType: Item Alternative,Item Alternative,Alternativa e artikullit
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Krijoni konsumatorë ose furnizues të humbur.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Vlerësimi {0} krijuar për punonjësit {1} në datën e caktuar varg
DocType: Academic Term,Education,Arsim
apps/erpnext/erpnext/public/js/pos/pos.html +89,Del,del
DocType: Selling Settings,Campaign Naming By,Emërtimi Fushata By
DocType: Employee,Current Address Is,Adresa e tanishme është
apps/erpnext/erpnext/utilities/user_progress.py +51,Monthly Sales Target (,Synimi i shitjeve mujore (
DocType: Physician Service Unit Schedule,Physician Service Unit Schedule,Orari i Shërbimit të Mjeku
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modifikuar
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Fakultative. Vë monedhë default kompanisë, nëse nuk është specifikuar."
DocType: Sales Invoice,Customer GSTIN,GSTIN Customer
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 ,"Lista e sëmundjeve të zbuluara në terren. Kur zgjidhet, do të shtojë automatikisht një listë të detyrave për t&#39;u marrë me sëmundjen"
DocType: Asset Repair,Repair Status,Gjendja e Riparimit
apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Rregjistrimet në ditar të kontabilitetit.
DocType: Delivery Note Item,Available Qty at From Warehouse,Qty në dispozicion në nga depo
DocType: POS Profile,Account for Change Amount,Llogaria për Ndryshim Shuma
DocType: Purchase Invoice,input service,shërbimi i hyrjes
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Row {0}: Partia / Llogaria nuk përputhet me {1} / {2} në {3} {4}
DocType: Maintenance Team Member,Maintenance Team Member,Anëtar i ekipit të mirëmbajtjes
DocType: Agriculture Analysis Criteria,Soil Analysis,Analiza e tokës
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13,Course Code: ,Kodi i kursit:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Ju lutemi shkruani Llogari kurriz
DocType: Account,Stock,Stock
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Reference Lloji i dokumentit duhet të jetë një e Rendit Blerje, Blerje Faturë ose Journal Entry"
DocType: Employee,Current Address,Adresa e tanishme
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","Nëse pika është një variant i një tjetër çështje pastaj përshkrimin, imazhi, çmimi, taksat, etj do të vendoset nga template përveç nëse specifikohet shprehimisht"
DocType: Serial No,Purchase / Manufacture Details,Blerje / Detajet Prodhimi
DocType: Assessment Group,Assessment Group,Grupi i Vlerësimit
apps/erpnext/erpnext/config/stock.py +333,Batch Inventory,Inventar Batch
DocType: Employee,Contract End Date,Kontrata Data e përfundimit
DocType: Sales Order,Track this Sales Order against any Project,Përcjell këtë Urdhër Sales kundër çdo Projektit
DocType: Sales Invoice Item,Discount and Margin,Discount dhe Margin
DocType: Lab Test,Prescription,recetë
DocType: Project,Second Email,Emaili i dytë
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111,Not Available,Not Available
DocType: Pricing Rule,Min Qty,Min Qty
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Çaktivizo modelin
DocType: GL Entry,Transaction Date,Transaksioni Data
DocType: Production Plan Item,Planned Qty,Planifikuar Qty
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Tatimi Total
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +245,For Quantity (Manufactured Qty) is mandatory,Për sasinë (Prodhuar Qty) është i detyrueshëm
DocType: Stock Entry,Default Target Warehouse,Gabim Magazina Target
DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Kompania Valuta)
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.,"Viti End Date nuk mund të jetë më herët se data e fillimit Year. Ju lutem, Korrigjo datat dhe provoni përsëri."
DocType: Notification Control,Purchase Receipt Message,Blerje Pranimi Mesazh
DocType: BOM,Scrap Items,Items skrap
DocType: Work Order,Actual Start Date,Aktuale Data e Fillimit
DocType: Sales Order,% of materials delivered against this Sales Order,% E materialeve dorëzuar kundër këtij Rendit Shitje
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Work Orders.,Jepni Kërkesat Materiale (MRP) dhe Urdhërat e Punës.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Vendosni mënyrën e paracaktuar të pagesës
DocType: Grant Application,Withdrawn,I tërhequr
DocType: Hub Settings,Hub Settings,Hub Cilësimet
DocType: Project,Gross Margin %,Marzhi bruto%
DocType: BOM,With Operations,Me Operacioneve
apps/erpnext/erpnext/accounts/party.py +259,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,"Regjistrimet kontabël tashmë janë bërë në monedhën {0} për kompaninë {1}. Ju lutem, përzgjidhni një llogari arkëtueshëm ose të pagueshëm me monedhën {0}."
DocType: Asset,Is Existing Asset,Është Asetin ekzistuese
DocType: Salary Detail,Statistical Component,Komponenti statistikore
DocType: Salary Detail,Statistical Component,Komponenti statistikore
DocType: Warranty Claim,If different than customer address,Nëse është e ndryshme se sa adresën e konsumatorëve
DocType: Purchase Invoice,Without Payment of Tax,Pa pagesën e tatimit
DocType: BOM Operation,BOM Operation,Bom Operacioni
apps/erpnext/erpnext/config/stock.py +145,Fulfilment,përmbushje
DocType: Purchase Taxes and Charges,On Previous Row Amount,Në Shuma Previous Row
DocType: Item,Has Expiry Date,Ka Data e Skadimit
apps/erpnext/erpnext/assets/doctype/asset/asset.js +282,Transfer Asset,Asset Transfer
DocType: POS Profile,POS Profile,POS Profilin
DocType: Training Event,Event Name,Event Emri
DocType: Physician,Phone (Office),Telefoni (Zyra)
apps/erpnext/erpnext/hooks.py +151,Admission,pranim
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Regjistrimet për {0}
apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Sezonalitetit për vendosjen buxhetet, objektivat etj"
DocType: Supplier Scorecard Scoring Variable,Variable Name,Emri i ndryshueshëm
apps/erpnext/erpnext/stock/get_item_details.py +144,"Item {0} is a template, please select one of its variants","Item {0} është një template, ju lutem zgjidhni një nga variantet e saj"
DocType: Asset,Asset Category,Asset Category
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Paguajnë neto nuk mund të jetë negative
DocType: Purchase Order,Advance Paid,Advance Paid
DocType: Item,Item Tax,Tatimi i artikullit
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883,Material to Supplier,Materiale për Furnizuesin
DocType: Soil Texture,Loamy Sand,Rërë e pangopur
DocType: Production Plan,Material Request Planning,Planifikimi i Kërkesave Materiale
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +676,Excise Invoice,Akciza Faturë
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Pragun {0}% shfaqet më shumë se një herë
DocType: Expense Claim,Employees Email Id,Punonjësit Email Id
DocType: Employee Attendance Tool,Marked Attendance,Pjesëmarrja e shënuar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Detyrimet e tanishme
apps/erpnext/erpnext/public/js/projects/timer.js +138,Timer exceeded the given hours.,Timer tejkalonte orët e dhëna.
apps/erpnext/erpnext/config/selling.py +297,Send mass SMS to your contacts,Dërgo SMS në masë për kontaktet tuaja
DocType: Patient,A Positive,Një pozitive
DocType: Program,Program Name,program Emri
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Konsideroni tatimit apo detyrimit për
DocType: Driver,Driving License Category,Kategoria e licencës së vozitjes
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158,No Reference,Asnjë referencë
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Aktuale Qty është e detyrueshme
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} aktualisht ka një {1} Scorecard të Furnizuesit, dhe Urdhërat e Blerjes për këtë furnizues duhet të lëshohen me kujdes."
DocType: Asset Maintenance Team,Asset Maintenance Team,Ekipi i Mirëmbajtjes së Aseteve
DocType: Employee Loan,Loan Type,Lloji Loan
DocType: Scheduling Tool,Scheduling Tool,caktimin Tool
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Credit Card
DocType: BOM,Item to be manufactured or repacked,Pika për të prodhuar apo ripaketohen
DocType: Employee Education,Major/Optional Subjects,/ Subjektet e mëdha fakultative
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Driver,Suspended,pezulluar
DocType: Training Event,Attendees,pjesëmarrësit
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Këtu ju mund të mbajë të dhënat e familjes si emrin dhe profesionin e prindërve, bashkëshortit dhe fëmijëve"
DocType: Academic Term,Term End Date,Term End Date
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Taksat dhe Tarifat zbritet (Kompania Valuta)
DocType: Item Group,General Settings,Cilësimet përgjithshme
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Nga Valuta dhe me monedhën nuk mund të jetë e njëjtë
DocType: Stock Entry,Repack,Ripaketoi
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Ju duhet të ruani formën para se të vazhdoni
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Ju lutem zgjidhni fillimisht Kompaninë
DocType: Item Attribute,Numeric Values,Vlerat numerike
apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Bashkangjit Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,Nivelet e aksioneve
DocType: Customer,Commission Rate,Rate Komisioni
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Krijuar {0} tabelat e rezultateve për {1} midis:
apps/erpnext/erpnext/stock/doctype/item/item.js +527,Make Variant,Bëni Variant
apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Aplikacionet pushimit bllok nga departamenti.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155,"Payment Type must be one of Receive, Pay and Internal Transfer","Pagesa Lloji duhet të jetë një nga Merre, të paguajë dhe Transfer të Brendshme"
apps/erpnext/erpnext/config/selling.py +184,Analytics,analitikë
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Shporta është bosh
DocType: Vehicle,Model,Model
DocType: Work Order,Actual Operating Cost,Aktuale Kosto Operative
DocType: Payment Entry,Cheque/Reference No,Çek / Reference No
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py +81,Root cannot be edited.,Rrënjë nuk mund të redaktohen.
DocType: Item,Units of Measure,Njësitë e masës
DocType: Manufacturing Settings,Allow Production on Holidays,Lejo Prodhimi në pushime
DocType: Sales Invoice,Customer's Purchase Order Date,Konsumatorit Rendit Blerje Data
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Capital Stock
DocType: Shopping Cart Settings,Show Public Attachments,Trego Attachments publike
DocType: Packing Slip,Package Weight Details,Paketa Peshë Detajet
DocType: Restaurant Reservation,Reservation Time,Koha e rezervimit
DocType: Payment Gateway Account,Payment Gateway Account,Pagesa Llogaria Gateway
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Pas përfundimit të pagesës përcjellëse përdorues në faqen e zgjedhur.
DocType: Company,Existing Company,Company ekzistuese
DocType: Healthcare Settings,Result Emailed,Rezultati u dërgua me email
apps/erpnext/erpnext/controllers/buying_controller.py +88,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Tax Category ka ndryshuar për të &quot;Total&quot;, sepse të gjitha sendet janë artikuj jo-aksioneve"
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,"Ju lutem, përzgjidhni një skedar CSV"
DocType: Student Leave Application,Mark as Present,Mark si pranishëm
DocType: Supplier Scorecard,Indicator Color,Treguesi Ngjyra
DocType: Purchase Order,To Receive and Bill,Për të marrë dhe Bill
apps/erpnext/erpnext/controllers/buying_controller.py +461,Row #{0}: Reqd by Date cannot be before Transaction Date,Rreshti # {0}: Reqd by Date nuk mund të jetë para datës së transaksionit
apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Produkte Featured
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Projektues
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Termat dhe Kushtet Template
DocType: Serial No,Delivery Details,Detajet e ofrimit të
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495,Cost Center is required in row {0} in Taxes table for type {1},Qendra Kosto është e nevojshme në rresht {0} në Tatimet tryezë për llojin {1}
DocType: Program,Program Code,Kodi program
DocType: Terms and Conditions,Terms and Conditions Help,Termat dhe Kushtet Ndihmë
,Item-wise Purchase Register,Pika-mençur Blerje Regjistrohu
DocType: Driver,Expiry Date,Data e Mbarimit
DocType: Healthcare Settings,Employee name and designation in print,Emri i punonjësit dhe emërtimi në shtyp
,accounts-browser,Llogaritë-browser
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Ju lutemi zgjidhni kategorinë e parë
apps/erpnext/erpnext/config/projects.py +13,Project master.,Mjeshtër projekt.
apps/erpnext/erpnext/controllers/status_updater.py +212,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Për të lejuar mbi-faturimit ose mbi-urdhërimin, të rinovuar &quot;Allowance&quot; në Stock Settings ose Item."
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,A nuk tregojnë ndonjë simbol si $ etj ardhshëm të valutave.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431, (Half Day),(Gjysme Dite)
DocType: Payment Term,Credit Days,Ditët e kreditit
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,"Ju lutemi, përzgjidhni Pacientin për të marrë Testet Lab"
apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Bëni Serisë Student
DocType: Fee Schedule,FRQ.,FRQ.
DocType: Leave Type,Is Carry Forward,Është Mbaj Forward
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841,Get Items from BOM,Të marrë sendet nga bom
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40,Lead Time Days,Lead ditësh
DocType: Cash Flow Mapping,Is Income Tax Expense,Është shpenzimi i tatimit mbi të ardhurat
apps/erpnext/erpnext/controllers/accounts_controller.py +621,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Posting Data duhet të jetë i njëjtë si data e blerjes {1} e aseteve {2}
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Kontrolloni këtë nëse studenti banon në Hostel e Institutit.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Ju lutem shkruani urdhëron Sales në tabelën e mësipërme
,Stock Summary,Stock Përmbledhje
apps/erpnext/erpnext/config/assets.py +54,Transfer an asset from one warehouse to another,Transferimi një aktiv nga një magazinë në tjetrën
DocType: Vehicle,Petrol,benzinë
apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Bill e materialeve
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Partia Lloji dhe Partia është e nevojshme për arkëtueshme / pagueshme llogari {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref Data
DocType: Employee,Reason for Leaving,Arsyeja e largimit
DocType: BOM Operation,Operating Cost(Company Currency),Kosto Operative (Company Valuta)
DocType: Employee Loan Application,Rate of Interest,Norma e interesit
DocType: Expense Claim Detail,Sanctioned Amount,Shuma e sanksionuar
DocType: Item,Shelf Life In Days,Jeta në skarë në ditë
DocType: GL Entry,Is Opening,Është Hapja
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Row {0}: debiti hyrja nuk mund të jetë i lidhur me një {1}
DocType: Journal Entry,Subscription Section,Seksioni i abonimit
apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Llogaria {0} nuk ekziston
DocType: Training Event,Training Program,Programi i Trajnimit
DocType: Account,Cash,Para
DocType: Employee,Short biography for website and other publications.,Biografia e shkurtër për faqen e internetit dhe botime të tjera.
