b'DocType: Employee',b'Salary Mode',b'Palkan tila'
b'DocType: Patient',b'Divorced',b'eronnut'
b'DocType: Buying Settings',b'Allow Item to be added multiple times in a transaction',b'Salli Kohta lis\xc3\xa4t\xc3\xa4\xc3\xa4n useita kertoja liiketoimi'
b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33',b'Cancel Material Visit {0} before cancelling this Warranty Claim',b'Peru materiaalik\xc3\xa4ynti {0} ennen takuuanomuksen perumista'
b'apps/erpnext/erpnext/config/education.py +118',b'Assessment Reports',b'Arviointikertomukset'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19',b'Consumer Products',b'Kuluttajatuotteet'
b'DocType: Purchase Receipt',b'Subscription Detail',b'Tilauksen yksityiskohdat'
b'DocType: Supplier Scorecard',b'Notify Supplier',b'Ilmoita toimittajalle'
b'DocType: Item',b'Customer Items',b'Asiakkaan nimikkeet'
b'DocType: Project',b'Costing and Billing',b'Kustannuslaskenta ja laskutus'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +48',b'Account {0}: Parent account {1} can not be a ledger',b'tili {0}: emotili {1} ei voi tilikirja'
b'DocType: Item',b'Publish Item to hub.erpnext.com',b'Julkaise Tuote on hub.erpnext.com'
b'apps/erpnext/erpnext/config/setup.py +88',b'Email Notifications',b's\xc3\xa4hk\xc3\xb6posti-ilmoitukset'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26',b'Evaluation',b'arviointi'
b'DocType: Item',b'Default Unit of Measure',b'Oletusyksikk\xc3\xb6'
b'DocType: SMS Center',b'All Sales Partner Contact',b'kaikki myyntikumppanin yhteystiedot'
b'DocType: Employee',b'Leave Approvers',b'Poissaolojen hyv\xc3\xa4ksyj\xc3\xa4t'
b'DocType: Sales Partner',b'Dealer',b'jakaja'
b'DocType: Work Order',b'WO-',b'WO-'
b'DocType: Consultation',b'Investigations',b'tutkimukset'
b'DocType: Restaurant Order Entry',b'Click Enter To Add',b'Napsauta Enter to Add (Lis\xc3\xa4\xc3\xa4)'
b'DocType: Employee',b'Rented',b'Vuokrattu'
b'DocType: Purchase Order',b'PO-',b'PO-'
b'DocType: Vehicle Service',b'Mileage',b'mittarilukema'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +253',b'Do you really want to scrap this asset?',b'Haluatko todella romuttaa t\xc3\xa4m\xc3\xa4n omaisuuden?'
b'DocType: Drug Prescription',b'Update Schedule',b'P\xc3\xa4ivit\xc3\xa4 aikataulu'
b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44',b'Select Default Supplier',b'Valitse Oletus toimittaja'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37',b'Currency is required for Price List {0}',b'valuuttahinnasto vaaditaan {0}'
b'DocType: Sales Taxes and Charges Template',b'* Will be calculated in the transaction.',b'* lasketaan tapahtumassa'
b'DocType: Purchase Order',b'Customer Contact',b'Asiakaspalvelu Yhteystiedot'
b'DocType: Patient Appointment',b'Check availability',b'Tarkista saatavuus'
b'DocType: Job Applicant',b'Job Applicant',b'Ty\xc3\xb6nhakija'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6',b'This is based on transactions against this Supplier. See timeline below for details',b'Toimittajaan liittyv\xc3\xa4t tapahtumat.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120',b'Legal',b'Oikeudellinen'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191',b'Actual type tax cannot be included in Item rate in row {0}',b'todellista veroa ei voi sis\xc3\xa4llytt\xc3\xa4\xc3\xa4 tuotteen tasoon rivill\xc3\xa4 {0}'
b'DocType: Bank Guarantee',b'Customer',b'Asiakas'
b'DocType: Purchase Receipt Item',b'Required By',b'pyyt\xc3\xa4j\xc3\xa4'
b'DocType: Delivery Note',b'Return Against Delivery Note',b'palautus kohdistettuna l\xc3\xa4hetteeseen'
b'DocType: Purchase Order',b'% Billed',b'% laskutettu'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43',b'Exchange Rate must be same as {0} {1} ({2})',b'Valuuttakurssi on oltava sama kuin {0} {1} ({2})'
b'DocType: Sales Invoice',b'Customer Name',b'Asiakkaan nimi'
b'DocType: Vehicle',b'Natural Gas',b'Maakaasu'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64',b'Bank account cannot be named as {0}',b'Pankkitilin ei voida nimetty {0}'
b'DocType: Account',b'Heads (or groups) against which Accounting Entries are made and balances are maintained.',"b'P\xc3\xa4\xc3\xa4n, (tai ryhm\xc3\xa4n), kohdistetut kirjanpidon kirjaukset tehd\xc3\xa4\xc3\xa4n ja tase s\xc3\xa4ilytet\xc3\xa4\xc3\xa4n'"
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196',b'Outstanding for {0} cannot be less than zero ({1})',b'odottavat {0} ei voi olla alle nolla ({1})'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348',b'There are no submitted Salary Slips to process.',b'Yht\xc3\xa4\xc3\xa4n vahvistettua palkkatositetta ei ole.'
b'DocType: Manufacturing Settings',b'Default 10 mins',b'oletus 10 min'
b'DocType: Leave Type',b'Leave Type Name',b'Vapaatyypin nimi'
b'apps/erpnext/erpnext/templates/pages/projects.js +62',b'Show open',b'N\xc3\xa4yt\xc3\xa4 auki'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8',b'It is necessary to take this action today itself for the above mentioned recurring',b'On v\xc3\xa4ltt\xc3\xa4m\xc3\xa4t\xc3\xb6nt\xc3\xa4 toteuttaa t\xc3\xa4m\xc3\xa4 toiminta itsest\xc3\xa4\xc3\xa4n edell\xc3\xa4 mainittujen toistuvasti'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156',b'Series Updated Successfully',b'Sarja p\xc3\xa4ivitetty onnistuneesti'
b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6',b'Checkout',b'Tarkista'
b'DocType: Pricing Rule',b'Apply On',b'k\xc3\xa4yt\xc3\xa4'
b'DocType: Item Price',b'Multiple Item prices.',b'Useiden Item hinnat.'
,b'Purchase Order Items To Be Received',b'Toimittajilta saapumattomat ostotilaukset'
b'DocType: SMS Center',b'All Supplier Contact',b'kaikki toimittajan yhteystiedot'
b'DocType: Support Settings',b'Support Settings',b'Tukiasetukset'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +75',b'Expected End Date can not be less than Expected Start Date',b'odotettu p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4 ei voi olla pienempi kuin odotettu aloitusp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/utilities/transaction_base.py +121',b'Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ',b'rivi # {0}: taso tulee olla sama kuin {1}: {2} ({3} / {4})'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241',b'New Leave Application',b'uusi poistumissovellus'
,b'Batch Item Expiry Status',b'Er\xc3\xa4 Item K\xc3\xa4yt tila'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184',b'Bank Draft',b'pankki sekki'
b'DocType: Membership',b'membership validaty section',b'j\xc3\xa4senyys validaty-osio'
b'DocType: Mode of Payment Account',b'Mode of Payment Account',b'maksutilin tila'
b'DocType: Consultation',b'Consultation',b'kuuleminen'
b'DocType: Accounts Settings',b'Show Payment Schedule in Print',b'N\xc3\xa4yt\xc3\xa4 maksuaikataulu Tulosta'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19',b'Sales and Returns',b'Myynti ja tuotot'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +56',b'Show Variants',b'N\xc3\xa4yt\xc3\xa4 mallivaihtoehdot'
b'DocType: Academic Term',b'Academic Term',b'Academic Term'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14',b'Material',b'Materiaali'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66',b'Making website',b'Sivuston luominen'
b'DocType: Opening Invoice Creation Tool Item',b'Quantity',b'M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546',b'Accounts table cannot be blank.',b'-Taulukon voi olla tyhj\xc3\xa4.'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154',b'Loans (Liabilities)',b'lainat (vastattavat)'
b'DocType: Employee Education',b'Year of Passing',b'valmistumisvuosi'
b'DocType: Item',b'Country of Origin',b'Alkuper\xc3\xa4maa'
b'DocType: Soil Texture',b'Soil Texture Criteria',b'Maaper\xc3\xa4n laatuvaatimukset'
b'apps/erpnext/erpnext/templates/includes/product_page.js +25',b'In Stock',b'Varastossa'
b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16',b'Primary Contact Details',b'Ensisijaiset yhteystiedot'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46',b'Open Issues',b'Avoimet kysymykset'
b'DocType: Production Plan Item',b'Production Plan Item',b'Tuotanto Plan Item'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +149',b'User {0} is already assigned to Employee {1}',b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4 {0} on jo asetettu ty\xc3\xb6suhteeseen organisaatiossa {1}'
b'DocType: Lab Test Groups',b'Add new line',b'Lis\xc3\xa4\xc3\xa4 uusi rivi'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31',b'Health Care',b'terveydenhuolto'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65',b'Delay in payment (Days)',b'Viiv\xc3\xa4styminen (p\xc3\xa4iv\xc3\xa4\xc3\xa4)'
b'DocType: Payment Terms Template Detail',b'Payment Terms Template Detail',b'Maksuehdot Mallipohja'
b'DocType: Hotel Room Reservation',b'Guest Name',b'Vieraan nimi'
b'DocType: Lab Prescription',b'Lab Prescription',b'Lab Prescription'
,b'Delay Days',b'Viivep\xc3\xa4iv\xc3\xa4t'
b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26',b'Service Expense',b'palvelu Expense'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899',b'Serial Number: {0} is already referenced in Sales Invoice: {1}',b'Sarjanumero: {0} on jo viitattu myyntilasku: {1}'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889',b'Invoice',b'lasku'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145',b'Make Retention Stock Entry',b'Tee s\xc3\xa4ilytyskurssi'
b'DocType: Purchase Invoice Item',b'Item Weight Details',b'Kohde Painon tiedot'
b'DocType: Asset Maintenance Log',b'Periodicity',b'Jaksotus'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21',b'Fiscal Year {0} is required',b'Verovuoden {0} vaaditaan'
b'DocType: Crop Cycle',b'The minimum distance between rows of plants for optimum growth',b'Minimaalinen et\xc3\xa4isyys kasvien riveist\xc3\xa4 optimaaliseen kasvuun'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21',b'Defense',b'puolustus'
b'DocType: Salary Component',b'Abbr',b'lyhenteet'
b'DocType: Appraisal Goal',b'Score (0-5)',b'Pisteet (0-5)'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225',b'Row {0}: {1} {2} does not match with {3}',b'rivi {0}: {1} {2} ei t\xc3\xa4sm\xc3\xa4\xc3\xa4 {3} kanssa'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77',b'Row # {0}:',b'Rivi # {0}:'
b'DocType: Timesheet',b'Total Costing Amount',b'Yhteens\xc3\xa4 Kustannuslaskenta M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Delivery Note',b'Vehicle No',b'Ajoneuvon nro'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163',b'Please select Price List',b'Ole hyv\xc3\xa4 ja valitse hinnasto'
b'DocType: Accounts Settings',b'Currency Exchange Settings',b'Valuutanvaihtoasetukset'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94',b'Row #{0}: Payment document is required to complete the trasaction',b'Rivi # {0}: Maksu asiakirja t\xc3\xa4ytett\xc3\xa4v\xc3\xa4 trasaction'
b'DocType: Work Order Operation',b'Work In Progress',b'Ty\xc3\xb6nalla'
b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13',b'Please select date',b'Valitse p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Daily Work Summary Group',b'Holiday List',b'lomaluettelo'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88',b'Please setup numbering series for Attendance via Setup &gt; Numbering Series',b'Aseta numeerinen sarja osallistumiselle Setup&gt; Numerosarjan kautta'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127',b'Accountant',b'Kirjanpit\xc3\xa4j\xc3\xa4'
b'DocType: Hub Settings',b'Selling Price List',b'Myynnin hinnasto'
b'DocType: Patient',b'Tobacco Current Use',b'Tupakan nykyinen k\xc3\xa4ytt\xc3\xb6'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56',b'Selling Rate',b'Myynnin m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Cost Center',b'Stock User',b'Varaston perusk\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'DocType: Soil Analysis',b'(Ca+Mg)/K',b'(Ca + Mg) / K'
b'DocType: Company',b'Phone No',b'Puhelinnumero'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239',b'New {0}: #{1}',b'Uusi {0}: # {1}'
b'DocType: Delivery Trip',b'Initial Email Notification Sent',b'Ensimm\xc3\xa4inen s\xc3\xa4hk\xc3\xb6postiviesti l\xc3\xa4hetetty'
,b'Sales Partners Commission',b'myyntikumppanit provisio'
b'DocType: Soil Texture',b'Sandy Clay Loam',b'Sandy Clay Loam'
b'DocType: Purchase Invoice',b'Rounding Adjustment',b'Py\xc3\xb6ristyksen s\xc3\xa4\xc3\xa4t\xc3\xb6'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +46',b'Abbreviation cannot have more than 5 characters',b'Lyhenne voi olla enint\xc3\xa4\xc3\xa4n 5 merkki\xc3\xa4'
b'DocType: Physician Schedule Time Slot',b'Physician Schedule Time Slot',b'L\xc3\xa4\xc3\xa4k\xc3\xa4ri Aikataulu Aikav\xc3\xa4lit'
b'DocType: Payment Request',b'Payment Request',b'Maksupyynt\xc3\xb6'
b'DocType: Asset',b'Value After Depreciation',b'Arvonalennuksen j\xc3\xa4lkeinen arvo'
b'DocType: Student',b'O+',b'O +'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8',b'Related',b'Asiaan liittyv\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43',"b""Attendance date can not be less than employee's joining date""",b'L\xc3\xa4sn\xc3\xa4olo p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla pienempi kuin ty\xc3\xb6ntekij\xc3\xa4n tuloaan p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Grading Scale',b'Grading Scale Name',b'Arvosteluasteikko Name'
b'DocType: Subscription',b'Repeat on Day',b'Toista p\xc3\xa4iv\xc3\xa4ll\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +41',b'This is a root account and cannot be edited.',b'T\xc3\xa4m\xc3\xa4 on kantatili eik\xc3\xa4 sit\xc3\xa4 voi muokata'
b'DocType: Sales Invoice',b'Company Address',b'yritys osoite'
b'DocType: BOM',b'Operations',b'Toiminnot'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38',b'Cannot set authorization on basis of Discount for {0}',b'oikeutusta ei voi asettaa alennuksen perusteella {0}'
b'DocType: Rename Tool',"b'Attach .csv file with two columns, one for the old name and one for the new name'","b'Liit\xc3\xa4 .csv-tiedosto, jossa on vain kaksi saraketta: vanha ja uusi nimi'"
b'apps/erpnext/erpnext/accounts/utils.py +73',b'{0} {1} not in any active Fiscal Year.',b'{0} {1} ei miss\xc3\xa4\xc3\xa4n aktiivista verovuonna.'
b'DocType: Packed Item',b'Parent Detail docname',b'P\xc3\xa4\xc3\xa4selostuksen docname'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69',"b'Reference: {0}, Item Code: {1} and Customer: {2}'","b'Viite: {0}, kohta Koodi: {1} ja Asiakas: {2}'"
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Kg',b'Kg'
b'apps/erpnext/erpnext/config/hr.py +45',b'Opening for a Job.',b'Avaaminen ja ty\xc3\xb6n.'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114',b'BOM is not specified for subcontracting item {0} at row {1}',b'BOM: t\xc3\xa4 ei ole m\xc3\xa4\xc3\xa4ritetty alihankintakohteeseen {0} rivill\xc3\xa4 {1}'
b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149',b'{0} Result submittted',b'{0} Tulos toimitettu'
b'DocType: Item Attribute',b'Increment',b'Lis\xc3\xa4ys'
b'apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74',b'Timespan',b'Aikaj\xc3\xa4nne'
b'apps/erpnext/erpnext/public/js/stock_analytics.js +58',b'Select Warehouse...',b'Valitse Varasto ...'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6',b'Advertising',b'mainonta'
b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22',b'Same Company is entered more than once',b'Sama yhti\xc3\xb6 on merkitty enemm\xc3\xa4n kuin kerran'
b'DocType: Patient',b'Married',b'Naimisissa'
b'apps/erpnext/erpnext/accounts/party.py +41',b'Not permitted for {0}',b'Ei saa {0}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593',b'Get items from',b'Hae nimikkeet'
b'DocType: Price List',b'Price Not UOM Dependant',b'Hinta ei ole UOM riippuvainen'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467',b'Stock cannot be updated against Delivery Note {0}',b'varastoa ei voi p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 l\xc3\xa4hetett\xc3\xa4 vastaan {0}'
b'apps/erpnext/erpnext/templates/pages/home.py +25',b'Product {0}',b'Tuotteen {0}'
b'apps/erpnext/erpnext/templates/generators/item_group.html +43',b'No items listed',b'Ei luetellut'
b'DocType: Asset Repair',b'Error Description',b'Virhe Kuvaus'
b'DocType: Payment Reconciliation',b'Reconcile',b'Yhteensovitus'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30',b'Grocery',b'p\xc3\xa4ivitt\xc3\xa4istavara'
b'DocType: Quality Inspection Reading',b'Reading 1',b'Lukema 1'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40',b'Pension Funds',b'El\xc3\xa4kerahastot'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +91',b'Next Depreciation Date cannot be before Purchase Date',b'Seuraava Poistot Date ei voi olla ennen Ostop\xc3\xa4iv\xc3\xa4'
b'DocType: Crop',b'Perennial',b'Monivuotinen'
b'DocType: Consultation',b'Consultation Date',b'Kuulemisp\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Accounts Settings',b'Use Custom Cash Flow Format',b'K\xc3\xa4yt\xc3\xa4 Custom Cash Flow -muotoa'
b'DocType: SMS Center',b'All Sales Person',b'kaikki myyj\xc3\xa4t'
b'DocType: Monthly Distribution',b'**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.',b'** Kuukausijako ** auttaa kausiluonteisen liiketoiminnan budjetoinnissa ja tavoiteasetannassa.'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1753',b'Not items found',b'Ei kohdetta l\xc3\xb6ydetty'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184',b'Salary Structure Missing',b'Palkka rakenne Puuttuvat'
b'DocType: Lead',b'Person Name',b'Henkil\xc3\xb6'
b'DocType: Sales Invoice Item',b'Sales Invoice Item',"b'Myyntilasku, tuote'"
b'DocType: Account',b'Credit',b'kredit'
b'DocType: POS Profile',b'Write Off Cost Center',b'Poiston kustannuspaikka'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +117',"b'e.g. ""Primary School"" or ""University""'",b'esimerkiksi &quot;Primary School&quot; tai &quot;University&quot;'
b'apps/erpnext/erpnext/config/stock.py +28',b'Stock Reports',b'Perusraportit'
b'DocType: Warehouse',b'Warehouse Detail',b'Varaston lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33',b'The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',b'Term P\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4 ei voi olla my\xc3\xb6hemmin kuin vuosi P\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4 Lukuvuoden johon termi\xc3\xa4 liittyy (Lukuvuosi {}). Korjaa p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4t ja yrit\xc3\xa4 uudelleen.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +269',"b'""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item'","b'&quot;Is Fixed Asset&quot; ei voi olla valitsematta, koska Asset kirjaa olemassa vasten kohde'"
b'DocType: Delivery Trip',b'Departure Time',b'L\xc3\xa4ht\xc3\xb6aika'
b'DocType: Vehicle Service',b'Brake Oil',b'Brake Oil'
b'DocType: Tax Rule',b'Tax Type',b'Verotyyppi'
,b'Completed Work Orders',b'Valmistuneet ty\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4ykset'
b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +581',b'Taxable Amount',b'veron perusteena'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160',b'You are not authorized to add or update entries before {0}',b'sinulla ei ole lupaa lis\xc3\xa4t\xc3\xa4 tai p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 kirjauksia ennen {0}'
b'DocType: BOM',b'Item Image (if not slideshow)',b'tuotekuva (jos diaesitys ei k\xc3\xa4yt\xc3\xb6ss\xc3\xa4)'
b'DocType: Work Order Operation',b'(Hour Rate / 60) * Actual Operation Time',b'(Tuntihinta / 60) * todellinen k\xc3\xa4ytetty aika'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103',b'Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry',b'Rivi # {0}: Viiteasiakirjatyypin on oltava yksi kulukorvauksesta tai p\xc3\xa4iv\xc3\xa4kirjakirjauksesta'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975',b'Select BOM',b'Valitse BOM'
b'DocType: SMS Log',b'SMS Log',b'Tekstiviesti loki'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Delivered Items',b'toimitettujen tuotteiden kustannukset'
b'apps/erpnext/erpnext/config/hr.py +127',b'Manage advance amount given to the Employee',b'Hallitse ty\xc3\xb6ntekij\xc3\xa4lle annettu ennakkom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38',b'The holiday on {0} is not between From Date and To Date',b'Loma {0} ei ajoitu aloitus- ja lopetusp\xc3\xa4iv\xc3\xa4n v\xc3\xa4lille'
b'DocType: Student Log',b'Student Log',b'Student Log'
b'apps/erpnext/erpnext/config/buying.py +165',b'Templates of supplier standings.',b'Toimittajien sijoitusten mallit.'
b'DocType: Lead',b'Interested',b'kiinnostunut'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216',b'Opening',b'Aukko'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32',b'From {0} to {1}',b'{0} -&gt; {1}'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234',b'Program: ',b'Ohjelmoida:'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50',b'Failed to setup taxes',b'Verojen asettaminen ep\xc3\xa4onnistui'
b'DocType: Item',b'Copy From Item Group',b'kopioi tuoteryhm\xc3\xa4st\xc3\xa4'
b'DocType: Delivery Trip',b'Delivery Notification',b'Toimitusilmoitus'
b'DocType: Journal Entry',b'Opening Entry',b'Avauskirjaus'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25',b'Account Pay Only',b'Tilin Pay Only'
b'DocType: Employee Loan',b'Repay Over Number of Periods',b'Repay Yli Kausien m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Stock Entry',b'Additional Costs',b'Lis\xc3\xa4kustannukset'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +138',b'Account with existing transaction can not be converted to group.',b'tilin tapahtumaa ei voi muuntaa ryhm\xc3\xa4ksi'
b'DocType: Lead',b'Product Enquiry',b'Tavara kysely'
b'DocType: Education Settings',b'Validate Batch for Students in Student Group',b'Vahvista Er\xc3\xa4 opiskelijoille Student Group'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35',b'No leave record found for employee {0} for {1}',b'Ei j\xc3\xa4t\xc3\xa4 kirjaa l\xc3\xb6ytynyt ty\xc3\xb6ntekij\xc3\xa4 {0} ja {1}'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23',b'Please enter company first',b'Anna yritys ensin'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365',b'Please select Company first',b'Ole hyv\xc3\xa4 ja valitse Company ensin'
b'DocType: Employee Education',b'Under Graduate',b'Ylioppilas'
b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27',b'Target On',b'Tavoitteeseen'
b'DocType: BOM',b'Total Cost',b'Kokonaiskustannukset'
b'DocType: Soil Analysis',b'Ca/K',b'Ca / K'
b'DocType: Journal Entry Account',b'Employee Loan',b'ty\xc3\xb6ntekij\xc3\xa4n Loan'
b'DocType: Fee Schedule',b'Send Payment Request Email',b'L\xc3\xa4het\xc3\xa4 maksuehdotus s\xc3\xa4hk\xc3\xb6postitse'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268',b'Item {0} does not exist in the system or has expired',b'Nimikett\xc3\xa4 {0} ei l\xc3\xb6ydy tai se on vanhentunut'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44',b'Real Estate',b'Kiinteist\xc3\xb6t'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1',b'Statement of Account',b'tiliote'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41',b'Pharmaceuticals',b'L\xc3\xa4\xc3\xa4keteollisuuden tuotteet'
b'DocType: Purchase Invoice Item',b'Is Fixed Asset',b'Onko k\xc3\xa4ytt\xc3\xb6omaisuusosakkeet'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273',"b'Available qty is {0}, you need {1}'","b'Saatavilla M\xc3\xa4\xc3\xa4r\xc3\xa4 on {0}, sinun {1}'"
b'DocType: Expense Claim Detail',b'Claim Amount',b'Korvauksen m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +653',b'Work Order has been {0}',b'Ty\xc3\xb6j\xc3\xa4rjestys on {0}'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56',b'Duplicate customer group found in the cutomer group table',b'Monista asiakasryhm\xc3\xa4 l\xc3\xb6ytyy cutomer ryhm\xc3\xa4taulukkoon'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31',b'Supplier Type / Supplier',b'toimittaja tyyppi / toimittaja'
b'DocType: Naming Series',b'Prefix',b'Etuliite'
b'apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7',b'Event Location',b'Tapahtuman sijainti'
b'DocType: Asset Settings',b'Asset Settings',b'Omaisuusasetukset'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68',b'Consumable',b'k\xc3\xa4ytett\xc3\xa4v\xc3\xa4'
b'DocType: Student',b'B-',b'B -'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98',b'Successfully unregistered.',b'Kirjaamaton rekister\xc3\xb6inti.'
b'DocType: Assessment Result',b'Grade',b'Arvosana'
b'DocType: Restaurant Table',b'No of Seats',b'Istumapaikkoja'
b'DocType: Subscription',"b'To add dynamic subject, use jinja tags like\n\n<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>'",b'Voit lis\xc3\xa4t\xc3\xa4 dynaamisen aiheen k\xc3\xa4ytt\xc3\xa4m\xc3\xa4ll\xc3\xa4 jinja-tunnisteita <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>'
b'DocType: Sales Invoice Item',b'Delivered By Supplier',b'Toimitetaan Toimittaja'
b'DocType: Asset Maintenance Task',b'Asset Maintenance Task',b'Omaisuudenhoitotoiminta'
b'DocType: SMS Center',b'All Contact',b'kaikki yhteystiedot'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232',b'Annual Salary',b'vuosipalkka'
b'DocType: Daily Work Summary',b'Daily Work Summary',b'P\xc3\xa4ivitt\xc3\xa4inen ty\xc3\xb6 Yhteenveto'
b'DocType: Period Closing Voucher',b'Closing Fiscal Year',b'tilikauden sulkeminen'
b'apps/erpnext/erpnext/accounts/party.py +392',b'{0} {1} is frozen',b'{0} {1} on j\xc3\xa4\xc3\xa4dytetty'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +140',b'Please select Existing Company for creating Chart of Accounts',b'Valitse Olemassa Company luoda tilikartan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80',b'Stock Expenses',b'varaston kulut'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Valitse Target Varasto'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.js +80',b'Please enter Preferred Contact Email',b'Anna Preferred S\xc3\xa4hk\xc3\xb6postiosoite'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxNum',b'CompAuxNum'
b'DocType: Journal Entry',b'Contra Entry',b'vastakirjaus'
b'DocType: Journal Entry Account',b'Credit in Company Currency',b'Luotto Yritys Valuutta'
b'DocType: Lab Test UOM',b'Lab Test UOM',b'Lab Test UOM'
b'DocType: Delivery Note',b'Installation Status',b'Asennuksen tila'
b'DocType: BOM',b'Quality Inspection Template',b'Laaduntarkastusmalli'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135',b'Do you want to update attendance?<br>Present: {0}\\\n\t\t\t\t\t<br>Absent: {1}',b'Haluatko p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 l\xc3\xa4sn\xc3\xa4olo? <br> Present: {0} \\ <br> Ei lainkaan: {1}'
b'apps/erpnext/erpnext/controllers/buying_controller.py +334',b'Accepted + Rejected Qty must be equal to Received quantity for Item {0}',b'hyv\xc3\xa4ksyttyjen + hyl\xc3\xa4ttyjen yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 on sama kuin tuotteiden vastaanotettu m\xc3\xa4\xc3\xa4r\xc3\xa4 {0}'
b'DocType: Request for Quotation',b'RFQ-',b'RFQ-'
b'DocType: Item',b'Supply Raw Materials for Purchase',b'toimita raaka-aineita ostoon'
b'DocType: Agriculture Analysis Criteria',b'Fertilizer',b'Lannoite'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152',b'At least one mode of payment is required for POS invoice.',b'Ainakin yksi maksutavan vaaditaan POS laskun.'
b'DocType: Products Settings',b'Show Products as a List',b'N\xc3\xa4yt\xc3\xa4 tuotteet listana'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +532',b'Item {0} is not active or end of life has been reached',b'Nimike {0} ei ole aktiivinen tai sen elinkaari p\xc3\xa4\xc3\xa4ttynyt'
b'DocType: Student Admission Program',b'Minimum Age',b'Minimi ik\xc3\xa4'
b'apps/erpnext/erpnext/utilities/user_progress.py +190',b'Example: Basic Mathematics',b'Esimerkki: Basic Mathematics'
b'DocType: Customer',b'Primary Address',b'ensisijainen osoite'
b'DocType: Production Plan',b'Material Request Detail',b'Materiaalipyynn\xc3\xb6n yksityiskohdat'
b'DocType: Selling Settings',b'Default Quotation Validity Days',b'Oletushakemusten voimassaoloajat'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +800',"b'To include tax in row {0} in Item rate, taxes in rows {1} must also be included'","b'Sis\xc3\xa4llyt\xc3\xa4 verorivi {0} tuotteen tasoon, verot riveill\xc3\xa4 {1} tulee my\xc3\xb6s sis\xc3\xa4llytt\xc3\xa4\xc3\xa4'"
b'apps/erpnext/erpnext/config/hr.py +223',b'Settings for HR Module',b'Henkil\xc3\xb6st\xc3\xb6moduulin asetukset'
b'DocType: SMS Center',b'SMS Center',b'Tekstiviesti keskus'
b'DocType: Sales Invoice',b'Change Amount',b'muutos M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: GST Settings',b'Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.',b'Aseta laskuarvo B2C: lle. B2CL ja B2CS lasketaan t\xc3\xa4m\xc3\xa4n laskuarvon perusteella.'
b'DocType: BOM Update Tool',b'New BOM',b'Uusi osaluettelo'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36',b'Show only POS',b'N\xc3\xa4yt\xc3\xa4 vain POS'
b'DocType: Driver',b'Driving License Categories',b'Ajokorttikategoriat'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118',b'Please enter Delivery Date',b'Anna toimitusp\xc3\xa4iv\xc3\xa4'
b'DocType: Depreciation Schedule',b'Make Depreciation Entry',b'Tee Poistot Entry'
b'DocType: Appraisal Template Goal',b'KRA',b'KRA'
b'DocType: Lead',b'Request Type',b'pyyd\xc3\xa4 tyyppi'
b'apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17',b'Make Employee',b'Tee ty\xc3\xb6ntekij\xc3\xa4'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14',b'Broadcasting',b'julkaisu'
b'apps/erpnext/erpnext/config/accounts.py +313',b'Setup mode of POS (Online / Offline)',b'POS (online / offline) asetustila'
b'DocType: Manufacturing Settings',b'Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order',b'Poistaa aikaleikkeiden luomisen ty\xc3\xb6j\xc3\xa4rjestysluetteloon. Toimintoja ei saa seurata ty\xc3\xb6j\xc3\xa4rjestyst\xc3\xa4 vastaan'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191',b'Execution',b'suoritus'
b'apps/erpnext/erpnext/config/manufacturing.py +62',b'Details of the operations carried out.',b'toteutetuneiden toimien lis\xc3\xa4tiedot'
b'DocType: Asset Maintenance Log',b'Maintenance Status',"b'huolto, tila'"
b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10',b'Membership Details',b'J\xc3\xa4senyystiedot'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56',b'{0} {1}: Supplier is required against Payable account {2}',b'{0} {1}: Toimittaja tarvitaan vastaan maksullisia huomioon {2}'
b'apps/erpnext/erpnext/config/selling.py +52',b'Items and Pricing',b'Nimikkeet ja hinnoittelu'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2',b'Total hours: {0}',b'Yhteens\xc3\xa4 tuntia: {0}'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43',b'From Date should be within the Fiscal Year. Assuming From Date = {0}',b'Alkaen p\xc3\xa4iv\xc3\xa4 tulee olla tilikaudella. Olettaen ett\xc3\xa4 alkaen p\xc3\xa4iv\xc3\xa4 = {0}'
b'DocType: Drug Prescription',b'Interval',b'intervalli'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253',b'Preference',b'etusija'
b'DocType: Grant Application',b'Individual',b'yksil\xc3\xb6llinen'
b'DocType: Academic Term',b'Academics User',b'Academics K\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'DocType: Cheque Print Template',b'Amount In Figure',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 Kuvassa'
b'DocType: Employee Loan Application',b'Loan Info',b'laina Info'
b'apps/erpnext/erpnext/config/maintenance.py +12',b'Plan for maintenance visits.',b'Suunnittele huoltok\xc3\xa4yntej\xc3\xa4'
b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Period',b'Toimittajan arviointijakso'
b'DocType: Share Transfer',b'Share Transfer',b'Osakekohtainen siirto'
b'DocType: POS Profile',b'Customer Groups',b'Asiakasryhm\xc3\xa4t'
b'apps/erpnext/erpnext/public/js/financial_statements.js +51',b'Financial Statements',b'Tilinp\xc3\xa4\xc3\xa4t\xc3\xb6s'
b'DocType: Guardian',b'Students',b'opiskelijat'
b'apps/erpnext/erpnext/config/selling.py +91',b'Rules for applying pricing and discount.',b's\xc3\xa4\xc3\xa4nt\xc3\xb6 hinnoitteluun ja alennuksiin'
b'DocType: Daily Work Summary',b'Daily Work Summary Group',b'P\xc3\xa4ivitt\xc3\xa4inen ty\xc3\xb6yhteenvetoryhm\xc3\xa4'
b'DocType: Physician Schedule',b'Time Slots',b'Aikav\xc3\xa4lit'
b'apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14',b'Price List must be applicable for Buying or Selling',b'Hinnastoa tulee soveltaa ostamiseen tai myymiseen'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79',b'Installation date cannot be before delivery date for Item {0}',b'asennusp\xc3\xa4iv\xc3\xa4 ei voi olla ennen tuotteen toimitusaikaa {0}'
b'DocType: Pricing Rule',b'Discount on Price List Rate (%)',b'hinnaston alennus taso (%)'
b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112',b'Item Template',b'Item Template'
b'apps/erpnext/erpnext/healthcare/setup.py +215',b'Biochemistry',b'Biokemia'
b'DocType: Job Offer',b'Select Terms and Conditions',b'Valitse ehdot ja s\xc3\xa4\xc3\xa4nn\xc3\xb6t'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72',b'Out Value',b'out Arvo'
b'DocType: Production Plan',b'Sales Orders',b'Myyntitilaukset'
b'DocType: Purchase Taxes and Charges',b'Valuation',b'Arvo'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +390',b'Set as Default',b'aseta oletukseksi'
b'DocType: Production Plan',b'PLN-',b'PLN-'
,b'Purchase Order Trends',b'Ostotilausten kehitys'
b'apps/erpnext/erpnext/utilities/user_progress.py +78',b'Go to Customers',b'Siirry asiakkaille'
b'DocType: Hotel Room Reservation',b'Late Checkin',b'My\xc3\xb6h\xc3\xa4inen sis\xc3\xa4\xc3\xa4nkirjautuminen'
b'apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7',b'The request for quotation can be accessed by clicking on the following link',b'Tarjouspyynt\xc3\xb6\xc3\xb6n p\xc3\xa4\xc3\xa4see klikkaamalla seuraavaa linkki\xc3\xa4'
b'apps/erpnext/erpnext/config/hr.py +81',b'Allocate leaves for the year.',b'kohdistaa poistumisen vuodelle'
b'DocType: SG Creation Tool Course',b'SG Creation Tool Course',b'SG Creation Tool Course'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275',b'Insufficient Stock',b'riitt\xc3\xa4m\xc3\xa4t\xc3\xb6n Stock'
b'DocType: Manufacturing Settings',b'Disable Capacity Planning and Time Tracking',b'poista kapasiteettisuunnittelu ja aikaseuranta k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'DocType: Email Digest',b'New Sales Orders',b'uusi myyntitilaus'
b'DocType: Bank Guarantee',b'Bank Account',b'Pankkitili'
b'DocType: Leave Type',b'Allow Negative Balance',b'Hyv\xc3\xa4ksy negatiivinen tase'
b'apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13',"b""You cannot delete Project Type 'External'""",b'Et voi poistaa projektityyppi\xc3\xa4 &quot;Ulkoinen&quot;'
b'DocType: Employee',b'Create User',b'Luo k\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'DocType: Selling Settings',b'Default Territory',b'oletus alue'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53',b'Television',b'Televisio'
b'DocType: Work Order Operation',"b""Updated via 'Time Log'""","b""P\xc3\xa4ivitetty 'aikaloki' kautta"""
b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +430',b'Advance amount cannot be greater than {0} {1}',b'Ennakon m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla suurempi kuin {0} {1}'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalCode',b'JournalCode'
b'DocType: Naming Series',b'Series List for this Transaction',b'Sarjalistaus t\xc3\xa4h\xc3\xa4n tapahtumaan'
b'DocType: Company',b'Enable Perpetual Inventory',b'Ota investointikertym\xc3\xa4menetelm\xc3\xa4n'
b'DocType: Company',b'Default Payroll Payable Account',b'Oletus Payroll Maksettava Account'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51',b'Update Email Group',b'P\xc3\xa4ivitys S\xc3\xa4hk\xc3\xb6postiryhm\xc3\xa4'
b'DocType: Sales Invoice',b'Is Opening Entry',b'on avauskirjaus'
b'DocType: Lab Test Template',"b'If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. '","b'Jos valinta ei ole valittuna, esine ei tule n\xc3\xa4kyviin myyntilaskuissa, mutta sit\xc3\xa4 voidaan k\xc3\xa4ytt\xc3\xa4\xc3\xa4 ryhm\xc3\xa4testien luomisessa.'"
b'DocType: Customer Group',b'Mention if non-standard receivable account applicable',b'maininta ellei sovelletaan saataien perustili\xc3\xa4 k\xc3\xa4ytet\xc3\xa4'
b'DocType: Course Schedule',b'Instructor Name',b'ohjaaja Name'
b'DocType: Supplier Scorecard',b'Criteria Setup',b'Perusasetukset'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206',b'For Warehouse is required before Submit',b'Varastoon -kentt\xc3\xa4 vaaditaan ennen vahvistusta'
b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8',b'Received On',b'Saatu'
b'DocType: Sales Partner',b'Reseller',b'J\xc3\xa4lleenmyyj\xc3\xa4'
b'DocType: Codification Table',b'Medical Code',b'Medical Code'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20',b'Please enter Company',b'Anna Company'
b'DocType: Delivery Note Item',b'Against Sales Invoice Item',b'Myyntilaskun kohdistus / nimike'
b'DocType: Agriculture Analysis Criteria',b'Linked Doctype',b'Linkitetty Doctype'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44',b'Net Cash from Financing',b'Rahoituksen nettokassavirta'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2375',"b'LocalStorage is full , did not save'","b'LocalStoragen on t\xc3\xa4ynn\xc3\xa4, ei tallentanut'"
b'DocType: Lead',b'Address & Contact',b'osoitteet ja yhteystiedot'
b'DocType: Leave Allocation',b'Add unused leaves from previous allocations',b'Lis\xc3\xa4\xc3\xa4 k\xc3\xa4ytt\xc3\xa4m\xc3\xa4tt\xc3\xb6m\xc3\xa4t l\xc3\xa4htee edellisest\xc3\xa4 m\xc3\xa4\xc3\xa4r\xc3\xa4rahoista'
b'DocType: Sales Partner',b'Partner website',b'Kumppanin verkkosivusto'
b'DocType: Restaurant Order Entry',b'Add Item',b'Lis\xc3\xa4\xc3\xa4 tavara'
b'DocType: Lab Test',b'Custom Result',b'Mukautettu tulos'
b'DocType: Delivery Stop',b'Contact Name',"b'yhteystiedot, nimi'"
b'DocType: Course Assessment Criteria',b'Course Assessment Criteria',b'Kurssin arviointiperusteet'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18',b'Tax Id: ',b'Verotunnus:'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216',b'Student ID: ',b'Opiskelijanumero:'
b'DocType: POS Customer Group',b'POS Customer Group',b'POS Asiakas Group'
b'DocType: Land Unit',b'Land Unit describing various land assets',"b'Maanomainen yksikk\xc3\xb6, joka kuvaa eri maaomaisuutta'"
b'DocType: Cheque Print Template',b'Line spacing for amount in words',b'Riviv\xc3\xa4li varten m\xc3\xa4\xc3\xa4r\xc3\xa4 kirjaimin'
b'DocType: Vehicle',b'Additional Details',b'Lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/templates/generators/bom.html +85',b'No description given',b'ei annettua kuvausta'
b'apps/erpnext/erpnext/config/buying.py +13',b'Request for purchase.',b'Pyyd\xc3\xa4 ostaa.'
b'DocType: Lab Test',b'Submitted Date',b'L\xc3\xa4hetetty p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6',b'This is based on the Time Sheets created against this project',b'T\xc3\xa4m\xc3\xa4 perustuu projektin tuntilistoihin'
,b'Open Work Orders',b'Avoimet ty\xc3\xb6j\xc3\xa4rjestykset'
b'DocType: Payment Term',b'Credit Months',b'Luottoajat'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409',b'Net Pay cannot be less than 0',b'Nettopalkka ei voi olla pienempi kuin 0'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',"b'To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription'","b'Jos haluat lopettaa toistuvien virheilmoitusten l\xc3\xa4hett\xc3\xa4misen j\xc3\xa4rjestelm\xc3\xa4st\xc3\xa4, olemme valinneet tilauksen Ei k\xc3\xa4yt\xc3\xb6ss\xc3\xa4 -kent\xc3\xa4n'"
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +121',b'Relieving Date must be greater than Date of Joining',b'Ty\xc3\xb6suhteen p\xc3\xa4\xc3\xa4ttymis\xc3\xa4p\xc3\xa4iv\xc3\xa4n on oltava aloitusp\xc3\xa4iv\xc3\xa4n j\xc3\xa4lkeen'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240',b'Leaves per Year',b'Vapaat vuodessa'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130',"b""Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.""","b""rivi {0}: t\xc3\xa4pp\xc3\xa4\xc3\xa4 'ennakko' kohdistettu tilille {1}, mik\xc3\xa4li t\xc3\xa4m\xc3\xa4 on ennakkokirjaus"""
b'apps/erpnext/erpnext/stock/utils.py +219',b'Warehouse {0} does not belong to company {1}',b'Varasto {0} ei kuulu yritykselle {1}'
b'DocType: Email Digest',b'Profit & Loss',b'Voitonmenetys'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Litre',b'litra'
b'DocType: Task',b'Total Costing Amount (via Time Sheet)',b'Yhteens\xc3\xa4 Costing M\xc3\xa4\xc3\xa4r\xc3\xa4 (via Time Sheet)'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76',b'Please setup Students under Student Groups',b'Aseta opiskelijat opiskelijaryhmiss\xc3\xa4'
b'DocType: Item Website Specification',b'Item Website Specification',b'Kohteen verkkosivustoasetukset'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449',b'Leave Blocked',b'vapaa kielletty'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +740',b'Item {0} has reached its end of life on {1}',b'Nimikeen {0} elinkaari on p\xc3\xa4\xc3\xa4ttynyt {1}'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83',b'Bank Entries',b'Bank merkinn\xc3\xa4t'
b'DocType: Crop',b'Annual',b'Vuotuinen'
b'DocType: Stock Reconciliation Item',b'Stock Reconciliation Item',b'Varaston t\xc3\xa4sm\xc3\xa4ytys nimike'
b'DocType: Stock Entry',b'Sales Invoice No',"b'Myyntilasku, nro'"
b'DocType: Material Request Item',b'Min Order Qty',b'min tilaus yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Student Group Creation Tool Course',b'Student Group Creation Tool Course',b'Student Group Creation Tool Course'
b'DocType: Lead',b'Do Not Contact',b'\xc3\xa4l\xc3\xa4 ota yhteytt\xc3\xa4'
b'apps/erpnext/erpnext/utilities/user_progress.py +210',b'People who teach at your organisation',"b'Ihmiset, jotka opettavat organisaatiossa'"
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135',b'Software Developer',b'Ohjelmistokehitt\xc3\xa4j\xc3\xa4'
b'DocType: Item',b'Minimum Order Qty',b'minimi tilaus yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Pricing Rule',b'Supplier Type',b'Toimittajan tyyppi'
b'DocType: Course Scheduling Tool',b'Course Start Date',b'Kurssin aloitusp\xc3\xa4iv\xc3\xa4'
,b'Student Batch-Wise Attendance',b'Student eriss\xc3\xa4 L\xc3\xa4sn\xc3\xa4olo'
b'DocType: POS Profile',b'Allow user to edit Rate',b'Salli k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n muokata Hinta'
b'DocType: Item',b'Publish in Hub',b'Julkaista Hub'
b'DocType: Student Admission',b'Student Admission',b'Opiskelijavalinta'
,b'Terretory',b'Alue'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +762',b'Item {0} is cancelled',b'Nimike {0} on peruutettu'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064',b'Material Request',b'Hankintapyynt\xc3\xb6'
b'DocType: Bank Reconciliation',b'Update Clearance Date',b'P\xc3\xa4ivit\xc3\xa4 tilitysp\xc3\xa4iv\xc3\xa4'
,b'GSTR-2',b'GSTR-2'
b'DocType: Item',b'Purchase Details',b'Oston lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407',"b""Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}""",b'Nimikett\xc3\xa4 {0} ei l\xc3\xb6ydy ostotilauksen {1} toimitettujen raaka-aineiden taulusta'
b'DocType: Salary Slip',b'Total Principal Amount',b'P\xc3\xa4\xc3\xa4oman kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Student Guardian',b'Relation',b'Suhde'
b'DocType: Student Guardian',b'Mother',b'\xc3\x84iti'
b'DocType: Restaurant Reservation',b'Reservation End Time',b'Varauksen loppumisaika'
b'DocType: Crop',b'Biennial',b'kaksivuotinen'
b'apps/erpnext/erpnext/config/selling.py +18',b'Confirmed orders from Customers.',b'asiakkailta vahvistetut tilaukset'
b'DocType: Purchase Receipt Item',b'Rejected Quantity',b'Hyl\xc3\xa4tty M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/fees/fees.py +80',b'Payment request {0} created',b'Maksupyynt\xc3\xb6 {0} luotiin'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Open Orders',b'Avoimet tilaukset'
b'apps/erpnext/erpnext/healthcare/setup.py +255',b'Low Sensitivity',b'Herkk\xc3\xa4 herkkyys'
b'DocType: Notification Control',b'Notification Control',b'Ilmoittaminen Ohjaus'
b'apps/erpnext/erpnext/templates/emails/training_event.html +17',b'Please confirm once you have completed your training',"b'Vahvista, kun olet suorittanut harjoittelusi'"
b'DocType: Lead',b'Suggestions',b'ehdotuksia'
b'DocType: Territory',b'Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.',"b'Tuoteryhm\xc3\xa4 ty\xc3\xb6kalu, aseta budjetit t\xc3\xa4ll\xc3\xa4, voit tehd\xc3\xa4 kausiluonteisen budjetin asettamalla jaksotuksen'"
b'DocType: Payment Term',b'Payment Term Name',b'Maksuehdot Nimi'
b'DocType: Healthcare Settings',b'Create documents for sample collection',b'Luo asiakirjat n\xc3\xa4ytteiden ker\xc3\xa4\xc3\xa4miseksi'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276',b'Payment against {0} {1} cannot be greater than Outstanding Amount {2}',b'Maksu vastaan {0} {1} ei voi olla suurempi kuin j\xc3\xa4ljell\xc3\xa4 {2}'
b'DocType: Shareholder',b'Address HTML',b'osoite HTML'
b'DocType: Lead',b'Mobile No.',b'Matkapuhelin'
b'DocType: Maintenance Schedule',b'Generate Schedule',b'muodosta aikataulu'
b'DocType: Purchase Invoice Item',b'Expense Head',b'Kustannusotsikko'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138',b'Please select Charge Type first',b'Valitse ensin veloitus tyyppi'
b'DocType: Crop',"b'You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. '","b'Voit m\xc3\xa4\xc3\xa4ritt\xc3\xa4\xc3\xa4 kaikki teht\xc3\xa4v\xc3\xa4t, jotka on suoritettava t\xc3\xa4lle satoa varten. P\xc3\xa4iv\xc3\xa4kentt\xc3\xa4\xc3\xa4n mainitaan p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4, jona teht\xc3\xa4v\xc3\xa4 on suoritettava, 1 on ensimm\xc3\xa4inen p\xc3\xa4iv\xc3\xa4 jne.'"
b'DocType: Student Group Student',b'Student Group Student',b'Student Group Student'
b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Latest',b'Viimeisin'
b'DocType: Asset Maintenance Task',b'2 Yearly',b'2 vuosittain'
b'DocType: Education Settings',b'Education Settings',b'Koulutusasetukset'
b'DocType: Vehicle Service',b'Inspection',b'tarkastus'
b'DocType: Supplier Scorecard Scoring Standing',b'Max Grade',b'Max Grade'
b'DocType: Email Digest',b'New Quotations',b'Uudet tarjoukset'
b'DocType: HR Settings',b'Emails salary slip to employee based on preferred email selected in Employee',b'S\xc3\xa4hk\xc3\xb6postit palkkakuitin ty\xc3\xb6ntekij\xc3\xb6iden perustuu ensisijainen s\xc3\xa4hk\xc3\xb6posti valittu Ty\xc3\xb6ntekij\xc3\xa4n'
b'DocType: Employee',b'The first Leave Approver in the list will be set as the default Leave Approver',b'Luettelon ensimm\xc3\xa4inen hyv\xc3\xa4ksyj\xc3\xa4 asetetaan oletukseksi.'
b'DocType: Tax Rule',b'Shipping County',b'Toimitus l\xc3\xa4\xc3\xa4ni'
b'apps/erpnext/erpnext/config/desktop.py +167',b'Learn',b'K\xc3\xa4ytt\xc3\xb6-opastus'
b'DocType: Asset',b'Next Depreciation Date',b'Seuraava poistop\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3',b'Activity Cost per Employee',b'Aktiviteetti kustannukset ty\xc3\xb6ntekij\xc3\xa4\xc3\xa4 kohti'
b'DocType: Accounts Settings',b'Settings for Accounts',b'Tilien asetukset'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673',b'Supplier Invoice No exists in Purchase Invoice {0}',b'Toimittaja laskun nro olemassa Ostolasku {0}'
b'apps/erpnext/erpnext/config/selling.py +118',b'Manage Sales Person Tree.',b'hallitse myyj\xc3\xa4puuta'
b'DocType: Job Applicant',b'Cover Letter',b'Saatekirje'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37',b'Outstanding Cheques and Deposits to clear',b'Erinomainen Sekkej\xc3\xa4 ja Talletukset tyhjent\xc3\xa4\xc3\xa4'
b'DocType: Item',b'Synced With Hub',b'synkronoi Hub:lla'
b'DocType: Driver',b'Fleet Manager',b'V\xc3\xa4lineiden yll\xc3\xa4pit\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542',b'Row #{0}: {1} can not be negative for item {2}',b'Rivi # {0}: {1} ei voi olla negatiivinen er\xc3\xa4 {2}'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59',b'Wrong Password',b'V\xc3\xa4\xc3\xa4r\xc3\xa4 salasana'
b'DocType: Item',b'Variant Of',b'Muunnelma kohteesta'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406',"b""Completed Qty can not be greater than 'Qty to Manufacture'""","b'valmiit yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla suurempi kuin ""tuotannon m\xc3\xa4\xc3\xa4r\xc3\xa4""'"
b'DocType: Period Closing Voucher',b'Closing Account Head',b'tilin otsikon sulkeminen'
b'DocType: Employee',b'External Work History',b'ulkoinen ty\xc3\xb6historia'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +111',b'Circular Reference Error',b'kiertoviite vihke'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206',b'Student Report Card',b'Opiskelukortti'
b'DocType: Appointment Type',b'Is Inpatient',b'On sairaala'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55',b'Guardian1 Name',b'Guardian1 Name'
b'DocType: Delivery Note',b'In Words (Export) will be visible once you save the Delivery Note.',"b'sanat n\xc3\xa4kyv\xc3\xa4t, (vienti) kun tallennat l\xc3\xa4hetteen'"
b'DocType: Cheque Print Template',b'Distance from left edge',b'Et\xc3\xa4isyys vasemmasta reunasta'
b'apps/erpnext/erpnext/utilities/bot.py +29',b'{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2})',b'{0} yksikk\xc3\xb6\xc3\xa4 [{1}] (# Form / Kohde / {1}) l\xc3\xb6ytyi [{2}] (# Form / Varasto / {2})'
b'DocType: Lead',b'Industry',b'teollisuus'
b'DocType: Employee',b'Job Profile',b'Job Profile'
b'DocType: BOM Item',b'Rate & Amount',b'Hinta &amp; m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6',b'This is based on transactions against this Company. See timeline below for details',b'T\xc3\xa4m\xc3\xa4 perustuu liiketoimiin t\xc3\xa4t\xc3\xa4 yhti\xc3\xb6t\xc3\xa4 vastaan. Katso yksityiskohtaisia tietoja aikajanasta'
b'DocType: Stock Settings',b'Notify by Email on creation of automatic Material Request',b'Ilmoita automaattisen hankintapyynn\xc3\xb6n luomisesta s\xc3\xa4hk\xc3\xb6postitse'
b'apps/erpnext/erpnext/healthcare/setup.py +259',b'Resistant',b'kest\xc3\xa4v\xc3\xa4'
b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77',b'Please set Hotel Room Rate on {}',b'Aseta hotellihuoneen hinta {}'
b'DocType: Journal Entry',b'Multi Currency',b'Multi Valuutta'
b'DocType: Opening Invoice Creation Tool',b'Invoice Type',b'lasku tyyppi'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939',b'Delivery Note',b'l\xc3\xa4hete'
b'DocType: Consultation',b'Encounter Impression',b'Encounter Impression'
b'apps/erpnext/erpnext/config/learn.py +82',b'Setting up Taxes',b'Verojen perusm\xc3\xa4\xc3\xa4ritykset'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134',b'Cost of Sold Asset',b'Kustannukset Myyty Asset'
b'DocType: Volunteer',b'Morning',b'Aamu'
b'apps/erpnext/erpnext/accounts/utils.py +350',b'Payment Entry has been modified after you pulled it. Please pull it again.',"b'Maksukirjausta on muutettu siirron j\xc3\xa4lkeen, siirr\xc3\xa4 se uudelleen'"
b'DocType: Program Enrollment Tool',b'New Student Batch',b'Uusi opiskelijaryhm\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +479',b'{0} entered twice in Item Tax',b'{0} vero on kirjattu kahdesti'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113',b'Summary for this week and pending activities',b'Yhteenveto t\xc3\xa4ll\xc3\xa4 viikolla ja keskener\xc3\xa4isten toimien'
b'DocType: Student Applicant',b'Admitted',b'Hyv\xc3\xa4ksytty'
b'DocType: Workstation',b'Rent Cost',b'vuokrakustannukset'
b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81',b'Amount After Depreciation',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 j\xc3\xa4lkeen Poistot'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97',b'Upcoming Calendar Events',b'Tulevia kalenteritapahtumia'
b'apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1',b'Variant Attributes',b'malli tuntomerkit'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85',b'Please select month and year',b'Ole hyv\xc3\xa4 ja valitse kuukausi ja vuosi'
b'DocType: Employee',b'Company Email',b'yrityksen s\xc3\xa4hk\xc3\xb6posti'
b'DocType: GL Entry',b'Debit Amount in Account Currency',b'Debit M\xc3\xa4\xc3\xa4r\xc3\xa4 tilini Valuutta'
b'DocType: Supplier Scorecard',b'Scoring Standings',b'Pisteiden sijoitukset'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'tilauksen arvo'
b'apps/erpnext/erpnext/config/accounts.py +27',b'Bank/Cash transactions against party or for internal transfer',b'Pankki / Cash liiketoimien vastaan osapuolelle tai sis\xc3\xa4inen siirto'
b'DocType: Shipping Rule',b'Valid for Countries',b'Voimassa maissa'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +55',"b""This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set""","b""T\xc3\xa4m\xc3\xa4 tuote on mallipohja, eik\xc3\xa4 sit\xc3\xa4 voi k\xc3\xa4ytt\xc3\xa4\xc3\xa4 tapahtumissa, tuotteen tuntomerkit kopioidaan ellei '\xc3\xa4l\xc3\xa4 kopioi' ole aktivoitu"""
b'DocType: Grant Application',b'Grant Application',b'Avustushakemus'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69',b'Total Order Considered',b'pidet\xc3\xa4\xc3\xa4n kokonaistilauksena'
b'apps/erpnext/erpnext/config/hr.py +243',"b'Employee designation (e.g. CEO, Director etc.).'","b'ty\xc3\xb6ntekij\xc3\xa4n nimitys (myyj\xc3\xa4, varastomies jne).'"
b'DocType: Sales Invoice',"b""Rate at which Customer Currency is converted to customer's base currency""","b'taso, jolla asiakkaan valuutta muunnetaan asiakkaan k\xc3\xa4ytt\xc3\xa4m\xc3\xa4ksi perusvaluutaksi'"
b'DocType: Course Scheduling Tool',b'Course Scheduling Tool',b'Tietenkin ajoitusty\xc3\xb6kalun'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +623',b'Row #{0}: Purchase Invoice cannot be made against an existing asset {1}',b'Rivi # {0}: Ostolaskujen ei voi tehd\xc3\xa4 vastaan olemassaolevan hy\xc3\xb6dykkeen {1}'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257',b'[Urgent] Error while creating recurring %s for %s',b'[Kiireellinen] Virhe luodessasi toistuvaa% s: ta% s: lle'
b'DocType: Land Unit',b'LInked Analysis',b'LInked Analysis'
b'DocType: Item Tax',b'Tax Rate',b'Veroaste'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73',b'Application period cannot be across two allocation records',b'Sovellusjakso ei voi olla kahden jakotiedon v\xc3\xa4liss\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59',b'{0} already allocated for Employee {1} for period {2} to {3}',b'{0} on jo my\xc3\xb6nnetty Ty\xc3\xb6suhde {1} kauden {2} ja {3}'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141',b'Purchase Invoice {0} is already submitted',b'Ostolasku {0} on jo vahvistettu'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92',b'Row # {0}: Batch No must be same as {1} {2}',b'Rivi # {0}: Er\xc3\xa4 on oltava sama kuin {1} {2}'
b'DocType: Material Request Plan Item',b'Material Request Plan Item',b'Materiaalihakemuksen suunnitelma'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52',b'Convert to non-Group',b'muunna pois ryhm\xc3\xa4st\xc3\xa4'
b'DocType: Project Update',b'Good/Steady',b'Hyv\xc3\xa4 / Steady'
b'DocType: C-Form Invoice Detail',b'Invoice Date',b'Laskun p\xc3\xa4iv\xc3\xa4ys'
b'DocType: GL Entry',b'Debit Amount',b'Debit M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/party.py +248',b'There can only be 1 Account per Company in {0} {1}',b'Kohdassa {0} {1} voi olla vain yksi tili per yritys'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426',b'Please see attachment',b'Katso liitetiedosto'
b'DocType: Purchase Order',b'% Received',b'% Saapunut'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3',b'Create Student Groups',b'Luo Student Groups'
b'DocType: Volunteer',b'Weekends',b'Viikonloppuisin'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Credit Note Amount',b'Hyvityslaskun summa'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187',b'{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3}',b'{0} ({1}) ei voi olla suurempi kuin suunniteltu kvantititeetti ({2}) Ty\xc3\xb6j\xc3\xa4rjestyksess\xc3\xa4 {3}'
b'DocType: Setup Progress Action',b'Action Document',b'Toiminta-asiakirja'
b'DocType: Chapter Member',b'Website URL',b'verkkosivujen URL'
,b'Finished Goods',b'Valmiit tavarat'
b'DocType: Delivery Note',b'Instructions',b'ohjeet'
b'DocType: Quality Inspection',b'Inspected By',b'tarkastanut'
b'DocType: Asset Maintenance Log',b'Maintenance Type',"b'huolto, tyyppi'"
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45',b'{0} - {1} is not enrolled in the Course {2}',b'{0} - {1} ei ilmoittautunut Course {2}'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225',b'Student Name: ',b'Opiskelijan nimi:'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59',b'Serial No {0} does not belong to Delivery Note {1}',b'Sarjanumero {0} ei kuulu l\xc3\xa4hetteeseen {1}'
b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97',"b""There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.""","b'N\xc3\xa4ytt\xc3\xa4\xc3\xa4 olevan ongelma palvelimen GoCardless-kokoonpanon kanssa. \xc3\x84l\xc3\xa4 huoli, jos vika ep\xc3\xa4onnistuu, summa palautetaan tilillesi.'"
b'apps/erpnext/erpnext/templates/pages/demo.html +47',b'ERPNext Demo',b'ERPNext Demo'
b'apps/erpnext/erpnext/public/js/utils/item_selector.js +20',b'Add Items',b'Lis\xc3\xa4\xc3\xa4 nimikkeit\xc3\xa4'
b'DocType: Item Quality Inspection Parameter',b'Item Quality Inspection Parameter',b'tuotteen laatutarkistus parametrit'
b'DocType: Depreciation Schedule',b'Schedule Date',"b'Aikataulu, p\xc3\xa4iv\xc3\xa4'"
b'apps/erpnext/erpnext/config/hr.py +116',"b'Earnings, Deductions and other Salary components'","b'Tulos, V\xc3\xa4hennykset ja muut Palkka komponentit'"
b'DocType: Packed Item',b'Packed Item',b'Pakattu tuote'
b'DocType: Job Offer Term',b'Job Offer Term',b'Ty\xc3\xb6tarjousaika'
b'apps/erpnext/erpnext/config/buying.py +65',b'Default settings for buying transactions.',b'Oston oletusasetukset.'
b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29',b'Activity Cost exists for Employee {0} against Activity Type - {1}',b'aktiviteettikustannukset per ty\xc3\xb6ntekij\xc3\xa4 {0} / aktiviteetin muoto - {1}'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Pakollinen kentt\xc3\xa4 - Get opiskelijoiden'
b'DocType: Program Enrollment',b'Enrolled courses',b'ilmoittautunut kursseja'
b'DocType: Currency Exchange',b'Currency Exchange',b'valuutanvaihto'
b'DocType: Opening Invoice Creation Tool Item',b'Item Name',b'Nimikkeen nimi'
b'DocType: Authorization Rule',b'Approving User  (above authorized value)',b'Hyv\xc3\xa4ksymisest\xc3\xa4 User (edell\xc3\xa4 valtuutettu arvo)'
b'DocType: Email Digest',b'Credit Balance',b'kredit tase'
b'DocType: Employee',b'Widowed',b'J\xc3\xa4\xc3\xa4nyt leskeksi'
b'DocType: Request for Quotation',b'Request for Quotation',b'Tarjouspyynt\xc3\xb6'
b'DocType: Healthcare Settings',b'Require Lab Test Approval',b'Vaaditaan Lab Test Approval'
b'DocType: Salary Slip Timesheet',b'Working Hours',b'Ty\xc3\xb6aika'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59',b'Total Outstanding',b'Yhteens\xc3\xa4 erinomainen'
b'DocType: Naming Series',b'Change the starting / current sequence number of an existing series.',b'muuta aloitusta / nykyselle j\xc3\xa4rjestysnumerolle tai olemassa oleville sarjoille'
b'DocType: Dosage Strength',b'Strength',b'Vahvuus'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1534',b'Create a new Customer',b'Luo uusi asiakas'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59',"b'If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.'",b'mik\xc3\xa4li useampi hinnoittelu s\xc3\xa4\xc3\xa4nt\xc3\xb6 jatkaa vaikuttamista k\xc3\xa4ytt\xc3\xa4j\xc3\xa4ji\xc3\xa4 pyydet\xc3\xa4\xc3\xa4n asettamaan prioriteetti manuaalisesti ristiriidan ratkaisemiseksi'
b'apps/erpnext/erpnext/utilities/activation.py +90',b'Create Purchase Orders',b'Luo ostotilaukset'
,b'Purchase Register',b'Osto Rekister\xc3\xb6idy'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116',b'Patient not found',b'Potilasta ei l\xc3\xb6ydy'
b'DocType: Scheduling Tool',b'Rechedule',b'Rechedule'
b'DocType: Landed Cost Item',b'Applicable Charges',b'sovellettavat maksut'
b'DocType: Workstation',b'Consumable Cost',b'k\xc3\xa4ytett\xc3\xa4v\xc3\xa4t kustannukset'
b'DocType: Purchase Receipt',b'Vehicle Date',b'Ajoneuvo P\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Student Log',b'Medical',b'L\xc3\xa4\xc3\xa4ketieteellinen'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175',b'Reason for losing',b'H\xc3\xa4vi\xc3\xb6n syy'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +52',b'Update Account Number',b'P\xc3\xa4ivit\xc3\xa4 tilinumero'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +44',b'Lead Owner cannot be same as the Lead',b'Liidin vastuullinen ei voi olla sama kuin itse liidi'
b'apps/erpnext/erpnext/accounts/utils.py +356',b'Allocated amount can not greater than unadjusted amount',b'Jaettava m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi ylitt\xc3\xa4\xc3\xa4 oikaisematon m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Announcement',b'Receiver',b'Vastaanotin'
b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83',b'Workstation is closed on the following dates as per Holiday List: {0}',b'Ty\xc3\xb6asema on suljettu seuraavina p\xc3\xa4ivin\xc3\xa4 lomap\xc3\xa4ivien {0} mukaan'
b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32',b'Opportunities',b'Mahdollisuudet'
b'DocType: Lab Test Template',b'Single',b'Yksitt\xc3\xa4inen'
b'DocType: Salary Slip',b'Total Loan Repayment',b'Yhteens\xc3\xa4 Lainan takaisinmaksu'
b'DocType: Account',b'Cost of Goods Sold',b'myydyn tavaran kustannuskset'
b'DocType: Subscription',b'Yearly',b'Vuosi'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230',b'Please enter Cost Center',b'Sy\xc3\xb6t\xc3\xa4 kustannuspaikka'
b'DocType: Drug Prescription',b'Dosage',b'annostus'
b'DocType: Journal Entry Account',b'Sales Order',b'Myyntitilaus'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69',b'Avg. Selling Rate',b'Myynnin keskihinta'
b'DocType: Assessment Plan',b'Examiner Name',b'Tutkijan Name'
b'DocType: Lab Test Template',b'No Result',b'Ei tulosta'
b'DocType: Purchase Invoice Item',b'Quantity and Rate',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 ja hinta'
b'DocType: Delivery Note',b'% Installed',b'% asennettu'
b'apps/erpnext/erpnext/utilities/user_progress.py +230',b'Classrooms/ Laboratories etc where lectures can be scheduled.',"b'Luokkahuoneet / Laboratories, johon k\xc3\xa4ytet\xc3\xa4\xc3\xa4n luentoja voidaan ajoittaa.'"
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46',b'Please enter company name first',b'Anna yrityksen nimi ensin'
b'DocType: Purchase Invoice',b'Supplier Name',b'Toimittaja'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25',b'Read the ERPNext Manual',b'Lue ERPNext Manual'
b'DocType: Purchase Invoice',b'01-Sales Return',b'01-myynnin palautus'
b'DocType: Account',b'Is Group',b'on ryhm\xc3\xa4'
b'DocType: Email Digest',b'Pending Purchase Orders',b'Odottaa Ostotilaukset'
b'DocType: Stock Settings',b'Automatically Set Serial Nos based on FIFO',b'Automaattisesti Serial nro perustuu FIFO'
b'DocType: Accounts Settings',b'Check Supplier Invoice Number Uniqueness',b'tarkista toimittajan laskunumeron yksil\xc3\xb6llisyys'
b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34',b'Primary Address Details',b'Ensisijaiset osoitetiedot'
b'DocType: Vehicle Service',b'Oil Change',b'\xc3\x96ljynvaihto'
b'DocType: Asset Maintenance Log',b'Asset Maintenance Log',b'Omaisuudenhoitokirja'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57',"b""'To Case No.' cannot be less than 'From Case No.'""","b""'Aloitustapahtumanumero' ei voi olla pienempi 'P\xc3\xa4\xc3\xa4ttymistapahtumanumero'"""
b'DocType: Chapter',b'Non Profit',b'nettotulos'
b'DocType: Production Plan',b'Not Started',b'Ei aloitettu'
b'DocType: Lead',b'Channel Partner',b'v\xc3\xa4lityskumppani'
b'DocType: Account',b'Old Parent',b'Vanha Parent'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Pakollinen kentt\xc3\xa4 - Lukuvuosi'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220',b'{0} {1} is not associated with {2} {3}',b'{0} {1} ei ole liitetty {2} {3}'
b'DocType: Notification Control',b'Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.',"b'muokkaa johdantoteksti\xc3\xa4 joka l\xc3\xa4hetet\xc3\xa4\xc3\xa4n s\xc3\xa4hk\xc3\xb6postin osana, joka tapahtumalla on oma johdantoteksi'"
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176',b'Please set default payable account for the company {0}',b'Aseta oletus maksettava osuus yhti\xc3\xb6n {0}'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +511',b'Transaction not allowed against stopped Work Order {0}',b'Tapahtuma ei ole sallittu pys\xc3\xa4ytetty\xc3\xa4 ty\xc3\xb6j\xc3\xa4rjestyst\xc3\xa4 vastaan {0}'
b'DocType: Setup Progress Action',b'Min Doc Count',b'Min Doc Count'
b'apps/erpnext/erpnext/config/manufacturing.py +84',b'Global settings for all manufacturing processes.',b'yleiset asetukset valmistusprosesseille'
b'DocType: Accounts Settings',b'Accounts Frozen Upto',b'tilit j\xc3\xa4\xc3\xa4dytetty toistaiseksi / asti'
b'DocType: SMS Log',b'Sent On',b'l\xc3\xa4hetetty'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +700',b'Attribute {0} selected multiple times in Attributes Table',b'Taito {0} valittu useita kertoja m\xc3\xa4\xc3\xa4ritteet taulukossa'
b'DocType: HR Settings',b'Employee record is created using selected field. ',b'ty\xc3\xb6ntekij\xc3\xa4 tietue luodaan k\xc3\xa4ytt\xc3\xa4m\xc3\xa4ll\xc3\xa4 valittua kentt\xc3\xa4\xc3\xa4'
b'DocType: Sales Order',b'Not Applicable',b'ei sovellettu'
b'apps/erpnext/erpnext/config/hr.py +70',b'Holiday master.',b'lomien valvonta'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85',b'Opening Invoice Item',b'Avaustilauksen avaus'
b'DocType: Request for Quotation Item',b'Required Date',b'pyydetty p\xc3\xa4iv\xc3\xa4'
b'DocType: Delivery Note',b'Billing Address',b'Laskutusosoite'
b'DocType: BOM',b'Costing',b'kustannuslaskenta'
b'DocType: Tax Rule',b'Billing County',b'Laskutus l\xc3\xa4\xc3\xa4ni'
b'DocType: Purchase Taxes and Charges',"b'If checked, the tax amount will be considered as already included in the Print Rate / Print Amount'",b't\xc3\xa4p\xc3\xa4tt\xc3\xa4ess\xc3\xa4 veron arvom\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4 pidet\xc3\xa4\xc3\xa4n jo sis\xc3\xa4llettyn\xc3\xa4 tulostetasoon / tulostem\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4n'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceRef',b'PieceRef'
b'DocType: Request for Quotation',b'Message for Supplier',b'Viesti toimittaja'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40',b'Work Order',b'Ty\xc3\xb6j\xc3\xa4rjestys'
b'DocType: Driver',b'DRIVER-.#####',b'DRIVER -. #####'
b'DocType: Sales Invoice',b'Total Qty',b'yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 yhteens\xc3\xa4'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 -s\xc3\xa4hk\xc3\xb6postitunnus'
b'DocType: Item',b'Show in Website (Variant)',b'N\xc3\xa4yt\xc3\xa4 Web-sivuston (Variant)'
b'DocType: Employee',b'Health Concerns',"b'terveys, huolenaiheet'"
b'DocType: Payroll Entry',b'Select Payroll Period',b'Valitse Payroll Aika'
b'DocType: Purchase Invoice',b'Unpaid',b'Palkaton'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49',b'Reserved for sale',b'Varattu myyt\xc3\xa4v\xc3\xa4n\xc3\xa4'
b'DocType: Packing Slip',b'From Package No.',b'pakkauksesta'
b'DocType: Item Attribute',b'To Range',b'Vaihtuakseen'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29',b'Securities and Deposits',b'Arvopaperit ja talletukset'
b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46',"b""Can't change valuation method, as there are transactions against some items which does not have it's own valuation method""","b'Voi muuttaa arvonm\xc3\xa4\xc3\xa4ritt\xc3\xa4mismenetelm\xc3\xa4\xc3\xa4 koska on olemassa tapahtumia vastaan joitakin kohtia, joita ei ole se oma arviointimenetelm\xc3\xa4\xc3\xa4'"
b'DocType: Student Report Generation Tool',b'Attended by Parents',b'Osallistuvat vanhemmat'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82',b'Total leaves allocated is mandatory',b'Hyv\xc3\xa4ksytt\xc3\xa4vien vapaiden kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4 on pakollinen'
b'DocType: Patient',b'AB Positive',b'AB Positiivinen'
b'DocType: Job Opening',b'Description of a Job Opening',b'Ty\xc3\xb6paikan kuvaus'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110',b'Pending activities for today',b'Vireill\xc3\xa4 toimintaa t\xc3\xa4n\xc3\xa4\xc3\xa4n'
b'apps/erpnext/erpnext/config/hr.py +24',b'Attendance record.',b'osallistumis tietue'
b'DocType: Salary Structure',b'Salary Component for timesheet based payroll.',b'Tuntilomakkeeseen perustuva palkan osuus.'
b'DocType: Sales Order Item',b'Used for Production Plan',b'K\xc3\xa4ytet\xc3\xa4\xc3\xa4n tuotannon suunnittelussa'
b'DocType: Employee Loan',b'Total Payment',b'Koko maksu'
b'DocType: Manufacturing Settings',b'Time Between Operations (in mins)',b'Toimintojen v\xc3\xa4linen aika (minuuteissa)'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132',b'{0} {1} is cancelled so the action cannot be completed',"b'{0} {1} on peruutettu, joten toimintoa ei voida suorittaa'"
b'DocType: Customer',b'Buyer of Goods and Services.',b'Tavaroiden ja palvelujen ostaja'
b'DocType: Journal Entry',b'Accounts Payable',b'maksettava tilit'
b'DocType: Patient',b'Allergies',b'allergiat'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33',b'The selected BOMs are not for the same item',b'Valitut osaluettelot eiv\xc3\xa4t koske samaa nimikett\xc3\xa4'
b'DocType: Supplier Scorecard Standing',b'Notify Other',b'Ilmoita muille'
b'DocType: Vital Signs',b'Blood Pressure (systolic)',b'Verenpaine (systolinen)'
b'DocType: Pricing Rule',b'Valid Upto',b'Voimassa asti'
b'DocType: Training Event',b'Workshop',b'ty\xc3\xb6paja'
b'DocType: Supplier Scorecard Scoring Standing',b'Warn Purchase Orders',b'Varoittaa ostotilauksia'
b'apps/erpnext/erpnext/utilities/user_progress.py +67',b'List a few of your customers. They could be organizations or individuals.',b'Luettele muutamia asiakkaitasi. Asiakkaat voivat olla organisaatioita tai yksil\xc3\xb6it\xc3\xa4.'
b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23',b'Enough Parts to Build',b'Tarpeeksi osat rakentaa'
b'DocType: POS Profile User',b'POS Profile User',b'POS-profiilin k\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128',b'Direct Income',b'suorat tulot'
b'DocType: Patient Appointment',b'Date TIme',b'Treffiaika'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45',"b'Can not filter based on Account, if grouped by Account'",b'ei voi suodattaa tileitt\xc3\xa4in mk\xc3\xa4li ryhmitelty tileitt\xc3\xa4in'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130',b'Administrative Officer',b'hallintovirkailija'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39',b'Setting up company and taxes',b'Yrityksen perustaminen ja verotus'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Valitse kurssi'
b'DocType: Codification Table',b'Codification Table',b'Kodifiointitaulukko'
b'DocType: Timesheet Detail',b'Hrs',b'hrs'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349',b'Please select Company',b'Ole hyv\xc3\xa4 ja valitse Company'
b'DocType: Stock Entry Detail',b'Difference Account',b'Erotuksen tili'
b'DocType: Purchase Invoice',b'Supplier GSTIN',b'Toimittaja GSTIN'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +47',b'Cannot close task as its dependant task {0} is not closed.',"b'ei voi sulkea sill\xc3\xa4 se on toisesta riippuvainen teht\xc3\xa4v\xc3\xa4 {0}, teht\xc3\xa4v\xc3\xa4\xc3\xa4 ei ole suljettu'"
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435',b'Please enter Warehouse for which Material Request will be raised',b'Sy\xc3\xb6t\xc3\xa4 varasto jonne hankintapyynt\xc3\xb6 ohjataan'
b'DocType: Work Order',b'Additional Operating Cost',b'lis\xc3\xa4toimintokustannukset'
b'DocType: Lab Test Template',b'Lab Routine',b'Lab Routine'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20',b'Cosmetics',b'kosmetiikka'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18',b'Please select Completion Date for Completed Asset Maintenance Log',b'Valitse Valmistuneen omaisuudenhoitorekisterin p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +552',"b'To merge, following properties must be same for both items'",b'Seuraavat ominaisuudet tulee olla samat molemmilla tuotteilla jotta ne voi sulauttaa'
b'DocType: Shipping Rule',b'Net Weight',b'Nettopaino'
b'DocType: Employee',b'Emergency Phone',b'h\xc3\xa4t\xc3\xa4numero'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82',b'{0} {1} does not exist.',b'{0} {1} ei ole olemassa.'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29',b'Buy',b'Ostaa'
,b'Serial No Warranty Expiry',b'Sarjanumeron takuu on p\xc3\xa4\xc3\xa4ttynyt'
b'DocType: Sales Invoice',b'Offline POS Name',b'Poissa POS Name'
b'apps/erpnext/erpnext/utilities/user_progress.py +180',b'Student Application',b'Opiskelija-sovellus'
b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Tarkentakaa arvosana Threshold 0%'
b'DocType: Sales Order',b'To Deliver',b'Toimitukseen'
b'DocType: Purchase Invoice Item',b'Item',b'Nimike'
b'apps/erpnext/erpnext/healthcare/setup.py +256',b'High Sensitivity',b'Suuri herkkyys'
b'apps/erpnext/erpnext/config/non_profit.py +48',b'Volunteer Type information.',b'Vapaaehtoisty\xc3\xb6ntekij\xc3\xb6iden tiedot.'
b'DocType: Cash Flow Mapping Template',b'Cash Flow Mapping Template',b'Kassavirran kartoitusmalli'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2555',b'Serial no item cannot be a fraction',b'Sarjanumero tuote ei voi olla jae'
b'DocType: Journal Entry',b'Difference (Dr - Cr)',b'erotus (\xe2\x82\xac - TV)'
b'DocType: Account',b'Profit and Loss',b'Tuloslaskelma'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104',"b'Not permitted, configure Lab Test Template as required'","b'Ei sallita, m\xc3\xa4\xc3\xa4rit\xc3\xa4 Lab Test Template tarvittaessa'"
b'DocType: Patient',b'Risk Factors',b'Riskitekij\xc3\xa4t'
b'DocType: Patient',b'Occupational Hazards and Environmental Factors',b'Ty\xc3\xb6per\xc3\xa4iset vaaratekij\xc3\xa4t ja ymp\xc3\xa4rist\xc3\xb6tekij\xc3\xa4t'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239',b'Stock Entries already created for Work Order ',"b'Osakkeet, jotka on jo luotu ty\xc3\xb6j\xc3\xa4rjestykseen'"
b'DocType: Vital Signs',b'Respiratory rate',b'Hengitysnopeus'
b'apps/erpnext/erpnext/config/stock.py +334',b'Managing Subcontracting',b'Alihankintojen hallinta'
b'DocType: Vital Signs',b'Body Temperature',b'Ruumiinl\xc3\xa4mp\xc3\xb6'
b'DocType: Project',b'Project will be accessible on the website to these users',b'Projekti on n\xc3\xa4iden k\xc3\xa4ytt\xc3\xa4jien n\xc3\xa4ht\xc3\xa4viss\xc3\xa4 www-sivustolla'
b'DocType: Detected Disease',b'Disease',b'tauti'
b'apps/erpnext/erpnext/config/projects.py +29',b'Define Project type.',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 Hankkeen tyyppi.'
b'DocType: Supplier Scorecard',b'Weighting Function',b'Painoarvon funktio'
b'DocType: Physician',b'OP Consulting Charge',b'OP-konsultointipalkkio'
b'apps/erpnext/erpnext/utilities/user_progress.py +28',b'Setup your ',b'Aseta oma'
b'DocType: Student Report Generation Tool',b'Show Marks',b'N\xc3\xa4yt\xc3\xa4 merkit'
b'DocType: Quotation',"b""Rate at which Price list currency is converted to company's base currency""","b'taso, jolla hinnasto valuutta muunnetaan yrityksen k\xc3\xa4ytt\xc3\xa4m\xc3\xa4ksi perusvaluutaksi'"
b'apps/erpnext/erpnext/setup/doctype/company/company.py +70',b'Account {0} does not belong to company: {1}',b'tili {0} ei kuulu yritykselle: {1}'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +52',b'Abbreviation already used for another company',b'Lyhenne on jo k\xc3\xa4yt\xc3\xb6ss\xc3\xa4 toisella yrityksell\xc3\xa4'
b'DocType: Selling Settings',b'Default Customer Group',b'Oletusasiakasryhm\xc3\xa4'
b'DocType: Asset Repair',b'ARLOG-',b'ARLOG-'
b'DocType: Global Defaults',"b""If disable, 'Rounded Total' field will not be visible in any transaction""","b""mik\xc3\xa4li 'py\xc3\xb6ristys yhteens\xc3\xa4' kentt\xc3\xa4 on poistettu k\xc3\xa4yt\xc3\xb6st\xc3\xa4 se ei n\xc3\xa4y miss\xc3\xa4\xc3\xa4n tapahtumassa"""
b'DocType: BOM',b'Operating Cost',b'K\xc3\xa4ytt\xc3\xb6kustannus'
b'DocType: Crop',b'Produced Items',b'Tuotteita'
b'DocType: Sales Order Item',b'Gross Profit',b'bruttovoitto'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49',b'Increment cannot be 0',b'Lis\xc3\xa4ys voi olla 0'
b'DocType: Company',b'Delete Company Transactions',b'poista yrityksen tapahtumia'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364',b'Reference No and Reference Date is mandatory for Bank transaction',b'Viitenumero ja viitep\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 on pakollinen Pankin myynnin'
b'DocType: Purchase Receipt',b'Add / Edit Taxes and Charges',b'Lis\xc3\xa4\xc3\xa4 / muokkaa veroja ja maksuja'
b'DocType: Payment Entry Reference',b'Supplier Invoice No',b'toimittajan laskun nro'
b'DocType: Territory',b'For reference',b'viitteeseen'
b'DocType: Healthcare Settings',b'Appointment Confirmation',b'Nimitysvakuutus'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158',"b'Cannot delete Serial No {0}, as it is used in stock transactions'","b'Sarjanumeroa {0} ei voida poistaa, koska sit\xc3\xa4 on k\xc3\xa4ytetty varastotapahtumissa'"
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256',b'Closing (Cr)',b'sulku (cr)'
b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1',b'Hello',b'Hei'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118',b'Move Item',b'Move Kohde'
b'DocType: Serial No',b'Warranty Period (Days)',b'Takuuaika (p\xc3\xa4iv\xc3\xa4\xc3\xa4)'
b'DocType: Installation Note Item',b'Installation Note Item',b'asennus huomautus tuote'
b'DocType: Production Plan Item',b'Pending Qty',b'Odottaa Kpl'
b'DocType: Budget',b'Ignore',b'ohita'
b'apps/erpnext/erpnext/accounts/party.py +396',b'{0} {1} is not active',b'{0} {1} ei ole aktiivinen'
b'apps/erpnext/erpnext/config/accounts.py +272',b'Setup cheque dimensions for printing',b'Setup tarkistaa mitat tulostettavaksi'
b'DocType: Salary Slip',b'Salary Slip Timesheet',b'Tuntilomake'
b'apps/erpnext/erpnext/controllers/buying_controller.py +160',b'Supplier Warehouse mandatory for sub-contracted Purchase Receipt',b'Toimittajan varasto on pakollinen alihankintasaapumisessa'
b'DocType: Pricing Rule',b'Valid From',b'Voimassa alkaen'
b'DocType: Sales Invoice',b'Total Commission',b'Provisio yhteens\xc3\xa4'
b'DocType: Pricing Rule',b'Sales Partner',b'Myyntikumppani'
b'apps/erpnext/erpnext/config/buying.py +150',b'All Supplier scorecards.',b'Kaikki toimittajan tuloskortit.'
b'DocType: Buying Settings',b'Purchase Receipt Required',b'Saapumistosite vaaditaan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188',b'Target warehouse in row {0} must be same as Work Order',b'Rivin {0} kohdavarastojen on oltava samat kuin ty\xc3\xb6j\xc3\xa4rjestys'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +155',b'Valuation Rate is mandatory if Opening Stock entered',"b'Arvostustaso on pakollinen, jos avausvarasto on merkitty'"
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143',b'No records found in the Invoice table',b'Tietueita ei l\xc3\xb6ytynyt laskutaulukosta'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34',b'Please select Company and Party Type first',b'Valitse ensin yritys ja osapuoli tyyppi'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31',"b'Already set default in pos profile {0} for user {1}, kindly disabled default'","b'Jo oletusasetus pos profiilissa {0} k\xc3\xa4ytt\xc3\xa4j\xc3\xa4lle {1}, yst\xc3\xa4v\xc3\xa4llisesti poistettu oletus'"
b'apps/erpnext/erpnext/config/accounts.py +293',b'Financial / accounting year.',b'Tili- / Kirjanpitokausi'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9',b'Accumulated Values',b'kertyneet Arvot'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162',"b'Sorry, Serial Nos cannot be merged'",b'Sarjanumeroita ei voi yhdist\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72',b'Territory is Required in POS Profile',b'Alue on pakollinen POS-profiilissa'
b'DocType: Supplier',b'Prevent RFQs',b'Est\xc3\xa4 RFQ: t'
b'apps/erpnext/erpnext/utilities/activation.py +83',b'Make Sales Order',b'tee myyntitilaus'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168',b'Salary Slip submitted for period from {0} to {1}',"b'Palkkalipe\xc3\xa4, joka toimitetaan ajanjaksolta {0} - {1}'"
b'DocType: Project Task',b'Project Task',b'Projekti Teht\xc3\xa4v\xc3\xa4'
,b'Lead Id',b'Liidin tunnus'
b'DocType: C-Form Invoice Detail',b'Grand Total',b'Kokonaissumma'
b'DocType: Assessment Plan',b'Course',b'kurssi'
b'DocType: Timesheet',b'Payslip',b'Maksulaskelma'
b'apps/erpnext/erpnext/public/js/pos/pos.html +4',b'Item Cart',b'Kohta koriin'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38',b'Fiscal Year Start Date should not be greater than Fiscal Year End Date',b'Tilikauden aloitusp\xc3\xa4iv\xc3\xa4 tule olla suurempi kuin tilikauden p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Issue',b'Resolution',b'Ratkaisu'
b'DocType: C-Form',b'IV',b'IV'
b'apps/erpnext/erpnext/templates/pages/order.html +76',b'Delivered: {0}',b'Toimitettu: {0}'
b'DocType: Expense Claim',b'Payable Account',b'Maksettava tili'
b'DocType: Payment Entry',b'Type of Payment',b'Tyyppi Payment'
b'DocType: Sales Order',b'Billing and Delivery Status',b'Laskutus ja Toiminnan tila'
b'DocType: Job Applicant',b'Resume Attachment',b'Palauta liite'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58',b'Repeat Customers',b'Toistuvat asiakkaat'
b'DocType: Leave Control Panel',b'Allocate',b'Jakaa'
b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108',b'Create Variant',b'Luo variantti'
b'DocType: Sales Invoice',b'Shipping Bill Date',b'Shipping Bill p\xc3\xa4iv\xc3\xa4'
b'DocType: Production Plan',b'Production Plan',b'Tuotantosuunnitelma'
b'DocType: Opening Invoice Creation Tool',b'Opening Invoice Creation Tool',b'Avaustilien luomisty\xc3\xb6kalu'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853',b'Sales Return',b'Myynti Return'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96',"b""Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period""",b'Huomautus: Total varattu lehdet {0} ei saa olla pienempi kuin jo hyv\xc3\xa4ksytty lehdet {1} kaudeksi'
,b'Total Stock Summary',b'Yhteens\xc3\xa4 Stock Yhteenveto'
b'DocType: Announcement',b'Posted By',b'L\xc3\xa4hett\xc3\xa4nyt'
b'DocType: Item',b'Delivered by Supplier (Drop Ship)',b'Toimittaja l\xc3\xa4hett\xc3\xa4\xc3\xa4 asiakkaalle (ns. suoratoimitus)'
b'DocType: Healthcare Settings',b'Confirmation Message',b'Vahvistusviesti'
b'apps/erpnext/erpnext/config/crm.py +12',b'Database of potential customers.',b'tietokanta potentiaalisista asiakkaista'
b'DocType: Authorization Rule',b'Customer or Item',b'Asiakas tai nimike'
b'apps/erpnext/erpnext/config/selling.py +28',b'Customer database.',b'asiakasrekisteri'
b'DocType: Quotation',b'Quotation To',b'Tarjouksen kohde'
b'DocType: Lead',b'Middle Income',b'keskitason tulo'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228',b'Opening (Cr)',b'Opening (Cr)'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +872',b'Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.',b'Nimikkeen {0} oletusyksikk\xc3\xb6\xc3\xa4 ei voida muuttaa koska nykyisell\xc3\xa4 yksik\xc3\xb6ll\xc3\xa4 on tehty tapahtumia. Luo uusi nimike k\xc3\xa4ytt\xc3\xa4\xc3\xa4ksesi uutta oletusyksikk\xc3\xb6\xc3\xa4.'
b'apps/erpnext/erpnext/accounts/utils.py +354',b'Allocated amount can not be negative',b'kohdennettu m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla negatiivinen'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Aseta Yhti\xc3\xb6'
b'DocType: Share Balance',b'Share Balance',b'Osuuden saldo'
b'DocType: Purchase Order Item',b'Billed Amt',"b'Laskutettu, pankkip\xc3\xa4\xc3\xa4te'"
b'DocType: Training Result Employee',b'Training Result Employee',b'Harjoitustulos Ty\xc3\xb6ntekij\xc3\xa4'
b'DocType: Warehouse',b'A logical Warehouse against which stock entries are made.',"b'perustettu varasto, minne varastokirjaukset tehd\xc3\xa4\xc3\xa4n'"
b'DocType: Repayment Schedule',b'Principal Amount',b'Lainap\xc3\xa4\xc3\xa4oma'
b'DocType: Employee Loan Application',b'Total Payable Interest',b'Yhteens\xc3\xa4 Maksettava korko'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57',b'Total Outstanding: {0}',b'Yhteens\xc3\xa4 erinomainen: {0}'
b'DocType: Sales Invoice Timesheet',b'Sales Invoice Timesheet',b'Tuntilomake'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118',b'Reference No & Reference Date is required for {0}',b'viitenumero ja viitep\xc3\xa4iv\xc3\xa4 vaaditaan{0}'
b'DocType: Payroll Entry',b'Select Payment Account to make Bank Entry',b'Valitse Maksutili tehd\xc3\xa4 Bank Entry'
b'DocType: Hotel Settings',b'Default Invoice Naming Series',b'Oletuslaskujen numeromerkki'
b'apps/erpnext/erpnext/utilities/activation.py +136',"b'Create Employee records to manage leaves, expense claims and payroll'","b'Luo Ty\xc3\xb6ntekij\xc3\xa4 kirjaa hallita lehti\xc3\xa4, korvaushakemukset ja palkkahallinnon'"
b'DocType: Restaurant Reservation',b'Restaurant Reservation',b'Ravintolavaraus'
b'DocType: Land Unit',b'Land Unit Name',b'Maayksik\xc3\xb6n nimi'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190',b'Proposal Writing',b'Ehdotus Kirjoittaminen'
b'DocType: Payment Entry Deduction',b'Payment Entry Deduction',b'Payment Entry V\xc3\xa4hennys'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14',b'Wrapping up',b'K\xc3\xa4\xc3\xa4rimist\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35',b'Notify Customers via Email',b'Ilmoita asiakkaille s\xc3\xa4hk\xc3\xb6postilla'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35',b'Another Sales Person {0} exists with the same Employee id',b'Toinen myyj\xc3\xa4 {0} on jo olemassa samalla tunnuksella'
b'DocType: Employee Advance',b'Claimed Amount',b'Vahvistettu m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/config/education.py +180',b'Masters',b'Masters'
b'DocType: Assessment Plan',b'Maximum Assessment Score',b'Suurin Assessment Score'
b'apps/erpnext/erpnext/config/accounts.py +138',b'Update Bank Transaction Dates',b'P\xc3\xa4ivit\xc3\xa4 tilitapahtumien p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4t'
b'apps/erpnext/erpnext/config/projects.py +41',b'Time Tracking',b'Ajanseuranta'
b'DocType: Purchase Invoice',b'DUPLICATE FOR TRANSPORTER',b'DUPLICATE El\xc3\xa4inkuljettajan'
b'apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49',b'Row {0}# Paid Amount cannot be greater than requested advance amount',b'Rivi {0} # maksettu summa ei voi olla suurempi kuin pyydetty ennakkomaksu'
b'DocType: Fiscal Year Company',b'Fiscal Year Company',b'Yrityksen tilikausi'
b'DocType: Packing Slip Item',b'DN Detail',b'DN lis\xc3\xa4tiedot'
b'DocType: Training Event',b'Conference',b'Konferenssi'
b'DocType: Timesheet',b'Billed',b'Laskutetaan'
b'DocType: Batch',b'Batch Description',b'Er\xc3\xa4n kuvaus'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Luominen opiskelijaryhm\xc3\xa4t'
b'apps/erpnext/erpnext/accounts/utils.py +727',"b'Payment Gateway Account not created, please create one manually.'","b'Payment Gateway Tili ei ole luotu, luo yksi k\xc3\xa4sin.'"
b'DocType: Supplier Scorecard',b'Per Year',b'Vuodessa'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51',b'Not eligible for the admission in this program as per DOB',b'Ei saa osallistua t\xc3\xa4h\xc3\xa4n ohjelmaan kuin DOB'
b'DocType: Sales Invoice',b'Sales Taxes and Charges',b'Myynnin verot ja maksut'
b'DocType: Employee',b'Organization Profile',b'Organisaatio Profile'
b'DocType: Vital Signs',b'Height (In Meter)',b'Korkeus (mittarissa)'
b'DocType: Student',b'Sibling Details',b'Sisarus tiedot'
b'DocType: Vehicle Service',b'Vehicle Service',b'ajoneuvo Service'
b'apps/erpnext/erpnext/config/setup.py +101',b'Automatically triggers the feedback request based on conditions.',b'Automaattisesti laukaisee palaute pyynt\xc3\xb6 perustuu olosuhteissa.'
b'DocType: Employee',b'Reason for Resignation',b'Eroamisen syy'
b'apps/erpnext/erpnext/config/hr.py +152',b'Template for performance appraisals.',b'Mallipohja kehityskeskusteluihin'
b'DocType: Sales Invoice',b'Credit Note Issued',b'Hyvityslasku Annettu'
b'DocType: Project Task',b'Weight',b'Paino'
b'DocType: Payment Reconciliation',b'Invoice/Journal Entry Details',"b'lasku / p\xc3\xa4iv\xc3\xa4kirjakirjaus, lis\xc3\xa4tiedot'"
b'apps/erpnext/erpnext/accounts/utils.py +83',"b""{0} '{1}' not in Fiscal Year {2}""","b""{0} '{1}' ei ole tilikaudella {2}"""
b'DocType: Buying Settings',b'Settings for Buying Module',b'Ostomoduulin asetukset'
b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21',b'Asset {0} does not belong to company {1}',b'Asset {0} ei kuulu yhti\xc3\xb6n {1}'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70',b'Please enter Purchase Receipt first',b'Anna ostokuitti ensin'
b'DocType: Buying Settings',b'Supplier Naming By',b'toimittajan nimennyt'
b'DocType: Activity Type',b'Default Costing Rate',b'Oletus Kustannuslaskenta Hinta'
b'DocType: Maintenance Schedule',b'Maintenance Schedule',b'huoltoaikataulu'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36',"b'Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.'","b'Hinnoittelus\xc3\xa4\xc3\xa4nt\xc3\xb6jen perusteet suodatetaan asiakkaan, asiakasryhm\xc3\xa4n, alueen, toimittajan, toimittaja tyypin, myyntikumppanin jne mukaan'"
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29',b'Net Change in Inventory',b'Nettomuutos Inventory'
b'apps/erpnext/erpnext/config/hr.py +162',b'Employee Loan Management',b'Ty\xc3\xb6ntekij\xc3\xa4n Loan Management'
b'DocType: Employee',b'Passport Number',b'Passin numero'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60',b'Relation with Guardian2',b'Suhde Guardian2'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124',b'Manager',b'Hallinta'
b'DocType: Payment Entry',b'Payment From / To',b'Maksaminen / To'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +170',b'New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0}',b'Uusi luottoraja on pienempi kuin nykyinen j\xc3\xa4ljell\xc3\xa4 asiakkaalle. Luottoraja on oltava atleast {0}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428',b'Please set account in Warehouse {0}',b'Aseta tili Warehouse {0}'
b'apps/erpnext/erpnext/controllers/trends.py +39',"b""'Based On' and 'Group By' can not be same""","b""'perustaja' ja 'ryhm\xc3\xa4' ei voi olla samat"""
b'DocType: Sales Person',b'Sales Person Targets',b'Myyj\xc3\xa4n tavoitteet'
b'DocType: Installation Note',b'IN-',b'SIS\xc3\x84\xc3\x84N-'
b'DocType: Work Order Operation',b'In minutes',b'minuutteina'
b'DocType: Issue',b'Resolution Date',b'Ratkaisun p\xc3\xa4iv\xc3\xa4ys'
b'DocType: Lab Test Template',b'Compound',b'Yhdiste'
b'DocType: Student Batch Name',b'Batch Name',b'er\xc3\xa4 Name'
b'DocType: Fee Validity',b'Max number of visit',b'Vierailun enimm\xc3\xa4ism\xc3\xa4\xc3\xa4r\xc3\xa4'
,b'Hotel Room Occupancy',b'Hotellihuoneisto'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358',b'Timesheet created:',b'Tuntilomake luotu:'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931',b'Please set default Cash or Bank account in Mode of Payment {0}',b'Valitse oletusmaksutapa kassa- tai pankkitili maksulle {0}'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24',b'Enroll',b'kirjoittautua'
b'DocType: GST Settings',b'GST Settings',b'GST Asetukset'
b'DocType: Selling Settings',b'Customer Naming By',b'asiakkaan nimennyt'
b'DocType: Student Leave Application',b'Will show the student as Present in Student Monthly Attendance Report',b'N\xc3\xa4ytt\xc3\xa4\xc3\xa4 opiskelijan L\xc3\xa4sn\xc3\xa4 Student Kuukauden L\xc3\xa4sn\xc3\xa4olo Report'
b'DocType: Depreciation Schedule',b'Depreciation Amount',b'Poistot M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56',b'Convert to Group',b'muunna ryhm\xc3\xa4ksi'
b'DocType: Delivery Trip',b'TOUR-.#####',b'KIERTUE-.#####'
b'DocType: Activity Cost',b'Activity Type',b'ty\xc3\xb6teht\xc3\xa4v\xc3\xa4'
b'DocType: Request for Quotation',b'For individual supplier',b'Yksitt\xc3\xa4isten toimittaja'
b'DocType: BOM Operation',b'Base Hour Rate(Company Currency)',b'Base Hour Rate (Company valuutta)'
b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47',b'Delivered Amount',b'toimitettu'
b'DocType: Quotation Item',b'Item Balance',b'Kohta Balance'
b'DocType: Sales Invoice',b'Packing List',b'Pakkausluettelo'
b'apps/erpnext/erpnext/config/buying.py +28',b'Purchase Orders given to Suppliers.',b'Ostotilaukset annetaan Toimittajat.'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43',b'Publishing',b'Kustannustoiminta'
b'DocType: Accounts Settings',b'Report Settings',b'Raporttiasetukset'
b'DocType: Activity Cost',b'Projects User',b'Projektien perusk\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Consumed',b'k\xc3\xa4ytetty'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158',b'{0}: {1} not found in Invoice Details table',b'{0}: {1} ei l\xc3\xb6ydy laskun lis\xc3\xa4tiedot taulukosta'
b'DocType: Asset',b'Asset Owner Company',b'Omaisuuden omistajan yritys'
b'DocType: Company',b'Round Off Cost Center',b'Py\xc3\xb6ristys kustannuspaikka'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242',b'Maintenance Visit {0} must be cancelled before cancelling this Sales Order',b'huoltok\xc3\xa4ynti {0} on peruttava ennen myyntitilauksen perumista'
b'DocType: Asset Maintenance Log',b'AML-',b'AML-'
b'DocType: Item',b'Material Transfer',b'Varastosiirto'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24',b'Could not find path for ',b'Ei l\xc3\xb6ytynyt polkua'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221',b'Opening (Dr)',b'Perustaminen (\xe2\x82\xac)'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39',b'Posting timestamp must be after {0}',b'Tositteen aikaleima pit\xc3\xa4\xc3\xa4 olla {0} j\xc3\xa4lkeen'
b'apps/erpnext/erpnext/config/accounts.py +39',b'To make recurring documents',b'Tee toistuvia asiakirjoja'
,b'GST Itemised Purchase Register',b'GST Eritelty Osto Register'
b'DocType: Course Scheduling Tool',b'Reschedule',b'uudelleenj\xc3\xa4rjestelyst\xc3\xa4'
b'DocType: Employee Loan',b'Total Interest Payable',b'Koko Korkokulut'
b'DocType: Landed Cost Taxes and Charges',b'Landed Cost Taxes and Charges',b'Kohdistuneet kustannukset verot ja maksut'
b'DocType: Work Order Operation',b'Actual Start Time',b'todellinen aloitusaika'
b'DocType: BOM Operation',b'Operation Time',b'Operation Time'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316',b'Finish',b'Suorittaa loppuun'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412',b'Base',b'pohja'
b'DocType: Timesheet',b'Total Billed Hours',b'Yhteens\xc3\xa4 laskutusasteesta'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1530',b'Write Off Amount',b'Poiston arvo'
b'DocType: Leave Block List Allow',b'Allow User',b'Salli K\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'DocType: Journal Entry',b'Bill No',b'Bill No'
b'DocType: Company',b'Gain/Loss Account on Asset Disposal',b'Omaisuuden h\xc3\xa4vitt\xc3\xa4misen voitto/tappiotili'
b'DocType: Vehicle Log',b'Service Details',b'palvelu Lis\xc3\xa4tiedot'
b'DocType: Subscription',b'Quarterly',b'3 kk'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47',b'EcritureLib',b'EcritureLib'
b'DocType: Lab Test Template',b'Grouped',b'ryhmitelty'
b'DocType: Selling Settings',b'Delivery Note Required',b'l\xc3\xa4hete vaaditaan'
b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Pankkitakauksen Numero'
b'DocType: Assessment Criteria',b'Assessment Criteria',b'Arviointikriteerit'
b'DocType: BOM Item',b'Basic Rate (Company Currency)',b'perustaso (yrityksen valuutta)'
b'DocType: Student Attendance',b'Student Attendance',b'Student L\xc3\xa4sn\xc3\xa4olo'
b'DocType: Sales Invoice Timesheet',b'Time Sheet',b'Tuntilista'
b'DocType: Manufacturing Settings',b'Backflush Raw Materials Based On',b'Backflush Raaka-aineet Perustuvat'
b'DocType: Sales Invoice',b'Port Code',b'Satamakoodi'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957',b'Reserve Warehouse',b'Varausvarasto'
b'DocType: Lead',b'Lead is an Organization',b'Lyijy on j\xc3\xa4rjest\xc3\xb6'
b'DocType: Guardian Interest',b'Interest',b'Kiinnostaa'
b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10',b'Pre Sales',b'pre Sales'
b'DocType: Instructor Log',b'Other Details',b'muut lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18',b'Suplier',b'suplier'
b'DocType: Lab Test',b'Test Template',b'Testimalli'
b'DocType: Restaurant Order Entry Item',b'Served',b'palveli'
b'apps/erpnext/erpnext/config/non_profit.py +13',b'Chapter information.',b'Luvun tiedot.'
b'DocType: Account',b'Accounts',b'Talous'
b'DocType: Vehicle',b'Odometer Value (Last)',b'Matkamittarin lukema (Last)'
b'apps/erpnext/erpnext/config/buying.py +160',b'Templates of supplier scorecard criteria.',b'Toimittajan tuloskortin kriteereiden mallit.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109',b'Marketing',b'Markkinointi'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303',b'Payment Entry is already created',b'Maksu k\xc3\xa4ytt\xc3\xb6 on jo luotu'
b'DocType: Request for Quotation',b'Get Suppliers',b'Hanki toimittajat'
b'DocType: Purchase Receipt Item Supplied',b'Current Stock',b'nykyinen varasto'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +610',b'Row #{0}: Asset {1} does not linked to Item {2}',b'Rivi # {0}: Asset {1} ei liity Tuote {2}'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15',b'Please setup Instructor Naming System in Education &gt; Education Settings',b'Aseta Instructor Naming System in Education&gt; Koulutusasetukset'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394',b'Preview Salary Slip',b'Preview Palkka Slip'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54',b'Account {0} has been entered multiple times',b'Tili {0} on sy\xc3\xb6tetty useita kertoja'
b'DocType: Account',b'Expenses Included In Valuation',b'Arvoon sis\xc3\xa4ltyv\xc3\xa4t kustannukset'
b'apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37',b'You can only renew if your membership expires within 30 days',"b'Voit uusia vain, jos j\xc3\xa4senyytesi p\xc3\xa4\xc3\xa4ttyy 30 p\xc3\xa4iv\xc3\xa4n kuluessa'"
b'DocType: Land Unit',b'Longitude',b'pituusaste'
,b'Absent Student Report',b'Absent Student Report'
b'DocType: Crop',b'Crop Spacing UOM',b'Crop Spacing UOM'
b'DocType: Accounts Settings',b'Only select if you have setup Cash Flow Mapper documents',"b'Valitse vain, jos sinulla on asetettu Cash Flow Mapper -asiakirjoja'"
b'DocType: Email Digest',b'Next email will be sent on:',b'Seuraava s\xc3\xa4hk\xc3\xb6postiviesti l\xc3\xa4hetet\xc3\xa4\xc3\xa4n:'
b'DocType: Supplier Scorecard',b'Per Week',b'Viikossa'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +666',b'Item has variants.',b'tuotteella on useampia malleja'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154',b'Total Student',b'Yhteens\xc3\xa4 opiskelija'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65',b'Item {0} not found',b'Nimikett\xc3\xa4 {0} ei l\xc3\xb6ydy'
b'DocType: Bin',b'Stock Value',b'varastoarvo'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +239',b'Company {0} does not exist',b'Yritys {0} ei ole olemassa'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40',b'{0} has fee validity till {1}',"b'{0} on maksullinen voimassa, kunnes {1}'"
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54',b'Tree Type',b'tyyppipuu'
b'DocType: BOM Explosion Item',b'Qty Consumed Per Unit',b'K\xc3\xa4ytetty yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 / yksikk\xc3\xb6'
b'DocType: GST Account',b'IGST Account',b'IGST-tili'
b'DocType: Serial No',b'Warranty Expiry Date',b'Takuun umpeutumisp\xc3\xa4iv\xc3\xa4'
b'DocType: Material Request Item',b'Quantity and Warehouse',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 ja Warehouse'
b'DocType: Hub Settings',b'Unregister',b'Poista rekister\xc3\xb6inti'
b'DocType: Sales Invoice',b'Commission Rate (%)',b'provisio (%)'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Valitse ohjelma'
b'DocType: Project',b'Estimated Cost',b'Kustannusarvio'
b'DocType: Purchase Order',b'Link to material requests',b'Kohdista hankintapyynt\xc3\xb6\xc3\xb6n'
b'DocType: Hub Settings',b'Publish',b'Julkaista'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7',b'Aerospace',b'ilmakeh\xc3\xa4'
,b'Fichier des Ecritures Comptables [FEC]',b'Fichier des Ecritures Comptables [FEC]'
b'DocType: Journal Entry',b'Credit Card Entry',b'luottokorttikirjaus'
b'apps/erpnext/erpnext/config/accounts.py +57',b'Company and Accounts',b'Yritys ja tilit'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70',b'In Value',b'in Arvo'
b'DocType: Asset Settings',b'Depreciation Options',b'Poistot'
b'apps/erpnext/erpnext/utilities/transaction_base.py +35',b'Invalid Posting Time',b'Virheellinen l\xc3\xa4hetysaika'
b'DocType: Lead',b'Campaign Name',b'Kampanjan nimi'
b'DocType: Hotel Room',b'Capacity',b'kapasiteetti'
b'DocType: Selling Settings',b'Close Opportunity After Days',b'Close tilaisuuden p\xc3\xa4iv\xc3\xa4\xc3\xa4'
,b'Reserved',b'Varattu'
b'DocType: Driver',b'License Details',b'Lisenssin tiedot'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85',b'The field From Shareholder cannot be blank',b'Kent\xc3\xa4n omistaja ei voi olla tyhj\xc3\xa4'
b'DocType: Purchase Order',b'Supply Raw Materials',b'toimita raaka-aineita'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10',b'Current Assets',b'lyhytaikaiset vastaavat'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121',b'{0} is not a stock Item',b'{0} ei ole varastonimike'
b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6',"b""Please share your feedback to the training by clicking on 'Training Feedback' and then 'New'""",b'Jaa palautetta koulutukseen klikkaamalla &quot;Harjoittelupalaute&quot; ja sitten &quot;Uusi&quot;'
b'DocType: Mode of Payment Account',b'Default Account',b'oletustili'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +273',b'Please select Sample Retention Warehouse in Stock Settings first',b'Valitse Sample Retention Warehouse varastossa Asetukset ensin'
b'DocType: Payment Entry',b'Received Amount (Company Currency)',b'Vastaanotetut Summa (Company valuutta)'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192',b'Lead must be set if Opportunity is made from Lead',"b'Liidi on pakollinen tieto, jos myyntimahdollisuus on muodostettu liidist\xc3\xa4'"
b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136',b'Payment Cancelled. Please check your GoCardless Account for more details',b'Maksu peruutettiin. Tarkista GoCardless-tilisi tarkempia tietoja'
b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29',b'Please select weekly off day',b'Ole hyv\xc3\xa4 ja valitse viikoittain off p\xc3\xa4iv\xc3\xa4'
b'DocType: Patient',b'O Negative',b'O Negatiivinen'
b'DocType: Work Order Operation',b'Planned End Time',b'Suunniteltu p\xc3\xa4\xc3\xa4ttymisaika'
,b'Sales Person Target Variance Item Group-Wise',"b'Tuoteryhm\xc3\xa4 ty\xc3\xb6kalu, myyj\xc3\xa4 ja vaihtelu tavoite'"
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +93',b'Account with existing transaction cannot be converted to ledger',b'tilin tapahtumaa ei voi muuttaa tilikirjaksi'
b'apps/erpnext/erpnext/config/non_profit.py +33',b'Memebership Type Details',b'J\xc3\xa4senyyden tyyppi Tiedot'
b'DocType: Delivery Note',"b""Customer's Purchase Order No""",b'asiakkaan ostotilaus numero'
b'DocType: Budget',b'Budget Against',b'Budget Against'
b'DocType: Employee',b'Cell Number',b'solunumero'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450',"b""There's no employee for the given criteria. Check that Salary Slips have not already been created.""","b'Ei ole ty\xc3\xb6ntekij\xc3\xa4\xc3\xa4 annettuihin kriteereihin. Tarkista, ett\xc3\xa4 palkkapeltoja ei ole viel\xc3\xa4 luotu.'"
b'apps/erpnext/erpnext/stock/reorder_item.py +194',b'Auto Material Requests Generated',b'Automaattinen hankintapyynt\xc3\xb6 luotu'
b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7',b'Lost',b'H\xc3\xa4vitty'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152',"b""You can not enter current voucher in 'Against Journal Entry' column""","b""kyseist\xc3\xa4 tositetta ei voi kohdistaa 'p\xc3\xa4iv\xc3\xa4kirjakirjaus' sarakkeessa"""
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50',b'Reserved for manufacturing',b'Varattu valmistus'
b'DocType: Soil Texture',b'Sand',b'Hiekka'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25',b'Energy',b'energia'
b'DocType: Opportunity',b'Opportunity From',b'tilaisuuteen'
b'apps/erpnext/erpnext/config/hr.py +98',b'Monthly salary statement.',b'kuukausipalkka tosite'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887',b'Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.',b'Rivi {0}: {1} Sarjanumerot kohdasta {2}. Olet antanut {3}.'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79',b'Please select a table',b'Valitse taulukko'
b'DocType: BOM',b'Website Specifications',b'Verkkosivuston tiedot'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78',"b""{0} is an invalid email address in 'Recipients'""","b""'Vastaanottajat' luettelossa on virheellinen s\xc3\xa4hk\xc3\xb6postiosoite {0}"""
b'DocType: Special Test Items',b'Particulars',b'tarkemmat tiedot'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24',b'{0}: From {0} of type {1}',b'{0}: valitse {0} tyypist\xc3\xa4 {1}'
b'DocType: Warranty Claim',b'CI-',b'Cl'
b'apps/erpnext/erpnext/controllers/buying_controller.py +300',b'Row {0}: Conversion Factor is mandatory',b'Rivi {0}: Conversion Factor on pakollista'
b'DocType: Student',b'A+',b'A +'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344',"b'Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}'","b'Useita Hinta S\xc3\xa4\xc3\xa4nn\xc3\xb6t ovat olemassa samoja kriteereit\xc3\xa4, ota ratkaista konflikti antamalla prioriteetti. Hinta S\xc3\xa4\xc3\xa4nn\xc3\xb6t: {0}'"
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519',b'Cannot deactivate or cancel BOM as it is linked with other BOMs',b'BOM:ia ei voi poistaa tai peruuttaa sill\xc3\xa4 muita BOM:ja on linkitettyn\xc3\xa4 siihen'
b'DocType: Asset',b'Maintenance',b'huolto'
b'DocType: Item Attribute Value',b'Item Attribute Value',"b'tuotetuntomerkki, arvo'"
b'apps/erpnext/erpnext/projects/doctype/project/project.py +406',b'Please Update your Project Status',b'P\xc3\xa4ivit\xc3\xa4 projektin tila'
b'DocType: Item',b'Maximum sample quantity that can be retained',"b'Suurin n\xc3\xa4ytteen m\xc3\xa4\xc3\xa4r\xc3\xa4, joka voidaan s\xc3\xa4ilytt\xc3\xa4\xc3\xa4'"
b'DocType: Project Update',b'How is the Project Progressing Right Now?',b'Kuinka projekti etenee nyt?'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418',b'Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3}',b'Rivi {0} # Tuote {1} ei voi siirt\xc3\xa4\xc3\xa4 enemp\xc3\xa4\xc3\xa4 kuin {2} ostotilausta vastaan {3}'
b'apps/erpnext/erpnext/config/selling.py +158',b'Sales campaigns.',b'Myynnin kampanjat'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117',b'Make Timesheet',b'Luo tuntilomake'
b'DocType: Sales Taxes and Charges Template',"b'Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.'","b'perusveromallipohja, jota voidaan k\xc3\xa4ytt\xc3\xa4\xc3\xa4 kaikkiin myyntitapahtumiin. t\xc3\xa4m\xc3\xa4 mallipohja voi sis\xc3\xa4lt\xc3\xa4\xc3\xa4 listan perusveroista ja my\xc3\xb6s muita veroja, kuten ""toimitus"", ""vakuutus"", ""k\xc3\xa4sittely"" jne #### huomaa ett\xc3\xa4 t\xc3\xa4nne m\xc3\xa4\xc3\xa4ritelty veroprosentti tulee olemaan oletus kaikille **tuotteille**, mik\xc3\xa4li **tuotteella** on eri veroprosentti tulee se m\xc3\xa4\xc3\xa4ritell\xc3\xa4 **tuotteen vero** taulukossa **tuote** ty\xc3\xb6kalussa. #### sarakkeiden kuvaus 1. laskennan tyyppi: - t\xc3\xa4m\xc3\xa4 voi olla **netto yhteens\xc3\xa4** (eli summa perusarvosta). - **edellisen rivin summa / arvom\xc3\xa4\xc3\xa4r\xc3\xa4 ** (kumulatiivisille veroille tai maksuille, mik\xc3\xa4li t\xc3\xa4m\xc3\xa4n on valittu edellisen rivin vero lasketaan prosentuaalisesti (verotaulukon) mukaan m\xc3\xa4\xc3\xa4r\xc3\xa4st\xc3\xa4 tai summasta 2. tilin otsikko: tilin tilikirja, johon verot varataan 3. kustannuspaikka: mik\xc3\xa4li vero / maksu on tuloa (kuten toimitus) tai kulua tulee se varata kustannuspaikkaa vastaan 4. kuvaus: veron kuvaus (joka tulostetaan laskulla / tositteella) 5. taso: veroprosentti. 6. arvom\xc3\xa4\xc3\xa4r\xc3\xa4: veron m\xc3\xa4\xc3\xa4r\xc3\xa4 7. yhteens\xc3\xa4: kumulatiivinen yhteissumma t\xc3\xa4h\xc3\xa4n asti. 8. sy\xc3\xb6t\xc3\xa4 rivi: mik\xc3\xa4li k\xc3\xa4ytet\xc3\xa4\xc3\xa4n rivi\xc3\xa4 ""edellinen rivi yhteens\xc3\xa4"", voit valita rivin numeron, jota k\xc3\xa4ytet\xc3\xa4\xc3\xa4n laskelman pohjana 9. onko t\xc3\xa4m\xc3\xa4 vero perustasoa: mik\xc3\xa4li t\xc3\xa4pp\xc3\xa4\xc3\xa4t t\xc3\xa4m\xc3\xa4n verovalintaa ei n\xc3\xa4y alhaalla tuotevalikossa, mutta liitet\xc3\xa4\xc3\xa4n perusverotuotteisiin tuotteen p\xc3\xa4\xc3\xa4sivulla, t\xc3\xa4m\xc3\xa4 helpottaa k\xc3\xb6nttisumman antoa asiakkaalle (sis\xc3\xa4lt\xc3\xa4en kaikki verot)'"
b'DocType: Employee',b'Bank A/C No.',b'Tilinumero'
b'DocType: Bank Guarantee',b'Project',b'Projekti'
b'DocType: Quality Inspection Reading',b'Reading 7',b'Lukema 7'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9',b'Partially Ordered',b'osittain Tilattu'
b'DocType: Lab Test',b'Lab Test',b'Lab Test'
b'DocType: Student Report Generation Tool',b'Student Report Generation Tool',b'Opiskelijaraportin generointity\xc3\xb6kalu'
b'DocType: Expense Claim Detail',b'Expense Claim Type',b'Kulukorvaustyyppi'
b'DocType: Shopping Cart Settings',b'Default settings for Shopping Cart',b'Ostoskorin oletusasetukset'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27',b'Add Timeslots',b'Lis\xc3\xa4\xc3\xa4 Timeslots'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138',b'Asset scrapped via Journal Entry {0}',b'Asset romutetaan kautta P\xc3\xa4iv\xc3\xa4kirjakirjaus {0}'
b'DocType: Employee Loan',b'Interest Income Account',b'Korkotuotot Account'
b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58',b'Review Invitation Sent',b'Tarkista kutsu l\xc3\xa4hetetty'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13',b'Biotechnology',b'Biotekniikka'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109',b'Office Maintenance Expenses',b'Toimitilan huollon kustannukset'
b'apps/erpnext/erpnext/utilities/user_progress.py +54',b'Go to ',b'Mene'
b'apps/erpnext/erpnext/config/learn.py +47',b'Setting up Email Account',b'M\xc3\xa4\xc3\xa4ritt\xc3\xa4minen S\xc3\xa4hk\xc3\xb6postitilin'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21',b'Please enter Item first',b'Anna Kohta ensin'
b'DocType: Asset Repair',b'Downtime',b'seisokkeja'
b'DocType: Account',b'Liability',b'vastattavat'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220',b'Sanctioned Amount cannot be greater than Claim Amount in Row {0}.',b'Hyv\xc3\xa4ksytt\xc3\xa4v\xc3\xa4n m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla suurempi kuin korvauksen m\xc3\xa4\xc3\xa4r\xc3\xa4 rivill\xc3\xa4 {0}.'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11',b'Academic Term: ',b'Akateeminen termi:'
b'DocType: Salary Detail',b'Do not include in total',b'\xc3\x84l\xc3\xa4 sis\xc3\xa4llyt\xc3\xa4 kokonaan'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206',b'Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series',b'Aseta Naming-sarja {0} asetukseksi Setup&gt; Settings&gt; Naming Series'
b'DocType: Company',b'Default Cost of Goods Sold Account',b'oletus myytyjen tuotteiden arvo tili'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1019',b'Sample quantity {0} cannot be more than received quantity {1}',b'N\xc3\xa4ytteen m\xc3\xa4\xc3\xa4r\xc3\xa4 {0} ei voi olla suurempi kuin vastaanotettu m\xc3\xa4\xc3\xa4r\xc3\xa4 {1}'
b'apps/erpnext/erpnext/stock/get_item_details.py +369',b'Price List not selected',b'Hinnasto ei valittu'
b'DocType: Employee',b'Family Background',b'Perhetausta'
b'DocType: Request for Quotation Supplier',b'Send Email',b'L\xc3\xa4het\xc3\xa4 s\xc3\xa4hk\xc3\xb6posti'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +228',b'Warning: Invalid Attachment {0}',b'Varoitus: Virheellinen liite {0}'
b'DocType: Item',b'Max Sample Quantity',b'Max n\xc3\xa4ytteen m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766',b'No Permission',b'Ei oikeuksia'
b'DocType: Vital Signs',b'Heart Rate / Pulse',b'Syke / pulssi'
b'DocType: Company',b'Default Bank Account',b'oletus pankkitili'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59',"b'To filter based on Party, select Party Type first'",b'Valitse osapuoli tyyppi saadaksesi osapuolen mukaisen suodatuksen'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48',"b""'Update Stock' can not be checked because items are not delivered via {0}""","b""'P\xc3\xa4ivit\xc3\xa4 varasto' ei voida k\xc3\xa4ytt\xc3\xa4\xc3\xa4 tuotteille, joita ei ole toimitettu {0} kautta"""
b'DocType: Vehicle',b'Acquisition Date',b'Hankintap\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Nos',b'Nos'
b'DocType: Item',b'Items with higher weightage will be shown higher',b'tuotteet joilla on korkeampi painoarvo n\xc3\xa4tet\xc3\xa4\xc3\xa4n ylemp\xc3\xa4n\xc3\xa4'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14',b'Lab Tests and Vital Signs',b'Lab testit ja elinvoimaiset merkit'
b'DocType: Bank Reconciliation Detail',b'Bank Reconciliation Detail',b'pankin t\xc3\xa4sm\xc3\xa4ytys lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +614',b'Row #{0}: Asset {1} must be submitted',b'Rivi # {0}: Asset {1} on esitett\xc3\xa4v\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40',b'No employee found',b'Yht\xc3\xa4\xc3\xa4n ty\xc3\xb6ntekij\xc3\xa4\xc3\xa4 ei l\xc3\xb6ytynyt'
b'DocType: Subscription',b'Stopped',b'pys\xc3\xa4ytetty'
b'DocType: Item',b'If subcontracted to a vendor',b'alihankinta toimittajalle'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Opiskelijaryhm\xc3\xa4n on jo p\xc3\xa4ivitetty.'
b'apps/erpnext/erpnext/config/projects.py +18',b'Project Update.',b'Projektin p\xc3\xa4ivitys.'
b'DocType: SMS Center',b'All Customer Contact',b'kaikki asiakkaan yhteystiedot'
b'DocType: Land Unit',b'Tree Details',b'Tree Tietoja'
b'DocType: Training Event',b'Event Status',b'Tapahtuman tila'
b'DocType: Volunteer',b'Availability Timeslot',b'Saatavuus Timeslot'
,b'Support Analytics',b'Asiakastuen analytiikka'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365',"b'If you have any questions, please get back to us.'","b'Jos sinulla on kysytt\xc3\xa4v\xc3\xa4\xc3\xa4, ota takaisin meille.'"
b'DocType: Cash Flow Mapper',b'Cash Flow Mapper',b'Cash Flow Mapper'
b'DocType: Item',b'Website Warehouse',b'Varasto'
b'DocType: Payment Reconciliation',b'Minimum Invoice Amount',b'Pienin Laskun summa'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111',b'{0} {1}: Cost Center {2} does not belong to Company {3}',b'{0} {1}: Kustannuspaikka {2} ei kuulu yhti\xc3\xb6lle {3}'
b'apps/erpnext/erpnext/utilities/user_progress.py +92',b'Upload your letter head (Keep it web friendly as 900px by 100px)',b'L\xc3\xa4het\xc3\xa4 kirjeesi p\xc3\xa4\xc3\xa4n (Pid\xc3\xa4 se web friendly kuin 900px 100px)'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88',b'{0} {1}: Account {2} cannot be a Group',b'{0} {1}: Tili {2} ei voi olla ryhm\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63',"b""Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table""",b'Kohta Rivi {idx}: {DOCTYPE} {DOCNAME} ei ole olemassa edell\xc3\xa4 {DOCTYPE} table'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295',b'Timesheet {0} is already completed or cancelled',b'Tuntilomake {0} on jo t\xc3\xa4ytetty tai peruttu'
b'apps/erpnext/erpnext/templates/pages/projects.html +42',b'No tasks',b'ei teht\xc3\xa4vi\xc3\xa4'
b'DocType: Item Variant Settings',b'Copy Fields to Variant',b'Kopioi kent\xc3\xa4t versioksi'
b'DocType: Asset',b'Opening Accumulated Depreciation',b'Avaaminen Kertyneet poistot'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49',b'Score must be less than or equal to 5',b'Pisteet on oltava pienempi tai yht\xc3\xa4 suuri kuin 5'
b'DocType: Program Enrollment Tool',b'Program Enrollment Tool',b'Ohjelma Ilmoittautuminen Tool'
b'apps/erpnext/erpnext/config/accounts.py +335',b'C-Form records',b'C-muoto tietue'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73',b'The shares already exist',b'Osakkeet ovat jo olemassa'
b'apps/erpnext/erpnext/config/selling.py +316',b'Customer and Supplier',b'Asiakas ja toimittaja'
b'DocType: Email Digest',b'Email Digest Settings',b's\xc3\xa4hk\xc3\xb6postitiedotteen asetukset'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367',b'Thank you for your business!',b'Kiitos liiketoimintaa!'
b'apps/erpnext/erpnext/config/support.py +12',b'Support queries from customers.',b'Asiakkaan tukikyselyt'
b'DocType: Setup Progress Action',b'Action Doctype',b'Toiminto Doctype'
b'DocType: HR Settings',b'Retirement Age',b'El\xc3\xa4keik\xc3\xa4'
b'DocType: Bin',b'Moving Average Rate',b'liukuva keskiarvo taso'
b'DocType: Production Plan',b'Select Items',b'Valitse tuotteet'
b'DocType: Share Transfer',b'To Shareholder',b'Osakkeenomistajalle'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372',b'{0} against Bill {1} dated {2}',b'{0} kuittia vastaan {1} p\xc3\xa4iv\xc3\xa4tty {2}'
b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Institution',b'Asennusinstituutti'
b'DocType: Program Enrollment',b'Vehicle/Bus Number',b'Ajoneuvo / bussi numero'
b'apps/erpnext/erpnext/education/doctype/course/course.js +17',b'Course Schedule',b'kurssin aikataulu'
b'DocType: Request for Quotation Supplier',b'Quote Status',b'Lainaus Status'
b'DocType: GoCardless Settings',b'Webhooks Secret',b'Webhooks Secret'
b'DocType: Maintenance Visit',b'Completion Status',b'katselmus tila'
b'DocType: Daily Work Summary Group',b'Select Users',b'Valitse k\xc3\xa4ytt\xc3\xa4j\xc3\xa4t'
b'DocType: Hotel Room Pricing Item',b'Hotel Room Pricing Item',b'Hotellihuoneen hinnoittelu'
b'DocType: HR Settings',b'Enter retirement age in years',b'Anna el\xc3\xa4keik\xc3\xa4 vuosina'
b'DocType: Crop',b'Target Warehouse',b'Varastoon'
b'DocType: Payroll Employee Detail',b'Payroll Employee Detail',b'Palkkahallinnon ty\xc3\xb6ntekij\xc3\xa4n tiedot'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128',b'Please select a warehouse',b'Valitse varasto'
b'DocType: Cheque Print Template',b'Starting location from left edge',b'Alkaen sijainti vasemmasta reunasta'
b'DocType: Item',b'Allow over delivery or receipt upto this percent',b'Salli yli toimitus- tai kuitti l\xc3\xa4hetett\xc3\xa4v\xc3\xa4\xc3\xa4n t\xc3\xa4h\xc3\xa4n prosenttia'
b'DocType: Stock Entry',b'STE-',b'Stefan'
b'DocType: Upload Attendance',b'Import Attendance',b'tuo osallistuminen'
b'apps/erpnext/erpnext/public/js/pos/pos.html +124',b'All Item Groups',b'Kaikki nimikeryhm\xc3\xa4t'
b'apps/erpnext/erpnext/config/setup.py +89',b'Automatically compose message on submission of transactions.',b'muodosta automaattinen viesti toiminnon l\xc3\xa4hetyksess\xc3\xa4'
b'DocType: Work Order',b'Item To Manufacture',b'tuote valmistukseen'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteLib',b'CompteLib'
b'apps/erpnext/erpnext/buying/utils.py +80',b'{0} {1} status is {2}',b'{0} {1} tila on {2}'
b'DocType: Water Analysis',b'Collection Temperature ',b'Ker\xc3\xa4ysl\xc3\xa4mp\xc3\xb6tila'
b'DocType: Employee',b'Provide Email Address registered in company',b'Antaa S\xc3\xa4hk\xc3\xb6postiosoite rekister\xc3\xb6ity yhti\xc3\xb6n'
b'DocType: Shopping Cart Settings',b'Enable Checkout',b'Ota Checkout'
b'apps/erpnext/erpnext/config/learn.py +202',b'Purchase Order to Payment',b'Ostotilauksesta maksuun'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48',b'Projected Qty',b'Ennustettu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Sales Invoice',b'Payment Due Date',b'Maksun er\xc3\xa4p\xc3\xa4iv\xc3\xa4'
b'DocType: Drug Prescription',b'Interval UOM',b'Interval UOM'
b'DocType: Customer',"b'Reselect, if the chosen address is edited after save'","b'Vahvista valinta uudelleen, jos valittua osoitetta muokataan tallennuksen j\xc3\xa4lkeen'"
b'apps/erpnext/erpnext/stock/doctype/item/item.js +522',b'Item Variant {0} already exists with same attributes',b'Tuote Variant {0} on jo olemassa samoja ominaisuuksia'
b'DocType: Item',b'Hub Publishing Details',b'Hub-julkaisutiedot'
b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117',"b""'Opening'""","b""'Avattu'"""
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130',b'Open To Do',b'Avaa teht\xc3\xa4v\xc3\xa4'
b'DocType: Notification Control',b'Delivery Note Message',b'l\xc3\xa4hetteen vieti'
b'DocType: Lab Test Template',b'Result Format',b'Tulosmuoto'
b'DocType: Expense Claim',b'Expenses',b'Kustannukset'
b'DocType: Item Variant Attribute',b'Item Variant Attribute',b'Tuote Variant Taito'
,b'Purchase Receipt Trends',b'Saapumisten kehitys'
b'DocType: Payroll Entry',b'Bimonthly',b'Kahdesti kuussa'
b'DocType: Vehicle Service',b'Brake Pad',b'Jarrupala'
b'DocType: Fertilizer',b'Fertilizer Contents',b'Lannoitteen sis\xc3\xa4lt\xc3\xb6'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119',b'Research & Development',b'Tutkimus ja kehitys'
b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20',b'Amount to Bill',b'Laskutettava'
b'DocType: Company',b'Registration Details',b'rekister\xc3\xb6innin lis\xc3\xa4tiedot'
b'DocType: Timesheet',b'Total Billed Amount',b'Laskutettu yhteens\xc3\xa4'
b'DocType: Item Reorder',b'Re-Order Qty',b'T\xc3\xa4ydennystilauksen yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Leave Block List Date',b'Leave Block List Date',b'p\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94',b'BOM #{0}: Raw material cannot be same as main Item',b'BOM # {0}: Raaka-aine ei voi olla sama kuin p\xc3\xa4\xc3\xa4osa'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92',b'Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges',b'Saapumistositteen riveill\xc3\xa4 olevat maksut pit\xc3\xa4\xc3\xa4 olla sama kuin verot ja maksut osiossa'
b'DocType: Sales Team',b'Incentives',b'kannustimet/bonukset'
b'DocType: SMS Log',b'Requested Numbers',b'vaaditut numerot'
b'DocType: Volunteer',b'Evening',b'Ilta'
b'DocType: Customer',b'Bypass credit limit check at Sales Order',b'Ohita luottorajan tarkistus myyntitilauksessa'
b'apps/erpnext/erpnext/config/hr.py +147',b'Performance appraisal.',b'Arviointikertomusta.'
b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100',"b""Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart""","b'""K\xc3\xa4yt\xc3\xa4 ostoskorille"" otettu k\xc3\xa4ytt\xc3\xb6\xc3\xb6n: Ostoskoritoiminto on k\xc3\xa4yt\xc3\xb6ss\xc3\xa4 ja ostoskorille tulisi olla ainakin yksi m\xc3\xa4\xc3\xa4ritelty veroasetus.'"
b'apps/erpnext/erpnext/controllers/accounts_controller.py +412',"b'Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.'","b'Maksu Entry {0} on liitetty vastaan Order {1}, tarkistaa, jos se tulee vet\xc3\xa4\xc3\xa4 kuin etuk\xc3\xa4teen t\xc3\xa4ss\xc3\xa4 laskussa.'"
b'DocType: Sales Invoice Item',b'Stock Details',b'Varastossa Tiedot'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29',b'Project Value',b'Projekti Arvo'
b'apps/erpnext/erpnext/config/selling.py +326',b'Point-of-Sale',b'Point-of-Sale'
b'DocType: Fee Schedule',b'Fee Creation Status',b'Maksunluonti tila'
b'DocType: Vehicle Log',b'Odometer Reading',b'matkamittarin lukema'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +116',"b""Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'""","b""Tilin tase on jo kredit, sy\xc3\xb6tetyn arvon tulee olla 'tasapainossa' eli 'debet'"""
b'DocType: Account',b'Balance must be',b'taseen on oltava'
b'DocType: Hub Settings',b'Publish Pricing',b'Julkaise Hinnoittelu'
b'DocType: Notification Control',b'Expense Claim Rejected Message',b'Viesti kulukorvauksen hylk\xc3\xa4\xc3\xa4misest\xc3\xa4'
,b'Available Qty',b'saatava yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Purchase Taxes and Charges',b'On Previous Row Total',b'Edellinen rivi yhteens\xc3\xa4'
b'DocType: Purchase Invoice Item',b'Rejected Qty',b'hyl\xc3\xa4tty M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Setup Progress Action',b'Action Field',b'Toiminta-alue'
b'DocType: Healthcare Settings',b'Manage Customer',b'Hallitse asiakasta'
b'DocType: Delivery Trip',b'Delivery Stops',b'Toimitus pys\xc3\xa4htyy'
b'DocType: Salary Slip',b'Working Days',b'Ty\xc3\xb6p\xc3\xa4iv\xc3\xa4t'
b'DocType: Serial No',b'Incoming Rate',b'saapuva taso'
b'DocType: Packing Slip',b'Gross Weight',b'bruttopaino'
,b'Final Assessment Grades',b'Loppuraportin arvosanat'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47',b'Enable Hub',b'Ota Hub k\xc3\xa4ytt\xc3\xb6\xc3\xb6n'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +110',b'The name of your company for which you are setting up this system.',"b'Yrityksen nimi, jolle olet luomassa t\xc3\xa4t\xc3\xa4 j\xc3\xa4rjestelm\xc3\xa4\xc3\xa4'"
b'DocType: HR Settings',b'Include holidays in Total no. of Working Days',"b'sis\xc3\xa4lt\xc3\xa4\xc3\xa4 vapaap\xc3\xa4ivi\xc3\xa4, ty\xc3\xb6p\xc3\xa4ivi\xc3\xa4 yhteens\xc3\xa4'"
b'apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108',b'Setup your Institute in ERPNext',b'Asenna instituutti ERP-j\xc3\xa4rjestelm\xc3\xa4\xc3\xa4n'
b'DocType: Agriculture Analysis Criteria',b'Plant Analysis',b'Kasvien analyysi'
b'DocType: Job Applicant',b'Hold',b'pid\xc3\xa4'
b'DocType: Project Update',b'Progress Details',b'Edistyst\xc3\xa4 koskevat tiedot'
b'DocType: Employee',b'Date of Joining',b'liittymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Naming Series',b'Update Series',b'P\xc3\xa4ivit\xc3\xa4 sarjat'
b'DocType: Supplier Quotation',b'Is Subcontracted',b'on alihankittu'
b'DocType: Restaurant Table',b'Minimum Seating',b'Minimi istuma'
b'DocType: Item Attribute',b'Item Attribute Values',"b'tuotetuntomerkki, arvot'"
b'DocType: Examination Result',b'Examination Result',b'tutkimustuloksen'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845',b'Purchase Receipt',b'Saapuminen'
,b'Received Items To Be Billed',b'Saivat kohteet laskuttamat'
b'apps/erpnext/erpnext/config/accounts.py +303',b'Currency exchange rate master.',b'valuuttataso valvonta'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209',b'Reference Doctype must be one of {0}',b'Viitetyypin tulee olla yksi seuraavista: {0}'
b'apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46',b'Filter Total Zero Qty',b'Suodatin yhteens\xc3\xa4 nolla'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341',b'Unable to find Time Slot in the next {0} days for Operation {1}',b'Aika-aukkoa ei l\xc3\xb6ydy seuraavaan {0} p\xc3\xa4iv\xc3\xa4n toiminnolle {1}'
b'DocType: Work Order',b'Plan material for sub-assemblies',b'Suunnittele materiaalit alituotantoon'
b'apps/erpnext/erpnext/config/selling.py +97',b'Sales Partners and Territory',b'Myynnin Partners ja Territory'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +600',b'BOM {0} must be active',b'BOM {0} tulee olla aktiivinen'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414',b'No Items available for transfer',b'Ei siirrett\xc3\xa4viss\xc3\xa4 olevia kohteita'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218',b'Closing (Opening + Total)',b'Sulkeminen (avaaminen + yhteens\xc3\xa4)'
b'DocType: Journal Entry',b'Depreciation Entry',b'Poistot Entry'
b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32',b'Please select the document type first',b'Valitse ensin asiakirjan tyyppi'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65',b'Cancel Material Visits {0} before cancelling this Maintenance Visit',b'Peru materiaalik\xc3\xa4ynti {0} ennen huoltok\xc3\xa4ynnin perumista'
b'DocType: Crop Cycle',b'ISO 8016 standard',b'ISO 8016 -standardi'
b'DocType: Pricing Rule',b'Rate or Discount',b'Hinta tai alennus'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213',b'Serial No {0} does not belong to Item {1}',b'Sarjanumero {0} ei kuulu tuotteelle {1}'
b'DocType: Purchase Receipt Item Supplied',b'Required Qty',b'vaadittu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126',b'Warehouses with existing transaction can not be converted to ledger.',b'Varastoissa nykyisten tapahtumaa ei voida muuntaa kirjanpitoon.'
b'DocType: Bank Reconciliation',b'Total Amount',b'Yhteens\xc3\xa4'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32',b'Internet Publishing',b'internet julkaisu'
b'DocType: Prescription Duration',b'Number',b'M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25',b'Creating {0} Invoice',b'Luo {0} lasku'
b'DocType: Medical Code',b'Medical Code Standard',b'Medical Code Standard'
b'DocType: Soil Texture',b'Clay Composition (%)',b'Savi koostumus (%)'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81',b'Please save before assigning task.',b'Tallenna ennen teht\xc3\xa4v\xc3\xa4n antamista.'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74',b'Balance Value',b'Taseen arvo'
b'DocType: Lab Test',b'Lab Technician',b'Laboratorio teknikko'
b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38',b'Sales Price List',b'Myyntihinnasto'
b'DocType: Healthcare Settings',"b'If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.'","b'Jos valitaan, luodaan asiakas, joka on kartoitettu Potilashenkil\xc3\xb6\xc3\xb6n. Potilaslaskut luodaan t\xc3\xa4t\xc3\xa4 asiakasta vastaan. Voit my\xc3\xb6s valita olemassa olevan asiakkaan potilaan luomisen aikana.'"
b'DocType: Bank Reconciliation',b'Account Currency',b'Tilin valuutta'
b'DocType: Lab Test',b'Sample ID',b'Sample ID'
b'apps/erpnext/erpnext/accounts/general_ledger.py +167',b'Please mention Round Off Account in Company',b'Merkitse yrityksen py\xc3\xb6ristys tili'
b'DocType: Purchase Receipt',b'Range',b'Alue'
b'DocType: Supplier',b'Default Payable Accounts',b'oletus maksettava tilit'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49',b'Employee {0} is not active or does not exist',b'Ty\xc3\xb6ntekij\xc3\xa4 {0} ei ole aktiivinen tai sit\xc3\xa4 ei ole olemassa'
b'DocType: Fee Structure',b'Components',b'komponentit'
b'DocType: Item Barcode',b'Item Barcode',b'tuote viivakoodi'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +329',b'Please enter Asset Category in Item {0}',b'Sy\xc3\xb6t\xc3\xa4 Asset Luokka momentille {0}'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +661',b'Item Variants {0} updated',b'Tuotemallit {0} p\xc3\xa4ivitetty'
b'DocType: Quality Inspection Reading',b'Reading 6',b'Lukema 6'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9',"b'to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field\nof this'","b'luodaan. Jos viiv\xc3\xa4styy, sinun on muutettava manuaalisesti t\xc3\xa4m\xc3\xa4n kent\xc3\xa4n &quot;Toista kuukausi-p\xc3\xa4iv\xc3\xa4&quot; -kentt\xc3\xa4\xc3\xa4n'"
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961',b'Cannot {0} {1} {2} without any negative outstanding invoice',b'Ei voi {0} {1} {2} ilman negatiivista maksamatta laskun'
b'DocType: Share Transfer',b'From Folio No',b'Folio No'
b'DocType: Purchase Invoice Advance',b'Purchase Invoice Advance',"b'Ostolasku, edistynyt'"
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199',b'Row {0}: Credit entry can not be linked with a {1}',b'rivi {0}: kredit kirjausta ei voi kohdistaa {1}'
b'apps/erpnext/erpnext/config/accounts.py +246',b'Define budget for a financial year.',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 budjetti varainhoitovuoden.'
b'DocType: Lead',b'LEAD-',b'VIHJE-'
b'DocType: Employee',b'Permanent Address Is',b'Pysyv\xc3\xa4 osoite on'
b'DocType: Work Order Operation',b'Operation completed for how many finished goods?',b'Kuinka montaa valmista tavaraa toiminnon suorituksen valmistuminen koskee?'
b'DocType: Payment Terms Template',b'Payment Terms Template',b'Maksuehdot Malline'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +51',b'The Brand',b'Br\xc3\xa4ndi'
b'DocType: Employee',b'Exit Interview Details',b'poistu haastattelun lis\xc3\xa4tiedoista'
b'DocType: Item',b'Is Purchase Item',b'on ostotuote'
b'DocType: Journal Entry Account',b'Purchase Invoice',b'Ostolasku'
b'DocType: Stock Ledger Entry',b'Voucher Detail No',b'Tosite lis\xc3\xa4tiedot nro'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +789',b'New Sales Invoice',b'Uusi myyntilasku'
b'DocType: Stock Entry',b'Total Outgoing Value',"b'kokonaisarvo, l\xc3\xa4htev\xc3\xa4'"
b'DocType: Physician',b'Appointments',b'nimitykset'
b'apps/erpnext/erpnext/public/js/account_tree_grid.js +223',b'Opening Date and Closing Date should be within same Fiscal Year',b'Aukiolop\xc3\xa4iv\xc3\xa4 ja P\xc3\xa4\xc3\xa4ttymisaika olisi oltava sama Tilikausi'
b'DocType: Lead',b'Request for Information',b'tietopyynt\xc3\xb6'
,b'LeaderBoard',b'leaderboard'
b'DocType: Sales Invoice Item',b'Rate With Margin (Company Currency)',b'Hinta marginaalilla (Company Currency)'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +802',b'Sync Offline Invoices',b'Synkronointi Offline Laskut'
b'DocType: Payment Request',b'Paid',b'Maksettu'
b'DocType: Program Fee',b'Program Fee',b'Program Fee'
b'DocType: BOM Update Tool',"b'Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.'","b'Vaihda tietty BOM kaikkiin muihin BOM-laitteisiin, joissa sit\xc3\xa4 k\xc3\xa4ytet\xc3\xa4\xc3\xa4n. Se korvaa vanhan BOM-linkin, p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 kustannukset ja regeneroi &quot;BOM Explosion Item&quot; -taulukon uuden BOM: n mukaisesti. Se my\xc3\xb6s p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 viimeisimm\xc3\xa4n hinnan kaikkiin ostomakeihin.'"
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447',b'The following Work Orders were created:',b'Seuraavat ty\xc3\xb6j\xc3\xa4rjestykset luotiin:'
b'DocType: Salary Slip',b'Total in words',b'Sanat yhteens\xc3\xa4'
b'DocType: Material Request Item',b'Lead Time Date',b'L\xc3\xa4pimenoaika'
,b'Employee Advance Summary',b'Ty\xc3\xb6ntekij\xc3\xa4n ennakkomaksu'
b'DocType: Asset',b'Available-for-use Date',b'K\xc3\xa4ytett\xc3\xa4viss\xc3\xa4 oleva p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Guardian',b'Guardian Name',b'Guardian Name'
b'DocType: Cheque Print Template',b'Has Print Format',b'On Print Format'
b'DocType: Employee Loan',b'Sanctioned',b'seuraamuksia'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +75',b' is mandatory. Maybe Currency Exchange record is not created for ',b'on pakollinen. Valuutanvaihtotietue on mahdollisesti luomatta'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139',b'Row #{0}: Please specify Serial No for Item {1}',b'Rivi # {0}: Ilmoittakaa Sarjanumero alamomentin {1}'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54',b'Supplier &gt; Supplier Type',b'Toimittaja&gt; Toimittajan tyyppi'
b'DocType: Crop Cycle',b'Crop Cycle',b'Crop Cycle'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633',"b""For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.""","b'Tuotepaketti nimikkeill\xc3\xa4 varasto, sarjanumero ja er\xc3\xa4numero haetaan samasta l\xc3\xa4hetetaulukosta. Mik\xc3\xa4li varasto ja er\xc3\xa4numero on sama kaikille l\xc3\xa4hetenimikkeille tai tuotepaketin nimikkeille (arvoja voidaan yll\xc3\xa4pit\xc3\xa4\xc3\xa4 nimikkeen p\xc3\xa4\xc3\xa4taulukossa), arvot kopioidaan l\xc3\xa4hetetaulukkoon.'"
b'DocType: Student Admission',b'Publish on website',b'Julkaise verkkosivusto'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651',b'Supplier Invoice Date cannot be greater than Posting Date',b'Toimittaja laskun p\xc3\xa4iv\xc3\xa4ys ei voi olla suurempi kuin julkaisup\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Purchase Invoice Item',b'Purchase Order Item',b'Ostotilaus Kohde'
b'DocType: Agriculture Task',b'Agriculture Task',b'Maatalous Teht\xc3\xa4v\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132',b'Indirect Income',b'v\xc3\xa4lilliset tulot'
b'DocType: Student Attendance Tool',b'Student Attendance Tool',b'Student L\xc3\xa4sn\xc3\xa4olo Tool'
b'DocType: Restaurant Menu',b'Price List (Auto created)',b'Hinnasto (luotu automaattisesti)'
b'DocType: Cheque Print Template',b'Date Settings',b'date Settings'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48',b'Variance',b'Vaihtelu'
,b'Company Name',b'Yrityksen nimi'
b'DocType: SMS Center',b'Total Message(s)',b'viestit yhteens\xc3\xa4'
b'DocType: Share Balance',b'Purchased',b'Osti'
b'DocType: Item Variant Settings',b'Rename Attribute Value in Item Attribute.',b'Nime\xc3\xa4 attribuutin arvo uudestaan nimikkeen ominaisuutena.'
b'DocType: Purchase Invoice',b'Additional Discount Percentage',b'Lis\xc3\xa4alennusprosentti'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24',b'View a list of all the help videos',b'Katso luettelo kaikista ohjevideot'
b'DocType: Agriculture Analysis Criteria',b'Soil Texture',b'Maaper\xc3\xa4n rakenne'
b'DocType: Bank Reconciliation',b'Select account head of the bank where cheque was deposited.',"b'Valitse pankin tilin otsikko, minne shekki/takaus talletetaan'"
b'DocType: Selling Settings',b'Allow user to edit Price List Rate in transactions',b'salli k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n muokata hinnaston tasoa tapahtumissa'
b'DocType: Pricing Rule',b'Max Qty',b'max yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25',b'Print Report Card',b'Tulosta raporttikortti'
b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30',"b'Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \\\n\t\t\t\t\t\tPlease enter a valid Invoice'","b'Rivi {0}: Laskun {1} on virheellinen, se voidaan peruuttaa / ei ole olemassa. \\ Anna kelvollinen Lasku'"
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132',b'Row {0}: Payment against Sales/Purchase Order should always be marked as advance',b'rivi {0}: maksu kohdistettuna myynti- / ostotilaukseen tulee aina merkit\xc3\xa4 ennakkomaksuksi'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16',b'Chemical',b'kemiallinen'
b'DocType: Salary Component Account',b'Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.',b'Oletus Bank / rahatililleen automaattisesti p\xc3\xa4ivitet\xc3\xa4\xc3\xa4n Palkka P\xc3\xa4iv\xc3\xa4kirjakirjaus kun t\xc3\xa4m\xc3\xa4 tila on valittuna.'
b'DocType: BOM',b'Raw Material Cost(Company Currency)',b'Raaka-ainekustannukset (Company valuutta)'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Rivi # {0}: Luokitus ei voi olla suurempi kuin m\xc3\xa4\xc3\xa4r\xc3\xa4 k\xc3\xa4ytt\xc3\xa4\xc3\xa4 {1} {2}'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Meter',b'metri'
b'DocType: Workstation',b'Electricity Cost',b's\xc3\xa4hk\xc3\xb6n kustannukset'
b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23',b'Lab testing datetime cannot be before collection datetime',b'Lab-testaus datetime ei voi olla ennen ker\xc3\xa4ys datetime'
b'DocType: HR Settings',"b""Don't send Employee Birthday Reminders""",b'\xc3\xa4l\xc3\xa4 l\xc3\xa4het\xc3\xa4 ty\xc3\xb6ntekij\xc3\xa4lle syntym\xc3\xa4p\xc3\xa4iv\xc3\xa4muistutuksia'
b'DocType: Expense Claim',b'Total Advance Amount',b'Ennakkomaksu yhteens\xc3\xa4'
b'DocType: Delivery Stop',b'Estimated Arrival',b'arvioitu saapumisaika'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34',b'Save Settings',b'Tallenna asetukset'
b'DocType: Delivery Stop',b'Notified by Email',b'Ilmoitettu s\xc3\xa4hk\xc3\xb6postitse'
b'DocType: Item',b'Inspection Criteria',b'tarkastuskriteerit'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14',b'Transfered',b'siirretty'
b'DocType: BOM Website Item',b'BOM Website Item',b'BOM-sivuston Kohta'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +52',b'Upload your letter head and logo. (you can edit them later).',b'Tuo kirjeen yl\xc3\xa4tunniste ja logo. (voit muokata niit\xc3\xa4 my\xc3\xb6hemmin)'
b'DocType: Timesheet Detail',b'Bill',b'Laskuttaa'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +88',b'Next Depreciation Date is entered as past date',b'Seuraavaksi Poistot Date kirjataan ohi p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208',b'White',b'Valkoinen'
b'DocType: SMS Center',b'All Lead (Open)',b'Kaikki Liidit (Avoimet)'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270',b'Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3})',b'Rivi {0}: M\xc3\xa4\xc3\xa4r\xc3\xa4 ei saatavilla {4} varasto {1} klo l\xc3\xa4hett\xc3\xa4mist\xc3\xa4 tullessa ({2} {3})'
b'apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18',b'You can only select a maximum of one option from the list of check boxes.',b'Voit valita enint\xc3\xa4\xc3\xa4n yhden vaihtoehdon valintaruutujen luettelosta.'
b'DocType: Purchase Invoice',b'Get Advances Paid',b'hae maksetut ennakot'
b'DocType: Item',b'Automatically Create New Batch',b'Automaattisesti Luo uusi er\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635',b'Assigning {0} to {1} (row {2})',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 {0} arvoon {1} (rivi {2})'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Make ',b'Tehd\xc3\xa4'
b'DocType: Student Admission',b'Admission Start Date',b'P\xc3\xa4\xc3\xa4symaksu aloitusp\xc3\xa4iv\xc3\xa4'
b'DocType: Journal Entry',b'Total Amount in Words',b'Yhteens\xc3\xa4 sanoina'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29',b'New Employee',b'Uusi ty\xc3\xb6ntekij\xc3\xa4'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7',"b""There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.""","b'Tapahtui virhe: todenn\xc3\xa4k\xc3\xb6inen syy on ettet ole tallentanut lomaketta. Mik\xc3\xa4li ongelma toistuu, ota yhteytt\xc3\xa4 j\xc3\xa4rjestelm\xc3\xa4n yll\xc3\xa4pit\xc3\xa4jiin.'"
b'apps/erpnext/erpnext/templates/pages/cart.html +5',b'My Cart',b'Ostoskori'
b'apps/erpnext/erpnext/controllers/selling_controller.py +130',b'Order Type must be one of {0}',"b""Tilaustyypin pit\xc3\xa4\xc3\xa4 olla jokin seuraavista '{0}'"""
b'DocType: Lead',b'Next Contact Date',b'seuraava yhteydenottopv\xc3\xa4'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36',b'Opening Qty',b'Avaus yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Healthcare Settings',b'Appointment Reminder',b'Nimitysohje'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478',b'Please enter Account for Change Amount',b'Anna Account for Change Summa'
b'DocType: Program Enrollment Tool Student',b'Student Batch Name',b'Opiskelijan Er\xc3\xa4 Name'
b'DocType: Consultation',b'Doctor',b'L\xc3\xa4\xc3\xa4k\xc3\xa4ri'
b'DocType: Holiday List',b'Holiday List Name',b'lomaluettelo nimi'
b'DocType: Repayment Schedule',b'Balance Loan Amount',b'Balance Lainam\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14',b'Schedule Course',b'Aikataulu kurssi'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236',b'Stock Options',"b'varasto, vaihtoehdot'"
b'DocType: Buying Settings',b'Disable Fetching Last Purchase Details in Purchase Order',b'Poista k\xc3\xa4yt\xc3\xb6st\xc3\xa4 ostotilauksen viimeiset ostotiedot'
b'DocType: Journal Entry Account',b'Expense Claim',b'Kulukorvaus'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +267',b'Do you really want to restore this scrapped asset?',b'Haluatko todella palauttaa t\xc3\xa4m\xc3\xa4n romuttaa etu?'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381',b'Qty for {0}',b'Yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4n {0}'
b'DocType: Leave Application',b'Leave Application',b'Vapaa-hakemus'
b'DocType: Patient',b'Patient Relation',b'Potilaan suhde'
b'apps/erpnext/erpnext/config/hr.py +80',b'Leave Allocation Tool',b'Vapaiden kohdistusty\xc3\xb6kalu'
b'DocType: Item',b'Hub Category to Publish',b'Hub Luokka julkaista'
b'DocType: Leave Block List',b'Leave Block List Dates',"b'poistu estoluettelo, p\xc3\xa4iv\xc3\xa4t'"
b'DocType: Sales Invoice',b'Billing Address GSTIN',b'Laskutusosoite GSTIN'
b'DocType: Assessment Plan',b'Evaluate',b'Arvioida'
b'DocType: Workstation',b'Net Hour Rate',b'tuntihinta (netto)'
b'DocType: Landed Cost Purchase Receipt',b'Landed Cost Purchase Receipt',"b'Kohdistetut kustannukset, ostokuitti'"
b'DocType: Company',b'Default Terms',b'oletus ehdot'
b'DocType: Supplier Scorecard Period',b'Criteria',b'Kriteeri'
b'DocType: Packing Slip Item',b'Packing Slip Item',"b'Pakkauslappu, tuote'"
b'DocType: Purchase Invoice',b'Cash/Bank Account',b'kassa- / pankkitili'
b'apps/erpnext/erpnext/public/js/queries.js +96',b'Please specify a {0}',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 {0}'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73',b'Removed items with no change in quantity or value.',b'Poistettu kohteita ei muutu m\xc3\xa4\xc3\xa4r\xc3\xa4n tai arvon.'
b'DocType: Delivery Note',b'Delivery To',b'Toimitus vastaanottajalle'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +415',b'Variant creation has been queued.',b'Vaihtoehtojen luominen on jonossa.'
b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100',b'Work Summary for {0}',b'Ty\xc3\xb6yhteenveto {0}'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +696',b'Attribute table is mandatory',b'Taito p\xc3\xb6yt\xc3\xa4 on pakollinen'
b'DocType: Production Plan',b'Get Sales Orders',b'hae myyntitilaukset'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68',b'{0} can not be negative',b'{0} ei voi olla negatiivinen'
b'DocType: Training Event',b'Self-Study',b'Itsen\xc3\xa4inen opiskelu'
b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27',b'Soil compositions do not add up to 100',b'Maaper\xc3\xa4n koostumukset eiv\xc3\xa4t saa olla enint\xc3\xa4\xc3\xa4n 100'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558',b'Discount',b'alennus'
b'DocType: Membership',b'Membership',b'J\xc3\xa4senyys'
b'DocType: Asset',b'Total Number of Depreciations',b'Poistojen kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Sales Invoice Item',b'Rate With Margin',b'Hinta kanssa marginaali'
b'DocType: Workstation',b'Wages',b'Palkat'
b'DocType: Asset Maintenance',b'Maintenance Manager Name',b'Huoltop\xc3\xa4\xc3\xa4llik\xc3\xb6n nimi'
b'DocType: Agriculture Task',b'Urgent',b'Kiireellinen'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174',b'Please specify a valid Row ID for row {0} in table {1}',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 kelvollinen Rivi tunnus rivin {0} taulukossa {1}'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84',b'Unable to find variable: ',b'Muuttujaa ei voitu l\xc3\xb6yt\xc3\xa4\xc3\xa4:'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +794',b'Please select a field to edit from numpad',b'Valitse kent\xc3\xa4st\xc3\xa4 muokkaus numerosta'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +264',b'Cannot be a fixed asset item as Stock Ledger is created.',"b'Ei voi olla kiinte\xc3\xa4 omaisuuser\xc3\xa4, koska Stock Ledger on luotu.'"
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23',b'Go to the Desktop and start using ERPNext',b'Siirry ty\xc3\xb6p\xc3\xb6yd\xc3\xa4lle ja alkaa k\xc3\xa4ytt\xc3\xa4\xc3\xa4 ERPNext'
b'DocType: Item',b'Manufacturer',b'Valmistaja'
b'DocType: Landed Cost Item',b'Purchase Receipt Item',b'Saapumistositteen nimike'
b'DocType: Purchase Receipt',b'PREC-RET-',b'PREC-j\xc3\xa4lkik\xc3\xa4-'
b'DocType: POS Profile',b'Sales Invoice Payment',b'Myynnin lasku Payment'
b'DocType: Quality Inspection Template',b'Quality Inspection Template Name',b'Laadun tarkastusmallin nimi'
b'DocType: Project',b'First Email',b'Ensimm\xc3\xa4inen s\xc3\xa4hk\xc3\xb6posti'
b'DocType: Production Plan Item',b'Reserved Warehouse in Sales Order / Finished Goods Warehouse',b'varattu varastosta myyntitilaukseen / valmiit tuotteet varastoon'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71',b'Selling Amount',b'Myynnin arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Repayment Schedule',b'Interest Amount',b'Korko Arvo'
b'DocType: Serial No',b'Creation Document No',b'Dokumentin luonti nro'
b'DocType: Share Transfer',b'Issue',b'Tukipyynt\xc3\xb6'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11',b'Records',b'asiakirjat'
b'DocType: Asset',b'Scrapped',b'Romutettu'
b'DocType: Purchase Invoice',b'Returns',b'Palautukset'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42',b'WIP Warehouse',b'KET-varasto'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195',b'Serial No {0} is under maintenance contract upto {1}',b'Sarjanumero {0} on huoltokannassa {1} asti'
b'apps/erpnext/erpnext/config/hr.py +35',b'Recruitment',b'Rekrytointi'
b'DocType: Lead',b'Organization Name',b'Organisaatio'
b'DocType: Tax Rule',b'Shipping State',b'L\xc3\xa4hett\xc3\xa4v\xc3\xa4ll\xc3\xa4 valtiolla'
,b'Projected Quantity as Source',b'Ennustettu M\xc3\xa4\xc3\xa4r\xc3\xa4 l\xc3\xa4hdemuodossa'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61',"b""Item must be added using 'Get Items from Purchase Receipts' button""","b'tuote tulee lis\xc3\xa4t\xc3\xa4 ""hae kohteita ostokuitit"" painikella'"
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858',b'Delivery Trip',b'Toimitusmatkan'
b'DocType: Student',b'A-',b'A -'
b'DocType: Share Transfer',b'Transfer Type',b'Siirtym\xc3\xa4tyyppi'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117',b'Sales Expenses',b'Myynnin kustannukset'
b'DocType: Consultation',b'Diagnosis',b'Diagnoosi'
b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18',b'Standard Buying',b'Perusosto'
b'DocType: GL Entry',b'Against',b'kohdistus'
b'DocType: Item',b'Default Selling Cost Center',b'Myynnin oletuskustannuspaikka'
b'apps/erpnext/erpnext/public/js/pos/pos.html +85',b'Disc',b'levy'
b'DocType: Sales Partner',b'Implementation Partner',b'sovelluskumppani'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1624',b'ZIP Code',b'Postinumero'
b'apps/erpnext/erpnext/controllers/selling_controller.py +252',b'Sales Order {0} is {1}',b'Myyntitilaus {0} on {1}'
b'DocType: Opportunity',b'Contact Info',"b'yhteystiedot, info'"
b'apps/erpnext/erpnext/config/stock.py +319',b'Making Stock Entries',b'Varastotapahtumien tekeminen'
b'DocType: Packing Slip',b'Net Weight UOM',b'Nettopainon yksikk\xc3\xb6'
b'DocType: Item',b'Default Supplier',b'oletus toimittaja'
b'DocType: Manufacturing Settings',b'Over Production Allowance Percentage',b'Ylituotantoprosentti'
b'DocType: Employee Loan',b'Repayment Schedule',b'maksuaikataulusta'
b'DocType: Shipping Rule Condition',b'Shipping Rule Condition',b'Toimitustavan ehdot'
b'DocType: Holiday List',b'Get Weekly Off Dates',b'hae viikottaiset poissa p\xc3\xa4iv\xc3\xa4t'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33',b'End Date can not be less than Start Date',b'p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4 ei voi olla ennen aloitusp\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337',"b""Invoice can't be made for zero billing hour""",b'Laskua ei voi tehd\xc3\xa4 nollaan laskutustunnilla'
b'DocType: Sales Person',b'Select company name first.',b'Valitse yrityksen nimi ensin.'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189',b'Email sent to {0}',b's\xc3\xa4hk\xc3\xb6postia l\xc3\xa4hetet\xc3\xa4\xc3\xa4n {0}'
b'apps/erpnext/erpnext/config/buying.py +23',b'Quotations received from Suppliers.',b'Toimittajilta saadut tarjoukset.'
b'apps/erpnext/erpnext/config/manufacturing.py +74',b'Replace BOM and update latest price in all BOMs',b'Korvaa BOM ja p\xc3\xa4ivit\xc3\xa4 viimeisin hinta kaikkiin BOM-paketteihin'
b'apps/erpnext/erpnext/controllers/selling_controller.py +27',b'To {0} | {1} {2}',b'Vastaanottajalle {0} | {1} {2}'
b'DocType: Delivery Trip',b'Driver Name',b'Kuljettajan nimi'
b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40',b'Average Age',b'Keskim\xc3\xa4\xc3\xa4r\xc3\xa4inen ik\xc3\xa4'
b'DocType: Education Settings',b'Attendance Freeze Date',b'L\xc3\xa4sn\xc3\xa4olo Freeze Date'
b'apps/erpnext/erpnext/utilities/user_progress.py +110',b'List a few of your suppliers. They could be organizations or individuals.',b'Luettele joitain toimittajiasi. Ne voivat olla organisaatioita tai yksil\xc3\xb6it\xc3\xa4.'
b'apps/erpnext/erpnext/templates/pages/home.html +31',b'View All Products',b'N\xc3\xa4yt\xc3\xa4 kaikki tuotteet'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Pienin Lyijy ik\xc3\xa4 (p\xc3\xa4iv\xc3\xa4\xc3\xa4)'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60',b'All BOMs',b'kaikki BOMs'
b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35',b'Hotel Rooms of type {0} are unavailable on {1}',b'Hotelli {0} ei ole saatavilla {1}'
b'DocType: Patient',b'Default Currency',b'Oletusvaluutta'
b'DocType: Expense Claim',b'From Employee',b'ty\xc3\xb6ntekij\xc3\xa4st\xc3\xa4'
b'DocType: Driver',b'Cellphone Number',b'puhelinnumero'
b'DocType: Project',b'Monitor Progress',b'Seurata edistymist\xc3\xa4'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +472',b'Warning: System will not check overbilling since amount for Item {0} in {1} is zero',b'Varoitus: J\xc3\xa4rjestelm\xc3\xa4 ei tarkista liikalaskutusta koska tuotteen {0} m\xc3\xa4\xc3\xa4r\xc3\xa4 kohdassa {1} on nolla'
b'DocType: Journal Entry',b'Make Difference Entry',b'tee erokirjaus'
b'DocType: Upload Attendance',b'Attendance From Date',b'osallistuminen p\xc3\xa4iv\xc3\xa4st\xc3\xa4'
b'DocType: Appraisal Template Goal',b'Key Performance Area',b'Key Performance Area'
b'DocType: Program Enrollment',b'Transportation',b'kuljetus'
b'apps/erpnext/erpnext/controllers/item_variant.py +94',b'Invalid Attribute',b'Virheellinen Taito'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240',b'{0} {1} must be submitted',b'{0} {1} pit\xc3\xa4\xc3\xa4 olla vahvistettu'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159',b'Quantity must be less than or equal to {0}',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 on oltava pienempi tai yht\xc3\xa4 suuri kuin {0}'
b'DocType: SMS Center',b'Total Characters',b'Henkil\xc3\xb6t yhteens\xc3\xa4'
b'DocType: Employee Advance',b'Claimed',b'v\xc3\xa4itti'
b'DocType: Crop',b'Row Spacing',b'Riviv\xc3\xa4li'
b'apps/erpnext/erpnext/controllers/buying_controller.py +164',b'Please select BOM in BOM field for Item {0}',b'Valitse BOM tuotteelle BOM kent\xc3\xa4st\xc3\xa4 {0}'
b'DocType: C-Form Invoice Detail',b'C-Form Invoice Detail',b'C-muoto laskutus lis\xc3\xa4tiedot'
b'DocType: Payment Reconciliation Invoice',b'Payment Reconciliation Invoice',b'Maksun t\xc3\xa4sm\xc3\xa4ytys laskuun'
b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38',b'Contribution %',b'panostus %'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215',"b""As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}""","b'Kuten kohti ostaminen asetukset jos Ostotilauksessa Pakollinen == KYLL\xc3\x84, sitten luoda Ostolasku, k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n t\xc3\xa4ytyy luoda ostotilaus ensin kohteen {0}'"
b'DocType: Company',b'Company registration numbers for your reference. Tax numbers etc.',"b'Esim. yrityksen rekisterinumero, veronumero, yms.'"
b'DocType: Sales Partner',b'Distributor',b'jakelija'
b'DocType: Shopping Cart Shipping Rule',b'Shopping Cart Shipping Rule',b'Ostoskorin toimitustapa'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +71',"b""Please set 'Apply Additional Discount On'""",b'Aseta &#39;K\xc3\xa4yt\xc3\xa4 lis\xc3\xa4alennusta &quot;'
,b'Ordered Items To Be Billed',b'tilatut laskutettavat tuotteet'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46',b'From Range has to be less than To Range',b'Vuodesta Range on oltava v\xc3\xa4hemm\xc3\xa4n kuin laitumelle'
b'DocType: Global Defaults',b'Global Defaults',b'Yleiset oletusasetukset'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +230',b'Project Collaboration Invitation',b'Project Collaboration Kutsu'
b'DocType: Salary Slip',b'Deductions',b'v\xc3\xa4hennykset'
b'DocType: Leave Allocation',b'LAL/',b'LAL /'
b'DocType: Setup Progress Action',b'Action Name',b'Toiminnon nimi'
b'apps/erpnext/erpnext/public/js/financial_statements.js +75',b'Start Year',b'Start Year'
b'apps/erpnext/erpnext/regional/india/utils.py +25',b'First 2 digits of GSTIN should match with State number {0}',b'Ensimm\xc3\xa4iset 2 numeroa GSTIN tulee vastata valtion numero {0}'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68',b'PDC/LC',b'PDC / LC'
b'DocType: Purchase Invoice',"b""Start date of current invoice's period""",b'aloitusp\xc3\xa4iv\xc3\xa4 nykyiselle laskutuskaudelle'
b'DocType: Salary Slip',b'Leave Without Pay',b'Palkaton vapaa'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385',b'Capacity Planning Error',b'kapasiteetin suunnittelu virhe'
,b'Trial Balance for Party',b'Alustava tase osapuolelle'
b'DocType: Lead',b'Consultant',b'konsultti'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356',b'Parents Teacher Meeting Attendance',b'Vanhempien opettajien kokous osallistuminen'
b'DocType: Salary Slip',b'Earnings',b'ansiot'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +441',b'Finished Item {0} must be entered for Manufacture type entry',b'Valmiit tuotteet {0} tulee vastaanottaa valmistus tyyppi kirjauksella'
b'apps/erpnext/erpnext/config/learn.py +87',b'Opening Accounting Balance',b'Avaa kirjanpidon tase'
,b'GST Sales Register',b'GST Sales Register'
b'DocType: Sales Invoice Advance',b'Sales Invoice Advance',"b'Myyntilasku, ennakko'"
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552',b'Nothing to request',b'Ei mit\xc3\xa4\xc3\xa4n pyydett\xc3\xa4v\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +18',b'Select your Domains',b'Valitse verkkotunnuksesi'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34',"b""Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3}""",b'Toinen Budget record &#39;{0}&#39; on jo olemassa vastaan {1} {2} &#39;verovuodelta {3}'
b'DocType: Item Variant Settings',b'Fields will be copied over only at time of creation.',b'Kent\xc3\xa4t kopioidaan vain luomisajankohtana.'
b'DocType: Setup Progress Action',b'Domains',b'Verkkotunnukset'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +41',"b""'Actual Start Date' can not be greater than 'Actual End Date'""",b'Aloitusp\xc3\xa4iv\xc3\xa4n tulee olla p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4\xc3\xa4 aiempi'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117',b'Management',b'hallinto'
b'DocType: Cheque Print Template',b'Payer Settings',b'Maksajan Asetukset'
b'DocType: Item Attribute Value',"b'This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""'","b'T\xc3\xa4m\xc3\xa4 liitet\xc3\xa4\xc3\xa4n mallin tuotenumeroon esim, jos lyhenne on ""SM"" ja tuotekoodi on ""T-PAITA"", mallin tuotekoodi on ""T-PAITA-SM""'"
b'DocType: Salary Slip',b'Net Pay (in words) will be visible once you save the Salary Slip.',b'Nettomaksu (sanoina) n\xc3\xa4kyy kun tallennat palkkalaskelman.'
b'DocType: Purchase Invoice',b'Is Return',b'on palautus'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',b'Caution',b'varovaisuus'
b'apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17',"b""Start day is greater than end day in task '{0}'""",b'Aloitusp\xc3\xa4iv\xc3\xa4 on suurempi kuin loppup\xc3\xa4iv\xc3\xa4 teht\xc3\xa4v\xc3\xa4ss\xc3\xa4 &#39;{0}&#39;'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815',b'Return / Debit Note',b'Tuotto / veloitusilmoituksen'
b'DocType: Price List Country',b'Price List Country',b'Hinnasto Maa'
b'DocType: Item',b'UOMs',b'Mittayksik\xc3\xb6t'
b'apps/erpnext/erpnext/stock/utils.py +212',b'{0} valid serial nos for Item {1}',b'{0} oikea sarjanumero (nos) tuotteelle {1}'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57',b'Item Code cannot be changed for Serial No.',b'sarjanumeron tuotekoodia ei voi vaihtaa'
b'DocType: Purchase Invoice Item',b'UOM Conversion Factor',b'Mittayksik\xc3\xb6n muuntokerroin'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40',b'Please enter Item Code to get Batch Number',b'Sy\xc3\xb6t\xc3\xa4 tuotenumero saada er\xc3\xa4numero'
b'DocType: Stock Settings',b'Default Item Group',b'oletus tuoteryhm\xc3\xa4'
b'DocType: Employee Loan',b'Partially Disbursed',b'osittain maksettu'
b'apps/erpnext/erpnext/config/non_profit.py +73',b'Grant information.',b'Tukea tiedot.'
b'apps/erpnext/erpnext/config/buying.py +38',b'Supplier database.',b'toimittaja tietokanta'
b'DocType: Account',b'Balance Sheet',b'tasekirja'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750',"b""Cost Center For Item with Item Code '""",b'Nimikkeen kustannuspaikka nimikekoodilla'
b'DocType: Fee Validity',b'Valid Till',b'Voimassa'
b'DocType: Student Report Generation Tool',b'Total Parents Teacher Meeting',b'Yhteens\xc3\xa4 vanhempien opettajien kokous'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2516',"b'Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.'","b'Maksutila ei ole m\xc3\xa4\xc3\xa4ritetty. Tarkista, onko tili on asetettu tila maksut tai POS Profile.'"
b'apps/erpnext/erpnext/buying/utils.py +74',b'Same item cannot be entered multiple times.',b'Samaa kohdetta ei voi sy\xc3\xb6tt\xc3\xa4\xc3\xa4 useita kertoja.'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30',"b'Further accounts can be made under Groups, but entries can be made against non-Groups'","b'lis\xc3\xa4tilej\xc3\xa4 voidaan tehd\xc3\xa4 kohdassa ryhm\xc3\xa4t, mutta kirjaukset toi suoraan tilille'"
b'DocType: Lead',b'Lead',b'Liidi'
b'DocType: Email Digest',b'Payables',b'Maksettavat'
b'DocType: Course',b'Course Intro',b'tietenkin Intro'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +105',b'Stock Entry {0} created',b'Varastotapahtuma {0} luotu'
b'apps/erpnext/erpnext/controllers/buying_controller.py +306',b'Row #{0}: Rejected Qty can not be entered in Purchase Return',b'rivi # {0}: hyl\xc3\xa4tty\xc3\xa4 yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4 ei voi merkit\xc3\xa4 oston palautukseksi'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +182',b'Changing Customer Group for the selected Customer is not allowed.',b'Asiakasryhm\xc3\xa4n muuttaminen valitulle asiakkaalle ei ole sallittua.'
,b'Purchase Order Items To Be Billed',b'Ostotilaus Items laskuttamat'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63',b'Updating estimated arrival times.',b'Arvioitu saapumisaikoja p\xc3\xa4ivitet\xc3\xa4\xc3\xa4n.'
b'DocType: Program Enrollment Tool',b'Enrollment Details',b'Ilmoittautumistiedot'
b'DocType: Purchase Invoice Item',b'Net Rate',b'nettohinta'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152',b'Please select a customer',b'Valitse asiakas'
b'DocType: Purchase Invoice Item',b'Purchase Invoice Item',"b'Ostolasku, tuote'"
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58',b'Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts',b'varastotilikirjan- ja p\xc3\xa4\xc3\xa4tilikirjan kirjaukset siirretty ostotositteisiin'
b'DocType: Student Report Generation Tool',b'Assessment Terms',b'Arviointiehdot'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8',b'Item 1',b'Nimike 1'
b'DocType: Holiday',b'Holiday',b'loma'
b'DocType: Support Settings',b'Close Issue After Days',b'Close Issue j\xc3\xa4lkeen Days'
b'DocType: Leave Control Panel',b'Leave blank if considered for all branches',b'tyhj\xc3\xa4 mik\xc3\xa4li se pidet\xc3\xa4\xc3\xa4n vaihtoehtona kaikissa toimialoissa'
b'DocType: Bank Guarantee',b'Validity in Days',b'Voimassaolo p\xc3\xa4iviss\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21',b'C-form is not applicable for Invoice: {0}',b'C-muoto ei sovelleta lasku: {0}'
b'DocType: Payment Reconciliation',b'Unreconciled Payment Details',b'Kohdistamattomien maksujen lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6',b'Member Activity',b'J\xc3\xa4sentoiminta'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'jotta Count'
b'DocType: Global Defaults',b'Current Fiscal Year',b'nykyinen tilikausi'
b'DocType: Purchase Order',b'Group same items',b'Ryhm\xc3\xa4 sama kohdetta'
b'DocType: Purchase Invoice',b'Disable Rounded Total',"b""poista 'py\xc3\xb6ristys yhteens\xc3\xa4' k\xc3\xa4yt\xc3\xb6st\xc3\xa4"""
b'DocType: Employee Loan Application',b'Repayment Info',b'takaisinmaksu Info'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448',"b""'Entries' cannot be empty""","b""'Kirjaukset' ei voi olla tyhj\xc3\xa4"""
b'DocType: Maintenance Team Member',b'Maintenance Role',b'Huolto Rooli'
b'apps/erpnext/erpnext/utilities/transaction_base.py +92',b'Duplicate row {0} with same {1}',b'monista rivi {0} sama kuin {1}'
,b'Trial Balance',b'Alustava tase'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443',b'Fiscal Year {0} not found',b'Verovuoden {0} ei l\xc3\xb6ytynyt'
b'apps/erpnext/erpnext/config/hr.py +309',b'Setting up Employees',b'Ty\xc3\xb6ntekij\xc3\xa4tietojen perustaminen'
b'DocType: Sales Order',b'SO-',b'NIIN-'
b'DocType: Hotel Room Reservation',b'Hotel Reservation User',b'Hotellin varaus k\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158',b'Please select prefix first',b'Ole hyv\xc3\xa4 ja valitse etuliite ensin'
b'DocType: Student',b'O-',b'O -'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189',b'Research',b'Tutkimus'
b'DocType: Maintenance Visit Purpose',b'Work Done',b'Ty\xc3\xb6 tehty'
b'apps/erpnext/erpnext/controllers/item_variant.py +35',b'Please specify at least one attribute in the Attributes table',b'Ilmoitathan ainakin yksi m\xc3\xa4\xc3\xa4rite M\xc3\xa4\xc3\xa4ritteet taulukossa'
b'DocType: Announcement',b'All Students',b'kaikki opiskelijat'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +45',b'Item {0} must be a non-stock item',b'Nimike {0} ei saa olla varastonimike'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +18',b'View Ledger',b'N\xc3\xa4yt\xc3\xa4 tilikirja'
b'DocType: Grading Scale',b'Intervals',b'v\xc3\xa4liajoin'
b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Earliest',b'aikaisintaan'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +526',"b'An Item Group exists with same name, please change the item name or rename the item group'","b'Samanniminen nimikeryhm\xc3\xa4 on jo olemassa, vaihda nimikkeen nime\xc3\xa4 tai nime\xc3\xa4 nimikeryhm\xc3\xa4 uudelleen'"
b'DocType: Crop Cycle',b'Less than a year',b'Alle vuosi'
b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52',b'Student Mobile No.',b'Student Mobile No.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105',b'Rest Of The World',b'Muu maailma'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81',b'The Item {0} cannot have Batch',b'Tuote {0} ei voi olla er\xc3\xa4'
b'DocType: Crop',b'Yield UOM',b'Tuotto UOM'
,b'Budget Variance Report',b'budjettivaihtelu raportti'
b'DocType: Salary Slip',b'Gross Pay',b'bruttomaksu'
b'DocType: Item',b'Is Item from Hub',b'Onko kohta Hubista'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118',b'Row {0}: Activity Type is mandatory.',b'Rivi {0}: Toimintalaji on pakollista.'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166',b'Dividends Paid',b'maksetut osingot'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36',b'Accounting Ledger',b'Kirjanpito Ledger'
b'DocType: Stock Reconciliation',b'Difference Amount',b'eron arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107',b'Dr {0} on Leave on {1}',b'Dr {0} l\xc3\xa4hd\xc3\xb6ss\xc3\xa4 {1}'
b'DocType: Purchase Invoice',b'Reverse Charge',b'Reverse Charge'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172',b'Retained Earnings',b'Kertyneet voittovarat'
b'DocType: Purchase Invoice',b'05-Change in POS',b'05-POS-muutos'
b'DocType: Vehicle Log',b'Service Detail',b'palvelu Detail'
b'DocType: BOM',b'Item Description',b'tuotteen kuvaus'
b'DocType: Student Sibling',b'Student Sibling',b'Student Sisarukset'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18',b'Payment Mode',b'maksutila'
b'DocType: Purchase Invoice',b'Supplied Items',b'Toimitetut nimikkeet'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85',b'Please set an active menu for Restaurant {0}',b'Aseta aktiivinen valikko ravintolalle {0}'
b'DocType: Student',b'STUD.',b'NASTA.'
b'DocType: Work Order',b'Qty To Manufacture',b'Valmistettava yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Email Digest',b'New Income',b'uusi Tulot'
b'DocType: Buying Settings',b'Maintain same rate throughout purchase cycle',b'yll\xc3\xa4pid\xc3\xa4 samaa tasoa l\xc3\xa4pi ostosyklin'
b'DocType: Opportunity Item',b'Opportunity Item',b'mahdollinen tuote'
,b'Student and Guardian Contact Details',b'Opiskelija ja Guardian Yhteystiedot'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53',b'Row {0}: For supplier {0} Email Address is required to send email',b'Rivi {0}: For toimittaja {0} S\xc3\xa4hk\xc3\xb6postiosoite on l\xc3\xa4hetett\xc3\xa4v\xc3\xa4 s\xc3\xa4hk\xc3\xb6postitse'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72',b'Temporary Opening',b'Tilap\xc3\xa4inen avaus'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10',b'View Hub',b'View Hub'
,b'Employee Leave Balance',b'Ty\xc3\xb6ntekij\xc3\xa4n k\xc3\xa4ytett\xc3\xa4viss\xc3\xa4 olevat vapaat'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147',b'Balance for Account {0} must always be {1}',b'Tilin tase {0} on oltava {1}'
b'DocType: Patient Appointment',b'More Info',b'Lis\xc3\xa4tietoja'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180',b'Valuation Rate required for Item in row {0}',b'Arvostustaso vaaditaan tuotteelle rivill\xc3\xa4 {0}'
b'DocType: Supplier Scorecard',b'Scorecard Actions',b'Tuloskorttitoimet'
b'apps/erpnext/erpnext/utilities/user_progress.py +169',b'Example: Masters in Computer Science',b'Esimerkki: Masters Computer Science'
b'DocType: Purchase Invoice',b'Rejected Warehouse',b'Hyl\xc3\xa4tty varasto'
b'DocType: GL Entry',b'Against Voucher',b'kuitin kohdistus'
b'DocType: Item',b'Default Buying Cost Center',b'Oston oletuskustannuspaikka'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6',"b'To get the best out of ERPNext, we recommend that you take some time and watch these help videos.'","b'Saadaksesi kaiken irti ERPNextist\xc3\xa4, Suosittelemme katsomaan n\xc3\xa4m\xc3\xa4 ohjevideot.'"
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +76',b' to ',b'henkil\xc3\xb6lle'
b'DocType: Supplier Quotation Item',b'Lead Time in days',"b'virtausaika, p\xc3\xa4ivin\xc3\xa4'"
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70',b'Accounts Payable Summary',b'maksettava tilien yhteenveto'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326',b'Payment of salary from {0} to {1}',b'Palkanmaksu v\xc3\xa4lill\xc3\xa4 {0} ja {1}'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213',b'Not authorized to edit frozen Account {0}',b'j\xc3\xa4\xc3\xa4dytetty\xc3\xa4 tili\xc3\xa4 {0} ei voi muokata'
b'DocType: Journal Entry',b'Get Outstanding Invoices',b'hae odottavat laskut'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84',b'Sales Order {0} is not valid',b'Myyntitilaus {0} ei ole kelvollinen'
b'DocType: Supplier Scorecard',b'Warn for new Request for Quotations',b'Varo uutta tarjouspyynt\xc3\xb6\xc3\xa4'
b'apps/erpnext/erpnext/utilities/activation.py +91',b'Purchase orders help you plan and follow up on your purchases',b'Ostotilaukset auttaa suunnittelemaan ja seurata ostoksistasi'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151',b'Lab Test Prescriptions',b'Lab Test Prescriptions'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166',b'The total Issue / Transfer quantity {0} in Material Request {1}  \\\n\t\t\t\t\t\t\tcannot be greater than requested quantity {2} for Item {3}',b'Nimikkeen {3} kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4 {0} ei voi ylitt\xc3\xa4\xc3\xa4 hankintapyynn\xc3\xb6n {1} tarvem\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4 {2}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197',b'Small',b'Pieni'
b'DocType: Opening Invoice Creation Tool Item',b'Opening Invoice Creation Tool Item',b'Laskujen luomisen ty\xc3\xb6kalun avaaminen'
b'DocType: Education Settings',b'Employee Number',b'ty\xc3\xb6ntekij\xc3\xa4n numero'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67',b'Case No(s) already in use. Try from Case No {0}',"b'asianumero/numerot on jo k\xc3\xa4yt\xc3\xb6ss\xc3\xa4, aloita asianumerosta {0}'"
b'DocType: Project',b'% Completed',b'% Valmis'
,b'Invoiced Amount (Exculsive Tax)',b'laskutettu arvom\xc3\xa4\xc3\xa4r\xc3\xa4 (sis\xc3\xa4lt\xc3\xa4en verot)'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14',b'Item 2',b'Nimike 2'
b'DocType: Supplier',b'SUPP-',b'toimittaja-'
b'DocType: Training Event',b'Training Event',b'koulutustapahtuma'
b'DocType: Item',b'Auto re-order',b'Auto re-order'
b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59',b'Total Achieved',"b'Yhteens\xc3\xa4, saavutettu'"
b'DocType: Employee',b'Place of Issue',b'Aiheen alue'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101',b'Contract',b'sopimus'
b'DocType: Plant Analysis',b'Laboratory Testing Datetime',b'Laboratoriotestaus Datetime'
b'DocType: Email Digest',b'Add Quote',b'Lis\xc3\xa4\xc3\xa4 Lainaus'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +987',b'UOM coversion factor required for UOM: {0} in Item: {1}',b'Mittayksik\xc3\xb6n muuntokerroin vaaditaan yksik\xc3\xb6lle {0} tuotteessa: {1}'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92',b'Indirect Expenses',b'V\xc3\xa4lilliset kustannukset'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98',b'Row {0}: Qty is mandatory',b'Rivill\xc3\xa4 {0}: Yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 vaaditaan'
b'DocType: Agriculture Analysis Criteria',b'Agriculture',b'Maatalous'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +794',b'Sync Master Data',b'Sync Master Data'
b'DocType: Asset Repair',b'Repair Cost',b'Korjaus kustannukset'
b'apps/erpnext/erpnext/utilities/user_progress.py +138',b'Your Products or Services',b'Tarjotut tuotteet ja/tai palvelut'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15',b'Failed to login',b'Sis\xc3\xa4\xc3\xa4nkirjautuminen ep\xc3\xa4onnistui'
b'DocType: Special Test Items',b'Special Test Items',b'Erityiset testit'
b'DocType: Mode of Payment',b'Mode of Payment',b'maksutapa'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +202',b'Website Image should be a public file or website URL',b'Sivuston kuvan tulee olla kuvatiedosto tai kuvan URL-osoite'
b'DocType: Student Applicant',b'AP',b'AP'
b'DocType: Purchase Invoice Item',b'BOM',b'BOM'
b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37',b'This is a root item group and cannot be edited.',b'T\xc3\xa4m\xc3\xa4 on kantatuoteryhm\xc3\xa4 eik\xc3\xa4 sit\xc3\xa4 voi muokata'
b'DocType: Journal Entry Account',b'Purchase Order',b'Ostotilaus'
b'DocType: Vehicle',b'Fuel UOM',b'Polttoaine UOM'
b'DocType: Warehouse',b'Warehouse Contact Info',b'Varaston yhteystiedot'
b'DocType: Payment Entry',b'Write Off Difference Amount',b'Kirjoita Off Ero M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Volunteer',b'Volunteer Name',b'Vapaaehtoinen nimi'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434',"b'{0}: Employee email not found, hence email not sent'","b'{0}: Ty\xc3\xb6ntekij\xc3\xa4n s\xc3\xa4hk\xc3\xb6postiosoitetta ei l\xc3\xb6ytynyt, joten s\xc3\xa4hk\xc3\xb6postia ei l\xc3\xa4hetetty'"
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85',b'Shipping rule not applicable for country {0}',b'Toimituss\xc3\xa4\xc3\xa4nt\xc3\xb6 ei koske maata {0}'
b'DocType: Item',b'Foreign Trade Details',b'Ulkomaankauppa Yksityiskohdat'
,b'Assessment Plan Status',b'Arviointisuunnitelman tila'
b'DocType: Email Digest',b'Annual Income',b'Vuositulot'
b'DocType: Serial No',b'Serial No Details',b'Sarjanumeron lis\xc3\xa4tiedot'
b'DocType: Purchase Invoice Item',b'Item Tax Rate',b'tuotteen veroaste'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89',b'Please select Physician and Date',b'Valitse l\xc3\xa4\xc3\xa4k\xc3\xa4ri ja p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Student Group Student',b'Group Roll Number',b'Ryhm\xc3\xa4 rullanumero'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145',"b'For {0}, only credit accounts can be linked against another debit entry'","b'{0}, vain kredit tili voidaan kohdistaa debet kirjaukseen'"
b'apps/erpnext/erpnext/projects/doctype/project/project.py +84',b'Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly',b'Yhteens\xc3\xa4 Kaikkien teht\xc3\xa4v\xc3\xa4n painojen tulisi olla 1. S\xc3\xa4\xc3\xa4d\xc3\xa4 painoja Project teht\xc3\xa4vien mukaisesti'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588',b'Delivery Note {0} is not submitted',b'L\xc3\xa4hete {0} ei ole vahvistettu'
b'apps/erpnext/erpnext/stock/get_item_details.py +148',b'Item {0} must be a Sub-contracted Item',b'Nimikkeen {0} pit\xc3\xa4\xc3\xa4 olla alihankittava nimike'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43',b'Capital Equipments',b'k\xc3\xa4ytt\xc3\xb6omaisuusp\xc3\xa4\xc3\xa4oma'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33',"b""Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.""","b""Hinnoittelus\xc3\xa4\xc3\xa4nt\xc3\xb6 tulee ensin valita  'k\xc3\xa4yt\xc3\xa4 t\xc3\xa4ss\xc3\xa4' kent\xc3\xa4st\xc3\xa4, joka voi olla tuote, tuoteryhm\xc3\xa4 tai br\xc3\xa4ndi"""
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246',b'Please set the Item Code first',b'Aseta alkiotunnus ensin'
b'DocType: Item',b'ITEM-',b'kuvallisissa osaluetteloissa'
b'apps/erpnext/erpnext/controllers/selling_controller.py +123',b'Total allocated percentage for sales team should be 100',b'Myyntitiimin yhteens\xc3\xa4 lasketun prosenttiosuuden pit\xc3\xa4\xc3\xa4 olla 100'
b'DocType: Sales Invoice Item',b'Edit Description',b'Muokkaa Kuvaus'
b'DocType: Antibiotic',b'Antibiotic',b'Antibiootti'
,b'Team Updates',b'Team p\xc3\xa4ivitykset'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912',b'For Supplier',b'toimittajalle'
b'DocType: Account',b'Setting Account Type helps in selecting this Account in transactions.',b'Tilityypin asetukset auttaa valitsemaan oikean tilin tapahtumaan'
b'DocType: Purchase Invoice',b'Grand Total (Company Currency)',b'Kokonaissumma (yrityksen valuutta)'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Create Print Format',b'Luo Print Format'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5',b'Fee Created',b'Maksu luodaan'
b'apps/erpnext/erpnext/utilities/bot.py +39',b'Did not find any item called {0}',b'Ei l\xc3\xb6yt\xc3\xa4nyt mit\xc3\xa4\xc3\xa4n kohde nimelt\xc3\xa4 {0}'
b'DocType: Supplier Scorecard Criteria',b'Criteria Formula',b'Kriteerikaava'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Total Outgoing',b'l\xc3\xa4htev\xc3\xa4t yhteens\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39',"b'There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""'","b'Voi olla vain yksi toimitustavan ehto jossa ""Arvoon"" -kent\xc3\xa4ss\xc3\xa4 on 0 tai tyhj\xc3\xa4.'"
b'DocType: Authorization Rule',b'Transaction',b'tapahtuma'
b'DocType: Patient Appointment',b'Duration',b'Kesto'
b'apps/erpnext/erpnext/controllers/status_updater.py +160',"b'For an item {0}, quantity must be positive number'",b'M\xc3\xa4\xc3\xa4r\xc3\xa4n {0} osalta m\xc3\xa4\xc3\xa4r\xc3\xa4n on oltava positiivinen numero'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27',b'Note: This Cost Center is a Group. Cannot make accounting entries against groups.',"b'Huom, t\xc3\xa4m\xc3\xa4 kustannuspaikka on ryhm\xc3\xa4 eik\xc3\xa4 ryhm\xc3\xa4\xc3\xa4 kohtaan voi tehd\xc3\xa4 kirjanpidon kirjauksia'"
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53',b'Child warehouse exists for this warehouse. You can not delete this warehouse.',b'Lapsi varasto olemassa t\xc3\xa4h\xc3\xa4n varastoon. Et voi poistaa t\xc3\xa4t\xc3\xa4 varasto.'
b'DocType: Item',b'Website Item Groups',b'Tuoteryhmien verkkosivu'
b'DocType: Purchase Invoice',b'Total (Company Currency)',b'Yhteens\xc3\xa4 (yrityksen valuutta)'
b'DocType: Daily Work Summary Group',b'Reminder',b'Muistutus'
b'apps/erpnext/erpnext/stock/utils.py +207',b'Serial number {0} entered more than once',b'Sarjanumero {0} kirjattu useammin kuin kerran'
b'DocType: Journal Entry',b'Journal Entry',b'p\xc3\xa4iv\xc3\xa4kirjakirjaus'
b'DocType: Expense Claim Advance',b'Unclaimed amount',b'Velvoittamaton m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148',b'{0} items in progress',b'{0} kohdetta k\xc3\xa4ynniss\xc3\xa4'
b'DocType: Workstation',b'Workstation Name',b'Ty\xc3\xb6aseman nimi'
b'DocType: Grading Scale Interval',b'Grade Code',b'Grade koodi'
b'DocType: POS Item Group',b'POS Item Group',b'POS Kohta Group'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17',b'Email Digest:',b'tiedote:'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613',b'BOM {0} does not belong to Item {1}',b'BOM {0} ei kuulu tuotteelle {1}'
b'DocType: Sales Partner',b'Target Distribution',b'Toimitus tavoitteet'
b'DocType: Purchase Invoice',b'06-Finalization of Provisional assessment',b'06-V\xc3\xa4liaikaisen arvioinnin viimeistely'
b'DocType: Salary Slip',b'Bank Account No.',b'Pankkitilin nro'
b'DocType: Naming Series',b'This is the number of the last created transaction with this prefix',b'Viimeinen tapahtuma on tehty t\xc3\xa4ll\xc3\xa4 numerolla ja t\xc3\xa4ll\xc3\xa4 etuliitteell\xc3\xa4'
b'DocType: Supplier Scorecard',"b'Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n'","b'Tuloskortin muuttujia voidaan k\xc3\xa4ytt\xc3\xa4\xc3\xa4 sek\xc3\xa4: {total_score} (kyseisen jakson kokonaispistem\xc3\xa4\xc3\xa4r\xc3\xa4), {period_number} (ajanjaksojen lukum\xc3\xa4\xc3\xa4r\xc3\xa4 t\xc3\xa4h\xc3\xa4n p\xc3\xa4iv\xc3\xa4\xc3\xa4n)'"
b'DocType: Quality Inspection Reading',b'Reading 8',b'Lukema 8'
b'DocType: Sales Partner',b'Agent',b'agentti'
b'DocType: Purchase Invoice',b'Taxes and Charges Calculation',b'Verot ja maksut laskelma'
b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Kirja Asset Poistot Entry Automaattisesti'
b'DocType: BOM Operation',b'Workstation',b'Ty\xc3\xb6asema'
b'DocType: Request for Quotation Supplier',b'Request for Quotation Supplier',b'tarjouspyynn\xc3\xb6n toimittaja'
b'DocType: Healthcare Settings',b'Registration Message',b'Ilmoitusviesti'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154',b'Hardware',b'kova tavara'
b'DocType: Prescription Dosage',b'Prescription Dosage',b'Reseptil\xc3\xa4\xc3\xa4kitys'
b'DocType: Attendance',b'HR Manager',b'HR yll\xc3\xa4pit\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/accounts/party.py +175',b'Please select a Company',b'Valitse Yritys'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92',b'Privilege Leave',b'Poistumisoikeus'
b'DocType: Purchase Invoice',b'Supplier Invoice Date',b'Toimittajan laskun p\xc3\xa4iv\xc3\xa4ys'
b'DocType: Asset Settings',b'This value is used for pro-rata temporis calculation',b'T\xc3\xa4t\xc3\xa4 arvoa k\xc3\xa4ytet\xc3\xa4\xc3\xa4n pro-rata temporis -laskentaan'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90',b'You need to enable Shopping Cart',b'Sinun tulee aktivoida ostoskori'
b'DocType: Payment Entry',b'Writeoff',b'Poisto'
b'DocType: Stock Settings',b'Naming Series Prefix',b'Nime\xc3\xa4 sarjan etuliite'
b'DocType: Appraisal Template Goal',b'Appraisal Template Goal',b'arvioinnin tavoite'
b'DocType: Salary Component',b'Earning',b'ansio'
b'DocType: Supplier Scorecard',b'Scoring Criteria',b'Pisteytyskriteerit'
b'DocType: Purchase Invoice',b'Party Account Currency',b'Osapuolitilin valuutta'
,b'BOM Browser',b'BOM selain'
b'apps/erpnext/erpnext/templates/emails/training_event.html +13',b'Please update your status for this training event',b'P\xc3\xa4ivit\xc3\xa4 tilasi t\xc3\xa4h\xc3\xa4n koulutustilaisuuteen'
b'DocType: Item Barcode',b'EAN',b'EAN'
b'DocType: Purchase Taxes and Charges',b'Add or Deduct',b'lis\xc3\xa4\xc3\xa4 tai v\xc3\xa4henn\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148',b'Overlapping conditions found between:',b'P\xc3\xa4\xc3\xa4llekk\xc3\xa4iset olosuhteisiin v\xc3\xa4lill\xc3\xa4:'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187',b'Against Journal Entry {0} is already adjusted against some other voucher',b'p\xc3\xa4iv\xc3\xa4kirjan kohdistettu kirjaus {0} on jo s\xc3\xa4\xc3\xa4detty muuhun tositteeseen'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68',b'Total Order Value',b'tilausten arvo yhteens\xc3\xa4'
b'apps/erpnext/erpnext/demo/setup/setup_data.py +328',b'Food',b'Ruoka'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57',b'Ageing Range 3',b'vanhentumisen skaala 3'
b'DocType: Maintenance Schedule Item',b'No of Visits',b'Vierailujen lukum\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165',b'Maintenance Schedule {0} exists against {1}',b'Huolto aikataulu {0} on olemassa vastaan {1}'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36',b'Enrolling student',b'ilmoittautumalla opiskelija'
b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33',b'Currency of the Closing Account must be {0}',b'Valuutta sulkeminen on otettava {0}'
b'apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21',b'Sum of points for all goals should be 100. It is {0}',"b'kaikista tavoitteiden pisteiden summa  tulee olla 100, nyt se on {0}'"
b'DocType: Project',b'Start and End Dates',b'Alkamis- ja p\xc3\xa4\xc3\xa4ttymisajankohta'
,b'Delivered Items To Be Billed',"b'toimitettu, laskuttamat'"
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16',b'Open BOM {0}',b'Open BOM {0}'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60',b'Warehouse cannot be changed for Serial No.',b'Sarjanumerolle ei voi muuttaa varastoa'
b'DocType: Authorization Rule',b'Average Discount',b'Keskim\xc3\xa4\xc3\xa4r\xc3\xa4inen alennus'
b'DocType: Project Update',b'Great/Quickly',b'Suuri / Nopeasti'
b'DocType: Purchase Invoice Item',b'UOM',b'Yksikk\xc3\xb6'
b'DocType: Rename Tool',b'Utilities',b'Hy\xc3\xb6dykkeet'
b'DocType: POS Profile',b'Accounting',b'Kirjanpito'
b'DocType: Employee',b'EMP/',b'EMP /'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133',b'Please select batches for batched item ',b'Valitse eriss\xc3\xa4 satseittain er\xc3\xa4'
b'DocType: Asset',b'Depreciation Schedules',b'Poistot aikataulut'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192',b'Following accounts might be selected in GST Settings:',b'Seuraavat tilit voidaan valita GST-asetuksissa:'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70',b'Application period cannot be outside leave allocation period',b'Hakuaika ei voi ulkona loman jakokauteen'
b'DocType: Activity Cost',b'Projects',b'Projektit'
b'DocType: Payment Request',b'Transaction Currency',b'valuuttakoodi'
b'apps/erpnext/erpnext/controllers/buying_controller.py +30',b'From {0} | {1} {2}',b'Kenelt\xc3\xa4 {0} | {1} {2}'
b'DocType: Work Order Operation',b'Operation Description',b'toiminnon kuvaus'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34',b'Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.',b'tilikauden alkamis- tai p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4\xc3\xa4 ei voi muuttaa sen j\xc3\xa4lkeen kun tilikausi tallennetaan'
b'DocType: Quotation',b'Shopping Cart',b'Ostoskori'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Avg Daily Outgoing',b'Avg Daily L\xc3\xa4htev\xc3\xa4'
b'DocType: POS Profile',b'Campaign',b'Kampanja'
b'DocType: Supplier',b'Name and Type',b'Nimi ja tyyppi'
b'DocType: Physician',b'Contacts and Address',b'Yhteystiedot ja osoite'
b'DocType: Purchase Invoice',b'Contact Person',b'Yhteyshenkil\xc3\xb6'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +38',"b""'Expected Start Date' can not be greater than 'Expected End Date'""","b""'Toivottu aloitusp\xc3\xa4iv\xc3\xa4' ei voi olla suurempi kuin 'toivottu p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'"""
b'DocType: Course Scheduling Tool',b'Course End Date',b'Tietenkin P\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Holiday List',b'Holidays',b'lomat'
b'DocType: Sales Order Item',b'Planned Quantity',b'Suunnitellut m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Purchase Invoice Item',b'Item Tax Amount',b'tuotteen vero'
b'DocType: Water Analysis',b'Water Analysis Criteria',b'Vesi-analyysiperusteet'
b'DocType: Item',b'Maintain Stock',b'huolla varastoa'
b'DocType: Employee',b'Prefered Email',b'prefered S\xc3\xa4hk\xc3\xb6posti'
b'DocType: Student Admission',b'Eligibility and Details',b'Kelpoisuus ja tiedot'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38',b'Net Change in Fixed Asset',b'Nettomuutos kiinte\xc3\xa4 omaisuus'
b'DocType: Leave Control Panel',b'Leave blank if considered for all designations',b'tyhj\xc3\xa4 mik\xc3\xa4li se pidet\xc3\xa4\xc3\xa4n vihtoehtona kaikille nimityksille'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +806',"b""Charge of type 'Actual' in row {0} cannot be included in Item Rate""","b""maksun tyyppi\xc3\xa4 'todellinen' rivill\xc3\xa4 {0} ei voi sis\xc3\xa4llytt\xc3\xa4\xc3\xa4 tuotearvoon"""
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382',b'Max: {0}',b'Max: {0}'
b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'From Datetime',b'Alkaen aikajana'
b'DocType: Email Digest',b'For Company',b'Yritykselle'
b'apps/erpnext/erpnext/config/support.py +17',b'Communication log.',b'Viestint\xc3\xa4loki'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195',"b'Request for Quotation is disabled to access from portal, for more check portal settings.'",b'Tarjouspyynt\xc3\xb6 on lopetettu p\xc3\xa4\xc3\xa4sy portaalin enemm\xc3\xa4n tarkistaa portaalin asetuksia.'
b'DocType: Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable',b'Toimittajan tuloskortin pisteytysmuuttuja'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72',b'Buying Amount',b'Oston m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Sales Invoice',b'Shipping Address Name',b'Toimitusosoitteen nimi'
b'DocType: Material Request',b'Terms and Conditions Content',b'Ehdot ja s\xc3\xa4\xc3\xa4nn\xc3\xb6t sis\xc3\xa4lt\xc3\xb6'
b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18',b'There were errors creating Course Schedule',b'Kurssin aikataulua luotiin virheit\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581',b'cannot be greater than 100',b'ei voi olla suurempi kuin 100'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +752',b'Item {0} is not a stock Item',b'Nimike {0} ei ole varastonimike'
b'DocType: Maintenance Visit',b'Unscheduled',b'Aikatauluttamaton'
b'DocType: Employee',b'Owned',b'Omistuksessa'
b'DocType: Salary Detail',b'Depends on Leave Without Pay',b'riippuu poistumisesta ilman palkkaa'
b'DocType: Pricing Rule',"b'Higher the number, higher the priority'","b'mit\xc3\xa4 korkeampi numero, sit\xc3\xa4 korkeampi prioriteetti'"
,b'Purchase Invoice Trends',b'Ostolaskujen kehitys'
b'DocType: Employee',b'Better Prospects',b'Parempi N\xc3\xa4kym\xc3\xa4t'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +217',"b'Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches'","b'Rivi # {0}: Er\xc3\xa4 {1} on vain {2} kpl. Valitse toinen er\xc3\xa4, joka on {3} kpl saatavilla tai jakaa rivin tulee useita rivej\xc3\xa4, antaa / kysymys useista erist\xc3\xa4'"
b'DocType: Vehicle',b'License Plate',b'Rekisterikilpi'
b'DocType: Appraisal',b'Goals',b'tavoitteet'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +353',b'Select POS Profile',b'Valitse POS-profiili'
b'DocType: Warranty Claim',b'Warranty / AMC Status',b'Takuun / yll\xc3\xa4pidon tila'
,b'Accounts Browser',b'tilien selain'
b'DocType: Payment Entry Reference',b'Payment Entry Reference',b'Payment Entry Viite'
b'DocType: GL Entry',b'GL Entry',b'P\xc3\xa4\xc3\xa4tilikirjaus'
b'DocType: HR Settings',b'Employee Settings',b'ty\xc3\xb6ntekij\xc3\xa4n asetukset'
,b'Batch-Wise Balance History',b'Er\xc3\xa4kohtainen tasehistoria'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73',b'Print settings updated in respective print format',b'Tulosta asetukset p\xc3\xa4ivitet\xc3\xa4\xc3\xa4n kunkin painettuna'
b'DocType: Package Code',b'Package Code',b'Pakkaus Code'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105',b'Apprentice',b'opettelu'
b'DocType: Purchase Invoice',b'Company GSTIN',b'Yritys GSTIN'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105',b'Negative Quantity is not allowed',b'Negatiivinen m\xc3\xa4\xc3\xa4r\xc3\xa4 ei ole sallittu'
b'DocType: Purchase Invoice Item',b'Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges',"b'Verotaulukkotiedot, jotka merkataan ja tallennet\xc3\xa4\xc3\xa4n t\xc3\xa4h\xc3\xa4n kentt\xc3\xa4\xc3\xa4n noudetaan tuote ty\xc3\xb6kalusta, jota k\xc3\xa4ytet\xc3\xa4\xc3\xa4n veroihin ja maksuihin'"
b'DocType: Supplier Scorecard Period',b'SSC-',b'SSC-'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +159',b'Employee cannot report to himself.',b'ty\xc3\xb6ntekij\xc3\xa4 ei voi raportoida itselleen'
b'DocType: Account',"b'If the account is frozen, entries are allowed to restricted users.'","b'mik\xc3\xa4li tili on j\xc3\xa4\xc3\xa4dytetty, kirjaukset on rajattu tietyille k\xc3\xa4ytt\xc3\xa4jille'"
b'DocType: Email Digest',b'Bank Balance',b'Pankkitilin tase'
b'apps/erpnext/erpnext/accounts/party.py +240',b'Accounting Entry for {0}: {1} can only be made in currency: {2}',b'Kirjaus {0}: {1} voidaan tehd\xc3\xa4 vain valuutassa: {2}'
b'DocType: Job Opening',"b'Job profile, qualifications required etc.'","b'ty\xc3\xb6profiili, vaaditut p\xc3\xa4tevydet jne'"
b'DocType: Journal Entry Account',b'Account Balance',b'Tilin tase'
b'apps/erpnext/erpnext/config/accounts.py +183',b'Tax Rule for transactions.',b'Veros\xc3\xa4\xc3\xa4nt\xc3\xb6\xc3\xb6n liiketoimia.'
b'DocType: Rename Tool',b'Type of document to rename.',b'asiakirjan tyyppi uudelleenime\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53',b'{0} {1}: Customer is required against Receivable account {2}',b'{0} {1}: Asiakkaan tarvitaan vastaan Receivable huomioon {2}'
b'DocType: Purchase Invoice',b'Total Taxes and Charges (Company Currency)',b'verot ja maksut yhteens\xc3\xa4 (yrityksen valuutta)'
b'DocType: Weather',b'Weather Parameter',b'S\xc3\xa4\xc3\xa4parametri'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60',"b""Show unclosed fiscal year's P&L balances""",b'N\xc3\xa4yt\xc3\xa4 unclosed tilikaudesta P &amp; L saldot'
b'DocType: Lab Test Template',b'Collection Details',b'Ker\xc3\xa4ilytiedot'
b'DocType: POS Profile',b'Allow Print Before Pay',b'Salli tulostus ennen maksamista'
b'DocType: Land Unit',b'Linked Soil Texture',b'Linkitetty maaper\xc3\xa4n rakenne'
b'DocType: Shipping Rule',b'Shipping Account',b'Toimituskulutili'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92',b'{0} {1}: Account {2} is inactive',b'{0} {1}: Tili {2} ei ole aktiivinen'
b'apps/erpnext/erpnext/utilities/activation.py +82',b'Make Sales Orders to help you plan your work and deliver on-time',b'Tee Myyntitilaukset auttaa suunnittelemaan ty\xc3\xb6t\xc3\xa4 ja toimittaa oikea-aikaisesti'
b'DocType: Quality Inspection',b'Readings',b'Lukemat'
b'DocType: Stock Entry',b'Total Additional Costs',b'Lis\xc3\xa4kustannusten kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4'
b'DocType: Course Schedule',b'SH',b'SH'
b'DocType: BOM',b'Scrap Material Cost(Company Currency)',b'Romu ainekustannukset (Company valuutta)'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66',b'Sub Assemblies',b'alikokoonpanot'
b'DocType: Asset',b'Asset Name',b'Asset Name'
b'DocType: Project',b'Task Weight',b'teht\xc3\xa4v\xc3\xa4 Paino'
b'DocType: Shipping Rule Condition',b'To Value',b'Arvoon'
b'DocType: Asset Movement',b'Stock Manager',b'Varaston yll\xc3\xa4pit\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171',b'Source warehouse is mandatory for row {0}',b'Varastosta on pakollinen rivill\xc3\xa4 {0}'
b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38',b'The Payment Term at row {0} is possibly a duplicate.',b'Maksuehto rivill\xc3\xa4 {0} on mahdollisesti kaksoiskappale.'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +30',b'Agriculture (beta)',b'Maatalous (beta)'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863',b'Packing Slip',b'Pakkauslappu'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110',b'Office Rent',b'Toimisto Vuokra'
b'apps/erpnext/erpnext/config/setup.py +111',b'Setup SMS gateway settings',b'Tekstiviestin reititinm\xc3\xa4\xc3\xa4ritykset'
b'DocType: Disease',b'Common Name',b'Yleinen nimi'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61',b'Import Failed!',b'tuonti ep\xc3\xa4onnistui!'
b'apps/erpnext/erpnext/public/js/templates/address_list.html +20',b'No address added yet.',b'osoitetta ei ole viel\xc3\xa4 lis\xc3\xa4tty'
b'DocType: Workstation Working Hour',b'Workstation Working Hour',b'Ty\xc3\xb6aseman ty\xc3\xb6aika'
b'DocType: Vital Signs',b'Blood Pressure',b'Verenpaine'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125',b'Analyst',b'Analyytikko'
b'DocType: Item',b'Inventory',b'inventaario'
b'DocType: Item',b'Sales Details',b'Myynnin lis\xc3\xa4tiedot'
b'DocType: Quality Inspection',b'QI-',b'Qi'
b'DocType: Opportunity',b'With Items',b'Tuotteilla'
b'DocType: Asset Maintenance',b'Maintenance Team',b'Huoltoryhm\xc3\xa4'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'In Qty',b'yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4n\xc3\xa4'
b'DocType: Education Settings',b'Validate Enrolled Course for Students in Student Group',b'Vahvista Rekister\xc3\xb6idyt kurssi opiskelijoille Student Group'
b'DocType: Notification Control',b'Expense Claim Rejected',b'Kulukorvaus hyl\xc3\xa4tty'
b'DocType: Item',b'Item Attribute',b'tuotetuntomerkki'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147',b'Government',b'hallinto'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40',b'Expense Claim {0} already exists for the Vehicle Log',b'Matkakorvauslomakkeet {0} on jo olemassa Vehicle Log'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +64',b'Institute Name',b'Institute Name'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117',b'Please enter repayment Amount',b'Anna lyhennyksen m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/config/stock.py +309',b'Item Variants',b'Tuotemallit ja -variaatiot'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +29',b'Services',b'Palvelut'
b'DocType: HR Settings',b'Email Salary Slip to Employee',b'S\xc3\xa4hk\xc3\xb6posti palkkakuitin ty\xc3\xb6ntekij\xc3\xb6iden'
b'DocType: Cost Center',b'Parent Cost Center',b'P\xc3\xa4\xc3\xa4kustannuspaikka'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041',b'Select Possible Supplier',b'Valitse Mahdollinen toimittaja'
b'DocType: Sales Invoice',b'Source',b'L\xc3\xa4hde'
b'DocType: Customer',"b'Select, to make the customer searchable with these fields'","b'Valitse, jotta asiakas voi hakea n\xc3\xa4it\xc3\xa4 kentti\xc3\xa4'"
b'apps/erpnext/erpnext/templates/pages/projects.html +31',b'Show closed',b'N\xc3\xa4yt\xc3\xa4suljetut'
b'DocType: Leave Type',b'Is Leave Without Pay',b'on poistunut ilman palkkaa'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +261',b'Asset Category is mandatory for Fixed Asset item',b'Asset Luokka on pakollinen K\xc3\xa4ytt\xc3\xb6omaisuuden er\xc3\xa4'
b'DocType: Fee Validity',b'Fee Validity',b'Maksun voimassaoloaika'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146',b'No records found in the Payment table',b'Tietueita ei l\xc3\xb6ytynyt maksutaulukosta'
b'apps/erpnext/erpnext/education/utils.py +19',b'This {0} conflicts with {1} for {2} {3}',b'T\xc3\xa4m\xc3\xa4 {0} on ristiriidassa {1} ja {2} {3}'
b'DocType: Student Attendance Tool',b'Students HTML',b'opiskelijat HTML'
b'DocType: POS Profile',b'Apply Discount',b'K\xc3\xa4yt\xc3\xa4 alennus'
b'DocType: GST HSN Code',b'GST HSN Code',b'GST HSN Koodi'
b'DocType: Employee External Work History',b'Total Experience',b'Kustannukset yhteens\xc3\xa4'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70',b'Open Projects',b'Avoimet projektit'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295',b'Packing Slip(s) cancelled',b'Pakkauslaput peruttu'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36',b'Cash Flow from Investing',b'Investointien rahavirta'
b'DocType: Program Course',b'Program Course',b'Ohjelma kurssi'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99',b'Freight and Forwarding Charges',b'rahdin ja huolinnan maksut'
b'DocType: Homepage',b'Company Tagline for website homepage',b'Verkkosivuston etusivulle sijoitettava yrityksen iskulause'
b'DocType: Item Group',b'Item Group Name',b'tuoteryhm\xc3\xa4n nimi'
b'apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27',b'Taken',b'Otettu'
b'DocType: Student',b'Date of Leaving',b'L\xc3\xa4hd\xc3\xb6n p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Pricing Rule',b'For Price List',b'hinnastoon'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27',b'Executive Search',b'edistynyt haku'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55',b'Setting defaults',b'Oletusasetusten m\xc3\xa4\xc3\xa4ritt\xc3\xa4minen'
b'apps/erpnext/erpnext/utilities/activation.py +63',b'Create Leads',b'Luo liidej\xc3\xa4'
b'DocType: Maintenance Schedule',b'Schedules',b'Aikataulut'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +468',b'POS Profile is required to use Point-of-Sale',b'POS-profiilia tarvitaan myyntipisteen k\xc3\xa4ytt\xc3\xa4miseen'
b'DocType: Purchase Invoice Item',b'Net Amount',b'netto'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141',b'{0} {1} has not been submitted so the action cannot be completed',"b'{0} {1} ei ole vahvistettu, joten toimintoa ei voida suorittaa loppuun'"
b'DocType: Purchase Order Item Supplied',b'BOM Detail No',b'BOM yksitt\xc3\xa4isnumero'
b'DocType: Landed Cost Voucher',b'Additional Charges',b'Lis\xc3\xa4maksut'
b'DocType: Purchase Invoice',b'Additional Discount Amount (Company Currency)',b'Lis\xc3\xa4alennus (yrityksen valuutassa)'
b'DocType: Supplier Scorecard',b'Supplier Scorecard',b'Toimittajan arviointi'
b'DocType: Plant Analysis',b'Result Datetime',b'Tulos Datetime'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +21',b'Please create new account from Chart of Accounts.',b'Ole hyv\xc3\xa4 ja lis\xc3\xa4\xc3\xa4 uusi tili tilikartasta'
,b'Support Hour Distribution',b'Tukiaseman jakelu'
b'DocType: Maintenance Visit',b'Maintenance Visit',"b'huolto, k\xc3\xa4ynti'"
b'DocType: Student',b'Leaving Certificate Number',b'Leaving Certificate Number'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58',"b'Appointment cancelled, Please review and cancel the invoice {0}'","b'Nimitys peruutettu, tarkista laskutus {0}'"
b'DocType: Sales Invoice Item',b'Available Batch Qty at Warehouse',b'saatavilla olevan er\xc3\xa4n yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 varastossa'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Update Print Format',b'P\xc3\xa4ivit\xc3\xa4 tulostusmuoto'
b'DocType: Landed Cost Voucher',b'Landed Cost Help',"b'Kohdistetut kustannukset, ohje'"
b'DocType: Purchase Invoice',b'Select Shipping Address',b'Valitse toimitusosoite'
b'apps/erpnext/erpnext/config/non_profit.py +28',b'Memebership Details',b'J\xc3\xa4senyyden tiedot'
b'DocType: Leave Block List',b'Block Holidays on important days.',b'\xc3\xa4l\xc3\xa4 salli lomia t\xc3\xa4rkein\xc3\xa4 p\xc3\xa4ivin\xc3\xa4'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220',b'Please input all required Result Value(s)',b'Sy\xc3\xb6t\xc3\xa4 kaikki tarvittava tulosarvo (t)'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106',b'Accounts Receivable Summary',b'saatava tilien yhteenveto'
b'DocType: Employee Loan',b'Monthly Repayment Amount',b'Kuukauden lyhennyksen m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9',b'Opening Invoices',b'Avauslaskut'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +195',b'Please set User ID field in an Employee record to set Employee Role',b'kirjoita k\xc3\xa4ytt\xc3\xa4j\xc3\xa4tunnus ty\xc3\xb6ntekij\xc3\xa4 tietue kentt\xc3\xa4\xc3\xa4n  valitaksesi ty\xc3\xb6ntekij\xc3\xa4n roolin'
b'DocType: UOM',b'UOM Name',b'Mittayksik\xc3\xb6n nimi'
b'DocType: GST HSN Code',b'HSN Code',b'HSN koodi'
b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39',b'Contribution Amount',b'panostuksen arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Purchase Invoice',b'Shipping Address',b'Toimitusosoite'
b'DocType: Stock Reconciliation',b'This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.',b'T\xc3\xa4m\xc3\xa4 ty\xc3\xb6kalu auttaa sinua p\xc3\xa4ivitt\xc3\xa4m\xc3\xa4\xc3\xa4n tai korjaamaan varastom\xc3\xa4\xc3\xa4r\xc3\xa4n ja -arvon j\xc3\xa4rjestelm\xc3\xa4ss\xc3\xa4. Sit\xc3\xa4 k\xc3\xa4ytet\xc3\xa4\xc3\xa4n yleens\xc3\xa4 synkronoitaessa j\xc3\xa4rjestelm\xc3\xa4n arvoja ja varaston todellisia fyysisi\xc3\xa4 arvoja.'
b'DocType: Delivery Note',b'In Words will be visible once you save the Delivery Note.',"b'sanat n\xc3\xa4kyv\xc3\xa4t, kun tallennat l\xc3\xa4hetteen'"
b'DocType: Expense Claim',b'EXP',b'EXP'
b'DocType: Water Analysis',b'Container',b'kontti'
b'apps/erpnext/erpnext/education/utils.py +50',b'Student {0} - {1} appears Multiple times in row {2} & {3}',b'Opiskelija {0} - {1} n\xc3\xa4kyy Useita kertoja per\xc3\xa4kk\xc3\xa4in {2} ja {3}'
b'DocType: Project',b'Day to Send',b'P\xc3\xa4iv\xc3\xa4 l\xc3\xa4hett\xc3\xa4\xc3\xa4'
b'DocType: Healthcare Settings',b'Manage Sample Collection',b'Hallinnoi n\xc3\xa4ytteenottoa'
b'DocType: Production Plan',b'Ignore Existing Ordered Quantity',b'Ohita olemassa oleva m\xc3\xa4\xc3\xa4r\xc3\xa4tty m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66',b'Please set the series to be used.',b'Aseta sarja k\xc3\xa4ytett\xc3\xa4v\xc3\xa4ksi.'
b'DocType: Patient',b'Tobacco Past Use',b'Tupakan aiempi k\xc3\xa4ytt\xc3\xb6'
b'DocType: Sales Invoice Item',b'Brand Name',b'br\xc3\xa4ndin nimi'
b'DocType: Purchase Receipt',b'Transporter Details',b'Transporter Lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55',b'User {0} is already assigned to Physician {1}',b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4 {0} on jo osoitettu l\xc3\xa4\xc3\xa4k\xc3\xa4rille {1}'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2700',b'Default warehouse is required for selected item',b'Oletus varasto tarvitaan valittu kohde'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Box',b'pl'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038',b'Possible Supplier',b'mahdollinen toimittaja'
b'DocType: Budget',b'Monthly Distribution',b'toimitus kuukaudessa'
b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68',b'Receiver List is empty. Please create Receiver List',"b'vastaanottajalista on tyhj\xc3\xa4, tee vastaanottajalista'"
b'apps/erpnext/erpnext/public/js/setup_wizard.js +31',b'Healthcare (beta)',b'Terveydenhuolto (beta)'
b'DocType: Production Plan Sales Order',b'Production Plan Sales Order',b'Tuotantosuunnitelma myyntitilaukselle'
b'DocType: Sales Partner',b'Sales Partner Target',b'Myyntikumppani tavoite'
b'DocType: Loan Type',b'Maximum Loan Amount',b'Suurin lainam\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Pricing Rule',b'Pricing Rule',b'Hinnoittelus\xc3\xa4\xc3\xa4nt\xc3\xb6'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'P\xc3\xa4\xc3\xa4llekk\xc3\xa4isi\xc3\xa4 rullan numero opiskelijan {0}'
b'DocType: Budget',b'Action if Annual Budget Exceeded',b'Toiminta jos vuosibudjetin ylitetty'
b'apps/erpnext/erpnext/config/learn.py +197',b'Material Request to Purchase Order',b'Ostotilaus hankintapyynn\xc3\xb6st\xc3\xa4'
b'DocType: Shopping Cart Settings',b'Payment Success URL',b'Maksu onnistui URL'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81',b'Row # {0}: Returned Item {1} does not exists in {2} {3}',b'rivi # {0}: palautettava tuote {1} ei l\xc3\xb6ydy {2} {3}'
b'DocType: Purchase Receipt',b'PREC-',b'PREC-'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16',b'Bank Accounts',b'Pankkitilit'
,b'Bank Reconciliation Statement',b'pankin t\xc3\xa4sm\xc3\xa4ytystosite'
b'DocType: Consultation',b'Medical Coding',b'L\xc3\xa4\xc3\xa4ketieteellinen koodaus'
b'DocType: Healthcare Settings',b'Reminder Message',b'Muistutusviesti'
,b'Lead Name',b'Liidin nimi'
,b'POS',b'POS'
b'DocType: C-Form',b'III',b'III'
b'apps/erpnext/erpnext/config/stock.py +314',b'Opening Stock Balance',b'Varastotaseen alkuarvo'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58',b'{0} must appear only once',b'{0} saa esiinty\xc3\xa4 vain kerran'
b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59',b'Leaves Allocated Successfully for {0}',b'Vapaat kohdennettu {0}:lle'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42',b'No Items to pack',b'ei pakattavia tuotteita'
b'DocType: Shipping Rule Condition',b'From Value',b'arvosta'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +606',b'Manufacturing Quantity is mandatory',b'Valmistus M\xc3\xa4\xc3\xa4r\xc3\xa4 on pakollista'
b'DocType: Employee Loan',b'Repayment Method',b'lyhennystapa'
b'DocType: Products Settings',"b'If checked, the Home page will be the default Item Group for the website'","b'Jos valittu, kotisivun tulee oletuksena Item ryhm\xc3\xa4n verkkosivuilla'"
b'DocType: Quality Inspection Reading',b'Reading 4',b'Lukema 4'
b'apps/erpnext/erpnext/config/hr.py +132',b'Claims for company expense.',b'Yrityksen maksettaviksi vaaditut kulut'
b'apps/erpnext/erpnext/utilities/activation.py +118',"b'Students are at the heart of the system, add all your students'","b'Opiskelijat ytimess\xc3\xa4 j\xc3\xa4rjestelm\xc3\xa4n, lis\xc3\xa4\xc3\xa4 kaikki opiskelijat'"
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97',b'Row #{0}: Clearance date {1} cannot be before Cheque Date {2}',b'Rivi # {0}: Tilitysp\xc3\xa4iv\xc3\xa4 {1} ei voi olla ennen shekin p\xc3\xa4iv\xc3\xa4\xc3\xa4 {2}'
b'DocType: Asset Maintenance Task',b'Certificate Required',b'Vaadittu todistus'
b'DocType: Company',b'Default Holiday List',b'oletus lomaluettelo'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196',b'Row {0}: From Time and To Time of {1} is overlapping with {2}',b'Rivi {0}: From Time ja To aika {1} on p\xc3\xa4\xc3\xa4llekk\xc3\xa4inen {2}'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145',b'Stock Liabilities',b'varasto vastattavat'
b'DocType: Purchase Invoice',b'Supplier Warehouse',b'toimittajan varasto'
b'DocType: Opportunity',b'Contact Mobile No',"b'yhteystiedot, puhelin'"
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399',b'Select Company',b'Valitse Yritys'
,b'Material Requests for which Supplier Quotations are not created',b'Materiaalipyynn\xc3\xb6t ilman toimituskykytiedustelua'
b'DocType: Student Report Generation Tool',b'Print Section',b'Tulosta osio'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34',"b""User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.""",b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4lle {0} ei ole oletusarvoista POS-profiilia. Tarkista t\xc3\xa4m\xc3\xa4n k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n oletusarvo rivill\xc3\xa4 {1}.'
b'DocType: Student Group',b'Set 0 for no limit',b'Aseta 0 ei rajaa'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122',b'The day(s) on which you are applying for leave are holidays. You need not apply for leave.',"b'P\xc3\xa4iv\xc3\xa4 (t), johon haet lupaa ovat vapaap\xc3\xa4ivi\xc3\xa4. Sinun ei tarvitse hakea lupaa.'"
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64',b'Row {idx}: {field} is required to create the Opening {invoice_type} Invoices',b'Rivin {idx}: {field} on luotava Opening {invoice_type} Laskut'
b'DocType: Customer',b'Primary Address and Contact Detail',b'Ensisijainen osoite ja yhteystiedot'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20',b'Resend Payment Email',b'L\xc3\xa4hett\xc3\xa4\xc3\xa4 maksu S\xc3\xa4hk\xc3\xb6posti'
b'apps/erpnext/erpnext/templates/pages/projects.html +27',b'New task',b'uusi teht\xc3\xa4v\xc3\xa4'
b'DocType: Consultation',b'Appointment',b'Nimitt\xc3\xa4minen'
b'apps/erpnext/erpnext/utilities/activation.py +74',b'Make Quotation',b'tee tarjous'
b'apps/erpnext/erpnext/config/education.py +230',b'Other Reports',b'Muut raportit'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +39',b'Please select at least one domain.',b'Valitse v\xc3\xa4hint\xc3\xa4\xc3\xa4n yksi verkkotunnus.'
b'DocType: Dependent Task',b'Dependent Task',b'riippuvainen teht\xc3\xa4v\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +444',b'Conversion factor for default Unit of Measure must be 1 in row {0}',b'Oletusyksik\xc3\xb6n muuntokerroin pit\xc3\xa4\xc3\xa4 olla 1 rivill\xc3\xa4 {0}'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188',b'Leave of type {0} cannot be longer than {1}',b'{0} -tyyppinen vapaa ei voi olla pidempi kuin {1}'
b'DocType: Manufacturing Settings',b'Try planning operations for X days in advance.',b'kokeile suunnitella toimia X p\xc3\xa4iv\xc3\xa4\xc3\xa4 etuk\xc3\xa4teen'
b'DocType: HR Settings',b'Stop Birthday Reminders',b'lopeta syntym\xc3\xa4p\xc3\xa4iv\xc3\xa4muistutukset'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235',b'Please set Default Payroll Payable Account in Company {0}',b'Aseta Default Payroll maksullisia tilin Yrityksen {0}'
b'DocType: SMS Center',b'Receiver List',b'Vastaanotin List'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1094',b'Search Item',b'haku Tuote'
b'DocType: Payment Schedule',b'Payment Amount',b'maksun arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Patient Appointment',b'Referring Physician',b'Viittaava l\xc3\xa4\xc3\xa4k\xc3\xa4ri'
b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46',b'Consumed Amount',b'k\xc3\xa4ytetty arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100',b'Net Change in Cash',b'Rahavarojen muutos'
b'DocType: Assessment Plan',b'Grading Scale',b'Arvosteluasteikko'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +438',b'Unit of Measure {0} has been entered more than once in Conversion Factor Table',b'yksikk\xc3\xb6\xc3\xa4 {0} on kirjattu useammin kuin kerran muuntokerroin taulukossa'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +639',b'Already completed',b'jo valmiiksi'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33',b'Stock In Hand',b'Stock k\xc3\xa4dess\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64',b'Import Successful!',b'tuonti onnistunut!'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29',b'Payment Request already exists {0}',b'Maksupyynt\xc3\xb6 on jo olemassa {0}'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Issued Items',b'aiheen tuotteiden kustannukset'
b'DocType: Physician',b'Hospital',b'Sairaala'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385',b'Quantity must not be more than {0}',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 saa olla enint\xc3\xa4\xc3\xa4n {0}'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117',b'Previous Financial Year is not closed',b'Edellisen tilikauden ei ole suljettu'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46',b'Age (Days)',b'Ik\xc3\xa4 (p\xc3\xa4iv\xc3\xa4\xc3\xa4)'
b'DocType: Quotation Item',b'Quotation Item',b'Tarjouksen tuote'
b'DocType: Customer',b'Customer POS Id',b'Asiakas POS Id'
b'DocType: Account',b'Account Name',b'Tilin nimi'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40',b'From Date cannot be greater than To Date',b'Alkaen p\xc3\xa4iv\xc3\xa4 ei voi olla suurempi kuin p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198',b'Serial No {0} quantity {1} cannot be a fraction',b'Sarjanumero {0} yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 {1} ei voi olla murto-osa'
b'apps/erpnext/erpnext/config/buying.py +43',b'Supplier Type master.',b'toimittajatyypin valvonta'
b'DocType: Purchase Order Item',b'Supplier Part Number',b'Toimittajan nimikekoodi'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108',b'Conversion rate cannot be 0 or 1',b'muuntokerroin ei voi olla 0 tai 1'
b'DocType: Share Balance',b'To No',b'Ei'
b'DocType: Subscription',b'Reference Document',b'vertailuasiakirja'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229',b'{0} {1} is cancelled or stopped',b'{0} {1} on peruutettu tai pys\xc3\xa4ytetty'
b'DocType: Accounts Settings',b'Credit Controller',b'kredit valvoja'
b'DocType: Grant Application',b'Applicant Type',b'Hakijan tyyppi'
b'DocType: Purchase Invoice',b'03-Deficiency in services',b'03-Palvelujen puute'
b'DocType: Delivery Note',b'Vehicle Dispatch Date',b'Ajoneuvon toimitusp\xc3\xa4iv\xc3\xa4'
b'DocType: Healthcare Settings',b'Default Medical Code Standard',b'Oletus Medical Code Standard'
b'DocType: Purchase Invoice Item',b'HSN/SAC',b'HSN / SAC'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237',b'Purchase Receipt {0} is not submitted',b'Saapumista {0} ei ole vahvistettu'
b'DocType: Company',b'Default Payable Account',b'oletus maksettava tili'
b'apps/erpnext/erpnext/config/website.py +17',"b'Settings for online shopping cart such as shipping rules, price list etc.'","b'Ostoskorin asetukset, kuten toimitustapa, hinnastot, jne'"
b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +113',b'{0}% Billed',b'{0}% laskutettu'
b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18',b'Reserved Qty',b'varattu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Party Account',b'Party Account',b'Osapuolitili'
b'apps/erpnext/erpnext/config/setup.py +122',b'Human Resources',b'Henkil\xc3\xb6st\xc3\xb6resurssit'
b'DocType: Lead',b'Upper Income',b'Ylemm\xc3\xa4t tulot'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17',b'Reject',b'Hyl\xc3\xa4t\xc3\xa4'
b'DocType: Journal Entry Account',b'Debit in Company Currency',b'Debit in Company Valuutta'
b'DocType: BOM Item',b'BOM Item',b'Osaluettelonimike'
b'DocType: Appraisal',b'For Employee',b'Ty\xc3\xb6ntekij\xc3\xa4n'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49',b'Make Disbursement Entry',b'Tee maksaminen Entry'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138',b'Row {0}: Advance against Supplier must be debit',b'Rivi {0}: Advance vastaan Toimittaja on veloittaa'
b'DocType: Company',b'Default Values',b'oletus arvot'
b'DocType: Membership',b'INR',b'INR'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60',b'{frequency} Digest',b'{Taajuus} Digest'
b'DocType: Expense Claim',b'Total Amount Reimbursed',b'Hyvitys yhteens\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5',b'This is based on logs against this Vehicle. See timeline below for details',b'T\xc3\xa4m\xc3\xa4 perustuu tukkien vastaan Vehicle. Katso aikajana lis\xc3\xa4tietoja alla'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90',b'Against Supplier Invoice {0} dated {1}',b'toimittajan ostolaskun kohdistus {0} p\xc3\xa4iv\xc3\xa4ys {1}'
b'DocType: Customer',b'Default Price List',b'oletus hinnasto'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +322',b'Asset Movement record {0} created',b'Asset Movement record {0} luotu'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51',b'You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings',b'Et voi poistaa tilikautta {0}. Tilikausi {0} on asetettu oletustilikaudeksi j\xc3\xa4rjestelm\xc3\xa4asetuksissa.'
b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20',b'A customer with the same name already exists',b'Saman nimen omaava asiakas on jo olemassa'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185',b'This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?',b'T\xc3\xa4m\xc3\xa4 l\xc3\xa4hett\xc3\xa4\xc3\xa4 palkkap\xc3\xa4iv\xc3\xa4sijoitukset ja luo suoritep\xc3\xa4iv\xc3\xa4kirja-merkinn\xc3\xa4n. Haluatko edet\xc3\xa4?'
b'DocType: Purchase Invoice',b'Total Net Weight',b'Nettopaino yhteens\xc3\xa4'
b'DocType: Purchase Invoice',b'Eligibility For ITC',b'Kelpoisuus ITC: lle'
b'DocType: Journal Entry',b'Entry Type',b'Entry Tyyppi'
,b'Customer Credit Balance',b'Asiakkaan kredit tase'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28',b'Net Change in Accounts Payable',b'Nettomuutos ostovelat'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'EcritureLet',b'EcritureLet'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +209',b'Credit limit has been crossed for customer {0} ({1}/{2})',b'Luottoraja on ylitetty asiakkaalle {0} ({1} / {2})'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42',"b""Customer required for 'Customerwise Discount'""","b""asiakkaalla tulee olla 'asiakaskohtainen alennus'"""
b'apps/erpnext/erpnext/config/accounts.py +140',b'Update bank payment dates with journals.',b'P\xc3\xa4ivit\xc3\xa4 pankin maksup\xc3\xa4iv\xc3\xa4t p\xc3\xa4iv\xc3\xa4kirjojen kanssa'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21',b'Pricing',b'Hinnoittelu'
b'DocType: Quotation',b'Term Details',b'Ehdon lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30',b'Cannot enroll more than {0} students for this student group.',b'Ei voi ilmoittautua enint\xc3\xa4\xc3\xa4n {0} opiskelijat t\xc3\xa4lle opiskelijaryhm\xc3\xa4lle.'
b'apps/erpnext/erpnext/templates/print_formats/includes/total.html +4',b'Total (Without Tax)',b'Yhteens\xc3\xa4 (ilman veroa)'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'lyijy Count'
b'apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15',b'{0} must be greater than 0',b'{0} on oltava suurempi kuin 0'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30',b'Stock Available',b'Varastossa saatavilla'
b'DocType: Manufacturing Settings',b'Capacity Planning For (Days)',b'kapasiteetin suunnittelu (p\xc3\xa4iville)'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10',b'Procurement',b'Hankinnat'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66',b'None of the items have any change in quantity or value.',b'Mik\xc3\xa4\xc3\xa4n kohteita ovat muutoksia m\xc3\xa4\xc3\xa4r\xc3\xa4n tai arvon.'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Pakollinen kentt\xc3\xa4 - Ohjelma'
b'DocType: Special Test Template',b'Result Component',b'Tuloskomponentti'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46',b'Warranty Claim',b'Takuuanomus'
,b'Lead Details',b'Liidin lis\xc3\xa4tiedot'
b'DocType: Volunteer',b'Availability and Skills',b'Saatavuus ja taidot'
b'DocType: Salary Slip',b'Loan repayment',b'Lainan takaisinmaksu'
b'DocType: Purchase Invoice',"b""End date of current invoice's period""",b'nykyisen laskukauden p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Pricing Rule',b'Applicable For',b'sovellettavissa'
b'DocType: Lab Test',b'Technician Name',b'Tekniikan nimi'
b'DocType: Accounts Settings',b'Unlink Payment on Cancellation of Invoice',b'Linkityksen Maksu mit\xc3\xa4t\xc3\xb6inti Lasku'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16',b'Current Odometer reading entered should be greater than initial Vehicle Odometer {0}',b'Matkamittarin lukema merkit\xc3\xa4\xc3\xa4n pit\xc3\xa4isi olla suurempi kuin alkuper\xc3\xa4isen ajoneuvon matkamittarin {0}'
b'DocType: Restaurant Reservation',b'No Show',b'Ei n\xc3\xa4yt\xc3\xa4'
b'DocType: Shipping Rule Country',b'Shipping Rule Country',b'Toimitustavan maa'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10',b'Leave and Attendance',b'Vapaat ja l\xc3\xa4sn\xc3\xa4olot'
b'DocType: Maintenance Visit',b'Partially Completed',b'Osittain Valmis'
b'apps/erpnext/erpnext/healthcare/setup.py +257',b'Moderate Sensitivity',b'Kohtuullinen herkkyys'
b'DocType: Leave Type',b'Include holidays within leaves as leaves',b'sis\xc3\xa4lt\xc3\xa4\xc3\xa4 vapaap\xc3\xa4ivi\xc3\xa4n poistumiset poistumisina'
b'DocType: Sales Invoice',b'Packed Items',b'Pakatut tuotteet'
b'apps/erpnext/erpnext/config/support.py +27',b'Warranty Claim against Serial No.',b'Takuuanomus sarjanumerolle'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197',"b""'Total'""","b""'Yhteens\xc3\xa4'"""
b'DocType: Shopping Cart Settings',b'Enable Shopping Cart',b'aktivoi ostoskori'
b'DocType: Employee',b'Permanent Address',b'Pysyv\xc3\xa4 osoite'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260',b'Advance paid against {0} {1} cannot be greater \\\n\t\t\t\t\t\tthan Grand Total {2}',b'Maksettu ennakko vastaan {0} {1} ei voi olla suurempi \\ kuin Grand Yhteens\xc3\xa4 {2}'
b'DocType: Consultation',b'Medication',b'L\xc3\xa4\xc3\xa4kitys'
b'DocType: Production Plan',b'Include Non Stock Items',b'Sis\xc3\xa4llyt\xc3\xa4 ei-kantatiedot'
b'DocType: Project Update',b'Challenging/Slow',b'Haastava / Slow'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147',b'Please select item code',b'Valitse tuotekoodi'
b'DocType: Student Sibling',b'Studying in Same Institute',b'Opiskelu Sama Institute'
b'DocType: Territory',b'Territory Manager',b'Aluep\xc3\xa4\xc3\xa4llikk\xc3\xb6'
b'DocType: Packed Item',b'To Warehouse (Optional)',b'Varastoon (valinnainen)'
b'DocType: GST Settings',b'GST Accounts',b'GST-tilit'
b'DocType: Payment Entry',b'Paid Amount (Company Currency)',b'Maksettu m\xc3\xa4\xc3\xa4r\xc3\xa4 (Yrityksen valuutta)'
b'DocType: Purchase Invoice',b'Additional Discount',b'Lis\xc3\xa4alennus'
b'DocType: Selling Settings',b'Selling Settings',b'Myynnin asetukset'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83',b'Confirm Action',b'Vahvista toimi'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39',b'Online Auctions',b'Online Auctions'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100',b'Please specify either Quantity or Valuation Rate or both',"b'Aseta m\xc3\xa4\xc3\xa4r\xc3\xa4, arvostustaso tai molemmat'"
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18',b'Fulfillment',b't\xc3\xa4yttymys'
b'apps/erpnext/erpnext/templates/generators/item.html +82',b'View in Cart',b'View Cart'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103',b'Marketing Expenses',b'Markkinointikustannukset'
,b'Item Shortage Report',b'Tuotevajausraportti'
b'apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15',"b""Can't create standard criteria. Please rename the criteria""",b'Vakiokriteereit\xc3\xa4 ei voi luoda. Nime\xc3\xa4 kriteerit uudelleen'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +311',"b'Weight is mentioned,\\nPlease mention ""Weight UOM"" too'","b'Paino on mainittu, \\ ssa mainitse my\xc3\xb6s ""Painoyksikk\xc3\xb6""'"
b'DocType: Stock Entry Detail',b'Material Request used to make this Stock Entry',b'Varaston kirjaus hankintapyynn\xc3\xb6st\xc3\xa4'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +68',b'Next Depreciation Date is mandatory for new asset',b'Seuraava Poistot Date on pakollinen uutta sis\xc3\xa4lt\xc3\xb6\xc3\xa4'
b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Erillinen perustuu luonnollisesti ryhm\xc3\xa4n kutakin Er\xc3\xa4'
b'apps/erpnext/erpnext/config/support.py +32',b'Single unit of an Item.',b'Tuotteen yksitt\xc3\xa4isyksikk\xc3\xb6'
b'DocType: Fee Category',b'Fee Category',b'Fee Luokka'
b'DocType: Agriculture Task',b'Next Business Day',b'Seuraava ty\xc3\xb6p\xc3\xa4iv\xc3\xa4'
b'DocType: Drug Prescription',b'Dosage by time interval',b'Annostus ajan mukaan'
b'DocType: Cash Flow Mapper',b'Section Header',b'Lohkon otsikko'
,b'Student Fee Collection',b'Student Fee Collection'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24',b'Appointment Duration (mins)',b'Nimitt\xc3\xa4misen kesto (min)'
b'DocType: Accounts Settings',b'Make Accounting Entry For Every Stock Movement',b'tee kirjanpidon kirjaus kaikille varastotapahtumille'
b'DocType: Leave Allocation',b'Total Leaves Allocated',"b'Poistumisten yhteism\xc3\xa4\xc3\xa4r\xc3\xa4, kohdennettu'"
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163',b'Warehouse required at Row No {0}',b'Varasto vaaditaan rivill\xc3\xa4 {0}'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +145',b'Please enter valid Financial Year Start and End Dates',b'Anna kelvollinen tilivuoden alkamis- ja p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Employee',b'Date Of Retirement',b'El\xc3\xa4kkeellesiirtymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Upload Attendance',b'Get Template',b'hae mallipohja'
b'DocType: Material Request',b'Transferred',b'siirretty'
b'DocType: Vehicle',b'Doors',b'ovet'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117',b'ERPNext Setup Complete!',b'ERPNext Asennus valmis!'
b'DocType: Healthcare Settings',b'Collect Fee for Patient Registration',b'Ker\xc3\xa4\xc3\xa4 maksut potilaan rekister\xc3\xb6innille'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +678',b'Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item',b'Ominaisuuksia ei voi muuttaa varastotoiminnan j\xc3\xa4lkeen. Tee uusi esine ja siirr\xc3\xa4 varastosi uuteen kohtaan'
b'DocType: Course Assessment Criteria',b'Weightage',b'Painoarvo'
b'DocType: Purchase Invoice',b'Tax Breakup',b'vero Breakup'
b'DocType: Packing Slip',b'PS-',b'PS-'
b'DocType: Member',b'Non Profit Member',b'Ei voittoa j\xc3\xa4sen'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67',"b""{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.""",b'{0} {1}: Kustannuspaikka vaaditaan &quot;Tuloslaskelma&quot; tilin {2}. M\xc3\xa4\xc3\xa4rit\xc3\xa4 oletuksena kustannukset Center for the Company.'
b'DocType: Payment Schedule',b'Payment Term',b'Maksuehto'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +160',b'A Customer Group exists with same name please change the Customer name or rename the Customer Group',"b'saman niminen asiakasryhm\xc3\xa4 on jo olemassa, vaihda asiakkaan nimi tai nime\xc3\xa4 asiakasryhm\xc3\xa4 uudelleen'"
b'DocType: Land Unit',b'Area',b'alue'
b'apps/erpnext/erpnext/public/js/templates/contact_list.html +37',b'New Contact',b'Uusi yhteystieto'
b'DocType: Territory',b'Parent Territory',b'P\xc3\xa4\xc3\xa4alue'
b'DocType: Purchase Invoice',b'Place of Supply',b'Toimituspaikka'
b'DocType: Quality Inspection Reading',b'Reading 2',b'Lukema 2'
b'DocType: Stock Entry',b'Material Receipt',b'Saapuminen'
b'DocType: Homepage',b'Products',b'Tuotteet'
b'DocType: Announcement',b'Instructor',b'Ohjaaja'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61',b'Select Item (optional)',b'Valitse kohde (valinnainen)'
b'DocType: Fee Schedule Student Group',b'Fee Schedule Student Group',b'Palkkioaikataulu Opiskelijaryhm\xc3\xa4'
b'DocType: Student',b'AB+',b'AB +'
b'DocType: Item',"b'If this item has variants, then it cannot be selected in sales orders etc.'","b'mik\xc3\xa4li t\xc3\xa4ll\xc3\xa4 tuotteella on useita malleja, sit\xc3\xa4 ei voi valita esim. myyntitilaukseen'"
b'DocType: Lead',b'Next Contact By',b'seuraava yhteydenottohl\xc3\xb6'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325',b'Quantity required for Item {0} in row {1}',b'Vaadittu tuotem\xc3\xa4\xc3\xa4r\xc3\xa4 {0} rivill\xc3\xa4 {1}'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45',b'Warehouse {0} can not be deleted as quantity exists for Item {1}',b'Varastoa {0} ei voi poistaa koska se sis\xc3\xa4lt\xc3\xa4\xc3\xa4 tuotetta {1}'
b'DocType: Quotation',b'Order Type',b'Tilaustyyppi'
,b'Item-wise Sales Register',"b'tuote ty\xc3\xb6kalu, myyntirekisteri'"
b'DocType: Asset',b'Gross Purchase Amount',b'Gross Osto M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/utilities/user_progress.py +39',b'Opening Balances',b'Avauspalkkiot'
b'DocType: Asset',b'Depreciation Method',b'Poistot Menetelm\xc3\xa4'
b'DocType: Purchase Taxes and Charges',b'Is this Tax included in Basic Rate?',b'kuuluuko t\xc3\xa4m\xc3\xa4 vero perustasoon?'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Target',b'tavoite yhteens\xc3\xa4'
b'DocType: Soil Texture',b'Sand Composition (%)',b'Hiekojen koostumus (%)'
b'DocType: Job Applicant',b'Applicant for a Job',b'ty\xc3\xb6n hakija'
b'DocType: Production Plan Material Request',b'Production Plan Material Request',b'Tuotanto Plan Materiaali Request'
b'DocType: Stock Reconciliation',b'Reconciliation JSON',b'JSON t\xc3\xa4sm\xc3\xa4ytys'
b'apps/erpnext/erpnext/accounts/report/financial_statements.html +3',b'Too many columns. Export the report and print it using a spreadsheet application.',"b'Liian monta saraketta, vie raportti taulukkolaskentaohjelman ja tulosta se siell\xc3\xa4'"
b'DocType: Purchase Invoice Item',b'Batch No',b'Er\xc3\xa4numero'
b'DocType: Selling Settings',"b""Allow multiple Sales Orders against a Customer's Purchase Order""",b'Salli useat Myyntitilaukset vastaan Asiakkaan Ostotilauksen'
b'DocType: Student Group Instructor',b'Student Group Instructor',b'Opiskelijaryhm\xc3\xa4n Ohjaaja'
b'DocType: Grant Application',b'Assessment  Mark (Out of 10)',b'Arviointimerkki (kymmenest\xc3\xa4)'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61',b'Guardian2 Mobile No',b'Guardian2 Mobile Ei'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +218',b'Main',b'T\xc3\xa4rkein'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +72',b'Variant',b'Malli'
b'DocType: Naming Series',b'Set prefix for numbering series on your transactions',b'Aseta sarjojen numeroinnin etuliite tapahtumiin'
b'DocType: Employee Attendance Tool',b'Employees HTML',b'Ty\xc3\xb6ntekij\xc3\xa4t HTML'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +458',b'Default BOM ({0}) must be active for this item or its template',b'oletus BOM ({0}) tulee olla aktiivinen t\xc3\xa4lle tuotteelle tai sen mallipohjalle'
b'DocType: Employee',b'Leave Encashed?',b'vapaa kuitattu rahana?'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32',b'Opportunity From field is mandatory',b'tilaisuuteen kentt\xc3\xa4 vaaditaan'
b'DocType: Email Digest',b'Annual Expenses',b'Vuosittaiset kustannukset'
b'DocType: Item',b'Variants',b'Mallit'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1148',b'Make Purchase Order',b'Tee Ostotilaus'
b'DocType: SMS Center',b'Send To',b'L\xc3\xa4het\xc3\xa4 kenelle'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133',b'There is not enough leave balance for Leave Type {0}',b'Vapaatyypille {0} ei ole tarpeeksi vapaata j\xc3\xa4ljell\xc3\xa4'
b'DocType: Payment Reconciliation Payment',b'Allocated amount',b'kohdennettu arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Sales Team',b'Contribution to Net Total',"b'panostus, netto yhteens\xc3\xa4'"
b'DocType: Sales Invoice Item',"b""Customer's Item Code""",b'Asiakkaan nimikekoodi'
b'DocType: Stock Reconciliation',b'Stock Reconciliation',b'Varaston t\xc3\xa4sm\xc3\xa4ytys'
b'DocType: Territory',b'Territory Name',b'Alueen nimi'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204',b'Work-in-Progress Warehouse is required before Submit',b'Keskener\xc3\xa4isten varasto vaaditaan ennen vahvistusta'
b'apps/erpnext/erpnext/config/hr.py +40',b'Applicant for a Job.',b'ty\xc3\xb6n hakija.'
b'DocType: Purchase Order Item',b'Warehouse and Reference',b'Varasto ja viite'
b'DocType: Supplier',b'Statutory info and other general information about your Supplier',b'toimittajan lakis\xc3\xa4\xc3\xa4teiset- ja muut p\xc3\xa4\xc3\xa4tiedot'
b'DocType: Item',b'Serial Nos and Batches',b'Sarjanumerot ja Er\xc3\xa4t'
b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'Opiskelijaryhm\xc3\xa4n Vahvuus'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261',b'Against Journal Entry {0} does not have any unmatched {1} entry',b'p\xc3\xa4iv\xc3\xa4kirjaan kohdistus {0} ei t\xc3\xa4sm\xc3\xa4\xc3\xa4m\xc3\xa4tt\xc3\xb6mi\xc3\xa4 {1} kirjauksia'
b'apps/erpnext/erpnext/config/hr.py +142',b'Appraisals',b'Kehityskeskustelut'
b'apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8',b'Training Events',b'Koulutustilaisuudet'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205',b'Duplicate Serial No entered for Item {0}',b'monista tuotteelle kirjattu sarjanumero {0}'
b'apps/erpnext/erpnext/config/selling.py +179',b'Track Leads by Lead Source.',b'Ratajohdot johdon l\xc3\xa4hteell\xc3\xa4.'
b'DocType: Shipping Rule Condition',b'A condition for a Shipping Rule',b'Toimitustavan ehdot'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +167',b'Please enter ',b'K\xc3\xa4y sis\xc3\xa4\xc3\xa4n'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43',b'Maintenance Log',b'Huoltokirja'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236',b'Please set filter based on Item or Warehouse',b'Aseta suodatin perustuu Tuote tai Varasto'
b'DocType: Packing Slip',b'The net weight of this package. (calculated automatically as sum of net weight of items)',"b'Pakkauksen nettopaino, summa lasketaan automaattisesti tuotteiden nettopainoista'"
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +802',b'Discount amount cannot be greater than 100%',b'Alennusm\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla suurempi kuin 100%'
b'DocType: Sales Order',b'To Deliver and Bill',b'L\xc3\xa4het\xc3\xa4 ja laskuta'
b'DocType: Student Group',b'Instructors',b'Ohjaajina'
b'DocType: GL Entry',b'Credit Amount in Account Currency',b'Luoton m\xc3\xa4\xc3\xa4r\xc3\xa4 Account Valuutta'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +603',b'BOM {0} must be submitted',b'Osaluettelo {0} pit\xc3\xa4\xc3\xa4 olla vahvistettu'
b'apps/erpnext/erpnext/config/accounts.py +460',b'Share Management',b'Jaa hallinta'
b'DocType: Authorization Control',b'Authorization Control',b'Valtuutus Ohjaus'
b'apps/erpnext/erpnext/controllers/buying_controller.py +317',b'Row #{0}: Rejected Warehouse is mandatory against rejected Item {1}',b'Rivi # {0}: Hyl\xc3\xa4tyt Warehouse on pakollinen vastaan hyl\xc3\xa4t\xc3\xa4\xc3\xa4n Tuote {1}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Payment',b'Maksu'
b'apps/erpnext/erpnext/controllers/stock_controller.py +92',"b'Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.'","b'Varasto {0} ei liity mihink\xc3\xa4\xc3\xa4n tilin, mainitse tilin varastoon kirjaa tai asettaa oletus inventaario huomioon yrityksen {1}.'"
b'apps/erpnext/erpnext/utilities/activation.py +81',b'Manage your orders',b'Hallitse tilauksia'
b'DocType: Work Order Operation',b'Actual Time and Cost',b'todellinen aika ja hinta'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56',b'Material Request of maximum {0} can be made for Item {1} against Sales Order {2}',b'Nimikkeelle {1} voidaan tehd\xc3\xa4 enint\xc3\xa4\xc3\xa4n {0} hankintapyynt\xc3\xb6\xc3\xa4 tilaukselle {2}'
b'DocType: Crop',b'Crop Spacing',b'Rajaa v\xc3\xa4li'
b'DocType: Course',b'Course Abbreviation',b'Course lyhenne'
b'DocType: Student Leave Application',b'Student Leave Application',b'Student J\xc3\xa4t\xc3\xa4 Application'
b'DocType: Item',b'Will also apply for variants',b'Sovelletaan my\xc3\xb6s tuotemalleissa'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +217',"b'Asset cannot be cancelled, as it is already {0}'","b'Asset ei voi peruuttaa, koska se on jo {0}'"
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29',b'Employee {0} on Half day on {1}',b'Ty\xc3\xb6ntekij\xc3\xa4n {0} Half p\xc3\xa4iv\xc3\xa4 {1}'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42',b'Total working hours should not be greater than max working hours {0}',b'Yhteens\xc3\xa4 ty\xc3\xb6aika ei saisi olla suurempi kuin max ty\xc3\xb6aika {0}'
b'apps/erpnext/erpnext/templates/pages/task_info.html +90',b'On',b'P\xc3\xa4\xc3\xa4ll\xc3\xa4'
b'apps/erpnext/erpnext/config/selling.py +62',b'Bundle items at time of sale.',b'Kootut nimikkeet myyntihetkell\xc3\xa4'
b'DocType: Material Request Plan Item',b'Actual Qty',b'kiinte\xc3\xa4 yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Sales Invoice Item',b'References',b'Viitteet'
b'DocType: Quality Inspection Reading',b'Reading 10',b'Lukema 10'
b'DocType: Item',b'Barcodes',b'viivakoodit'
b'DocType: Hub Category',b'Hub Node',b'hubi sidos'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78',b'You have entered duplicate items. Please rectify and try again.',b'Olet sy\xc3\xb6tt\xc3\xa4nyt kohteen joka on jo olemassa. Korjaa ja yrit\xc3\xa4 uudelleen.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129',b'Associate',b'kolleega'
b'DocType: Asset Movement',b'Asset Movement',b'Asset Movement'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508',b'Work Order {0} must be submitted',b'Ty\xc3\xb6j\xc3\xa4rjestys {0} on toimitettava'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2214',b'New Cart',b'uusi koriin'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44',b'Item {0} is not a serialized Item',b'Nimike {0} ei ole sarjoitettu tuote'
b'DocType: SMS Center',b'Create Receiver List',b'tee vastaanottajalista'
b'DocType: Vehicle',b'Wheels',b'Py\xc3\xb6r\xc3\xa4t'
b'DocType: Packing Slip',b'To Package No.',b'Pakkausnumeroon'
b'DocType: Patient Relation',b'Family',b'Perhe'
b'DocType: Production Plan',b'Material Requests',b'Hankintapyynn\xc3\xb6t'
b'DocType: Warranty Claim',b'Issue Date',b'Kirjauksen p\xc3\xa4iv\xc3\xa4ys'
b'DocType: Activity Cost',b'Activity Cost',b'aktiviteettikustannukset'
b'DocType: Sales Invoice Timesheet',b'Timesheet Detail',b'Tuntilomakkeen tiedot'
b'DocType: Purchase Receipt Item Supplied',b'Consumed Qty',b'k\xc3\xa4ytetty yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52',b'Telecommunications',b'Tietoliikenne'
b'apps/erpnext/erpnext/accounts/party.py +263',"b""Billing currency must be equal to either default company's currency or party account currency""",b'Laskutusvaluutan on vastattava joko yrityksen oletusvaluuttaa tai osapuolten tilin valuuttaa'
b'DocType: Packing Slip',b'Indicates that the package is a part of this delivery (Only Draft)',"b'osoittaa, pakkaus on vain osa t\xc3\xa4t\xc3\xa4 toimitusta (luonnos)'"
b'DocType: Soil Texture',b'Loam',b'savimaata'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +705',b'Row {0}: Due Date cannot be before posting date',b'Rivi {0}: er\xc3\xa4p\xc3\xa4iv\xc3\xa4 ei voi olla ennen l\xc3\xa4hett\xc3\xa4misp\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36',b'Make Payment Entry',b'tee maksukirjaus'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129',b'Quantity for Item {0} must be less than {1}',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 alamomentille {0} on oltava pienempi kuin {1}'
,b'Sales Invoice Trends',b'Myyntilaskujen kehitys'
b'DocType: Leave Application',b'Apply / Approve Leaves',b'k\xc3\xa4yt\xc3\xa4 / hyv\xc3\xa4ksy poistumiset'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'For',b'Varten'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167',"b""Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'""","b""rivi voi viitata edelliseen riviin vain jos maksu tyyppi on 'edellisen rivin arvom\xc3\xa4\xc3\xa4r\xc3\xa4' tai 'edellinen rivi yhteens\xc3\xa4'"""
b'DocType: Sales Order Item',b'Delivery Warehouse',b'toimitus varasto'
b'apps/erpnext/erpnext/config/accounts.py +241',b'Tree of financial Cost Centers.',b'Tree taloudellisen kustannuspaikat.'
b'DocType: Serial No',b'Delivery Document No',b'Toimitus Document No'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191',"b""Please set 'Gain/Loss Account on Asset Disposal' in Company {0}""",b'Aseta &#39;Gain / tuloslaskelma Omaisuudenhoitoalan h\xc3\xa4vitt\xc3\xa4misest\xc3\xa4 &quot;in Company {0}'
b'DocType: Landed Cost Voucher',b'Get Items From Purchase Receipts',b'hae tuotteet ostokuiteista'
b'DocType: Serial No',b'Creation Date',b'tekop\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33',b'Item {0} appears multiple times in Price List {1}',b'Nimike {0} on useampaan kertaan hinnastossa hinnastossa {1}'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41',"b'Selling must be checked, if Applicable For is selected as {0}'",b'Myynnin tulee olla t\xc3\xa4p\xc3\xa4ttyn\xc3\xa4 mik\xc3\xa4li saatavilla {0} on valittu'
b'DocType: Production Plan Material Request',b'Material Request Date',b'Tarvep\xc3\xa4iv\xc3\xa4'
b'DocType: Purchase Order Item',b'Supplier Quotation Item',b'Toimituskykytiedustelun tuote'
b'DocType: Student',b'Student Mobile Number',b'Student Mobile Number'
b'DocType: Item',b'Has Variants',b'useita tuotemalleja'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +488',"b'Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings'","b'Ei voida ylikirjoittaa rivikohta {0} {1} yli {2}. Jotta voit laskuttaa ylim\xc3\xa4\xc3\xa4r\xc3\xa4isen hinnan, aseta Tukosasetukset'"
b'apps/erpnext/erpnext/templates/emails/training_event.html +11',b'Update Response',b'P\xc3\xa4ivit\xc3\xa4 vastaus'
b'apps/erpnext/erpnext/public/js/utils.js +232',b'You have already selected items from {0} {1}',b'Olet jo valitut kohteet {0} {1}'
b'DocType: Monthly Distribution',b'Name of the Monthly Distribution',"b'toimitus kuukaudessa, nimi'"
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Er\xc3\xa4tunnuksesi on pakollinen'
b'DocType: Sales Person',b'Parent Sales Person',b'P\xc3\xa4\xc3\xa4myyj\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100',b'The seller and the buyer cannot be the same',b'Myyj\xc3\xa4 ja ostaja eiv\xc3\xa4t voi olla samat'
b'DocType: Project',b'Collect Progress',b'Ker\xc3\xa4\xc3\xa4 edistyst\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24',b'Select the program first',b'Valitse ensin ohjelma'
b'DocType: Patient Appointment',b'Patient Age',b'Potilaan ik\xc3\xa4'
b'apps/erpnext/erpnext/config/learn.py +253',b'Managing Projects',b'Toimitusjohtaja Projektit'
b'DocType: Supplier',b'Supplier of Goods or Services.',b'Tavara- tai palvelutoimittaja'
b'DocType: Budget',b'Fiscal Year',b'Tilikausi'
b'DocType: Asset Maintenance Log',b'Planned',b'suunnitellut'
b'DocType: Healthcare Settings',b'Default receivable accounts to be used if not set in Patient to book Consultation charges.',"b'Vahinkovakuutustilej\xc3\xa4 k\xc3\xa4ytet\xc3\xa4\xc3\xa4n, jos niit\xc3\xa4 ei ole asetettu potilaan kirjanpitoon.'"
b'DocType: Vehicle Log',b'Fuel Price',b'polttoaineen hinta'
b'DocType: Budget',b'Budget',b'budjetti'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65',b'Set Open',b'Aseta Avaa'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +258',b'Fixed Asset Item must be a non-stock item.',b'K\xc3\xa4ytt\xc3\xb6- omaisuuser\xc3\xa4n oltava ei-varastotuote.'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50',"b""Budget cannot be assigned against {0}, as it's not an Income or Expense account""","b'Talousarvio ei voi luovuttaa vastaan {0}, koska se ei ole tuottoa tai kulua tili'"
b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51',b'Achieved',b'saavutettu'
b'DocType: Student Admission',b'Application Form Route',b'Hakulomake Route'
b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66',b'Territory / Customer',b'Alue / Asiakas'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44',b'Leave Type {0} cannot be allocated since it is leave without pay',"b'J\xc3\xa4t\xc3\xa4 tyyppi {0} ei voi varata, koska se j\xc3\xa4tt\xc3\xa4\xc3\xa4 ilman palkkaa'"
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167',b'Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2}',b'rivi {0}: kohdennettavan arvom\xc3\xa4\xc3\xa4r\xc3\xa4n {1} on oltava pienempi tai yht\xc3\xa4 suuri kuin odottava arvom\xc3\xa4\xc3\xa4r\xc3\xa4 {2}'
b'DocType: Sales Invoice',b'In Words will be visible once you save the Sales Invoice.',"b'sanat n\xc3\xa4kyv\xc3\xa4t, kun tallennat myyntilaskun'"
b'DocType: Lead',b'Follow Up',b'Seuranta'
b'DocType: Item',b'Is Sales Item',b'on myyntituote'
b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21',b'Item Group Tree',b'tuoteryhm\xc3\xa4puu'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69',b'Item {0} is not setup for Serial Nos. Check Item master',"b'Nimikkeelle {0} ei m\xc3\xa4\xc3\xa4ritetty sarjanumeroita, t\xc3\xa4pp\xc3\xa4\xc3\xa4 tuote ty\xc3\xb6kalu'"
b'DocType: Maintenance Visit',b'Maintenance Time',"b'huolto, aika'"
,b'Amount to Deliver',b'toimitettava arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335',b'Same item has been entered multiple times. {0}',b'Sama kohde on sy\xc3\xb6tetty useita kertoja. {0}'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30',b'The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',b'Term alkamisp\xc3\xa4iv\xc3\xa4 ei voi olla aikaisempi kuin vuosi alkamisp\xc3\xa4iv\xc3\xa4 Lukuvuoden johon termi\xc3\xa4 liittyy (Lukuvuosi {}). Korjaa p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4t ja yrit\xc3\xa4 uudelleen.'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190',b'There were errors.',b'Oli virheit\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166',b'Employee {0} has already applied for {1} between {2} and {3} : ',b'Ty\xc3\xb6ntekij\xc3\xa4 {0} on jo hakenut {1} v\xc3\xa4lill\xc3\xa4 {2} ja {3}:'
b'DocType: Guardian',b'Guardian Interests',b'Guardian Harrastukset'
b'DocType: Naming Series',b'Current Value',b'Nykyinen arvo'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +273',b'Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year',b'Useita verovuoden olemassa p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4n {0}. M\xc3\xa4\xc3\xa4rit\xc3\xa4 yritys verovuonna'
b'DocType: Education Settings',b'Instructor Records to be created by',b'Ohjaajan rekisterit luodaan'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229',b'{0} created',b'tehnyt {0}'
b'DocType: GST Account',b'GST Account',b'GST-tili'
b'DocType: Delivery Note Item',b'Against Sales Order',b'myyntitilauksen kohdistus'
,b'Serial No Status',b'Sarjanumero tila'
b'DocType: Payment Entry Reference',b'Outstanding',b'maksamatta'
b'DocType: Supplier',b'Warn POs',b'Varoittaa PO: t'
,b'Daily Timesheet Summary',b'P\xc3\xa4ivitt\xc3\xa4inen tuntilomakeyhteenveto'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137',"b'Row {0}: To set {1} periodicity, difference between from and to date \\\n\t\t\t\t\t\tmust be greater than or equal to {2}'",b'rivi {0}: asettaaksesi {1} kausituksen aloitus ja p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4n ero \\ tulee olla suurempi tai yht\xc3\xa4 suuri kuin {2}'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6',b'This is based on stock movement. See {0} for details',b'Varastotapahtumat. {0} sis\xc3\xa4lt\xc3\xa4\xc3\xa4 tiedot tapahtumista.'
b'DocType: Pricing Rule',b'Selling',b'Myynti'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392',b'Amount {0} {1} deducted against {2}',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 {0} {1} v\xc3\xa4hennet\xc3\xa4\xc3\xa4n vastaan {2}'
b'DocType: Employee',b'Salary Information',b'Palkkatietoja'
b'DocType: Sales Person',b'Name and Employee ID',b'Nimi ja Ty\xc3\xb6ntekij\xc3\xa4n ID'
b'apps/erpnext/erpnext/accounts/party.py +308',b'Due Date cannot be before Posting Date',b'Er\xc3\xa4p\xc3\xa4iv\xc3\xa4 voi olla ennen tositep\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'DocType: Website Item Group',b'Website Item Group',b'Tuoteryhm\xc3\xa4n verkkosivu'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463',b'No salary slip found to submit for the above selected criteria OR salary slip already submitted',"b'Mit\xc3\xa4\xc3\xa4n palkkalippua, jonka todettiin j\xc3\xa4tt\xc3\xa4v\xc3\xa4n edell\xc3\xa4 mainittujen kriteerien tai palkkasumman perusteella'"
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150',b'Duties and Taxes',b'tullit ja verot'
b'DocType: Projects Settings',b'Projects Settings',b'Projektit-asetukset'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356',b'Please enter Reference date',b'Anna Viiteajankohta'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44',b'{0} payment entries can not be filtered by {1}',b'{0} maksukirjauksia ei voida suodattaa {1}:lla'
b'DocType: Item Website Specification',b'Table for Item that will be shown in Web Site',b'Verkkosivuilla n\xc3\xa4kyvien tuotteiden taulukko'
b'DocType: Purchase Order Item Supplied',b'Supplied Qty',b'yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 toimitettu'
b'DocType: Purchase Order Item',b'Material Request Item',b'Hankintapyynt\xc3\xb6nimike'
b'apps/erpnext/erpnext/config/selling.py +75',b'Tree of Item Groups.',b'tuoteryhmien puu'
b'DocType: Production Plan',b'Total Produced Qty',b'Kokonaistuotanto'
b'DocType: Payroll Entry',b'Get Employee Details',b'Hanki ty\xc3\xb6ntekij\xc3\xa4n tiedot'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177',b'Cannot refer row number greater than or equal to current row number for this Charge type',"b'rivi ei voi viitata nykyist\xc3\xa4 suurempaan tai nykyisen rivin numeroon, vaihda maksun tyyppi\xc3\xa4'"
b'DocType: Asset',b'Sold',b'Myyty'
,b'Item-wise Purchase History',b'Nimikkeen ostohistoria'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230',"b""Please click on 'Generate Schedule' to fetch Serial No added for Item {0}""","b'klikkaa ""muodosta aikataulu"" ja sy\xc3\xb6t\xc3\xa4 tuotteen sarjanumero {0}'"
b'DocType: Account',b'Frozen',b'j\xc3\xa4\xc3\xa4dytetty'
b'DocType: Sales Invoice Payment',b'Base Amount (Company Currency)',b'Base M\xc3\xa4\xc3\xa4r\xc3\xa4 (Company valuutta)'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928',b'Raw Materials',b'Raakamateriaalit'
b'DocType: Payment Reconciliation Payment',b'Reference Row',b'Viite Row'
b'DocType: Installation Note',b'Installation Time',b'asennus aika'
b'DocType: Sales Invoice',b'Accounting Details',b'Kirjanpito Lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +113',b'Delete all the Transactions for this Company',b'poista kaikki tapahtumat t\xc3\xa4lt\xc3\xa4 yritykselt\xc3\xa4'
b'DocType: Patient',b'O Positive',b'O Positiivinen'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68',b'Investments',b'sijoitukset'
b'DocType: Issue',b'Resolution Details',b'Ratkaisun lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3',b'Allocations',b'm\xc3\xa4\xc3\xa4r\xc3\xa4rahat'
b'DocType: Item Quality Inspection Parameter',b'Acceptance Criteria',b'hyv\xc3\xa4ksymiskriteerit'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159',b'Please enter Material Requests in the above table',b'Sy\xc3\xb6t\xc3\xa4 hankintapyynn\xc3\xb6t yll\xc3\xa4 olevaan taulukkoon'
b'DocType: Item Attribute',b'Attribute Name',"b'tuntomerkki, nimi'"
b'DocType: BOM',b'Show In Website',b'n\xc3\xa4yt\xc3\xa4 verkkosivustossa'
b'DocType: Shopping Cart Settings',b'Show Quantity in Website',b'N\xc3\xa4yt\xc3\xa4 M\xc3\xa4\xc3\xa4r\xc3\xa4 Website'
b'DocType: Employee Loan Application',b'Total Payable Amount',b'Yhteens\xc3\xa4 Maksettava m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Task',b'Expected Time (in hours)',b'odotettu aika (tunteina)'
b'DocType: Item Reorder',b'Check in (group)',b'Check in (ryhm\xc3\xa4)'
b'DocType: Soil Texture',b'Silt',b'liete'
,b'Qty to Order',b'Tilattava yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Period Closing Voucher',"b'The account head under Liability or Equity, in which Profit/Loss will be booked'","b'Tilin p\xc3\xa4\xc3\xa4ns\xc3\xa4 velan tai oman p\xc3\xa4\xc3\xa4oman, jossa voitto / tappio kirjataan'"
b'apps/erpnext/erpnext/config/projects.py +36',b'Gantt chart of all tasks.',b'gantt kaavio kaikista teht\xc3\xa4vist\xc3\xa4'
b'DocType: Opportunity',b'Mins to First Response',b'Vastausaika (min)'
b'DocType: Pricing Rule',b'Margin Type',b'marginaali Tyyppi'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15',b'{0} hours',b'{0} tuntia'
b'DocType: Course',b'Default Grading Scale',b'Oletus Arvosteluasteikko'
b'DocType: Appraisal',b'For Employee Name',b'Ty\xc3\xb6ntekij\xc3\xa4n nimeen'
b'DocType: Holiday List',b'Clear Table',b'tyhjenn\xc3\xa4 taulukko'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119',b'Available slots',b'K\xc3\xa4ytett\xc3\xa4viss\xc3\xa4 olevat paikat'
b'DocType: C-Form Invoice Detail',b'Invoice No',b'laskun nro'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363',b'Make Payment',b'Maksaa'
b'DocType: Room',b'Room Name',b'huoneen nimi'
b'DocType: Prescription Duration',b'Prescription Duration',b'Reseptikesto'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81',"b'Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Vapaita ei voida k\xc3\xa4ytt\xc3\xa4\xc3\xa4 / peruuttaa ennen {0}, koska k\xc3\xa4ytett\xc3\xa4viss\xc3\xa4 olevat vapaat on jo siirretty eteenp\xc3\xa4in jaksolle {1}'"
b'DocType: Activity Cost',b'Costing Rate',"b'kustannuslaskenta, taso'"
b'apps/erpnext/erpnext/config/selling.py +234',b'Customer Addresses And Contacts',b'Asiakkaan osoitteet ja yhteystiedot'
,b'Campaign Efficiency',b'Kampanjan tehokkuus'
b'DocType: Discussion',b'Discussion',b'keskustelu'
b'DocType: Payment Entry',b'Transaction ID',b'Transaction ID'
b'DocType: Volunteer',b'Anytime',b'Milloin tahansa'
b'DocType: Patient',b'Surgical History',b'Kirurginen historia'
b'DocType: Employee',b'Resignation Letter Date',b'Eropyynn\xc3\xb6n p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39',b'Pricing Rules are further filtered based on quantity.',b'Hinnoittelus\xc3\xa4\xc3\xa4nn\xc3\xb6t on suodatettu m\xc3\xa4\xc3\xa4r\xc3\xa4n mukaan'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127',b'Not Set',b'Ei asetettu'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Aseta jolloin se liittyy ty\xc3\xb6ntekij\xc3\xb6iden {0}'
b'DocType: Task',b'Total Billing Amount (via Time Sheet)',b'Total Billing M\xc3\xa4\xc3\xa4r\xc3\xa4 (via Time Sheet)'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61',b'Repeat Customer Revenue',b'Toistuvien asiakkuuksien liikevaihto'
b'DocType: Soil Texture',b'Silty Clay Loam',b'Silty Clay Loam'
b'DocType: Chapter',b'Chapter',b'luku'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Pair',b'Pari'
b'DocType: Mode of Payment Account',b'Default account will be automatically updated in POS Invoice when this mode is selected.',"b'Oletus tili p\xc3\xa4ivitet\xc3\xa4\xc3\xa4n automaattisesti POS-laskuun, kun t\xc3\xa4m\xc3\xa4 tila on valittu.'"
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970',b'Select BOM and Qty for Production',b'Valitse BOM ja M\xc3\xa4\xc3\xa4r\xc3\xa4 Tuotannon'
b'DocType: Asset',b'Depreciation Schedule',b'Poistot aikataulu'
b'apps/erpnext/erpnext/config/selling.py +124',b'Sales Partner Addresses And Contacts',b'-myyj\xc3\xa4\xc3\xa4n osoitteista ja yhteystiedoista'
b'DocType: Bank Reconciliation Detail',b'Against Account',b'tili kohdistus'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52',b'Half Day Date should be between From Date and To Date',b'Half Day Date pit\xc3\xa4isi olla v\xc3\xa4lill\xc3\xa4 P\xc3\xa4iv\xc3\xa4st\xc3\xa4 ja P\xc3\xa4iv\xc3\xa4\xc3\xa4n'
b'DocType: Maintenance Schedule Detail',b'Actual Date',b'todellinen p\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139',b'Please set the Default Cost Center in {0} company.',b'Aseta oletuskustannuspaikka {0} yrityksess\xc3\xa4.'
b'DocType: Item',b'Has Batch No',b'on er\xc3\xa4 nro'
b'apps/erpnext/erpnext/public/js/utils.js +106',b'Annual Billing: {0}',b'Vuotuinen laskutus: {0}'
b'apps/erpnext/erpnext/config/accounts.py +200',b'Goods and Services Tax (GST India)',b'Tavarat ja palvelut Tax (GST Intia)'
b'DocType: Delivery Note',b'Excise Page Number',b'poisto sivunumero'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227',"b'Company, From Date and To Date is mandatory'","b'Company, P\xc3\xa4iv\xc3\xa4st\xc3\xa4 ja P\xc3\xa4iv\xc3\xa4\xc3\xa4n on pakollinen'"
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33',b'Get from Consultation',b'Hae neuvotteluista'
b'DocType: Asset',b'Purchase Date',b'Ostop\xc3\xa4iv\xc3\xa4'
b'DocType: Volunteer',b'Volunteer Type',b'Vapaaehtoisty\xc3\xb6'
b'DocType: Student',b'Personal Details',b'Henkil\xc3\xb6kohtaiset lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193',"b""Please set 'Asset Depreciation Cost Center' in Company {0}""",b'Ole hyv\xc3\xa4 ja aseta yrityksen {0} poistojen kustannuspaikka.'
,b'Maintenance Schedules',b'huoltoaikataulut'
b'DocType: Task',b'Actual End Date (via Time Sheet)',b'Todellinen Lopetusp\xc3\xa4iv\xc3\xa4 (via kellokortti)'
b'DocType: Soil Texture',b'Soil Type',b'Maaper\xc3\xa4tyyppi'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387',b'Amount {0} {1} against {2} {3}',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 {0} {1} vastaan {2} {3}'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277',b'New Message',b'Uusi viesti'
,b'Quotation Trends',b'Tarjousten kehitys'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160',b'Item Group not mentioned in item master for item {0}',b'tuotteen {0} tuoteryhm\xc3\xa4\xc3\xa4 ei ole mainittu kohdassa tuote ty\xc3\xb6kalu'
b'DocType: GoCardless Mandate',b'GoCardless Mandate',b'GoCardless Mandate'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368',b'Debit To account must be a Receivable account',b'tilin debet tulee olla saatava tili'
b'DocType: Shipping Rule',b'Shipping Amount',b'Toimituskustannus arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Supplier Scorecard Period',b'Period Score',b'Ajanjakso'
b'apps/erpnext/erpnext/utilities/user_progress.py +66',b'Add Customers',b'Lis\xc3\xa4\xc3\xa4 Asiakkaat'
b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Pending Amount',b'Odottaa arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Lab Test Template',b'Special',b'erityinen'
b'DocType: Purchase Order Item Supplied',b'Conversion Factor',b'muuntokerroin'
b'DocType: Purchase Order',b'Delivered',b'toimitettu'
,b'Vehicle Expenses',b'ajoneuvojen kulut'
b'DocType: Serial No',b'Invoice Details',b'laskun tiedot'
b'DocType: Grant Application',b'Show on Website',b'N\xc3\xa4yt\xc3\xa4 verkkosivustolla'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +212',b'Expected value after useful life must be greater than or equal to {0}',"b'Odotettu arvo sen j\xc3\xa4lkeen, kun k\xc3\xa4ytt\xc3\xb6i\xc3\xa4n on oltava suurempi tai yht\xc3\xa4 suuri kuin {0}'"
b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29',b'Start on',b'Aloita'
b'DocType: Hub Category',b'Hub Category',b'Hub-luokka'
b'DocType: Purchase Invoice',b'SEZ',b'SEZ'
b'DocType: Purchase Receipt',b'Vehicle Number',b'Ajoneuvon rekisterinumero'
b'DocType: Employee Loan',b'Loan Amount',b'Lainan m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Student Report Generation Tool',b'Add Letterhead',b'Lis\xc3\xa4\xc3\xa4 kirjelomake'
b'DocType: Program Enrollment',b'Self-Driving Vehicle',b'Itsest\xc3\xa4\xc3\xa4n kulkevaa ajoneuvoa'
b'DocType: Supplier Scorecard Standing',b'Supplier Scorecard Standing',b'Toimittajan sijoitus'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443',b'Row {0}: Bill of Materials not found for the Item {1}',b'Rivi {0}: osaluettelosi ei l\xc3\xb6ytynyt Tuote {1}'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98',b'Total allocated leaves {0} cannot be less than already approved leaves {1} for the period',b'Yhteens\xc3\xa4 my\xc3\xb6nnetty lehdet {0} ei voi olla pienempi kuin jo hyv\xc3\xa4ksytty lehdet {1} kaudeksi'
b'DocType: Journal Entry',b'Accounts Receivable',b'saatava tilit'
,b'Supplier-Wise Sales Analytics',b'Toimittajakohtainen myyntianalytiikka'
b'DocType: Purchase Invoice',b'Availed ITC Central Tax',b'K\xc3\xa4ytti ITC: n keskusveroa'
b'DocType: Salary Structure',b'Select employees for current Salary Structure',b'Valitse ty\xc3\xb6ntekij\xc3\xb6it\xc3\xa4 nykyist\xc3\xa4 Palkkarakenne'
b'DocType: Sales Invoice',b'Company Address Name',b'Yrityksen Osoite Nimi'
b'DocType: Work Order',b'Use Multi-Level BOM',b'K\xc3\xa4yt\xc3\xa4 monitasoista osaluetteloa'
b'DocType: Bank Reconciliation',b'Include Reconciled Entries',b'sis\xc3\xa4llyt\xc3\xa4 t\xc3\xa4sm\xc3\xa4tyt kirjaukset'
b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Vanhemman Course (J\xc3\xa4t\xc3\xa4 tyhj\xc3\xa4ksi, jos t\xc3\xa4m\xc3\xa4 ei ole osa emoyhti\xc3\xb6n Course)'"
b'DocType: Leave Control Panel',b'Leave blank if considered for all employee types',b'tyhj\xc3\xa4 mik\xc3\xa4li se pidet\xc3\xa4\xc3\xa4n vaihtoehtona  kaikissa ty\xc3\xb6ntekij\xc3\xa4 tyypeiss\xc3\xa4'
b'DocType: Landed Cost Voucher',b'Distribute Charges Based On',b'toimitusmaksut perustuen'
b'DocType: Projects Settings',b'Timesheets',b'Tuntilomakkeet'
b'DocType: HR Settings',b'HR Settings',b'Henkil\xc3\xb6st\xc3\xb6hallinnan m\xc3\xa4\xc3\xa4ritykset'
b'DocType: Salary Slip',b'net pay info',b'nettopalkka info'
b'DocType: Lab Test Template',b'This value is updated in the Default Sales Price List.',b'T\xc3\xa4m\xc3\xa4 arvo p\xc3\xa4ivitet\xc3\xa4\xc3\xa4n oletusmyyntihinnassa.'
b'DocType: Email Digest',b'New Expenses',b'Uudet kustannukset'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79',b'PDC/LC Amount',b'PDC / LC-m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Shareholder',b'Shareholder',b'osakas'
b'DocType: Purchase Invoice',b'Additional Discount Amount',b'Lis\xc3\xa4alennus'
b'DocType: Cash Flow Mapper',b'Position',b'asento'
b'DocType: Patient',b'Patient Details',b'Potilastiedot'
b'DocType: Patient',b'B Positive',b'B Positiivinen'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +596',"b'Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.'","b'Rivi # {0}: M\xc3\xa4\xc3\xa4r\xc3\xa4 on 1, kun kohde on kiinte\xc3\xa4n omaisuuden. K\xc3\xa4yt\xc3\xa4 erillist\xc3\xa4 rivi useita kpl.'"
b'DocType: Leave Block List Allow',b'Leave Block List Allow',b'Salli'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +317',b'Abbr can not be blank or space',b'lyhenne ei voi olla tyhj\xc3\xa4 tai v\xc3\xa4lily\xc3\xb6nti'
b'DocType: Patient Medical Record',b'Patient Medical Record',b'Potilaan l\xc3\xa4\xc3\xa4ketieteellinen tietue'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +68',b'Group to Non-Group',b'Ryhm\xc3\xa4 Non-ryhm\xc3\xa4n'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50',b'Sports',b'urheilu'
b'DocType: Loan Type',b'Loan Name',b'laina Name'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Actual',b'Kiinte\xc3\xa4 summa yhteens\xc3\xa4'
b'DocType: Lab Test UOM',b'Test UOM',b'Testaa UOM'
b'DocType: Student Siblings',b'Student Siblings',b'Student Sisarukset'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Unit',b'Yksikk\xc3\xb6'
b'apps/erpnext/erpnext/stock/get_item_details.py +138',b'Please specify Company',b'Ilmoitathan Company'
,b'Customer Acquisition and Loyalty',b'asiakashankinta ja suhteet'
b'DocType: Asset Maintenance Task',b'Maintenance Task',b'Huolto Teht\xc3\xa4v\xc3\xa4'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118',b'Please set B2C Limit in GST Settings.',b'Aseta B2C-raja GST-asetuksissa.'
b'DocType: Purchase Invoice',b'Warehouse where you are maintaining stock of rejected items',b'Hylkyvarasto'
b'DocType: Work Order',b'Skip Material Transfer',b'Ohita varastosiirto'
b'apps/erpnext/erpnext/setup/utils.py +109',b'Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually',b'Pysty l\xc3\xb6yt\xc3\xa4m\xc3\xa4\xc3\xa4n vaihtokurssi {0} ja {1} avaimen p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 {2}. Luo Valuutanvaihto enn\xc3\xa4tys manuaalisesti'
b'DocType: POS Profile',b'Price List',b'Hinnasto'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22',b'{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.',"b'{0} on nyt oletustilikausi. Lataa selaimesi uudelleen, jotta muutokset tulevat voimaan.'"
b'apps/erpnext/erpnext/projects/doctype/task/task.js +45',b'Expense Claims',b'Kulukorvaukset'
b'DocType: Issue',b'Support',b'Tuki'
,b'BOM Search',b'BOM-haku'
b'DocType: Project',b'Total Consumed Material Cost  (via Stock Entry)',b'Kulutettu kokonaiskustannus (osakem\xc3\xa4\xc3\xa4r\xc3\xa4ll\xc3\xa4)'
b'DocType: Item',"b'Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.'",b'Julkaise &quot;Varastossa&quot; tai &quot;Ei varastossa&quot; Hubissa t\xc3\xa4m\xc3\xa4n varaston varastosta.'
b'DocType: Vehicle',b'Fuel Type',b'Polttoaine'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27',b'Please specify currency in Company',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 yrityksen valuutta'
b'DocType: Workstation',b'Wages per hour',b'Tuntipalkat'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47',b'Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}',b'Er\xc3\xa4n varastotase {0} muuttuu negatiiviseksi {1} tuotteelle {2} varastossa {3}'
b'apps/erpnext/erpnext/templates/emails/reorder_item.html +1',"b""Following Material Requests have been raised automatically based on Item's re-order level""",b'Seuraavat hankintapyynn\xc3\xb6t luotu tilauspisteen mukaisesti'
b'DocType: Email Digest',b'Pending Sales Orders',b'Odottaa Myyntitilaukset'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +312',b'Account {0} is invalid. Account Currency must be {1}',b'Tili {0} ei kelpaa. Tilin valuutan on oltava {1}'
b'DocType: Healthcare Settings',b'Remind Before',b'Muistuta ennen'
b'apps/erpnext/erpnext/buying/utils.py +34',b'UOM Conversion factor is required in row {0}',b'Mittayksik\xc3\xb6n muuntokerroin vaaditaan rivill\xc3\xa4 {0}'
b'DocType: Production Plan Item',b'material_request_item',b'material_request_item'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087',"b'Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry'","b'Rivi # {0}: Reference Document Type on yksi myyntitilaus, myyntilasku tai P\xc3\xa4iv\xc3\xa4kirjakirjaus'"
b'DocType: Salary Component',b'Deduction',b'v\xc3\xa4hennys'
b'DocType: Item',b'Retain Sample',b'S\xc3\xa4ilyt\xc3\xa4 n\xc3\xa4yte'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115',b'Row {0}: From Time and To Time is mandatory.',b'Rivi {0}: From Time ja Kellonaikatilaan on pakollista.'
b'DocType: Stock Reconciliation Item',b'Amount Difference',b'm\xc3\xa4\xc3\xa4r\xc3\xa4 ero'
b'apps/erpnext/erpnext/stock/get_item_details.py +356',b'Item Price added for {0} in Price List {1}',"b""Nimikkeen '{0}' hinta lis\xc3\xa4tty hinnastolle '{1}'"""
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8',b'Please enter Employee Id of this sales person',b'Sy\xc3\xb6t\xc3\xa4 ty\xc3\xb6ntekij\xc3\xa4tunnu t\xc3\xa4lle myyj\xc3\xa4lle'
b'DocType: Territory',b'Classification of Customers by region',b'asiakkaiden luokittelu alueittain'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71',b'In Production',b'Tuotannossa'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65',b'Difference Amount must be zero',b'Ero m\xc3\xa4\xc3\xa4r\xc3\xa4 on nolla'
b'DocType: Project',b'Gross Margin',b'bruttokate'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61',b'Please enter Production Item first',b'Sy\xc3\xb6t\xc3\xa4 ensin tuotantotuote'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45',b'Calculated Bank Statement balance',b'Laskettu tilin saldo'
b'DocType: Normal Test Template',b'Normal Test Template',b'Normaali testausmalli'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64',b'disabled user',b'k\xc3\xa4ytt\xc3\xa4j\xc3\xa4 poistettu k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919',b'Quotation',b'Tarjous'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984',b'Cannot set a received RFQ to No Quote',b'Vastaanotettua pyynt\xc3\xb6\xc3\xa4 ei voi m\xc3\xa4\xc3\xa4ritt\xc3\xa4\xc3\xa4 Ei lainkaan'
b'DocType: Quotation',b'QTN-',b'QTN-'
b'DocType: Salary Slip',b'Total Deduction',b'V\xc3\xa4hennys yhteens\xc3\xa4'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18',b'Select an account to print in account currency',"b'Valitse tili, jonka haluat tulostaa tilin valuuttana'"
,b'Production Analytics',b'Tuotanto-analytiikka'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6',b'This is based on transactions against this Patient. See timeline below for details',b'T\xc3\xa4m\xc3\xa4 perustuu potilaaseen kohdistuviin liiketoimiin. Katso lis\xc3\xa4tietoja alla olevasta aikataulusta'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204',b'Cost Updated',b'kustannukset p\xc3\xa4ivitetty'
b'DocType: Patient',b'Date of Birth',b'Syntym\xc3\xa4p\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133',b'Item {0} has already been returned',b'Nimike {0} on palautettu'
b'DocType: Fiscal Year',b'**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.',b'**tilikausi** sis\xc3\xa4lt\xc3\xa4\xc3\xa4 kaikki sen kuluessa kirjatut kirjanpito- ym. taloudenhallinnan tapahtumat'
b'DocType: Opportunity',b'Customer / Lead Address',b'Asiakkaan / Liidin osoite'
b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Setup',b'Toimittajan tuloskortin asetukset'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133',b'Assessment Plan Name',b'Arviointisuunnitelman nimi'
b'DocType: Work Order Operation',b'Work Order Operation',b'Ty\xc3\xb6j\xc3\xa4rjestyksen toiminta'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +233',b'Warning: Invalid SSL certificate on attachment {0}',b'Varoitus: Liitteen {0} SSL-varmenne ei kelpaa'
b'apps/erpnext/erpnext/utilities/activation.py +64',"b'Leads help you get business, add all your contacts and more as your leads'",b'Liidien avulla liiketoimintaasi ja kontaktiesi m\xc3\xa4\xc3\xa4r\xc3\xa4 kasvaa ja niist\xc3\xa4 syntyy uusia mahdollisuuksia'
b'DocType: Work Order Operation',b'Actual Operation Time',b'todellinen toiminta-aika'
b'DocType: Authorization Rule',b'Applicable To (User)',b'sovellettavissa (k\xc3\xa4ytt\xc3\xa4j\xc3\xa4)'
b'DocType: Purchase Taxes and Charges',b'Deduct',b'v\xc3\xa4hent\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238',b'Job Description',b'ty\xc3\xb6n kuvaus'
b'DocType: Student Applicant',b'Applied',b'soveltava'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874',b'Re-open',b'Avaa uudelleen'
b'DocType: Sales Invoice Item',b'Qty as per Stock UOM',b'Yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 / varastoyksikk\xc3\xb6'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59',b'Guardian2 Name',b'Guardian2 Name'
b'DocType: Purchase Invoice',b'02-Post Sale Discount',b'02-Post Sale alennus'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132',"b'Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series'","b'erikoismerkit ""-"", ""#"", ""."" ja ""/"" ei ole sallittuja sarjojen nime\xc3\xa4misess\xc3\xa4'"
b'DocType: Campaign',"b'Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.'","b'seuraa myyntikampankoita, seuraa vihjeit\xc3\xa4, -tarjouksia, myyntitilauksia ym mitataksesi kampanjaan sijoitetun p\xc3\xa4\xc3\xa4oman tuoton'"
,b'SO Qty',b'Myyntitilaukset yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91',b'The field To Shareholder cannot be blank',b'Kent\xc3\xa4n osakkeenomistaja ei voi olla tyhj\xc3\xa4'
b'DocType: Guardian',b'Work Address',b'Ty\xc3\xb6osoite'
b'DocType: Appraisal',b'Calculate Total Score',b'Laske yhteispisteet'
b'DocType: Health Insurance',b'Health Insurance',b'Terveysvakuutus'
b'DocType: Asset Repair',b'Manufacturing Manager',b'Valmistus yll\xc3\xa4pit\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191',b'Serial No {0} is under warranty upto {1}',b'Sarjanumerolla {0} on takuu {1} asti'
b'DocType: Plant Analysis Criteria',b'Minimum Permissible Value',b'Pienin sallittu arvo'
b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41',b'User {0} already exists',b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4 {0} on jo olemassa'
b'apps/erpnext/erpnext/hooks.py +109',b'Shipments',b'Toimitukset'
b'DocType: Payment Entry',b'Total Allocated Amount (Company Currency)',b'Yhteens\xc3\xa4 jaettava m\xc3\xa4\xc3\xa4r\xc3\xa4 (Company valuutta)'
b'DocType: Purchase Order Item',b'To be delivered to customer',b'Toimitetaan asiakkaalle'
b'DocType: BOM',b'Scrap Material Cost',b'Romu ainekustannukset'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227',b'Serial No {0} does not belong to any Warehouse',b'Sarjanumero {0} ei kuulu mihink\xc3\xa4\xc3\xa4n Warehouse'
b'DocType: Grant Application',b'Email Notification Sent',b'S\xc3\xa4hk\xc3\xb6postiviesti l\xc3\xa4hetetty'
b'DocType: Purchase Invoice',b'In Words (Company Currency)',b'sanat (yrityksen valuutta)'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018',"b'Item Code, warehouse, quantity are required on row'","b'Rivikohtainen koodi, varasto, m\xc3\xa4\xc3\xa4r\xc3\xa4 vaaditaan'"
b'DocType: Pricing Rule',b'Supplier',b'Toimittaja'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41',b'Show Payment Details',b'N\xc3\xa4yt\xc3\xa4 maksutiedot'
b'DocType: Consultation',b'Consultation Time',b'Kuuleminen'
b'DocType: C-Form',b'Quarter',b'3 kk'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106',b'Miscellaneous Expenses',b'Sekalaiset kustannukset'
b'DocType: Global Defaults',b'Default Company',b'oletus yritys'
b'apps/erpnext/erpnext/controllers/stock_controller.py +227',b'Expense or Difference account is mandatory for Item {0} as it impacts overall stock value',b'Kustannus- / erotuksen tili vaaditaan tuotteelle {0} sill\xc3\xa4 se vaikuttaa varastoarvoon'
b'DocType: Payment Request',b'PR',b'PR'
b'DocType: Cheque Print Template',b'Bank Name',b'pankin nimi'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30',b'-Above',b'-yll\xc3\xa4'
b'DocType: Employee Loan',b'Employee Loan Account',b'Ty\xc3\xb6ntekij\xc3\xa4n lainatilin'
b'DocType: Leave Application',b'Total Leave Days',"b'Poistumisten yhteism\xc3\xa4\xc3\xa4r\xc3\xa4, p\xc3\xa4iv\xc3\xa4t'"
b'DocType: Email Digest',b'Note: Email will not be sent to disabled users',b'huom: s\xc3\xa4hk\xc3\xb6postia ei l\xc3\xa4hetet\xc3\xa4 k\xc3\xa4yt\xc3\xb6st\xc3\xa4 poistetuille k\xc3\xa4ytt\xc3\xa4jille'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Lukum\xc3\xa4\xc3\xa4r\xc3\xa4 Vuorovaikutus'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +105',b'Item Variant Settings',b'Kohta Variant-asetukset'
b'apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37',b'Select Company...',b'Valitse yritys...'
b'DocType: Leave Control Panel',b'Leave blank if considered for all departments',b'tyhj\xc3\xa4 mik\xc3\xa4li se pidet\xc3\xa4\xc3\xa4n vaihtoehtona kaikilla osastoilla'
b'apps/erpnext/erpnext/config/hr.py +228',"b'Types of employment (permanent, contract, intern etc.).'","b'ty\xc3\xb6sopimuksen tyypit (jatkuva, sopimus, sis\xc3\xa4inen jne)'"
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434',b'{0} is mandatory for Item {1}',b'{0} on pakollinen tuotteelle {1}'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136',"b'Item {0}: {1} qty produced, '","b'Tuote {0}: {1} qty tuotettu,'"
b'DocType: Payroll Entry',b'Fortnightly',b'joka toinen viikko'
b'DocType: Currency Exchange',b'From Currency',b'valuutasta'
b'DocType: Vital Signs',b'Weight (In Kilogram)',b'Paino (kilogrammoina)'
b'DocType: Chapter',b'chapters/chapter_name\nleave blank automatically set after saving chapter.',b'luvut / luku_nimi j\xc3\xa4tt\xc3\xa4\xc3\xa4 tyhj\xc3\xa4ksi automaattisesti asetetun luvun tallentamisen j\xc3\xa4lkeen.'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202',b'Please set GST Accounts in GST Settings',b'Aseta GST-tilit GST-asetuksissa'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31',b'Type of Business',b'Liiketoiminnan tyyppi'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171',"b'Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row'","b'Valitse kohdennettava arvom\xc3\xa4\xc3\xa4r\xc3\xa4, laskun tyyppi ja laskun numero v\xc3\xa4hint\xc3\xa4\xc3\xa4n yhdelle riville'"
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128',b'Cost of New Purchase',b'Kustannukset New Purchase'
b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35',b'All tasks for the detected diseases were imported',b'Kaikki havaittujen tautien teht\xc3\xa4v\xc3\xa4t tuodaan maahan'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97',b'Sales Order required for Item {0}',b'Myyntitilaus vaaditaan tuotteelle {0}'
b'DocType: Grant Application',b'Grant Description',b'Avustuksen kuvaus'
b'DocType: Purchase Invoice Item',b'Rate (Company Currency)',b'hinta (yrityksen valuutassa)'
b'DocType: Student Guardian',b'Others',b'Muut'
b'DocType: Payment Entry',b'Unallocated Amount',b'Kohdistamattomat M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/templates/includes/product_page.js +91',b'Cannot find a matching Item. Please select some other value for {0}.',b'Nimikett\xc3\xa4 ei l\xc3\xb6ydy. Valitse jokin muu arvo {0}.'
b'DocType: POS Profile',b'Taxes and Charges',b'Verot ja maksut'
b'DocType: Item',"b'A Product or a Service that is bought, sold or kept in stock.'","b'tavara tai palvelu joka ostetaan, myyd\xc3\xa4\xc3\xa4n tai varastoidaan'"
b'apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44',b'No more updates',b'Ei en\xc3\xa4\xc3\xa4 p\xc3\xa4ivityksi\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171',"b""Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row""","b""ei voi valita maksun tyyppi\xc3\xa4, kuten 'edellisen rivin arvom\xc3\xa4\xc3\xa4r\xc3\xa4' tai 'edellinen rivi yhteens\xc3\xa4' ensimm\xc3\xa4iseksi riviksi"""
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6',b'This covers all scorecards tied to this Setup',b'T\xc3\xa4m\xc3\xa4 kattaa kaikki t\xc3\xa4m\xc3\xa4n asetusten sidotut tuloskartat'
b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29',b'Child Item should not be a Product Bundle. Please remove item `{0}` and save',b'Tuotepaketti ei voi sis\xc3\xa4lt\xc3\xa4\xc3\xa4 nimikett\xc3\xa4 joka on tuotepaketti. Poista nimike `{0}` ja tallenna.'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12',b'Banking',b'Pankkitoiminta'
b'apps/erpnext/erpnext/utilities/activation.py +108',b'Add Timesheets',b'Lis\xc3\xa4\xc3\xa4 tuntilomakkeet'
b'DocType: Vehicle Service',b'Service Item',b'palvelu Tuote'
b'DocType: Bank Guarantee',b'Bank Guarantee',b'Pankkitakaus'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39',"b""Please click on 'Generate Schedule' to get schedule""","b'klikkaa ""muodosta aikataulu"" saadaksesi aikataulun'"
b'DocType: Bin',b'Ordered Quantity',b'tilattu m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +118',"b'e.g. ""Build tools for builders""'","b'esim, ""rakenna ty\xc3\xb6kaluja rakentajille""'"
b'DocType: Grading Scale',b'Grading Scale Intervals',b'Arvosteluasteikko intervallit'
b'apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39',b'Profit for the year',b'Tulos vuodelle'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125',b'{0} {1}: Accounting Entry for {2} can only be made in currency: {3}',b'{0} {1}: Accounting Entry {2} voidaan tehd\xc3\xa4 valuutta: {3}'
b'DocType: Fee Schedule',b'In Process',b'prosessissa'
b'DocType: Authorization Rule',b'Itemwise Discount',"b'tuote ty\xc3\xb6kalu, alennus'"
b'apps/erpnext/erpnext/config/accounts.py +75',b'Tree of financial accounts.',b'Tree of tilinp\xc3\xa4\xc3\xa4t\xc3\xb6s.'
b'DocType: Cash Flow Mapping',b'Cash Flow Mapping',b'Kassavirran kartoitus'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364',b'{0} against Sales Order {1}',b'{0} myyntitilausta vastaan {1}'
b'DocType: Account',b'Fixed Asset',b'Pitkaikaiset vastaavat'
b'apps/erpnext/erpnext/config/stock.py +324',b'Serialized Inventory',b'Sarjanumeroitu varastonhallinta'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74',b'Email not found in default contact',b'S\xc3\xa4hk\xc3\xb6posti\xc3\xa4 ei l\xc3\xb6ydy oletusyhteydell\xc3\xa4'
b'DocType: Employee Loan',b'Account Info',b'Tilitiedot'
b'DocType: Activity Type',b'Default Billing Rate',b'Oletus laskutustaksa'
b'DocType: Fees',b'Include Payment',b'Sis\xc3\xa4llyt\xc3\xa4 maksu'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Opiskelija ryhm\xc3\xa4t luotu.'
b'DocType: Sales Invoice',b'Total Billing Amount',b'Lasku yhteens\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50',b'Program in the Fee Structure and Student Group {0} are different.',b'Palkkarakenteen ja opiskelijaryhm\xc3\xa4n ohjelma {0} eroavat toisistaan.'
b'DocType: Fee Schedule',b'Receivable Account',b'Saatava tili'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +618',b'Row #{0}: Asset {1} is already {2}',b'Rivi # {0}: Asset {1} on jo {2}'
b'DocType: Quotation Item',b'Stock Balance',b'Varastotase'
b'apps/erpnext/erpnext/config/selling.py +321',b'Sales Order to Payment',b'Myyntitilauksesta maksuun'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123',b'CEO',b'toimitusjohtaja'
b'DocType: Purchase Invoice',b'With Payment of Tax',b'Veronmaksu'
b'DocType: Expense Claim Detail',b'Expense Claim Detail',b'Kulukorvauksen lis\xc3\xa4tiedot'
b'DocType: Purchase Invoice',b'TRIPLICATE FOR SUPPLIER',b'Kolminkertaisesti TOIMITTAJA'
b'DocType: Land Unit',b'Is Container',b'Onko kontti'
b'DocType: Crop Cycle',b'This will be day 1 of the crop cycle',b'T\xc3\xa4m\xc3\xa4 on viljelykierron 1. p\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871',b'Please select correct account',b'Valitse oikea tili'
b'DocType: Purchase Invoice Item',b'Weight UOM',b'Painoyksikk\xc3\xb6'
b'apps/erpnext/erpnext/config/accounts.py +466',b'List of available Shareholders with folio numbers',"b'Luettelo osakkeenomistajista, joilla on folionumerot'"
b'DocType: Salary Structure Employee',b'Salary Structure Employee',b'Palkka rakenne Ty\xc3\xb6ntekij\xc3\xa4n'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45',b'Show Variant Attributes',b'N\xc3\xa4yt\xc3\xa4 varianttim\xc3\xa4\xc3\xa4ritteet'
b'DocType: Student',b'Blood Group',b'Veriryhm\xc3\xa4'
b'DocType: Course',b'Course Name',b'Kurssin nimi'
b'DocType: Employee Leave Approver',"b""Users who can approve a specific employee's leave applications""",b'Seuraavat k\xc3\xa4ytt\xc3\xa4j\xc3\xa4t voivat hyv\xc3\xa4ksy\xc3\xa4 organisaation loma-anomukset'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52',b'Office Equipments',b'Toimisto v\xc3\xa4lineist\xc3\xb6'
b'DocType: Purchase Invoice Item',b'Qty',b'Yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Fiscal Year',b'Companies',b'Yritykset'
b'DocType: Supplier Scorecard',b'Scoring Setup',b'Pisteytysasetukset'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24',b'Electronics',b'elektroniikka'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326',b'Debit ({0})',b'Debit ({0})'
b'DocType: Stock Settings',b'Raise Material Request when stock reaches re-order level',b'Luo hankintapyynt\xc3\xb6 kun saldo on alle tilauspisteen'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98',b'Full-time',b'p\xc3\xa4\xc3\xa4toiminen'
b'DocType: Payroll Entry',b'Employees',b'Ty\xc3\xb6ntekij\xc3\xa4t'
b'DocType: Employee',b'Contact Details',"b'yhteystiedot, lis\xc3\xa4tiedot'"
b'DocType: C-Form',b'Received Date',b'Saivat Date'
b'DocType: Delivery Note',"b'If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.'",b'Valitse tekem\xc3\xa4si mallipohja myyntiverolle ja maksulle.'
b'DocType: BOM Scrap Item',b'Basic Amount (Company Currency)',b'Basic Summa (Company valuutta)'
b'DocType: Student',b'Guardians',b'Guardians'
b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13',b'Payment Confirmation',b'Maksuvahvistus'
b'DocType: Shopping Cart Settings',b'Prices will not be shown if Price List is not set',"b'Hinnat ei n\xc3\xa4ytet\xc3\xa4, jos hinnasto ei ole asetettu'"
b'DocType: Stock Entry',b'Total Incoming Value',"b'Kokonaisarvo, saapuva'"
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362',b'Debit To is required',b'Veloituksen tarvitaan'
b'apps/erpnext/erpnext/utilities/activation.py +109',"b'Timesheets help keep track of time, cost and billing for activites done by your team'","b'Tuntilomakkeet auttavat seuraamaan aikaa, kustannuksia ja laskutusta tiimisi toiminnasta.'"
b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'Purchase Price List',b'Ostohinta List'
b'apps/erpnext/erpnext/config/buying.py +155',b'Templates of supplier scorecard variables.',b'Toimittajan tuloskortin muuttujien mallipohjat.'
b'DocType: Job Offer Term',b'Offer Term',b'Tarjouksen voimassaolo'
b'DocType: Asset',b'Quality Manager',b'Laadunhallinnan yll\xc3\xa4pit\xc3\xa4j\xc3\xa4'
b'DocType: Job Applicant',b'Job Opening',b'Ty\xc3\xb6paikka'
b'DocType: Payment Reconciliation',b'Payment Reconciliation',b'Maksun t\xc3\xa4sm\xc3\xa4ytys'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153',"b""Please select Incharge Person's name""",b'Valitse vastuuhenkil\xc3\xb6n nimi'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51',b'Technology',b'Teknologia'
b'DocType: Hub Settings',b'Unregister from Hub',b'Poista tilisi Hubista'
b'apps/erpnext/erpnext/public/js/utils.js +108',b'Total Unpaid: {0}',b'Maksamattomat yhteens\xc3\xa4: {0}'
b'DocType: BOM Website Operation',b'BOM Website Operation',b'BOM-sivuston K\xc3\xa4ytt\xc3\xb6'
b'DocType: Supplier Scorecard',b'Supplier Score',b'Toimittajan pisteytys'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +213',b'Total Invoiced Amt',"b'Kokonaislaskutus, pankkip\xc3\xa4\xc3\xa4te'"
b'DocType: Supplier',b'Warn RFQs',b'Varoittaa pyynt\xc3\xb6j\xc3\xa4'
b'DocType: BOM',b'Conversion Rate',b'Muuntokurssi'
b'apps/erpnext/erpnext/templates/pages/product_search.html +3',b'Product Search',b'Tuotehaku'
b'DocType: Assessment Plan',b'To Time',b'Aikaan'
b'DocType: Authorization Rule',b'Approving Role (above authorized value)',b'Hyv\xc3\xa4ksymisest\xc3\xa4 Rooli (edell\xc3\xa4 valtuutettu arvo)'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118',b'Credit To account must be a Payable account',b'kredit tilin tulee olla maksutili'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43',b'Please select Student Admission which is mandatory for the paid student applicant',"b'Valitse opiskelijavaihto, joka on pakollinen opiskelijalle'"
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355',b'BOM recursion: {0} cannot be parent or child of {2}',b'BOM-rekursio: {0} ei voi olla {2}:n osa tai p\xc3\xa4invastoin'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21',b'Please select a Price List to publish pricing',b'Valitse hinnasto julkaistaksesi hinnoittelun'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38',b'Budget List',b'Budjettilista'
b'DocType: Work Order Operation',b'Completed Qty',b'valmiit yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148',"b'For {0}, only debit accounts can be linked against another credit entry'","b'{0}, vain debet tili voidaan kohdistaa kredit kirjaukseen'"
b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27',b'Price List {0} is disabled',b'Hinnasto {0} on poistettu k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127',b'Row {0}: Completed Qty cannot be more than {1} for operation {2}',b'Rivi {0}: Valmis M\xc3\xa4\xc3\xa4r\xc3\xa4 voi olla enint\xc3\xa4\xc3\xa4n {1} toimimaan {2}'
b'DocType: Manufacturing Settings',b'Allow Overtime',b'Salli Ylity\xc3\xb6t'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Sarja-nimikett\xc3\xa4 {0} ei voi p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 varaston t\xc3\xa4sm\xc3\xa4ytyksell\xc3\xa4, tee varastotapahtuma'"
b'DocType: Training Event Employee',b'Training Event Employee',b'Koulutustapahtuma Ty\xc3\xb6ntekij\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031',b'Maximum Samples - {0} can be retained for Batch {1} and Item {2}.',b'Suurin n\xc3\xa4ytteit\xc3\xa4 - {0} voidaan s\xc3\xa4ilytt\xc3\xa4\xc3\xa4 er\xc3\xa4\xc3\xa4 {1} ja kohtaan {2}.'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7',b'Add Time Slots',b'Lis\xc3\xa4\xc3\xa4 aikav\xc3\xa4lej\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201',b'{0} Serial Numbers required for Item {1}. You have provided {2}.',b'{0} sarjanumerot tarvitaan Tuotteelle {1}. Olet antanut {2}.'
b'DocType: Stock Reconciliation Item',b'Current Valuation Rate',b'Nykyinen arvostus'
b'DocType: Training Event',b'Advance',b'edet\xc3\xa4'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'for making recurring again.',b'toistuvan uudelleen.'
b'apps/erpnext/erpnext/config/erpnext_integrations.py +13',b'GoCardless payment gateway settings',b'GoCardless-maksuyhteysasetukset'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122',b'Exchange Gain/Loss',b'Exchange voitto / tappio'
b'DocType: Opportunity',b'Lost Reason',b'H\xc3\xa4vi\xc3\xa4missyy'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +265',b'Row #{0}: Account {1} does not belong to company {2}',b'Rivi # {0}: tili {1} ei kuulu yritykseen {2}'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30',b'Unable to find DocType {0}',b'DocType {0} ei l\xc3\xb6ytynyt'
b'apps/erpnext/erpnext/public/js/templates/address_list.html +22',b'New Address',b'Uusi osoite'
b'DocType: Quality Inspection',b'Sample Size',b'N\xc3\xa4ytteen koko'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47',b'Please enter Receipt Document',b'Anna kuitti asiakirja'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369',b'All items have already been invoiced',b'Kaikki nimikkeet on jo laskutettu'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49',"b""Please specify a valid 'From Case No.'""",b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 kelvollinen &quot;Case No.&quot;'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24',b'Further cost centers can be made under Groups but entries can be made against non-Groups',"b'lis\xc3\xa4\xc3\xa4 kustannuspaikkoja voidaan tehd\xc3\xa4 kohdassa ryhm\xc3\xa4t, mutta pelk\xc3\xa4t merkinn\xc3\xa4t voi kohdistaa ilman ryhmi\xc3\xa4'"
b'apps/erpnext/erpnext/config/setup.py +66',b'Users and Permissions',b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4t ja k\xc3\xa4ytt\xc3\xb6oikeudet'
b'DocType: Vehicle Log',b'VLOG.',b'Vlogi.'
b'DocType: Branch',b'Branch',b'Sivutoimiala'
b'DocType: Soil Analysis',b'Ca/(K+Ca+Mg)',b'Ca / (K + Ca + Mg)'
b'DocType: Delivery Trip',b'Fulfillment User',b'T\xc3\xa4ytt\xc3\xa4j\xc3\xa4n k\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/config/setup.py +61',b'Printing and Branding',b'Tulostus ja br\xc3\xa4nd\xc3\xa4ys'
b'DocType: Company',b'Total Monthly Sales',b'Kuukausittainen myynti yhteens\xc3\xa4'
b'DocType: Agriculture Analysis Criteria',b'Weather',b'S\xc3\xa4\xc3\xa4'
b'DocType: Bin',b'Actual Quantity',b'kiinte\xc3\xa4 yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Shipping Rule',b'example: Next Day Shipping',b'esimerkiksi: seuraavan p\xc3\xa4iv\xc3\xa4n toimitus'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187',b'Serial No {0} not found',b'Sarjanumeroa {0} ei l\xc3\xb6ydy'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291',b'Subscription has been {0}',b'Tilaus on {0}'
b'DocType: Fee Schedule Program',b'Fee Schedule Program',b'Maksun aikatauluohjelma'
b'DocType: Fee Schedule Program',b'Student Batch',b'Student Er\xc3\xa4'
b'apps/erpnext/erpnext/utilities/activation.py +119',b'Make Student',b'Tee Student'
b'DocType: Supplier Scorecard Scoring Standing',b'Min Grade',b'Min Grade'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +218',b'You have been invited to collaborate on the project: {0}',b'Sinut on kutsuttu yhteisty\xc3\xb6h\xc3\xb6n projektissa {0}'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157',b'Physician not available on {0}',b'L\xc3\xa4\xc3\xa4k\xc3\xa4ri ei ole k\xc3\xa4ytett\xc3\xa4viss\xc3\xa4 {0}'
b'DocType: Leave Block List Date',b'Block Date',b'estop\xc3\xa4iv\xc3\xa4'
b'DocType: Crop',b'Crop',b'sato'
b'DocType: Purchase Receipt',b'Supplier Delivery Note',b'Toimituksen toimitushuomautus'
b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70',b'Apply Now',b'Hae nyt'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Todellinen m\xc3\xa4\xc3\xa4r\xc3\xa4 {0} / Waiting m\xc3\xa4\xc3\xa4r\xc3\xa4 {1}'
b'DocType: Purchase Invoice',b'E-commerce GSTIN',b'S\xc3\xa4hk\xc3\xb6inen kaupank\xc3\xa4ynti GSTIN'
b'DocType: Sales Order',b'Not Delivered',b'toimittamatta'
,b'Bank Clearance Summary',b'pankin tilitysyhteenveto'
b'apps/erpnext/erpnext/config/setup.py +106',"b'Create and manage daily, weekly and monthly email digests.'","b'tee ja hallitse (p\xc3\xa4iv\xc3\xa4-, viikko- ja kuukausi) s\xc3\xa4hk\xc3\xb6postitiedotteita'"
b'DocType: Appraisal Goal',b'Appraisal Goal',b'arvioinnin tavoite'
b'DocType: Stock Reconciliation Item',b'Current Amount',b'nykyinen M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58',b'Buildings',b'Rakennukset'
b'DocType: Fee Schedule',b'Fee Structure',b'Palkkioj\xc3\xa4rjestelm\xc3\xa4'
b'DocType: Timesheet Detail',b'Costing Amount',"b'kustannuslaskenta, arvom\xc3\xa4\xc3\xa4r\xc3\xa4'"
b'DocType: Student Admission Program',b'Application Fee',b'Hakemusmaksu'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52',b'Submit Salary Slip',b'Vahvista palkkatosite'
b'apps/erpnext/erpnext/controllers/selling_controller.py +137',b'Maxiumm discount for Item {0} is {1}%',b'Maxiumm alennus Tuote {0} on {1}%'
b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16',b'Import in Bulk',b'tuo massana'
b'DocType: Sales Partner',b'Address & Contacts',b'osoitteet ja yhteystiedot'
b'DocType: SMS Log',b'Sender Name',b'L\xc3\xa4hett\xc3\xa4j\xc3\xa4n nimi'
b'DocType: Agriculture Analysis Criteria',b'Agriculture Analysis Criteria',b'Maatalousanalyysikriteerit'
b'DocType: POS Profile',b'[Select]',b'[valitse]'
b'DocType: Vital Signs',b'Blood Pressure (diastolic)',b'Verenpaine (diastolinen)'
b'DocType: SMS Log',b'Sent To',b'L\xc3\xa4hetetty kenelle'
b'DocType: Agriculture Task',b'Holiday Management',b'Lomahallinta'
b'DocType: Payment Request',b'Make Sales Invoice',b'tee myyntilasku'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61',b'Softwares',b'Ohjelmistot'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +53',b'Next Contact Date cannot be in the past',b'Seuraava Ota Date ei voi olla menneisyydess\xc3\xa4'
b'DocType: Company',b'For Reference Only.',b'vain viitteeksi'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112',b'Physician {0} not available on {1}',b'L\xc3\xa4\xc3\xa4k\xc3\xa4ri {0} ei ole k\xc3\xa4ytett\xc3\xa4viss\xc3\xa4 {1}'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2581',b'Select Batch No',b'Valitse Er\xc3\xa4'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61',b'Invalid {0}: {1}',b'virheellinen {0}: {1}'
,b'GSTR-1',b'GSTR-1'
b'DocType: Purchase Invoice',b'PINV-RET-',b'PINV-j\xc3\xa4lkik\xc3\xa4-'
b'DocType: Fee Validity',b'Reference Inv',b'Viite Inv'
b'DocType: Sales Invoice Advance',b'Advance Amount',b'Ennakko'
b'DocType: Manufacturing Settings',b'Capacity Planning',b'kapasiteetin suunnittelu'
b'DocType: Supplier Quotation',b'Rounding Adjustment (Company Currency',b'Py\xc3\xb6ristyskorjaus (Company Currency'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43',"b""'From Date' is required""","b""'Aloitusp\xc3\xa4iv\xc3\xa4' on pakollinen"""
b'DocType: Journal Entry',b'Reference Number',b'Viitenumero'
b'DocType: Employee',b'Employment Details',"b'ty\xc3\xb6sopimus, lis\xc3\xa4tiedot'"
b'DocType: Employee',b'New Workplace',b'Uusi Ty\xc3\xb6paikka'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17',b'Set as Closed',b'Aseta suljetuksi'
b'apps/erpnext/erpnext/stock/get_item_details.py +127',b'No Item with Barcode {0}',b'Ei l\xc3\xb6ydy tuotetta viivakoodilla {0}'
b'DocType: Normal Test Items',b'Require Result Value',b'Vaaditaan tulosarvoa'
b'DocType: Item',b'Show a slideshow at the top of the page',b'N\xc3\xa4yt\xc3\xa4 diaesitys sivun yl\xc3\xa4reunassa'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532',b'Boms',b'BOMs'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +162',b'Stores',b'varastoi'
b'DocType: Project Type',b'Projects Manager',b'Projektien yll\xc3\xa4pit\xc3\xa4j\xc3\xa4'
b'DocType: Serial No',b'Delivery Time',b'toimitusaika'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33',b'Ageing Based On',b'vanhentuminen perustuu'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61',b'Appointment cancelled',b'Nimitys peruutettiin'
b'DocType: Item',b'End of Life',b'elinkaaren loppu'
b'apps/erpnext/erpnext/demo/setup/setup_data.py +331',b'Travel',b'matka'
b'DocType: Student Report Generation Tool',b'Include All Assessment Group',b'Sis\xc3\xa4llyt\xc3\xa4 kaikki arviointiryhm\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183',b'No active or default Salary Structure found for employee {0} for the given dates',b'Ei aktiivisia tai oletus Palkkarakenne l\xc3\xb6ytynyt ty\xc3\xb6ntekij\xc3\xa4 {0} varten kyseisen\xc3\xa4 p\xc3\xa4iv\xc3\xa4n\xc3\xa4'
b'DocType: Leave Block List',b'Allow Users',b'Salli K\xc3\xa4ytt\xc3\xa4j\xc3\xa4t'
b'DocType: Purchase Order',b'Customer Mobile No',b'Matkapuhelin'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1',b'Recurring',b'Toistuva'
b'DocType: Cash Flow Mapping Template Details',b'Cash Flow Mapping Template Details',b'Kassavirtakaavion mallipohjan tiedot'
b'DocType: Cost Center',b'Track separate Income and Expense for product verticals or divisions.',b'seuraa tavaran erillisi\xc3\xa4 tuloja ja kuluja  toimialoittain tai osastoittain'
b'DocType: Rename Tool',b'Rename Tool',b'Nime\xc3\xa4 ty\xc3\xb6kalu'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72',b'Update Cost',b'P\xc3\xa4ivit\xc3\xa4 kustannukset'
b'DocType: Item Reorder',b'Item Reorder',b'Tuotteen t\xc3\xa4ydennystilaus'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463',b'Show Salary Slip',b'N\xc3\xa4yt\xc3\xa4 Palkka Slip'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849',b'Transfer Material',b'Varastosiirto'
b'DocType: Fees',b'Send Payment Request',b'L\xc3\xa4het\xc3\xa4 maksupyynt\xc3\xb6'
b'DocType: BOM',"b'Specify the operations, operating cost and give a unique Operation no to your operations.'","b'm\xc3\xa4\xc3\xa4rit\xc3\xa4 toiminnot, k\xc3\xa4ytt\xc3\xb6kustannukset ja anna toiminnoille oma uniikki numero'"
b'DocType: Water Analysis',b'Origin',b'alkuper\xc3\xa4'
b'apps/erpnext/erpnext/controllers/status_updater.py +204',b'This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?',b'T\xc3\xa4m\xc3\xa4 asiakirja on yli rajan {0} {1} alkion {4}. Teetk\xc3\xb6 toisen {3} vasten samalla {2}?'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1154',b'Please set recurring after saving',b'Ole hyv\xc3\xa4 ja aseta toistuvuustieto vasta lomakkeen tallentamisen j\xc3\xa4lkeen.'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769',b'Select change amount account',b'Valitse muutoksen suuruuden tili'
b'DocType: Purchase Invoice',b'Price List Currency',"b'Hinnasto, valuutta'"
b'DocType: Naming Series',b'User must always select',b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4n tulee aina valita'
b'DocType: Stock Settings',b'Allow Negative Stock',b'salli negatiivinen varastoarvo'
b'DocType: Installation Note',b'Installation Note',b'asennus huomautus'
b'DocType: Soil Texture',b'Clay',b'Savi'
b'DocType: Topic',b'Topic',b'Aihe'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45',b'Cash Flow from Financing',b'Rahoituksen rahavirta'
b'DocType: Budget Account',b'Budget Account',b'Talousarviotili'
b'DocType: Quality Inspection',b'Verified By',b'Vahvistanut'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +78',"b""Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.""","b'Yrityksen oletusvaluuttaa ei voi muuttaa sill\xc3\xa4 tapahtumia on olemassa, tapahtumat tulee peruuttaa jotta oletusvaluuttaa voi muuttaa'"
b'DocType: Cash Flow Mapping',b'Is Income Tax Liability',b'Onko tuloverovelvollisuus'
b'DocType: Grading Scale Interval',b'Grade Description',b'Grade Kuvaus'
b'DocType: Stock Entry',b'Purchase Receipt No',b'Saapumistositteen nro'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30',b'Earnest Money',b'aikaisintaan raha'
b'DocType: Sales Invoice',b' Shipping Bill Number',b'Toimituslaskunumero'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34',b'Traceability',b'j\xc3\xa4ljitett\xc3\xa4vyys'
b'DocType: Asset Maintenance Log',b'Actions performed',b'Teht\xc3\xa4v\xc3\xa4t suoritettiin'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51',b'Customer &gt; Customer Group &gt; Territory',b'Asiakas&gt; Asiakasryhm\xc3\xa4&gt; Alue'
b'DocType: Cash Flow Mapper',b'Section Leader',b'Ryhm\xc3\xa4njohtaja'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137',b'Source of Funds (Liabilities)',b'Rahoituksen l\xc3\xa4hde (vieras p\xc3\xa4\xc3\xa4oma)'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +431',b'Quantity in row {0} ({1}) must be same as manufactured quantity {2}',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 rivill\xc3\xa4 {0} ({1}) tulee olla sama kuin valmistettu m\xc3\xa4\xc3\xa4r\xc3\xa4 {2}'
b'DocType: Supplier Scorecard Scoring Standing',b'Employee',b'Ty\xc3\xb6ntekij\xc3\xa4'
b'DocType: Asset Repair',b'Failure Date',b'Vianm\xc3\xa4\xc3\xa4ritysp\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Sample Collection',b'Collected Time',b'Ker\xc3\xa4tty aika'
b'DocType: Company',b'Sales Monthly History',b'Myynti Kuukausittainen historia'
b'DocType: Asset Maintenance Task',b'Next Due Date',b'seuraava er\xc3\xa4p\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214',b'Select Batch',b'Valitse Batch'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244',b'{0} {1} is fully billed',b'{0} {1} on kokonaan laskutettu'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31',b'Vital Signs',b'Elonmerkit'
b'DocType: Training Event',b'End Time',b'ajan loppu'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63',b'Active Salary Structure {0} found for employee {1} for the given dates',b'Aktiivinen Palkkarakenne {0} l\xc3\xb6ytyi ty\xc3\xb6ntekij\xc3\xb6iden {1} annetulle p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4t'
b'DocType: Payment Entry',b'Payment Deductions or Loss',b'Maksu v\xc3\xa4hennykset tai tappio'
b'DocType: Soil Analysis',b'Soil Analysis Criterias',b'Maaper\xc3\xa4n analyysikriteerit'
b'apps/erpnext/erpnext/config/setup.py +42',b'Standard contract terms for Sales or Purchase.',"b'perussopimusehdot, myynti tai osto'"
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +112',b'Group by Voucher',b'tositteen ryhm\xc3\xa4'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233',b'Are you sure you want to cancel this appointment?',b'Haluatko varmasti peruuttaa nimityksen?'
b'DocType: Hotel Room Pricing Package',b'Hotel Room Pricing Package',b'Hotellihuoneen hinnoittelupaketti'
b'apps/erpnext/erpnext/config/crm.py +6',b'Sales Pipeline',b'Sales Pipeline'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201',b'Please set default account in Salary Component {0}',b'Aseta oletus tilin palkanosa {0}'
b'apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7',b'Required On',b'pyydetylle'
b'DocType: Rename Tool',b'File to Rename',b'Uudelleen nimett\xc3\xa4v\xc3\xa4 tiedosto'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200',b'Please select BOM for Item in Row {0}',b'Valitse BOM varten Tuote rivill\xc3\xa4 {0}'
b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28',b'Account {0} does not match with Company {1} in Mode of Account: {2}',b'Tilin {0} ei vastaa yhti\xc3\xb6n {1} -tilassa Account: {2}'
b'apps/erpnext/erpnext/controllers/buying_controller.py +464',b'Specified BOM {0} does not exist for Item {1}',b'M\xc3\xa4\xc3\xa4ritelty\xc3\xa4 BOM:ia {0} ei l\xc3\xb6ydy tuotteelle {1}'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301',b'Course: ',b'kurssi:'
b'DocType: Soil Texture',b'Sandy Loam',b'Sandy Loam'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232',b'Maintenance Schedule {0} must be cancelled before cancelling this Sales Order',b'huoltoaikataulu {0} on peruttava ennen myyntitilauksen perumista'
b'DocType: POS Profile',b'Applicable for Users',b'Soveltuu k\xc3\xa4ytt\xc3\xa4jille'
b'DocType: Notification Control',b'Expense Claim Approved',b'Kulukorvaus hyv\xc3\xa4ksytty'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231',b'No Work Orders created',b'Ei luotu ty\xc3\xb6j\xc3\xa4rjestys'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321',b'Salary Slip of employee {0} already created for this period',b'Palkka Slip ty\xc3\xb6ntekij\xc3\xb6iden {0} on jo luotu t\xc3\xa4ll\xc3\xa4 kaudella'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155',b'Pharmaceutical',b'L\xc3\xa4\xc3\xa4kealan'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Cost of Purchased Items',b'ostettujen tuotteiden kustannukset'
b'DocType: Selling Settings',b'Sales Order Required',b'Myyntitilaus vaaditaan'
b'DocType: Purchase Invoice',b'Credit To',b'kredittiin'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceDate',b'PieceDate'
b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31',b'Active Leads / Customers',b'Aktiiviset liidit / asiakkaat'
b'DocType: Employee Education',b'Post Graduate',b'Jatko'
b'DocType: Maintenance Schedule Detail',b'Maintenance Schedule Detail',b'huoltoaikataulu lis\xc3\xa4tiedot'
b'DocType: Supplier Scorecard',b'Warn for new Purchase Orders',b'Varo uusia ostotilauksia'
b'DocType: Quality Inspection Reading',b'Reading 9',b'Lukema 9'
b'DocType: Supplier',b'Is Frozen',b'on j\xc3\xa4\xc3\xa4dytetty'
b'apps/erpnext/erpnext/stock/utils.py +224',b'Group node warehouse is not allowed to select for transactions',b'Ryhm\xc3\xa4 solmu varasto ei saa valita liiketoimien'
b'DocType: Buying Settings',b'Buying Settings',b'Oston asetukset'
b'DocType: Stock Entry Detail',b'BOM No. for a Finished Good Item',b'BOM nro valmiille tuotteelle'
b'DocType: Upload Attendance',b'Attendance To Date',b'osallistuminen p\xc3\xa4iv\xc3\xa4\xc3\xa4n'
b'DocType: Request for Quotation Supplier',b'No Quote',b'Ei lainkaan'
b'DocType: Warranty Claim',b'Raised By',b'Pyynn\xc3\xb6n tekij\xc3\xa4'
b'DocType: Payment Gateway Account',b'Payment Account',b'Maksutili'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909',b'Please specify Company to proceed',b'Ilmoitathan Yritys jatkaa'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27',b'Net Change in Accounts Receivable',b'Nettomuutos Myyntireskontra'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88',b'Compensatory Off',b'korvaava on pois'
b'DocType: Job Offer',b'Accepted',b'hyv\xc3\xa4ksytyt'
b'DocType: Grant Application',b'Organization',b'organisaatio'
b'DocType: BOM Update Tool',b'BOM Update Tool',b'BOM-p\xc3\xa4ivitysty\xc3\xb6kalu'
b'DocType: SG Creation Tool Course',b'Student Group Name',b'Opiskelijan Group Name'
b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17',b'Show exploded view',b'N\xc3\xa4yt\xc3\xa4 r\xc3\xa4j\xc3\xa4hdysn\xc3\xa4kym\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7',b'Creating Fees',b'Maksujen luominen'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +91',b'Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.',"b'Haluatko varmasti poistaa kaikki t\xc3\xa4m\xc3\xa4n yrityksen tapahtumat, p\xc3\xa4\xc3\xa4tyedostosi s\xc3\xa4ilyy silti entisell\xc3\xa4\xc3\xa4n, t\xc3\xa4t\xc3\xa4 toimintoa ei voi peruuttaa'"
b'apps/erpnext/erpnext/templates/pages/product_search.html +21',b'Search Results',b'Hakutulokset'
b'DocType: Room',b'Room Number',b'Huoneen numero'
b'apps/erpnext/erpnext/utilities/transaction_base.py +107',b'Invalid reference {0} {1}',b'Virheellinen viittaus {0} {1}'
b'DocType: Shipping Rule',b'Shipping Rule Label',b'Toimitustapa otsikko'
b'DocType: Journal Entry Account',b'Payroll Entry',b'Palkkasumma'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75',b'View Fees Records',b'Katso maksutiedot'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +35',b'Make Tax Template',b'Tee veromalli'
b'apps/erpnext/erpnext/public/js/conf.js +28',b'User Forum',b'Keskustelupalsta'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319',b'Raw Materials cannot be blank.',b'Raaka-aineet ei voi olla tyhji\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498',"b'Could not update stock, invoice contains drop shipping item.'","b'Ei voinut p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 hyllyss\xc3\xa4, lasku sis\xc3\xa4lt\xc3\xa4\xc3\xa4 pudota merenkulku er\xc3\xa4.'"
b'DocType: Lab Test Sample',b'Lab Test Sample',b'Lab Test -n\xc3\xa4yte'
b'DocType: Item Variant Settings',b'Allow Rename Attribute Value',b'Salli Rename attribuutin arvo'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491',b'Quick Journal Entry',b'Nopea P\xc3\xa4iv\xc3\xa4kirjakirjaus'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200',b'You can not change rate if BOM mentioned agianst any item',"b'hintaa ei voi muuttaa, jos BOM liitetty johonkin tuotteeseen'"
b'DocType: Restaurant',b'Invoice Series Prefix',b'Laskujen sarjan etuliite'
b'DocType: Employee',b'Previous Work Experience',b'Edellinen Ty\xc3\xb6kokemus'
b'DocType: Stock Entry',b'For Quantity',b'yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4n'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205',b'Please enter Planned Qty for Item {0} at row {1}',b'Sy\xc3\xb6t\xc3\xa4 suunniteltu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 tuotteelle {0} rivill\xc3\xa4 {1}'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93',b'Google Maps integration is not enabled',b'Google Mapsin integraatio ei ole k\xc3\xa4yt\xc3\xb6ss\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241',b'{0} {1} is not submitted',b'{0} {1} ei ole vahvistettu'
b'DocType: Member',b'Membership Expiry Date',b'J\xc3\xa4senyyden p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131',b'{0} must be negative in return document',b'{0} on oltava negatiivinen saatavat dokumentissa'
,b'Minutes to First Response for Issues',b'Vastausaikaraportti (ongelmat)'
b'DocType: Purchase Invoice',b'Terms and Conditions1',b'Ehdot ja s\xc3\xa4\xc3\xa4nn\xc3\xb6t 1'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +109',b'The name of the institute for which you are setting up this system.',b'Nimi Instituutin jolle olet luomassa t\xc3\xa4t\xc3\xa4 j\xc3\xa4rjestelm\xc3\xa4\xc3\xa4.'
b'DocType: Accounts Settings',"b'Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.'","b'kirjanpidon kirjaus on toistaiseksi j\xc3\xa4\xc3\xa4dytetty, vain alla mainitussa roolissa voi t\xc3\xa4ll\xc3\xa4 hetkell\xc3\xa4 kirjata / muokata tili\xc3\xa4'"
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116',b'Please save the document before generating maintenance schedule',b'Tallenna asiakirja ennen huoltoaikataulun muodostusta'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30',b'Latest price updated in all BOMs',b'Viimeisin hinta p\xc3\xa4ivitetty kaikissa BOM-paketeissa'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28',b'Project Status',b'Projektin tila'
b'DocType: UOM',b'Check this to disallow fractions. (for Nos)',b't\xc3\xa4pp\xc3\xa4\xc3\xa4 ellet halua murtolukuja (Nos:iin)'
b'DocType: Student Admission Program',b'Naming Series (for Student Applicant)',b'Nime\xc3\xa4minen Series (opiskelija Hakija)'
b'DocType: Delivery Note',b'Transporter Name',b'kuljetusyritys nimi'
b'DocType: Authorization Rule',b'Authorized Value',b'Valtuutettu Arvo'
b'DocType: BOM',b'Show Operations',b'N\xc3\xa4yt\xc3\xa4 Operations'
,b'Minutes to First Response for Opportunity',b'Vastausaikaraportti (mahdollisuudet)'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Absent',"b'Yhteens\xc3\xa4, puuttua'"
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +862',b'Item or Warehouse for row {0} does not match Material Request',b'Rivin {0} nimike tai varasto ei t\xc3\xa4sm\xc3\xa4\xc3\xa4 hankintapyynn\xc3\xb6n kanssa'
b'apps/erpnext/erpnext/config/stock.py +191',b'Unit of Measure',b'Yksikk\xc3\xb6'
b'DocType: Fiscal Year',b'Year End Date',b'Vuoden viimeinen p\xc3\xa4iv\xc3\xa4'
b'DocType: Task Depends On',b'Task Depends On',b'Teht\xc3\xa4v\xc3\xa4 riippuu'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026',b'Opportunity',b'Myyntimahdollisuus'
b'DocType: Operation',b'Default Workstation',b'oletus ty\xc3\xb6piste'
b'DocType: Notification Control',b'Expense Claim Approved Message',b'Viesti kulukorvauksen hyv\xc3\xa4ksymisest\xc3\xa4'
b'DocType: Payment Entry',b'Deductions or Loss',b'V\xc3\xa4hennykset tai Loss'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247',b'{0} {1} is closed',b'{0} {1} on suljettu'
b'DocType: Email Digest',b'How frequently?',b'kuinka usein'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55',b'Total Collected: {0}',b'Ker\xc3\xa4tty yhteens\xc3\xa4: {0}'
b'DocType: Purchase Receipt',b'Get Current Stock',b'hae nykyinen varasto'
b'DocType: Purchase Invoice',b'ineligible',b'tukikelpoisia'
b'apps/erpnext/erpnext/config/manufacturing.py +46',b'Tree of Bill of Materials',b'Osaluettelorakenne'
b'DocType: Student',b'Joining Date',b'liittyminen Date'
,b'Employees working on a holiday',b'Virallisena lomap\xc3\xa4iv\xc3\xa4n\xc3\xa4 ty\xc3\xb6skentelev\xc3\xa4t ty\xc3\xb6ntekij\xc3\xa4t'
b'DocType: Share Balance',b'Current State',b'Nykyinen tila'
b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152',b'Mark Present',b'Mark Nykyinen'
b'DocType: Share Transfer',b'From Shareholder',b'Osakkeenomistajalta'
b'DocType: Project',b'% Complete Method',b'% T\xc3\xa4ydellinen Menetelm\xc3\xa4'
b'apps/erpnext/erpnext/healthcare/setup.py +181',b'Drug',b'l\xc3\xa4\xc3\xa4ke'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200',b'Maintenance start date can not be before delivery date for Serial No {0}',b'huollon aloitusp\xc3\xa4iv\xc3\xa4 ei voi olla ennen sarjanumeron {0} toimitusaikaa'
b'DocType: Work Order',b'Actual End Date',b'todellinen p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Cash Flow Mapping',b'Is Finance Cost Adjustment',b'Onko rahoituskustannusten s\xc3\xa4\xc3\xa4t\xc3\xb6?'
b'DocType: BOM',b'Operating Cost (Company Currency)',b'K\xc3\xa4ytt\xc3\xb6kustannukset (Company valuutta)'
b'DocType: Purchase Invoice',b'PINV-',b'PINV-'
b'DocType: Authorization Rule',b'Applicable To (Role)',b'sovellettavissa (rooli)'
b'DocType: BOM Update Tool',b'Replace BOM',b'Korvaa BOM'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110',b'Code {0} already exist',b'Koodi {0} on jo olemassa'
b'DocType: Employee Advance',b'Purpose',b'Tapahtuma'
b'DocType: Company',b'Fixed Asset Depreciation Settings',b'Kiinte\xc3\xa4n omaisuuden poistoasetukset'
b'DocType: Item',b'Will also apply for variants unless overrridden',"b'Sovelletaan my\xc3\xb6s tuotemalleissa, ellei kumota'"
b'DocType: Purchase Invoice',b'Advances',b'ennakot'
b'DocType: Work Order',b'Manufacture against Material Request',b'Valmista materiaalipyynt\xc3\xb6\xc3\xa4 vasten'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14',b'Assessment Group: ',b'Arviointiryhm\xc3\xa4:'
b'DocType: Item Reorder',b'Request for',b'Pyynt\xc3\xb6'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32',b'Approving User cannot be same as user the rule is Applicable To',b'hyv\xc3\xa4ksyv\xc3\xa4 k\xc3\xa4ytt\xc3\xa4j\xc3\xa4 ei voi olla sama kuin k\xc3\xa4ytetyss\xc3\xa4 s\xc3\xa4\xc3\xa4nn\xc3\xb6ss\xc3\xa4 oleva'
b'DocType: Stock Entry Detail',b'Basic Rate (as per Stock UOM)',b'Perushinta (varastoyksik\xc3\xb6ss\xc3\xa4)'
b'DocType: SMS Log',b'No of Requested SMS',b'Pyydetyn SMS-viestin numero'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246',b'Leave Without Pay does not match with approved Leave Application records',b'J\xc3\xa4t\xc3\xa4 Ilman Pay ei vastaa hyv\xc3\xa4ksytty\xc3\xa4 Leave Application kirjaa'
b'DocType: Campaign',b'Campaign-.####',b'kampanja -. ####'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21',b'Next Steps',b'Seuraavat vaiheet'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796',b'Please supply the specified items at the best possible rates',b'Ole hyv\xc3\xa4 ja toimittaa erityisiin kohtiin on paras mahdollinen hinnat'
b'DocType: Membership',b'USD',b'USD'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28',b'Make Invoice',b'tee Lasku'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80',b'Remaining Balance',b'J\xc3\xa4ljell\xc3\xa4oleva saldo'
b'DocType: Selling Settings',b'Auto close Opportunity after 15 days',b'Auto l\xc3\xa4hell\xc3\xa4 Mahdollisuus 15 p\xc3\xa4iv\xc3\xa4n j\xc3\xa4lkeen'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86',b'Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.',"b'Ostosopimukset eiv\xc3\xa4t ole sallittuja {0}, koska tulosvastine on {1}.'"
b'apps/erpnext/erpnext/stock/doctype/item/item.py +498',b'Barcode {0} is not a valid {1} code',b'Viivakoodi {0} ei ole kelvollinen {1} koodi'
b'apps/erpnext/erpnext/public/js/financial_statements.js +83',b'End Year',b'end Year'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / Lyijy%'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +124',b'Contract End Date must be greater than Date of Joining',b'sopimuksen p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4 tulee olla liittymisp\xc3\xa4iv\xc3\xa4n j\xc3\xa4lkeen'
b'DocType: Driver',b'Driver',b'kuljettaja'
b'DocType: Vital Signs',b'Nutrition Values',b'Ravitsemusarvot'
b'DocType: Lab Test Template',b'Is billable',b'On laskutettava'
b'DocType: Delivery Note',b'DN-',b'DN-'
b'DocType: Sales Partner',b'A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.',"b'Ulkopuolinen v\xc3\xa4litt\xc3\xa4j\xc3\xa4 / edustaja / agentti / j\xc3\xa4lleenmyyj\xc3\xa4, joka myy yrityksen tavaraa provisiolla.'"
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376',b'{0} against Purchase Order {1}',b'{0} ostotilausta vastaan {1}'
b'DocType: Patient',b'Patient Demographics',b'Potilaiden v\xc3\xa4est\xc3\xb6tiedot'
b'DocType: Task',b'Actual Start Date (via Time Sheet)',b'Todellinen aloitusp\xc3\xa4iv\xc3\xa4 (via kellokortti)'
b'apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15',b'This is an example website auto-generated from ERPNext',b'T\xc3\xa4m\xc3\xa4 on ERPNext-j\xc3\xa4rjestelm\xc3\xa4n automaattisesti luoma verkkosivu'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43',b'Ageing Range 1',b'vanhentumisen skaala 1'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212',b'Total advance amount cannot be greater than total claimed amount',b'Ennakkomaksu ei voi olla suurempi kuin vaadittu kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Purchase Taxes and Charges Template',"b'Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.'","b'perusveromallipohja, jota voidaan k\xc3\xa4ytt\xc3\xa4\xc3\xa4 kaikkiin ostotapahtumiin. t\xc3\xa4m\xc3\xa4 mallipohja voi sis\xc3\xa4lt\xc3\xa4\xc3\xa4 listan perusveroista ja my\xc3\xb6s muita veroja, kuten ""toimitus"", ""vakuutus"", ""k\xc3\xa4sittely"" jne #### huomaa ett\xc3\xa4 t\xc3\xa4nne m\xc3\xa4\xc3\xa4ritelty veroprosentti tulee olemaan oletus kaikille **tuotteille**, mik\xc3\xa4li **tuotteella** on eri veroprosentti tulee se m\xc3\xa4\xc3\xa4ritell\xc3\xa4 **tuotteen vero** taulukossa **tuote** ty\xc3\xb6kalussa. #### sarakkeiden kuvaus 1. laskennan tyyppi: - t\xc3\xa4m\xc3\xa4 voi olla **netto yhteens\xc3\xa4** (eli summa perusarvosta). - **edellisen rivin summa / m\xc3\xa4\xc3\xa4r\xc3\xa4 ** (kumulatiivisille veroille tai maksuille, mik\xc3\xa4li t\xc3\xa4m\xc3\xa4n on valittu edellisen rivin vero lasketaan prosentuaalisesti (verotaulukon) mukaan arvom\xc3\xa4\xc3\xa4r\xc3\xa4st\xc3\xa4 tai summasta 2. tilin otsikko: tilin tilikirja, johon verot varataan 3. kustannuspaikka: mik\xc3\xa4li vero / maksu on tuloa (kuten toimitus) tai kulua tulee se varata kustannuspaikkaa vastaan 4. kuvaus: veron kuvaus (joka tulostetaan laskulla / tositteella) 5. taso: veroprosentti. 6. m\xc3\xa4\xc3\xa4r\xc3\xa4: veron arvom\xc3\xa4\xc3\xa4r\xc3\xa4 7. yhteens\xc3\xa4: kumulatiivinen yhteissumma t\xc3\xa4h\xc3\xa4n asti. 8. sy\xc3\xb6t\xc3\xa4 rivi: mik\xc3\xa4li k\xc3\xa4ytet\xc3\xa4\xc3\xa4n rivi\xc3\xa4 ""edellinen rivi yhteens\xc3\xa4"", voit valita rivin numeron, jota k\xc3\xa4ytet\xc3\xa4\xc3\xa4n laskelman pohjana 9. pid\xc3\xa4 vero tai kustannus: t\xc3\xa4ss\xc3\xa4 osiossa voit m\xc3\xa4\xc3\xa4ritt\xc3\xa4\xc3\xa4, jos vero / kustannus on pelkk\xc3\xa4 arvo (ei kuulu summaan) tai pelk\xc3\xa4st\xc3\xa4\xc3\xa4n summaan (ei lis\xc3\xa4\xc3\xa4 tuotteen arvoa) tai kumpaakin 10. lis\xc3\xa4\xc3\xa4 tai v\xc3\xa4henn\xc3\xa4: voit lis\xc3\xa4t\xc3\xa4 tai v\xc3\xa4hent\xc3\xa4\xc3\xa4 veroa'"
b'DocType: Homepage',b'Homepage',b'Kotisivu'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68',b'Select Physician...',b'Valitse l\xc3\xa4\xc3\xa4k\xc3\xa4ri ...'
b'DocType: Grant Application',b'Grant Application Details ',b'Apurahan hakemustiedot'
b'DocType: Purchase Receipt Item',b'Recd Quantity',b'RECD M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65',b'Fee Records Created - {0}',b'Fee Records Luotu - {0}'
b'DocType: Asset Category Account',b'Asset Category Account',b'Asset Luokka Account'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913',b'Row #{0} (Payment Table): Amount must be positive',b'Rivi # {0} (Maksutaulukko): M\xc3\xa4\xc3\xa4r\xc3\xa4n on oltava positiivinen'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteNum',b'CompteNum'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137',b'Cannot produce more Item {0} than Sales Order quantity {1}',b'ei voi valmistaa suurempaa m\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4 tuotteita {0} kuin myyntitilauksen m\xc3\xa4\xc3\xa4r\xc3\xa4 {1}'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +391',b'Select Attribute Values',b'Valitse attribuuttiarvot'
b'DocType: Purchase Invoice',b'Reason For Issuing document',b'Asiakirjan my\xc3\xb6nt\xc3\xa4misen syy'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539',b'Stock Entry {0} is not submitted',b'Varastotapahtumaa {0} ei ole vahvistettu'
b'DocType: Payment Reconciliation',b'Bank / Cash Account',b'Pankki-tai Kassatili'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +47',b'Next Contact By cannot be same as the Lead Email Address',b'Seuraava Ota By voi olla sama kuin Lead S\xc3\xa4hk\xc3\xb6postiosoite'
b'DocType: Tax Rule',b'Billing City',b'Laskutus Kaupunki'
b'DocType: Asset',b'Manual',b'manuaalinen'
b'DocType: Salary Component Account',b'Salary Component Account',b'Palkanosasta Account'
b'DocType: Global Defaults',b'Hide Currency Symbol',b'piilota valuuttasymbooli'
b'apps/erpnext/erpnext/config/non_profit.py +58',b'Donor information.',b'Luovuttajan tiedot.'
b'apps/erpnext/erpnext/config/accounts.py +330',"b'e.g. Bank, Cash, Credit Card'","b'esim, pankki, kassa, luottokortti'"
b'DocType: Lead Source',b'Source Name',b'Source Name'
b'DocType: Vital Signs',"b'Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""'","b'Normaali lepovaihe aikuispotilailla on noin 120 mmHg systolista ja 80 mmHg diastolista, lyhennettyn\xc3\xa4 &quot;120/80 mmHg&quot;'"
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +119',"b'Set items shelf life in days, to set expiry based on manufacturing_date plus self life'","b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 tuotteiden s\xc3\xa4ilyvyys p\xc3\xa4ivin\xc3\xa4, asettaaksesi voimassaolon p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4n valmistus-p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4n ja itseluottamuksen perusteella'"
b'DocType: Journal Entry',b'Credit Note',b'hyvityslasku'
b'DocType: Projects Settings',b'Ignore Employee Time Overlap',b'Ohita ty\xc3\xb6ntekij\xc3\xa4n p\xc3\xa4\xc3\xa4llekk\xc3\xa4isyysaika'
b'DocType: Warranty Claim',b'Service Address',b'Palveluosoite'
b'DocType: Asset Maintenance Task',b'Calibration',b'kalibrointi'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97',b'{0} is a company holiday',b'{0} on yritysloma'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49',b'Furnitures and Fixtures',b'Huonekaluja ja kalusteet'
b'DocType: Item',b'Manufacture',b'Valmistus'
b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Company',b'Setup Company'
,b'Lab Test Report',b'Lab Test Report'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13',b'Please Delivery Note first',b'Ensin l\xc3\xa4hete'
b'DocType: Student Applicant',b'Application Date',b'Hakup\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Salary Detail',b'Amount based on formula',b'Laskettu m\xc3\xa4\xc3\xa4r\xc3\xa4 kaavan'
b'DocType: Purchase Invoice',b'Currency and Price List',b'Valuutta ja hinnasto'
b'DocType: Opportunity',b'Customer / Lead Name',b'Asiakkaan / Liidin nimi'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115',b'Clearance Date not mentioned',b'tilitysp\xc3\xa4iv\xc3\xa4\xc3\xa4 ei ole mainittu'
b'apps/erpnext/erpnext/config/manufacturing.py +7',b'Production',b'Tuotanto'
b'DocType: Guardian',b'Occupation',b'Ammatti'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74',b'Row {0}:Start Date must be before End Date',b'Rivi {0}: Aloitus on ennen P\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Crop',b'Planting Area',b'Istutusalue'
b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Qty)',b'yhteens\xc3\xa4 (yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4)'
b'DocType: Installation Note Item',b'Installed Qty',b'asennettu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4',b'This could be because of some invalid Email Addresses in the',"b'T\xc3\xa4m\xc3\xa4 voi johtua siit\xc3\xa4, ett\xc3\xa4 joitain virheellisi\xc3\xa4 s\xc3\xa4hk\xc3\xb6postiosoitteita on'"
b'apps/erpnext/erpnext/utilities/user_progress.py +31',b'You added ',b'Lis\xc3\xa4sit'
b'DocType: Purchase Taxes and Charges',b'Parenttype',b'P\xc3\xa4\xc3\xa4tyyppi'
b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10',b'Training Result',b'Harjoitustulos'
b'DocType: Purchase Invoice',b'Is Paid',b'On maksettu'
b'DocType: Salary Structure',b'Total Earning',b'Ansiot yhteens\xc3\xa4'
b'DocType: Purchase Receipt',b'Time at which materials were received',b'Saapumisaika'
b'DocType: Products Settings',b'Products per Page',b'Tuotteet per sivu'
b'DocType: Stock Ledger Entry',b'Outgoing Rate',b'l\xc3\xa4htev\xc3\xa4 taso'
b'apps/erpnext/erpnext/config/hr.py +233',b'Organization branch master.',b'Organisaation sivutoimialamalline'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +313',b' or ',b'tai'
b'DocType: Sales Order',b'Billing Status',b'Laskutus tila'
b'apps/erpnext/erpnext/public/js/conf.js +32',b'Report an Issue',b'Ilmoita ongelma'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120',b'Utility Expenses',b'Hy\xc3\xb6dykekulut'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64',b'90-Above',b'90 ja yli'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252',b'Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher',b'Rivi # {0}: P\xc3\xa4iv\xc3\xa4kirjakirjaus {1} ei ole huomioon {2} tai jo sovitettu toista voucher'
b'DocType: Supplier Scorecard Criteria',b'Criteria Weight',b'Kriteerit Paino'
b'DocType: Buying Settings',b'Default Buying Price List',b'Ostohinnasto (oletus)'
b'DocType: Payroll Entry',b'Salary Slip Based on Timesheet',b'Palkka tuntilomakkeen mukaan'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43',b'Buying Rate',b'Ostaminen'
b'DocType: Notification Control',b'Sales Order Message',"b'Myyntitilaus, viesti'"
b'apps/erpnext/erpnext/config/setup.py +15',"b'Set Default Values like Company, Currency, Current Fiscal Year, etc.'","b'Aseta oletusarvot kuten yritys, valuutta, kuluvan tilikausi jne'"
b'DocType: Payment Entry',b'Payment Type',b'Maksun tyyppi'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',"b'Valitse Er\xc3\xa4 momentille {0}. Pysty l\xc3\xb6yt\xc3\xa4m\xc3\xa4\xc3\xa4n yhden er\xc3\xa4n, joka t\xc3\xa4ytt\xc3\xa4\xc3\xa4 t\xc3\xa4m\xc3\xa4n vaatimuksen'"
b'DocType: Hub Category',b'Parent Category',b'Vanhemman luokka'
b'DocType: Payroll Entry',b'Select Employees',b'Valitse ty\xc3\xb6ntekij\xc3\xa4t'
b'DocType: Opportunity',b'Potential Sales Deal',b'Potentiaaliset Myynti Deal'
b'DocType: Complaint',b'Complaints',b'valitukset'
b'DocType: Payment Entry',b'Cheque/Reference Date',b'Sekki / Viitep\xc3\xa4iv\xc3\xa4'
b'DocType: Purchase Invoice',b'Total Taxes and Charges',b'verot ja maksut yhteens\xc3\xa4'
b'DocType: Employee',b'Emergency Contact',b'h\xc3\xa4t\xc3\xa4yhteydenotto'
b'DocType: Bank Reconciliation Detail',b'Payment Entry',b'Payment Entry'
,b'sales-browser',b'Myynti-selain'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +79',b'Ledger',b'P\xc3\xa4\xc3\xa4kirja'
b'DocType: Patient Medical Record',b'PMR-',b'PMR-'
b'DocType: Drug Prescription',b'Drug Code',b'Huumekoodi'
b'DocType: Target Detail',b'Target  Amount',b'Tavoite arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: POS Profile',b'Print Format for Online',b'Tulosta formaatti verkossa'
b'DocType: Shopping Cart Settings',b'Shopping Cart Settings',b'Ostoskoritoiminnon asetukset'
b'DocType: Journal Entry',b'Accounting Entries',"b'kirjanpito, kirjaukset'"
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17',"b""If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.""","b'Jos valittu hinnoittelus\xc3\xa4\xc3\xa4nt\xc3\xb6 on tehty &quot;Hinta&quot;, se korvaa hinnaston. Hinnoittelu S\xc3\xa4\xc3\xa4nt\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 on lopullinen kurssi, joten ylim\xc3\xa4\xc3\xa4r\xc3\xa4ist\xc3\xa4 alennusta ei pit\xc3\xa4isi soveltaa. Niinp\xc3\xa4 tapahtumissa, kuten myyntitoimeksiannossa, ostotilauksellakin jne., Se noudetaan &quot;Rate&quot; -kentt\xc3\xa4\xc3\xa4n eik\xc3\xa4 &quot;Price List Rate&quot; -kentt\xc3\xa4\xc3\xa4n.'"
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24',b'Duplicate Entry. Please check Authorization Rule {0}',"b'monista kirjaus, tarkista oikeutuss\xc3\xa4\xc3\xa4nn\xc3\xb6t {0}'"
b'DocType: Journal Entry Account',b'Reference Due Date',b'Viiv\xc3\xa4stysp\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Purchase Order',b'Ref SQ',b'Ref SQ'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55',b'Receipt document must be submitted',b'Kuitti asiakirja on esitett\xc3\xa4v\xc3\xa4'
b'DocType: Purchase Invoice Item',b'Received Qty',b'Saapunut yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Stock Entry Detail',b'Serial No / Batch',b'Sarjanumero / er\xc3\xa4'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340',b'Not Paid and Not Delivered',b'Ei makseta ja ei toimiteta'
b'DocType: Product Bundle',b'Parent Item',b'P\xc3\xa4\xc3\xa4kohde'
b'DocType: Account',b'Account Type',b'Tilin tyyppi'
b'DocType: Delivery Note',b'DN-RET-',b'DN-j\xc3\xa4lkik\xc3\xa4-'
b'apps/erpnext/erpnext/templates/pages/projects.html +58',b'No time sheets',b'Ei aikaa arkkia'
b'DocType: GoCardless Mandate',b'GoCardless Customer',b'GoCardless-asiakas'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123',b'Leave Type {0} cannot be carry-forwarded',b'{0} -tyyppist\xc3\xa4 vapaata ei voi siirt\xc3\xa4\xc3\xa4 eteenp\xc3\xa4in'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215',"b""Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'""","b'huoltuaikataulua ei ole luotu kaikille tuotteille, klikkaa ""muodosta aikataulu""'"
,b'To Produce',b'Tuotantoon'
b'apps/erpnext/erpnext/config/hr.py +93',b'Payroll',b'Palkanmaksu'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196',"b'For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included'","b'riviin {0}:ssa {1} sis\xc3\xa4llyt\xc3\xa4 {2} tuotetasolle, rivit {3} tulee my\xc3\xb6s sis\xc3\xa4llytt\xc3\xa4\xc3\xa4'"
b'DocType: Patient Service Unit',b'Parent Service Unit',b'Vanhempien huoltoyksikk\xc3\xb6'
b'apps/erpnext/erpnext/utilities/activation.py +101',b'Make User',b'Tee K\xc3\xa4ytt\xc3\xa4j\xc3\xa4n'
b'DocType: Packing Slip',b'Identification of the package for the delivery (for print)',b'pakkauksen tunnistus toimitukseen (tulostus)'
b'DocType: Bin',b'Reserved Quantity',b'Varattu M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Anna voimassa oleva s\xc3\xa4hk\xc3\xb6postiosoite'
b'DocType: Volunteer Skill',b'Volunteer Skill',b'Vapaaehtoinen taito'
b'DocType: Bank Reconciliation',b'Include POS Transactions',b'Sis\xc3\xa4llyt\xc3\xa4 POS-tapahtumia'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +784',b'Please select an item in the cart',b'Valitse kohde ostoskoriin'
b'DocType: Landed Cost Voucher',b'Purchase Receipt Items',b'Saapumistositteen nimikkeet'
b'apps/erpnext/erpnext/config/learn.py +21',b'Customizing Forms',b'muotojen muokkaus'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74',b'Arrear',b'arrear'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158',b'Depreciation Amount during the period',b'Poistot M\xc3\xa4\xc3\xa4r\xc3\xa4 ajanjaksolla'
b'apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43',b'Disabled template must not be default template',b'Vammaiset mallia saa olla oletuspohja'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314',b'For row {0}: Enter planned qty',b'Rivi {0}: Sy\xc3\xb6t\xc3\xa4 suunniteltu m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Shareholder',b'SH-',b'SH-'
b'DocType: Account',b'Income Account',b'tulotili'
b'DocType: Payment Request',"b""Amount in customer's currency""",b'Summa asiakkaan valuutassa'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825',b'Delivery',b'Toimitus'
b'DocType: Volunteer',b'Weekdays',b'Arkisin'
b'DocType: Stock Reconciliation Item',b'Current Qty',b'nykyinen yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Restaurant Menu',b'Restaurant Menu',b'Ravintola Valikko'
b'apps/erpnext/erpnext/templates/generators/item_group.html +36',b'Prev',b'Taaksep\xc3\xa4in'
b'DocType: Appraisal Goal',b'Key Responsibility Area',b'Key Vastuu Area'
b'apps/erpnext/erpnext/utilities/activation.py +127',"b'Student Batches help you track attendance, assessments and fees for students'","b'Student Er\xc3\xa4t avulla voit seurata l\xc3\xa4sn\xc3\xa4oloa, arvioinnit ja palkkiot opiskelijoille'"
b'DocType: Payment Entry',b'Total Allocated Amount',b'Yhteens\xc3\xa4 osuutensa'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +151',b'Set default inventory account for perpetual inventory',b'Aseta oletus varaston osuus investointikertym\xc3\xa4menetelm\xc3\xa4n'
b'DocType: Item Reorder',b'Material Request Type',b'Hankintapyynn\xc3\xb6n tyyppi'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252',b'Accural Journal Entry for salaries from {0} to {1}',b'Accural P\xc3\xa4iv\xc3\xa4kirjakirjaus palkkojen v\xc3\xa4lill\xc3\xa4 {0} ja {1}'
b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17',b'Send Grant Review Email',b'L\xc3\xa4het\xc3\xa4 rahastoarvio s\xc3\xa4hk\xc3\xb6posti'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +848',"b'LocalStorage is full, did not save'","b'LocalStoragen on t\xc3\xa4ynn\xc3\xa4, ei tallentanut'"
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100',b'Row {0}: UOM Conversion Factor is mandatory',b'Rivi {0}: UOM Muuntokerroin on pakollinen'
b'apps/erpnext/erpnext/utilities/user_progress.py +235',b'Room Capacity',b'Huoneen kapasiteetti'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95',b'Ref',b'Viite'
b'DocType: Lab Test',b'LP-',b'LP-'
b'DocType: Healthcare Settings',b'Registration Fee',b'Rekister\xc3\xb6intimaksu'
b'DocType: Budget',b'Cost Center',b'Kustannuspaikka'
b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45',b'Voucher #',b'Tosite #'
b'DocType: Notification Control',b'Purchase Order Message',b'Ostotilaus Message'
b'DocType: Tax Rule',b'Shipping Country',b'Toimitusmaa'
b'DocType: Selling Settings',"b""Hide Customer's Tax Id from Sales Transactions""",b'Piilota Asiakkaan Tax Id myyntitapahtumia'
b'DocType: Upload Attendance',b'Upload HTML',b'Tuo HTML-koodia'
b'DocType: Employee',b'Relieving Date',b'P\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14',"b'Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.'","b'Hinnoittelu s\xc3\xa4\xc3\xa4nt\xc3\xb6 on tehty t\xc3\xa4m\xc3\xa4 korvaa hinnaston / m\xc3\xa4\xc3\xa4rit\xc3\xa4 alennus, joka perustuu kriteereihin'"
b'DocType: Serial No',b'Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt',b'Varastoa voi muuttaa ainoastaan varaston Kirjauksella / L\xc3\xa4hetteell\xc3\xa4 / Ostokuitilla'
b'DocType: Employee Education',b'Class / Percentage',b'Luokka / prosentti'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134',b'Head of Marketing and Sales',b'markkinoinnin ja myynnin p\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72',b'Income Tax',b'tulovero'
b'apps/erpnext/erpnext/config/selling.py +174',b'Track Leads by Industry Type.',b'Seuraa vihjeit\xc3\xa4 toimialan mukaan'
b'apps/erpnext/erpnext/utilities/user_progress.py +101',b'Go to Letterheads',b'Siirry kirjelomakkeisiin'
b'DocType: Item Supplier',b'Item Supplier',b'tuote toimittaja'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1255',b'Please enter Item Code to get batch no',b'Sy\xc3\xb6t\xc3\xa4 tuotekoodi saadaksesi er\xc3\xa4numeron'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880',b'Please select a value for {0} quotation_to {1}',b'Sy\xc3\xb6t\xc3\xa4 arvot tarjouksesta {0} tarjoukseen {1}'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419',b'No Items selected for transfer',b'Siirrett\xc3\xa4vi\xc3\xa4 kohteita ei ole valittu'
b'apps/erpnext/erpnext/config/selling.py +46',b'All Addresses.',b'kaikki osoitteet'
b'DocType: Company',b'Stock Settings',b'varastoasetukset'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +183',"b'Merging is only possible if following properties are same in both records. Is Group, Root Type, Company'","b'yhdist\xc3\xa4minen on mahdollista vain, jos seuraavat arvot ovat samoja molemmissa tietueissa, kantatyyppi, ryhm\xc3\xa4, viite, yritys'"
b'DocType: Vehicle',b'Electric',b'S\xc3\xa4hk\xc3\xb6inen'
b'DocType: Task',b'% Progress',b'% Progress'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123',b'Gain/Loss on Asset Disposal',b'Voitto / tappio Omaisuudenhoitoalan H\xc3\xa4vitt\xc3\xa4minen'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117',b'Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.',b'Tilille {0} ei ole tili\xc3\xa4. <br> Aseta tilikarttasi oikein.'
b'DocType: Task',b'Depends on Tasks',b'Riippuu Teht\xc3\xa4v\xc3\xa4t'
b'apps/erpnext/erpnext/config/selling.py +36',b'Manage Customer Group Tree.',b'hallitse asiakasryhm\xc3\xa4puuta'
b'DocType: Shopping Cart Settings',b'Attachments can be shown without enabling the shopping cart',"b'Liitteet voidaan n\xc3\xa4ytt\xc3\xa4\xc3\xa4 ilman, ett\xc3\xa4 ostoskoria otetaan k\xc3\xa4ytt\xc3\xb6\xc3\xb6n.'"
b'DocType: Normal Test Items',b'Result Value',b'Tulosarvo'
b'DocType: Hotel Room',b'Hotels',b'hotellit'
b'DocType: Supplier Quotation',b'SQTN-',b'SQTN-'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22',b'New Cost Center Name',b'uuden kustannuspaikan nimi'
b'DocType: Leave Control Panel',b'Leave Control Panel',b'poistu ohjauspaneelista'
b'DocType: Project',b'Task Completion',b'Task T\xc3\xa4ydennys'
b'apps/erpnext/erpnext/templates/includes/product_page.js +22',b'Not in Stock',b'Not in Stock'
b'DocType: Volunteer',b'Volunteer Skills',b'Vapaaehtoisty\xc3\xb6ntekij\xc3\xa4t'
b'DocType: Appraisal',b'HR User',b'HR k\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'DocType: Purchase Invoice',b'Taxes and Charges Deducted',b'Netto ilman veroja ja kuluja'
b'apps/erpnext/erpnext/hooks.py +142',b'Issues',b'Tukipyynn\xc3\xb6t'
b'apps/erpnext/erpnext/controllers/status_updater.py +12',b'Status must be one of {0}',b'Tilan tulee olla yksi {0}:sta'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64',b'Reminder to update GSTIN Sent',b'Muistutus GSTIN-l\xc3\xa4hetyksen p\xc3\xa4ivitt\xc3\xa4miseksi'
b'DocType: Sales Invoice',b'Debit To',b'debet kirjaus kohteeseen'
b'DocType: Restaurant Menu Item',b'Restaurant Menu Item',b'Ravintola-valikkokohta'
b'DocType: Delivery Note',b'Required only for sample item.',b'vain demoer\xc3\xa4 on pyydetty'
b'DocType: Stock Ledger Entry',b'Actual Qty After Transaction',b'todellinen yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 tapahtuman j\xc3\xa4lkeen'
,b'Pending SO Items For Purchase Request',"b'Ostettavat pyynt\xc3\xb6, odottavat myyntitilaukset'"
b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35',b'Student Admissions',b'Opiskelijavalinta'
b'apps/erpnext/erpnext/accounts/party.py +388',b'{0} {1} is disabled',b'{0} {1} on poistettu k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'DocType: Supplier',b'Billing Currency',b'Laskutus Valuutta'
b'DocType: Sales Invoice',b'SINV-RET-',b'SINV-j\xc3\xa4lkik\xc3\xa4-'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200',b'Extra Large',b'eritt\xc3\xa4in suuri'
b'DocType: Crop',b'Scientific Name',b'Tieteellinen nimi'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Leaves',b'Yhteens\xc3\xa4 lehdet'
b'DocType: Customer',"b'Reselect, if the chosen contact is edited after save'","b'Vahvista uudelleen, jos valittua konetta muokataan tallentamisen j\xc3\xa4lkeen'"
b'DocType: Consultation',b'In print',b'Painossa'
,b'Profit and Loss Statement',b'Tuloslaskelma selvitys'
b'DocType: Bank Reconciliation Detail',b'Cheque Number',b'takaus/shekki numero'
,b'Sales Browser',b'Myyntiselain'
b'DocType: Journal Entry',b'Total Credit',b'Kredit yhteens\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542',b'Warning: Another {0} # {1} exists against stock entry {2}',b'Varoitus:  Varastotapahtumalle {2} on jo olemassa toinen {0} # {1}'
b'apps/erpnext/erpnext/utilities/user_progress_utils.py +66',b'Local',b'Paikallinen'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26',b'Loans and Advances (Assets)',b'lainat ja ennakot (vastaavat)'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12',b'Debtors',b'velalliset'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199',b'Large',b'Suuri'
b'DocType: Homepage Featured Product',b'Homepage Featured Product',b'Kotisivu Erityistuotteet'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248',b'All Assessment Groups',b'Kaikki Assessment Groups'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15',b'New Warehouse Name',b'Uusi varasto Name'
b'apps/erpnext/erpnext/accounts/report/financial_statements.py +259',b'Total {0} ({1})',b'Yhteens\xc3\xa4 {0} ({1})'
b'DocType: C-Form Invoice Detail',b'Territory',b'Alue'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151',b'Please mention no of visits required',b'Vierailujen m\xc3\xa4\xc3\xa4r\xc3\xa4 vaaditaan'
b'DocType: Stock Settings',b'Default Valuation Method',b'oletus arvomenetelm\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26',b'Fee',b'Maksu'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +154',b'Update in progress. It might take a while.',b'P\xc3\xa4ivitys k\xc3\xa4ynniss\xc3\xa4. Voi kest\xc3\xa4\xc3\xa4 hetken.'
b'DocType: Production Plan Item',b'Produced Qty',b'Tuotettu m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Vehicle Log',b'Fuel Qty',b'polttoaineen m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Stock Entry',b'Target Warehouse Name',b'Kohdevaraston nimi'
b'DocType: Work Order Operation',b'Planned Start Time',b'Suunniteltu aloitusaika'
b'DocType: Course',b'Assessment',b'Arviointi'
b'DocType: Payment Entry Reference',b'Allocated',b'kohdennettu'
b'apps/erpnext/erpnext/config/accounts.py +267',b'Close Balance Sheet and book Profit or Loss.',b'Sulje tase- ja tuloslaskelma kirja'
b'DocType: Student Applicant',b'Application Status',b'sovellus status'
b'DocType: Sensitivity Test Items',b'Sensitivity Test Items',b'Herkkyyskoe'
b'DocType: Project Update',b'Project Update',b'Projektin p\xc3\xa4ivitys'
b'DocType: Fees',b'Fees',b'Maksut'
b'DocType: Currency Exchange',b'Specify Exchange Rate to convert one currency into another',b'm\xc3\xa4\xc3\xa4rit\xc3\xa4 valuutan muunnostaso vaihtaaksesi valuutan toiseen'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159',b'Quotation {0} is cancelled',b'Tarjous {0} on peruttu'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119',b'Total Outstanding Amount',b'odottava arvom\xc3\xa4\xc3\xa4r\xc3\xa4 yhteens\xc3\xa4'
b'DocType: Sales Partner',b'Targets',b'Tavoitteet'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54',b'Please register the SIREN number in the company information file',b'Rekister\xc3\xb6i SIREN-numero yritystiedostossa'
b'DocType: Price List',b'Price List Master',b'Hinnasto valvonta'
b'DocType: GST Account',b'CESS Account',b'CESS-tili'
b'DocType: Sales Person',b'All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.',b'kaikki myyntitapahtumat voidaan kohdistaa useammalle ** myyj\xc3\xa4lle ** tavoitteiden asettamiseen ja seurantaan'
,b'S.O. No.',b'Myyntitilaus nro'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241',b'Please create Customer from Lead {0}',b'Luo asiakkuus vihjeest\xc3\xa4 {0}'
b'apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3',b'Select Patient',b'Valitse potilas'
b'DocType: Price List',b'Applicable for Countries',b'Sovelletaan Maat'
b'DocType: Supplier Scorecard Scoring Variable',b'Parameter Name',b'Parametrin nimi'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52',b'Student Group Name is mandatory in row {0}',b'Opiskelija Ryhm\xc3\xa4n nimi on pakollinen rivin {0}'
b'DocType: Homepage',b'Products to be shown on website homepage',b'Verkkosivuston etusivulla n\xc3\xa4ytett\xc3\xa4v\xc3\xa4t tuotteet'
b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13',b'This is a root customer group and cannot be edited.',b'T\xc3\xa4m\xc3\xa4 on perusasiakasryhm\xc3\xa4 joka ei ole muokattavissa.'
b'DocType: Student',b'AB-',b'AB -'
b'DocType: POS Profile',b'Ignore Pricing Rule',b'ohita hinnoittelu s\xc3\xa4\xc3\xa4nt\xc3\xb6'
b'DocType: Employee Education',b'Graduate',b'valmistunut'
b'DocType: Leave Block List',b'Block Days',b'estop\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83',"b'Shipping Address does not have country, which is required for this Shipping Rule'","b'Toimitusosoitteella ei ole maata, joka vaaditaan t\xc3\xa4ss\xc3\xa4 l\xc3\xa4hetyss\xc3\xa4\xc3\xa4nn\xc3\xb6ss\xc3\xa4'"
b'DocType: Journal Entry',b'Excise Entry',b'aksiisikirjaus'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65',"b""Warning: Sales Order {0} already exists against Customer's Purchase Order {1}""",b'Varoitus: Myyntitilaus {0} on jo olemassa vastaan Asiakkaan Ostotilaus {1}'
b'DocType: Terms and Conditions',"b'Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.'","b'perusehdot, jotka voidaan lis\xc3\xa4t\xc3\xa4 myynteihin ja ostoihin esim, 1. tarjouksen voimassaolo 1. maksuehdot (ennakko, luotto, osaennakko jne) 1. lis\xc3\xa4kulut (asiakkaan maksettavaksi) 1. turvallisuus / k\xc3\xa4ytt\xc3\xb6varoitukset 1. takuuasiat 1. palautusoikeus. 1. toimitusehdot 1. riita-, korvaus- ja vastuuasioiden k\xc3\xa4sittely jne 1. omat osoite ja yhteystiedot'"
b'DocType: Issue',b'Issue Type',b'Julkaisutyyppi'
b'DocType: Attendance',b'Leave Type',b'Vapaan tyyppi'
b'DocType: Purchase Invoice',b'Supplier Invoice Details',b'Toimittaja Laskun tiedot'
b'DocType: Agriculture Task',b'Ignore holidays',b'Ohita vapaap\xc3\xa4iv\xc3\xa4t'
b'apps/erpnext/erpnext/controllers/stock_controller.py +233',"b""Expense / Difference account ({0}) must be a 'Profit or Loss' account""","b""Kustannus- / erotuksen tili ({0}) tulee olla 'tuloslaskelma' tili"""
b'DocType: Project',b'Copied From',b'kopioitu'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340',b'Invoice already created for all billing hours',b'Laskutus on jo luotu kaikille laskutustunteille'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96',b'Name error: {0}',b'Nimivirhe: {0}'
b'DocType: Cash Flow Mapping',b'Is Finance Cost',b'Onko rahoituskustannus'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18',b'Attendance for employee {0} is already marked',b'ty\xc3\xb6ntekij\xc3\xa4n {0} osallistuminen on jo merkitty'
b'DocType: Packing Slip',b'If more than one package of the same type (for print)',b'mik\xc3\xa4li useampi saman tyypin pakkaus (tulostus)'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27',b'Please set default customer in Restaurant Settings',b'Aseta oletusasiakas ravintolaasetuksissa'
,b'Salary Register',b'Palkka Register'
b'DocType: Warehouse',b'Parent Warehouse',b'P\xc3\xa4\xc3\xa4varasto'
b'DocType: C-Form Invoice Detail',b'Net Total',b'netto yhteens\xc3\xa4'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +546',b'Default BOM not found for Item {0} and Project {1}',b'Oletuksena BOM ei l\xc3\xb6ytynyt Tuote {0} ja Project {1}'
b'apps/erpnext/erpnext/config/hr.py +168',b'Define various loan types',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 eri laina tyypit'
b'DocType: Bin',b'FCFS Rate',b'FCFS taso'
b'DocType: Opening Invoice Creation Tool Item',b'Outstanding Amount',b'odottava arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/templates/generators/bom.html +71',b'Time(in mins)',b'Aika (min)'
b'DocType: Project Task',b'Working',b'Ty\xc3\xb6skennell\xc3\xa4'
b'DocType: Stock Ledger Entry',b'Stock Queue (FIFO)',b'varastojono (FIFO)'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +127',b'Financial Year',b'Talousvuosi'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46',b'{0} does not belong to Company {1}',b'{0} ei kuulu yritykseen {1}'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66',b'Could not solve criteria score function for {0}. Make sure the formula is valid.',"b'Ei voitu ratkaista kriteerien pisteet-funktiota {0}. Varmista, ett\xc3\xa4 kaava on kelvollinen.'"
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122',b'Cost as on',b'Cost kuin'
b'DocType: Healthcare Settings',b'Out Patient Settings',b'Out potilasasetukset'
b'DocType: Account',b'Round Off',b'py\xc3\xb6ristys'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259',b'Quantity must be positive',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 on positiivinen'
b'DocType: Material Request Plan Item',b'Requested Qty',b'pyydetty yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96',b'The fields From Shareholder and To Shareholder cannot be blank',b'Kent\xc3\xa4t Osakkeenomistajalta ja Osakkeenomistajalle eiv\xc3\xa4t voi olla tyhji\xc3\xa4'
b'DocType: Tax Rule',b'Use for Shopping Cart',b'K\xc3\xa4yt\xc3\xa4 ostoskoriin'
b'apps/erpnext/erpnext/controllers/item_variant.py +101',b'Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}',b'Arvo {0} attribuutille {1} ei ole voimassa olevien kohdeattribuuttien luettelossa tuotteelle {2}'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79',b'Select Serial Numbers',b'Valitse sarjanumerot'
b'DocType: BOM Item',b'Scrap %',b'Romu %'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46',"b'Charges will be distributed proportionately based on item qty or amount, as per your selection'","b'maksut jaetaan suhteellisesti tuotteiden yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4n tai arvom\xc3\xa4\xc3\xa4r\xc3\xa4n mukaan, m\xc3\xa4\xc3\xa4rityksen perusteella'"
b'DocType: Maintenance Visit',b'Purposes',b'Tarkoituksiin'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112',b'Atleast one item should be entered with negative quantity in return document',b'v\xc3\xa4hint\xc3\xa4\xc3\xa4n yhdell\xc3\xa4 tuottella tulee olla negatiivinen m\xc3\xa4\xc3\xa4r\xc3\xa4 palautus asiakirjassa'
b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71',"b'Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations'","b'tuote {0} kauemmin kuin mik\xc3\xa4\xc3\xa4n saatavillaoleva ty\xc3\xb6aika ty\xc3\xb6asemalla {1}, hajoavat toiminta useiksi toiminnoiksi'"
b'DocType: Membership',b'Membership Status',b'J\xc3\xa4senyyden tila'
,b'Requested',b'Pyydetty'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93',b'No Remarks',b'Ei huomautuksia'
b'DocType: Asset',b'In Maintenance',b'Huollossa'
b'DocType: Purchase Invoice',b'Overdue',b'My\xc3\xb6h\xc3\xa4ss\xc3\xa4'
b'DocType: Account',b'Stock Received But Not Billed',b'varasto vastaanotettu mutta ei laskutettu'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +84',b'Root Account must be a group',b'Root on ryhm\xc3\xa4'
b'DocType: Drug Prescription',b'Drug Prescription',b'L\xc3\xa4\xc3\xa4kehoito'
b'DocType: Fees',b'FEE.',b'MAKSU.'
b'DocType: Employee Loan',b'Repaid/Closed',b'Palautettava / Suljettu'
b'DocType: Item',b'Total Projected Qty',b'Arvioitu kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Monthly Distribution',b'Distribution Name',"b'toimitus, nimi'"
b'apps/erpnext/erpnext/stock/stock_ledger.py +477',"b'Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry'","b'Arviointikurssia ei ole l\xc3\xb6ytynyt {0}, joka on velvollinen tekem\xc3\xa4\xc3\xa4n kirjanpitoarvot {1} {2}. Jos kohde k\xc3\xa4sitell\xc3\xa4\xc3\xa4n {1}: n nollaarvostuskorkoineen, mainitse {1} kohtaan taulukossa. Muussa tapauksessa luo saapuva osakekauppa kohteen kohtaan tai mainitse arvonm\xc3\xa4\xc3\xa4rityskorvaus Item-tietueessa ja yrit\xc3\xa4 sitten l\xc3\xa4hett\xc3\xa4\xc3\xa4 tai peruuttaa t\xc3\xa4m\xc3\xa4 merkint\xc3\xa4'"
b'DocType: Course',b'Course Code',b'Course koodi'
b'apps/erpnext/erpnext/controllers/stock_controller.py +337',b'Quality Inspection required for Item {0}',b'Tuotteelle {0} laatutarkistus'
b'DocType: POS Settings',b'Use POS in Offline Mode',b'K\xc3\xa4yt\xc3\xa4 POS Offline-tilassa'
b'DocType: Supplier Scorecard',b'Supplier Variables',b'Toimittajan muuttujat'
b'DocType: Quotation',"b""Rate at which customer's currency is converted to company's base currency""","b'taso, jolla asiakkaan valuutta muunnetaan yrityksen k\xc3\xa4ytt\xc3\xa4m\xc3\xa4ksi perusvaluutaksi'"
b'DocType: Purchase Invoice Item',b'Net Rate (Company Currency)',b'nettotaso (yrityksen valuutta)'
b'DocType: Salary Detail',b'Condition and Formula Help',b'Ehto ja Formula Ohje'
b'apps/erpnext/erpnext/config/selling.py +105',b'Manage Territory Tree.',b'hallitse aluepuuta'
b'DocType: Patient Service Unit',b'Patient Service Unit',b'Potilaspalveluyksikk\xc3\xb6'
b'DocType: Journal Entry Account',b'Sales Invoice',b'Myyntilasku'
b'DocType: Journal Entry Account',b'Party Balance',b'Osatase'
b'DocType: Cash Flow Mapper',b'Section Subtotal',b'Osasto Yhteens\xc3\xa4'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +498',b'Please select Apply Discount On',b'Valitse k\xc3\xa4yt\xc3\xa4 alennusta'
b'DocType: Stock Settings',b'Sample Retention Warehouse',b'N\xc3\xa4ytteen s\xc3\xa4ilytysvarasto'
b'DocType: Company',b'Default Receivable Account',b'oletus saatava tili'
b'DocType: Physician Schedule',b'Physician Schedule',b'L\xc3\xa4\xc3\xa4k\xc3\xa4ri Aikataulu'
b'DocType: Purchase Invoice',b'Deemed Export',b'Katsottu vienti'
b'DocType: Stock Entry',b'Material Transfer for Manufacture',b'Varastosiirto tuotantoon'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20',b'Discount Percentage can be applied either against a Price List or for all Price List.',"b'alennusprosenttia voi soveltaa yhteen, tai useampaan hinnastoon'"
b'DocType: Subscription',b'Half-yearly',b'6 kk'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407',b'Accounting Entry for Stock',b'Kirjanpidon varastotapahtuma'
b'DocType: Lab Test',b'LabTest Approver',b'LabTest Approver'
b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61',b'You have already assessed for the assessment criteria {}.',b'Olet jo arvioitu arviointikriteerit {}.'
b'DocType: Vehicle Service',b'Engine Oil',b'Moottori\xc3\xb6ljy'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1005',b'Work Orders Created: {0}',b'Luodut ty\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4ykset: {0}'
b'DocType: Sales Invoice',b'Sales Team1',b'Myyntitiimi 1'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +547',b'Item {0} does not exist',b'tuotetta {0} ei ole olemassa'
b'DocType: Sales Invoice',b'Customer Address',b'Asiakkaan osoite'
b'DocType: Employee Loan',b'Loan Details',b'Loan tiedot'
b'DocType: Company',b'Default Inventory Account',b'Oletus Inventory Tili'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192',b'The folio numbers are not matching',b'Folio-numerot eiv\xc3\xa4t t\xc3\xa4sm\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124',b'Row {0}: Completed Qty must be greater than zero.',b'Rivi {0}: Valmis M\xc3\xa4\xc3\xa4r\xc3\xa4 on oltava suurempi kuin nolla.'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262',b'Payment Request for {0}',b'Maksupyynt\xc3\xb6 {0}'
b'DocType: Item Barcode',b'Barcode Type',b'Viivakoodityyppi'
b'DocType: Antibiotic',b'Antibiotic Name',b'Antibioottin nimi'
b'DocType: Purchase Invoice',b'Apply Additional Discount On',b'k\xc3\xa4yt\xc3\xa4 lis\xc3\xa4alennusta'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66',b'Select Type...',b'Valitse tyyppi ...'
b'DocType: Crop Cycle',b'A link to all the Land Units in which the Crop is growing',"b'Linkki kaikkiin maayksik\xc3\xb6ihin, joissa viljely kasvaa'"
b'DocType: Account',b'Root Type',b'kantatyyppi'
b'DocType: Item',b'FIFO',b'FIFO'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136',b'Row # {0}: Cannot return more than {1} for Item {2}',b'rivi # {0}: ei voi palauttaa enemm\xc3\xa4n kuin {1} tuotteelle {2}'
b'DocType: Item Group',b'Show this slideshow at the top of the page',b'N\xc3\xa4yt\xc3\xa4 t\xc3\xa4m\xc3\xa4 diaesitys sivun yl\xc3\xa4reunassa'
b'DocType: BOM',b'Item UOM',b'tuote UOM'
b'DocType: Sales Taxes and Charges',b'Tax Amount After Discount Amount (Company Currency)',b'Veron arvom\xc3\xa4\xc3\xa4r\xc3\xa4 alennusten j\xc3\xa4lkeen (yrityksen valuutta)'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177',b'Target warehouse is mandatory for row {0}',b'Kohdevarasto on pakollinen rivill\xc3\xa4 {0}'
b'DocType: Cheque Print Template',b'Primary Settings',b'Perusasetukset'
b'DocType: Purchase Invoice',b'Select Supplier Address',b'Valitse toimittajan osoite'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397',b'Add Employees',b'Lis\xc3\xa4\xc3\xa4 Ty\xc3\xb6ntekij\xc3\xa4t'
b'DocType: Purchase Invoice Item',b'Quality Inspection',b'Laatutarkistus'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196',b'Extra Small',b'eritt\xc3\xa4in pieni'
b'DocType: Company',b'Standard Template',b'Standard Template'
b'DocType: Training Event',b'Theory',b'Teoria'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806',b'Warning: Material Requested Qty is less than Minimum Order Qty',b'Varoitus: Pyydetty materiaalin m\xc3\xa4\xc3\xa4r\xc3\xa4 alittaa minimi hankintaer\xc3\xa4n'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211',b'Account {0} is frozen',b'tili {0} on j\xc3\xa4\xc3\xa4dytetty'
b'DocType: Company',b'Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.',"b'juridinen hl\xc3\xb6 / tyt\xc3\xa4ryhti\xc3\xb6, jolla on erillinen tilikartta kuuluu organisaatioon'"
b'DocType: Payment Request',b'Mute Email',b'Mute S\xc3\xa4hk\xc3\xb6posti'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29',"b'Food, Beverage & Tobacco'","b'Ruoka, Juoma ja Tupakka'"
b'DocType: Account',b'Account Number',b'Tilinumero'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752',b'Can only make payment against unbilled {0}',b'Voi vain maksun vastaan laskuttamattomia {0}'
b'apps/erpnext/erpnext/controllers/selling_controller.py +102',b'Commission rate cannot be greater than 100',b'provisio taso ei voi olla suurempi kuin 100'
b'DocType: Volunteer',b'Volunteer',b'vapaaehtoinen'
b'DocType: Stock Entry',b'Subcontract',b'alihankinta'
b'apps/erpnext/erpnext/public/js/utils/party.js +166',b'Please enter {0} first',b'Kirjoita {0} ensimm\xc3\xa4isen'
b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104',b'No replies from',b'Ei vastauksia'
b'DocType: Work Order Operation',b'Actual End Time',b'todellinen p\xc3\xa4\xc3\xa4ttymisaika'
b'DocType: Item',b'Manufacturer Part Number',b'valmistajan osanumero'
b'DocType: Work Order Operation',b'Estimated Time and Cost',b'arvioitu aika ja kustannus'
b'DocType: Bin',b'Bin',b'Astia'
b'DocType: Crop',b'Crop Name',b'Rajaa nimi'
b'DocType: SMS Log',b'No of Sent SMS',b'L\xc3\xa4hetetyn SMS-viestin numero'
b'DocType: Antibiotic',b'Healthcare Administrator',b'Terveydenhuollon hallinto'
b'apps/erpnext/erpnext/utilities/user_progress.py +47',b'Set a Target',b'Aseta kohde'
b'DocType: Dosage Strength',b'Dosage Strength',b'Annostusvoima'
b'DocType: Account',b'Expense Account',b'Kustannustili'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49',b'Software',b'Ohjelmisto'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203',b'Colour',b'v\xc3\xa4rit\xc3\xa4'
b'DocType: Assessment Plan Criteria',b'Assessment Plan Criteria',b'Assessment Plan Criteria'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +118',b'Expiry date is mandatory for selected item',b'Viimeinen voimassaolop\xc3\xa4iv\xc3\xa4 on pakollinen valitulle kohteelle'
b'DocType: Supplier Scorecard Scoring Standing',b'Prevent Purchase Orders',b'Est\xc3\xa4\xc3\xa4 ostotilaukset'
b'apps/erpnext/erpnext/healthcare/setup.py +258',b'Susceptible',b'herkk\xc3\xa4'
b'DocType: Patient Appointment',b'Scheduled',b'Aikataulutettu'
b'apps/erpnext/erpnext/config/buying.py +18',b'Request for quotation.',b'Tarjouspyynt\xc3\xb6.'
b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13',"b'Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle'",b'Valitse nimike joka ei ole varastonimike mutta on myyntinimike. Toista samaa tuotepakettia ei saa olla.'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148',b'Select Customer',b'Valitse asiakas'
b'DocType: Student Log',b'Academic',b'akateeminen'
b'DocType: Patient',b'Personal and Social History',b'Henkil\xc3\xb6kohtainen ja sosiaalinen historia'
b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51',b'User {0} created',b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4 {0} luotiin'
b'DocType: Fee Schedule',b'Fee Breakup for each student',b'Palkkioerot kunkin opiskelijan osalta'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +541',b'Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2})',b'Yhteens\xc3\xa4 etuk\xc3\xa4teen ({0}) vastaan Order {1} ei voi olla suurempi kuin Grand Total ({2})'
b'DocType: Sales Partner',b'Select Monthly Distribution to unevenly distribute targets across months.',b'Valitse toimitusten kk jaksotus tehd\xc3\xa4ksesi kausiluonteiset toimitusttavoitteet'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78',b'Change Code',b'Vaihda koodi'
b'DocType: Purchase Invoice Item',b'Valuation Rate',b'Arvostustaso'
b'DocType: Stock Reconciliation',b'SR/',b'SR /'
b'DocType: Vehicle',b'Diesel',b'diesel-'
b'apps/erpnext/erpnext/stock/get_item_details.py +388',b'Price List Currency not selected',"b'Hinnasto, valuutta ole valittu'"
b'DocType: Purchase Invoice',b'Availed ITC Cess',b'K\xc3\xa4ytti ITC Cessia'
,b'Student Monthly Attendance Sheet',b'Student Kuukauden L\xc3\xa4sn\xc3\xa4olo Sheet'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96',b'Shipping rule only applicable for Selling',b'Myyntiin sovellettava toimituss\xc3\xa4\xc3\xa4nt\xc3\xb6'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30',b'Project Start Date',b'Projekti aloitusp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23',b'Until',b'Asti'
b'DocType: Rename Tool',b'Rename Log',b'Nime\xc3\xa4 Loki'
b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Opiskelijaryhm\xc3\xa4n tai kurssin aikataulu on pakollinen'
b'DocType: HR Settings',b'Maintain Billing Hours and Working Hours Same on Timesheet',b'Pid\xc3\xa4 laskutus- ja ty\xc3\xb6skentelytunnit samoina tuntilomakkeella.'
b'DocType: Maintenance Visit Purpose',b'Against Document No',b'Dokumentin nro kohdistus'
b'DocType: BOM',b'Scrap',b'Romu'
b'apps/erpnext/erpnext/utilities/user_progress.py +217',b'Go to Instructors',b'Siirry opettajille'
b'apps/erpnext/erpnext/config/selling.py +110',b'Manage Sales Partners.',b'hallitse myyntikumppaneita'
b'DocType: Quality Inspection',b'Inspection Type',b'tarkistus tyyppi'
b'DocType: Fee Validity',b'Visited yet',b'K\xc3\xa4yn viel\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134',b'Warehouses with existing transaction can not be converted to group.',b'Varastoissa nykyisten tapahtumaa ei voida muuntaa ryhm\xc3\xa4\xc3\xa4n.'
b'DocType: Assessment Result Tool',b'Result HTML',b'tulos HTML'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35',b'Expires On',b'Vanhemee'
b'apps/erpnext/erpnext/utilities/activation.py +117',b'Add Students',b'Lis\xc3\xa4\xc3\xa4 Opiskelijat'
b'apps/erpnext/erpnext/public/js/utils.js +270',b'Please select {0}',b'Ole hyv\xc3\xa4 ja valitse {0}'
b'DocType: C-Form',b'C-Form No',b'C-muoto nro'
b'DocType: BOM',b'Exploded_items',b'r\xc3\xa4j\xc3\xa4ytetyt_tuotteet'
b'apps/erpnext/erpnext/utilities/user_progress.py +139',b'List your products or services that you buy or sell.',"b'Luetteloi tuotteet tai palvelut, joita ostetaan tai myyd\xc3\xa4\xc3\xa4n.'"
b'DocType: Water Analysis',b'Storage Temperature',b'S\xc3\xa4ilytysl\xc3\xa4mp\xc3\xb6tila'
b'DocType: Employee Attendance Tool',b'Unmarked Attendance',b'Merkitsem\xc3\xa4t\xc3\xb6n L\xc3\xa4sn\xc3\xa4olo'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137',b'Researcher',b'Tutkija'
b'DocType: Program Enrollment Tool Student',b'Program Enrollment Tool Student',b'Ohjelma Ilmoittautuminen Tool Student'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16',b'Start date should be less than end date for task {0}',b'Aloitusp\xc3\xa4iv\xc3\xa4 olisi pienempi kuin teht\xc3\xa4v\xc3\xa4 {0}'
b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25',b'Name or Email is mandatory',b'Nimi tai S\xc3\xa4hk\xc3\xb6posti on pakollinen'
b'DocType: Member',b'MEM-',b'MEM-'
b'DocType: Instructor',b'Instructor Log',b'Ohjaajan loki'
b'DocType: Purchase Order Item',b'Returned Qty',b'Palautetut Kpl'
b'DocType: Student',b'Exit',b'poistu'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +156',b'Root Type is mandatory',b'kantatyyppi vaaditaan'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29',b'Failed to install presets',b'Esiasetusten asentaminen ep\xc3\xa4onnistui'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44',"b'{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.'","b'{0} on t\xc3\xa4ll\xc3\xa4 hetkell\xc3\xa4 {1} toimittajatietokortin seisominen, ja t\xc3\xa4m\xc3\xa4n toimittajan pyynn\xc3\xb6st\xc3\xa4 tulisi antaa varovaisuus.'"
b'DocType: Chapter',b'Non Profit Manager',b'Non Profit Manager'
b'DocType: BOM',b'Total Cost(Company Currency)',b'Kokonaiskustannukset (Company valuutta)'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315',b'Serial No {0} created',b'Sarjanumeron on luonut {0}'
b'DocType: Homepage',b'Company Description for website homepage',b'Verkkosivuston etusivulle sijoitettava yrityksen kuvaus'
b'DocType: Item Customer Detail',"b'For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes'",b'voit tulostaa n\xc3\xa4m\xc3\xa4 koodit tulostusmuodoissa asiakirjoihin kuten laskut ja l\xc3\xa4hetteet asiakkaiden ty\xc3\xb6n helpottamiseksi'
b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18',b'Suplier Name',b'suplier Name'
b'apps/erpnext/erpnext/accounts/report/financial_statements.py +174',b'Could not retrieve information for {0}.',b'Tietoja {0} ei l\xc3\xb6ytynyt.'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134',b'Opening Entry Journal',b'Avausp\xc3\xa4iv\xc3\xa4kirja'
b'DocType: Sales Invoice',b'Time Sheet List',b'Tuntilistaluettelo'
b'DocType: Employee',b'You can enter any date manually',b'voit kirjoittaa mink\xc3\xa4 tahansa p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4n manuaalisesti'
b'DocType: Healthcare Settings',b'Result Printed',b'Tulos tulostettu'
b'DocType: Asset Category Account',b'Depreciation Expense Account',b'Poistokustannusten tili'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233',b'Probationary Period',b'Koeaika'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32',b'View {0}',b'N\xc3\xa4yt\xc3\xa4 {0}'
b'DocType: Customer Group',b'Only leaf nodes are allowed in transaction',b'Vain jatkosidokset ovat sallittuja tapahtumassa'
b'DocType: Project',b'Total Costing Amount (via Timesheets)',b'Kokonaiskustannusm\xc3\xa4\xc3\xa4r\xc3\xa4 (aikataulujen mukaan)'
b'DocType: Employee Advance',b'Expense Approver',b'Kulukorvausten hyv\xc3\xa4ksyj\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136',b'Row {0}: Advance against Customer must be credit',b'Rivi {0}: Advance vastaan asiakkaan on luotto'
b'DocType: Project',b'Hourly',b'tunti-'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +89',b'Non-Group to Group',b'Non-ryhm\xc3\xa4n Group'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Er\xc3\xa4 on pakollinen rivill\xc3\xa4 {0}'
b'DocType: Purchase Receipt Item Supplied',b'Purchase Receipt Item Supplied',b'Saapumistositteen nimike toimitettu'
b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'To Datetime',b'Aikajana'
b'apps/erpnext/erpnext/config/selling.py +302',b'Logs for maintaining sms delivery status',b'Lokit yll\xc3\xa4pit\xc3\xa4miseksi sms toimituksen tila'
b'DocType: Accounts Settings',b'Make Payment via Journal Entry',b'Tee Maksu P\xc3\xa4iv\xc3\xa4kirjakirjaus'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +223',b'Printed On',b'painettu'
b'DocType: Item',b'Inspection Required before Delivery',b'Tarkastus Pakollinen ennen Delivery'
b'DocType: Item',b'Inspection Required before Purchase',b'Tarkastus Pakollinen ennen Purchase'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93',b'Pending Activities',b'Odottaa Aktiviteetit'
b'DocType: Patient Appointment',b'Reminded',b'muistutti'
b'DocType: Patient',b'PID-',b'PID-'
b'DocType: Chapter Member',b'Chapter Member',b'Luku J\xc3\xa4sen'
b'DocType: Material Request Plan Item',b'Minimum Order Quantity',b'v\xc3\xa4himm\xc3\xa4istilausm\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +106',b'Your Organization',b'Organisaation'
b'DocType: Fee Component',b'Fees Category',b'Maksut Luokka'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +134',b'Please enter relieving date.',b'Sy\xc3\xb6t\xc3\xa4 lievitt\xc3\xa4\xc3\xa4 p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4.'
b'apps/erpnext/erpnext/controllers/trends.py +149',b'Amt',b'pankkip\xc3\xa4\xc3\xa4te'
b'DocType: Supplier Scorecard',b'Notify Employee',b'Ilmoita ty\xc3\xb6ntekij\xc3\xa4lle'
b'DocType: Opportunity',b'Enter name of campaign if source of enquiry is campaign',b'sy\xc3\xb6t\xc3\xa4 kampanjan nimi jos kirjauksen l\xc3\xa4hde on kampanja'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38',b'Newspaper Publishers',b'Newspaper Publishers'
b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30',b'Select Fiscal Year',b'Valitse tilikausi'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115',b'Expected Delivery Date should be after Sales Order Date',b'Odotettu toimitusp\xc3\xa4iv\xc3\xa4 on myynnin tilausp\xc3\xa4iv\xc3\xa4n j\xc3\xa4lkeen'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42',b'Reorder Level',b'T\xc3\xa4ydennystilaustaso'
b'DocType: Company',b'Chart Of Accounts Template',b'Tilikartta Template'
b'DocType: Attendance',b'Attendance Date',"b'osallistuminen, p\xc3\xa4iv\xc3\xa4'"
b'apps/erpnext/erpnext/stock/get_item_details.py +352',b'Item Price updated for {0} in Price List {1}',b'Hinta p\xc3\xa4ivitetty {0} in hinnasto {1}'
b'DocType: Salary Structure',b'Salary breakup based on Earning and Deduction.',b'Palkkaerittelyn kohdistetut ansiot ja v\xc3\xa4hennykset'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +128',b'Account with child nodes cannot be converted to ledger',b'tilin alasidoksia ei voi muuttaa tilikirjaksi'
b'DocType: Purchase Invoice Item',b'Accepted Warehouse',b'hyv\xc3\xa4ksytyt varasto'
b'DocType: Bank Reconciliation Detail',b'Posting Date',b'Tositep\xc3\xa4iv\xc3\xa4'
b'DocType: Item',b'Valuation Method',b'Arvomenetelm\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203',b'Mark Half Day',b'Mark Half Day'
b'DocType: Sales Invoice',b'Sales Team',b'Myyntitiimi'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87',b'Duplicate entry',b'monista kirjaus'
b'DocType: Program Enrollment Tool',b'Get Students',b'Hanki Opiskelijat'
b'DocType: Serial No',b'Under Warranty',b'Takuu voimassa'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516',b'[Error]',b'[virhe]'
b'DocType: Sales Order',b'In Words will be visible once you save the Sales Order.',"b'sanat n\xc3\xa4kyv\xc3\xa4t, kun tallennat myyntitilauksen'"
,b'Employee Birthday',b'Ty\xc3\xb6ntekij\xc3\xa4n syntym\xc3\xa4p\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14',b'Please select Completion Date for Completed Repair',b'Valitse Valmis-korjauksen p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Student Batch Attendance Tool',b'Student Batch Attendance Tool',b'Student Er\xc3\xa4 L\xc3\xa4sn\xc3\xa4olo Tool'
b'apps/erpnext/erpnext/controllers/status_updater.py +213',b'Limit Crossed',b'Raja ylitetty'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22',b'Scheduled Upto',b'Suunniteltu yl\xc3\xb6sp\xc3\xa4in'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55',b'Venture Capital',b'P\xc3\xa4\xc3\xa4omasijoitus'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40',"b""An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.""",b'Lukukaudessa t\xc3\xa4ll\xc3\xa4 &quot;Lukuvuosi {0} ja&quot; Term Name &#39;{1} on jo olemassa. Ole hyv\xc3\xa4 ja muokata n\xc3\xa4it\xc3\xa4 merkint\xc3\xb6j\xc3\xa4 ja yrit\xc3\xa4 uudelleen.'
b'DocType: UOM',b'Must be Whole Number',b't\xc3\xa4ytyy olla kokonaisluku'
b'DocType: Leave Control Panel',b'New Leaves Allocated (In Days)',b'uusi poistumisten kohdennus (p\xc3\xa4ivi\xc3\xa4)'
b'DocType: Purchase Invoice',b'Invoice Copy',b'laskukopion'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49',b'Serial No {0} does not exist',b'Sarjanumeroa {0} ei ole olemassa'
b'DocType: Sales Invoice Item',b'Customer Warehouse (Optional)',b'Asiakkaan varasto (valinnainen)'
b'DocType: Pricing Rule',b'Discount Percentage',b'Alennusprosentti'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51',b'Reserved for sub contracting',b'Varattu alihankintaan'
b'DocType: Payment Reconciliation Invoice',b'Invoice Number',b'laskun numero'
b'DocType: Shopping Cart Settings',b'Orders',b'Tilaukset'
b'DocType: Employee Leave Approver',b'Leave Approver',b'Poissaolojen hyv\xc3\xa4ksyj\xc3\xa4'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285',b'Please select a batch',b'Valitse er\xc3\xa4'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalLib',b'JournalLib'
b'DocType: Assessment Group',b'Assessment Group Name',b'Assessment Group Name'
b'DocType: Manufacturing Settings',b'Material Transferred for Manufacture',b'Tuotantoon siirretyt materiaalit'
b'DocType: Landed Cost Item',b'Receipt Document Type',b'Kuitti Document Type'
b'DocType: Daily Work Summary Settings',b'Select Companies',b'Valitse Yritykset'
b'DocType: Antibiotic',b'Healthcare',b'Terveydenhuolto'
b'DocType: Target Detail',b'Target Detail',b'Tavoite lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +65',b'Single Variant',b'Yksi variantti'
b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24',b'All Jobs',b'kaikki ty\xc3\xb6t'
b'DocType: Sales Order',b'% of materials billed against this Sales Order',b'% myyntitilauksen materiaaleista laskutettu'
b'DocType: Program Enrollment',b'Mode of Transportation',b'Kuljetusmuoto'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49',b'Period Closing Entry',b'Kauden sulkukirjaus'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72',b'Select Department...',b'Valitse osasto ...'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38',b'Cost Center with existing transactions can not be converted to group',b'olemassaolevien tapahtumien kustannuspaikkaa ei voi muuttaa ryhm\xc3\xa4ksi'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374',b'Amount {0} {1} {2} {3}',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 {0} {1} {2} {3}'
b'DocType: Account',b'Depreciation',b'arvonalennus'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102',b'The number of shares and the share numbers are inconsistent',b'Osakkeiden lukum\xc3\xa4\xc3\xa4r\xc3\xa4 ja osakem\xc3\xa4\xc3\xa4r\xc3\xa4 ovat ep\xc3\xa4johdonmukaisia'
b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49',b'Supplier(s)',b'toimittaja/toimittajat'
b'DocType: Employee Attendance Tool',b'Employee Attendance Tool',b'Ty\xc3\xb6ntekij\xc3\xa4n l\xc3\xa4sn\xc3\xa4olo Tool'
b'DocType: Guardian Student',b'Guardian Student',b'Guardian Student'
b'DocType: Supplier',b'Credit Limit',b'luottoraja'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Selling Price List Rate',b'Keskim. Myynnin hinnasto'
b'DocType: Salary Component',b'Salary Component',b'Palkanosasta'
b'apps/erpnext/erpnext/accounts/utils.py +495',b'Payment Entries {0} are un-linked',b'Maksu merkinn\xc3\xa4t {0} ovat un sidottu'
b'DocType: GL Entry',b'Voucher No',b'Tosite nro'
,b'Lead Owner Efficiency',b'Lyijy Omistaja Tehokkuus'
b'DocType: Leave Allocation',b'Leave Allocation',b'Vapaan kohdistus'
b'DocType: Payment Request',b'Recipient Message And Payment Details',b'Vastaanottaja Message ja maksutiedot'
b'DocType: Training Event',b'Trainer Email',b'Trainer S\xc3\xa4hk\xc3\xb6posti'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550',b'Material Requests {0} created',b'Hankintapyynt\xc3\xb6j\xc3\xa4 luotu {0}'
b'DocType: Restaurant Reservation',b'No of People',b'Ihmisten m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/config/selling.py +164',b'Template of terms or contract.',b'Sopimusehtojen mallipohja'
b'DocType: Purchase Invoice',b'Address and Contact',b'Osoite ja yhteystiedot'
b'DocType: Cheque Print Template',b'Is Account Payable',b'Onko tili Maksettava'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276',b'Stock cannot be updated against Purchase Receipt {0}',b'Varastoa ei voida p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 saapumista {0} vastaan'
b'DocType: Support Settings',b'Auto close Issue after 7 days',b'Auto l\xc3\xa4hell\xc3\xa4 Issue 7 p\xc3\xa4iv\xc3\xa4n j\xc3\xa4lkeen'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71',"b'Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Vapaita ei voida k\xc3\xa4ytt\xc3\xa4\xc3\xa4 ennen {0}, koska k\xc3\xa4ytett\xc3\xa4viss\xc3\xa4 olevat vapaat on jo siirretty eteenp\xc3\xa4in jaksolle {1}'"
b'apps/erpnext/erpnext/accounts/party.py +317',b'Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)',b'huom: viitep\xc3\xa4iv\xc3\xa4 huomioiden asiakkaan luottoraja ylittyy {0} p\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/program/program.js +8',b'Student Applicant',b'Student Hakija'
b'DocType: Purchase Invoice',b'ORIGINAL FOR RECIPIENT',b'ORIGINAL RECIPIENT'
b'DocType: Asset Category Account',b'Accumulated Depreciation Account',b'Kertyneiden poistojen tili'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11',b'This email is autogenerated',b'T\xc3\xa4m\xc3\xa4 s\xc3\xa4hk\xc3\xb6posti on automaattinen'
b'DocType: Stock Settings',b'Freeze Stock Entries',b'j\xc3\xa4\xc3\xa4dyt\xc3\xa4 varaston kirjaukset'
b'DocType: Program Enrollment',b'Boarding Student',b'lennolle Student'
b'DocType: Asset',b'Expected Value After Useful Life',b'Odotusarvo j\xc3\xa4lkeen k\xc3\xa4ytt\xc3\xb6i\xc3\xa4n'
b'DocType: Item',b'Reorder level based on Warehouse',b'Varastoon perustuva t\xc3\xa4ydennystilaustaso'
b'DocType: Activity Cost',b'Billing Rate',b'Laskutus taso'
,b'Qty to Deliver',b'Toimitettava yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
,b'Stock Analytics',b'Varastoanalytiikka'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523',b'Operations cannot be left blank',b'Toimintaa ei voi j\xc3\xa4tt\xc3\xa4\xc3\xa4 tyhj\xc3\xa4ksi'
b'DocType: Maintenance Visit Purpose',b'Against Document Detail No',b'Dokumentin yksityiskohta nro kohdistus'
b'apps/erpnext/erpnext/regional/__init__.py +11',b'Deletion is not permitted for country {0}',b'Poistaminen ei ole sallittua maan {0}'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110',b'Party Type is mandatory',b'Osapuoli tyyppi on pakollinen'
b'DocType: Quality Inspection',b'Outgoing',b'L\xc3\xa4htev\xc3\xa4'
b'DocType: Material Request',b'Requested For',b'Pyydetty kohteelle'
b'DocType: Quotation Item',b'Against Doctype',b'koskien tietuetyyppi\xc3\xa4'
b'apps/erpnext/erpnext/controllers/buying_controller.py +404',b'{0} {1} is cancelled or closed',b'{0} {1} on peruutettu tai suljettu'
b'DocType: Asset',b'Calculate Depreciation',b'Laske poistot'
b'DocType: Delivery Note',b'Track this Delivery Note against any Project',b'seuraa t\xc3\xa4t\xc3\xa4 l\xc3\xa4hetett\xc3\xa4 kohdistettuna projektiin'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35',b'Net Cash from Investing',b'Investointien nettokassavirta'
b'DocType: Work Order',b'Work-in-Progress Warehouse',b'Ty\xc3\xb6nalla varasto'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111',b'Asset {0} must be submitted',b'Omaisuus {0} pit\xc3\xa4\xc3\xa4 olla vahvistettu'
b'DocType: Fee Schedule Program',b'Total Students',b'Opiskelijat yhteens\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56',b'Attendance Record {0} exists against Student {1}',b'L\xc3\xa4sn\xc3\xa4olo Record {0} on olemassa vastaan Opiskelija {1}'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354',b'Reference #{0} dated {1}',b'Viite # {0} p\xc3\xa4iv\xc3\xa4tty {1}'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164',b'Depreciation Eliminated due to disposal of assets',b'Poistot Putosi johtuu omaisuuden myynnist\xc3\xa4'
b'DocType: Member',b'Member',b'J\xc3\xa4sen'
b'apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15',b'Manage Addresses',b'Hallitse Osoitteet'
b'DocType: Work Order Item',b'Work Order Item',b'Ty\xc3\xb6j\xc3\xa4rjestys'
b'DocType: Pricing Rule',b'Item Code',b'Nimikekoodi'
b'DocType: Serial No',b'Warranty / AMC Details',b'Takuun / yll\xc3\xa4pidon lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',b'Valitse opiskelijat manuaalisesti Toiminto perustuu ryhm\xc3\xa4n'
b'DocType: Journal Entry',b'User Remark',b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4 huomautus'
b'DocType: Lead',b'Market Segment',b'Market Segment'
b'DocType: Agriculture Analysis Criteria',b'Agriculture Manager',b'Maatalousp\xc3\xa4\xc3\xa4llikk\xc3\xb6'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966',b'Paid Amount cannot be greater than total negative outstanding amount {0}',b'Maksettu summa ei voi olla suurempi kuin koko negatiivinen j\xc3\xa4ljell\xc3\xa4 {0}'
b'DocType: Supplier Scorecard Period',b'Variables',b'muuttujat'
b'DocType: Employee Internal Work History',b'Employee Internal Work History',b'ty\xc3\xb6ntekij\xc3\xa4n sis\xc3\xa4inen ty\xc3\xb6historia'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249',b'Closing (Dr)',b'sulku (dr)'
b'DocType: Cheque Print Template',b'Cheque Size',b'Shekki Koko'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232',b'Serial No {0} not in stock',b'Sarjanumero {0} ei varastossa'
b'apps/erpnext/erpnext/config/selling.py +169',b'Tax template for selling transactions.',b'Veromallipohja myyntitapahtumiin'
b'DocType: Sales Invoice',b'Write Off Outstanding Amount',b'Poiston odottava arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27',b'Account {0} does not match with Company {1}',b'Tilin {0} ei vastaa yhti\xc3\xb6n {1}'
b'DocType: Education Settings',b'Current Academic Year',b'Nykyinen Lukuvuosi'
b'DocType: Stock Settings',b'Default Stock UOM',b'Oletusvarastoyksikk\xc3\xb6'
b'DocType: Asset',b'Number of Depreciations Booked',b'Kirjattujen poistojen lukum\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/public/js/pos/pos.html +71',b'Qty Total',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 yhteens\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32',b'Against Employee Loan: {0}',b'Vastaan ty\xc3\xb6ntekij\xc3\xa4 lainan: {0}'
b'DocType: Landed Cost Item',b'Receipt Document',b'kuitti Document'
b'DocType: Employee Education',b'School/University',b'Koulu/Yliopisto'
b'DocType: Payment Request',b'Reference Details',b'Viite Tietoja'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +56',b'Expected Value After Useful Life must be less than Gross Purchase Amount',b'Odotusarvo j\xc3\xa4lkeen k\xc3\xa4ytt\xc3\xb6i\xc3\xa4n on oltava alle Gross Purchase M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Sales Invoice Item',b'Available Qty at Warehouse',b'saatava varaston yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Billed Amount',b'laskutettu'
b'DocType: Share Transfer',b'(including)',b'(mukaan lukien)'
b'DocType: Asset',b'Double Declining Balance',b'Double j\xc3\xa4\xc3\xa4nn\xc3\xb6sarvopoisto'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180',b'Closed order cannot be cancelled. Unclose to cancel.',b'Suljettu j\xc3\xa4rjestys ei voi peruuttaa. Unclose peruuttaa.'
b'DocType: Student Guardian',b'Father',b'Is\xc3\xa4'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +627',"b""'Update Stock' cannot be checked for fixed asset sale""","b""'P\xc3\xa4ivit\xc3\xa4 varasto' ei voida valita k\xc3\xa4ytt\xc3\xb6omaisuuden myynteihin"""
b'DocType: Bank Reconciliation',b'Bank Reconciliation',b'pankin t\xc3\xa4sm\xc3\xa4ytys'
b'DocType: Attendance',b'On Leave',b'lomalla'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7',b'Get Updates',b'Liity s\xc3\xa4hk\xc3\xb6postilistalle'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96',b'{0} {1}: Account {2} does not belong to Company {3}',b'{0} {1}: Tili {2} ei kuulu yhti\xc3\xb6n {3}'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +397',b'Select at least one value from each of the attributes.',b'Valitse ainakin yksi arvo kustakin attribuutista.'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166',b'Material Request {0} is cancelled or stopped',b'Hankintapyynt\xc3\xb6 {0} on peruttu tai keskeytetty'
b'apps/erpnext/erpnext/config/hr.py +314',b'Leave Management',b'Vapaiden hallinta'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +118',b'Group by Account',b'tilin ryhm\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21',b'Please select Employee',b'Valitse Ty\xc3\xb6ntekij\xc3\xa4'
b'DocType: Sales Order',b'Fully Delivered',b't\xc3\xa4ysin toimitettu'
b'DocType: Lead',b'Lower Income',b'matala tulo'
b'DocType: Restaurant Order Entry',b'Current Order',b'Nykyinen tilaus'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196',b'Source and target warehouse cannot be same for row {0}',b'L\xc3\xa4hde- ja kohdevarasto eiv\xc3\xa4t voi olla samat rivill\xc3\xa4 {0}'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243',"b'Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry'","b'Erotuksen tili tulee olla vastaavat/vastattavat tili huomioiden, ett\xc3\xa4 varaston t\xc3\xa4sm\xc3\xa4ytys vaatii aloituskirjauksen'"
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107',b'Disbursed Amount cannot be greater than Loan Amount {0}',b'Maksettu summa ei voi olla suurempi kuin lainan m\xc3\xa4\xc3\xa4r\xc3\xa4 {0}'
b'apps/erpnext/erpnext/utilities/user_progress.py +176',b'Go to Programs',b'Siirry kohtaan Ohjelmat'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205',b'Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}',b'Rivi {0} # Sallittu m\xc3\xa4\xc3\xa4r\xc3\xa4 {1} ei voi olla suurempi kuin lunastamaton summa {2}'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89',b'Purchase Order number required for Item {0}',b'Ostotilauksen numero vaaditaan tuotteelle {0}'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18',"b""'From Date' must be after 'To Date'""",b'Aloitusp\xc3\xa4iv\xc3\xa4n tulee olla ennen p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39',b'Cannot change status as student {0} is linked with student application {1}',b'Ei voida muuttaa asemaa opiskelija {0} liittyy opiskelijavalinta {1}'
b'DocType: Asset',b'Fully Depreciated',b't\xc3\xa4ydet poistot'
b'DocType: Item Barcode',b'UPC-A',b'UPC-A'
,b'Stock Projected Qty',b'ennustettu varaston yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444',b'Customer {0} does not belong to project {1}',b'asiakas {0} ei kuulu projektiin {1}'
b'DocType: Employee Attendance Tool',b'Marked Attendance HTML',b'Merkitty L\xc3\xa4sn\xc3\xa4olo HTML'
b'apps/erpnext/erpnext/utilities/activation.py +73',"b'Quotations are proposals, bids you have sent to your customers'","b'Lainaukset ovat ehdotuksia, tarjouksia olet l\xc3\xa4hett\xc3\xa4nyt asiakkaille'"
b'DocType: Sales Invoice',"b""Customer's Purchase Order""",b'Asiakkaan Ostotilaus'
b'DocType: Consultation',b'Patient',b'potilas'
b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47',b'Bypass credit check at Sales Order ',b'Ohita luottotarkastus myyntitilauksesta'
b'DocType: Land Unit',b'Check if it is a hydroponic unit',"b'Tarkista, onko se hydroponic yksikk\xc3\xb6'"
b'apps/erpnext/erpnext/config/stock.py +109',b'Serial No and Batch',b'Sarjanumero ja er\xc3\xa4'
b'DocType: Warranty Claim',b'From Company',b'Yrityksest\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52',b'Sum of Scores of Assessment Criteria needs to be {0}.',b'Summa Kymmeni\xc3\xa4 Arviointikriteerit on oltava {0}.'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +77',b'Please set Number of Depreciations Booked',b'Aseta m\xc3\xa4\xc3\xa4r\xc3\xa4 Poistot varatut'
b'DocType: Supplier Scorecard Period',b'Calculations',b'Laskelmat'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86',b'Value or Qty',b'Arvo tai yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Payment Terms Template',b'Payment Terms',b'Maksuehdot'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449',b'Productions Orders cannot be raised for:',b'Productions Tilaukset ei voida nostaa varten:'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Minute',b'Minuutti'
b'DocType: Purchase Invoice',b'Purchase Taxes and Charges',b'Oston verot ja maksut'
b'DocType: Chapter',b'Meetup Embed HTML',b'Meetup Upota HTML'
b'apps/erpnext/erpnext/utilities/user_progress.py +121',b'Go to Suppliers',b'Siirry toimittajiin'
,b'Qty to Receive',b'Vastaanotettava yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Leave Block List',b'Leave Block List Allowed',b'Sallitut'
b'DocType: Grading Scale Interval',b'Grading Scale Interval',b'Arvosteluasteikko Interval'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49',b'Expense Claim for Vehicle Log {0}',b'Matkakorvauslomakkeet kulkuneuvojen Log {0}'
b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Alennus (%) on Hinnasto Hinta kanssa marginaali'
b'apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59',b'All Warehouses',b'kaikki kaupalliset'
b'DocType: Sales Partner',b'Retailer',b'J\xc3\xa4lleenmyyj\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115',b'Credit To account must be a Balance Sheet account',b'Kredit tilin on oltava tase tili'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118',b'All Supplier Types',b'kaikki toimittajatyypit'
b'DocType: Donor',b'Donor',b'luovuttaja'
b'DocType: Global Defaults',b'Disable In Words',b'Poista In Sanat'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +60',b'Item Code is mandatory because Item is not automatically numbered',"b'tuotekoodi vaaditaan, sill\xc3\xa4 tuotetta ei numeroida automaattisesti'"
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98',b'Quotation {0} not of type {1}',b'Tarjous {0} ei ole tyyppi\xc3\xa4 {1}'
b'DocType: Maintenance Schedule Item',b'Maintenance Schedule Item',"b'huoltoaikataulu, tuote'"
b'DocType: Sales Order',b'%  Delivered',b'% toimitettu'
b'apps/erpnext/erpnext/education/doctype/fees/fees.js +105',b'Please set the Email ID for the Student to send the Payment Request',b'Aseta opiskelijalle s\xc3\xa4hk\xc3\xb6postiosoite l\xc3\xa4hett\xc3\xa4m\xc3\xa4\xc3\xa4n maksupyynt\xc3\xb6'
b'DocType: Patient',b'Medical History',b'L\xc3\xa4\xc3\xa4ketieteellinen historia'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157',b'Bank Overdraft Account',b'pankin tilinylitystili'
b'DocType: Patient',b'Patient ID',b'Potilaan tunnus'
b'DocType: Physician Schedule',b'Schedule Name',b'Aikataulun nimi'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48',b'Make Salary Slip',b'Tee palkkalaskelma'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840',b'Add All Suppliers',b'Lis\xc3\xa4\xc3\xa4 kaikki toimittajat'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94',b'Row #{0}: Allocated Amount cannot be greater than outstanding amount.',b'Rivi # {0}: osuutensa ei voi olla suurempi kuin lainam\xc3\xa4\xc3\xa4r\xc3\xa4.'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75',b'Browse BOM',b'selaa BOM:a'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155',b'Secured Loans',b'Taatut lainat'
b'DocType: Purchase Invoice',b'Edit Posting Date and Time',b'Muokkaa tositteen p\xc3\xa4iv\xc3\xa4yst\xc3\xa4'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101',b'Please set Depreciation related Accounts in Asset Category {0} or Company {1}',b'Aseta poistot liittyv\xc3\xa4t tilien instrumenttikohtaisilla {0} tai Company {1}'
b'DocType: Lab Test Groups',b'Normal Range',b'Normaali alue'
b'DocType: Academic Term',b'Academic Year',b'Lukuvuosi'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Available Selling',b'Saatavana myyntiin'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169',b'Opening Balance Equity',b'Avaa oman p\xc3\xa4\xc3\xa4oman tase'
b'DocType: Lead',b'CRM',b'CRM'
b'DocType: Purchase Invoice',b'N',b'N'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175',b'Remaining',b'j\xc3\xa4ljell\xc3\xa4 oleva'
b'DocType: Appraisal',b'Appraisal',b'Arvioinnit'
b'DocType: Purchase Invoice',b'GST Details',b'GST-tiedot'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156',b'Email sent to supplier {0}',b'S\xc3\xa4hk\xc3\xb6posti l\xc3\xa4hetet\xc3\xa4\xc3\xa4n toimittaja {0}'
b'DocType: Item',b'Default Sales Unit of Measure',b'Oletusmyyntiyksikk\xc3\xb6'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9',b'Academic Year: ',b'Lukuvuosi:'
b'DocType: Opportunity',b'OPTY-',b'OPTY-'
b'apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19',b'Date is repeated',b'P\xc3\xa4iv\xc3\xa4 toistetaan'
b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27',b'Authorized Signatory',b'Valtuutettu allekirjoitus'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64',b'Create Fees',b'Luo palkkioita'
b'DocType: Project',b'Total Purchase Cost (via Purchase Invoice)',b'hankintakustannusten kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4 (ostolaskuista)'
b'DocType: Training Event',b'Start Time',b'aloitusaika'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400',b'Select Quantity',b'Valitse yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Customs Tariff Number',b'Customs Tariff Number',b'Tullitariffinumero'
b'DocType: Patient Appointment',b'Patient Appointment',b'Potilaan nimitt\xc3\xa4minen'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34',b'Approving Role cannot be same as role the rule is Applicable To',b'hyv\xc3\xa4ksyv\xc3\xa4 rooli ei voi olla sama kuin k\xc3\xa4ytetyss\xc3\xa4 s\xc3\xa4\xc3\xa4nn\xc3\xb6ss\xc3\xa4 oleva'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64',b'Unsubscribe from this Email Digest',b'Peru t\xc3\xa4m\xc3\xa4n s\xc3\xa4hk\xc3\xb6postilistan tilaus'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830',b'Get Suppliers By',b'Hanki Toimittajat'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173',b'{0} not found for Item {1}',b'{0} ei l\xc3\xb6ydy kohdasta {1}'
b'apps/erpnext/erpnext/utilities/user_progress.py +197',b'Go to Courses',b'Siirry kursseihin'
b'DocType: Accounts Settings',b'Show Inclusive Tax In Print',b'N\xc3\xa4yt\xc3\xa4 Inclusive Tax In Print'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17',"b'Bank Account, From Date and To Date are Mandatory'","b'Pankkitili, p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 ja p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 ovat pakollisia'"
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28',b'Message Sent',b'Viesti l\xc3\xa4hetetty'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +98',b'Account with child nodes cannot be set as ledger',b'Huomioon lapsen solmuja ei voida asettaa Ledger'
b'DocType: C-Form',b'II',b'II'
b'DocType: Sales Invoice',"b""Rate at which Price list currency is converted to customer's base currency""","b'taso, jolla hinnasto valuutta muunnetaan asiakkaan k\xc3\xa4ytt\xc3\xa4m\xc3\xa4ksi perusvaluutaksi'"
b'DocType: Purchase Invoice Item',b'Net Amount (Company Currency)',b'netto (yrityksen valuutassa)'
b'DocType: Physician',b'Physician Schedules',b'L\xc3\xa4\xc3\xa4k\xc3\xa4rin aikataulut'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215',b'Total advance amount cannot be greater than total sanctioned amount',b'Ennakkomaksun kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla suurempi kuin kokonainen seuraamusm\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Salary Slip',b'Hour Rate',b'tuntitaso'
b'DocType: Stock Settings',b'Item Naming By',b'tuotteen nime\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46',b'Another Period Closing Entry {0} has been made after {1}',b'toinen jakson sulkukirjaus {0} on tehty {1} j\xc3\xa4lkeen'
b'DocType: Work Order',b'Material Transferred for Manufacturing',b'Tuotantoon siirretyt materiaalit'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41',b'Account {0} does not exists',b'Tili\xc3\xa4 {0} ei l\xc3\xb6ydy'
b'DocType: Project',b'Project Type',b'projektin tyyppi'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +153',b'Child Task exists for this Task. You can not delete this Task.',b'T\xc3\xa4t\xc3\xa4 teht\xc3\xa4v\xc3\xa4\xc3\xa4 varten on teht\xc3\xa4v\xc3\xa4 lapsesi teht\xc3\xa4v\xc3\xa4. Et voi poistaa t\xc3\xa4t\xc3\xa4 teht\xc3\xa4v\xc3\xa4\xc3\xa4.'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'DateLet',b'DateLet'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16',b'Either target qty or target amount is mandatory.',b'tavoite yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 tai tavoite arvom\xc3\xa4\xc3\xa4r\xc3\xa4 vaaditaan'
b'apps/erpnext/erpnext/config/projects.py +56',b'Cost of various activities',b'vaihtelevien aktiviteettien kustannukset'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60',"b'Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}'","b'Tapahtuma asetettu arvoon {0}, koska myyntihenkil\xc3\xb6\xc3\xb6n liitetty ty\xc3\xb6ntekij\xc3\xa4 ei omista k\xc3\xa4ytt\xc3\xa4j\xc3\xa4tunnusta {1}'"
b'DocType: Timesheet',b'Billing Details',b'Laskutustiedot'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163',b'Source and target warehouse must be different',b'L\xc3\xa4hde ja kohde varasto on oltava eri'
b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140',b'Payment Failed. Please check your GoCardless Account for more details',b'Maksu ep\xc3\xa4onnistui. Tarkista GoCardless-tilisi tarkempia tietoja'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101',b'Not allowed to update stock transactions older than {0}',b'ei ole sallittua p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 yli {0} vanhoja varastotapahtumia'
b'DocType: BOM',b'Inspection Required',b'tarkistus vaaditaan'
b'DocType: Purchase Invoice Item',b'PR Detail',b'PR Detail'
b'DocType: Driving License Category',b'Class',b'luokka'
b'DocType: Sales Order',b'Fully Billed',b't\xc3\xa4ysin laskutettu'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426',b'Work Order cannot be raised against a Item Template',b'Ty\xc3\xb6tilaa ei voi nostaa esinett\xc3\xa4 kohti'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101',b'Shipping rule only applicable for Buying',b'Osto koskee vain toimituss\xc3\xa4\xc3\xa4nt\xc3\xb6\xc3\xa4'
b'DocType: Vital Signs',b'BMI',b'BMI'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20',b'Cash In Hand',b'k\xc3\xa4sirahat'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137',b'Delivery warehouse required for stock item {0}',b'Toimitus varasto tarvitaan varastonimike {0}'
b'DocType: Packing Slip',b'The gross weight of the package. Usually net weight + packaging material weight. (for print)',"b'Pakkauksen bruttopaino, yleens\xc3\xa4 tuotteen nettopaino + pakkausmateriaalin paino  (tulostukseen)'"
b'DocType: Assessment Plan',b'Program',b'Ohjelmoida'
b'DocType: Accounts Settings',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts',"b'Roolin omaavat k\xc3\xa4ytt\xc3\xa4j\xc3\xa4t voivat j\xc3\xa4\xc3\xa4dytt\xc3\xa4\xc3\xa4 tilej\xc3\xa4, sek\xc3\xa4 luoda ja muokata kirjanpidon kirjauksia j\xc3\xa4\xc3\xa4dytettyill\xc3\xa4 tileill\xc3\xa4'"
b'DocType: Serial No',b'Is Cancelled',b'on peruutettu'
b'DocType: Student Group',b'Group Based On',b'Ryhm\xc3\xa4t pohjautuvat'
b'DocType: Journal Entry',b'Bill Date',b'Bill Date'
b'DocType: Healthcare Settings',b'Laboratory SMS Alerts',b'Laboratorion SMS-ilmoitukset'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20',"b'Service Item,Type,frequency and expense amount are required'","b'Palvelu Tuote, tyyppi, taajuus ja kustannuksella m\xc3\xa4\xc3\xa4r\xc3\xa4 tarvitaan'"
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45',"b'Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:'",b'vaikka useita hinnoittelus\xc3\xa4\xc3\xa4nt\xc3\xb6j\xc3\xa4 on olemassa korkeimmalla prioriteetilla seuraavia sis\xc3\xa4isi\xc3\xa4 prioriteettej\xc3\xa4 noudatetaan'
b'DocType: Plant Analysis Criteria',b'Plant Analysis Criteria',b'Kasvien analyysikriteerit'
b'DocType: Cheque Print Template',b'Cheque Height',b'Shekki Korkeus'
b'DocType: Supplier',b'Supplier Details',b'toimittajan lis\xc3\xa4tiedot'
b'DocType: Setup Progress',b'Setup Progress',b'Asennuksen edistyminen'
b'DocType: Hub Settings',b'Publish Items to Hub',b'Julkaise tuotteet Hub'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35',b'From value must be less than to value in row {0}',b'arvosta t\xc3\xa4ytyy olla pienempi kuin arvo rivill\xc3\xa4 {0}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182',b'Wire Transfer',b'S\xc3\xa4hk\xc3\xb6inen tilisiirto'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92',b'Check all',b'Tarkista kaikki'
,b'Issued Items Against Work Order',b'Ty\xc3\xb6tilauksen vastaiset er\xc3\xa4t'
b'DocType: Vehicle Log',b'Invoice Ref',b'lasku Ref'
b'DocType: Company',b'Default Income Account',b'oletus tulotili'
b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32',b'Customer Group / Customer',b'Asiakasryhm\xc3\xa4 / asiakas'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37',b'Unclosed Fiscal Years Profit / Loss (Credit)',b'Unclosed tilikausiin voitto / tappio (luotto)'
b'DocType: Sales Invoice',b'Time Sheets',b'Tuntilistat'
b'DocType: Lab Test Template',b'Change In Item',b'Muuta kohdetta'
b'DocType: Payment Gateway Account',b'Default Payment Request Message',b'Oletus maksupyynt\xc3\xb6 Viesti'
b'DocType: Item Group',b'Check this if you want to show in website',b't\xc3\xa4pp\xc3\xa4\xc3\xa4 mik\xc3\xa4li haluat n\xc3\xa4ytt\xc3\xa4\xc3\xa4 t\xc3\xa4m\xc3\xa4n verkkosivuilla'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338',b'Balance ({0})',b'Saldo ({0})'
b'apps/erpnext/erpnext/config/accounts.py +134',b'Banking and Payments',b'Pankit ja maksut'
,b'Welcome to ERPNext',b'Tervetuloa ERPNext - j\xc3\xa4rjestelm\xc3\xa4\xc3\xa4n'
b'apps/erpnext/erpnext/config/learn.py +102',b'Lead to Quotation',b'vihjeest\xc3\xa4 tarjous'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34',b'Email Reminders will be sent to all parties with email contacts',"b'S\xc3\xa4hk\xc3\xb6posti-muistutukset l\xc3\xa4hetet\xc3\xa4\xc3\xa4n kaikille osapuolille, joilla on s\xc3\xa4hk\xc3\xb6postiyhteystiedot'"
b'DocType: Project',b'Twice Daily',b'Kahdesti p\xc3\xa4iv\xc3\xa4ss\xc3\xa4'
b'DocType: Patient',b'A Negative',b'Negatiivinen'
b'apps/erpnext/erpnext/templates/includes/product_list.js +45',b'Nothing more to show.',b'Ei voi muuta osoittaa.'
b'DocType: Lead',b'From Customer',b'asiakkaasta'
b'apps/erpnext/erpnext/demo/setup/setup_data.py +327',b'Calls',b'Pyynn\xc3\xb6t'
b'apps/erpnext/erpnext/utilities/user_progress.py +143',b'A Product',b'Tuote'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207',b'Batches',b'eriss\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34',b'Make Fee Schedule',b'Tee maksujen aikataulu'
b'DocType: Purchase Order Item Supplied',b'Stock UOM',b'Varastoyksikk\xc3\xb6'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233',b'Purchase Order {0} is not submitted',b'Ostotilaus {0} ei ole vahvistettu'
b'DocType: Vital Signs',b'Normal reference range for an adult is 16\xe2\x80\x9320 breaths/minute (RCP 2012)',b'Normaali viitealue aikuiselle on 16-20 hengityst\xc3\xa4 / minuutti (RCP 2012)'
b'DocType: Customs Tariff Number',b'Tariff Number',b'tariffi numero'
b'DocType: Work Order Item',b'Available Qty at WIP Warehouse',b'Available Kpl WIP Warehouse'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +39',b'Projected',b'Ennuste'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222',b'Serial No {0} does not belong to Warehouse {1}',b'Sarjanumero {0} ei kuulu varastoon {1}'
b'apps/erpnext/erpnext/controllers/status_updater.py +177',b'Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0',b'huom: j\xc3\xa4rjestelm\xc3\xa4 ei tarkista ylitoimitusta tai tuotteen ylivarausta {0} yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4n\xc3\xa4 tai arvom\xc3\xa4\xc3\xa4r\xc3\xa4n ollessa 0'
b'DocType: Notification Control',b'Quotation Message',b'Tarjouksen viesti'
b'DocType: Employee Loan',b'Employee Loan Application',b'Ty\xc3\xb6ntekij\xc3\xa4n lainahakemuksen'
b'DocType: Issue',b'Opening Date',b'Opening Date'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86',b'Please save the patient first',b'Tallenna potilas ensin'
b'apps/erpnext/erpnext/education/api.py +80',b'Attendance has been marked successfully.',b'L\xc3\xa4sn\xc3\xa4olo on merkitty onnistuneesti.'
b'DocType: Program Enrollment',b'Public Transport',b'Julkinen liikenne'
b'DocType: Soil Texture',b'Silt Composition (%)',b'Silt-kokoonpano (%)'
b'DocType: Journal Entry',b'Remark',b'Huomautus'
b'DocType: Healthcare Settings',b'Avoid Confirmation',b'Vahvista vahvistus'
b'DocType: Purchase Receipt Item',b'Rate and Amount',b'hinta ja arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176',b'Account Type for {0} must be {1}',b'Tilityyppi on {0} on {1}'
b'DocType: Healthcare Settings',b'Default income accounts to be used if not set in Physician to book Consultation charges.',"b'Oletustulotilej\xc3\xa4 k\xc3\xa4ytet\xc3\xa4\xc3\xa4n, jos niit\xc3\xa4 ei ole asetettu l\xc3\xa4\xc3\xa4k\xc3\xa4riin kirjaamaan neuvottelumaksut.'"
b'apps/erpnext/erpnext/config/hr.py +55',b'Leaves and Holiday',b'Vapaat ja lomat'
b'DocType: Education Settings',b'Current Academic Term',b'Nykyinen lukukaudessa'
b'DocType: Sales Order',b'Not Billed',b'Ei laskuteta'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76',b'Both Warehouse must belong to same Company',b'Molempien varastojen tulee kuulua samalle organisaatiolle'
b'apps/erpnext/erpnext/public/js/templates/contact_list.html +34',b'No contacts added yet.',b'yhteystietoja ei ole lis\xc3\xa4tty'
b'DocType: Purchase Invoice Item',b'Landed Cost Voucher Amount',"b'Kohdistetut kustannukset, arvom\xc3\xa4\xc3\xa4r\xc3\xa4'"
,b'Item Balance (Simple)',b'Item Balance (yksinkertainen)'
b'apps/erpnext/erpnext/config/accounts.py +17',b'Bills raised by Suppliers.',b'Laskut esille Toimittajat.'
b'DocType: POS Profile',b'Write Off Account',b'Poistotili'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Debit Note Amt',b'Veloitusilmoituksen Amt'
b'apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5',b'Discount Amount',b'alennus arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Purchase Invoice',b'Return Against Purchase Invoice',"b'ostolasku, palautuksen kohdistus'"
b'DocType: Item',b'Warranty Period (in days)',b'Takuuaika (p\xc3\xa4ivin\xc3\xa4)'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61',b'Failed to set defaults',b'Oletusasetusten m\xc3\xa4\xc3\xa4ritt\xc3\xa4minen ep\xc3\xa4onnistui'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56',b'Relation with Guardian1',b'Suhde Guardian1'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +786',b'Please select BOM against item {0}',b'Valitse BOM kohdasta {0}'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18',b'Make Invoices',b'Tee laskut'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23',b'Net Cash from Operations',b'Liiketoiminnan nettorahavirta'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26',b'Item 4',b'Nimike 4'
b'DocType: Student Admission',b'Admission End Date',b'P\xc3\xa4\xc3\xa4symaksu P\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30',b'Sub-contracting',b'Alihankinta'
b'DocType: Journal Entry Account',b'Journal Entry Account',b'p\xc3\xa4iv\xc3\xa4kirjakirjaus tili'
b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3',b'Student Group',b'Student Group'
b'DocType: Shopping Cart Settings',b'Quotation Series',"b'Tarjous, sarjat'"
b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57',"b'An item exists with same name ({0}), please change the item group name or rename the item'","b'Samanniminen nimike on jo olemassa ({0}), vaihda nimikeryhm\xc3\xa4n nime\xc3\xa4 tai nime\xc3\xa4 nimike uudelleen'"
b'DocType: Soil Analysis Criteria',b'Soil Analysis Criteria',b'Maaper\xc3\xa4n analyysikriteerit'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2041',b'Please select customer',b'Valitse asiakas'
b'DocType: C-Form',b'I',b'min\xc3\xa4'
b'DocType: Company',b'Asset Depreciation Cost Center',b'Poistojen kustannuspaikka'
b'DocType: Production Plan Sales Order',b'Sales Order Date',"b'Myyntitilaus, p\xc3\xa4iv\xc3\xa4'"
b'DocType: Sales Invoice Item',b'Delivered Qty',b'toimitettu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Assessment Plan',b'Assessment Plan',b'arviointi Plan'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90',b'Customer {0} is created.',b'Asiakas {0} luodaan.'
b'DocType: Stock Settings',b'Limit Percent',b'raja Prosenttia'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82',b' Currently no stock available in any warehouse',"b'T\xc3\xa4ll\xc3\xa4 hetkell\xc3\xa4 ei varastossa,'"
,b'Payment Period Based On Invoice Date',b'Maksuaikaa perustuu laskun p\xc3\xa4iv\xc3\xa4ykseen'
b'DocType: Sample Collection',b'No. of print',b'Tulosteiden m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Hotel Room Reservation Item',b'Hotel Room Reservation Item',b'Hotellin huoneen varaosat'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58',b'Missing Currency Exchange Rates for {0}',b'valuuttakurssi puuttuu {0}'
b'DocType: Health Insurance',b'Health Insurance Name',b'Sairausvakuutuksen nimi'
b'DocType: Assessment Plan',b'Examiner',b'tarkastaja'
b'DocType: Student',b'Siblings',b'Sisarukset'
b'DocType: Journal Entry',b'Stock Entry',b'Varastotapahtuma'
b'DocType: Payment Entry',b'Payment References',b'Maksu viitteet'
b'DocType: C-Form',b'C-FORM-',b'C-muodostumisesta'
b'DocType: Vehicle',b'Insurance Details',b'vakuutus Lis\xc3\xa4tiedot'
b'DocType: Account',b'Payable',b'Maksettava'
b'DocType: Share Balance',b'Share Type',b'Osaketyyppi'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113',b'Please enter Repayment Periods',b'Anna takaisinmaksuajat'
b'apps/erpnext/erpnext/shopping_cart/cart.py +378',b'Debtors ({0})',b'Velalliset ({0})'
b'DocType: Pricing Rule',b'Margin',b'Marginaali'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57',b'New Customers',b'Uudet asiakkaat'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74',b'Gross Profit %',b'bruttovoitto %'
b'DocType: Appraisal Goal',b'Weightage (%)',b'Painoarvo (%)'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +503',b'Change POS Profile',b'Muuta POS-profiilia'
b'DocType: Bank Reconciliation Detail',b'Clearance Date',b'tilitysp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7',b'Assessment Report',b'Arviointikertomus'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +59',b'Gross Purchase Amount is mandatory',b'Gross Ostoksen kokonaissumma on pakollinen'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +95',b'Company name not same',b'Yrityksen nimi ei ole sama'
b'DocType: Lead',b'Address Desc',b'osoitetiedot'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113',b'Party is mandatory',b'Osapuoli on pakollinen'
b'DocType: Journal Entry',b'JV-',b'JV-'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +712',b'Rows with duplicate due dates in other rows were found: {list}',"b'Rivit, joilla oli kahta p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4 toisissa riveiss\xc3\xa4, l\xc3\xb6ytyiv\xc3\xa4t: {list}'"
b'DocType: Topic',b'Topic Name',b'Aihe Name'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37',b'Atleast one of the Selling or Buying must be selected',b'Ainakin osto tai myynti on pakko valita'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290',b'Select an employee to get the employee advance.',"b'Valitse ty\xc3\xb6ntekij\xc3\xa4, jotta ty\xc3\xb6ntekij\xc3\xa4 etenee.'"
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56',b'Please select a valid Date',b'Valitse voimassa oleva p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +36',b'Select the nature of your business.',b'Valitse liiketoiminnan luonteesta.'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +24',b'Please setup Employee Naming System in Human Resource &gt; HR Settings',b'Aseta henkil\xc3\xb6st\xc3\xb6n nime\xc3\xa4misj\xc3\xa4rjestelm\xc3\xa4 henkil\xc3\xb6resursseihin&gt; HR-asetukset'
b'DocType: Lab Test Template',"b'Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.'","b'Yksitt\xc3\xa4inen tulos, joka vaatii vain yhden tulon, tuloksen UOM ja normaaliarvon <br> Yhdistelm\xc3\xa4 tuloksiin, jotka edellytt\xc3\xa4v\xc3\xa4t useita sy\xc3\xb6tt\xc3\xb6kentti\xc3\xa4, joilla on vastaavat tapahtumien nimet, tuloksen UOM-arvot ja normaalit arvot <br> Kuvaava testeiss\xc3\xa4, joissa on useita tulokomponentteja ja vastaavat tuloksen kent\xc3\xa4t. <br> Ryhmitelty testipohjille, jotka ovat muiden testipohjien joukko. <br> Ei tulos testeille ilman tuloksia. My\xc3\xb6sk\xc3\xa4\xc3\xa4n Lab Test ei ole luotu. esim. Sub-testit ryhmiteltyihin tuloksiin.'"
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86',b'Row #{0}: Duplicate entry in References {1} {2}',b'Rivi # {0}: Monista merkint\xc3\xa4 Viitteet {1} {2}'
b'apps/erpnext/erpnext/config/manufacturing.py +57',b'Where manufacturing operations are carried.',b'Miss\xc3\xa4 valmistus tapahtuu'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18',b'As Examiner',b'Tutkijana'
b'DocType: Appointment Type',b'Default Duration',b'Oletuskesto'
b'DocType: Asset Movement',b'Source Warehouse',b'Varastosta'
b'DocType: Installation Note',b'Installation Date',b'asennusp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30',b'Share Ledger',b'Osakekirja'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +606',b'Row #{0}: Asset {1} does not belong to company {2}',b'Rivi # {0}: Asset {1} ei kuulu yhti\xc3\xb6n {2}'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206',b'Sales Invoice {0} created',b'Myynti lasku {0} luotiin'
b'DocType: Employee',b'Confirmation Date',b'Ty\xc3\xb6sopimuksen vahvistamisp\xc3\xa4iv\xc3\xa4'
b'DocType: C-Form',b'Total Invoiced Amount',b'Kokonaislaskutus arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50',b'Min Qty can not be greater than Max Qty',b'min yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla suurempi kuin max yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Soil Texture',b'Silty Clay',b'Silty Clay'
b'DocType: Account',b'Accumulated Depreciation',b'Kertyneet poistot'
b'DocType: Supplier Scorecard Scoring Standing',b'Standing Name',b'Pysyv\xc3\xa4 nimi'
b'DocType: Stock Entry',b'Customer or Supplier Details',b'Asiakkaan tai tavarantoimittajan Tietoja'
b'DocType: Employee Loan Application',b'Required by Date',b'Vaaditaan Date'
b'DocType: Lead',b'Lead Owner',b'Liidin vastuullinen'
b'DocType: Production Plan',b'Sales Orders Detail',b'Myyntitilaukset'
b'DocType: Bin',b'Requested Quantity',b'pyydetty m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Patient',b'Marital Status',b'Siviilis\xc3\xa4\xc3\xa4ty'
b'DocType: Stock Settings',b'Auto Material Request',b'Automaattinen hankintapyynt\xc3\xb6'
b'DocType: Delivery Note Item',b'Available Batch Qty at From Warehouse',b'Saatavilla Er\xc3\xa4 Kpl osoitteessa varastosta'
b'DocType: Customer',b'CUST-',b'CUST-'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Idevise',b'Idevise'
b'DocType: Salary Slip',b'Gross Pay - Total Deduction - Loan Repayment',b'Gross Pay - Yhteens\xc3\xa4 v\xc3\xa4hent\xc3\xa4minen - Lainan takaisinmaksu'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29',b'Current BOM and New BOM can not be same',b'nykyinen BOM ja uusi BOM ei voi olla samoja'
b'apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47',b'Salary Slip ID',b'Palkka Slip ID'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +118',b'Date Of Retirement must be greater than Date of Joining',b'El\xc3\xa4kkeellesiirtymisp\xc3\xa4iv\xc3\xa4n on oltava ty\xc3\xb6suhteen aloitusp\xc3\xa4iv\xc3\xa4\xc3\xa4 my\xc3\xb6hemmin'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +68',b'Multiple Variants',b'Useita vaihtoehtoja'
b'DocType: Sales Invoice',b'Against Income Account',b'tulotilin kodistus'
b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +117',b'{0}% Delivered',b'{0}% toimitettu'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107',b'Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).',b'Nimikkeen {0}: tilattu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 {1} ei voi olla pienempi kuin pienin tilaus yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 {2} (m\xc3\xa4\xc3\xa4ritetty nimikkeelle)'
b'DocType: Monthly Distribution Percentage',b'Monthly Distribution Percentage',"b'toimitus kuukaudessa, prosenttiosuus'"
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49',b'Please login as another user.',b'Ole hyv\xc3\xa4 ja kirjaudu sis\xc3\xa4\xc3\xa4n toisena k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n\xc3\xa4.'
b'DocType: Daily Work Summary Group User',b'Daily Work Summary Group User',b'P\xc3\xa4ivitt\xc3\xa4isen ty\xc3\xb6yhteenvetoryhm\xc3\xa4n k\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'DocType: Territory',b'Territory Targets',b'Aluetavoite'
b'DocType: Soil Analysis',b'Ca/Mg',b'Ca / Mg'
b'DocType: Delivery Note',b'Transporter Info',b'kuljetuksen info'
b'apps/erpnext/erpnext/accounts/utils.py +502',b'Please set default {0} in Company {1}',b'Aseta oletus {0} in Company {1}'
b'DocType: Cheque Print Template',b'Starting position from top edge',b'Alkuasentoon yl\xc3\xa4reunasta'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33',b'Same supplier has been entered multiple times',b'Sama toimittaja on sy\xc3\xb6tetty useita kertoja'
b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152',b'Gross Profit / Loss',b'Bruttotuottoprosentin / tappio'
,b'Warehouse wise Item Balance Age and Value',b'Varasto viisas Item Balance Age and Value'
b'DocType: Purchase Order Item Supplied',b'Purchase Order Item Supplied',b'Tuote ostotilaus toimitettu'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +94',b'Company Name cannot be Company',b'Yrityksen nime\xc3\xa4 ei voi Company'
b'apps/erpnext/erpnext/config/setup.py +27',b'Letter Heads for print templates.',b'Tulosteotsakkeet mallineille'
b'apps/erpnext/erpnext/config/setup.py +32',b'Titles for print templates e.g. Proforma Invoice.',"b'Tulostus, mallipohjan otsikot esim, proformalaskuun'"
b'DocType: Program Enrollment',b'Walking',b'K\xc3\xa4vely'
b'DocType: Student Guardian',b'Student Guardian',b'Student Guardian'
b'DocType: Member',b'Member Name',b'J\xc3\xa4sen nimi'
b'DocType: Stock Settings',b'Use Naming Series',b'K\xc3\xa4yt\xc3\xa4 nimipalvelusarjaa'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218',b'Valuation type charges can not marked as Inclusive',b'Arvotyypin maksuja ei voi merkata sis\xc3\xa4ltyviksi'
b'DocType: POS Profile',b'Update Stock',b'P\xc3\xa4ivit\xc3\xa4 varasto'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'in the subscription',b'liittym\xc3\xa4ss\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100',b'Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.',"b'Erilaiset mittayksik\xc3\xb6t voivat johtaa virheellisiin (kokonais) painoarvoihin. Varmista, ett\xc3\xa4 joka kohdassa k\xc3\xa4ytet\xc3\xa4\xc3\xa4n samaa mittayksikk\xc3\xb6\xc3\xa4.'"
b'DocType: Membership',b'Payment Details',b'Maksutiedot'
b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'BOM Rate',b'BOM taso'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225',"b'Stopped Work Order cannot be cancelled, Unstop it first to cancel'","b'Pys\xc3\xa4ytetty\xc3\xa4 ty\xc3\xb6j\xc3\xa4rjestyst\xc3\xa4 ei voi peruuttaa, keskeytt\xc3\xa4\xc3\xa4 se ensin peruuttamalla'"
b'DocType: Asset',b'Journal Entry for Scrap',b'Journal Entry for Romu'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83',b'Please pull items from Delivery Note',b'Siirr\xc3\xa4 tuotteita l\xc3\xa4hetteelt\xc3\xa4'
b'apps/erpnext/erpnext/accounts/utils.py +472',b'Journal Entries {0} are un-linked',b'p\xc3\xa4iv\xc3\xa4kirjakirjauksia {0} ei ole kohdistettu'
b'apps/erpnext/erpnext/config/crm.py +92',"b'Record of all communications of type email, phone, chat, visit, etc.'","b'Tiedot kaikesta viestinn\xc3\xa4st\xc3\xa4; s\xc3\xa4hk\xc3\xb6posti, puhelin, pikaviestint\xc3\xa4, k\xc3\xa4ynnit, jne.'"
b'DocType: Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing',b'Toimittajan sijoituspisteet'
b'DocType: Manufacturer',b'Manufacturers used in Items',b'Valmistajat k\xc3\xa4ytet\xc3\xa4\xc3\xa4n Items'
b'apps/erpnext/erpnext/accounts/general_ledger.py +170',b'Please mention Round Off Cost Center in Company',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 yrityksen py\xc3\xb6ristys kustannuspaikka'
b'DocType: Purchase Invoice',b'Terms',b'Ehdot'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10',b'Select Days',b'Valitse p\xc3\xa4iv\xc3\xa4t'
b'DocType: Academic Term',b'Term Name',b'Term Name'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332',b'Credit ({0})',b'Luotto ({0})'
b'DocType: Buying Settings',b'Purchase Order Required',b'Ostotilaus vaaditaan'
,b'Item-wise Sales History',"b'tuote ty\xc3\xb6kalu, myyntihistoria'"
b'DocType: Expense Claim',b'Total Sanctioned Amount',b'Hyv\xc3\xa4ksytt\xc3\xa4v\xc3\xa4 m\xc3\xa4\xc3\xa4r\xc3\xa4 yhteens\xc3\xa4'
b'DocType: Land Unit',b'Land Unit',b'Maayksikk\xc3\xb6'
,b'Purchase Analytics',b'Hankinta-analytiikka'
b'DocType: Sales Invoice Item',b'Delivery Note Item',b'l\xc3\xa4hetteen tuote'
b'DocType: Asset Maintenance Log',b'Task',b'Teht\xc3\xa4v\xc3\xa4'
b'DocType: Purchase Taxes and Charges',b'Reference Row #',b'Viite Row #'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76',b'Batch number is mandatory for Item {0}',b'Er\xc3\xa4numero on pakollinen tuotteelle {0}'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13',b'This is a root sales person and cannot be edited.',b'T\xc3\xa4m\xc3\xa4 on kantamyyj\xc3\xa4 eik\xc3\xa4 niit\xc3\xa4 voi muokata'
b'DocType: Salary Detail',"b""If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ""","b'Jos valittu, m\xc3\xa4\xc3\xa4ritetty arvo tai laskettuna t\xc3\xa4m\xc3\xa4 komponentti ei edist\xc3\xa4 tulokseen tai v\xc3\xa4hennyksi\xc3\xa4. Kuitenkin se on arvo voi viitata muista komponenteista, joita voidaan lis\xc3\xa4t\xc3\xa4 tai v\xc3\xa4hent\xc3\xa4\xc3\xa4.'"
b'DocType: Asset Settings',b'Number of Days in Fiscal Year',b'Tilikauden p\xc3\xa4ivien lukum\xc3\xa4\xc3\xa4r\xc3\xa4'
,b'Stock Ledger',b'Varastokirjanpidon tilikirja'
b'apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29',b'Rate: {0}',b'Hinta: {0}'
b'DocType: Company',b'Exchange Gain / Loss Account',b'valuutanvaihtojen voitto/tappiotili'
b'apps/erpnext/erpnext/config/hr.py +7',b'Employee and Attendance',b'Ty\xc3\xb6ntekij\xc3\xa4t ja l\xc3\xa4sn\xc3\xa4olo'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93',b'Purpose must be one of {0}',b'Tapahtuman on oltava jokin {0}'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100',b'Fill the form and save it',b'T\xc3\xa4yt\xc3\xa4 muoto ja tallenna se'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26',b'Community Forum',b'Yhteis\xc3\xb6n Forum'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Varsinainen kpl varastossa'
b'DocType: Homepage',"b'URL for ""All Products""'","b'""Kaikki tuotteet"" - sivun WWW-osoite'"
b'DocType: Leave Application',b'Leave Balance Before Application',b'Vapaan m\xc3\xa4\xc3\xa4r\xc3\xa4 ennen'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46',b'Send SMS',b'L\xc3\xa4het\xc3\xa4 tekstiviesti'
b'DocType: Supplier Scorecard Criteria',b'Max Score',b'Max Score'
b'DocType: Cheque Print Template',b'Width of amount in word',b'Leveys m\xc3\xa4\xc3\xa4r\xc3\xa4n sanassa'
b'DocType: Company',b'Default Letter Head',b'oletus kirjeen otsikko'
b'DocType: Purchase Order',b'Get Items from Open Material Requests',b'Hae nimikkeet avoimista hankintapyynn\xc3\xb6ist\xc3\xa4'
b'DocType: Hotel Room Amenity',b'Billable',b'Laskutettava'
b'DocType: Lab Test Template',b'Standard Selling Rate',b'Perusmyyntihinta'
b'DocType: Account',b'Rate at which this tax is applied',b'taso jolla t\xc3\xa4t\xc3\xa4 veroa sovelletaan'
b'DocType: Cash Flow Mapper',b'Section Name',b'Osaston nimi'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77',b'Reorder Qty',b'T\xc3\xa4ydennystilauksen yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28',b'Current Job Openings',b'Avoimet ty\xc3\xb6paikat'
b'DocType: Company',b'Stock Adjustment Account',b'Varastons\xc3\xa4\xc3\xa4t\xc3\xb6tili'
b'apps/erpnext/erpnext/public/js/payment/pos_payment.html +17',b'Write Off',b'Poisto'
b'DocType: Patient Service Unit',b'Allow Overlap',b'Salli p\xc3\xa4\xc3\xa4llekk\xc3\xa4isyys'
b'DocType: Timesheet Detail',b'Operation ID',b'Operation ID'
b'DocType: Employee',"b'System User (login) ID. If set, it will become default for all HR forms.'","b'j\xc3\xa4rjestelm\xc3\xa4k\xc3\xa4ytt\xc3\xa4j\xc3\xa4 (kirjautuminen) tunnus, mik\xc3\xa4li annetaan siit\xc3\xa4 tulee oletus kaikkiin HR muotoihin'"
b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16',b'{0}: From {1}',b'{0}: {1}:st\xc3\xa4'
b'DocType: Task',b'depends_on',b'riippuu'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60',b'Queued for updating latest price in all Bill of Materials. It may take a few minutes.',b'Joudut p\xc3\xa4ivitt\xc3\xa4m\xc3\xa4\xc3\xa4n viimeisimm\xc3\xa4n hinnan kaikkiin Bill of Materials -asiakirjoihin. Voi kest\xc3\xa4\xc3\xa4 muutaman minuutin.'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26',"b""Name of new Account. Note: Please don't create accounts for Customers and Suppliers""",b'Nimi uusi tili. Huomautus: \xc3\x84l\xc3\xa4 luo asiakastilej\xc3\xa4 ja Toimittajat'
b'apps/erpnext/erpnext/config/setup.py +37',b'Country wise default Address Templates',"b'maa ty\xc3\xb6kalu, oletus osoite, mallipohja'"
b'DocType: Water Analysis',b'Appearance',b'Ulkomuoto'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Buying Price List Rate',b'Keskim. Hintaluokan hinta'
b'DocType: Sales Order Item',b'Supplier delivers to Customer',b'Toimittaja toimittaa Asiakkaalle'
b'apps/erpnext/erpnext/config/non_profit.py +23',b'Member information.',b'J\xc3\xa4senen tiedot.'
b'apps/erpnext/erpnext/utilities/bot.py +34',b'[{0}](#Form/Item/{0}) is out of stock',b'[{0}] (# Form / Item / {0}) on loppunut'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +58',b'Asset Maintenance',b'Omaisuuden yll\xc3\xa4pito'
,b'Sales Payment Summary',b'Myyntimaksun yhteenveto'
b'DocType: Restaurant',b'Restaurant',b'Ravintola'
b'apps/erpnext/erpnext/accounts/party.py +320',b'Due / Reference Date cannot be after {0}',b'er\xc3\xa4- / viitep\xc3\xa4iv\xc3\xa4 ei voi olla {0} j\xc3\xa4lkeen'
b'apps/erpnext/erpnext/config/setup.py +51',b'Data Import and Export',b'tietojen tuonti ja vienti'
b'DocType: Patient',b'Account Details',b'tilin tiedot'
b'DocType: Crop',b'Materials Required',b'Vaaditut materiaalit'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76',b'No students Found',b'Ei opiskelijat Todettu'
b'DocType: Medical Department',b'Medical Department',b'L\xc3\xa4\xc3\xa4ketieteen osasto'
b'DocType: Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Criteria',b'Toimittajan tuloskortin pisteytyskriteerit'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55',b'Invoice Posting Date',b'Laskun tositep\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25',b'Sell',b'Myyd\xc3\xa4'
b'DocType: Purchase Invoice',b'Rounded Total',b'yhteens\xc3\xa4 py\xc3\xb6ristettyn\xc3\xa4'
b'DocType: Product Bundle',b'List items that form the package.',b'Listaa nimikkeet jotka muodostavat pakkauksen.'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39',b'Not permitted. Please disable the Test Template',b'Ei sallittu. Poista kokeilumalli k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26',b'Percentage Allocation should be equal to 100%',b'Prosenttiosuuden jako tulisi olla yht\xc3\xa4 suuri 100%'
b'DocType: Crop Cycle',b'Linked Land Unit',b'Linkitetty maayksikk\xc3\xb6'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584',b'Please select Posting Date before selecting Party',b'Valitse tositep\xc3\xa4iv\xc3\xa4 ennen osapuolta'
b'DocType: Program Enrollment',b'School House',b'School House'
b'DocType: Serial No',b'Out of AMC',b'Yll\xc3\xa4pitosopimus ei ole voimassa'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +82',b'Number of Depreciations Booked cannot be greater than Total Number of Depreciations',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 Poistot varatut ei voi olla suurempi kuin kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4 Poistot'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47',b'Make Maintenance Visit',b'tee huoltok\xc3\xa4ynti'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +215',b'Please contact to the user who have Sales Master Manager {0} role',"b'Ota yhteytt\xc3\xa4 k\xc3\xa4ytt\xc3\xa4j\xc3\xa4\xc3\xa4n, jolla on myynninhallinnan valvojan rooli {0}'"
b'DocType: Company',b'Default Cash Account',b'oletus kassatili'
b'apps/erpnext/erpnext/config/accounts.py +62',b'Company (not Customer or Supplier) master.',b'yrityksen valvonta (ei asiakas tai toimittaja)'
b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6',b'This is based on the attendance of this Student',b'T\xc3\xa4m\xc3\xa4 perustuu l\xc3\xa4sn\xc3\xa4olo t\xc3\xa4m\xc3\xa4n Student'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178',b'No Students in',b'Ei opiskelijat'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179',b'Add more items or open full form',b'Lis\xc3\xa4t\xc3\xa4 kohteita tai avata koko lomakkeen'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212',b'Delivery Notes {0} must be cancelled before cancelling this Sales Order',b'l\xc3\xa4hete {0} tulee perua ennen myyntilauksen perumista'
b'apps/erpnext/erpnext/utilities/user_progress.py +259',b'Go to Users',b'Siirry K\xc3\xa4ytt\xc3\xa4jiin'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85',b'Paid amount + Write Off Amount can not be greater than Grand Total',b'Maksettu arvom\xc3\xa4\xc3\xa4r\xc3\xa4 + poistotilin summa ei voi olla suurempi kuin kokonaissumma'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78',b'{0} is not a valid Batch Number for Item {1}',b'{0} ei sallittu er\xc3\xa4numero tuotteelle {1}'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130',b'Note: There is not enough leave balance for Leave Type {0}',b'Huom: j\xc3\xa4\xc3\xa4nn\xc3\xb6styypille {0} ei ole tarpeeksi vapaata j\xc3\xa4\xc3\xa4nn\xc3\xb6stasetta'
b'apps/erpnext/erpnext/regional/india/utils.py +16',b'Invalid GSTIN or Enter NA for Unregistered',b'Virheellinen GSTIN tai Enter NA Rekister\xc3\xb6im\xc3\xa4t\xc3\xb6n'
b'DocType: Training Event',b'Seminar',b'seminaari'
b'DocType: Program Enrollment Fee',b'Program Enrollment Fee',b'Ohjelma Ilmoittautuminen Fee'
b'DocType: Item',b'Supplier Items',b'Toimittajan nimikkeet'
b'DocType: Opportunity',b'Opportunity Type',b'mahdollisuuden tyyppi'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16',b'New Company',b'Uusi yritys'
b'apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17',b'Transactions can only be deleted by the creator of the Company',b'vain j\xc3\xa4rjestelm\xc3\xa4n perustaja voi poistaa tapahtumia'
b'apps/erpnext/erpnext/accounts/general_ledger.py +21',b'Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.',"b'l\xc3\xb6ytyi virheellinen m\xc3\xa4\xc3\xa4r\xc3\xa4 p\xc3\xa4\xc3\xa4tilikirjan kirjauksia, olet ehk\xc3\xa4 valinnut v\xc3\xa4\xc3\xa4r\xc3\xa4n tilin tapahtumaan'"
b'DocType: Employee',b'Prefered Contact Email',b'Prefered S\xc3\xa4hk\xc3\xb6postiosoite'
b'DocType: Cheque Print Template',b'Cheque Width',b'Shekki Leveys'
b'DocType: Selling Settings',b'Validate Selling Price for Item against Purchase Rate or Valuation Rate',b'Validoi myyntihinta Tuote vastaan Purchase Rate tai arvostus Hinta'
b'DocType: Fee Schedule',b'Fee Schedule',b'Fee aikataulu'
b'DocType: Hub Settings',b'Publish Availability',b'Julkaise Saatavuus'
b'DocType: Company',b'Create Chart Of Accounts Based On',b'Luo tilikartta perustuu'
b'apps/erpnext/erpnext/projects/doctype/task/task.js +91',b'Cannot convert it to non-group. Child Tasks exist.',b'Muuntaminen ei ole mahdollista ryhm\xc3\xa4lle. Lapsi teht\xc3\xa4v\xc3\xa4t ovat olemassa.'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +112',b'Date of Birth cannot be greater than today.',b'Syntym\xc3\xa4p\xc3\xa4iv\xc3\xa4 ei voi olla t\xc3\xa4m\xc3\xa4n p\xc3\xa4iv\xc3\xa4n j\xc3\xa4lkeen'
,b'Stock Ageing',b'Varaston vanheneminen'
b'apps/erpnext/erpnext/education/doctype/student/student.py +40',b'Student {0} exist against student applicant {1}',b'Opiskelija {0} on olemassa vastaan opiskelijahakijaksi {1}'
b'DocType: Purchase Invoice',b'Rounding Adjustment (Company Currency)',b'Py\xc3\xb6ristyskorjaus (yrityksen valuutta)'
b'apps/erpnext/erpnext/projects/doctype/task/task.js +39',b'Timesheet',b'Tuntilomake'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243',b'Batch: ',b'er\xc3\xa4:'
b'DocType: Volunteer',b'Afternoon',b'Iltap\xc3\xa4iv\xc3\xa4ll\xc3\xa4'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +258',"b""{0} '{1}' is disabled""","b""{0} '{1}' on poistettu k\xc3\xa4yt\xc3\xb6st\xc3\xa4"""
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13',b'Set as Open',b'Aseta avoimeksi'
b'DocType: Cheque Print Template',b'Scanned Cheque',b'Skannattu Shekki'
b'DocType: Notification Control',b'Send automatic emails to Contacts on Submitting transactions.',b'L\xc3\xa4het\xc3\xa4 s\xc3\xa4hk\xc3\xb6posti yhteyshenkil\xc3\xb6ille kun tapahtuma vahvistetaan.'
b'DocType: Timesheet',b'Total Billable Amount',b'Laskutettava summa yhteens\xc3\xa4'
b'DocType: Customer',b'Credit Limit and Payment Terms',b'Luottoraja ja maksuehdot'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20',b'Item 3',b'Nimike 3'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6',b'Order Entry',b'Tilauksen merkint\xc3\xa4'
b'DocType: Purchase Order',b'Customer Contact Email',b'Asiakas S\xc3\xa4hk\xc3\xb6postiosoite'
b'DocType: Warranty Claim',b'Item and Warranty Details',b'Kohta ja takuu Tietoja'
b'DocType: Chapter',b'Chapter Members',b'Lukuj\xc3\xa4senet'
b'DocType: Sales Team',b'Contribution (%)',b'panostus (%)'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +102',"b""Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified""","b""huom: maksukirjausta ei synny sill\xc3\xa4 'kassa- tai pankkitili\xc3\xa4' ei ole m\xc3\xa4\xc3\xa4ritetty"""
b'apps/erpnext/erpnext/projects/doctype/project/project.py +70',b'Project {0} already exists',b'Hanke {0} on jo olemassa'
b'DocType: Medical Department',b'Nursing User',b'Hoitoty\xc3\xb6ntekij\xc3\xa4'
b'DocType: Plant Analysis',b'Plant Analysis Criterias',b'Kasvien analyysikriteerit'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239',b'Responsibilities',b'Vastuut'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125',b'Validity period of this quotation has ended.',b'T\xc3\xa4m\xc3\xa4n noteerauksen voimassaoloaika on p\xc3\xa4\xc3\xa4ttynyt.'
b'DocType: Expense Claim Account',b'Expense Claim Account',b'Matkakorvauslomakkeet Account'
b'DocType: Accounts Settings',b'Allow Stale Exchange Rates',b'Salli vanhentuneet kurssit'
b'DocType: Sales Person',b'Sales Person Name',b'Myyj\xc3\xa4n nimi'
b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54',b'Please enter atleast 1 invoice in the table',b'Sy\xc3\xb6t\xc3\xa4 taulukkoon v\xc3\xa4hint\xc3\xa4\xc3\xa4n yksi lasku'
b'apps/erpnext/erpnext/utilities/user_progress.py +247',b'Add Users',b'Lis\xc3\xa4\xc3\xa4 k\xc3\xa4ytt\xc3\xa4ji\xc3\xa4'
b'DocType: POS Item Group',b'Item Group',b'Tuoteryhm\xc3\xa4'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16',b'Student Group: ',b'Opiskelijaryhm\xc3\xa4:'
b'DocType: Item',b'Safety Stock',b'Varmuusvarasto'
b'DocType: Healthcare Settings',b'Healthcare Settings',b'Terveydenhuollon asetukset'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +54',b'Progress % for a task cannot be more than 100.',b'Progress% teht\xc3\xa4v\xc3\xa4\xc3\xa4n ei voi olla enemm\xc3\xa4n kuin 100.'
b'DocType: Stock Reconciliation Item',b'Before reconciliation',b'Ennen t\xc3\xa4sm\xc3\xa4ytyst\xc3\xa4'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12',b'To {0}',b'{0}:lle'
b'DocType: Purchase Invoice',b'Taxes and Charges Added (Company Currency)',b'Lis\xc3\xa4tyt verot ja maksut (yrityksen valuutassa)'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +476',b'Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable',"b'tuotteen vero, rivi {0} veron tyyppi tulee m\xc3\xa4\xc3\xa4ritell\xc3\xa4 (tulo, kulu, veloitettava)'"
b'DocType: Sales Order',b'Partly Billed',b'Osittain Laskutetaan'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +43',b'Item {0} must be a Fixed Asset Item',b'Kohta {0} on oltava k\xc3\xa4ytt\xc3\xb6- omaisuuser\xc3\xa4n'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +372',b'Make Variants',b'Tee muutokset'
b'DocType: Item',b'Default BOM',b'oletus BOM'
b'DocType: Project',b'Total Billed Amount (via Sales Invoices)',b'Laskutettu kokonaissumma (myyntilaskut)'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Debit Note Amount',b'Veloitusilmoituksen M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Project Update',b'Not Updated',b'Ei p\xc3\xa4ivitetty'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106',"b'There are inconsistencies between the rate, no of shares and the amount calculated'","b'Ristiriitojen v\xc3\xa4lill\xc3\xa4 on ristiriita, osakkeiden lukum\xc3\xa4\xc3\xa4r\xc3\xa4 ja laskettu m\xc3\xa4\xc3\xa4r\xc3\xa4'"
b'apps/erpnext/erpnext/setup/doctype/company/company.js +89',b'Please re-type company name to confirm',b'Kirjoita yrityksen nimi uudelleen vahvistukseksi'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +216',b'Total Outstanding Amt',"b'odottaa, pankkip\xc3\xa4\xc3\xa4te yhteens\xc3\xa4'"
b'DocType: Journal Entry',b'Printing Settings',b'Tulostusasetukset'
b'DocType: Employee Advance',b'Advance Account',b'Ennakkomaksu'
b'DocType: Job Offer',b'Job Offer Terms',b'Ty\xc3\xb6tarjouksen ehdot'
b'DocType: Sales Invoice',b'Include Payment (POS)',b'Sis\xc3\xa4lt\xc3\xa4v\xc3\xa4t maksut (POS)'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292',b'Total Debit must be equal to Total Credit. The difference is {0}',"b'Debet yhteens\xc3\xa4 tulee olla sama kuin kredit yhteens\xc3\xa4, ero on {0}'"
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11',b'Automotive',b'Automotive'
b'DocType: Vehicle',b'Insurance Company',b'Vakuutusyhti\xc3\xb6'
b'DocType: Asset Category Account',b'Fixed Asset Account',b'Kiinte\xc3\xa4 tasetilille'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414',b'Variable',b'Muuttuja'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47',b'From Delivery Note',b'l\xc3\xa4hetteest\xc3\xa4'
b'DocType: Chapter',b'Members',b'J\xc3\xa4senet'
b'DocType: Student',b'Student Email Address',b'Student S\xc3\xa4hk\xc3\xb6postiosoite'
b'DocType: Item',b'Hub Warehouse',b'Hub-varasto'
b'DocType: Assessment Plan',b'From Time',b'ajasta'
b'DocType: Hotel Settings',b'Hotel Settings',b'Hotellin asetukset'
b'apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12',b'In Stock: ',b'Varastossa:'
b'DocType: Notification Control',b'Custom Message',b'Mukautettu viesti'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33',b'Investment Banking',b'sijoitukset pankki'
b'DocType: Purchase Invoice',b'input',b'panos'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79',b'Cash or Bank Account is mandatory for making payment entry',b'kassa tai pankkitili vaaditaan maksujen kirjaukseen'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Student Osoite'
b'DocType: Purchase Invoice',b'Price List Exchange Rate',b'valuuttakurssi'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +251',b'Account Number {0} already used in account {1}',b'Tilinumero {0} on jo k\xc3\xa4ytetty tili {1}'
b'DocType: GoCardless Mandate',b'Mandate',b'mandaatti'
b'DocType: POS Profile',b'POS Profile Name',b'POS-profiilin nimi'
b'DocType: Hotel Room Reservation',b'Booked',b'Varattu'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxLib',b'CompAuxLib'
b'DocType: Purchase Invoice Item',b'Rate',b'Hinta'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104',b'Intern',b'harjoitella'
b'DocType: Delivery Stop',b'Address Name',b'Osoite Nimi'
b'DocType: Stock Entry',b'From BOM',b'Osaluettelolta'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639',b'Splitting {0} units of {1}',b'Jakamalla {0} yksikk\xc3\xb6\xc3\xa4 {1}'
b'DocType: Assessment Code',b'Assessment Code',b'arviointi koodi'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73',b'Basic',b'perustiedot'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94',b'Stock transactions before {0} are frozen',b'ennen {0} rekister\xc3\xb6idyt varastotapahtumat on j\xc3\xa4\xc3\xa4dytetty'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219',"b""Please click on 'Generate Schedule'""","b'klikkaa ""muodosta aikataulu""'"
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122',b'Reference No is mandatory if you entered Reference Date',b'viitenumero vaaditaan myk\xc3\xa4li viitep\xc3\xa4iv\xc3\xa4 on annettu'
b'DocType: Bank Reconciliation Detail',b'Payment Document',b'Maksu asiakirja'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37',b'Error evaluating the criteria formula',b'Virhe arvosteluperusteiden kaavasta'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +115',b'Date of Joining must be greater than Date of Birth',b'liittymisp\xc3\xa4iv\xc3\xa4 tulee olla syntym\xc3\xa4p\xc3\xa4iv\xc3\xa4n j\xc3\xa4lkeen'
b'DocType: Salary Slip',b'Salary Structure',b'Palkkarakenne'
b'DocType: Account',b'Bank',b'pankki'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9',b'Airline',b'lentoyhti\xc3\xb6'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853',b'Issue Material',b'Varasto-otto'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'An error occured while creating recurring',b'Virhe aiheutui toistuvan luomisen aikana'
b'DocType: Material Request Item',b'For Warehouse',b'Varastoon'
b'DocType: Employee',b'Offer Date',b'Ty\xc3\xb6sopimusehdotuksen p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33',b'Quotations',b'Lainaukset'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +735',b'You are in offline mode. You will not be able to reload until you have network.',b'Olet offline-tilassa. Et voi ladata kunnes olet verkon.'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47',b'No Student Groups created.',b'Ei opiskelijaryhmille luotu.'
b'DocType: Purchase Invoice Item',b'Serial No',b'Sarjanumero'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119',b'Monthly Repayment Amount cannot be greater than Loan Amount',b'Kuukauden lyhennyksen m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla suurempi kuin Lainam\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143',b'Please enter Maintaince Details first',b'Sy\xc3\xb6t\xc3\xa4 yll\xc3\xa4pidon lis\xc3\xa4tiedot ensin'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56',b'Row #{0}: Expected Delivery Date cannot be before Purchase Order Date',b'Rivi # {0}: Odotettu toimitusp\xc3\xa4iv\xc3\xa4 ei voi olla ennen ostotilausp\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'DocType: Purchase Invoice',b'Print Language',b'k\xc3\xa4ytett\xc3\xa4v\xc3\xa4 tulosteiden kieli'
b'DocType: Salary Slip',b'Total Working Hours',b'Kokonaisty\xc3\xb6aika'
b'DocType: Sales Invoice',b'Customer PO Details',b'Asiakas PO: n tiedot'
b'DocType: Subscription',b'Next Schedule Date',b'Seuraava aikataulu'
b'DocType: Stock Entry',b'Including items for sub assemblies',b'mukaanlukien alikokoonpanon tuotteet'
b'DocType: Opening Invoice Creation Tool Item',b'Temporary Opening Account',b'Tilap\xc3\xa4inen avaustili'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1964',b'Enter value must be positive',b'Anna-arvon on oltava positiivinen'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446',b'All Territories',b'Kaikki alueet'
b'apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49',b'Add Multiple Tasks',b'Lis\xc3\xa4\xc3\xa4 useita teht\xc3\xa4vi\xc3\xa4'
b'DocType: Purchase Invoice',b'Items',b'Nimikkeet'
b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34',b'Student is already enrolled.',b'Opiskelijan on jo ilmoittautunut.'
b'DocType: Fiscal Year',b'Year Name',b'Vuoden nimi'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241',b'There are more holidays than working days this month.',b'T\xc3\xa4ss\xc3\xa4 kuussa ei ole lomap\xc3\xa4ivi\xc3\xa4 ty\xc3\xb6p\xc3\xa4ivin\xc3\xa4'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78',b'PDC/LC Ref',b'PDC / LC Ref'
b'DocType: Product Bundle Item',b'Product Bundle Item',b'Tuotepaketin nimike'
b'DocType: Sales Partner',b'Sales Partner Name',b'Myyntikumppani nimi'
b'apps/erpnext/erpnext/hooks.py +136',b'Request for Quotations',b'Pyynt\xc3\xb6 Lainaukset'
b'DocType: Payment Reconciliation',b'Maximum Invoice Amount',b'Suurin Laskun summa'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Montantdevise',b'Montantdevise'
b'apps/erpnext/erpnext/healthcare/setup.py +210',b'Haematology',b'hematologian'
b'DocType: Normal Test Items',b'Normal Test Items',b'Normaalit koekappaleet'
b'DocType: Student Language',b'Student Language',b'Student Kieli'
b'apps/erpnext/erpnext/config/selling.py +23',b'Customers',b'asiakkaat'
b'DocType: Cash Flow Mapping',b'Is Working Capital',b'On k\xc3\xa4ytt\xc3\xb6p\xc3\xa4\xc3\xa4oma'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Tilaus / Quot%'
b'apps/erpnext/erpnext/config/healthcare.py +25',b'Record Patient Vitals',b'Record potilaan vitals'
b'DocType: Fee Schedule',b'Institution',b'Instituutio'
b'DocType: Asset',b'Partially Depreciated',b'Osittain poistoja'
b'DocType: Issue',b'Opening Time',b'Aukeamisaika'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89',b'From and To dates required',b'alkaen- ja p\xc3\xa4\xc3\xa4tyen p\xc3\xa4iv\xc3\xa4 vaaditaan'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46',b'Securities & Commodity Exchanges',b'Arvopaperit & hy\xc3\xb6dykkeet vaihto'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +689',"b""Default Unit of Measure for Variant '{0}' must be same as in Template '{1}'""","b""Variaation '{0}' oletusyksikk\xc3\xb6 pit\xc3\xa4\xc3\xa4 olla sama kuin mallilla '{1}'"""
b'DocType: Shipping Rule',b'Calculate Based On',b'Laskenta perustuen'
b'DocType: Delivery Note Item',b'From Warehouse',b'Varastosta'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59',b'No employees for the mentioned criteria',b'Ei ty\xc3\xb6ntekij\xc3\xb6it\xc3\xa4 mainituilla kriteereill\xc3\xa4'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955',b'No Items with Bill of Materials to Manufacture',b'Kohteita ei Bill materiaalien valmistus'
b'DocType: Hotel Settings',b'Default Customer',b'Oletusasiakas'
b'DocType: Assessment Plan',b'Supervisor Name',b'ohjaaja Name'
b'DocType: Healthcare Settings',b'Do not confirm if appointment is created for the same day',"b'\xc3\x84l\xc3\xa4 vahvista, onko tapaaminen luotu samalle p\xc3\xa4iv\xc3\xa4lle'"
b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Ohjelma Ilmoittautuminen kurssi'
b'DocType: Purchase Taxes and Charges',b'Valuation and Total',b'Arvo ja Summa'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11',b'Scorecards',b'tuloskortit'
b'DocType: Tax Rule',b'Shipping City',b'Toimitus Kaupunki'
b'DocType: Notification Control',b'Customize the Notification',b'muokkaa ilmoitusta'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24',b'Cash Flow from Operations',b'LIIKETOIMINNAN RAHAVIRTA'
b'DocType: Purchase Invoice',b'Shipping Rule',b'Toimitustapa'
b'DocType: Patient Relation',b'Spouse',b'puoliso'
b'DocType: Lab Test Groups',b'Add Test',b'Lis\xc3\xa4\xc3\xa4 testi'
b'DocType: Manufacturer',b'Limited to 12 characters',b'Rajattu 12 merkkiin'
b'DocType: Journal Entry',b'Print Heading',b'Tulosteen otsikko'
b'apps/erpnext/erpnext/config/stock.py +146',b'Delivery Trip service tours to customers.',b'Toimitusmatkavierailut asiakkaille.'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57',b'Total cannot be zero',b'Yhteens\xc3\xa4 ei voi olla nolla'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16',"b""'Days Since Last Order' must be greater than or equal to zero""","b""'P\xc3\xa4iv\xc3\xa4\xc3\xa4 edellisest\xc3\xa4 tilauksesta' on oltava suurempi tai yht\xc3\xa4suuri kuin nolla"""
b'DocType: Plant Analysis Criteria',b'Maximum Permissible Value',b'Suurin sallittu arvo'
b'DocType: Journal Entry Account',b'Employee Advance',b'Ty\xc3\xb6ntekij\xc3\xa4n ennakko'
b'DocType: Payroll Entry',b'Payroll Frequency',b'Payroll Frequency'
b'DocType: Lab Test Template',b'Sensitivity',b'Herkkyys'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941',b'Raw Material',b'Raaka-aine'
b'DocType: Leave Application',b'Follow via Email',b'Seuraa s\xc3\xa4hk\xc3\xb6postitse'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55',b'Plants and Machineries',b'Laitteet ja koneisto'
b'DocType: Purchase Taxes and Charges',b'Tax Amount After Discount Amount',b'Veron arvom\xc3\xa4\xc3\xa4r\xc3\xa4 alennuksen j\xc3\xa4lkeen'
b'DocType: Daily Work Summary Settings',b'Daily Work Summary Settings',b'P\xc3\xa4ivitt\xc3\xa4inen ty\xc3\xb6 Yhteenveto Asetukset'
b'apps/erpnext/erpnext/controllers/buying_controller.py +447',b'Please enter Reqd by Date',b'Anna Reqd p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4n mukaan'
b'DocType: Payment Entry',b'Internal Transfer',b'sis\xc3\xa4inen siirto'
b'DocType: Asset Maintenance',b'Maintenance Tasks',b'Huoltotoimet'
b'apps/erpnext/erpnext/setup/doctype/territory/territory.py +19',b'Either target qty or target amount is mandatory',b'tavoite yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 tai tavoite arvom\xc3\xa4\xc3\xa4r\xc3\xa4 vaaditaan'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366',b'Please select Posting Date first',b'Valitse ensin tositep\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/public/js/account_tree_grid.js +209',b'Opening Date should be before Closing Date',b'Aukiolop\xc3\xa4iv\xc3\xa4 pit\xc3\xa4isi olla ennen Tarjouksentekij\xc3\xa4'
b'DocType: Leave Control Panel',b'Carry Forward',b'siirr\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30',b'Cost Center with existing transactions can not be converted to ledger',b'olemassaolevien tapahtumien kustannuspaikkaa ei voi muuttaa tilikirjaksi'
b'DocType: Department',b'Days for which Holidays are blocked for this department.',b'p\xc3\xa4iv\xc3\xa4t jolloin lomat on estetty t\xc3\xa4lle osastolle'
b'DocType: GoCardless Mandate',b'ERPNext Integrations',b'ERPNext-integraatiot'
b'DocType: Crop Cycle',b'Detected Disease',b'Havaittu tauti'
,b'Produced',b'Valmistettu'
b'DocType: Item',b'Item Code for Suppliers',b'Toimittajan nimikekoodi'
b'DocType: Issue',b'Raised By (Email)',b'Pyynn\xc3\xb6n tekij\xc3\xa4 (s\xc3\xa4hk\xc3\xb6posti)'
b'DocType: Training Event',b'Trainer Name',b'Trainer Name'
b'DocType: Mode of Payment',b'General',b'p\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Viimeisin yhteydenotto'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372',"b""Cannot deduct when category is for 'Valuation' or 'Valuation and Total'""","b""v\xc3\xa4hennyst\xc3\xa4 ei voi tehd\xc3\xa4 jos kategoria on  'arvo'  tai 'arvo ja summa'"""
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234',b'Serial Nos Required for Serialized Item {0}',b'Sarjanumero edelytt\xc3\xa4\xc3\xa4 sarjoitettua tuotetta {0}'
b'apps/erpnext/erpnext/config/accounts.py +144',b'Match Payments with Invoices',b'Match Maksut Laskut'
b'DocType: Journal Entry',b'Bank Entry',b'pankkikirjaus'
b'DocType: Authorization Rule',b'Applicable To (Designation)',b'sovellettavissa (nimi)'
,b'Profitability Analysis',b'Kannattavuusanalyysi'
b'DocType: Fees',b'Student Email',b'Opiskelijan s\xc3\xa4hk\xc3\xb6posti'
b'DocType: Supplier',b'Prevent POs',b'Est\xc3\xa4 tuottajaorganisaatioita'
b'DocType: Patient',"b'Allergies, Medical and Surgical History'","b'Allergiat, l\xc3\xa4\xc3\xa4ketieteellinen ja kirurginen historia'"
b'apps/erpnext/erpnext/templates/generators/item.html +77',b'Add to Cart',b'Lis\xc3\xa4\xc3\xa4 koriin'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28',b'Group By',b'ryhm\xc3\xa4n'
b'DocType: Guardian',b'Interests',b'etu'
b'apps/erpnext/erpnext/config/accounts.py +298',b'Enable / disable currencies.',"b'aktivoi / poista k\xc3\xa4yt\xc3\xb6st\xc3\xa4, valuutat'"
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105',b'Dr {0} on Half day Leave on {1}',b'Dr {0} puolen p\xc3\xa4iv\xc3\xa4n lomalla {1}'
b'DocType: Production Plan',b'Get Material Request',b'Hae hankintapyynt\xc3\xb6'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111',b'Postal Expenses',b'Postituskulut'
b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Amt)',b'yhteens\xc3\xa4 (summa)'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26',b'Entertainment & Leisure',b'edustus & vapaa-aika'
,b'Item Variant Details',b'Tuote varianttien tiedot'
b'DocType: Quality Inspection',b'Item Serial No',b'tuote sarjanumero'
b'apps/erpnext/erpnext/utilities/activation.py +135',b'Create Employee Records',b'Luo Ty\xc3\xb6ntekij\xc3\xa4 Records'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Present',b'Nykyarvo yhteens\xc3\xa4'
b'apps/erpnext/erpnext/config/accounts.py +105',b'Accounting Statements',b'tilinp\xc3\xa4\xc3\xa4t\xc3\xb6ksen'
b'DocType: Drug Prescription',b'Hour',b'tunti'
b'DocType: Restaurant Order Entry',b'Last Sales Invoice',b'Viimeinen ostolasku'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +788',b'Please select Qty against item {0}',b'Valitse Qty {0}'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29',b'New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt',"b'uusi sarjanumero voi olla varastossa, sarjanumero muodoruu varaston kirjauksella tai ostokuitilla'"
b'DocType: Lead',b'Lead Type',b'vihjeen tyyppi'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114',b'You are not authorized to approve leaves on Block Dates',b'Sinulla ei ole lupa hyv\xc3\xa4ksy\xc3\xa4 lehdet Block P\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4t'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394',b'All these items have already been invoiced',b'Kaikki n\xc3\xa4m\xc3\xa4 asiat on jo laskutettu'
b'DocType: Company',b'Monthly Sales Target',b'Kuukausittainen myyntiketju'
b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37',b'Can be approved by {0}',b'Hyv\xc3\xa4ksynn\xc3\xa4n voi tehd\xc3\xa4 {0}'
b'DocType: Hotel Room',b'Hotel Room Type',b'Hotellin huoneen tyyppi'
b'DocType: Item',b'Default Material Request Type',b'Oletus hankintapyynn\xc3\xb6n tyyppi'
b'DocType: Supplier Scorecard',b'Evaluation Period',b'Arviointijakso'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13',b'Unknown',b'Tuntematon'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954',b'Work Order not created',b'Ty\xc3\xb6j\xc3\xa4rjestyst\xc3\xa4 ei luotu'
b'DocType: Shipping Rule',b'Shipping Rule Conditions',b'Toimitustavan ehdot'
b'DocType: Purchase Invoice',b'Export Type',b'Vientityyppi'
b'DocType: Salary Slip Loan',b'Salary Slip Loan',b'Palkkavelkakirjalaina'
b'DocType: BOM Update Tool',b'The new BOM after replacement',b'Uusi osaluettelo korvauksen j\xc3\xa4lkeen'
,b'Point of Sale',b'Myyntipiste'
b'DocType: Payment Entry',b'Received Amount',b'Vastaanotetut M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Patient',b'Widow',b'Leski'
b'DocType: GST Settings',b'GSTIN Email Sent On',b'GSTIN S\xc3\xa4hk\xc3\xb6posti L\xc3\xa4hetetyt K\xc3\xa4yt\xc3\xb6ss\xc3\xa4'
b'DocType: Program Enrollment',b'Pick/Drop by Guardian',b'Pick / Drop Guardian'
b'DocType: Crop',b'Planting UOM',b'Istutus UOM'
b'DocType: Account',b'Tax',b'Vero'
b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45',b'Not Marked',b'ei Merkitty'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1',b'Opening Invoices Summary',b'Avauslaskujen yhteenveto'
b'DocType: Education Settings',b'Education Manager',b'Koulutusp\xc3\xa4\xc3\xa4llikk\xc3\xb6'
b'DocType: Crop Cycle',b'The minimum length between each plant in the field for optimum growth',b'Pienin pituus jokaisen kasvin v\xc3\xa4lill\xc3\xa4 optimaalisen kasvun suhteen'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Er\xc3\xa4-nimikett\xc3\xa4 {0} ei voi p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 varaston t\xc3\xa4sm\xc3\xa4ytyksell\xc3\xa4, tee varastotapahtuma'"
b'DocType: Quality Inspection',b'Report Date',b'raporttip\xc3\xa4iv\xc3\xa4'
b'DocType: Student',b'Middle Name',b'Toinen nimi'
b'DocType: C-Form',b'Invoices',b'laskut'
b'DocType: Water Analysis',b'Type of Sample',b'N\xc3\xa4ytteen tyyppi'
b'DocType: Batch',b'Source Document Name',b'L\xc3\xa4hde Asiakirjan nimi'
b'DocType: Production Plan',b'Get Raw Materials For Production',b'Hanki raaka-aineita tuotannolle'
b'DocType: Job Opening',b'Job Title',b'Ty\xc3\xb6teht\xc3\xa4v\xc3\xa4'
b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84',"b'{0} indicates that {1} will not provide a quotation, but all items \\\n\t\t\t\t\thave been quoted. Updating the RFQ quote status.'","b'{0} ilmoittaa, ett\xc3\xa4 {1} ei anna tarjousta, mutta kaikki kohteet on mainittu. RFQ-lainauksen tilan p\xc3\xa4ivitt\xc3\xa4minen.'"
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026',b'Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.',b'Suurin n\xc3\xa4ytteit\xc3\xa4 - {0} on jo s\xc3\xa4ilytetty er\xc3\xa4\xc3\xa4 {1} ja er\xc3\xa4\xc3\xa4 {2} er\xc3\xa4\xc3\xa4 {3} varten.'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125',b'Please Set Supplier Type in Buying Settings.',b'Aseta toimittajan tyyppi ostosasetuksiin.'
b'DocType: Manufacturing Settings',b'Update BOM Cost Automatically',b'P\xc3\xa4ivit\xc3\xa4 BOM-hinta automaattisesti'
b'DocType: Lab Test',b'Test Name',b'Testi Nimi'
b'apps/erpnext/erpnext/utilities/activation.py +99',b'Create Users',b'Luo K\xc3\xa4ytt\xc3\xa4j\xc3\xa4t'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Gram',b'Gramma'
b'DocType: Supplier Scorecard',b'Per Month',b'Kuukaudessa'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433',b'Quantity to Manufacture must be greater than 0.',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 Valmistus on oltava suurempi kuin 0.'
b'DocType: Asset Settings',b'Calculate Prorated Depreciation Schedule Based on Fiscal Year',"b'Laske tasapoisto, joka perustuu tilikauteen'"
b'apps/erpnext/erpnext/config/maintenance.py +17',b'Visit report for maintenance call.',b'K\xc3\xa4yntiraportti huoltopyynn\xc3\xb6ille'
b'DocType: Stock Entry',b'Update Rate and Availability',b'P\xc3\xa4ivit\xc3\xa4 m\xc3\xa4\xc3\xa4r\xc3\xa4 ja saatavuus'
b'DocType: Stock Settings',b'Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.',"b'Vastaanoton tai toimituksen prosenttiosuus on liian suuri suhteessa tilausm\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4n, esim: mik\xc3\xa4li 100 yksikk\xc3\xb6\xc3\xa4 on tilattu sallittu ylitys on 10% niin sallittu m\xc3\xa4\xc3\xa4r\xc3\xa4 on 110 yksikk\xc3\xb6\xc3\xa4'"
b'DocType: POS Customer Group',b'Customer Group',b'Asiakasryhm\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217',b'Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs',b'Rivi # {0}: K\xc3\xa4ytt\xc3\xb6 {1} ei ole valmis {2} valmiiden tuotteiden kohdalla ty\xc3\xb6j\xc3\xa4rjestyksess\xc3\xa4 # {3}. P\xc3\xa4ivit\xc3\xa4 toimintatila ajanjaksojen avulla'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Uusi Er\xc3\xa4tunnuksesi (valinnainen)'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201',b'Expense account is mandatory for item {0}',b'Kustannustili on vaaditaan tuotteelle {0}'
b'DocType: BOM',b'Website Description',b'Verkkosivuston kuvaus'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47',b'Net Change in Equity',b'Nettomuutos Equity'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +220',b'Please cancel Purchase Invoice {0} first',b'Peru ostolasku {0} ensin'
b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43',"b'Email Address must be unique, already exists for {0}'","b'S\xc3\xa4hk\xc3\xb6postiosoite t\xc3\xa4ytyy olla yksil\xc3\xb6llinen, on jo olemassa {0}'"
b'DocType: Serial No',b'AMC Expiry Date',b'Yll\xc3\xa4pidon umpeutumisp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880',b'Receipt',b'kuitti'
,b'Sales Register',b'Myyntirekisteri'
b'DocType: Daily Work Summary Group',b'Send Emails At',b'L\xc3\xa4het\xc3\xa4 s\xc3\xa4hk\xc3\xb6posteja'
b'DocType: Quotation',b'Quotation Lost Reason',"b'Tarjous h\xc3\xa4vitty, syy'"
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381',b'Transaction reference no {0} dated {1}',b'Transaction viitenumero {0} p\xc3\xa4iv\xc3\xa4tyn {1}'
b'apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5',b'There is nothing to edit.',b'Ei muokattavaa.'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116',b'Summary for this month and pending activities',b'Yhteenveto t\xc3\xa4ss\xc3\xa4 kuussa ja keskener\xc3\xa4isten toimien'
b'apps/erpnext/erpnext/utilities/user_progress.py +248',"b'Add users to your organization, other than yourself.'",b'Lis\xc3\xa4\xc3\xa4 k\xc3\xa4ytt\xc3\xa4ji\xc3\xa4 muuhun organisaatioon kuin itse.'
b'DocType: Customer Group',b'Customer Group Name',b'Asiakasryhm\xc3\xa4n nimi'
b'apps/erpnext/erpnext/public/js/pos/pos.html +109',b'No Customers yet!',b'Ei Asiakkaat viel\xc3\xa4!'
b'apps/erpnext/erpnext/public/js/financial_statements.js +56',b'Cash Flow Statement',b'Rahavirtalaskelma'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473',b'No material request created',b'Materiaalihakua ei ole luotu'
b'apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23',b'Loan Amount cannot exceed Maximum Loan Amount of {0}',b'Lainam\xc3\xa4\xc3\xa4r\xc3\xa4 voi ylitt\xc3\xa4\xc3\xa4 suurin lainam\xc3\xa4\xc3\xa4r\xc3\xa4 on {0}'
b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22',b'License',b'lisenssi'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491',b'Please remove this Invoice {0} from C-Form {1}',b'Poista lasku {0} C-kaaviosta {1}'
b'DocType: Leave Control Panel',"b""Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year""",b'Valitse jatka eteenp\xc3\xa4in mik\xc3\xa4li haluat sis\xc3\xa4llytt\xc3\xa4\xc3\xa4 edellisen tilikauden taseen t\xc3\xa4lle tilikaudelle'
b'DocType: GL Entry',b'Against Voucher Type',b'tositteen tyyppi kohdistus'
b'DocType: Physician',b'Phone (R)',b'Puhelin (R)'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56',b'Time slots added',b'Aikav\xc3\xa4lit lis\xc3\xa4t\xc3\xa4\xc3\xa4n'
b'DocType: Item',b'Attributes',b'tuntomerkkej\xc3\xa4'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31',b'Enable Template',b'Ota mallipohja k\xc3\xa4ytt\xc3\xb6\xc3\xb6n'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226',b'Please enter Write Off Account',b'Sy\xc3\xb6t\xc3\xa4 poistotili'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71',b'Last Order Date',b'Viimeinen tilaus p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Patient',b'B Negative',b'B Negatiivinen'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25',b'Maintenance Status has to be Cancelled or Completed to Submit',b'Huoltotila on peruutettava tai teht\xc3\xa4v\xc3\xa4 l\xc3\xa4hetett\xc3\xa4v\xc3\xa4ksi'
b'DocType: Hotel Room',b'Hotel Room',b'Hotellihuone'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47',b'Account {0} does not belongs to company {1}',b'Tili {0} ei kuulu yritykselle {1}'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884',b'Serial Numbers in row {0} does not match with Delivery Note',b'Sarjanumeroita per\xc3\xa4kk\xc3\xa4in {0} ei vastaa l\xc3\xa4hetysluettelon'
b'DocType: Student',b'Guardian Details',b'Guardian Tietoja'
b'DocType: C-Form',b'C-Form',b'C-muoto'
b'apps/erpnext/erpnext/config/hr.py +18',b'Mark Attendance for multiple employees',b'Mark L\xc3\xa4sn\xc3\xa4olo useita ty\xc3\xb6ntekij\xc3\xb6it\xc3\xa4'
b'DocType: Agriculture Task',b'Start Day',b'Aloita p\xc3\xa4iv\xc3\xa4'
b'DocType: Vehicle',b'Chassis No',b'Alusta ei'
b'DocType: Payment Request',b'Initiated',b'Aloitettu'
b'DocType: Production Plan Item',b'Planned Start Date',b'Suunniteltu aloitusp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +618',b'Please select a BOM',b'Valitse BOM'
b'DocType: Purchase Invoice',b'Availed ITC Integrated Tax',b'K\xc3\xa4ytti ITC: n integroitua veroa'
b'DocType: Serial No',b'Creation Document Type',b'Dokumenttityypin luonti'
b'DocType: Project Task',b'View Timesheet',b'N\xc3\xa4yt\xc3\xa4 aikakirja'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54',b'End date must be greater than start date',b'Loppup\xc3\xa4iv\xc3\xa4n on oltava alkamisp\xc3\xa4iv\xc3\xa4'
b'DocType: Leave Type',b'Is Encash',b'on perint\xc3\xa4'
b'DocType: Leave Allocation',b'New Leaves Allocated',b'uusi poistumisten kohdennus'
b'apps/erpnext/erpnext/controllers/trends.py +269',b'Project-wise data is not available for Quotation',"b'projekti ty\xc3\xb6kalu, tietoja ei ole saatavilla tarjousvaiheessa'"
b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30',b'End on',b'Lopeta'
b'DocType: Project',b'Expected End Date',b'odotettu p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Budget Account',b'Budget Amount',b'talousarvio M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Donor',b'Donor Name',b'Luovuttajan nimi'
b'DocType: Appraisal Template',b'Appraisal Template Title',b'arvioinnin otsikko'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39',"b""From Date {0} for Employee {1} cannot be before employee's joining Date {2}""",b'Vuodesta Date {0} for Employee {1} ei voi olla ennen ty\xc3\xb6ntekij\xc3\xa4n liittymist\xc3\xa4 Date {2}'
b'apps/erpnext/erpnext/utilities/user_progress_utils.py +29',b'Commercial',b'kaupallinen'
b'DocType: Patient',b'Alcohol Current Use',b'Alkoholi nykyinen k\xc3\xa4ytt\xc3\xb6'
b'DocType: Student Admission Program',b'Student Admission Program',b'Opiskelijavalintaohjelma'
b'DocType: Payment Entry',b'Account Paid To',b'Tilin Palkallinen'
b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24',b'Parent Item {0} must not be a Stock Item',b'P\xc3\xa4\xc3\xa4kohde {0} ei saa olla varasto tuote'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466',b'Could not submit any Salary Slip <br>\\\n\t\t\tPossible reasons: <br>\\\n\t\t\t1. Net pay is less than 0. <br>\\\n\t\t\t2. Company Email Address specified in employee master is not valid. <br>',b'Ei voitu l\xc3\xa4hett\xc3\xa4\xc3\xa4 palkkap\xc3\xa4iv\xc3\xa4rahaa <br> \\ Mahdollisia syit\xc3\xa4: <br> \\ 1. Nettopalkka on alle 0. <br> \\ 2. Ty\xc3\xb6ntekij\xc3\xb6iden p\xc3\xa4\xc3\xa4llik\xc3\xb6lle m\xc3\xa4\xc3\xa4ritetty yrityksen s\xc3\xa4hk\xc3\xb6postiosoite ei ole kelvollinen. <br>'
b'apps/erpnext/erpnext/config/selling.py +57',b'All Products or Services.',b'Kaikki tuotteet tai palvelut'
b'DocType: Expense Claim',b'More Details',b'Lis\xc3\xa4tietoja'
b'DocType: Supplier Quotation',b'Supplier Address',b'Toimittajan osoite'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128',b'{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}',b'{0} talousarvion tili {1} vastaan {2} {3} on {4}. Se ylit\xc3\xa4 {5}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695',"b""Row {0}# Account must be of type 'Fixed Asset'""",b'Rivi {0} # Account t\xc3\xa4ytyy olla tyyppi\xc3\xa4 &quot;K\xc3\xa4ytt\xc3\xb6omaisuuden&quot;'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Out Qty',b'ulkona yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'and unchcked Disabled in the',b'ja unchcked Poissa k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41',b'Series is mandatory',b'Sarjat ovat pakollisia'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28',b'Financial Services',b'Talouspalvelu'
b'DocType: Student Sibling',b'Student ID',b'opiskelijanumero'
b'apps/erpnext/erpnext/config/projects.py +51',b'Types of activities for Time Logs',b'Toimintamuodot Aika Lokit'
b'DocType: Opening Invoice Creation Tool',b'Sales',b'Myynti'
b'DocType: Stock Entry Detail',b'Basic Amount',b'Perusm\xc3\xa4\xc3\xa4r\xc3\xa4t'
b'DocType: Training Event',b'Exam',b'Koe'
b'DocType: Complaint',b'Complaint',b'Valitus'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462',b'Warehouse required for stock Item {0}',b'Varasto vaaditaan varastotuotteelle {0}'
b'DocType: Leave Allocation',b'Unused leaves',b'K\xc3\xa4ytt\xc3\xa4m\xc3\xa4tt\xc3\xb6m\xc3\xa4t lehdet'
b'DocType: Patient',b'Alcohol Past Use',b'Alkoholin aiempi k\xc3\xa4ytt\xc3\xb6'
b'DocType: Fertilizer Content',b'Fertilizer Content',b'Lannoitteen sis\xc3\xa4lt\xc3\xb6'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187',b'Cr',b'Cr'
b'DocType: Project Update',b'Problematic/Stuck',b'Ongelmalliset / Stuck'
b'DocType: Tax Rule',b'Billing State',b'Laskutus valtion'
b'DocType: Share Transfer',b'Transfer',b'siirto'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252',b'Work Order {0} must be cancelled before cancelling this Sales Order',b'Ty\xc3\xb6j\xc3\xa4rjestys {0} on peruutettava ennen myyntitilauksen peruuttamista'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917',b'Fetch exploded BOM (including sub-assemblies)',b'Nouda BOM r\xc3\xa4j\xc3\xa4ytys (mukaan lukien alikokoonpanot)'
b'DocType: Authorization Rule',b'Applicable To (Employee)',b'sovellettavissa (ty\xc3\xb6ntekij\xc3\xa4)'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +137',b'Due Date is mandatory',b'er\xc3\xa4p\xc3\xa4iv\xc3\xa4 vaaditaan'
b'apps/erpnext/erpnext/controllers/item_variant.py +82',b'Increment for Attribute {0} cannot be 0',b'Puuston Taito {0} ei voi olla 0'
b'apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19',b'Rooms Booked',b'Huoneita varattu'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +57',b'Ends On date cannot be before Next Contact Date.',b'P\xc3\xa4\xc3\xa4ttyy P\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla ennen Seuraava Yhteysp\xc3\xa4iv\xc3\xa4.'
b'DocType: Journal Entry',b'Pay To / Recd From',b'Pay To / RECD Mist\xc3\xa4'
b'DocType: Naming Series',b'Setup Series',b'Sarjojen m\xc3\xa4\xc3\xa4ritys'
b'DocType: Payment Reconciliation',b'To Invoice Date',b'Laskun p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Shareholder',b'Contact HTML',"b'yhteystiedot, HTML'"
b'apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19',b'Registration fee can not be Zero',b'Ilmoittautumismaksu ei voi olla nolla'
b'DocType: Disease',b'Treatment Period',b'Hoitokausi'
b'apps/erpnext/erpnext/education/api.py +338',b'Result already Submitted',b'Tulos on jo l\xc3\xa4hetetty'
b'apps/erpnext/erpnext/controllers/buying_controller.py +169',b'Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied',b'Varatut varastot ovat pakollisia tavaran {0} toimittamissa raaka-aineissa'
,b'Inactive Customers',b'Ei-aktiiviset asiakkaat'
b'DocType: Student Admission Program',b'Maximum Age',b'Enimm\xc3\xa4isik\xc3\xa4'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28',b'Please wait 3 days before resending the reminder.',b'Odota 3 p\xc3\xa4iv\xc3\xa4\xc3\xa4 ennen muistutuksen l\xc3\xa4hett\xc3\xa4mist\xc3\xa4.'
b'DocType: Landed Cost Voucher',b'LCV',b'LCV'
b'DocType: Landed Cost Voucher',b'Purchase Receipts',b'Osto Kuitit'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29',b'How Pricing Rule is applied?',b'miten hinnoittelu s\xc3\xa4\xc3\xa4nt\xc3\xb6\xc3\xa4 k\xc3\xa4ytet\xc3\xa4\xc3\xa4n'
b'DocType: Stock Entry',b'Delivery Note No',b'l\xc3\xa4hetteen numero'
b'DocType: Cheque Print Template',b'Message to show',b'Viesti n\xc3\xa4ytt\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +28',b'Retail',b'V\xc3\xa4hitt\xc3\xa4iskauppa'
b'DocType: Student Attendance',b'Absent',b'puuttua'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591',b'Product Bundle',b'Tuotepaketti'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38',b'Unable to find score starting at {0}. You need to have standing scores covering 0 to 100',"b'Pistett\xc3\xa4 ei l\xc3\xb6ydy {0} alkaen. Sinun on oltava pysyvi\xc3\xa4 pisteit\xc3\xa4, jotka kattavat 0-100'"
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212',b'Row {0}: Invalid reference {1}',b'Rivi {0}: Virheellinen viittaus {1}'
b'DocType: Purchase Taxes and Charges Template',b'Purchase Taxes and Charges Template',b'Ostoverot ja maksupohjat'
b'DocType: Timesheet',b'TS-',b'TS-'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61',b'{0} {1}: Either debit or credit amount is required for {2}',b'{0} {1}: Joko debit- tai credit- summa tarvitaan {2}'
b'DocType: GL Entry',b'Remarks',b'Huomautukset'
b'DocType: Hotel Room Amenity',b'Hotel Room Amenity',b'Hotellin huoneen mukavuudet'
b'DocType: Payment Entry',b'Account Paid From',b'Tilin maksettu'
b'DocType: Purchase Order Item Supplied',b'Raw Material Item Code',b'Raaka-aineen tuotekoodi'
b'DocType: Task',b'Parent Task',b'Vanhempien teht\xc3\xa4v\xc3\xa4'
b'DocType: Journal Entry',b'Write Off Based On',b'Poisto perustuu'
b'apps/erpnext/erpnext/utilities/activation.py +65',b'Make Lead',b'Luo liidi'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112',b'Print and Stationery',b'Tulosta ja Paperi'
b'DocType: Stock Settings',b'Show Barcode Field',b'N\xc3\xa4yt\xc3\xa4 Viivakoodi-kentt\xc3\xa4'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809',b'Send Supplier Emails',b'L\xc3\xa4het\xc3\xa4 toimittaja S\xc3\xa4hk\xc3\xb6postit'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96',"b'Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.'","b'Palkka jo k\xc3\xa4sitell\xc3\xa4 v\xc3\xa4lisen\xc3\xa4 aikana {0} ja {1}, J\xc3\xa4t\xc3\xa4 hakuaika voi olla v\xc3\xa4lill\xc3\xa4 t\xc3\xa4ll\xc3\xa4 aikav\xc3\xa4lill\xc3\xa4.'"
b'DocType: Chapter Member',b'Leave Reason',b'J\xc3\xa4t\xc3\xa4 syy'
b'DocType: Guardian Interest',b'Guardian Interest',b'Guardian Interest'
b'DocType: Volunteer',b'Availability',b'Saatavuus'
b'apps/erpnext/erpnext/config/accounts.py +319',b'Setup default values for POS Invoices',b'POS laskujen oletusarvot'
b'apps/erpnext/erpnext/config/hr.py +182',b'Training',b'koulutus'
b'DocType: Project',b'Time to send',b'Aika l\xc3\xa4hett\xc3\xa4\xc3\xa4'
b'DocType: Timesheet',b'Employee Detail',b'ty\xc3\xb6ntekij\xc3\xa4n Detail'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 -s\xc3\xa4hk\xc3\xb6postitunnus'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68',"b""Next Date's day and Repeat on Day of Month must be equal""",b'Seuraava P\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 p\xc3\xa4iv\xc3\xa4 ja Toista kuukauden p\xc3\xa4iv\xc3\xa4 on oltava sama'
b'DocType: Lab Prescription',b'Test Code',b'Testikoodi'
b'apps/erpnext/erpnext/config/website.py +11',b'Settings for website homepage',b'Verkkosivun kotisivun asetukset'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40',b'RFQs are not allowed for {0} due to a scorecard standing of {1}',"b'Tarjouspyynn\xc3\xb6t eiv\xc3\xa4t ole sallittuja {0}, koska tuloskortin arvo on {1}'"
b'DocType: Job Offer',b'Awaiting Response',b'Odottaa vastausta'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60',b'Above',b'Yl\xc3\xa4puolella'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1466',b'Total Amount {0}',b'Kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4 {0}'
b'apps/erpnext/erpnext/controllers/item_variant.py +306',b'Invalid attribute {0} {1}',b'Virheellinen m\xc3\xa4\xc3\xa4rite {0} {1}'
b'DocType: Supplier',b'Mention if non-standard payable account',b'Mainitse jos standardista maksetaan tilille'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25',"b""Please select the assessment group other than 'All Assessment Groups'""",b'Valitse arvioinnin muu ryhm\xc3\xa4 kuin &quot;Kaikki arviointi Ryhmien'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67',b'Row {0}: Cost center is required for an item {1}',b'Rivi {0}: Kustannuspaikka tarvitaan kohteen {1}'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureDate',b'EcritureDate'
b'DocType: Training Event Employee',b'Optional',b'Valinnainen'
b'DocType: Salary Slip',b'Earning & Deduction',b'ansio & v\xc3\xa4hennys'
b'DocType: Agriculture Analysis Criteria',b'Water Analysis',b'Veden analyysi'
b'DocType: Chapter',b'Region',b'Alue'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38',b'Optional. This setting will be used to filter in various transactions.',"b'valinnainen, asetusta k\xc3\xa4ytet\xc3\xa4\xc3\xa4n suodatettaessa eri tapahtumia'"
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110',b'Negative Valuation Rate is not allowed',b'negatiivinen arvotaso ei ole sallittu'
b'DocType: Holiday List',b'Weekly Off',b'Viikottain pois'
b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7',b'Reload Linked Analysis',b'Lataa linkitetty analyysi'
b'DocType: Fiscal Year',"b'For e.g. 2012, 2012-13'","b'esim 2012, 2012-13'"
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96',b'Provisional Profit / Loss (Credit)',b'Voitto/tappio ote (kredit)'
b'DocType: Sales Invoice',b'Return Against Sales Invoice',b'palautus kohdistettuna myyntilaskuun'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32',b'Item 5',b'Nimike 5'
b'DocType: Serial No',b'Creation Time',b'tekoaika'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62',b'Total Revenue',b'liikevaihto yhteens\xc3\xa4'
b'DocType: Patient',b'Other Risk Factors',b'Muut riskitekij\xc3\xa4t'
b'DocType: Sales Invoice',b'Product Bundle Help',b'Tuotepaketti ohje'
,b'Monthly Attendance Sheet',b'Kuukausittainen l\xc3\xa4sn\xc3\xa4olokirjanpito'
b'apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15',b'No record found',b'Tietuetta ei l\xc3\xb6ydy'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140',b'Cost of Scrapped Asset',b'Kustannukset Scrapped Asset'
b'apps/erpnext/erpnext/controllers/stock_controller.py +236',b'{0} {1}: Cost Center is mandatory for Item {2}',b'{0} {1}: Kustannuspaikka on pakollinen nimikkeell\xc3\xa4 {2}'
b'DocType: Vehicle',b'Policy No',b'Policy Ei'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686',b'Get Items from Product Bundle',b'Hae nimikkeet tuotepaketista'
b'DocType: Asset',b'Straight Line',b'Suora viiva'
b'DocType: Project User',b'Project User',b'Projektik\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Jakaa'
b'DocType: GL Entry',b'Is Advance',b'on ennakko'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21',b'Attendance From Date and Attendance To Date is mandatory',"b'osallistuminen p\xc3\xa4iv\xc3\xa4st\xc3\xa4, osallistuminen p\xc3\xa4iv\xc3\xa4\xc3\xa4n To vaaditaan'"
b'apps/erpnext/erpnext/controllers/buying_controller.py +156',"b""Please enter 'Is Subcontracted' as Yes or No""","b'Sy\xc3\xb6t\xc3\xa4 ""on alihankittu"" (kyll\xc3\xa4 tai ei)'"
b'DocType: Item',b'Default Purchase Unit of Measure',b'Oletusarvonostoyksikk\xc3\xb6'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Viime yhteysp\xc3\xa4iv\xc3\xa4'
b'DocType: Sales Team',b'Contact No.',b'yhteystiedot nro'
b'DocType: Bank Reconciliation',b'Payment Entries',b'Maksu merkinn\xc3\xa4t'
b'DocType: Land Unit',b'Land Unit Details',b'Maayksik\xc3\xb6n tiedot'
b'DocType: Land Unit',b'Latitude',b'leveysaste'
b'DocType: Work Order',b'Scrap Warehouse',b'romu Varasto'
b'DocType: Work Order',b'Check if material transfer entry is not required',"b'Tarkista, onko materiaali siirto merkint\xc3\xa4\xc3\xa4 ei tarvita'"
b'DocType: Program Enrollment Tool',b'Get Students From',b'Get opiskelijaa'
b'apps/erpnext/erpnext/config/learn.py +263',b'Publish Items on Website',b'Julkaise kohteet Website'
b'apps/erpnext/erpnext/utilities/activation.py +126',b'Group your students in batches',b'Group opiskelijat eriss\xc3\xa4'
b'DocType: Authorization Rule',b'Authorization Rule',b'Valtuutus Rule'
b'DocType: POS Profile',b'Offline POS Section',b'Offline POS-osio'
b'DocType: Sales Invoice',b'Terms and Conditions Details',b'Ehdot ja s\xc3\xa4\xc3\xa4nn\xc3\xb6t lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/templates/generators/item.html +100',b'Specifications',b'Tekniset tiedot'
b'DocType: Sales Taxes and Charges Template',b'Sales Taxes and Charges Template',b'Myyntiverot ja maksupohjat'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68',b'Total (Credit)',b'Yhteens\xc3\xa4 (luotto)'
b'DocType: Repayment Schedule',b'Payment Date',b'Maksup\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Uusi Er\xc3\xa4 M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10',b'Apparel & Accessories',b'asut ja tarvikkeet'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91',b'Could not solve weighted score function. Make sure the formula is valid.',"b'Ei voitu ratkaista painotettua pisteet -toimintoa. Varmista, ett\xc3\xa4 kaava on kelvollinen.'"
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67',b'Number of Order',b'tilausten lukum\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Item Group',b'HTML / Banner that will show on the top of product list.',b'HTML / banneri joka n\xc3\xa4kyy tuoteluettelon p\xc3\xa4\xc3\xa4ll\xc3\xa4'
b'DocType: Shipping Rule',b'Specify conditions to calculate shipping amount',b'm\xc3\xa4\xc3\xa4rit\xc3\xa4 toimituskustannus arvom\xc3\xa4\xc3\xa4r\xc3\xa4laskennan ehdot'
b'DocType: Program Enrollment',"b""Institute's Bus""",b'Instituutin bussi'
b'DocType: Accounts Settings',b'Role Allowed to Set Frozen Accounts & Edit Frozen Entries',b'rooli voi j\xc3\xa4\xc3\xa4dytt\xc3\xa4\xc3\xa4- sek\xc3\xa4 muokata j\xc3\xa4\xc3\xa4dytettyj\xc3\xa4 kirjauksia'
b'DocType: Supplier Scorecard Scoring Variable',b'Path',b'polku'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28',b'Cannot convert Cost Center to ledger as it has child nodes',"b'kustannuspaikasta ei voi siirt\xc3\xa4\xc3\xa4 tilikirjaan, sill\xc3\xa4 kustannuspaikalla on alasidoksia'"
b'DocType: Production Plan',b'Total Planned Qty',b'Suunniteltu kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68',b'Opening Value',b'Opening Arvo'
b'DocType: Salary Detail',b'Formula',b'Kaava'
b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47',b'Serial #',b'Sarja #'
b'DocType: Lab Test Template',b'Lab Test Template',b'Lab Test Template'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +181',b'Sales Account',b'Myynti tili'
b'DocType: Purchase Invoice Item',b'Total Weight',b'Kokonaispaino'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94',b'Commission on Sales',b'provisio myynti'
b'DocType: Job Offer Term',b'Value / Description',b'Arvo / Kuvaus'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +630',"b'Row #{0}: Asset {1} cannot be submitted, it is already {2}'","b'Rivi # {0}: Asset {1} ei voida antaa, se on jo {2}'"
b'DocType: Tax Rule',b'Billing Country',b'Laskutusmaa'
b'DocType: Purchase Order Item',b'Expected Delivery Date',b'odotettu toimitusp\xc3\xa4iv\xc3\xa4'
b'DocType: Restaurant Order Entry',b'Restaurant Order Entry',b'Ravintola Tilaus Entry'
b'apps/erpnext/erpnext/accounts/general_ledger.py +134',b'Debit and Credit not equal for {0} #{1}. Difference is {2}.',b'debet ja kredit eiv\xc3\xa4t t\xc3\xa4sm\xc3\xa4\xc3\xa4 {0} # {1}. ero on {2}'
b'DocType: Asset Maintenance Task',b'Assign To Name',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 nimi'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98',b'Entertainment Expenses',b'Edustuskustannukset'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98',b'Make Material Request',b'Luo hankintapyynt\xc3\xb6'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20',b'Open Item {0}',b'Open Kohta {0}'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222',b'Sales Invoice {0} must be cancelled before cancelling this Sales Order',b'Myyntilasku {0} tulee peruuttaa ennen myyntitilauksen perumista'
b'DocType: Consultation',b'Age',b'ik\xc3\xa4'
b'DocType: Sales Invoice Timesheet',b'Billing Amount',b'laskutuksen arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Cash Flow Mapping',b'Select Maximum Of 1',b'Valitse maksimi 1'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84',b'Invalid quantity specified for item {0}. Quantity should be greater than 0.',b'virheellinen yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 on m\xc3\xa4\xc3\xa4ritetty tuotteelle {0} se tulee olla suurempi kuin 0'
b'DocType: Company',b'Default Employee Advance Account',b'Ty\xc3\xb6ntekij\xc3\xa4n ennakkotili'
b'apps/erpnext/erpnext/config/hr.py +60',b'Applications for leave.',b'poistumishakemukset'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +164',b'Account with existing transaction can not be deleted',b'tilin tapahtumaa ei voi poistaa'
b'DocType: Vehicle',b'Last Carbon Check',b'Viimeksi Carbon Tarkista'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102',b'Legal Expenses',b'Juridiset kustannukset'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140',b'Please select quantity on row ',b'Valitse m\xc3\xa4\xc3\xa4r\xc3\xa4 rivill\xc3\xa4'
b'apps/erpnext/erpnext/config/accounts.py +277',b'Make Opening Sales and Purchase Invoices',b'Tee myynti- ja ostolaskujen avaaminen'
b'DocType: Purchase Invoice',b'Posting Time',b'Tositeaika'
b'DocType: Timesheet',b'% Amount Billed',b'% laskutettu arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118',b'Telephone Expenses',b'Puhelinkulut'
b'DocType: Sales Partner',b'Logo',b'Logo'
b'DocType: Naming Series',b'Check this if you want to force the user to select a series before saving. There will be no default if you check this.',"b't\xc3\xa4pp\xc3\xa4\xc3\xa4 mik\xc3\xa4li haluat pakottaa k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n valitsemaan sarjan ennen tallennusta, t\xc3\xa4p\xc3\xa4st\xc3\xa4 ei synny oletusta'"
b'apps/erpnext/erpnext/stock/get_item_details.py +131',b'No Item with Serial No {0}',b'Ei Kohta Serial Ei {0}'
b'DocType: Email Digest',b'Open Notifications',b'Avaa Ilmoitukset'
b'DocType: Payment Entry',b'Difference Amount (Company Currency)',b'Ero Summa (Company valuutta)'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79',b'Direct Expenses',b'Suorat kustannukset'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60',b'New Customer Revenue',b'Uusi asiakas Liikevaihto'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119',b'Travel Expenses',b'matkakulut'
b'DocType: Maintenance Visit',b'Breakdown',b'hajoitus'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50',b'Add custom field Subscription in the doctype {0}',b'Lis\xc3\xa4\xc3\xa4 mukautettu kentt\xc3\xa4-tilaus dokktityyppiin {0}'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +820',b'Account: {0} with currency: {1} can not be selected',b'Tili: {0} kanssa valuutta: {1} ei voi valita'
b'DocType: Purchase Receipt Item',b'Sample Quantity',b'N\xc3\xa4ytteen m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Manufacturing Settings',"b'Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.'","b'P\xc3\xa4ivitys BOM maksaa automaattisesti Scheduler-ohjelman avulla, joka perustuu viimeisimp\xc3\xa4\xc3\xa4n arvostusnopeuteen / hinnastonopeuteen / raaka-aineiden viimeiseen ostohintaan.'"
b'DocType: Bank Reconciliation Detail',b'Cheque Date',b'takaus/shekki p\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +50',b'Account {0}: Parent account {1} does not belong to company: {2}',b'Tili {0}: emotili {1} ei kuulu yritykselle: {2}'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +106',b'Successfully deleted all transactions related to this company!',b'kaikki t\xc3\xa4h\xc3\xa4n yritykseen liittyv\xc3\xa4t tapahtumat on poistettu'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27',b'As on Date',b'Kuin P\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Appraisal',b'HR',b'HR'
b'DocType: Program Enrollment',b'Enrollment Date',b'ilmoittautuminen Date'
b'DocType: Healthcare Settings',b'Out Patient SMS Alerts',b'Out Patient SMS -ilmoitukset'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100',b'Probation',b'Koeaika'
b'apps/erpnext/erpnext/config/hr.py +115',b'Salary Components',b'Palkanosat'
b'DocType: Program Enrollment Tool',b'New Academic Year',b'Uusi Lukuvuosi'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811',b'Return / Credit Note',b'Tuotto / hyvityslasku'
b'DocType: Stock Settings',b'Auto insert Price List rate if missing',"b'Lis\xc3\xa4\xc3\xa4 automaattisesti hinnastoon, jos puuttuu'"
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +117',b'Total Paid Amount',b'maksettu arvom\xc3\xa4\xc3\xa4r\xc3\xa4 yhteens\xc3\xa4'
b'DocType: GST Settings',b'B2C Limit',b'B2C-raja'
b'DocType: Work Order Item',b'Transferred Qty',b'siirretty yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/config/learn.py +11',b'Navigating',b'Liikkuminen'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188',b'Planning',b'Suunnittelu'
b'DocType: Share Balance',b'Issued',b'liitetty'
b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14',b'Student Activity',b'Student Activity'
b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80',b'Supplier Id',b'toimittaja tunnus'
b'DocType: Payment Request',b'Payment Gateway Details',b'Payment Gateway Tietoja'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276',b'Quantity should be greater than 0',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 olisi oltava suurempi kuin 0'
b'DocType: Journal Entry',b'Cash Entry',b'kassakirjaus'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17',"b""Child nodes can be only created under 'Group' type nodes""",b'Child solmut voidaan ainoastaan perustettu &quot;ryhm\xc3\xa4&quot; tyyppi solmuja'
b'DocType: Leave Application',b'Half Day Date',b'Half Day Date'
b'DocType: Academic Year',b'Academic Year Name',b'Lukuvuosi Name'
b'DocType: Sales Partner',b'Contact Desc',"b'yhteystiedot, kuvailu'"
b'apps/erpnext/erpnext/config/hr.py +65',"b'Type of leaves like casual, sick etc.'","b'Vapaatyypit, kuten vapaa-aika, sairastuminen, jne.'"
b'DocType: Email Digest',b'Send regular summary reports via Email.',b'L\xc3\xa4het\xc3\xa4 yhteenvetoraportteja s\xc3\xa4\xc3\xa4nn\xc3\xb6llisesti s\xc3\xa4hk\xc3\xb6postitse'
b'DocType: Payment Entry',b'PE-',b'PE-'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282',b'Please set default account in Expense Claim Type {0}',b'Aseta oletus tilin Matkakorvauslomakkeet tyyppi {0}'
b'DocType: Assessment Result',b'Student Name',b'Opiskelijan nimi'
b'DocType: Brand',b'Item Manager',b'Nimikkeiden yll\xc3\xa4pit\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143',b'Payroll Payable',b'Payroll Maksettava'
b'DocType: Buying Settings',b'Default Supplier Type',b'oletus toimittajatyyppi'
b'DocType: Plant Analysis',b'Collection Datetime',b'Kokoelma datetime'
b'DocType: Work Order',b'Total Operating Cost',b'k\xc3\xa4ytt\xc3\xb6kustannukset yhteens\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171',b'Note: Item {0} entered multiple times',b'huom: tuote {0} kirjattu useampia kertoja'
b'apps/erpnext/erpnext/config/selling.py +41',b'All Contacts.',b'kaikki yhteystiedot'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Company Abbreviation',b'yrityksen lyhenne'
b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47',b'User {0} does not exist',b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4 {0} ei ole olemassa'
b'DocType: Payment Term',b'Day(s) after invoice date',b'P\xc3\xa4iv\xc3\xa4 (t) laskun p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4n j\xc3\xa4lkeen'
b'DocType: Payment Schedule',b'Payment Schedule',b'Maksuaikataulu'
b'DocType: Subscription',b'SUB-',b'SUB-'
b'DocType: Item Attribute Value',b'Abbreviation',b'Lyhenne'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195',b'Payment Entry already exists',b'Maksu Entry jo olemassa'
b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36',b'Not authroized since {0} exceeds limits',b'Ei authroized koska {0} ylitt\xc3\xa4\xc3\xa4 rajat'
b'apps/erpnext/erpnext/config/hr.py +110',b'Salary template master.',b'palkka mallipohja valvonta'
b'apps/erpnext/erpnext/healthcare/setup.py +241',b'Pathology',b'Patologia'
b'DocType: Restaurant Order Entry',b'Restaurant Table',b'Ravintola-taulukko'
b'DocType: Hotel Room',b'Hotel Manager',b'Hotelli manageri'
b'DocType: Leave Type',b'Max Days Leave Allowed',b'maksimi poistumisp\xc3\xa4iv\xc3\xa4t sallittu'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63',b'Set Tax Rule for shopping cart',b'Aseta Tax Rule ostoskoriin'
b'DocType: Purchase Invoice',b'Taxes and Charges Added',b'Lis\xc3\xa4tyt verot ja maksut'
,b'Sales Funnel',b'Myyntihankekantaan'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +49',b'Abbreviation is mandatory',b'Lyhenne on pakollinen'
b'DocType: Project',b'Task Progress',b'teht\xc3\xa4v\xc3\xa4 Progress'
b'apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7',b'Cart',b'kori'
,b'Qty to Transfer',b'Siirrett\xc3\xa4v\xc3\xa4 yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/config/selling.py +13',b'Quotes to Leads or Customers.',b'Noteerauksesta vihjeeksi tai asiakkaaksi'
b'DocType: Stock Settings',b'Role Allowed to edit frozen stock',b'rooli saa muokata j\xc3\xa4\xc3\xa4dytetty\xc3\xa4 varastoa'
,b'Territory Target Variance Item Group-Wise',"b'Aluetavoite vaihtelu, tuoteryhm\xc3\xa4 ty\xc3\xb6kalu'"
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143',b'All Customer Groups',b'kaikki asiakasryhm\xc3\xa4t'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114',b'Accumulated Monthly',b'kertyneet Kuukauden'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +781',b'{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.',"b'{0} on pakollinen, voi olla ettei valuutanvaihto tietuetta ei tehty {1}:st\xc3\xa4 {2}:n.'"
b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44',b'Tax Template is mandatory.',b'Vero malli on pakollinen.'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +44',b'Account {0}: Parent account {1} does not exist',b'tili {0}: emotili {1} ei ole olemassa'
b'DocType: Purchase Invoice Item',b'Price List Rate (Company Currency)',b'Hinta (yrityksen valuutassa)'
b'DocType: Products Settings',b'Products Settings',b'Tuotteet Asetukset'
,b'Item Price Stock',b'Tuote Hinta Varastossa'
b'DocType: Lab Prescription',b'Test Created',b'Testi luotiin'
b'DocType: Healthcare Settings',b'Custom Signature in Print',b'Mukautettu allekirjoitus tulostuksessa'
b'DocType: Account',b'Temporary',b'V\xc3\xa4liaikainen'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +107',b'Customer LPO No.',b'Asiakas LPO nro'
b'DocType: Program',b'Courses',b'Kurssit'
b'DocType: Monthly Distribution Percentage',b'Percentage Allocation',b'Prosenttiosuus'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128',b'Secretary',b'Sihteeri'
b'DocType: Global Defaults',"b""If disable, 'In Words' field will not be visible in any transaction""","b'Jos poistaa k\xc3\xa4yt\xc3\xb6st\xc3\xa4, &quot;In Sanat&quot; kent\xc3\xa4ss\xc3\xa4 ei n\xc3\xa4y miss\xc3\xa4\xc3\xa4n kauppa'"
b'DocType: Serial No',b'Distinct unit of an Item',b'tuotteen erillisyksikk\xc3\xb6'
b'DocType: Supplier Scorecard Criteria',b'Criteria Name',b'Kriteerien nimi'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295',b'Please set Company',b'Aseta Company'
b'DocType: Pricing Rule',b'Buying',b'Osto'
b'apps/erpnext/erpnext/config/agriculture.py +24',b'Diseases & Fertilizers',b'Taudit ja lannoitteet'
b'DocType: HR Settings',b'Employee Records to be created by',b'ty\xc3\xb6ntekij\xc3\xa4 tietue on teht\xc3\xa4v\xc3\xa4'
b'DocType: Patient',b'AB Negative',b'AB negatiivinen'
b'DocType: Sample Collection',b'SMPL-',b'SMPL-'
b'DocType: POS Profile',b'Apply Discount On',b'Levit\xc3\xa4 alennus'
b'DocType: Member',b'Membership Type',b'J\xc3\xa4senyystyyppi'
,b'Reqd By Date',b'Reqd P\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140',b'Creditors',b'luotonantajat'
b'DocType: Assessment Plan',b'Assessment Name',b'arviointi Name'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94',b'Show PDC in Print',b'N\xc3\xa4yt\xc3\xa4 PDC Printissa'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97',b'Row # {0}: Serial No is mandatory',b'Rivi # {0}: Sarjanumero on pakollinen'
b'DocType: Purchase Taxes and Charges',b'Item Wise Tax Detail',"b'tuote ty\xc3\xb6kalu, verotiedot'"
b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13',b'Job Offer',b'Ty\xc3\xb6tarjous'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Institute Abbreviation',b'Institute lyhenne'
,b'Item-wise Price List Rate',b'Tuotekohtainen hinta hinnastossa'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082',b'Supplier Quotation',b'Toimituskykytiedustelu'
b'DocType: Quotation',b'In Words will be visible once you save the Quotation.',"b'sanat n\xc3\xa4kyv\xc3\xa4t, kun tallennat tarjouksen'"
b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 ({0}) ei voi olla osa rivill\xc3\xa4 {1}'
b'DocType: Consultation',b'C-',b'C-'
b'DocType: Attendance',b'ATT-',b'ATT-'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +492',b'Barcode {0} already used in Item {1}',b'Viivakoodi {0} on jo k\xc3\xa4yt\xc3\xb6ss\xc3\xa4 tuotteella {1}'
b'apps/erpnext/erpnext/config/selling.py +86',b'Rules for adding shipping costs.',b'toimituskustannusten lis\xc3\xa4ys s\xc3\xa4\xc3\xa4nn\xc3\xb6t'
b'DocType: Hotel Room',b'Extra Bed Capacity',b'Lis\xc3\xa4vuoteen kapasiteetti'
b'DocType: Item',b'Opening Stock',b'Aloitusvarasto'
b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20',b'Customer is required',b'Asiakas on pakollinen'
b'DocType: Lab Test',b'Result Date',b'Tulosp\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77',b'PDC/LC Date',b'PDC / LC Date'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20',b'{0} is mandatory for Return',b'{0} on pakollinen palautukseen'
b'DocType: Purchase Order',b'To Receive',b'Saavuta'
b'apps/erpnext/erpnext/utilities/user_progress.py +252',b'user@example.com',b'user@example.com'
b'DocType: Asset',b'Asset Owner',b'Omaisuuden omistaja'
b'DocType: Employee',b'Personal Email',b'Henkil\xc3\xb6kohtainen s\xc3\xa4hk\xc3\xb6posti'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57',b'Total Variance',b'vaihtelu yhteens\xc3\xa4'
b'DocType: Accounts Settings',"b'If enabled, the system will post accounting entries for inventory automatically.'","b'Mik\xc3\xa4li k\xc3\xa4yt\xc3\xb6ss\xc3\xa4, j\xc3\xa4rjestelm\xc3\xa4 tekee varastokirjanpidon tilikirjaukset automaattisesti.'"
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15',b'Brokerage',b'v\xc3\xa4lityspalkkio'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195',b'Attendance for employee {0} is already marked for this day',b'L\xc3\xa4sn\xc3\xa4olo ty\xc3\xb6ntekij\xc3\xb6iden {0} on jo merkitty t\xc3\xa4t\xc3\xa4 p\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'DocType: Work Order Operation',"b""in Minutes\nUpdated via 'Time Log'""","b'""aikaloki"" p\xc3\xa4ivitys minuuteissa'"
b'DocType: Customer',b'From Lead',b'Liidist\xc3\xa4'
b'apps/erpnext/erpnext/config/manufacturing.py +13',b'Orders released for production.',b'tuotantoon luovutetut tilaukset'
b'apps/erpnext/erpnext/public/js/account_tree_grid.js +65',b'Select Fiscal Year...',b'Valitse tilikausi ...'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567',b'POS Profile required to make POS Entry',b'POS profiili vaatii POS kirjauksen'
b'DocType: Program Enrollment Tool',b'Enroll Students',b'Ilmoittaudu Opiskelijat'
b'DocType: Lab Test',b'Approved Date',b'Hyv\xc3\xa4ksytty p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21',b'Standard Selling',b'perusmyynti'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165',b'Atleast one warehouse is mandatory',b'Ainakin yksi varasto on pakollinen'
b'DocType: Serial No',b'Out of Warranty',b'Out of Takuu'
b'DocType: BOM Update Tool',b'Replace',b'Vaihda'
b'apps/erpnext/erpnext/templates/includes/product_list.js +42',b'No products found.',b'Ei l\xc3\xb6ytynyt tuotteita.'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360',b'{0} against Sales Invoice {1}',b'{0} myyntilaskua vastaan {1}'
b'DocType: Antibiotic',b'Laboratory User',b'Laboratoriok\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'DocType: Sales Invoice',b'SINV-',b'SINV-'
b'DocType: Request for Quotation Item',b'Project Name',b'Projektin nimi'
b'DocType: Customer',b'Mention if non-standard receivable account',b'Mainitse jos ei-standardi velalliset'
b'DocType: Journal Entry Account',b'If Income or Expense',b'Mik\xc3\xa4li tulot tai kustannukset'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288',b'Select interest income account in employee loan {0}',b'Valitse korkotulotili ty\xc3\xb6ntekij\xc3\xa4lainaan {0}'
b'DocType: Work Order',b'Required Items',b'Tarvittavat kohteet'
b'DocType: Stock Ledger Entry',b'Stock Value Difference',"b'varastoarvo, ero'"
b'apps/erpnext/erpnext/config/learn.py +229',b'Human Resource',b'henkil\xc3\xb6st\xc3\xb6resurssi'
b'DocType: Payment Reconciliation Payment',b'Payment Reconciliation Payment',b'Maksun t\xc3\xa4sm\xc3\xa4ytys toiseen maksuun'
b'DocType: Disease',b'Treatment Task',b'Hoitoty\xc3\xb6'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38',b'Tax Assets',"b'Vero, vastaavat'"
b'DocType: BOM Item',b'BOM No',b'BOM nro'
b'DocType: Instructor',b'INS/',b'INS /'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160',b'Journal Entry {0} does not have account {1} or already matched against other voucher',b'p\xc3\xa4iv\xc3\xa4kirjakirjauksella {0} ei ole tili\xc3\xa4 {1} tai on t\xc3\xa4sm\xc3\xa4tty toiseen tositteeseen'
b'DocType: Item',b'Moving Average',b'Liukuva keskiarvo'
b'DocType: BOM Update Tool',b'The BOM which will be replaced',b'Korvattava osaluettelo'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46',b'Electronic Equipments',b'S\xc3\xa4hk\xc3\xb6inen Kalusto'
b'DocType: Asset',b'Maintenance Required',b'Huoltoa tarvitaan'
b'DocType: Account',b'Debit',b'debet'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49',b'Leaves must be allocated in multiples of 0.5',b'Vapaat tulee kohdentaa luvun 0.5 kerrannaisina'
b'DocType: Work Order',b'Operation Cost',b'toiminnan kustannus'
b'apps/erpnext/erpnext/config/hr.py +29',b'Upload attendance from a .csv file',b'Lataa osallistumislomake .csv-tiedostoon'
b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45',b'Outstanding Amt',"b'odottaa, pankkip\xc3\xa4\xc3\xa4te'"
b'DocType: Sales Person',b'Set targets Item Group-wise for this Sales Person.',"b'Tuoteryhm\xc3\xa4 ty\xc3\xb6kalu, aseta tavoitteet t\xc3\xa4lle myyj\xc3\xa4lle'"
b'DocType: Stock Settings',b'Freeze Stocks Older Than [Days]',b'j\xc3\xa4\xc3\xa4dyt\xc3\xa4 yli [p\xc3\xa4iv\xc3\xa4\xc3\xa4] vanhat varastot'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +600',b'Row #{0}: Asset is mandatory for fixed asset purchase/sale',b'Rivi # {0}: Asset on pakollinen k\xc3\xa4ytt\xc3\xb6omaisuushankintoihin osto / myynti'
b'DocType: Asset Maintenance Team',b'Maintenance Team Name',b'Huoltotiimin nimi'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42',"b'If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.'","b'yll\xc3\xa4mainituilla ehdoilla l\xc3\xb6ytyy kaksi tai useampia hinnoittelus\xc3\xa4\xc3\xa4nt\xc3\xb6j\xc3\xa4 ja prioriteettia tarvitaan, prioriteettinumero luku 0-20:n v\xc3\xa4lill\xc3\xa4, oletusarvona se on nolla (tyhj\xc3\xa4), mit\xc3\xa4 korkeampi luku sit\xc3\xa4 suurempi prioriteetti'"
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197',"b""Customer is mandatory if 'Opportunity From' is selected as Customer""","b'Asiakas on pakollinen, jos Asiakas valitsee tilaisuuden'"
b'apps/erpnext/erpnext/controllers/trends.py +36',b'Fiscal Year: {0} does not exists',b'Tilikautta: {0} ei ole olemassa'
b'DocType: Currency Exchange',b'To Currency',b'Valuuttakursseihin'
b'DocType: Leave Block List',b'Allow the following users to approve Leave Applications for block days.',b'salli seuraavien k\xc3\xa4ytt\xc3\xa4jien hyv\xc3\xa4ksy\xc3\xa4 poistumissovelluksen estop\xc3\xa4iv\xc3\xa4t'
b'apps/erpnext/erpnext/config/hr.py +137',b'Types of Expense Claim.',b'Kulukorvauksen tyypit'
b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'Myynnin hinnan kohteen {0} on pienempi kuin sen {1}. Myynnin m\xc3\xa4\xc3\xa4r\xc3\xa4 tulisi olla v\xc3\xa4hint\xc3\xa4\xc3\xa4n {2}'
b'DocType: Item',b'Taxes',b'Verot'
b'DocType: Purchase Invoice',b'capital goods',b'tuotantohy\xc3\xb6dykkeet'
b'DocType: Purchase Invoice Item',b'Weight Per Unit',b'Paino per yksikk\xc3\xb6'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344',b'Paid and Not Delivered',b'Maksettu ja ei toimitettu'
b'DocType: Project',b'Default Cost Center',b'Oletus kustannuspaikka'
b'DocType: Bank Guarantee',b'End Date',b'p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/config/stock.py +7',b'Stock Transactions',b'Varastotapahtumat'
b'DocType: Budget',b'Budget Accounts',b'talousarviokirjanpito'
b'DocType: Employee',b'Internal Work History',b'sis\xc3\xa4inen ty\xc3\xb6historia'
b'DocType: Depreciation Schedule',b'Accumulated Depreciation Amount',b'Kertyneiden poistojen summa'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42',b'Private Equity',b'Private Equity'
b'DocType: Supplier Scorecard Variable',b'Supplier Scorecard Variable',b'Toimittajan tuloskortin muuttuja'
b'DocType: Employee Loan',b'Fully Disbursed',b'maksettu t\xc3\xa4ysin'
b'DocType: Employee Advance',b'Due Advance Amount',b'Ennakkomaksu'
b'DocType: Maintenance Visit',b'Customer Feedback',b'asiakaspalaute'
b'DocType: Account',b'Expense',b'Kustannus'
b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54',b'Score cannot be greater than Maximum Score',b'Pisteet ei voi olla suurempi kuin maksimipisteet'
b'apps/erpnext/erpnext/utilities/user_progress.py +129',b'Customers and Suppliers',b'Asiakkaat ja toimittajat'
b'DocType: Item Attribute',b'From Range',b'Alkaen Range'
b'DocType: BOM',b'Set rate of sub-assembly item based on BOM',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 alikokoonpanon m\xc3\xa4\xc3\xa4r\xc3\xa4 osumakohtaisesti'
b'DocType: Hotel Room Reservation',b'Invoiced',b'laskutettu'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98',b'Syntax error in formula or condition: {0}',b'Syntaksivirhe kaavassa tai tila: {0}'
b'DocType: Daily Work Summary Settings Company',b'Daily Work Summary Settings Company',b'P\xc3\xa4ivitt\xc3\xa4inen ty\xc3\xb6 Yhteenveto Asetukset Company'
b'apps/erpnext/erpnext/stock/utils.py +125',b'Item {0} ignored since it is not a stock item',b'Nimike {0} ohitetaan sill\xc3\xa4 se ei ole varastotuote'
b'DocType: Appraisal',b'APRSL',b'APRSL'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23',"b'To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.'",b'Kaikki sovellettavat hinnoittelus\xc3\xa4\xc3\xa4nn\xc3\xb6t tulee poistaa k\xc3\xa4yt\xc3\xb6st\xc3\xa4 ettei hinnoittelus\xc3\xa4\xc3\xa4nt\xc3\xb6j\xc3\xa4 k\xc3\xa4ytet\xc3\xa4 t\xc3\xa4h\xc3\xa4n tapahtumaan'
b'DocType: Payment Term',b'Day(s) after the end of the invoice month',b'P\xc3\xa4iv\xc3\xa4 (\xc3\xa4) laskutuskuukauden p\xc3\xa4\xc3\xa4ttymisen j\xc3\xa4lkeen'
b'DocType: Assessment Group',b'Parent Assessment Group',b'Parent Assessment Group'
b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27',b'Jobs',b'Ty\xc3\xb6paikat'
,b'Sales Order Trends',b'Myyntitilausten kehitys'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51',"b""The 'From Package No.' field must neither be empty nor it's value less than 1.""",b'&quot;Paketin nro&quot; kentt\xc3\xa4 ei saa olla tyhj\xc3\xa4 eik\xc3\xa4 sen arvo pienempi kuin 1.'
b'DocType: Employee',b'Held On',b'j\xc3\xa4rjesteltiin'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36',b'Production Item',b'Tuotanto tuote'
,b'Employee Information',b'Ty\xc3\xb6ntekij\xc3\xb6iden tiedot'
b'DocType: Stock Entry Detail',b'Additional Cost',b'Muita Kustannukset'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48',"b'Can not filter based on Voucher No, if grouped by Voucher'",b'ei voi suodattaa tositenumero pohjalta mik\xc3\xa4li tosite on ryhm\xc3\xa4ss\xc3\xa4'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918',b'Make Supplier Quotation',b'Tee toimituskykytiedustelu'
b'DocType: Quality Inspection',b'Incoming',b'saapuva'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +70',b'Default tax templates for sales and purchase are created.',b'Myynnin ja ostoksen oletusmaksumalleja luodaan.'
b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57',b'Assessment Result record {0} already exists.',b'Arviointi Tulosrekisteri {0} on jo olemassa.'
b'DocType: BOM',b'Materials Required (Exploded)',b'Materiaalitarve (avattu)'
b'apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60',"b""Please set Company filter blank if Group By is 'Company'""",b'Aseta Yritysfiltteri tyhj\xc3\xa4ksi jos Ryhmittelyperuste on &#39;yritys&#39;'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66',b'Posting Date cannot be future date',b'Kirjoittamisen p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla tulevaisuudessa'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102',b'Row # {0}: Serial No {1} does not match with {2} {3}',b'Rivi # {0}: Sarjanumero {1} ei vastaa {2} {3}'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'for generating the recurring',b'toistuvan'
b'DocType: Stock Entry',b'Target Warehouse Address',b'Kohdevaraston osoite'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86',b'Casual Leave',b'tavallinen poistuminen'
b'DocType: Agriculture Task',b'End Day',b'Lopeta p\xc3\xa4iv\xc3\xa4'
b'DocType: Batch',b'Batch ID',b'Er\xc3\xa4n tunnus'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380',b'Note: {0}',b'Huomautus: {0}'
,b'Delivery Note Trends',b'L\xc3\xa4hetysten kehitys'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112',"b""This Week's Summary""",b'Viikon yhteenveto'
b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22',b'In Stock Qty',b'Varastossa M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Delivery Trip',b'Calculate Estimated Arrival Times',b'Laske arvioitu saapumisaikasi'
b'apps/erpnext/erpnext/accounts/general_ledger.py +113',b'Account: {0} can only be updated via Stock Transactions',b'Tili\xc3\xa4 {0} voi p\xc3\xa4ivitt\xc3\xa4\xc3\xa4 vain varastotapahtumien kautta'
b'DocType: Student Group Creation Tool',b'Get Courses',b'Get Kurssit'
b'DocType: GL Entry',b'Party',b'Osapuoli'
b'DocType: Healthcare Settings',b'Patient Name',b'Potilaan nimi'
b'DocType: Variant Field',b'Variant Field',b'Varianttikentt\xc3\xa4'
b'DocType: Sales Order',b'Delivery Date',b'toimitusp\xc3\xa4iv\xc3\xa4'
b'DocType: Opportunity',b'Opportunity Date',b'mahdollisuuden p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Employee',b'Health Insurance Provider',b'Sairausvakuutuksen tarjoaja'
b'DocType: Purchase Receipt',b'Return Against Purchase Receipt',b'Palautus kohdistettuna saapumiseen'
b'DocType: Water Analysis',b'Person Responsible',b'Vastuuhenkil\xc3\xb6'
b'DocType: Request for Quotation Item',b'Request for Quotation Item',b'tarjouspyynn\xc3\xb6n tuote'
b'DocType: Purchase Order',b'To Bill',b'Laskuta'
b'DocType: Material Request',b'% Ordered',b'% j\xc3\xa4rjestetty'
b'DocType: Education Settings',"b'For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.'",b'Kurssille pohjainen opiskelija Groupin Kurssi validoitu jokaiselle oppilaalle p\xc3\xa4\xc3\xa4ss\xc3\xa4 kirjoilla Kurssit Program Ilmoittautuminen.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103',b'Piecework',b'Urakkaty\xc3\xb6'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70',b'Avg. Buying Rate',b'Oston keskihinta'
b'DocType: Share Balance',b'From No',b'Nro'
b'DocType: Task',b'Actual Time (in Hours)',b'todellinen aika (tunneissa)'
b'DocType: Employee',b'History In Company',b'yrityksen historia'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270',b'New Message from {sender}',b'Uusi viesti {l\xc3\xa4hett\xc3\xa4j\xc3\xa4lt\xc3\xa4}'
b'DocType: Customer',b'Customer Primary Address',b'Asiakas ensisijainen osoite'
b'apps/erpnext/erpnext/config/learn.py +107',b'Newsletters',b'Uutiskirjeet'
b'DocType: Drug Prescription',b'Description/Strength',b'Kuvaus / vahvuus'
b'DocType: Share Balance',b'Is Company',b'Onko yritys'
b'DocType: Stock Ledger Entry',b'Stock Ledger Entry',b'Varastokirjanpidon tilikirjaus'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83',b'Same item has been entered multiple times',b'Sama viesti on tullut useita kertoja'
b'DocType: Department',b'Leave Block List',b'Estoluettelo'
b'DocType: Purchase Invoice',b'Tax ID',b'Tax ID'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192',b'Item {0} is not setup for Serial Nos. Column must be blank',"b'tuotteella {0} ei ole m\xc3\xa4\xc3\xa4ritetty\xc3\xa4 sarjanumeroa, sarake on tyhj\xc3\xa4'"
b'DocType: Accounts Settings',b'Accounts Settings',b'tilien asetukset'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11',b'Approve',b'Hyv\xc3\xa4ksy\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69',"b'Malformatted address for {0}, please fix to continue.'","b'Virheellinen muoto {0}, korjaa se jatkaaksesi.'"
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28',"b'Number of new Account, it will be included in the account name as a prefix'","b'Uuden tilin numero, se sis\xc3\xa4llytet\xc3\xa4\xc3\xa4n tilin nimen etuliitteen\xc3\xa4'"
b'DocType: Maintenance Team Member',b'Team Member',b'Tiimin j\xc3\xa4sen'
b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151',b'No Result to submit',b'Ei tulosta'
b'DocType: Customer',b'Sales Partner and Commission',b'Myynti Partner ja komission'
b'DocType: Employee Loan',b'Rate of Interest (%) / Year',b'Korkokanta (%) / vuosi'
,b'Project Quantity',b'Project M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79',"b""Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'""","b'Yhteens\xc3\xa4 {0} kaikki kohteet on nolla, voi olla sinun pit\xc3\xa4isi muuttaa &quot;v\xc3\xa4lit perustuvat maksujen &#39;'"
b'DocType: Opportunity',b'To Discuss',b'Keskusteluun'
b'apps/erpnext/erpnext/stock/stock_ledger.py +377',b'{0} units of {1} needed in {2} to complete this transaction.',b'{0} yksikk\xc3\xb6\xc3\xa4 {1} tarvitaan {2} tapahtuman suorittamiseen.'
b'DocType: Loan Type',b'Rate of Interest (%) Yearly',b'Korkokanta (%) Vuotuinen'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71',b'Temporary Accounts',b'V\xc3\xa4liaikaiset tilit'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207',b'Black',b'musta'
b'DocType: BOM Explosion Item',b'BOM Explosion Item',b'BOM-tuotesis\xc3\xa4lt\xc3\xb6'
b'DocType: Shareholder',b'Contact List',b'Yhteystietoluettelo'
b'DocType: Account',b'Auditor',b'Tilintarkastaja'
b'DocType: Project',b'Frequency To Collect Progress',b'Taajuus ker\xc3\xa4t\xc3\xa4 edistymist\xc3\xa4'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132',b'{0} items produced',b'{0} nimikett\xc3\xa4 valmistettu'
b'apps/erpnext/erpnext/utilities/user_progress.py +58',b'Learn More',b'Lis\xc3\xa4tietoja'
b'DocType: Cheque Print Template',b'Distance from top edge',b'Et\xc3\xa4isyys yl\xc3\xa4reunasta'
b'apps/erpnext/erpnext/stock/get_item_details.py +367',b'Price List {0} is disabled or does not exist',b'Hinnasto {0} on poistettu k\xc3\xa4yt\xc3\xb6st\xc3\xa4 tai sit\xc3\xa4 ei ole'
b'DocType: Purchase Invoice',b'Return',b'paluu'
b'DocType: Pricing Rule',b'Disable',b'poista k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180',b'Mode of payment is required to make a payment',b'Tila maksu on suoritettava maksu'
b'DocType: Project Task',b'Pending Review',b'Odottaa n\xc3\xa4kym\xc3\xa4'
b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14',"b'Edit in full page for more options like assets, serial nos, batches etc.'","b'Muokkaa koko sivulta lis\xc3\xa4\xc3\xa4 vaihtoehtoja, kuten varat, sarjanumerot, er\xc3\xa4t jne.'"
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10',b'Appointments and Consultations',b'Nimitykset ja neuvottelut'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41',b'{0} - {1} is not enrolled in the Batch {2}',b'{0} - {1} ei ilmoittautunut Er\xc3\xa4 {2}'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113',"b'Asset {0} cannot be scrapped, as it is already {1}'","b'Asset {0} ei voida romuttaa, koska se on jo {1}'"
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77',b'Cheques Required',b'Tarkastukset ovat pakollisia'
b'DocType: Task',b'Total Expense Claim (via Expense Claim)',b'Kulukorvaus yhteens\xc3\xa4 (kulukorvauksesta)'
b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177',b'Mark Absent',b'Mark Absent'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40',b'Failed to setup company',b'Yrityksen perustamiseen ep\xc3\xa4onnistui'
b'DocType: Asset Repair',b'Asset Repair',b'Omaisuuden korjaus'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143',b'Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}',b'Rivi {0}: valuutta BOM # {1} pit\xc3\xa4isi olla yht\xc3\xa4 suuri kuin valittu valuutta {2}'
b'DocType: Journal Entry Account',b'Exchange Rate',b'Valuuttakurssi'
b'DocType: Patient',b'Additional information regarding the patient',b'Lis\xc3\xa4tietoja potilaasta'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585',b'Sales Order {0} is not submitted',b'Myyntitilaus {0} ei ole vahvistettu'
b'DocType: Homepage',b'Tag Line',b'Tagirivi'
b'DocType: Fee Component',b'Fee Component',b'Fee Component'
b'apps/erpnext/erpnext/config/hr.py +204',b'Fleet Management',b'Kaluston hallinta'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080',b'Add items from',b'Lis\xc3\xa4\xc3\xa4 kohteita'
b'apps/erpnext/erpnext/config/agriculture.py +7',b'Crops & Lands',b'Kasvit ja maisemat'
b'DocType: Cheque Print Template',b'Regular',b's\xc3\xa4\xc3\xa4nn\xc3\xb6llinen'
b'DocType: Fertilizer',b'Density (if liquid)',b'Tiheys (jos nestem\xc3\xa4inen)'
b'apps/erpnext/erpnext/education/doctype/course/course.py +20',b'Total Weightage of all Assessment Criteria must be 100%',b'Yhteens\xc3\xa4 weightage Kaikkien Arviointikriteerit on oltava 100%'
b'DocType: Purchase Order Item',b'Last Purchase Rate',b'Viimeisin ostohinta'
b'DocType: Account',b'Asset',b'vastaavat'
b'DocType: Project Task',b'Task ID',b'Teht\xc3\xa4v\xc3\xa4tunnus'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84',b'Stock cannot exist for Item {0} since has variants',b't\xc3\xa4lle tuotteelle ei ole varastopaikkaa {0} koska siit\xc3\xa4 on useita malleja'
b'DocType: Lab Test',b'Mobile',b'mobile'
,b'Sales Person-wise Transaction Summary',"b'Myyj\xc3\xa4n ty\xc3\xb6kalu,  tapahtuma yhteenveto'"
b'DocType: Training Event',b'Contact Number',b'Yhteysnumero'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73',b'Warehouse {0} does not exist',b'Varastoa {0} ei ole olemassa'
b'DocType: Monthly Distribution',b'Monthly Distribution Percentages',"b'toimitus kuukaudessa, prosenttiosuudet'"
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +110',b'The selected item cannot have Batch',b'Valittu tuote ei voi olla er\xc3\xa4'
b'DocType: Delivery Note',b'% of materials delivered against this Delivery Note',b'% l\xc3\xa4hetteen materiaaleista toimitettu'
b'DocType: Asset Maintenance Log',b'Has Certificate',b'Onko sertifikaatti'
b'DocType: Project',b'Customer Details',"b'asiakas, lis\xc3\xa4tiedot'"
b'DocType: Asset',b'Check if Asset requires Preventive Maintenance or Calibration',"b'Tarkista, onko Asset vaatii ehk\xc3\xa4isev\xc3\xa4\xc3\xa4 yll\xc3\xa4pitoa tai kalibrointia'"
b'apps/erpnext/erpnext/public/js/setup_wizard.js +87',b'Company Abbreviation cannot have more than 5 characters',b'Yrityksen lyhennelm\xc3\xa4 voi olla enint\xc3\xa4\xc3\xa4n 5 merkki\xc3\xa4'
b'DocType: Employee',b'Reports to',b'raportoi'
,b'Unpaid Expense Claim',b'Palkaton Matkakorvauslomakkeet'
b'DocType: Payment Entry',b'Paid Amount',b'Maksettu arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/utilities/user_progress.py +158',b'Explore Sales Cycle',b'Tutustu myyntitykliin'
b'DocType: Assessment Plan',b'Supervisor',b'Valvoja'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869',b'Retention Stock Entry',b'Retention Stock Entry'
,b'Available Stock for Packing Items',b'Pakattavien nimikkeiden saatavuus'
b'DocType: Item Variant',b'Item Variant',b'tuotemalli'
,b'Work Order Stock Report',b'Ty\xc3\xb6j\xc3\xa4rjestyksen raportti'
b'DocType: Assessment Result Tool',b'Assessment Result Tool',b'Assessment Tulos Tool'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24',b'As Supervisor',b'Ohjaajana'
b'DocType: BOM Scrap Item',b'BOM Scrap Item',b'BOM romu Kohta'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +895',b'Submitted orders can not be deleted',b'Vahvistettuja tilauksia ei voi poistaa'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +114',"b""Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'""","b""Tilin tase on jo dedet, sy\xc3\xb6tetyn arvon tulee olla 'tasapainossa' eli 'krebit'"""
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118',b'Quality Management',b'M\xc3\xa4\xc3\xa4r\xc3\xa4hallinta'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +41',b'Item {0} has been disabled',b'Kohta {0} on poistettu k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'DocType: Project',b'Total Billable Amount (via Timesheets)',b'Laskutettava summa yhteens\xc3\xa4 (kautta aikajaksoja)'
b'DocType: Agriculture Task',b'Previous Business Day',b'Edellinen ty\xc3\xb6p\xc3\xa4iv\xc3\xa4'
b'DocType: Employee Loan',b'Repay Fixed Amount per Period',b'Repay kiinte\xc3\xa4 m\xc3\xa4\xc3\xa4r\xc3\xa4 Period'
b'DocType: Employee',b'Health Insurance No',b'Sairausvakuutus nro'
b'apps/erpnext/erpnext/buying/utils.py +47',b'Please enter quantity for Item {0}',b'Kirjoita kpl m\xc3\xa4\xc3\xa4r\xc3\xa4 tuotteelle {0}'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Credit Note Amt',b'Hyvityslaskun Amt'
b'DocType: Employee External Work History',b'Employee External Work History',b'ty\xc3\xb6ntekij\xc3\xa4n muu ty\xc3\xb6kokemus'
b'DocType: Opening Invoice Creation Tool',b'Purchase',b'Osto'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Balance Qty',b'taseyksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20',b'Goals cannot be empty',b'Tavoitteet voi olla tyhj\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15',b'Enrolling students',b'Ilmoittautuminen opiskelijoille'
b'DocType: Item Group',b'Parent Item Group',b'P\xc3\xa4\xc3\xa4tuoteryhm\xc3\xa4'
b'DocType: Appointment Type',b'Appointment Type',b'Nimitystyyppi'
b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21',b'{0} for {1}',b'{0} on {1}'
b'DocType: Healthcare Settings',b'Valid number of days',b'Voimassa oleva p\xc3\xa4ivien m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +39',b'Cost Centers',b'kustannuspaikat'
b'DocType: Land Unit',b'Linked Plant Analysis',b'Linkitetty kasvien analyysi'
b'DocType: Purchase Receipt',"b""Rate at which supplier's currency is converted to company's base currency""","b'taso, jolla toimittajan valuutta muunnetaan yrityksen k\xc3\xa4ytt\xc3\xa4m\xc3\xa4ksi perusvaluutaksi'"
b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36',b'Row #{0}: Timings conflicts with row {1}',b'Rivi # {0}: ajoitukset ristiriidassa rivin {1}'
b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Salli nollahinta'
b'DocType: Training Event Employee',b'Invited',b'Kutsuttu'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178',b'Multiple active Salary Structures found for employee {0} for the given dates',b'Useita aktiivisia Palkka Structures l\xc3\xb6ytynyt ty\xc3\xb6ntekij\xc3\xa4 {0} varten kyseisen\xc3\xa4 p\xc3\xa4iv\xc3\xa4n\xc3\xa4'
b'apps/erpnext/erpnext/config/accounts.py +308',b'Setup Gateway accounts.',b'Setup Gateway tilej\xc3\xa4.'
b'DocType: Employee',b'Employment Type',b'Ty\xc3\xb6sopimustyypit'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42',b'Fixed Assets',b'Kiinte\xc3\xa4t varat'
b'DocType: Payment Entry',b'Set Exchange Gain / Loss',b'Aseta Exchange voitto / tappio'
,b'GST Purchase Register',b'GST Osto Register'
,b'Cash Flow',b'Kassavirta'
b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25',b'Combined invoice portion must equal 100%',b'Yhdistetyn laskutusosan on oltava 100%'
b'DocType: Item Group',b'Default Expense Account',b'Oletus kustannustili'
b'DocType: GST Account',b'CGST Account',b'CGST-tili'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53',b'Student Email ID',b'Opiskelijan S\xc3\xa4hk\xc3\xb6posti ID'
b'DocType: Employee',b'Notice (days)',b'Ilmoitus (p\xc3\xa4iv\xc3\xa4\xc3\xa4)'
b'DocType: Tax Rule',b'Sales Tax Template',b'Sales Tax Malline'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2510',b'Select items to save the invoice',b'Valitse kohteita tallentaa laskun'
b'DocType: Employee',b'Encashment Date',b'perint\xc3\xa4 p\xc3\xa4iv\xc3\xa4'
b'DocType: Training Event',b'Internet',b'Internet'
b'DocType: Special Test Template',b'Special Test Template',b'Erityinen testausmalli'
b'DocType: Account',b'Stock Adjustment',b'Varastons\xc3\xa4\xc3\xa4t\xc3\xb6'
b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34',b'Default Activity Cost exists for Activity Type - {0}',b'oletus aktiviteettikustannus aktiviteetin tyypille - {0}'
b'DocType: Work Order',b'Planned Operating Cost',b'Suunnitellut k\xc3\xa4ytt\xc3\xb6kustannukset'
b'DocType: Academic Term',b'Term Start Date',b'Term aloitusp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/config/accounts.py +471',b'List of all share transactions',b'Luettelo kaikista osakekaupoista'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'OPP Count'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244',b'Please find attached {0} #{1}',b'Ohessa {0} # {1}'
b'apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52',b'Average Rate',b'Keskim\xc3\xa4\xc3\xa4r\xc3\xa4inen hinta'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +728',b'Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total',b'Maksun kokonaissumman summan on vastattava suurta / py\xc3\xb6ristetty\xc3\xa4 summaa'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34',b'Bank Statement balance as per General Ledger',b'Tiliote tasapaino kohti P\xc3\xa4\xc3\xa4kirja'
b'DocType: Job Applicant',b'Applicant Name',b'hakijan nimi'
b'DocType: Authorization Rule',b'Customer / Item Name',b'Asiakas / Nimikkeen nimi'
b'DocType: Buying Settings',"b'If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt'","b'Jos t\xc3\xa4m\xc3\xa4 asetus on otettu k\xc3\xa4ytt\xc3\xb6\xc3\xb6n, viimeisi\xc3\xa4 ostotiedot eiv\xc3\xa4t noudu edellisest\xc3\xa4 ostotilauksesta tai ostokuitista'"
b'DocType: Product Bundle',"b'Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials'","b'Koosta useita nimikkeit\xc3\xa4 tuotepaketiksi. \nKoostaminen on k\xc3\xa4tev\xc3\xa4 tapa ryhmitell\xc3\xa4 tietyt nimikkeet paketiksi ja se mahdollistaa paketissa olevien nimikkeiden varastosaldon seurannan tuotepaketti -nimikkeen sijaan.\n\nTuotepaketti -nimike ""ei ole varastonimike"" mutta ""on myyntinimike"".\n\nEsimerkki: \nMyyt\xc3\xa4ess\xc3\xa4 kannettavia tietokoneita sek\xc3\xa4 niihin sopivia laukkuja, asiakkaalle annetaan alennus mik\xc3\xa4li h\xc3\xa4n ostaa molemmat. T\xc3\xa4ten ""tietokone + laukku"" muodostavat uuden tuotepaketin.'"
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42',b'Serial No is mandatory for Item {0}',b'Sarjanumero vaaditaan tuotteelle {0}'
b'DocType: Item Variant Attribute',b'Attribute',b'tuntomerkki'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43',b'Please specify from/to range',b'Ilmoitathan mist\xc3\xa4 / vaihtelevan'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28',b'Opening {0} Invoice created',b'Laskun {0} avaaminen luotu'
b'DocType: Serial No',b'Under AMC',b'Yll\xc3\xa4pito voimassa'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55',b'Item valuation rate is recalculated considering landed cost voucher amount',b'tuotteen arvon taso on p\xc3\xa4ivitetty kohdistettujen tositteiden arvom\xc3\xa4\xc3\xa4r\xc3\xa4 kustannuksen mukaan'
b'apps/erpnext/erpnext/config/selling.py +153',b'Default settings for selling transactions.',b'Myynnin oletusasetukset.'
b'DocType: Guardian',b'Guardian Of ',b'Guardian Of'
b'DocType: Grading Scale Interval',b'Threshold',b'kynnys'
b'DocType: BOM Update Tool',b'Current BOM',b'nykyinen BOM'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32',b'Balance (Dr - Cr)',b'Saldo (Dr - Cr)'
b'apps/erpnext/erpnext/public/js/utils.js +55',b'Add Serial No',b'Lis\xc3\xa4\xc3\xa4 sarjanumero'
b'DocType: Work Order Item',b'Available Qty at Source Warehouse',b'Available Kpl l\xc3\xa4hdeverolakia Warehouse'
b'apps/erpnext/erpnext/config/support.py +22',b'Warranty',b'Takuu'
b'DocType: Purchase Invoice',b'Debit Note Issued',b'Debit Note Annettu'
b'DocType: Work Order',b'Warehouses',b'Varastot'
b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18',b'{0} asset cannot be transferred',b'{0} hy\xc3\xb6dykkeen ei voida siirt\xc3\xa4\xc3\xa4'
b'DocType: Hotel Room Pricing',b'Hotel Room Pricing',b'Hotellin huonehinta'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +80',b'This Item is a Variant of {0} (Template).',b'T\xc3\xa4m\xc3\xa4 kohta on muunnelma {0} (malli).'
b'DocType: Workstation',b'per hour',b'Tunnissa'
b'apps/erpnext/erpnext/config/buying.py +7',b'Purchasing',b'Ostot'
b'DocType: Announcement',b'Announcement',b'Ilmoitus'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84',b'Customer LPO',b'Asiakas LPO'
b'DocType: Education Settings',"b'For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.'",b'Sill\xc3\xa4 er\xc3\xa4pohjaisia opiskelijat sek\xc3\xa4 opiskelijakunta Er\xc3\xa4 validoidaan jokaiselle oppilaalle Ohjelmasta Ilmoittautuminen.'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50',b'Warehouse can not be deleted as stock ledger entry exists for this warehouse.',"b'Varastoa ei voi poistaa, koska varastokirjanpidossa on siihen liittyvi\xc3\xa4 kirjauksia.'"
b'apps/erpnext/erpnext/public/js/setup_wizard.js +25',b'Distribution',b'toimitus'
b'DocType: Expense Claim Advance',b'Expense Claim Advance',b'Kulujen ennakkovaatimus'
b'DocType: Lab Test',b'Report Preference',b'Ilmoita suosikeista'
b'apps/erpnext/erpnext/config/non_profit.py +43',b'Volunteer information.',b'Vapaaehtoiset tiedot.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133',b'Project Manager',b'Projektihallinta'
,b'Quoted Item Comparison',b'Noteeratut Kohta Vertailu'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34',b'Overlap in scoring between {0} and {1}',b'P\xc3\xa4\xc3\xa4llekk\xc3\xa4isyys pisteiden v\xc3\xa4lill\xc3\xa4 {0} ja {1}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114',b'Dispatch',b'l\xc3\xa4hetys'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74',b'Max discount allowed for item: {0} is {1}%',b'Max alennus sallittua item: {0} on {1}%'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176',b'Net Asset value as on',b'Substanssi kuin'
b'DocType: Crop',b'Produce',b'Tuottaa'
b'DocType: Hotel Settings',b'Default Taxes and Charges',b'Oletus Verot ja maksut'
b'DocType: Account',b'Receivable',b'Saatava'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308',b'Row #{0}: Not allowed to change Supplier as Purchase Order already exists',b'Rivi # {0}: Ei saa muuttaa Toimittaja kuten ostotilaus on jo olemassa'
b'DocType: Accounts Settings',b'Role that is allowed to submit transactions that exceed credit limits set.',b'roolilla jolla voi l\xc3\xa4hett\xc3\xa4\xc3\xa4 tapamtumia p\xc3\xa4\xc3\xa4see luottoraja asetuksiin'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +989',b'Select Items to Manufacture',b'Valitse tuotteet Valmistus'
b'DocType: Delivery Stop',b'Delivery Stop',b'Toimitus pys\xc3\xa4htyy'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +963',"b'Master data syncing, it might take some time'","b'Master data synkronointia, se saattaa kest\xc3\xa4\xc3\xa4 jonkin aikaa'"
b'DocType: Item',b'Material Issue',b'materiaali aihe'
b'DocType: Employee Education',b'Qualification',b'P\xc3\xa4tevyys'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42',b'View Salary Slips',b'Katso palkkalippuja'
b'DocType: Item Price',b'Item Price',b'Nimikkeen hinta'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48',b'Soap & Detergent',b'Saippua & pesuaine'
b'DocType: BOM',b'Show Items',b'N\xc3\xa4yt\xc3\xa4 kohteet'
b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30',b'From Time cannot be greater than To Time.',b'From Time ei voi olla suurempi kuin ajoin.'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92',b'Do you want to notify all the customers by email?',b'Haluatko ilmoittaa kaikille asiakkaille s\xc3\xa4hk\xc3\xb6postilla?'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36',b'Motion Picture & Video',b'Motion Picture &amp; Video'
b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5',b'Ordered',b'tilattu'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51',b'Resume',b'Jatkaa'
b'DocType: Salary Detail',b'Component',b'komponentti'
b'DocType: Assessment Criteria',b'Assessment Criteria Group',b'Arviointikriteerit Group'
b'DocType: Healthcare Settings',b'Patient Name By',b'Potilaan nimi'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +72',b'Opening Accumulated Depreciation must be less than equal to {0}',b'Avaaminen Kertyneet poistot on oltava pienempi tai yht\xc3\xa4 suuri kuin {0}'
b'DocType: Warehouse',b'Warehouse Name',b'Varaston nimi'
b'DocType: Naming Series',b'Select Transaction',b'Valitse tapahtuma'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30',b'Please enter Approving Role or Approving User',b'Anna hyv\xc3\xa4ksyminen rooli tai hyv\xc3\xa4ksyminen K\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'DocType: Journal Entry',b'Write Off Entry',b'Poiston kirjaus'
b'DocType: BOM',b'Rate Of Materials Based On',b'Materiaalilaskenta perustuen'
b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21',b'Support Analtyics',b'Tuki analyysi'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102',b'Uncheck all',b'Poista kaikki'
b'DocType: POS Profile',b'Terms and Conditions',b'Ehdot ja s\xc3\xa4\xc3\xa4nn\xc3\xb6t'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49',b'To Date should be within the Fiscal Year. Assuming To Date = {0}',"b'P\xc3\xa4iv\xc3\xa4 tulee olla t\xc3\xa4ll\xc3\xa4 tilikaudella, oletettu lopetusp\xc3\xa4iv\xc3\xa4 = {0}'"
b'DocType: Employee',"b'Here you can maintain height, weight, allergies, medical concerns etc'","b't\xc3\xa4ss\xc3\xa4 voit yll\xc3\xa4pit\xc3\xa4\xc3\xa4 terveystietoja, pituus, paino, allergiat, l\xc3\xa4\xc3\xa4kkeet jne'"
b'DocType: Leave Block List',b'Applies to Company',b'koskee yrityst\xc3\xa4'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231',b'Cannot cancel because submitted Stock Entry {0} exists',b'Ei voi perua. Vahvistettu varastotapahtuma {0} on olemassa.'
b'DocType: Employee Loan',b'Disbursement Date',b'maksup\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80',"b""'Recipients' not specified""",b'&#39;Vastaanottajat&#39; ei ole m\xc3\xa4\xc3\xa4ritelty'
b'DocType: BOM Update Tool',b'Update latest price in all BOMs',b'P\xc3\xa4ivit\xc3\xa4 viimeisin hinta kaikkiin ostomakeihin'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23',b'Medical Record',b'Sairauskertomus'
b'DocType: Vehicle',b'Vehicle',b'ajoneuvo'
b'DocType: Purchase Invoice',b'In Words',b'sanat'
b'apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15',b'{0} must be submitted',b'{0} on toimitettava'
b'DocType: POS Profile',b'Item Groups',b'Kohta Ryhm\xc3\xa4t'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +221',"b""Today is {0}'s birthday!""",b'T\xc3\xa4n\xc3\xa4\xc3\xa4n on {0}:n syntym\xc3\xa4p\xc3\xa4iv\xc3\xa4'
b'DocType: Sales Order Item',b'For Production',b'tuotantoon'
b'DocType: Payment Request',b'payment_url',b'payment_url'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186',b'Please add a Temporary Opening account in Chart of Accounts',b'Lis\xc3\xa4\xc3\xa4 tilap\xc3\xa4inen tilitietojen tilap\xc3\xa4inen avaaminen'
b'DocType: Customer',b'Customer Primary Contact',b'Asiakasl\xc3\xa4ht\xc3\xb6inen yhteyshenkil\xc3\xb6'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154',b'Period Closing Journal',b'Aikakauslehti'
b'DocType: Project Task',b'View Task',b'N\xc3\xa4yt\xc3\xa4 teht\xc3\xa4v\xc3\xa4'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'OPP / Lyijy%'
b'DocType: Material Request',b'MREQ-',b'MREQ-'
b'DocType: Payment Schedule',b'Invoice Portion',b'Laskuosuus'
,b'Asset Depreciations and Balances',b'Asset Poistot ja taseet'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370',b'Amount {0} {1} transferred from {2} to {3}',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 {0} {1} siirretty {2} ja {3}'
b'DocType: Sales Invoice',b'Get Advances Received',b'hae saadut ennakot'
b'DocType: Email Digest',b'Add/Remove Recipients',b'lis\xc3\xa4\xc3\xa4 / poista vastaanottajia'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19',"b""To set this Fiscal Year as Default, click on 'Set as Default'""","b'Asettaaksesi t\xc3\xa4m\xc3\xa4n tilikaudenoletukseksi, klikkaa ""aseta oletukseksi""'"
b'DocType: Production Plan',b'Include Subcontracted Items',b'Sis\xc3\xa4llyt\xc3\xa4 alihankintana teht\xc3\xa4v\xc3\xa4t kohteet'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +220',b'Join',b'Liitty\xc3\xa4 seuraan'
b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21',b'Shortage Qty',b'Vajaa m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +672',b'Cannot change Variant properties after stock transction. You will have to make a new Item to do this.',b'Vaihtoehtoisia ominaisuuksia ei voi vaihtaa varastotoimituksen j\xc3\xa4lkeen. Sinun t\xc3\xa4ytyy tehd\xc3\xa4 uusi esine tehd\xc3\xa4 t\xc3\xa4m\xc3\xa4.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +714',b'Item variant {0} exists with same attributes',b'Tuote variantti {0} ovat olemassa samoja ominaisuuksia'
b'DocType: Employee Loan',b'Repay from Salary',b'Maksaa maasta Palkka'
b'DocType: Leave Application',b'LAP/',b'LAP /'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360',b'Requesting payment against {0} {1} for amount {2}',b'Maksupyynn\xc3\xb6n vastaan {0} {1} m\xc3\xa4\xc3\xa4r\xc3\xa4ksi {2}'
b'DocType: Salary Slip',b'Salary Slip',b'Palkkalaskelma'
b'DocType: Lead',b'Lost Quotation',b'kadonnut Quotation'
b'apps/erpnext/erpnext/utilities/user_progress.py +221',b'Student Batches',b'Opiskelijaryhm\xc3\xa4t'
b'DocType: Pricing Rule',b'Margin Rate or Amount',b'Marginaali nopeuteen tai m\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4n'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48',"b""'To Date' is required""","b""'P\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4' on pakollinen"""
b'DocType: Packing Slip',"b'Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.'","b'muodosta pakkausluetteloita toimitettaville pakkauksille, k\xc3\xa4ytet\xc3\xa4\xc3\xa4n pakkausnumeron, -sis\xc3\xa4lt\xc3\xb6 ja painon m\xc3\xa4\xc3\xa4ritykseen'"
b'DocType: Sales Invoice Item',b'Sales Order Item',"b'Myyntitilaus, tuote'"
b'DocType: Salary Slip',b'Payment Days',b'Maksup\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'DocType: Stock Settings',b'Convert Item Description to Clean HTML',b'Muuta kohteen kuvaus Puhdista HTML'
b'DocType: Patient',b'Dormant',b'uinuva'
b'DocType: Salary Slip',b'Total Interest Amount',b'Kokonaiskorkojen m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124',b'Warehouses with child nodes cannot be converted to ledger',b'Varasto lapsen solmuja ei voida muuntaa Ledger'
b'DocType: BOM',b'Manage cost of operations',b'hallitse toimien kustannuksia'
b'DocType: Accounts Settings',b'Stale Days',b'Stale Days'
b'DocType: Notification Control',"b'When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.'","b'Kun valitut tapahtumat vahvistetaan, j\xc3\xa4rjestelm\xc3\xa4 avaa ponnahdusikkunaan s\xc3\xa4hk\xc3\xb6postiviestin jolla tapahtumat voi l\xc3\xa4hett\xc3\xa4\xc3\xa4 tapahtumien yhteyshenkil\xc3\xb6ille s\xc3\xa4hk\xc3\xb6postiliittein\xc3\xa4.'"
b'apps/erpnext/erpnext/config/setup.py +14',b'Global Settings',b'yleiset asetukset'
b'DocType: Crop',b'Row Spacing UOM',b'Riviv\xc3\xa4litys UOM'
b'DocType: Assessment Result Detail',b'Assessment Result Detail',b'Arviointi Tulos Detail'
b'DocType: Employee Education',b'Employee Education',b'ty\xc3\xb6ntekij\xc3\xa4 koulutus'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53',b'Duplicate item group found in the item group table',b'Monista kohde ryhm\xc3\xa4 l\xc3\xb6ysi er\xc3\xa4\xc3\xa4n ryhm\xc3\xa4taulukkoon'
b'DocType: Land Unit',b'Parent Land Unit',b'Vanhempainmaan yksikk\xc3\xb6'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1113',b'It is needed to fetch Item Details.',b'Sit\xc3\xa4 tarvitaan hakemaan Osa Tiedot.'
b'DocType: Fertilizer',b'Fertilizer Name',b'Lannoitteen nimi'
b'DocType: Salary Slip',b'Net Pay',b'Nettomaksu'
b'DocType: Cash Flow Mapping Accounts',b'Account',b'tili'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217',b'Serial No {0} has already been received',b'Sarjanumero {0} on jo saapunut'
,b'Requested Items To Be Transferred',b'siirrett\xc3\xa4v\xc3\xa4t pyydetyt tuotteet'
b'DocType: Expense Claim',b'Vehicle Log',b'ajoneuvo Log'
b'DocType: Vital Signs',b'Presence of a fever (temp &gt; 38.5 \xc2\xb0C/101.3 \xc2\xb0F or sustained temp &gt; 38 \xc2\xb0C/100.4 \xc2\xb0F)',"b'Kuumeen esiintyminen (l\xc3\xa4mp\xc3\xb6tila&gt; 38,5 \xc2\xb0 C / 101,3 \xc2\xb0 F tai jatkuva l\xc3\xa4mp\xc3\xb6tila&gt; 38 \xc2\xb0 C / 100,4 \xc2\xb0 F)'"
b'DocType: Customer',b'Sales Team Details',b'Myyntitiimin lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1352',b'Delete permanently?',b'poista pysyv\xc3\xa4sti?'
b'DocType: Expense Claim',b'Total Claimed Amount',b'Vaatimukset arvom\xc3\xa4\xc3\xa4r\xc3\xa4 yhteens\xc3\xa4'
b'apps/erpnext/erpnext/config/crm.py +17',b'Potential opportunities for selling.',b'Myynnin potentiaalisia tilaisuuksia'
b'DocType: Shareholder',b'Folio no.',b'Folio no.'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246',b'Invalid {0}',b'Virheellinen {0}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90',b'Sick Leave',b'Sairaspoistuminen'
b'DocType: Email Digest',b'Email Digest',b's\xc3\xa4hk\xc3\xb6postitiedote'
b'DocType: Delivery Note',b'Billing Address Name',b'Laskutus osoitteen nimi'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22',b'Department Stores',b'osasto kaupat'
,b'Item Delivery Date',b'Tuote Toimitusp\xc3\xa4iv\xc3\xa4'
b'DocType: Production Plan',b'Material Requested',b'Pyydetty materiaali'
b'DocType: Warehouse',b'PIN',b'PIN'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116',"b""Error '{0}' occured. Arguments {1}.""",b'Virhe &#39;{0}&#39; tapahtui. Argumentit {1}.'
b'DocType: Bin',b'Reserved Qty for sub contract',b'Varattu m\xc3\xa4\xc3\xa4r\xc3\xa4 alihankintana'
b'DocType: Patient Service Unit',b'Patinet Service Unit',b'Patinetin huoltoyksikk\xc3\xb6'
b'DocType: Sales Invoice',b'Base Change Amount (Company Currency)',b'Base Muuta Summa (Company valuutta)'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304',b'No accounting entries for the following warehouses',b'ei kirjanpidon kirjauksia seuraaviin varastoihin'
b'apps/erpnext/erpnext/projects/doctype/project/project.js +95',b'Save the document first.',b'Tallenna asiakirja ensin'
b'apps/erpnext/erpnext/shopping_cart/cart.py +74',b'Only {0} in stock for item {1}',b'Vain {0} varastossa kohteen {1}'
b'DocType: Account',b'Chargeable',b'veloitettava'
b'DocType: Company',b'Change Abbreviation',b'muuta lyhennett\xc3\xa4'
b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66',b'Pay {0} {1}',b'Maksa {0} {1}'
b'DocType: Expense Claim Detail',b'Expense Date',b'Kustannusp\xc3\xa4iv\xc3\xa4'
b'DocType: Item',b'Max Discount (%)',b'Max Alennus (%)'
b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30',b'Credit Days cannot be a negative number',b'Luottop\xc3\xa4iv\xc3\xa4t eiv\xc3\xa4t voi olla negatiivinen luku'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70',b'Last Order Amount',b'Viimeisen tilauksen arvo'
b'DocType: Cash Flow Mapper',b'e.g Adjustments for:',b'esim. S\xc3\xa4\xc3\xa4t\xc3\xb6:'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +275',"b' {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item'","b'{0} S\xc3\xa4ilyt\xc3\xa4 n\xc3\xa4ytteit\xc3\xa4 perustuu er\xc3\xa4\xc3\xa4n, tarkista, onko er\xc3\xa4numero s\xc3\xa4ilytt\xc3\xa4nyt n\xc3\xa4ytteen kohteen'"
b'DocType: Task',b'Is Milestone',b'on Milestone'
b'DocType: Delivery Stop',b'Email Sent To',b'S\xc3\xa4hk\xc3\xb6posti l\xc3\xa4hetet\xc3\xa4\xc3\xa4n'
b'DocType: Budget',b'Warn',b'Varoita'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81',b'Are you sure you want to unregister?',b'Haluatko varmasti poistaa tilisi?'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +797',b'All items have already been transferred for this Work Order.',b'Kaikki kohteet on jo siirretty t\xc3\xa4h\xc3\xa4n ty\xc3\xb6j\xc3\xa4rjestykseen.'
b'DocType: Appraisal',"b'Any other remarks, noteworthy effort that should go in the records.'","b'muut huomiot, huomioitavat asiat tulee laittaa t\xc3\xa4h\xc3\xa4n tietueeseen'"
b'DocType: Asset Maintenance',b'Manufacturing User',b'Valmistus perusk\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'DocType: Purchase Invoice',b'Raw Materials Supplied',b'Raaka-aineet toimitettu'
b'DocType: C-Form',b'Series',b'Numerosarja'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282',b'Currency of the price list {0} must be {1} or {2}',b'Hinnaston valuutan {0} on oltava {1} tai {2}'
b'DocType: Appraisal',b'Appraisal Template',b'Arvioinnin mallipohjat'
b'DocType: Soil Texture',b'Ternary Plot',b'Tern\xc3\xa4\xc3\xa4rinen tontti'
b'DocType: Item Group',b'Item Classification',b'tuote luokittelu'
b'DocType: Driver',b'License Number',b'Rekisteri numero'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131',b'Business Development Manager',b'Liiketoiminnan kehitysp\xc3\xa4\xc3\xa4llikk\xc3\xb6'
b'DocType: Maintenance Visit Purpose',b'Maintenance Visit Purpose',b'Huoltok\xc3\xa4ynnin tarkoitus'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19',b'Invoice Patient Registration',b'Laskun potilaan rekister\xc3\xb6inti'
b'DocType: Crop',b'Period',b'Aikajakso'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27',b'General Ledger',b'P\xc3\xa4\xc3\xa4tilikirja'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33',b'Employee {0} on Leave on {1}',b'Ty\xc3\xb6ntekij\xc3\xa4n {0} virkavapaalla {1}'
b'apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10',b'View Leads',b'N\xc3\xa4yt\xc3\xa4 vihjeet'
b'DocType: Program Enrollment Tool',b'New Program',b'uusi ohjelma'
b'DocType: Item Attribute Value',b'Attribute Value',"b'tuntomerkki, arvo'"
,b'Itemwise Recommended Reorder Level',b'Tuotekohtainen suositeltu t\xc3\xa4ydennystilaustaso'
b'DocType: Salary Detail',b'Salary Detail',b'Palkka Detail'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070',b'Please select {0} first',b'Ole hyv\xc3\xa4 ja valitse {0} Ensimm\xc3\xa4inen'
b'DocType: Appointment Type',b'Physician',b'L\xc3\xa4\xc3\xa4k\xc3\xa4ri'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +872',b'Batch {0} of Item {1} has expired.',b'Er\xc3\xa4 {0} tuotteesta {1} on vanhentunut.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11',b'Consultations',b'kuulemiset'
b'DocType: Sales Invoice',b'Commission',b'provisio'
b'apps/erpnext/erpnext/config/manufacturing.py +27',b'Time Sheet for manufacturing.',b'Valmistuksen tuntilista'
b'apps/erpnext/erpnext/templates/pages/cart.html +37',b'Subtotal',b'V\xc3\xa4lisumma'
b'apps/erpnext/erpnext/config/erpnext_integrations.py +18',b'GoCardless SEPA Mandate',b'GoCardless SEPA-toimeksianto'
b'DocType: Physician',b'Charges',b'maksut'
b'DocType: Production Plan',b'Get Items For Work Order',b'Hae kohteet ty\xc3\xb6j\xc3\xa4rjestykseen'
b'DocType: Salary Detail',b'Default Amount',b'oletus arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Lab Test Template',b'Descriptive',b'kuvaileva'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95',b'Warehouse not found in the system',b'Varastoa ei l\xc3\xb6ydy j\xc3\xa4rjestelm\xc3\xa4st\xc3\xa4'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115',"b""This Month's Summary""",b'T\xc3\xa4m\xc3\xa4n kuun yhteenveto'
b'DocType: Quality Inspection Reading',b'Quality Inspection Reading',b'Laarutarkistuksen luku'
b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25',b'`Freeze Stocks Older Than` should be smaller than %d days.',b'Kylm\xc3\xa4varasto pit\xc3\xa4isi olla v\xc3\xa4hemm\xc3\xa4n kuin % p\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'DocType: Tax Rule',b'Purchase Tax Template',b'Myyntiverovelkojen malli'
b'apps/erpnext/erpnext/utilities/user_progress.py +48',"b""Set a sales goal you'd like to achieve for your company.""","b'Aseta myyntitavoite, jonka haluat saavuttaa yrityksellesi.'"
,b'Project wise Stock Tracking',"b'projekt ty\xc3\xb6kalu, varastoseuranta'"
b'DocType: GST HSN Code',b'Regional',b'alueellinen'
b'apps/erpnext/erpnext/config/healthcare.py +40',b'Laboratory',b'laboratorio'
b'DocType: Stock Entry Detail',b'Actual Qty (at source/target)',b'todellinen yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 (l\xc3\xa4hde/tavoite)'
b'DocType: Item Customer Detail',b'Ref Code',b'Viite Koodi'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75',b'Customer Group is Required in POS Profile',b'Asiakasryhm\xc3\xa4 on pakollinen POS-profiilissa'
b'apps/erpnext/erpnext/config/hr.py +12',b'Employee records.',b'ty\xc3\xb6ntekij\xc3\xa4 tietue'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +98',b'Please set Next Depreciation Date',b'M\xc3\xa4\xc3\xa4rit\xc3\xa4 Seuraava Poistot Date'
b'DocType: HR Settings',b'Payroll Settings',b'Palkanlaskennan asetukset'
b'apps/erpnext/erpnext/config/accounts.py +146',b'Match non-linked Invoices and Payments.',b't\xc3\xa4sm\xc3\xa4\xc3\xa4 linkitt\xc3\xa4m\xc3\xa4tt\xc3\xb6m\xc3\xa4t maksut ja laskut'
b'DocType: POS Settings',b'POS Settings',b'POS-asetukset'
b'apps/erpnext/erpnext/templates/pages/cart.html +16',b'Place Order',b'Tee tilaus'
b'DocType: Email Digest',b'New Purchase Orders',b'Uusi Ostotilaukset'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24',b'Root cannot have a parent cost center',b'P\xc3\xa4\xc3\xa4tasolla ei voi olla p\xc3\xa4\xc3\xa4kustannuspaikkaa'
b'apps/erpnext/erpnext/public/js/stock_analytics.js +54',b'Select Brand...',b'Valitse Merkki ...'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +32',b'Non Profit (beta)',b'Ei voittoa (beta)'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18',b'Training Events/Results',b'Koulutustapahtumat / Tulokset'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152',b'Accumulated Depreciation as on',b'Kertyneet poistot kuin'
b'DocType: Sales Invoice',b'C-Form Applicable',b'C-muotoa sovelletaan'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438',b'Operation Time must be greater than 0 for Operation {0}',b'Toiminta-aika on oltava suurempi kuin 0 Toiminta {0}'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107',b'Warehouse is mandatory',b'Varasto on pakollinen'
b'DocType: Shareholder',b'Address and Contacts',b'Osoite ja yhteystiedot'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67',b'Failed to create website',b'Sivuston luominen ep\xc3\xa4onnistui'
b'DocType: Soil Analysis',b'Mg/K',b'Mg / K'
b'DocType: UOM Conversion Detail',b'UOM Conversion Detail',b'Mittayksik\xc3\xb6n muunnon lis\xc3\xa4tiedot'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924',b'Retention Stock Entry already created or Sample Quantity not provided',b'J\xc3\xa4ljell\xc3\xa4 oleva s\xc3\xa4ilytysvarastokirjaus tai n\xc3\xa4ytem\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4 ei ole toimitettu'
b'DocType: Program',b'Program Abbreviation',b'Ohjelma lyhenne'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52',b'Charges are updated in Purchase Receipt against each item',b'maksut on p\xc3\xa4ivitetty ostokuitilla kondistettuna jokaiseen tuotteeseen'
b'DocType: Warranty Claim',b'Resolved By',b'Ratkaisija'
b'DocType: Bank Guarantee',b'Start Date',b'aloitusp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/config/hr.py +75',b'Allocate leaves for a period.',b'kohdistaa poistumisen kaudelle'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42',b'Cheques and Deposits incorrectly cleared',b'Sekkej\xc3\xa4 ja Talletukset virheellisesti selvitetty'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +46',b'Account {0}: You can not assign itself as parent account',b'tili {0}: et voi nimet\xc3\xa4 t\xc3\xa4t\xc3\xa4 tili\xc3\xa4 emotiliksi'
b'DocType: Purchase Invoice Item',b'Price List Rate',b'hinta'
b'apps/erpnext/erpnext/utilities/activation.py +72',b'Create customer quotes',b'Luoda asiakkaalle lainausmerkit'
b'DocType: Item',"b'Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.'","b'N\xc3\xa4yt\xc3\xa4 t\xc3\xa4m\xc3\xa4n varaston saatavat ""varastossa"" tai ""ei varastossa"" perusteella'"
b'apps/erpnext/erpnext/config/manufacturing.py +38',b'Bill of Materials (BOM)',b'Osaluettelo (BOM)'
b'DocType: Item',b'Average time taken by the supplier to deliver',b'Keskim\xc3\xa4\xc3\xa4r\xc3\xa4inen aika toimittajan toimittamaan'
b'DocType: Sample Collection',b'Collected By',b'Ker\xc3\xa4tty'
b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35',b'Assessment Result',b'arviointi tulos'
b'DocType: Hotel Room Package',b'Hotel Room Package',b'Hotellihuoneen paketti'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13',b'Hours',b'tuntia'
b'DocType: Project',b'Expected Start Date',b'odotettu aloitusp\xc3\xa4iv\xc3\xa4'
b'DocType: Purchase Invoice',b'04-Correction in Invoice',b'04-Korjaus laskussa'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963',b'Work Order already created for all items with BOM',"b'Ty\xc3\xb6j\xc3\xa4rjestys on luotu kaikille kohteille, joissa on BOM'"
b'apps/erpnext/erpnext/stock/doctype/item/item.js +60',b'Variant Details Report',b'Vaihtotiedotiedot Raportti'
b'DocType: Setup Progress Action',b'Setup Progress Action',b'Setup Progress -toiminto'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36',b'Buying Price List',b'Ostohinta'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49',b'Remove item if charges is not applicable to that item',b'poista tuote mik\xc3\xa4li maksuja ei voi soveltaa siihen'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21',b'Please select Maintenance Status as Completed or remove Completion Date',b'Valitse Huolto-tila Valmis tai poista Valmistumisp\xc3\xa4iv\xc3\xa4'
b'DocType: Supplier',b'Default Payment Terms Template',b'Oletusmaksutavaramalli'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34',b'Transaction currency must be same as Payment Gateway currency',b'Maksuv\xc3\xa4lineen\xc3\xa4 on oltava sama kuin Payment Gateway valuutta'
b'DocType: Payment Entry',b'Receive',b'Vastaanottaa'
b'apps/erpnext/erpnext/templates/pages/rfq.html +75',b'Quotations: ',b'Lainaukset:'
b'DocType: Maintenance Visit',b'Fully Completed',b't\xc3\xa4ysin valmis'
b'apps/erpnext/erpnext/projects/doctype/project/project_list.js +6',b'{0}% Complete',b'{0}% valmis'
b'DocType: Employee',b'Educational Qualification',b'koulutusksen arviointi'
b'DocType: Workstation',b'Operating Costs',b'K\xc3\xa4ytt\xc3\xb6kustannukset'
b'DocType: Budget',b'Action if Accumulated Monthly Budget Exceeded',b'Toiminta jos kuukausikulutus budjetti ylitetty'
b'DocType: Subscription',b'Submit on creation',b'Vahvista luonnin yhteydess\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483',b'Currency for {0} must be {1}',b'Valuutta {0} on {1}'
b'DocType: Asset',b'Disposal Date',b'h\xc3\xa4vitt\xc3\xa4minen Date'
b'DocType: Daily Work Summary Settings',"b'Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.'","b'S\xc3\xa4hk\xc3\xb6postit l\xc3\xa4hetet\xc3\xa4\xc3\xa4n kaikille aktiivinen Yrityksen ty\xc3\xb6ntekij\xc3\xa4t on tietyn tunnin, jos heill\xc3\xa4 ei ole loma. Yhteenveto vastauksista l\xc3\xa4hetet\xc3\xa4\xc3\xa4n keskiy\xc3\xb6ll\xc3\xa4.'"
b'DocType: Employee Leave Approver',b'Employee Leave Approver',b'Poissaolon hyv\xc3\xa4ksyj\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +510',b'Row {0}: An Reorder entry already exists for this warehouse {1}',b'Rivi {0}: t\xc3\xa4ydennystilaus on jo kirjattu t\xc3\xa4lle varastolle {1}'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99',"b'Cannot declare as lost, because Quotation has been made.'","b'ei voida vahvistaa h\xc3\xa4vityksi, sill\xc3\xa4 tarjous on tehty'"
b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16',b'Training Feedback',b'Training Palaute'
b'DocType: Supplier Scorecard Criteria',b'Supplier Scorecard Criteria',b'Toimittajan tuloskortin kriteerit'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149',b'Please select Start Date and End Date for Item {0}',b'Ole hyv\xc3\xa4 ja valitse alkamisp\xc3\xa4iv\xc3\xa4 ja p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4 Kohta {0}'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55',b'Course is mandatory in row {0}',b'Kurssi on pakollinen rivi {0}'
b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16',b'To date cannot be before from date',b'P\xc3\xa4iv\xc3\xa4\xc3\xa4n ei voi olla ennen aloitusp\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'DocType: Supplier Quotation Item',b'Prevdoc DocType',b'Edellinen tietuetyyppi'
b'DocType: Cash Flow Mapper',b'Section Footer',b'Osa-alatunniste'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +304',b'Add / Edit Prices',b'Lis\xc3\xa4\xc3\xa4 / muokkaa hintoja'
b'DocType: Batch',b'Parent Batch',b'Parent Er\xc3\xa4'
b'DocType: Cheque Print Template',b'Cheque Print Template',b'Shekki Print Template'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36',b'Chart of Cost Centers',b'Kustannuspaikkakaavio'
b'DocType: Lab Test Template',b'Sample Collection',b'N\xc3\xa4ytteenottokokoelma'
,b'Requested Items To Be Ordered',b'Tilauksessa olevat nimiketarpeet'
b'apps/erpnext/erpnext/public/js/hub/hub_page.js +137',b'My Orders',b'Omat tilaukset'
b'DocType: Price List',b'Price List Name',b'Hinnaston nimi'
b'DocType: BOM',b'Manufacturing',b'Valmistus'
,b'Ordered Items To Be Delivered',b'Asiakkaille toimittamattomat tilaukset'
b'DocType: Account',b'Income',b'tulo'
b'DocType: Industry Type',b'Industry Type',b'teollisuus tyyppi'
b'apps/erpnext/erpnext/templates/includes/cart.js +150',b'Something went wrong!',b'Jokin meni pieleen!'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105',b'Warning: Leave application contains following block dates',b'Varoitus: Hakemus vapaasta sis\xc3\xa4lt\xc3\xa4\xc3\xa4 p\xc3\xa4ivi\xc3\xa4 joita ei ole sallittu'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275',b'Sales Invoice {0} has already been submitted',b'Myyntilasku {0} on jo vahvistettu'
b'DocType: Supplier Scorecard Scoring Criteria',b'Score',b'Pisteet'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25',b'Fiscal Year {0} does not exist',b'Verovuoden {0} ei ole olemassa'
b'DocType: Asset Maintenance Log',b'Completion Date',b'katselmus p\xc3\xa4iv\xc3\xa4'
b'DocType: Purchase Invoice Item',b'Amount (Company Currency)',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 (yrityksen valuutassa)'
b'DocType: Agriculture Analysis Criteria',b'Agriculture User',b'Maatalous-k\xc3\xa4ytt\xc3\xa4j\xc3\xa4'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38',b'Valid till date cannot be before transaction date',b'Voimassa oleva p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla ennen tapahtumap\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/stock/stock_ledger.py +381',b'{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.',b'{0} yksikk\xc3\xb6\xc3\xa4 {1} tarvitaan {2} on {3} {4} varten {5} tapahtuman suorittamiseen.'
b'DocType: Fee Schedule',b'Student Category',b'Student Luokka'
b'DocType: Announcement',b'Student',b'Opiskelija'
b'apps/erpnext/erpnext/config/hr.py +238',b'Organization unit (department) master.',"b'organisaatioyksikk\xc3\xb6, osasto valvonta'"
b'DocType: Shipping Rule',b'Shipping Rule Type',b'L\xc3\xa4hetyss\xc3\xa4\xc3\xa4nn\xc3\xb6tyyppi'
b'apps/erpnext/erpnext/utilities/user_progress.py +239',b'Go to Rooms',b'Siirry huoneisiin'
b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75',b'Please enter message before sending',b'Anna viestin ennen l\xc3\xa4hett\xc3\xa4mist\xc3\xa4'
b'DocType: Purchase Invoice',b'DUPLICATE FOR SUPPLIER',b'DUPLICATE TOIMITTAJILLE'
b'DocType: Email Digest',b'Pending Quotations',b'Odottaa Lainaukset'
b'apps/erpnext/erpnext/config/accounts.py +318',b'Point-of-Sale Profile',b'Point-of-Sale Profile'
b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25',b'{0} should be a value between 0 and 100',b'{0} pit\xc3\xa4isi olla arvo v\xc3\xa4lill\xc3\xa4 0 ja 100'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +94',b'Next Depreciation Date cannot be before Available-for-use Date',b'Seuraava poistoaika ei voi olla ennen K\xc3\xa4ytett\xc3\xa4viss\xc3\xa4 olevaa p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156',b'Unsecured Loans',b'Vakuudettomat lainat'
b'DocType: Cost Center',b'Cost Center Name',b'kustannuspaikan nimi'
b'DocType: Student',b'B+',b'B +'
b'DocType: HR Settings',b'Max working hours against Timesheet',b'Tuntilomakkeella hyv\xc3\xa4ksyttyjen ty\xc3\xb6tuntien enimm\xc3\xa4ism\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Maintenance Schedule Detail',b'Scheduled Date',"b'Aikataulutettu, p\xc3\xa4iv\xc3\xa4'"
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +214',b'Total Paid Amt',b'maksettu yhteens\xc3\xa4'
b'DocType: SMS Center',b'Messages greater than 160 characters will be split into multiple messages',b'Viestit yli 160 merkki\xc3\xa4 jaetaan useita viestej\xc3\xa4'
b'DocType: Purchase Receipt Item',b'Received and Accepted',b'Saanut ja hyv\xc3\xa4ksynyt'
b'DocType: Hub Settings',b'Company and Seller Profile',b'Yritys- ja Myyj\xc3\xa4profiili'
,b'GST Itemised Sales Register',b'GST Eritelty Sales Register'
b'DocType: Soil Texture',b'Silt Loam',b'Silt Loam'
,b'Serial No Service Contract Expiry',b'Palvelusopimuksen p\xc3\xa4\xc3\xa4ttyminen sarjanumerolle'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299',b'You cannot credit and debit same account at the same time',b'sek\xc3\xa4 kredit- ett\xc3\xa4 debet-kirjausta ei voi tehd\xc3\xa4 samalle tilille yhtaikaa'
b'DocType: Vital Signs',"b""Adults' pulse rate is anywhere between 50 and 80 beats per minute.""",b'Aikuisten pulssi on v\xc3\xa4lill\xc3\xa4 50-80 ly\xc3\xb6nti\xc3\xa4 minuutissa.'
b'DocType: Naming Series',b'Help HTML',"b'HTML, ohje'"
b'DocType: Student Group Creation Tool',b'Student Group Creation Tool',b'Student Group Creation Tool'
b'DocType: Item',b'Variant Based On',b'Variant perustuvat'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53',b'Total weightage assigned should be 100%. It is {0}',b'Nimetyn painoarvon tulee yhteens\xc3\xa4 olla 100%. Nyt se on {0}'
b'apps/erpnext/erpnext/utilities/user_progress.py +109',b'Your Suppliers',b'omat toimittajat'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'Please correct the',b'Korjaa'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80',b'Cannot set as Lost as Sales Order is made.',b'ei voi asettaa h\xc3\xa4vityksi sill\xc3\xa4 myyntitilaus on tehty'
b'DocType: Request for Quotation Item',b'Supplier Part No',b'Toimittaja osanumero'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382',"b""Cannot deduct when category is for 'Valuation' or 'Vaulation and Total'""","b'Ei voi v\xc3\xa4hent\xc3\xa4\xc3\xa4, kun kategoria on &quot;arvostus&quot; tai &quot;Vaulation ja Total&quot;'"
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377',b'Received From',b'Saadut'
b'DocType: Lead',b'Converted',b'muunnettu'
b'DocType: Item',b'Has Serial No',b'on sarjanumero'
b'DocType: Employee',b'Date of Issue',b'Kirjauksen p\xc3\xa4iv\xc3\xa4ys'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222',"b""As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}""","b'Kuten kohti ostaminen Asetukset, jos hankinta Reciept Pakollinen == KYLL\xc3\x84, sitten luoda Ostolasku, k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n t\xc3\xa4ytyy luoda Ostokuitti ensin kohteen {0}'"
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167',b'Row #{0}: Set Supplier for item {1}',b'Rivi # {0}: Aseta toimittaja kohteen {1}'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121',b'Row {0}: Hours value must be greater than zero.',b'Rivi {0}: Tuntia arvon on oltava suurempi kuin nolla.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +195',b'Website Image {0} attached to Item {1} cannot be found',b'Sivuston kuvaa {0} kohteelle {1} ei l\xc3\xb6ydy'
b'DocType: Issue',b'Content Type',b'sis\xc3\xa4ll\xc3\xb6n tyyppi'
b'DocType: Asset',b'Assets',b'varat'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17',b'Computer',b'tietokone'
b'DocType: Item',b'List this Item in multiple groups on the website.',b'Listaa t\xc3\xa4st\xc3\xa4 Kohta useisiin ryhmiin verkkosivuilla.'
b'DocType: Payment Term',b'Due Date Based On',b'Er\xc3\xa4p\xc3\xa4iv\xc3\xa4 perustuu'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82',b'Please set default customer group and territory in Selling Settings',b'Aseta oletusryhm\xc3\xa4 ja alue Myynnin asetuksiin'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214',b'{0} {1} does not exist',b'{0} {1} ei ole olemassa'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323',b'Please check Multi Currency option to allow accounts with other currency',b'Tarkista usean valuutan mahdollisuuden sallia tilej\xc3\xa4 muu valuutta'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88',b'Item: {0} does not exist in the system',b'tuote: {0} ei ole j\xc3\xa4rjestelm\xc3\xa4ss\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +106',b'You are not authorized to set Frozen value',b'sinulla ei ole oikeutta asettaa j\xc3\xa4\xc3\xa4tymis arva'
b'DocType: Payment Reconciliation',b'Get Unreconciled Entries',b'hae t\xc3\xa4sm\xc3\xa4\xc3\xa4m\xc3\xa4tt\xc3\xb6m\xc3\xa4t kirjaukset'
b'DocType: Payment Reconciliation',b'From Invoice Date',b'Alkaen Laskun p\xc3\xa4iv\xc3\xa4ys'
b'DocType: Healthcare Settings',b'Laboratory Settings',b'Laboratorioasetukset'
b'DocType: Patient Appointment',b'Service Unit',b'Huoltoyksikk\xc3\xb6'
b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97',b'Successfully Set Supplier',b'Toimittaja onnistui'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75',b'Leave Encashment',b'j\xc3\xa4t\xc3\xa4 perint\xc3\xa4'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +114',b'What does it do?',b'Mit\xc3\xa4 t\xc3\xa4m\xc3\xa4 tekee?'
b'DocType: Crop',b'Byproducts',b'sivutuotteita'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +84',b'To Warehouse',b'Varastoon'
b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26',b'All Student Admissions',b'Kaikki Opiskelijavalinta'
,b'Average Commission Rate',b'keskim\xc3\xa4\xc3\xa4r\xc3\xa4inen provisio'
b'DocType: Share Balance',b'No of Shares',b'Osuuksien m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +448',"b""'Has Serial No' can not be 'Yes' for non-stock item""","b""Varastoimattoman nimikkeen 'Sarjanumeroitu' -arvo ei voi olla 'kyll\xc3\xa4'"""
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59',b'Select Status',b'Valitse Tila'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41',b'Attendance can not be marked for future dates',b'osallistumisia ei voi merkit\xc3\xa4 tuleville p\xc3\xa4iville'
b'DocType: Pricing Rule',b'Pricing Rule Help',"b'Hinnoittelus\xc3\xa4\xc3\xa4nt\xc3\xb6, ohjeet'"
b'DocType: School House',b'House Name',b'Talon nimi'
b'DocType: Fee Schedule',b'Total Amount per Student',b'Opiskelijan kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Purchase Taxes and Charges',b'Account Head',b'tilin otsikko'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153',b'Electrical',b's\xc3\xa4hk\xc3\xb6inen'
b'apps/erpnext/erpnext/utilities/activation.py +100',b'Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts',b'Lis\xc3\xa4\xc3\xa4 loput organisaatiosi k\xc3\xa4ytt\xc3\xa4jille. Voit my\xc3\xb6s lis\xc3\xa4t\xc3\xa4 kutsua Asiakkaat portaaliin lis\xc3\xa4\xc3\xa4m\xc3\xa4ll\xc3\xa4 ne Yhteydet'
b'DocType: Stock Entry',b'Total Value Difference (Out - In)',b'arvoero (ulos-sis\xc3\xa4\xc3\xa4n) yhteens\xc3\xa4'
b'DocType: Grant Application',b'Requested Amount',b'Pyydetty m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348',b'Row {0}: Exchange Rate is mandatory',b'Rivi {0}: Vaihtokurssi on pakollinen'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27',b'User ID not set for Employee {0}',b'K\xc3\xa4ytt\xc3\xa4j\xc3\xa4tunnusta ei asetettu ty\xc3\xb6ntekij\xc3\xa4lle {0}'
b'DocType: Vehicle',b'Vehicle Value',b'ajoneuvo Arvo'
b'DocType: Crop Cycle',b'Detected Diseases',b'Havaitut taudit'
b'DocType: Stock Entry',b'Default Source Warehouse',b'Varastosta (oletus)'
b'DocType: Item',b'Customer Code',b'Asiakkaan yrityskoodi'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +220',b'Birthday Reminder for {0}',b'Syntym\xc3\xa4p\xc3\xa4iv\xc3\xa4muistutus {0}'
b'DocType: Asset Maintenance Task',b'Last Completion Date',b'Viimeinen p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72',b'Days Since Last Order',b'p\xc3\xa4iv\xc3\xa4\xc3\xa4 edellisest\xc3\xa4 tilauksesta'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365',b'Debit To account must be a Balance Sheet account',b'Debit tilin on oltava tase tili'
b'DocType: Buying Settings',b'Naming Series',b'Nime\xc3\xa4 sarjat'
b'DocType: GoCardless Settings',b'GoCardless Settings',b'GoCardless Settings'
b'DocType: Leave Block List',b'Leave Block List Name',b'nimi'
b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14',b'Insurance Start date should be less than Insurance End date',b'Vakuutus Aloitusp\xc3\xa4iv\xc3\xa4 pit\xc3\xa4isi olla alle Insurance P\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32',b'Stock Assets',"b'Varasto, vastaavat'"
b'DocType: Restaurant',b'Active Menu',b'Aktiivinen valikko'
b'DocType: Target Detail',b'Target Qty',b'Tavoite yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Shopping Cart Settings',b'Checkout Settings',b'Kassalle Asetukset'
b'DocType: Student Attendance',b'Present',b'Nykyinen'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37',b'Delivery Note {0} must not be submitted',b'L\xc3\xa4hete {0} ei saa olla vahvistettu'
b'DocType: Notification Control',b'Sales Invoice Message',"b'Myyntilasku, viesti'"
b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27',b'Closing Account {0} must be of type Liability / Equity',b'Tilin sulkemisen {0} on oltava tyyppi\xc3\xa4 Vastuu / Oma p\xc3\xa4\xc3\xa4oma'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325',b'Salary Slip of employee {0} already created for time sheet {1}',b'Palkka Slip ty\xc3\xb6ntekij\xc3\xb6iden {0} on jo luotu kellokortti {1}'
b'DocType: Vehicle Log',b'Odometer',b'Matkamittari'
b'DocType: Production Plan Item',b'Ordered Qty',b'tilattu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +744',b'Item {0} is disabled',b'Nimike {0} on poistettu k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'DocType: Stock Settings',b'Stock Frozen Upto',b'varasto j\xc3\xa4\xc3\xa4dytetty asti'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930',b'BOM does not contain any stock item',b'Osaluettelo ei sis\xc3\xa4ll\xc3\xa4 yht\xc3\xa4k\xc3\xa4\xc3\xa4n varastonimikett\xc3\xa4'
b'DocType: Chapter',b'Chapter Head',b'Luvun p\xc3\xa4\xc3\xa4'
b'DocType: Payment Term',b'Month(s) after the end of the invoice month',b'Kuukausi (t) laskutuskuukauden p\xc3\xa4\xc3\xa4ttymisen j\xc3\xa4lkeen'
b'apps/erpnext/erpnext/config/projects.py +24',b'Project activity / task.',b'Teht\xc3\xa4v\xc3\xa4'
b'DocType: Vehicle Log',b'Refuelling Details',b'Tankkaaminen tiedot'
b'apps/erpnext/erpnext/config/hr.py +104',b'Generate Salary Slips',b'Tuota palkkalaskelmat'
b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25',b'Lab result datetime cannot be before testing datetime',b'Lab-tuloksen datetime ei voi olla ennen datetime -testausta'
b'DocType: POS Profile',b'Allow user to edit Discount',b'Salli k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n muokata alennusta'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55',b'Get customers from',b'Hanki asiakkaita'
b'DocType: Purchase Invoice Item',b'Include Exploded Items',b'Sis\xc3\xa4llyt\xc3\xa4 r\xc3\xa4j\xc3\xa4ht\xc3\xa4m\xc3\xa4tt\xc3\xb6mi\xc3\xa4 kohteita'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45',"b'Buying must be checked, if Applicable For is selected as {0}'",b'osto tulee t\xc3\xa4p\xc3\xa4t\xc3\xa4 mik\xc3\xa4lisovellus on valittu {0}:na'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40',b'Discount must be less than 100',b'alennus on oltava alle 100'
b'DocType: Shipping Rule',b'Restrict to Countries',b'Rajoita maihin'
b'DocType: Purchase Invoice',b'Write Off Amount (Company Currency)',b'Kirjoita Off M\xc3\xa4\xc3\xa4r\xc3\xa4 (Yrityksen valuutta)'
b'DocType: Sales Invoice Timesheet',b'Billing Hours',b'Laskutus tuntia'
b'DocType: Project',b'Total Sales Amount (via Sales Order)',b'Myyntim\xc3\xa4\xc3\xa4r\xc3\xa4n kokonaism\xc3\xa4\xc3\xa4r\xc3\xa4 (myyntitilauksen mukaan)'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +548',b'Default BOM for {0} not found',b'Oletus BOM varten {0} ei l\xc3\xb6ytynyt'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +514',b'Row #{0}: Please set reorder quantity',b'Rivi # {0}: Aseta t\xc3\xa4ydennystilauksen yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/public/js/pos/pos.html +20',b'Tap items to add them here',b'Kosketa kohteita lis\xc3\xa4t\xc3\xa4 ne t\xc3\xa4st\xc3\xa4'
b'DocType: Fees',b'Program Enrollment',b'Ohjelma Ilmoittautuminen'
b'DocType: Share Transfer',b'To Folio No',b'Folio nro'
b'DocType: Landed Cost Voucher',b'Landed Cost Voucher',b'Kohdistetut kustannukset'
b'apps/erpnext/erpnext/public/js/queries.js +39',b'Please set {0}',b'Aseta {0}'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} ei ole aktiivinen opiskelija'
b'DocType: Employee',b'Health Details',"b'terveys, lis\xc3\xa4tiedot'"
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'Luoda maksatuspyynt\xc3\xb6 viiteasiakirja tarvitaan'
b'DocType: Soil Texture',b'Sandy Clay',b'Sandy Clay'
b'DocType: Grant Application',b'Assessment  Manager',b'Arviointip\xc3\xa4\xc3\xa4llikk\xc3\xb6'
b'DocType: Payment Entry',b'Allocate Payment Amount',b'Varaa maksusumma'
b'DocType: Employee External Work History',b'Salary',b'Palkka'
b'DocType: Serial No',b'Delivery Document Type',b'Toimitus Dokumenttityyppi'
b'DocType: Sales Order',b'Partly Delivered',b'Osittain toimitettu'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48',b'Item Code &gt; Item Group &gt; Brand',b'Item Code&gt; Item Group&gt; Tuotemerkki'
b'DocType: Item Variant Settings',b'Do not update variants on save',b'\xc3\x84l\xc3\xa4 p\xc3\xa4ivit\xc3\xa4 tallennustilaa'
b'DocType: Email Digest',b'Receivables',b'Saatavat'
b'DocType: Lead Source',b'Lead Source',b'Liidin alkuper\xc3\xa4'
b'DocType: Customer',b'Additional information regarding the customer.',b'Lis\xc3\xa4tietoja asiakas.'
b'DocType: Quality Inspection Reading',b'Reading 5',b'Lukema 5'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236',"b'{0} {1} is associated with {2}, but Party Account is {3}'","b'{0} {1} liittyy {2}, mutta Party-tili on {3}'"
b'apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7',b'View Lab Tests',b'N\xc3\xa4yt\xc3\xa4 laboratoriotestit'
b'DocType: Purchase Invoice',b'Y',b'Y'
b'DocType: Maintenance Visit',b'Maintenance Date',"b'huolto, p\xc3\xa4iv\xc3\xa4'"
b'DocType: Purchase Invoice Item',b'Rejected Serial No',b'Hyl\xc3\xa4tty sarjanumero'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82',b'Year start date or end date is overlapping with {0}. To avoid please set company',b'Vuoden aloitusp\xc3\xa4iv\xc3\xa4 tai lopetusp\xc3\xa4iv\xc3\xa4 on p\xc3\xa4\xc3\xa4llekk\xc3\xa4inen {0}. V\xc3\xa4ltt\xc3\xa4miseksi aseta yritys'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +122',b'Please mention the Lead Name in Lead {0}',b'Mainitse Lead Name Lead {0}'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156',b'Start date should be less than end date for Item {0}',b'aloitusp\xc3\xa4iv\xc3\xa4 tulee olla pienempi kuin p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4 tuotteelle {0}'
b'DocType: Item',"b'Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.'","b'esim ABCD. ##### mik\xc3\xa4li sarjat on m\xc3\xa4\xc3\xa4ritetty ja sarjanumeroa ei ole mainittu toiminnossa, t\xc3\xa4ll\xc3\xb6in automaattinen sarjanumeron teko pohjautuu t\xc3\xa4h\xc3\xa4n sarjaan, mik\xc3\xa4li haluat t\xc3\xa4lle tuotteelle aina nimenomaisen sarjanumeron j\xc3\xa4t\xc3\xa4 t\xc3\xa4m\xc3\xa4 kohta tyhj\xc3\xa4ksi.'"
b'DocType: Upload Attendance',b'Upload Attendance',b'Tuo osallistumistietoja'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +579',b'BOM and Manufacturing Quantity are required',b'BOM ja valmistusm\xc3\xa4\xc3\xa4r\xc3\xa4 tarvitaan'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50',b'Ageing Range 2',b'vanhentumisen skaala 2'
b'DocType: SG Creation Tool Course',b'Max Strength',b'max Strength'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28',b'Installing presets',b'Esiasetusten asennus'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85',b'No Delivery Note selected for Customer {}',b'Ei toimitustiedostoa valittu asiakkaalle {}'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25',b'BOM replaced',b'BOM korvattu'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052',b'Select Items based on Delivery Date',b'Valitse kohteet toimitusp\xc3\xa4iv\xc3\xa4n perusteella'
b'DocType: Grant Application',b'Has any past Grant Record',b'Onko jokin mennyt Grant Record'
,b'Sales Analytics',b'Myyntianalytiikka'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127',b'Available {0}',b'K\xc3\xa4ytett\xc3\xa4viss\xc3\xa4 {0}'
,b'Prospects Engaged But Not Converted',b'N\xc3\xa4kym\xc3\xa4t Kihloissa Mutta ei muunneta'
b'DocType: Manufacturing Settings',b'Manufacturing Settings',b'valmistuksen asetukset'
b'apps/erpnext/erpnext/config/setup.py +56',b'Setting up Email',b'S\xc3\xa4hk\xc3\xb6postin perusm\xc3\xa4\xc3\xa4ritykset'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57',b'Guardian1 Mobile No',b'Guardian1 Mobile Ei'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106',b'Please enter default currency in Company Master',b'Sy\xc3\xb6t\xc3\xa4 oletusvaluutta yritys valvonnassa'
b'DocType: Stock Entry Detail',b'Stock Entry Detail',b'Varastotapahtuman yksityiskohdat'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109',b'Daily Reminders',b'P\xc3\xa4ivitt\xc3\xa4inen Muistutukset'
b'DocType: Products Settings',b'Home Page is Products',b'tuotteiden kotisivu'
,b'Asset Depreciation Ledger',b'Asset Poistot Ledger'
b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91',b'Tax Rule Conflicts with {0}',b'Veros\xc3\xa4\xc3\xa4nt\xc3\xb6 on ristiriidassa kohdan {0} kanssa'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25',b'New Account Name',b'nime\xc3\xa4 uusi tili'
b'DocType: Purchase Invoice Item',b'Raw Materials Supplied Cost',b'Raaka-aine toimitettu kustannus'
b'DocType: Selling Settings',b'Settings for Selling Module',b'Myyntimoduulin asetukset'
b'DocType: Hotel Room Reservation',b'Hotel Room Reservation',b'Hotellihuoneen varaaminen'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115',b'Customer Service',b'Asiakaspalvelu'
b'DocType: BOM',b'Thumbnail',b'Pikkukuva'
b'DocType: Item Customer Detail',b'Item Customer Detail',b'tuote asiakas lis\xc3\xa4tyedot'
b'apps/erpnext/erpnext/config/hr.py +50',b'Offer candidate a Job.',b'Tarjoa ehdokkaalle t\xc3\xb6it\xc3\xa4.'
b'DocType: Notification Control',b'Prompt for Email on Submission of',b'Kysyy S\xc3\xa4hk\xc3\xb6posti esitett\xc3\xa4ess\xc3\xa4'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88',b'Total allocated leaves are more than days in the period',b'Yhteens\xc3\xa4 my\xc3\xb6nnetty lehdet ovat enemm\xc3\xa4n kuin p\xc3\xa4iv\xc3\xa4\xc3\xa4 kaudella'
b'DocType: Land Unit',b'Linked Soil Analysis',b'Linkitetty maaper\xc3\xa4n analyysi'
b'DocType: Pricing Rule',b'Percentage',b'Prosentti'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70',b'Item {0} must be a stock Item',b'Nimike {0} pit\xc3\xa4\xc3\xa4 olla varastonimike'
b'DocType: Manufacturing Settings',b'Default Work In Progress Warehouse',b'Oletus KET-varasto'
b'apps/erpnext/erpnext/config/accounts.py +288',b'Default settings for accounting transactions.',b'kirjanpidon tapahtumien oletusasetukset'
b'DocType: Maintenance Visit',b'MV',b'MV'
b'DocType: Restaurant',b'Default Tax Template',b'Oletusmaksutaulukko'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66',b'{0} Students have been enrolled',b'{0} Opiskelijat on ilmoittautunut'
b'DocType: Fees',b'Student Details',b'Opiskelijan tiedot'
b'DocType: Purchase Invoice Item',b'Stock Qty',b'Stock kpl'
b'DocType: Employee Loan',b'Repayment Period in Months',b'Takaisinmaksuaika kuukausina'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26',b'Error: Not a valid id?',b'virhe: tunnus ei ole kelvollinen'
b'DocType: Naming Series',b'Update Series Number',b'P\xc3\xa4ivit\xc3\xa4 sarjanumerot'
b'DocType: Account',b'Equity',b'oma p\xc3\xa4\xc3\xa4oma'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78',"b""{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry""",b'{0} {1}: &quot;Tuloslaskelma&quot; tyyppi huomioon {2} ei sallita avaaminen Entry'
b'DocType: Sales Order',b'Printing Details',b'Tulostus Lis\xc3\xa4tiedot'
b'DocType: Task',b'Closing Date',b'sulkup\xc3\xa4iv\xc3\xa4'
b'DocType: Sales Order Item',b'Produced Quantity',b'Tuotettu M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Timesheet',b'Work Detail',b'Ty\xc3\xb6n yksityiskohdat'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126',b'Engineer',b'insin\xc3\xb6\xc3\xb6ri'
b'DocType: Journal Entry',b'Total Amount Currency',b'Yhteens\xc3\xa4 M\xc3\xa4\xc3\xa4r\xc3\xa4 Valuutta'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38',b'Search Sub Assemblies',b'haku alikokoonpanot'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171',b'Item Code required at Row No {0}',b'tuotekoodi vaaditaan riville {0}'
b'DocType: GST Account',b'SGST Account',b'SGST-tili'
b'apps/erpnext/erpnext/utilities/user_progress.py +154',b'Go to Items',b'Siirry kohteisiin'
b'DocType: Sales Partner',b'Partner Type',b'Kumppani tyyppi'
b'DocType: Purchase Taxes and Charges',b'Actual',b'kiinte\xc3\xa4 m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Restaurant Menu',b'Restaurant Manager',b'Ravintolap\xc3\xa4\xc3\xa4llikk\xc3\xb6'
b'DocType: Authorization Rule',b'Customerwise Discount',b'asiakaskohtainen alennus'
b'apps/erpnext/erpnext/config/projects.py +46',b'Timesheet for tasks.',b'Teht\xc3\xa4vien tuntilomake.'
b'DocType: Purchase Invoice',b'Against Expense Account',b'Kustannustilin kohdistus'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282',b'Installation Note {0} has already been submitted',b'Asennustosite {0} on jo vahvistettu'
b'DocType: Bank Reconciliation',b'Get Payment Entries',b'Get Payment Merkinn\xc3\xa4t'
b'DocType: Quotation Item',b'Against Docname',b'Dokumentin nimi kohdistus'
b'DocType: SMS Center',b'All Employee (Active)',b'kaikki ty\xc3\xb6ntekij\xc3\xa4t (aktiiviset)'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9',b'View Now',b'N\xc3\xa4yt\xc3\xa4 nyt'
b'DocType: BOM',b'Raw Material Cost',b'Raaka-ainekustannukset'
b'DocType: Item Reorder',b'Re-Order Level',b'T\xc3\xa4ydennystilaustaso'
b'apps/erpnext/erpnext/projects/doctype/project/project.js +54',b'Gantt Chart',b'gantt kaavio'
b'DocType: Crop Cycle',b'Cycle Type',b'Syklityyppi'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99',b'Part-time',b'Osa-aikainen'
b'DocType: Employee',b'Applicable Holiday List',b'sovellettava lomalista'
b'DocType: Employee',b'Cheque',b'takaus/shekki'
b'DocType: Training Event',b'Employee Emails',b'Ty\xc3\xb6ntekij\xc3\xa4n s\xc3\xa4hk\xc3\xb6postit'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60',b'Series Updated',b'Sarja p\xc3\xa4ivitetty'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +159',b'Report Type is mandatory',b'raportin tyyppi vaaditaan'
b'DocType: Item',b'Serial Number Series',b'Sarjanumero sarjat'
b'apps/erpnext/erpnext/buying/utils.py +68',b'Warehouse is mandatory for stock Item {0} in row {1}',b'Varasto vaaditaan varastotuotteelle {0} rivill\xc3\xa4 {1}'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45',b'Retail & Wholesale',b'V\xc3\xa4hitt\xc3\xa4ismyynti &amp; Tukkukauppa'
b'DocType: Issue',b'First Responded On',b'Ensimm\xc3\xa4iset vastaavat'
b'DocType: Website Item Group',b'Cross Listing of Item in multiple groups',b'ristiluettelo tuotteille jotka on useammissa ryhmiss\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90',b'Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}',b'Tilikauden alkamisp\xc3\xa4iv\xc3\xa4 ja tilikauden p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4 on asetettu tilikaudelle {0}'
b'DocType: Projects Settings',b'Ignore User Time Overlap',b'Ohita k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n aika p\xc3\xa4\xc3\xa4llekk\xc3\xa4isyys'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113',b'Clearance Date updated',b'Tilitysp\xc3\xa4iv\xc3\xa4 p\xc3\xa4ivitetty'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Er\xc3\xa4'
b'DocType: Stock Settings',b'Batch Identification',b'Er\xc3\xa4tunnistus'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132',b'Successfully Reconciled',b'onnistuneesti t\xc3\xa4sm\xc3\xa4ytetty'
b'DocType: Request for Quotation Supplier',b'Download PDF',b'Lataa PDF'
b'DocType: Work Order',b'Planned End Date',b'Suunniteltu p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Shareholder',b'Hidden list maintaining the list of contacts linked to Shareholder',"b'Piilotettu luettelo, joka yll\xc3\xa4pit\xc3\xa4\xc3\xa4 Osakkeenomistajan yhteystietoja'"
b'apps/erpnext/erpnext/config/non_profit.py +63',b'Donor Type information.',b'Luovutustyypin tiedot.'
b'DocType: Request for Quotation',b'Supplier Detail',b'Toimittaja Detail'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100',b'Error in formula or condition: {0}',b'Virhe kaavassa tai tila: {0}'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +99',b'Invoiced Amount',b'laskutettu'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47',b'Criteria weights must add up to 100%',b'Kriteerien painojen on oltava jopa 100%'
b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7',b'Attendance',b'osallistuminen'
b'apps/erpnext/erpnext/public/js/pos/pos.html +115',b'Stock Items',b'varastosta l\xc3\xb6ytyv\xc3\xa4t'
b'DocType: BOM',b'Materials',b'Materiaalit'
b'DocType: Leave Block List',"b'If not checked, the list will have to be added to each Department where it has to be applied.'","b'ellei ole t\xc3\xa4p\xc3\xa4ttyn\xc3\xa4 luettelo on lis\xc3\xa4tt\xc3\xa4v\xc3\xa4 jokaiseen osastoon, jossa sit\xc3\xa4 sovelletaan'"
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111',b'Creating {0}',b'{0}'
b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28',b'Source and Target Warehouse cannot be same',b'Source ja Target Varasto voi olla sama'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586',b'Posting date and posting time is mandatory',b'L\xc3\xa4hett\xc3\xa4mist\xc3\xa4 p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4 ja l\xc3\xa4hett\xc3\xa4mist\xc3\xa4 aika on pakollista'
b'apps/erpnext/erpnext/config/buying.py +76',b'Tax template for buying transactions.',b'Ostotapahtumien veromallipohja.'
,b'Item Prices',b'Tuotehinnat'
b'DocType: Purchase Order',b'In Words will be visible once you save the Purchase Order.',"b'sanat n\xc3\xa4kyv\xc3\xa4t, kun tallennat ostotilauksen'"
b'DocType: Period Closing Voucher',b'Period Closing Voucher',b'Kauden sulkutosite'
b'DocType: Consultation',b'Review Details',b'Tarkastele tietoja'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185',b'The shareholder does not belong to this company',b'Osakkeenomistaja ei kuulu t\xc3\xa4h\xc3\xa4n yhti\xc3\xb6\xc3\xb6n'
b'DocType: Dosage Form',b'Dosage Form',b'Annostuslomake'
b'apps/erpnext/erpnext/config/selling.py +67',b'Price List master.',b'Hinnasto valvonta.'
b'DocType: Task',b'Review Date',b'Review Date'
b'DocType: Company',b'Series for Asset Depreciation Entry (Journal Entry)',b'K\xc3\xa4ytt\xc3\xb6omaisuuden poistojen sarja (p\xc3\xa4iv\xc3\xa4kirja)'
b'DocType: Membership',b'Member Since',b'J\xc3\xa4sen vuodesta'
b'DocType: Purchase Invoice',b'Advance Payments',b'Ennakkomaksut'
b'DocType: Purchase Taxes and Charges',b'On Net Total',b'nettosummasta'
b'apps/erpnext/erpnext/controllers/item_variant.py +92',b'Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}',b'Attribuutin arvo {0} on oltava alueella {1} ja {2} ja lis\xc3\xa4yksin {3} kohteelle {4}'
b'DocType: Restaurant Reservation',b'Waitlisted',b'Jonossa'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +124',b'Currency can not be changed after making entries using some other currency',b'Valuuttaa ei voi muuttaa sen j\xc3\xa4lkeen kun kirjauksia on jo tehty jossain toisessa valuutassa.'
b'DocType: Shipping Rule',b'Fixed',b'kiinte\xc3\xa4'
b'DocType: Vehicle Service',b'Clutch Plate',b'kytkin Plate'
b'DocType: Company',b'Round Off Account',b'py\xc3\xb6ristys tili'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93',b'Administrative Expenses',b'Hallinnolliset kustannukset'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18',b'Consulting',b'konsultointi'
b'DocType: Customer Group',b'Parent Customer Group',b'P\xc3\xa4\xc3\xa4asiakasryhm\xc3\xa4'
b'DocType: Journal Entry',b'Subscription',b'tilaus'
b'DocType: Purchase Invoice',b'Contact Email',"b'yhteystiedot, s\xc3\xa4hk\xc3\xb6posti'"
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11',b'Fee Creation Pending',b'Maksun luominen vireill\xc3\xa4'
b'DocType: Appraisal Goal',b'Score Earned',b'Ansaitut pisteet'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241',b'Notice Period',b'Irtisanomisaika'
b'DocType: Asset Category',b'Asset Category Name',b'Asset Luokan nimi'
b'apps/erpnext/erpnext/setup/doctype/territory/territory.js +13',b'This is a root territory and cannot be edited.',b'T\xc3\xa4m\xc3\xa4 on kanta-alue eik\xc3\xa4 sit\xc3\xa4 voi muokata'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5',b'New Sales Person Name',b'New Sales Person Name'
b'DocType: Packing Slip',b'Gross Weight UOM',b'bruttopaino UOM'
b'DocType: Asset Maintenance Task',b'Preventive Maintenance',b'Ennakkohuolto'
b'DocType: Delivery Note Item',b'Against Sales Invoice',b'myyntilaskun kohdistus'
b'DocType: Purchase Invoice',b'07-Others',b'07-Muut'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151',b'Please enter serial numbers for serialized item ',b'Anna sarjanumeroita serialized er\xc3\xa4'
b'DocType: Bin',b'Reserved Qty for Production',b'Varattu M\xc3\xa4\xc3\xa4r\xc3\xa4 for Production'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureNum',b'EcritureNum'
b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. """,b'J\xc3\xa4t\xc3\xa4 valitsematta jos et halua pohtia er\xc3\xa4n samalla tietenkin toimiviin ryhmiin.'
b'DocType: Asset',b'Frequency of Depreciation (Months)',b'Taajuus Poistot (kuukautta)'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500',b'Credit Account',b'Luottotili'
b'DocType: Landed Cost Item',b'Landed Cost Item',"b'Kohdistetut kustannukset, tuote'"
b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57',b'Show zero values',b'N\xc3\xa4yt\xc3\xa4 nolla-arvot'
b'DocType: BOM',b'Quantity of item obtained after manufacturing / repacking from given quantities of raw materials',b'Tuotem\xc3\xa4\xc3\xa4r\xc3\xa4arvio valmistuksen- / uudelleenpakkauksen j\xc3\xa4lkeen annetuista raaka-aineen m\xc3\xa4\xc3\xa4rist\xc3\xa4'
b'DocType: Lab Test',b'Test Group',b'Testiryhm\xc3\xa4'
b'DocType: Payment Reconciliation',b'Receivable / Payable Account',b'Saatava / maksettava tili'
b'DocType: Delivery Note Item',b'Against Sales Order Item',b'Myyntitilauksen kohdistus / nimike'
b'DocType: Company',b'Company Logo',b'Yrityksen logo'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +709',b'Please specify Attribute Value for attribute {0}',b'Ilmoitathan Taito Vastinetta m\xc3\xa4\xc3\xa4rite {0}'
b'DocType: Item',b'Default Warehouse',b'oletus varasto'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45',b'Budget cannot be assigned against Group Account {0}',b'budjettia ei voi nimet\xc3\xa4 ryhm\xc3\xa4tiliin {0}'
b'DocType: Healthcare Settings',b'Patient Registration',b'Potilaan rekister\xc3\xb6inti'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22',b'Please enter parent cost center',b'Sy\xc3\xb6t\xc3\xa4 p\xc3\xa4\xc3\xa4kustannuspaikka'
b'DocType: Delivery Note',b'Print Without Amount',b'Tulosta ilman arvom\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57',b'Depreciation Date',b'Poistot Date'
,b'Work Orders in Progress',b'Ty\xc3\xb6j\xc3\xa4rjestykset ovat k\xc3\xa4ynniss\xc3\xa4'
b'DocType: Issue',b'Support Team',b'Tukitiimi'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36',b'Expiry (In Days)',b'P\xc3\xa4\xc3\xa4ttymisest\xc3\xa4 (p\xc3\xa4ivin\xc3\xa4)'
b'DocType: Appraisal',b'Total Score (Out of 5)',b'osumat (5:st\xc3\xa4) yhteens\xc3\xa4'
b'DocType: Fee Structure',b'FS.',b'FS.'
b'DocType: Student Attendance Tool',b'Batch',b'Er\xc3\xa4'
b'DocType: Donor',b'Donor Type',b'Luovuttajan tyyppi'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +27',b'Balance',b'tase'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66',b'Please select the Company',b'Valitse yritys'
b'DocType: Room',b'Seating Capacity',b'Istumapaikkoja'
b'DocType: Issue',b'ISS-',b'ISS-'
b'DocType: Lab Test Groups',b'Lab Test Groups',b'Lab testiryhm\xc3\xa4t'
b'DocType: Project',b'Total Expense Claim (via Expense Claims)',b'Kulukorvaus yhteens\xc3\xa4 (kulukorvauksesta)'
b'DocType: GST Settings',b'GST Summary',b'GST Yhteenveto'
b'apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16',b'Please enable default incoming account before creating Daily Work Summary Group',b'Ota k\xc3\xa4ytt\xc3\xb6\xc3\xb6n oletusarvoinen saapuva tili ennen p\xc3\xa4ivitt\xc3\xa4isen ty\xc3\xb6yhteenvetoryhm\xc3\xa4n luomista'
b'DocType: Assessment Result',b'Total Score',b'Kokonaispisteet'
b'DocType: Journal Entry',b'Debit Note',b'debet viesti'
b'DocType: Stock Entry',b'As per Stock UOM',b'Varastoyksik\xc3\xb6ss\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7',b'Not Expired',b'ei vanhentunut'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49',b'ValidDate',b'Kelvollinen p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Student Log',b'Achievement',b'Saavutus'
b'DocType: Batch',b'Source Document Type',b'L\xc3\xa4hde Asiakirjan tyyppi'
b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24',b'Following course schedules were created',b'Seuraavat kurssisuunnitelmat luotiin'
b'DocType: Journal Entry',b'Total Debit',b'Debet yhteens\xc3\xa4'
b'DocType: Manufacturing Settings',b'Default Finished Goods Warehouse',b'Valmiiden tavaroiden oletusvarasto'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108',b'Please select Patient',b'Valitse potilas'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76',b'Sales Person',b'Myyj\xc3\xa4'
b'DocType: Hotel Room Package',b'Amenities',b'palveluihin'
b'apps/erpnext/erpnext/config/accounts.py +233',b'Budget and Cost Center',b'Talousarvio ja kustannuspaikka'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65',b'Multiple default mode of payment is not allowed',b'Useita oletusmaksutapoja ei sallita'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',b'for the',b'varten'
,b'Appointment Analytics',b'Nimitys Analytics'
b'DocType: Vehicle Service',b'Half Yearly',b'6 kk'
b'DocType: Lead',b'Blog Subscriber',b'Blogin tilaaja'
b'DocType: Guardian',b'Alternate Number',b'vaihtoehtoinen Number'
b'DocType: Healthcare Settings',b'Consultations in valid days',b'Kuulemiset kelvollisina p\xc3\xa4ivin\xc3\xa4'
b'DocType: Assessment Plan Criteria',b'Maximum Score',b'maksimipistem\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/config/setup.py +83',b'Create rules to restrict transactions based on values.',b'tee tapahtumien arvoon perustuvia rajoituss\xc3\xa4\xc3\xa4nt\xc3\xb6j\xc3\xa4'
b'DocType: Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts',b'Rahavirtojen kartoitustilej\xc3\xa4'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49',b' Group Roll No',b'Ryhm\xc3\xa4 Roll Ei'
b'DocType: Batch',b'Manufacturing Date',b'Valmistusp\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9',b'Fee Creation Failed',b'Maksun luominen ep\xc3\xa4onnistui'
b'DocType: Opening Invoice Creation Tool',b'Create Missing Party',b'Luo puuttuva puolue'
b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',b'J\xc3\xa4t\xc3\xa4 tyhj\xc3\xa4ksi jos teet opiskelijoiden ryhm\xc3\xa4\xc3\xa4 vuodessa'
b'DocType: HR Settings',"b'If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day'",b't\xc3\xa4p\xc3\xa4tt\xc3\xa4ess\xc3\xa4 lomap\xc3\xa4iv\xc3\xa4t sis\xc3\xa4ltyv\xc3\xa4t ty\xc3\xb6p\xc3\xa4iviin ja t\xc3\xa4m\xc3\xa4 lis\xc3\xa4\xc3\xa4 palkan avoa / p\xc3\xa4iv\xc3\xa4'
b'DocType: Purchase Invoice',b'Total Advance',"b'Yhteens\xc3\xa4, ennakko'"
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27',b'Change Template Code',b'Muuta mallikoodia'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23',b'The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.',b'Term P\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4 ei voi olla aikaisempi kuin Term aloitusp\xc3\xa4iv\xc3\xa4. Korjaa p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4t ja yrit\xc3\xa4 uudelleen.'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'quot Count'
,b'BOM Stock Report',b'BOM Stock Report'
b'DocType: Stock Reconciliation Item',b'Quantity Difference',b'M\xc3\xa4\xc3\xa4r\xc3\xa4 ero'
b'DocType: Employee Advance',b'EA-',b'EA-'
b'DocType: Opportunity Item',b'Basic Rate',b'perushinta'
b'DocType: GL Entry',b'Credit Amount',b'Luoton m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Cheque Print Template',b'Signatory Position',b'Allekirjoittaja Position'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173',b'Set as Lost',b'Aseta kadonneeksi'
b'DocType: Timesheet',b'Total Billable Hours',b'Yhteens\xc3\xa4 laskutettavat tunnit'
b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4',b'Payment Receipt Note',b'Maksukuitin Huomautus'
b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6',b'This is based on transactions against this Customer. See timeline below for details',b'T\xc3\xa4m\xc3\xa4 perustuu asiakasta koskeviin tapahtumiin. Katso lis\xc3\xa4tietoja ao. aikajanalta'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162',b'Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2}',b'Rivi {0}: My\xc3\xb6nnetyn {1} on oltava pienempi tai yht\xc3\xa4 suuri kuin Payment Entry m\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4n {2}'
b'DocType: Program Enrollment Tool',b'New Academic Term',b'Uusi akateeminen termi'
,b'Course wise Assessment Report',b'Tietenkin viisasta arviointiraportti'
b'DocType: Purchase Invoice',b'Availed ITC State/UT Tax',b'K\xc3\xa4ytti ITC-valtion / UT-veroa'
b'DocType: Tax Rule',b'Tax Rule',b'Veros\xc3\xa4\xc3\xa4nt\xc3\xb6\xc3\xb6n'
b'DocType: Selling Settings',b'Maintain Same Rate Throughout Sales Cycle',b'yll\xc3\xa4pid\xc3\xa4 samaa tasoa l\xc3\xa4pi myyntisyklin'
b'DocType: Manufacturing Settings',b'Plan time logs outside Workstation Working Hours.',b'Suunnittele aikaa lokit ulkopuolella Workstation ty\xc3\xb6aikalain.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115',b'Dr {0} does not have a Physician Schedule. Add it in Physician master',b'Dr {0}: lla ei ole l\xc3\xa4\xc3\xa4k\xc3\xa4rin ajoitusta. Lis\xc3\xa4\xc3\xa4 se Physician masteriin'
b'apps/erpnext/erpnext/public/js/pos/pos.html +98',b'Customers in Queue',b'Asiakkaat jonossa'
b'DocType: Driver',b'Issuing Date',b'Julkaisup\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Student',b'Nationality',b'kansalaisuus'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109',b'Submit this Work Order for further processing.',b'L\xc3\xa4het\xc3\xa4 t\xc3\xa4m\xc3\xa4 ty\xc3\xb6j\xc3\xa4rjestys jatkok\xc3\xa4sittely\xc3\xa4 varten.'
,b'Items To Be Requested',b'Nimiketarpeet'
b'DocType: Purchase Order',b'Get Last Purchase Rate',b'k\xc3\xa4yt\xc3\xa4 viimeisimm\xc3\xa4n edellisen oston hintoja'
b'DocType: Company',b'Company Info',b'yrityksen tiedot'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1385',b'Select or add new customer',b'Valitse tai lis\xc3\xa4t\xc3\xa4 uuden asiakkaan'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173',b'Cost center is required to book an expense claim',b'Kustannuspaikkaa vaaditaan varata kulukorvauslasku'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9',b'Application of Funds (Assets)',b'sovellus varat (vastaavat)'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6',b'This is based on the attendance of this Employee',b'T\xc3\xa4m\xc3\xa4 perustuu ty\xc3\xb6ntekij\xc3\xa4n l\xc3\xa4sn\xc3\xa4oloihin'
b'DocType: Assessment Result',b'Summary',b'Yhteenveto'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112',b'Mark Attendance',b'Merkitse osallistuminen'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494',b'Debit Account',b'Luottotililt\xc3\xa4'
b'DocType: Fiscal Year',b'Year Start Date',b'Vuoden aloitusp\xc3\xa4iv\xc3\xa4'
b'DocType: Attendance',b'Employee Name',b'ty\xc3\xb6ntekij\xc3\xa4n nimi'
b'DocType: Restaurant Order Entry Item',b'Restaurant Order Entry Item',b'Ravintola Tilaus Entry Item'
b'DocType: Purchase Invoice',b'Rounded Total (Company Currency)',b'py\xc3\xb6ristys yhteens\xc3\xa4 (yrityksen  valuutta)'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +96',b'Cannot covert to Group because Account Type is selected.',b'ei voi k\xc3\xa4\xc3\xa4nt\xc3\xa4\xc3\xa4 ryhmiin sill\xc3\xa4 tilin tyyppi on valittu'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260',b'{0} {1} has been modified. Please refresh.',b'{0} {1} on muuttunut. Lataa uudelleen.'
b'DocType: Leave Block List',b'Stop users from making Leave Applications on following days.',b'est\xc3\xa4 k\xc3\xa4ytt\xc3\xa4ji\xc3\xa4 tekem\xc3\xa4st\xc3\xa4 poistumissovelluksia seuraavina p\xc3\xa4ivin\xc3\xa4'
b'DocType: Asset Maintenance Team',b'Maintenance Team Members',b'Huoltoryhm\xc3\xa4n j\xc3\xa4senet'
b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63',b'Purchase Amount',b'Osto M\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261',b'Supplier Quotation {0} created',b'Toimittaja noteeraus {0} luotu'
b'apps/erpnext/erpnext/accounts/report/financial_statements.py +103',b'End Year cannot be before Start Year',b'Loppu vuosi voi olla ennen Aloitusvuosi'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234',b'Employee Benefits',b'ty\xc3\xb6ntekij\xc3\xa4 etuudet'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264',b'Packed quantity must equal quantity for Item {0} in row {1}',b'Pakattujen m\xc3\xa4\xc3\xa4r\xc3\xa4 tulee olla kuin tuotteen {0} m\xc3\xa4\xc3\xa4r\xc3\xa4 rivill\xc3\xa4 {1}'
b'DocType: Work Order',b'Manufactured Qty',b'valmistettu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78',"b""The shares don't exist with the {0}""",b'Osuuksia ei ole {0}'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64',b'Invoice Created',b'Lasku luotu'
b'DocType: Asset',b'Out of Order',b'Ep\xc3\xa4kunnossa'
b'DocType: Purchase Receipt Item',b'Accepted Quantity',b'hyv\xc3\xa4ksytyt m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Projects Settings',b'Ignore Workstation Time Overlap',b'Ohita ty\xc3\xb6aseman ajan p\xc3\xa4\xc3\xa4llekk\xc3\xa4isyys'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +242',b'Please set a default Holiday List for Employee {0} or Company {1}',b'Aseta oletus Holiday List Ty\xc3\xb6ntekij\xc3\xa4 {0} tai Company {1}'
b'apps/erpnext/erpnext/accounts/party.py +30',b'{0}: {1} does not exists',b'{0}: {1} ei l\xc3\xb6ydy'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76',b'Select Batch Numbers',b'Valitse er\xc3\xa4numerot'
b'apps/erpnext/erpnext/config/accounts.py +12',b'Bills raised to Customers.',b'Laskut nostetaan asiakkaille.'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Project Id',b'Projekti Id'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534',b'Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}',b'Kulukorvauksen {1} rivill\xc3\xa4 {0}: m\xc3\xa4\xc3\xa4r\xc3\xa4 ei voi olla suurempi kuin j\xc3\xa4ljell\xc3\xa4 oleva m\xc3\xa4\xc3\xa4r\xc3\xa4 ({2}).'
b'DocType: Patient Service Unit',b'Medical Administrator',b'L\xc3\xa4\xc3\xa4ketieteellinen p\xc3\xa4\xc3\xa4llikk\xc3\xb6'
b'DocType: Assessment Plan',b'Schedule',b'Aikataulu'
b'DocType: Account',b'Parent Account',b'P\xc3\xa4\xc3\xa4tili'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266',b'Available',b'saatavissa'
b'DocType: Quality Inspection Reading',b'Reading 3',b'Lukema 3'
b'DocType: Stock Entry',b'Source Warehouse Address',b'L\xc3\xa4hdealueen osoite'
,b'Hub',b'hubi'
b'DocType: GL Entry',b'Voucher Type',b'Tositetyyppi'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1717',b'Price List not found or disabled',b'Hinnastoa ei l\xc3\xb6ydy tai se on poistettu k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'DocType: Student Applicant',b'Approved',b'hyv\xc3\xa4ksytty'
b'apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15',b'Price',b'Hinta'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267',"b""Employee relieved on {0} must be set as 'Left'""","b'ty\xc3\xb6ntekij\xc3\xa4 vapautettu {0} tulee asettaa ""vasemmalla""'"
b'DocType: Hub Settings',b'Last Sync On',b'Viimeisin synkronointi p\xc3\xa4\xc3\xa4ll\xc3\xa4'
b'DocType: Guardian',b'Guardian',b'holhooja'
b'DocType: Opening Invoice Creation Tool',b'Create missing customer or supplier.',b'Luo puuttuva asiakas tai toimittaja.'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42',b'Appraisal {0} created for Employee {1} in the given date range',b'ty\xc3\xb6ntekij\xc3\xa4lle {1} on tehty arviointi {0} ilmoitettuna p\xc3\xa4iv\xc3\xa4n\xc3\xa4'
b'DocType: Academic Term',b'Education',b'koulutus'
b'apps/erpnext/erpnext/public/js/pos/pos.html +89',b'Del',b'del'
b'DocType: Selling Settings',b'Campaign Naming By',b'kampanja nimennyt'
b'DocType: Employee',b'Current Address Is',b'nykyinen osoite on'
b'apps/erpnext/erpnext/utilities/user_progress.py +51',b'Monthly Sales Target (',b'Kuukausittainen myyntiketju ('
b'DocType: Physician Service Unit Schedule',b'Physician Service Unit Schedule',b'L\xc3\xa4\xc3\xa4k\xc3\xa4rin huoltopalvelun aikataulu'
b'apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9',b'modified',b'muokattu'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43',"b""Optional. Sets company's default currency, if not specified.""","b'Vapaaehtoinen. Asettaa yhti\xc3\xb6n oletusvaluuttaa, jos ei ole m\xc3\xa4\xc3\xa4ritelty.'"
b'DocType: Sales Invoice',b'Customer GSTIN',b'Asiakas GSTIN'
b'DocType: Crop Cycle',"b""List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ""","b'Luettelo kent\xc3\xa4ll\xc3\xa4 havaituista taudeista. Kun se valitaan, se lis\xc3\xa4\xc3\xa4 automaattisesti teht\xc3\xa4v\xc3\xa4luettelon taudin hoitamiseksi'"
b'DocType: Asset Repair',b'Repair Status',b'Korjaustila'
b'apps/erpnext/erpnext/config/accounts.py +67',b'Accounting journal entries.',"b'kirjanpito, p\xc3\xa4iv\xc3\xa4kirjakirjaukset'"
b'DocType: Delivery Note Item',b'Available Qty at From Warehouse',b'Available Kpl at varastosta'
b'DocType: POS Profile',b'Account for Change Amount',b'Vaihtotilin summa'
b'DocType: Purchase Invoice',b'input service',b'sy\xc3\xb6tt\xc3\xb6palvelu'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217',b'Row {0}: Party / Account does not match with {1} / {2} in {3} {4}',b'Rivi {0}: Party / Tili ei vastaa {1} / {2} ja {3} {4}'
b'DocType: Maintenance Team Member',b'Maintenance Team Member',b'Huoltoryhm\xc3\xa4n j\xc3\xa4sen'
b'DocType: Agriculture Analysis Criteria',b'Soil Analysis',b'Maaper\xc3\xa4n analyysi'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13',b'Course Code: ',b'Kurssikoodi:'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240',b'Please enter Expense Account',b'Sy\xc3\xb6t\xc3\xa4 kustannustili'
b'DocType: Account',b'Stock',b'Varasto'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095',"b'Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry'","b'Rivi # {0}: Reference Document Type on yksi Ostotilaus, Ostolasku tai P\xc3\xa4iv\xc3\xa4kirjakirjaus'"
b'DocType: Employee',b'Current Address',b'nykyinen osoite'
b'DocType: Item',"b'If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified'","b'mik\xc3\xa4li tuote on toisen tuotteen malli tulee tuotteen kuvaus, kuva, hinnoittelu, verot ja muut tiedot oletuksena mallipohjasta ellei oletusta ole erikseen poistettu'"
b'DocType: Serial No',b'Purchase / Manufacture Details',b'Oston/valmistuksen lis\xc3\xa4tiedot'
b'DocType: Assessment Group',b'Assessment Group',b'Assessment Group'
b'apps/erpnext/erpnext/config/stock.py +329',b'Batch Inventory',b'Varastoer\xc3\xa4t'
b'DocType: Employee',b'Contract End Date',b'sopimuksen p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Sales Order',b'Track this Sales Order against any Project',b'seuraa t\xc3\xa4t\xc3\xa4 myyntitilausta projektissa'
b'DocType: Sales Invoice Item',b'Discount and Margin',b'Alennus ja marginaali'
b'DocType: Lab Test',b'Prescription',b'Resepti'
b'DocType: Project',b'Second Email',b'Toinen s\xc3\xa4hk\xc3\xb6posti'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111',b'Not Available',b'ei saatavilla'
b'DocType: Pricing Rule',b'Min Qty',b'min yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36',b'Disable Template',b'Poista mallipohja k\xc3\xa4yt\xc3\xb6st\xc3\xa4'
b'DocType: GL Entry',b'Transaction Date',b'tapahtuma p\xc3\xa4iv\xc3\xa4'
b'DocType: Production Plan Item',b'Planned Qty',b'suunniteltu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121',b'Total Tax',b'verot yhteens\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204',b'For Quantity (Manufactured Qty) is mandatory',b'yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4\xc3\xa4n (valmistettu yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4) vaaditaan'
b'DocType: Stock Entry',b'Default Target Warehouse',b'Varastoon (oletus)'
b'DocType: Purchase Invoice',b'Net Total (Company Currency)',b'netto yhteens\xc3\xa4 (yrityksen valuutta)'
b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14',b'The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.',b'Teemavuosi Lopetusp\xc3\xa4iv\xc3\xa4 ei voi olla aikaisempi kuin vuosi aloitusp\xc3\xa4iv\xc3\xa4. Korjaa p\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4t ja yrit\xc3\xa4 uudelleen.'
b'DocType: Notification Control',b'Purchase Receipt Message',b'Saapumistositteen viesti'
b'DocType: BOM',b'Scrap Items',b'romu kohteet'
b'DocType: Work Order',b'Actual Start Date',b'todellinen aloitusp\xc3\xa4iv\xc3\xa4'
b'DocType: Sales Order',b'% of materials delivered against this Sales Order',b'% myyntitilauksen materiaaleista toimitettu'
b'apps/erpnext/erpnext/config/manufacturing.py +18',b'Generate Material Requests (MRP) and Work Orders.',b'Luo materiaalipyynt\xc3\xb6j\xc3\xa4 (MRP) ja ty\xc3\xb6j\xc3\xa4rjestys.'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62',b'Set default mode of payment',b'Aseta oletusmoodi'
b'DocType: Grant Application',b'Withdrawn',b'peruutettu'
b'DocType: Hub Settings',b'Hub Settings',b'hubi asetukset'
b'DocType: Project',b'Gross Margin %',b'bruttokate %'
b'DocType: BOM',b'With Operations',b'Toiminnoilla'
b'apps/erpnext/erpnext/accounts/party.py +259',b'Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.',b'Kirjaukset on jo tehty valuutassa {0} yhti\xc3\xb6n {1}. Valitse saamisen tai maksettava tilille valuutta {0}.'
b'DocType: Asset',b'Is Existing Asset',b'Onko Olemassa Asset'
b'DocType: Salary Detail',b'Statistical Component',b'tilastollinen Komponentti'
b'DocType: Warranty Claim',b'If different than customer address',b'mik\xc3\xa4li eri kuin asiakkan osoite'
b'DocType: Purchase Invoice',b'Without Payment of Tax',b'Ilman veroa'
b'DocType: BOM Operation',b'BOM Operation',b'BOM k\xc3\xa4ytt\xc3\xb6'
b'apps/erpnext/erpnext/config/stock.py +141',b'Fulfilment',b't\xc3\xa4yttymys'
b'DocType: Purchase Taxes and Charges',b'On Previous Row Amount',b'Edellisen rivin arvom\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Item',b'Has Expiry Date',b'On vanhentunut'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +282',b'Transfer Asset',b'siirto Asset'
b'DocType: POS Profile',b'POS Profile',b'POS Profile'
b'DocType: Training Event',b'Event Name',b'Tapahtuman nimi'
b'DocType: Physician',b'Phone (Office)',b'Puhelin (toimisto)'
b'apps/erpnext/erpnext/hooks.py +151',b'Admission',b'sis\xc3\xa4\xc3\xa4np\xc3\xa4\xc3\xa4sy'
b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29',b'Admissions for {0}',b'Teatterikatsojam\xc3\xa4\xc3\xa4riin {0}'
b'apps/erpnext/erpnext/config/accounts.py +257',"b'Seasonality for setting budgets, targets etc.'","b'kausivaihtelu asetukset esim, budjettiin, tavoitteisiin jne'"
b'DocType: Supplier Scorecard Scoring Variable',b'Variable Name',b'Muuttujan nimi'
b'apps/erpnext/erpnext/stock/get_item_details.py +144',"b'Item {0} is a template, please select one of its variants'","b'Nimike {0} on mallipohja, valitse yksi sen variaatioista'"
b'DocType: Asset',b'Asset Category',b'Asset Luokka'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31',b'Net pay cannot be negative',b'Nettomaksu ei voi olla negatiivinen'
b'DocType: Purchase Order',b'Advance Paid',b'Ennakkoon maksettu'
b'DocType: Item',b'Item Tax',b'Tuotteen vero'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883',b'Material to Supplier',b'Materiaali toimittajalle'
b'DocType: Soil Texture',b'Loamy Sand',b'Loamy Sand'
b'DocType: Production Plan',b'Material Request Planning',b'Materiaalin pyynn\xc3\xb6n suunnittelu'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +638',b'Excise Invoice',b'Valmistevero Lasku'
b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16',b'Treshold {0}% appears more than once',b'Kynnys {0}% esiintyy useammin kuin kerran'
b'DocType: Expense Claim',b'Employees Email Id',b'ty\xc3\xb6ntekij\xc3\xa4n s\xc3\xa4hk\xc3\xb6postiosoite'
b'DocType: Employee Attendance Tool',b'Marked Attendance',b'Merkitty L\xc3\xa4sn\xc3\xa4olo'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138',b'Current Liabilities',b'lyhytaikaiset vastattavat'
b'apps/erpnext/erpnext/config/selling.py +297',b'Send mass SMS to your contacts',b'L\xc3\xa4het\xc3\xa4 massatekstiviesti yhteystiedoillesi'
b'DocType: Patient',b'A Positive',b'Positiivinen'
b'DocType: Program',b'Program Name',b'Ohjelman nimi'
b'DocType: Purchase Taxes and Charges',b'Consider Tax or Charge for',b'pidet\xc3\xa4\xc3\xa4n veroille tai maksuille'
b'DocType: Driver',b'Driving License Category',b'Ajokorttiluokka'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158',b'No Reference',b'Ei viitett\xc3\xa4'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57',b'Actual Qty is mandatory',b'todellinen yksikk\xc3\xb6m\xc3\xa4\xc3\xa4r\xc3\xa4 on pakollinen arvo'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',"b'{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.'","b'{0} on t\xc3\xa4ll\xc3\xa4 hetkell\xc3\xa4 {1} toimittajan tuloskortin seisominen, ja t\xc3\xa4m\xc3\xa4n toimittajan antamat ostotilaukset tulisi antaa varoen.'"
b'DocType: Asset Maintenance Team',b'Asset Maintenance Team',b'Omaisuudenhoitoyhti\xc3\xb6'
b'DocType: Employee Loan',b'Loan Type',b'laina Tyyppi'
b'DocType: Scheduling Tool',b'Scheduling Tool',b'Ajoitusty\xc3\xb6kalun'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180',b'Credit Card',b'luottokortti'
b'DocType: BOM',b'Item to be manufactured or repacked',b'tuote joka valmistetaan- tai pakataan uudelleen'
b'DocType: Employee Education',b'Major/Optional Subjects',b'Major / Vapaaehtoinen Aiheet'
b'DocType: Sales Invoice Item',b'Drop Ship',b'Suoratoimitus'
b'DocType: Driver',b'Suspended',b'Keskeytetty'
b'DocType: Training Event',b'Attendees',b'Osallistujat'
b'DocType: Employee',"b'Here you can maintain family details like name and occupation of parent, spouse and children'","b'talleta t\xc3\xa4h\xc3\xa4n esim. perheen lis\xc3\xa4tiedot, kuten vanhempien nimi ja ammatti, puoliso ja lapset'"
b'DocType: Academic Term',b'Term End Date',b'Ehtojen p\xc3\xa4\xc3\xa4ttymisp\xc3\xa4iv\xc3\xa4'
b'DocType: Purchase Invoice',b'Taxes and Charges Deducted (Company Currency)',b'Netto ilman veroja ja kuluja (yrityksen valuutassa)'
b'DocType: Item Group',b'General Settings',b'p\xc3\xa4\xc3\xa4asetukset'
b'apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23',b'From Currency and To Currency cannot be same',b'L\xc3\xa4hde- ja kohdevaluutta eiv\xc3\xa4t voi olla samoja'
b'DocType: Stock Entry',b'Repack',b'Pakkaa uudelleen'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6',b'You must Save the form before proceeding',b'Sinun tulee tallentaa lomake ennen kuin jatkat'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113',b'Please select the Company first',b'Valitse ensin yritys'
b'DocType: Item Attribute',b'Numeric Values',b'Numeroarvot'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +56',b'Attach Logo',b'Kiinnit\xc3\xa4 Logo'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +51',b'Stock Levels',b'Stock Levels'
b'DocType: Customer',b'Commission Rate',b'provisio'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187',b'Created {0} scorecards for {1} between: ',b'Luotu {0} tuloskartan {1} v\xc3\xa4lill\xc3\xa4:'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +505',b'Make Variant',b'Tee Variant'
b'apps/erpnext/erpnext/config/hr.py +87',b'Block leave applications by department.',b'est\xc3\xa4 poistumissovellukset osastoittain'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155',"b'Payment Type must be one of Receive, Pay and Internal Transfer'","b'Maksu tyyppi on yksi vastaanottaminen, Pay ja sis\xc3\xa4inen siirto'"
b'apps/erpnext/erpnext/config/selling.py +184',b'Analytics',b'Analytiikka'
b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25',b'Cart is Empty',b'Ostoskori on tyhj\xc3\xa4'
b'DocType: Vehicle',b'Model',b'Malli'
b'DocType: Work Order',b'Actual Operating Cost',b'todelliset toimintakustannukset'
b'DocType: Payment Entry',b'Cheque/Reference No',b'Sekki / viitenumero'
b'DocType: Soil Texture',b'Clay Loam',b'Clay Loam'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +81',b'Root cannot be edited.',b'kantaa ei voi muokata'
b'DocType: Item',b'Units of Measure',b'Mittayksik\xc3\xb6t'
b'DocType: Manufacturing Settings',b'Allow Production on Holidays',b'salli tuotanto lomap\xc3\xa4ivin\xc3\xa4'
b'DocType: Sales Invoice',"b""Customer's Purchase Order Date""",b'asiakkaan ostotilaus p\xc3\xa4iv\xc3\xa4'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163',b'Capital Stock',b'osakep\xc3\xa4\xc3\xa4oma'
b'DocType: Shopping Cart Settings',b'Show Public Attachments',b'N\xc3\xa4yt\xc3\xa4 Julkiset Liitteet'
b'DocType: Packing Slip',b'Package Weight Details',"b'Pakkauspaino, lis\xc3\xa4tiedot'"
b'DocType: Restaurant Reservation',b'Reservation Time',b'Varausaika'
b'DocType: Payment Gateway Account',b'Payment Gateway Account',b'Maksu Gateway tili'
b'DocType: Shopping Cart Settings',b'After payment completion redirect user to selected page.',b'Maksun j\xc3\xa4lkeen valmistumisen ohjata k\xc3\xa4ytt\xc3\xa4j\xc3\xa4n valitulle sivulle.'
b'DocType: Company',b'Existing Company',b'Olemassa Company'
b'DocType: Healthcare Settings',b'Result Emailed',b'Tulos l\xc3\xa4hetettiin s\xc3\xa4hk\xc3\xb6postitse'
b'apps/erpnext/erpnext/controllers/buying_controller.py +87',"b'Tax Category has been changed to ""Total"" because all the Items are non-stock items'","b'Veroluokka on muutettu &quot;Total&quot;, koska kaikki tuotteet ovat ei-varastosta l\xc3\xb6ytyv\xc3\xa4t'"
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103',b'Please select a csv file',b'Valitse csv tiedosto'
b'DocType: Student Leave Application',b'Mark as Present',b'Merkitse Present'
b'DocType: Supplier Scorecard',b'Indicator Color',b'Indikaattorin v\xc3\xa4ri'
b'DocType: Purchase Order',b'To Receive and Bill',b'Saavuta ja laskuta'
b'apps/erpnext/erpnext/controllers/buying_controller.py +445',b'Row #{0}: Reqd by Date cannot be before Transaction Date',b'Rivi # {0}: Reqd by Date ei voi olla ennen tapahtumap\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/templates/pages/home.html +14',b'Featured Products',b'Esittelyss\xc3\xa4 olevat tuotteet'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136',b'Designer',b'suunnittelija'
b'apps/erpnext/erpnext/config/selling.py +163',b'Terms and Conditions Template',b'Ehdot ja s\xc3\xa4\xc3\xa4nn\xc3\xb6t mallipohja'
b'DocType: Serial No',b'Delivery Details',"b'toimitus, lis\xc3\xa4tiedot'"
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495',b'Cost Center is required in row {0} in Taxes table for type {1}',b'Kustannuspaikka tarvitsee rivin {0} verokannan {1}'
b'DocType: Program',b'Program Code',b'Program Code'
b'DocType: Terms and Conditions',b'Terms and Conditions Help',b'Ehdot Ohje'
,b'Item-wise Purchase Register',"b'tuote ty\xc3\xb6kalu, ostorekisteri'"
b'DocType: Driver',b'Expiry Date',b'vanhenemis p\xc3\xa4iv\xc3\xa4'
b'DocType: Healthcare Settings',b'Employee name and designation in print',b'Ty\xc3\xb6ntekij\xc3\xa4n nimi ja nimike painettuna'
,b'accounts-browser',b'tilit-selain'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368',b'Please select Category first',b'Ole hyv\xc3\xa4 ja valitse Luokka ensin'
b'apps/erpnext/erpnext/config/projects.py +13',b'Project master.',b'projekti valvonta'
b'apps/erpnext/erpnext/controllers/status_updater.py +212',"b'To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.'","b'Sallia yli-laskutus tai over-tilaus, p\xc3\xa4ivit\xc3\xa4 &quot;avustus&quot; varastossa Settings tai Item.'"
b'DocType: Global Defaults',b'Do not show any symbol like $ etc next to currencies.',"b'\xc3\xa4l\xc3\xa4 k\xc3\xa4yt\xc3\xa4 symbooleita,  $ jne valuuttojen vieress\xc3\xa4'"
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431',b' (Half Day)',b'(1/2 p\xc3\xa4iv\xc3\xa4)'
b'DocType: Payment Term',b'Credit Days',b'kredit p\xc3\xa4iv\xc3\xa4\xc3\xa4'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145',b'Please select Patient to get Lab Tests',b'Valitse Potilas saadaksesi Lab Testit'
b'apps/erpnext/erpnext/utilities/activation.py +128',b'Make Student Batch',b'Tee Student Er\xc3\xa4'
b'DocType: Fee Schedule',b'FRQ.',b'FRQ.'
b'DocType: Leave Type',b'Is Carry Forward',b'siirret\xc3\xa4\xc3\xa4k\xc3\xb6'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841',b'Get Items from BOM',b'Hae nimikkeet osaluettelolta'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Lead Time Days',"b'virtausaika, p\xc3\xa4iv\xc3\xa4\xc3\xa4'"
b'DocType: Cash Flow Mapping',b'Is Income Tax Expense',b'Onko tuloveroa'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +621',b'Row #{0}: Posting Date must be same as purchase date {1} of asset {2}',b'Rivi # {0}: julkaisup\xc3\xa4iv\xc3\xa4 on oltava sama kuin ostop\xc3\xa4iv\xc3\xa4st\xc3\xa4 {1} asset {2}'
b'DocType: Program Enrollment',"b""Check this if the Student is residing at the Institute's Hostel.""",b'Valitse t\xc3\xa4m\xc3\xa4 jos opiskelija oleskelee instituutin Hostel.'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125',b'Please enter Sales Orders in the above table',b'Sy\xc3\xb6t\xc3\xa4 Myyntitilaukset edell\xc3\xa4 olevasta taulukosta'
,b'Stock Summary',b'Stock Yhteenveto'
b'apps/erpnext/erpnext/config/assets.py +54',b'Transfer an asset from one warehouse to another',b'Luovuttaa omaisuuttaan yhdest\xc3\xa4 varastosta another'
b'DocType: Vehicle',b'Petrol',b'Bensiini'
b'apps/erpnext/erpnext/config/learn.py +217',b'Bill of Materials',b'Osaluettelo'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105',b'Row {0}: Party Type and Party is required for Receivable / Payable account {1}',b'rivi {0}: osapuolityyppi ja osapuoli vaaditaan saatava / maksettava tilille {1}'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94',b'Ref Date',b'Viite P\xc3\xa4iv\xc3\xa4m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Employee',b'Reason for Leaving',b'Poistumisen syy'
b'DocType: BOM Operation',b'Operating Cost(Company Currency)',b'K\xc3\xa4ytt\xc3\xb6kustannukset (Company valuutta)'
b'DocType: Employee Loan Application',b'Rate of Interest',b'Kiinnostuksen taso'
b'DocType: Expense Claim Detail',b'Sanctioned Amount',b'Hyv\xc3\xa4ksytt\xc3\xa4v\xc3\xa4 m\xc3\xa4\xc3\xa4r\xc3\xa4'
b'DocType: Item',b'Shelf Life In Days',b'S\xc3\xa4ilyvyys p\xc3\xa4ivin\xc3\xa4'
b'DocType: GL Entry',b'Is Opening',b'on avaus'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196',b'Row {0}: Debit entry can not be linked with a {1}',b'rivi {0}: debet kirjausta ei voi kohdistaa {1}'
b'DocType: Journal Entry',b'Subscription Section',b'Tilausjakso'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +177',b'Account {0} does not exist',b'tili\xc3\xa4 {0} ei l\xc3\xb6ydy'
b'DocType: Training Event',b'Training Program',b'Koulutusohjelma'
b'DocType: Account',b'Cash',b'K\xc3\xa4teinen'
b'DocType: Employee',b'Short biography for website and other publications.',b'Lyhyt historiikki verkkosivuille ja muihin julkaisuihin'
