DocType: Accounting Period,Period Name,Periodens namn
DocType: Employee,Salary Mode,Lön Läge
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Registrera
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Delvis mottagen
DocType: Patient,Divorced,Skild
DocType: Support Settings,Post Route Key,Skriv in ruttnyckeln
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Link,Event-länk
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Tillåt Punkt som ska läggas till flera gånger i en transaktion
DocType: Content Question,Content Question,Innehållsfråga
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,Avbryt Material {0} innan du avbryter denna garantianspråk
DocType: Customer Feedback Table,Qualitative Feedback,Kvalitativ feedback
apps/erpnext/erpnext/config/education.py,Assessment Reports,Bedömningsrapporter
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Kundfordringar Rabatterat konto
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,Avbokad
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Konsumentprodukter
DocType: Supplier Scorecard,Notify Supplier,Meddela Leverantör
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,Välj Partityp först
DocType: Item,Customer Items,Kundartiklar
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Liabilities,Skulder
DocType: Project,Costing and Billing,Kostnadsberäkning och fakturering
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Förskottsvaluta ska vara samma som företagsvaluta {0}
DocType: QuickBooks Migrator,Token Endpoint,Token Endpoint
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} can not be a ledger,Kontot {0}: Förälder kontot {1} kan inte vara en liggare
DocType: Item,Publish Item to hub.erpnext.com,Publish Post som hub.erpnext.com
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,Kan inte hitta aktiv lämningsperiod
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,Utvärdering
DocType: Item,Default Unit of Measure,Standard mätenhet
DocType: SMS Center,All Sales Partner Contact,Alla försäljningspartners kontakter
DocType: Department,Leave Approvers,Ledighetsgodkännare
DocType: Employee,Bio / Cover Letter,Bio / Cover Letter
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Search Items ...,Sök efter objekt ...
DocType: Patient Encounter,Investigations,undersökningar
DocType: Restaurant Order Entry,Click Enter To Add,Klicka på Enter för att lägga till
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL","Saknar värde för lösenord, API-nyckel eller Shopify-URL"
DocType: Employee,Rented,Hyrda
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Alla konton
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Kan inte överföra Medarbetare med status Vänster
DocType: Vehicle Service,Mileage,Miltal
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,Vill du verkligen att skrota denna tillgång?
DocType: Drug Prescription,Update Schedule,Uppdateringsschema
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,Välj Standard Leverantör
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Visa anställd
DocType: Payroll Period,Standard Tax Exemption Amount,Standard skattebefrielse belopp
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Ny växelkurs
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Currency is required for Price List {0},Valuta krävs för prislista {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Kommer att beräknas i transaktionen.
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Installera anställdes namngivningssystem i mänskliga resurser&gt; HR-inställningar
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
DocType: Purchase Order,Customer Contact,Kundkontakt
DocType: Shift Type,Enable Auto Attendance,Aktivera automatisk närvaro
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Vänligen ange lager och datum
DocType: Lost Reason Detail,Opportunity Lost Reason,Möjlighet förlorad anledning
DocType: Patient Appointment,Check availability,Kontrollera tillgänglighet
DocType: Retention Bonus,Bonus Payment Date,Bonusbetalningsdatum
DocType: Employee,Job Applicant,Arbetssökande
DocType: Job Card,Total Time in Mins,Total tid i minuter
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,This is based on transactions against this Supplier. See timeline below for details,Detta grundar sig på transaktioner mot denna leverantör. Se tidslinje nedan för mer information
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Överproduktionsprocent för arbetsorder
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,Rättslig
DocType: Sales Invoice,Transport Receipt Date,Transportmottagningsdatum
DocType: Shopify Settings,Sales Order Series,Försäljningsorderserie
DocType: Vital Signs,Tongue,Tunga
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Actual type tax cannot be included in Item rate in row {0},Verklig typskatt kan inte ingå i produktomsättning i rad {0}
DocType: Allowed To Transact With,Allowed To Transact With,Tillåtet att handla med
DocType: Bank Guarantee,Customer,Kunden
DocType: Purchase Receipt Item,Required By,Krävs av
DocType: Delivery Note,Return Against Delivery Note,Återgå mot Följesedel
DocType: Asset Category,Finance Book Detail,Finans bok detaljer
apps/erpnext/erpnext/assets/doctype/asset/asset.py,All the depreciations has been booked,Alla avskrivningar har bokats
DocType: Purchase Order,% Billed,% Fakturerad
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,Lönenummer
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),Växelkurs måste vara samma som {0} {1} ({2})
DocType: Employee Tax Exemption Declaration,HRA Exemption,HRA Undantag
DocType: Sales Invoice,Customer Name,Kundnamn
DocType: Vehicle,Natural Gas,Naturgas
DocType: Project,Message will sent to users to get their status on the project,Meddelandet skickas till användare för att få sin status på projektet
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},Bankkontot kan inte namnges som {0}
DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA enligt lönestruktur
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Huvudtyper (eller grupper) mot vilka bokföringsposter görs och balanser upprätthålls.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Outstanding for {0} cannot be less than zero ({1}),Utstående för {0} kan inte vara mindre än noll ({1})
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,Servicestoppdatum kan inte vara före startdatum för service
DocType: Manufacturing Settings,Default 10 mins,Standard 10 minuter
DocType: Leave Type,Leave Type Name,Ledighetstyp namn
apps/erpnext/erpnext/templates/pages/projects.js,Show open,Visa öppna
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Employee ID is linked with another instructor,Anställds-ID är länkat till en annan instruktör
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,Serie uppdaterats
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Checkout,Checka ut
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Non stock items,Varor som inte finns i lager
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} på rad {1}
DocType: Asset Finance Book,Depreciation Start Date,Avskrivning Startdatum
DocType: Pricing Rule,Apply On,Applicera på
DocType: Item Price,Multiple Item prices.,Flera produktpriser.
,Purchase Order Items To Be Received,Inköpsorder Artiklar att ta emot
DocType: SMS Center,All Supplier Contact,Alla Leverantörskontakter
DocType: Support Settings,Support Settings,support Inställningar
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Konto {0} läggs till i barnföretaget {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/exotel_settings/exotel_settings.py,Invalid credentials,Ogiltiga uppgifter
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC tillgängligt (oavsett om det är fullständigt)
DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS-inställningar
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Bearbetar kuponger
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Rad # {0}: Pris måste vara samma som {1}: {2} ({3} / {4})
,Batch Item Expiry Status,Batch Punkt Utgångs Status
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,Bankväxel
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Late Entries,Totalt sent inlägg
DocType: Mode of Payment Account,Mode of Payment Account,Betalningssätt konto
apps/erpnext/erpnext/config/healthcare.py,Consultation,Samråd
DocType: Accounts Settings,Show Payment Schedule in Print,Visa betalningsplan i utskrift
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Objektvarianter uppdaterade
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Försäljning och Returer
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Visar varianter
DocType: Academic Term,Academic Term,Akademisk - termin
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Arbetsgivarskattebefrielse underkategori
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',Vänligen ange en adress på företaget &#39;% s&#39;
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,Material
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
			amount and previous claimed amount",Maximal nytta av arbetstagaren {0} överstiger {1} med summan {2} av förmånsansökningen pro rata komponent \ summa och tidigare anspråk på beloppet
DocType: Opening Invoice Creation Tool Item,Quantity,Kvantitet
,Customers Without Any Sales Transactions,Kunder utan försäljningstransaktioner
DocType: Manufacturing Settings,Disable Capacity Planning,Inaktivera kapacitetsplanering
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Konton tabell kan inte vara tomt.
DocType: Delivery Trip,Use Google Maps Direction API to calculate estimated arrival times,Använd Google Maps Direction API för att beräkna beräknade ankomsttider
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),Lån (skulder)
DocType: Patient Encounter,Encounter Time,Mötes tid
DocType: Staffing Plan Detail,Total Estimated Cost,Totala beräknade kostnader
DocType: Employee Education,Year of Passing,Passerande År
DocType: Routing,Routing Name,Routing Name
DocType: Item,Country of Origin,Ursprungsland
DocType: Soil Texture,Soil Texture Criteria,Marktexturkriterier
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,I Lager
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,Primär kontaktuppgifter
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,öppna frågor
DocType: Production Plan Item,Production Plan Item,Produktionsplan för artikel
DocType: Leave Ledger Entry,Leave Ledger Entry,Lämna Ledger Entry
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} is already assigned to Employee {1},Användare {0} är redan tilldelad anställd {1}
DocType: Lab Test Groups,Add new line,Lägg till en ny rad
apps/erpnext/erpnext/utilities/activation.py,Create Lead,Skapa bly
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,Sjukvård
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Delay in payment (Days),Försenad betalning (dagar)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Betalningsvillkor Mallinformation
DocType: Hotel Room Reservation,Guest Name,Gästnamn
DocType: Delivery Note,Issue Credit Note,Utgåva Kreditnot
DocType: Lab Prescription,Lab Prescription,Lab Prescription
,Delay Days,Fördröjningsdagar
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,tjänsten Expense
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Number: {0} is already referenced in Sales Invoice: {1},Serienummer: {0} är redan refererad i försäljningsfaktura: {1}
DocType: Bank Statement Transaction Invoice Item,Invoice,Faktura
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Maximalt undantaget belopp
DocType: Purchase Invoice Item,Item Weight Details,Produkt Vikt detaljer
DocType: Asset Maintenance Log,Periodicity,Periodicitet
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,Räkenskapsårets {0} krävs
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Net Profit/Loss,Nettovinst / förlust
DocType: Employee Group Table,ERPNext User ID,ERPNext användar-ID
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Minsta avstånd mellan rader av växter för optimal tillväxt
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient to get prescribed procedure,Välj patient för att få föreskriven procedur
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,Försvar
DocType: Salary Component,Abbr,Förkortning
DocType: Appraisal Goal,Score (0-5),Poäng (0-5)
DocType: Tally Migration,Tally Creditors Account,Tally kreditorer konto
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: {1} {2} does not match with {3},Rad {0}: {1} {2} matchar inte med {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Row # {0}:,Rad # {0}:
DocType: Timesheet,Total Costing Amount,Totala Kalkyl Mängd
DocType: Sales Invoice,Vehicle No,Fordons nr
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,Välj Prislista
DocType: Accounts Settings,Currency Exchange Settings,Valutaväxlingsinställningar
DocType: Appointment Booking Slots,Appointment Booking Slots,Utnämning Bokning Slots
DocType: Work Order Operation,Work In Progress,Pågående Arbete
DocType: Leave Control Panel,Branch (optional),Gren (valfritt)
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,Välj datum
DocType: Item Price,Minimum Qty ,Minsta antal
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,BOM recursion: {0} cannot be child of {1},BOM-rekursion: {0} kan inte vara barn till {1}
DocType: Finance Book,Finance Book,Finansbok
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-
DocType: Appointment Booking Settings,Holiday List,Holiday Lista
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,The parent account {0} does not exists,Moderkontot {0} finns inte
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Granskning och åtgärder
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,This employee already has a log with the same timestamp.{0},Denna anställd har redan en logg med samma tidsstämpel. {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,Revisor
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Försäljningsprislista
DocType: Patient,Tobacco Current Use,Tobaks nuvarande användning
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Selling Rate,Försäljningsfrekvens
DocType: Cost Center,Stock User,Lager Användar
DocType: Soil Analysis,(Ca+Mg)/K,(Ca+Mg) / K
DocType: Delivery Stop,Contact Information,Kontakt information
apps/erpnext/erpnext/public/js/hub/pages/Category.vue,Search for anything ...,Sök efter allt ...
,Stock and Account Value Comparison,Jämförelse av lager och konto
DocType: Company,Phone No,Telefonnr
DocType: Delivery Trip,Initial Email Notification Sent,Initial Email Notification Sent
DocType: Bank Statement Settings,Statement Header Mapping,Statement Header Mapping
,Sales Partners Commission,Försäljning Partners kommissionen
DocType: Soil Texture,Sandy Clay Loam,Sandig Clay Loam
DocType: Purchase Invoice,Rounding Adjustment,Avrundningsjustering
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation cannot have more than 5 characters,Förkortning kan inte ha mer än 5 tecken
DocType: Amazon MWS Settings,AU,AU
DocType: Payment Order,Payment Request,Betalningsbegäran
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,För att visa loggar över lojalitetspoäng som tilldelats en kund.
DocType: Asset,Value After Depreciation,Värde efter avskrivningar
DocType: Student,O+,O +
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,Relaterad
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,Närvaro datum kan inte vara mindre än arbetstagarens Inträdesdatum
DocType: Grading Scale,Grading Scale Name,Bedömningsskala Namn
DocType: Employee Training,Training Date,Träningsdatum
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Lägg till användare på Marketplace
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,Detta är en root-kontot och kan inte ändras.
DocType: POS Profile,Company Address,Företags Adress
DocType: BOM,Operations,Verksamhet
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},Det går inte att ställa in tillstånd på grund av rabatt för {0}
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON cannot be generated for Sales Return as of now,e-Way Bill JSON kan inte genereras för försäljningsavkastning från och med nu
DocType: Subscription,Subscription Start Date,Prenumerations startdatum
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,Standardfordringar som ska användas om den inte är inställd på patienten för att boka avtalsavgifter.
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Bifoga CSV-fil med två kolumner, en för det gamla namnet och en för det nya namnet"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 2,Från Adress 2
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,Få information från deklarationen
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1} inte i något aktivt räkenskapsår.
DocType: Packed Item,Parent Detail docname,Överordnat Detalj doknamn
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Reference: {0}, Item Code: {1} and Customer: {2}","Referens: {0}, Artikelnummer: {1} och Kund: {2}"
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,{0} {1} is not present in the parent company,{0} {1} finns inte i moderbolaget
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,Pröva period Slutdatum kan inte vara före startdatum för prövningsperiod
DocType: Tax Withholding Category,Tax Withholding Category,Skatteavdragskategori
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Avbryt journalposten {0} först
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,BOM is not specified for subcontracting item {0} at row {1},BOM är inte specificerat för underleverantörsobjekt {0} i rad {1}
DocType: Vital Signs,Reflexes,reflexer
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0} Resultat skickat
DocType: Item Attribute,Increment,Inkrement
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Hjälpresultat för
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,Välj Warehouse ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,Reklam
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Same Company is entered more than once,Samma Företaget anges mer än en gång
DocType: Patient,Married,Gift
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},Ej tillåtet för {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get items from,Få objekt från
DocType: Stock Entry,Send to Subcontractor,Skicka till underleverantör
DocType: Purchase Invoice,Apply Tax Withholding Amount,Applicera Skatteavdrag Belopp
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Stock cannot be updated against Delivery Note {0},Stock kan inte uppdateras mot följesedel {0}
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,Summa belopp Credited
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,Inga föremål listade
DocType: Asset Repair,Error Description,Felbeskrivning
DocType: Payment Reconciliation,Reconcile,Avstämma
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Grocery,Matvaror
DocType: Quality Inspection Reading,Reading 1,Avläsning 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,Pensionsfonder
DocType: Exchange Rate Revaluation Account,Gain/Loss,Vinst / förlust
DocType: Crop,Perennial,Perenn
DocType: Program,Is Published,Publiceras
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Delivery Notes,Visa leveransanteckningar
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.",För att tillåta överfakturering uppdaterar du &quot;Över faktureringsbidrag&quot; i Kontoinställningar eller artikeln.
DocType: Patient Appointment,Procedure,Procedur
DocType: Accounts Settings,Use Custom Cash Flow Format,Använd anpassat kassaflödesformat
DocType: SMS Center,All Sales Person,Alla försäljningspersonal
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,**Månatlig Distribution** hjälper dig distribuera budgeten/målen över månader om du har säsongsförsäljning i din verksamhet.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Not items found,Inte artiklar hittade
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Lönestruktur saknas
DocType: Lead,Person Name,Namn
,Supplier Ledger Summary,Leverantörsbok Sammanfattning
DocType: Sales Invoice Item,Sales Invoice Item,Fakturan Punkt
apps/erpnext/erpnext/projects/doctype/project/project.js,Duplicate project has been created,Duplikatprojekt har skapats
DocType: Quality Procedure Table,Quality Procedure Table,Kvalitetsprocedurstabell
DocType: Account,Credit,Kredit
DocType: POS Profile,Write Off Cost Center,Avskrivning kostnadsställe
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Primary School"" or ""University""",t.ex. &quot;Primary School&quot; eller &quot;universitet&quot;
apps/erpnext/erpnext/config/stock.py,Stock Reports,lagerrapporter
DocType: Warehouse,Warehouse Detail,Lagerdetalj
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Sista datum för kolkontroll kan inte vara ett framtida datum
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,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.,Termen Slutdatum kan inte vara senare än slutet av året Datum för läsåret som termen är kopplad (läsåret {}). Rätta datum och försök igen.
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Är anläggningstillgång"" kan inte avmarkeras då ett tillgångsregister finns mot objektet"
DocType: Delivery Trip,Departure Time,Avgångstid
DocType: Vehicle Service,Brake Oil,bromsolja
DocType: Tax Rule,Tax Type,Skatte Typ
,Completed Work Orders,Avslutade arbetsorder
DocType: Support Settings,Forum Posts,Foruminlägg
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",Uppgiften har antagits som ett bakgrundsjobb. Om det finns något problem med behandlingen i bakgrunden kommer systemet att lägga till en kommentar om felet i denna aktieavstämning och återgå till utkastet.
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has work order assigned to it.,Rad # {0}: Det går inte att radera objekt {1} som har tilldelats arbetsordning.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Ledsen, giltighetskupongkoden har inte startat"
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Skattepliktiga belopp
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Du har inte behörighet att lägga till eller uppdatera poster före {0}
DocType: Leave Policy,Leave Policy Details,Lämna policy detaljer
DocType: BOM,Item Image (if not slideshow),Produktbild (om inte bildspel)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Rad # {0}: Drift {1} är inte slutfört för {2} antal färdigvaror i arbetsordern {3}. Uppdatera driftsstatus via Jobbkort {4}.
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Timkostnad/60) * Faktisk produktionstid
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Row # {0}: Referensdokumenttyp måste vara ett av kostnadskrav eller journalinmatning
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,Välj BOM
DocType: SMS Log,SMS Log,SMS-logg
DocType: Call Log,Ringing,Ringande
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Kostnad levererat gods
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,The holiday on {0} is not between From Date and To Date,Semester på {0} är inte mellan Från datum och Till datum
DocType: Inpatient Record,Admission Scheduled,Tillträde planerat
DocType: Student Log,Student Log,Student Log
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Mallar av leverantörsställningar.
DocType: Lead,Interested,Intresserad
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,Öppning
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,Program:
DocType: Item,Copy From Item Group,Kopiera från artikelgrupp
DocType: Journal Entry,Opening Entry,Öppnings post
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Endast konto Pay
DocType: Loan,Repay Over Number of Periods,Repay Över Antal perioder
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Quantity to Produce can not be less than Zero,Antalet att producera kan inte vara mindre än noll
DocType: Stock Entry,Additional Costs,Merkostnader
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be converted to group.,Konto med befintlig transaktioner kan inte omvandlas till grupp.
DocType: Lead,Product Enquiry,Produkt Förfrågan
DocType: Education Settings,Validate Batch for Students in Student Group,Validera batch för studenter i studentgruppen
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},Ingen ledighet rekord hittades för arbetstagare {0} för {1}
DocType: Company,Unrealized Exchange Gain/Loss Account,Orealiserat Exchange Gain / Loss-konto
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,Ange företaget först
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please select Company first,Välj Företaget först
DocType: Employee Education,Under Graduate,Enligt Graduate
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,Vänligen ange standardmall för meddelandet om status för vänsterstatus i HR-inställningar.
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,Mål på
DocType: BOM,Total Cost,Total Kostnad
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Allocation Expired!,Tilldelningen har gått ut!
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Leave Type,Maximum Carry Forwarded Leaves,Maximala framåtriktade löv
DocType: Salary Slip,Employee Loan,Employee Loan
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-
DocType: Fee Schedule,Send Payment Request Email,Skicka betalningsförfrågan via e-post
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,Objektet existerar inte {0} i systemet eller har löpt ut
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,Lämna tomma om Leverantören är obestämd
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Fastighet
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,Kontoutdrag
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,Läkemedel
DocType: Purchase Invoice Item,Is Fixed Asset,Är anläggningstillgång
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Future Payments,Visa framtida betalningar
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,This bank account is already synchronized,Detta bankkonto är redan synkroniserat
DocType: Homepage,Homepage Section,Hemsidan avsnitt
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Arbetsorder har varit {0}
DocType: Budget,Applicable on Purchase Order,Gäller på inköpsorder
DocType: Item,STO-ITEM-.YYYY.-,STO-item-.YYYY.-
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,Lösenordspolicy för lönesedlar är inte inställd
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Duplicate kundgrupp finns i cutomer grupptabellen
DocType: Location,Location Name,Platsnamn
DocType: Quality Procedure Table,Responsible Individual,Ansvarig individ
DocType: Naming Series,Prefix,Prefix
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Plats för evenemang
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Available Stock,Tillgängligt lager
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Förbrukningsartiklar
DocType: Student,B-,B-
DocType: Assessment Result,Grade,Kvalitet
DocType: Restaurant Table,No of Seats,Antal platser
DocType: Sales Invoice,Overdue and Discounted,Försenade och rabatterade
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belongs to the custodian {1},Tillgång {0} tillhör inte vårdnadshavaren {1}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Samtalet bröts
DocType: Sales Invoice Item,Delivered By Supplier,Levereras av Supplier
DocType: Asset Maintenance Task,Asset Maintenance Task,Asset Maintenance Task
DocType: SMS Center,All Contact,Alla Kontakter
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Annual Salary,Årslön
DocType: Daily Work Summary,Daily Work Summary,Dagliga Work Sammandrag
DocType: Period Closing Voucher,Closing Fiscal Year,Stänger Räkenskapsårets
apps/erpnext/erpnext/accounts/party.py,{0} {1} is frozen,{0} {1} är fryst
apps/erpnext/erpnext/setup/doctype/company/company.py,Please select Existing Company for creating Chart of Accounts,Välj befintligt företag för att skapa konto
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,Stock Kostnader
DocType: Appointment,Calendar Event,Kalenderhändelse
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Välj Target Warehouse
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Välj Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,Ange Preferred Kontakt Email
DocType: Purchase Invoice Item,Accepted Qty,Godkänd antal
DocType: Journal Entry,Contra Entry,Konteringsanteckning
DocType: Journal Entry Account,Credit in Company Currency,Kredit i bolaget Valuta
DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
DocType: Delivery Note,Installation Status,Installationsstatus
DocType: BOM,Quality Inspection Template,Kvalitetskontrollmall
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Vill du uppdatera närvaro? <br> Föreliggande: {0} \ <br> Frånvarande: {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Godkända + Avvisad Antal måste vara lika med mottagna kvantiteten för punkt {0}
DocType: Item,Supply Raw Materials for Purchase,Leverera råvaror för köp
DocType: Agriculture Analysis Criteria,Fertilizer,Fertilizer
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.",Kan inte garantera leverans med serienummer som \ Item {0} läggs till med och utan Se till att leverans med \ Serienummer
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,Minst ett läge av betalning krävs för POS faktura.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Batch no is required for batched item {0},Bunt nr krävs för batchföremål {0}
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Bankräkning Transaktionsfaktura
DocType: Salary Detail,Tax on flexible benefit,Skatt på flexibel fördel
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} is not active or end of life has been reached,Produkt {0} är inte aktiv eller uttjänta har nåtts
DocType: Student Admission Program,Minimum Age,Lägsta ålder
DocType: Customer,Primary Address,Primäradress
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Diff Antal
DocType: Production Plan,Material Request Detail,Materialförfrågan Detalj
DocType: Appointment Booking Settings,Notify customer and agent via email on the day of the appointment.,Meddela kund och agent via e-post dagen för avtalet.
DocType: Selling Settings,Default Quotation Validity Days,Standard Offertid Giltighetsdagar
apps/erpnext/erpnext/controllers/accounts_controller.py,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Om du vill inkludera skatt i rad {0} i punkt hastighet, skatter i rader {1} måste också inkluderas"
apps/erpnext/erpnext/config/quality_management.py,Quality Procedure.,Kvalitetsförfarande.
DocType: SMS Center,SMS Center,SMS Center
DocType: Payroll Entry,Validate Attendance,Styrk närvaro
DocType: Sales Invoice,Change Amount,Ändra Mängd
DocType: Party Tax Withholding Config,Certificate Received,Certifikat mottaget
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Ange fakturavärde för B2C. B2CL och B2CS beräknad baserat på detta fakturavärde.
DocType: BOM Update Tool,New BOM,Ny BOM
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Föreskrivna förfaranden
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Visa bara POS
DocType: Supplier Group,Supplier Group Name,Leverantörsgruppsnamn
DocType: Driver,Driving License Categories,Körkortskategorier
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Ange leveransdatum
DocType: Depreciation Schedule,Make Depreciation Entry,Göra Av- Entry
DocType: Closed Document,Closed Document,Stängt dokument
DocType: HR Settings,Leave Settings,Lämna inställningar
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Typ av förfrågan
DocType: Purpose of Travel,Purpose of Travel,Mening med resa
DocType: Payroll Period,Payroll Periods,Löneperiod
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,Sändning
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),Inställningsläge för POS (Online / Offline)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Select a Supplier from the Default Supplier List of the items below.,Välj en leverantör från standardleverantörslistan med artiklarna nedan.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,Exekvering
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,Detaljer om de åtgärder som genomförs.
DocType: Asset Maintenance Log,Maintenance Status,Underhåll Status
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,Artikel Skattebelopp ingår i värdet
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Medlemsuppgifter
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Leverantör krävs mot betalkonto {2}
apps/erpnext/erpnext/config/buying.py,Items and Pricing,Produkter och prissättning
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kund&gt; Kundgrupp&gt; Territorium
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Totalt antal timmar: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,From Date should be within the Fiscal Year. Assuming From Date = {0},Från Datum bör ligga inom räkenskapsåret. Förutsatt Från Datum = {0}
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-
DocType: Drug Prescription,Interval,Intervall
DocType: Pricing Rule,Promotional Scheme Id,Kampanjschema-id
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,Preferens
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,Inward Supplies (kan omvänd laddning)
DocType: Supplier,Individual,Individuell
DocType: Academic Term,Academics User,Akademisk - användare
DocType: Cheque Print Template,Amount In Figure,Belopp I figur
DocType: Loan Application,Loan Info,Loan info
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All Other ITC,Alla andra ITC
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,Planer för underhållsbesök.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Leverantörens scorecardperiod
DocType: Support Settings,Search APIs,Sök API: er
DocType: Share Transfer,Share Transfer,Delöverföring
,Expiring Memberships,Utgående medlemskap
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Läs bloggen
DocType: POS Profile,Customer Groups,kundgrupper
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Bokslut
DocType: Guardian,Students,studenter
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,Regler för tillämpning av prissättning och rabatt.
DocType: Daily Work Summary,Daily Work Summary Group,Daglig arbetsöversiktskoncern
DocType: Practitioner Schedule,Time Slots,Tidsluckor
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,Prislista måste gälla för att köpa eller sälja
DocType: Shift Assignment,Shift Request,Skiftförfrågan
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Installation date cannot be before delivery date for Item {0},Installationsdatum kan inte vara före leveransdatum för punkt {0}
DocType: Purchase Invoice Item,Discount on Price List Rate (%),Rabatt på Prislista Andel (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Artikelmall
DocType: Job Offer,Select Terms and Conditions,Välj Villkor
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,ut Värde
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Inställningsinställningar för bankräkning
DocType: Woocommerce Settings,Woocommerce Settings,Woocommerce-inställningar
DocType: Leave Ledger Entry,Transaction Name,Transaktionsnamn
DocType: Production Plan,Sales Orders,Kundorder
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Flera lojalitetsprogram som finns för kunden. Var god välj manuellt.
DocType: Purchase Taxes and Charges,Valuation,Värdering
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,Ange som standard
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item.,Sista utgångsdatum är obligatoriskt för vald artikel.
,Purchase Order Trends,Inköpsorder Trender
DocType: Hotel Room Reservation,Late Checkin,Sen incheckning
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Finding linked payments,Hitta länkade betalningar
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,Offertbegäran kan nås genom att klicka på följande länk
DocType: Quiz Result,Selected Option,Valt alternativ
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Creation Tool Course
DocType: Bank Statement Transaction Invoice Item,Payment Description,Betalningsbeskrivning
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ange Naming Series för {0} via Setup&gt; Inställningar&gt; Naming Series
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,otillräcklig Stock
DocType: Email Digest,New Sales Orders,Ny kundorder
DocType: Bank Account,Bank Account,Bankkonto
DocType: Travel Itinerary,Check-out Date,Utcheckningsdatum
DocType: Leave Type,Allow Negative Balance,Tillåt negativt saldo
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',Du kan inte ta bort Project Type &#39;External&#39;
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Välj alternativt alternativ
DocType: Employee,Create User,Skapa användare
DocType: Selling Settings,Default Territory,Standard Område
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,Tv
DocType: Work Order Operation,Updated via 'Time Log',Uppdaterad via &quot;Time Log&quot;
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Select the customer or supplier.,Välj kund eller leverantör.
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,Country Code in File does not match with country code set up in the system,Landskod i fil stämmer inte med landskod som ställts in i systemet
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,Välj endast en prioritet som standard.
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Advance beloppet kan inte vara större än {0} {1}
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Tidsluckan hoppa över, slitsen {0} till {1} överlappar existerande slits {2} till {3}"
DocType: Naming Series,Series List for this Transaction,Serie Lista för denna transaktion
DocType: Company,Enable Perpetual Inventory,Aktivera evigt lager
DocType: Bank Guarantee,Charges Incurred,Avgifter uppkommit
apps/erpnext/erpnext/public/js/education/lms/quiz.js,Something went wrong while evaluating the quiz.,Något gick fel vid utvärderingen av frågesporten.
DocType: Appointment Booking Settings,Success Settings,Framgångsinställningar
DocType: Company,Default Payroll Payable Account,Standard Lön Betal konto
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Edit Details,Redigera detaljer
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Uppdatera E-postgrupp
DocType: POS Profile,Only show Customer of these Customer Groups,Visa endast kund för dessa kundgrupper
DocType: Sales Invoice,Is Opening Entry,Är öppen anteckning
apps/erpnext/erpnext/public/js/conf.js,Documentation,Dokumentation
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Om det inte är markerat visas inte produkten i försäljningsfaktura, men kan användas vid grupptestinsamling."
DocType: Customer Group,Mention if non-standard receivable account applicable,Nämn om icke-standard mottagningskonto tillämpat
DocType: Course Schedule,Instructor Name,instruktör Namn
DocType: Company,Arrear Component,Arrear Component
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,Stock Entry has been already created against this Pick List,Lagerinmatning har redan skapats mot den här listan
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,"The unallocated amount of Payment Entry {0} \
			is greater than the Bank Transaction's unallocated amount",Det odelade beloppet för betalningsinmatning {0} \ är större än banköverföringens icke tilldelade belopp
DocType: Supplier Scorecard,Criteria Setup,Kriterier Setup
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,For Warehouse is required before Submit,För Lagerkrävs innan du kan skicka
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Received On,Mottog den
DocType: Codification Table,Medical Code,Medicinsk kod
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Anslut Amazon med ERPNext
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Kontakta oss
DocType: Delivery Note Item,Against Sales Invoice Item,Mot fakturaprodukt
DocType: Agriculture Analysis Criteria,Linked Doctype,Länkad doktyp
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,Nettokassaflöde från finansiering
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save","Localstorage är full, inte spara"
DocType: Lead,Address & Contact,Adress och kontakt
DocType: Leave Allocation,Add unused leaves from previous allocations,Lägg oanvända blad från tidigare tilldelningar
DocType: Sales Partner,Partner website,partner webbplats
DocType: Restaurant Order Entry,Add Item,Lägg till vara
DocType: Party Tax Withholding Config,Party Tax Withholding Config,Partskatteavdrag Konfig
DocType: Lab Test,Custom Result,Anpassat resultat
apps/erpnext/erpnext/templates/emails/confirm_appointment.html,Click on the link below to verify your email and confirm the appointment,Klicka på länken nedan för att bekräfta din e-post och bekräfta möten
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Bank accounts added,Bankkonton tillagda
DocType: Call Log,Contact Name,Kontaktnamn
DocType: Plaid Settings,Synchronize all accounts every hour,Synkronisera alla konton varje timme
DocType: Course Assessment Criteria,Course Assessment Criteria,Kriterier för bedömning Course
DocType: Pricing Rule Detail,Rule Applied,Tillämpad regel
DocType: Service Level Priority,Resolution Time Period,Upplösningstid
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,Skatte ID:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,Student-ID:
DocType: POS Customer Group,POS Customer Group,POS Kundgrupp
DocType: Healthcare Practitioner,Practitioner Schedules,Utövarens scheman
DocType: Cheque Print Template,Line spacing for amount in words,Radavstånd för beloppet i ord
DocType: Vehicle,Additional Details,ytterligare detaljer
apps/erpnext/erpnext/templates/generators/bom.html,No description given,Ingen beskrivning ges
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Hämta objekt från lagret
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Begäran om köp.
DocType: POS Closing Voucher Details,Collected Amount,Samlat belopp
DocType: Lab Test,Submitted Date,Inlämnad Datum
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Företagets fält krävs
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,This is based on the Time Sheets created against this project,Detta grundar sig på tidrapporter som skapats mot detta projekt
DocType: Item,Minimum quantity should be as per Stock UOM,Minsta kvantitet ska vara enligt lager UOM
DocType: Call Log,Recording URL,Inspelnings-URL
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Start Date cannot be before the current date,Startdatum kan inte vara före det aktuella datumet
,Open Work Orders,Öppna arbetsorder
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Out Patient Consulting Charge Item
DocType: Payment Term,Credit Months,Kreditmånader
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Nettolön kan inte vara mindre än 0
DocType: Contract,Fulfilled,uppfyllt
DocType: Inpatient Record,Discharge Scheduled,Utsläpp Schemalagd
DocType: POS Closing Voucher,Cashier,Kassör
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Avgångar per år
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Rad {0}: Kontrollera ""Är i förskott"" mot konto {1} om det är ett förskotts post."
apps/erpnext/erpnext/stock/utils.py,Warehouse {0} does not belong to company {1},Lager {0} tillhör inte företaget {1}
DocType: Email Digest,Profit & Loss,Vinst förlust
DocType: Task,Total Costing Amount (via Time Sheet),Totalt Costing Belopp (via Tidrapportering)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,Vänligen uppsättning studenter under studentgrupper
DocType: Item Website Specification,Item Website Specification,Produkt hemsidespecifikation
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,Lämna Blockerad
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} has reached its end of life on {1},Punkt {0} har nått slutet av sin livslängd på {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Bank Entries,bankAnteckningar
DocType: Customer,Is Internal Customer,Är internkund
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Om Auto Opt In är markerad, kommer kunderna automatiskt att kopplas till det berörda Lojalitetsprogrammet (vid spara)"
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Lager Avstämning Punkt
DocType: Stock Entry,Sales Invoice No,Försäljning Faktura nr
DocType: Website Filter Field,Website Filter Field,Fält för webbplatsfilter
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Tillförsel Typ
DocType: Material Request Item,Min Order Qty,Min Order kvantitet
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Student Group Creation Tool Course
DocType: Lead,Do Not Contact,Kontakta ej
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,Mjukvaruutvecklare
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,Skapa provbehållningsinmatning
DocType: Item,Minimum Order Qty,Minimum Antal
DocType: Supplier,Supplier Type,Leverantör Typ
DocType: Course Scheduling Tool,Course Start Date,Kursstart
,Student Batch-Wise Attendance,Student satsvis Närvaro
DocType: POS Profile,Allow user to edit Rate,Tillåt användare att redigera Kurs
DocType: Item,Publish in Hub,Publicera i Hub
DocType: Student Admission,Student Admission,Student Antagning
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is cancelled,Punkt {0} avbryts
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,Avskrivningsraden {0}: Avskrivning Startdatum anges som förflutet datum
DocType: Contract Template,Fulfilment Terms and Conditions,Uppfyllande Villkor
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Materialförfrågan
DocType: Bank Reconciliation,Update Clearance Date,Uppdatera Clearance Datum
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,Bundle Qty
,GSTR-2,GSTR-2
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},"Produkt  {0} hittades inte i ""råvaror som levereras""  i beställning {1}"
DocType: Salary Slip,Total Principal Amount,Summa huvudbelopp
DocType: Student Guardian,Relation,Förhållande
DocType: Quiz Result,Correct,Korrekt
DocType: Student Guardian,Mother,Mor
DocType: Restaurant Reservation,Reservation End Time,Bokning Sluttid
DocType: Crop,Biennial,Tvåårig
,BOM Variance Report,BOM-variansrapport
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,Bekräftade ordrar från kunder.
DocType: Purchase Receipt Item,Rejected Quantity,Avvisad Kvantitet
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,Betalningsförfrågan {0} skapad
DocType: Inpatient Record,Admitted Datetime,Admitted Datetime
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Backflush råvaror från arbets-i-lager lager
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Open Orders,Öppna beställningar
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Unable to find Salary Component {0},Det gick inte att hitta lönekomponent {0}
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Låg känslighet
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Order omplacerad för synkronisering
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,Vänligen bekräfta när du har avslutat din träning
DocType: Lead,Suggestions,Förslag
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Ange artikelgrupp visa budgetar på detta område. Du kan även inkludera säsongs genom att ställa in Distribution.
DocType: Woocommerce Settings,This company will be used to create Sales Orders.,Detta företag kommer att användas för att skapa försäljningsorder.
DocType: Plaid Settings,Plaid Public Key,Plaid Public Key
DocType: Payment Term,Payment Term Name,Betalningsnamn Namn
DocType: Healthcare Settings,Create documents for sample collection,Skapa dokument för provinsamling
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Betalning mot {0} {1} inte kan vara större än utestående beloppet {2}
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Alla hälsovårdstjänster
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Converting Opportunity,Om konvertering av möjlighet
DocType: Bank Account,Address HTML,Adress HTML
DocType: Lead,Mobile No.,Mobilnummer.
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,Betalningssätt
DocType: Maintenance Schedule,Generate Schedule,Generera Schema
DocType: Purchase Invoice Item,Expense Head,Utgiftshuvud
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Charge Type first,Välj Avgiftstyp först
DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Du kan definiera alla uppgifter som behöver utföras för denna gröda här. Dagfältet används för att nämna den dag då uppgiften ska utföras, 1 är första dagen, etc."
DocType: Student Group Student,Student Group Student,Student Group Student
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,Senaste
DocType: Packed Item,Actual Batch Quantity,Faktiskt antal mängder
DocType: Asset Maintenance Task,2 Yearly,2 årligen
DocType: Education Settings,Education Settings,Utbildningsinställningar
DocType: Vehicle Service,Inspection,Inspektion
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Information om fakturering saknas
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Balans i basvaluta
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Email Digest,New Quotations,Nya Citat
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,Närvaro som inte lämnats in för {0} som {1} på ledighet.
DocType: Journal Entry,Payment Order,Betalningsorder
apps/erpnext/erpnext/www/book_appointment/verify/index.html,Verify Email,Verifiera Email
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Intäkter från andra källor
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered",Om det är tomt kommer överföringskontot eller företagets standard att övervägas
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,E-post lönebesked till anställd baserat på föredragna e-post väljs i Employee
DocType: Tax Rule,Shipping County,Frakt County
DocType: Currency Exchange,For Selling,För försäljning
apps/erpnext/erpnext/config/desktop.py,Learn,Lär dig
,Trial Balance (Simple),Testbalans (enkel)
DocType: Purchase Invoice Item,Enable Deferred Expense,Aktivera uppskjuten kostnad
apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Tillämpad kupongkod
DocType: Asset,Next Depreciation Date,Nästa Av- Datum
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivitet Kostnad per anställd
DocType: Accounts Settings,Settings for Accounts,Inställningar för konton
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},Leverantör faktura nr existerar i inköpsfaktura {0}
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,Hantera Säljare.
DocType: Job Applicant,Cover Letter,Personligt brev
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,Utestående checkar och insättningar för att rensa
DocType: Item,Synced With Hub,Synkroniserad med Hub
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,Leveranser från ISD
DocType: Driver,Fleet Manager,Fleet manager
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Row #{0}: {1} can not be negative for item {2},Rad # {0}: {1} kan inte vara negativt för produkten {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Fel Lösenord
DocType: POS Profile,Offline POS Settings,Offline POS-inställningar
DocType: Stock Entry Detail,Reference Purchase Receipt,Referensköpskvitto
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,Variant av
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Completed Qty can not be greater than 'Qty to Manufacture',"Avslutade Antal kan inte vara större än ""antal för Tillverkning '"
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Period based On,Period baserat på
DocType: Period Closing Voucher,Closing Account Head,Stänger Konto Huvud
DocType: Employee,External Work History,Extern Arbetserfarenhet
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,Cirkelreferens fel
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,Studentrapportkort
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,Från Pin-kod
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person,Visa säljare
DocType: Appointment Type,Is Inpatient,Är inpatient
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Name,Guardian1 Namn
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,I ord (Export) kommer att vara synlig när du sparar följesedel.
DocType: Cheque Print Template,Distance from left edge,Avstånd från vänstra kanten
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} enheterav [{1}] (#Form/Objekt/{1}) hittades i [{2}] (#Form/Lager/{2})
DocType: Lead,Industry,Industri
DocType: BOM Item,Rate & Amount,Betygsätt och belopp
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Inställningar för lista över webbplatser
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py,Tax Total,Skatt totalt
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Belopp på integrerad skatt
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Meddela via e-post om skapandet av automatisk Material Begäran
DocType: Accounting Dimension,Dimension Name,Dimension Namn
apps/erpnext/erpnext/healthcare/setup.py,Resistant,Resistent
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},Ange hotellets rumspris på {}
DocType: Journal Entry,Multi Currency,Flera valutor
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Faktura Typ
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from date must be less than valid upto date,Giltigt från datum måste vara mindre än giltigt fram till datum
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Exception occurred while reconciling {0},Undantag inträffade vid försoning av {0}
DocType: Purchase Invoice,Set Accepted Warehouse,Ställ in accepterat lager
DocType: Employee Benefit Claim,Expense Proof,Expense Proof
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Sparar {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Följesedel
DocType: Patient Encounter,Encounter Impression,Encounter Impression
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Ställa in skatter
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Kostnader för sålda Asset
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required while receiving Asset {0} from an employee,Målplats krävs när du får tillgång {0} från en anställd
DocType: Volunteer,Morning,Morgon
apps/erpnext/erpnext/accounts/utils.py,Payment Entry has been modified after you pulled it. Please pull it again.,Betalningsposten har ändrats efter att du hämtade den. Vänligen hämta igen.
DocType: Program Enrollment Tool,New Student Batch,Ny studentbatch
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} angiven två gånger under punkten Skatt
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this week and pending activities,Sammanfattning för denna vecka och pågående aktiviteter
DocType: Student Applicant,Admitted,medgav
DocType: Workstation,Rent Cost,Hyr Kostnad
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Item listing removed,Objektlistan har tagits bort
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid transactions sync error,Fel synkroniseringsfel
DocType: Leave Ledger Entry,Is Expired,Har gått ut
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Belopp efter avskrivningar
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Kommande kalenderhändelser
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Variant attribut
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,Välj månad och år
DocType: Employee,Company Email,Företagets e-post
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Användaren har inte tillämpat regeln på fakturan {0}
DocType: GL Entry,Debit Amount in Account Currency,Betal-Belopp i konto Valuta
DocType: Supplier Scorecard,Scoring Standings,Scoring Ställningar
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Ordervärde
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Ordervärde
DocType: Certified Consultant,Certified Consultant,Certifierad konsult
apps/erpnext/erpnext/config/accounts.py,Bank/Cash transactions against party or for internal transfer,Bank / Cash transaktioner mot partiet eller för intern överföring
DocType: Shipping Rule,Valid for Countries,Gäller för länder
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,Sluttid kan inte vara före starttid
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1 exakt matchning.
apps/erpnext/erpnext/stock/doctype/item/item.js,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,Denna punkt är en mall och kan inte användas i transaktioner. Punkt attribut kommer att kopieras över till varianterna inte &quot;Nej Kopiera&quot; ställs in
DocType: Grant Application,Grant Application,Bidragsansökan
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Considered,Den totala order Anses
DocType: Certification Application,Not Certified,Ej certifierad
DocType: Asset Value Adjustment,New Asset Value,Nytt tillgångsvärde
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,I takt med vilket kundens Valuta omvandlas till kundens basvaluta
DocType: Course Scheduling Tool,Course Scheduling Tool,Naturligtvis Scheduling Tool
DocType: Crop Cycle,LInked Analysis,Analys
DocType: POS Closing Voucher,POS Closing Voucher,POS Closing Voucher
DocType: Invoice Discounting,Loan Start Date,Lånets startdatum
DocType: Contract,Lapsed,förfallit
DocType: Item Tax Template Detail,Tax Rate,Skattesats
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,Kursregistrering {0} finns inte
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,Ansökningsperioden kan inte över två fördelningsrekord
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},{0} som redan tilldelats för anställd {1} för perioden {2} till {3}
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush råvaror av underleverantör baserat på
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,Inköpsfakturan {0} är redan lämnad
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Batch No must be same as {1} {2},Rad # {0}: Batch nr måste vara samma som {1} {2}
DocType: Material Request Plan Item,Material Request Plan Item,Material Beställningsplan
DocType: Leave Type,Allow Encashment,Tillåt Encashment
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to non-Group,Konvertera till icke-gruppen
DocType: Exotel Settings,Account SID,Konto SID
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Fakturadatum
DocType: GL Entry,Debit Amount,Debit Belopp
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},Det kan bara finnas ett konto per Company i {0} {1}
DocType: Support Search Source,Response Result Key Path,Svar sökväg
DocType: Journal Entry,Inter Company Journal Entry,Inter Company Journal Entry
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Förfallodatum kan inte vara före bokföring / leverantörs fakturadatum
DocType: Employee Training,Employee Training,Utbildning för anställda
DocType: Quotation Item,Additional Notes,Ytterligare anmärkningar
DocType: Purchase Order,% Received,% Emot
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Skapa studentgrupper
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}","Tillgänglig mängd är {0}, du behöver {1}"
DocType: Volunteer,Weekends,helger
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,Kreditnotbelopp
DocType: Setup Progress Action,Action Document,Handlingsdokument
DocType: Chapter Member,Website URL,Webbadress
apps/erpnext/erpnext/controllers/stock_controller.py,Row #{0}: Serial No {1} does not belong to Batch {2},Rad # {0}: Serienummer {1} tillhör inte batch {2}
,Finished Goods,Färdiga Varor
DocType: Delivery Note,Instructions,Instruktioner
DocType: Quality Inspection,Inspected By,Inspekteras av
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
DocType: Asset Maintenance Log,Maintenance Type,Servicetyp
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0} - {1} är inte inskriven i kursen {2}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Elevs namn:
DocType: POS Closing Voucher,Difference,Skillnad
DocType: Delivery Settings,Delay between Delivery Stops,Fördröjning mellan leveransstopp
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},Serienummer {0} tillhör inte följesedel {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,"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.","Det verkar finnas ett problem med serverns GoCardless-konfiguration. Oroa dig inte, i händelse av fel kommer beloppet att återbetalas till ditt konto."
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,Lägg produkter
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Produktkvalitetskontroll Parameter
DocType: Leave Application,Leave Approver Name,Ledighetsgodkännare Namn
DocType: Depreciation Schedule,Schedule Date,Schema Datum
DocType: Amazon MWS Settings,FR,FR
DocType: Packed Item,Packed Item,Packad artikel
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Service End Date cannot be before Invoice Posting Date,Rad nr {0}: Service slutdatum kan inte vara före fakturadatum
DocType: Job Offer Term,Job Offer Term,Erbjudandeperiod
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,Standardinställningar för att inköps transaktioner.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Activity Cost exists for Employee {0} against Activity Type - {1},Aktivitetskostnad existerar för anställd {0} mot Aktivitetstyp - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Obligatoriskt fält - Få studenter från
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Obligatoriskt fält - Få studenter från
DocType: Program Enrollment,Enrolled courses,Inskrivna kurser
DocType: Program Enrollment,Enrolled courses,Inskrivna kurser
DocType: Currency Exchange,Currency Exchange,Valutaväxling
apps/erpnext/erpnext/support/doctype/issue/issue.js,Resetting Service Level Agreement.,Återställ avtal om servicenivå.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Item Name,Produktnamn
DocType: Authorization Rule,Approving User  (above authorized value),Godkännande Användare (ovan auktoriserad värde)
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,Tillgodohavande
DocType: Employee,Widowed,Änka
DocType: Request for Quotation,Request for Quotation,Offertförfrågan
DocType: Healthcare Settings,Require Lab Test Approval,Kräv laboratorietest godkännande
DocType: Attendance,Working Hours,Arbetstimmar
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Totalt Utestående
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Ändra start / aktuella sekvensnumret av en befintlig serie.
DocType: Accounts Settings,Percentage you are allowed to bill more against the amount ordered. For example: If the order value is $100 for an item and tolerance is set as 10% then you are allowed to bill for $110.,Procentandel du får fakturera mer mot det beställda beloppet. Till exempel: Om ordervärdet är $ 100 för en artikel och toleransen är inställd på 10% får du fakturera $ 110.
DocType: Dosage Strength,Strength,Styrka
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Det går inte att hitta objekt med den här streckkoden
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Skapa en ny kund
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Förfaller på
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Om flera prissättningsregler fortsätta att gälla, kan användarna uppmanas att ställa Prioritet manuellt för att lösa konflikten."
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Return,bara Return
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,Skapa inköpsorder
,Purchase Register,Inköpsregistret
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Patienten hittades inte
DocType: Landed Cost Item,Applicable Charges,Tillämpliga avgifter
DocType: Workstation,Consumable Cost,Förbrukningsartiklar Kostnad
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time for {0} at index {1} can't be greater than Resolution Time.,Svarstiden för {0} vid index {1} kan inte vara större än upplösningstiden.
DocType: Purchase Receipt,Vehicle Date,Fordons Datum
DocType: Campaign Email Schedule,Campaign Email Schedule,Kampanjens e-postschema
DocType: Student Log,Medical,Medicinsk
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Var god välj Drug
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Bly Ägaren kan inte vara densamma som den ledande
DocType: Announcement,Receiver,Mottagare
DocType: Location,Area UOM,Område UOM
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Workstation is closed on the following dates as per Holiday List: {0},Arbetsstation är stängd på följande datum enligt kalender: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Opportunities,Möjligheter
DocType: Lab Test Template,Single,Singel
DocType: Compensatory Leave Request,Work From Date,Arbeta från datum
DocType: Salary Slip,Total Loan Repayment,Totala låne Återbetalning
DocType: Project User,View attachments,Visa bilagor
DocType: Account,Cost of Goods Sold,Kostnad för sålda varor
DocType: Article,Publish Date,Utgivningsdatum
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,Ange kostnadsställe
DocType: Drug Prescription,Dosage,Dosering
DocType: DATEV Settings,DATEV Settings,DATEV-inställningar
DocType: Journal Entry Account,Sales Order,Kundorder
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,Avg. Säljkurs
DocType: Assessment Plan,Examiner Name,examiner Namn
DocType: Lab Test Template,No Result,Inget resultat
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Fallback-serien är &quot;SO-WOO-&quot;.
DocType: Purchase Invoice Item,Quantity and Rate,Kvantitet och betyg
DocType: Delivery Note,% Installed,% Installerad
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Bolagets valutor för båda företagen ska matcha för Inter Company Transactions.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,Ange företagetsnamn först
DocType: Travel Itinerary,Non-Vegetarian,Ickevegetarisk
DocType: Purchase Invoice,Supplier Name,Leverantörsnamn
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Läs ERPNext Manual
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Visa löv av alla avdelningsmedlemmar i kalendern
DocType: Purchase Invoice,01-Sales Return,01-Försäljningsreturer
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Antal per BOM-linje
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Temporärt på håll
DocType: Account,Is Group,Är grupperad
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Credit Note {0} has been created automatically,Kreditnot {0} har skapats automatiskt
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Begäran om råvaror
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatiskt Serial Nos baserat på FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Kontrollera Leverantörens unika Fakturanummer
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,Primär adressuppgifter
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Public token is missing for this bank,Offentligt symbol saknas för denna bank
DocType: Vehicle Service,Oil Change,Oljebyte
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operating Cost as per Work Order / BOM,Driftskostnad per arbetsorder / BOM
DocType: Leave Encashment,Leave Balance,Lämna Balans
DocType: Asset Maintenance Log,Asset Maintenance Log,Asset Maintenance Log
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.',"""Till Ärende nr."" kan inte vara mindre än ""Från ärende nr"""
DocType: Certification Application,Non Profit,Välgörenhets
DocType: Production Plan,Not Started,Inte Startat
DocType: Lead,Channel Partner,Kanalpartner
DocType: Account,Old Parent,Gammalt mål
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Obligatoriskt fält - Academic Year
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1} är inte associerad med {2} {3}
DocType: Opportunity,Converted By,Konverterad av
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,You need to login as a Marketplace User before you can add any reviews.,Du måste logga in som Marketplace-användare innan du kan lägga till några recensioner.
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},Rad {0}: Drift krävs mot råvaruposten {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},Transaktion tillåts inte mot stoppad Arbetsorder {0}
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,Globala inställningar för alla tillverkningsprocesser.
DocType: Accounts Settings,Accounts Frozen Upto,Konton frysta upp till
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,Bearbeta dagboksdata
DocType: SMS Log,Sent On,Skickas på
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Incoming call from {0},Inkommande samtal från {0}
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,Attribut {0} valda flera gånger i attribut Tabell
DocType: HR Settings,Employee record is created using selected field. ,Personal register skapas med hjälp av valda fältet.
DocType: Sales Order,Not Applicable,Inte Tillämpbar
DocType: Amazon MWS Settings,UK,Storbritannien
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Öppna fakturaobjekt
DocType: Request for Quotation Item,Required Date,Obligatorisk Datum
DocType: Accounts Settings,Billing Address,Fakturaadress
DocType: Bank Statement Settings,Statement Headers,Statement Headers
DocType: Travel Request,Costing,Kostar
DocType: Tax Rule,Billing County,Billings County
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Om markerad, kommer skattebeloppet anses redan ingå i Skriv värdet / Skriv beloppet"
DocType: Request for Quotation,Message for Supplier,Meddelande till leverantören
DocType: BOM,Work Order,Arbetsorder
DocType: Sales Invoice,Total Qty,Totalt Antal
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-post-ID
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-post-ID
DocType: Item,Show in Website (Variant),Visa på webbplatsen (Variant)
DocType: Employee,Health Concerns,Hälsoproblem
DocType: Payroll Entry,Select Payroll Period,Välj Payroll Period
apps/erpnext/erpnext/regional/india/utils.py,"Invalid {0}! The check digit validation has failed.
			Please ensure you've typed the {0} correctly.",Ogiltig {0}! Valideringen av kontrollsiffran misslyckades. Se till att du har skrivit {0} korrekt.
DocType: Purchase Invoice,Unpaid,Obetald
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,Reserverade till salu
DocType: Packing Slip,From Package No.,Från Paket No.
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the transaction,Rad # {0}: Betalningsdokument krävs för att slutföra transaktionen
DocType: Item Attribute,To Range,Range
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Securities and Deposits,Värdepapper och inlåning
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Kan inte ändra värderingsmetoden, eftersom det finns transaktioner mot vissa poster som inte har egen värderingsmetod"
DocType: Student Report Generation Tool,Attended by Parents,Närvarade av föräldrar
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py,Employee {0} has already applied for {1} on {2} : ,Anställd {0} har redan ansökt om {1} på {2}:
DocType: Inpatient Record,AB Positive,AB Positiv
DocType: Job Opening,Description of a Job Opening,Beskrivning av ett jobb
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Pending activities for today,I avvaktan på aktiviteter för dag
DocType: Salary Structure,Salary Component for timesheet based payroll.,Lönedel för tidrapport baserad lönelistan.
DocType: Driver,Applicable for external driver,Gäller för extern drivrutin
DocType: Sales Order Item,Used for Production Plan,Används för produktionsplan
DocType: BOM,Total Cost (Company Currency),Total kostnad (företagsvaluta)
DocType: Loan,Total Payment,Total betalning
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Kan inte avbryta transaktionen för slutförd arbetsorder.
DocType: Manufacturing Settings,Time Between Operations (in mins),Time Between Operations (i minuter)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,PO redan skapad för alla beställningsobjekt
DocType: Healthcare Service Unit,Occupied,Ockuperade
DocType: Clinical Procedure,Consumables,Förbruknings
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,Inkludera standardbokposter
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,{0} {1} är avbruten så åtgärden kan inte slutföras
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Planerad kvantitet: Kvantitet för vilken arbetsorder har höjts, men väntar på att tillverkas."
DocType: Customer,Buyer of Goods and Services.,Köpare av varor och tjänster.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,&quot;anställd_fält_värde&quot; och &quot;tidsstämpel&quot; krävs.
DocType: Journal Entry,Accounts Payable,Leverantörsreskontra
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,Mängden {0} som anges i denna betalningsförfrågan skiljer sig från det beräknade beloppet för alla betalningsplaner: {1}. Se till att detta är korrekt innan du skickar in dokumentet.
DocType: Patient,Allergies,allergier
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,The selected BOMs are not for the same item,De valda stycklistor är inte samma objekt
apps/erpnext/erpnext/stock/doctype/item_variant_settings/item_variant_settings.py,Cannot set the field <b>{0}</b> for copying in variants,Det går inte att ställa in fältet <b>{0}</b> för kopiering i varianter
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Byt produktkod
DocType: Supplier Scorecard Standing,Notify Other,Meddela Annan
DocType: Vital Signs,Blood Pressure (systolic),Blodtryck (systolisk)
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1} är {2}
DocType: Item Price,Valid Upto,Giltig upp till
DocType: Leave Type,Expire Carry Forwarded Leaves (Days),Utgå Bär vidarebefordrade blad (dagar)
DocType: Training Event,Workshop,Verkstad
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Varna inköpsorder
DocType: Employee Tax Exemption Proof Submission,Rented From Date,Hyrd från datum
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Tillräckligt med delar för att bygga
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Spara först
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Items are required to pull the raw materials which is associated with it.,Föremål krävs för att dra råvarorna som är associerade med det.
DocType: POS Profile User,POS Profile User,POS Profil Användare
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,Rad {0}: Avskrivnings Startdatum krävs
DocType: Purchase Invoice Item,Service Start Date,Service Startdatum
DocType: Subscription Invoice,Subscription Invoice,Prenumerationsfaktura
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Direkt inkomst
DocType: Patient Appointment,Date TIme,Datum Tid
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Account, if grouped by Account","Kan inte filtrera baserat på konto, om grupperad efter konto"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Administrative Officer,Handläggare
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Var god välj Kurs
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Var god välj Kurs
DocType: Codification Table,Codification Table,Kodifierings tabell
DocType: Timesheet Detail,Hrs,H
apps/erpnext/erpnext/regional/report/datev/datev.py,<b>To Date</b> is a mandatory filter.,<b>Hittills</b> är ett obligatoriskt filter.
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Changes in {0},Förändringar i {0}
DocType: Employee Skill,Employee Skill,Anställdas skicklighet
DocType: Employee Advance,Returned Amount,Återlämnat belopp
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Account,Differenskonto
DocType: Pricing Rule,Discount on Other Item,Rabatt på annan artikel
DocType: Purchase Invoice,Supplier GSTIN,Leverantör GSTIN
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,Visa formulär
DocType: Work Order,Additional Operating Cost,Ytterligare driftkostnader
DocType: Lab Test Template,Lab Routine,Lab Routine
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Cosmetics,Kosmetika
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Completion Date for Completed Asset Maintenance Log,Var god välj Slutdatum för slutförd underhållsförteckning
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} is not the default supplier for any items.,{0} är inte standardleverantören för några artiklar.
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items","För att sammanfoga, måste följande egenskaper vara samma för båda objekten"
DocType: Supplier,Block Supplier,Blockleverantör
DocType: Shipping Rule,Net Weight,Nettovikt
DocType: Job Opening,Planned number of Positions,Planerat antal positioner
DocType: Employee,Emergency Phone,Nödtelefon
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,{0} {1} does not exist.,{0} {1} existerar inte.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Buy,Köpa
,Serial No Warranty Expiry,Serial Ingen garanti löper ut
DocType: Sales Invoice,Offline POS Name,Offline POS Namn
DocType: Task,Dependencies,beroenden
DocType: Bank Statement Transaction Payment Item,Payment Reference,Betalningsreferens
DocType: Supplier,Hold Type,Håll typ
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Ange grad för tröskelvärdet 0%
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Ange grad för tröskelvärdet 0%
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Bankredovisning Transaktionsbetalningsartikel
DocType: Sales Order,To Deliver,Att Leverera
DocType: Purchase Invoice Item,Item,Objekt
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,Hög känslighet
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Volontär typ information.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Cash Flow Mapping Template
DocType: Travel Request,Costing Details,Kostnadsdetaljer
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Visa Returer
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Serienummer objekt kan inte vara en bråkdel
DocType: Journal Entry,Difference (Dr - Cr),Skillnad (Dr - Cr)
DocType: Bank Guarantee,Providing,tillhandahålla
DocType: Account,Profit and Loss,Resultaträkning
DocType: Tally Migration,Tally Migration,Tally Migration
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,"Not permitted, configure Lab Test Template as required","Ej tillåtet, konfigurera Lab Test Template efter behov"
DocType: Patient,Risk Factors,Riskfaktorer
DocType: Patient,Occupational Hazards and Environmental Factors,Arbetsrisker och miljöfaktorer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,Lagerinmatningar som redan har skapats för arbetsorder
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Se tidigare order
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,{0} conversations,{0} konversationer
DocType: Vital Signs,Respiratory rate,Andningsfrekvens
apps/erpnext/erpnext/config/help.py,Managing Subcontracting,Hantera Underleverantörer
DocType: Vital Signs,Body Temperature,Kroppstemperatur
DocType: Project,Project will be accessible on the website to these users,Projektet kommer att vara tillgänglig på webbplatsen till dessa användare
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Kan inte avbryta {0} {1} eftersom serienummer {2} inte hör till lagret {3}
DocType: Detected Disease,Disease,Sjukdom
DocType: Company,Default Deferred Expense Account,Standard uppskjuten kostnadskonto
apps/erpnext/erpnext/config/projects.py,Define Project type.,Definiera projekttyp.
DocType: Supplier Scorecard,Weighting Function,Viktningsfunktion
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Totalt faktiskt belopp
DocType: Healthcare Practitioner,OP Consulting Charge,OP Consulting Charge
DocType: Student Report Generation Tool,Show Marks,Visa betyg
DocType: Support Settings,Get Latest Query,Hämta senaste frågan
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,I takt med vilket Prislistans valuta omvandlas till företagets basvaluta
apps/erpnext/erpnext/setup/doctype/company/company.py,Account {0} does not belong to company: {1},Kontot {0} tillhör inte företaget: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,Förkortningen används redan för ett annat företag
DocType: Selling Settings,Default Customer Group,Standard Kundgrupp
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Betalning Tems
DocType: Employee,IFSC Code,IFSC-kod
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Om inaktiverad ""Rundad Totalt fältet inte syns i någon transaktion"
DocType: BOM,Operating Cost,Rörelse Kostnad
DocType: Crop,Produced Items,Producerade produkter
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Matchtransaktion till fakturor
apps/erpnext/erpnext/erpnext_integrations/exotel_integration.py,Error in Exotel incoming call,Fel i Exotel-inkommande samtal
DocType: Sales Order Item,Gross Profit,Bruttoförtjänst
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Avblockera faktura
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Inkrement kan inte vara 0
DocType: Company,Delete Company Transactions,Radera Företagstransactions
DocType: Production Plan Item,Quantity and Description,Kvantitet och beskrivning
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference No and Reference Date is mandatory for Bank transaction,Referensnummer och referens Datum är obligatorisk för Bank transaktion
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Lägg till / redigera skatter och avgifter
DocType: Payment Entry Reference,Supplier Invoice No,Leverantörsfaktura Nej
DocType: Territory,For reference,Som referens
DocType: Healthcare Settings,Appointment Confirmation,Avtalsbekräftelse
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions","Kan inte ta bort Löpnummer {0}, eftersom det används i aktietransaktioner"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),Closing (Cr)
DocType: Purchase Invoice,Registered Composition,Registrerad sammansättning
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,Hallå
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Flytta objekt
DocType: Employee Incentive,Incentive Amount,Incitamentsbelopp
,Employee Leave Balance Summary,Sammanfattning av anställdas ledighet
DocType: Serial No,Warranty Period (Days),Garantiperiod (dagar)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,Totalt kredit- / debiteringsbelopp ska vara samma som länkad journalinmatning
DocType: Installation Note Item,Installation Note Item,Installeringsnotis objekt
DocType: Production Plan Item,Pending Qty,Väntar Antal
DocType: Budget,Ignore,Ignorera
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} är inte aktiv
DocType: Woocommerce Settings,Freight and Forwarding Account,Frakt och vidarebefordran konto
apps/erpnext/erpnext/config/accounts.py,Setup cheque dimensions for printing,kryss Setup dimensioner för utskrift
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Skapa lönesedlar
DocType: Vital Signs,Bloated,Uppsvälld
DocType: Salary Slip,Salary Slip Timesheet,Lön Slip Tidrapport
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Leverantör Warehouse obligatorisk för underleverantörer inköpskvitto
DocType: Item Price,Valid From,Giltig Från
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Your rating: ,Ditt betyg:
DocType: Sales Invoice,Total Commission,Totalt kommissionen
DocType: Tax Withholding Account,Tax Withholding Account,Skatteavdragskonto
DocType: Pricing Rule,Sales Partner,Försäljnings Partner
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Alla leverantörs scorecards.
DocType: Buying Settings,Purchase Receipt Required,Inköpskvitto Krävs
DocType: Sales Invoice,Rail,Järnväg
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Verklig kostnad
DocType: Item,Website Image,Webbplatsbild
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse in row {0} must be same as Work Order,Mållager i rad {0} måste vara samma som Arbetsorder
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,Värderingskurs är obligatoriskt om ingående lager angivits
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Invoice table,Inga träffar i Faktura tabellen
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,Välj Företag och parti typ först
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,"Already set default in pos profile {0} for user {1}, kindly disabled default","Ange redan standard i posprofil {0} för användare {1}, vänligt inaktiverad standard"
apps/erpnext/erpnext/config/accounts.py,Financial / accounting year.,Budget / räkenskapsåret.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,ackumulerade värden
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has already been delivered,Rad # {0}: Det går inte att radera artikel {1} som redan har levererats
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged","Tyvärr, kan serienumren inte slås samman"
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,Kundgruppen kommer att ställa in till vald grupp medan du synkroniserar kunder från Shopify
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,Territoriet är obligatoriskt i POS-profilen
DocType: Supplier,Prevent RFQs,Förhindra RFQs
DocType: Hub User,Hub User,Hub-användare
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Löneskalan lämnas in för perioden från {0} till {1}
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Passing Score value should be between 0 and 100,Värdet för godkänt resultat bör vara mellan 0 och 100
DocType: Loyalty Point Entry Redemption,Redeemed Points,Inlösta poäng
,Lead Id,Prospekt Id
DocType: C-Form Invoice Detail,Grand Total,Totalsumma
DocType: Assessment Plan,Course,Kurs
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Sektionskod
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item {0} at row {1},Värderingsgrad krävs för artikel {0} i rad {1}
DocType: Timesheet,Payslip,lönespecifikation
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Prissättningsregler {0} uppdateras
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,Halvdagens datum bör vara mellan datum och datum
DocType: POS Closing Voucher,Expense Amount,Kostnadsmängd
apps/erpnext/erpnext/public/js/pos/pos.html,Item Cart,Punkt varukorgen
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Capacity Planning Error, planned start time can not be same as end time","Kapacitetsplaneringsfel, planerad starttid kan inte vara samma som sluttid"
DocType: Quality Action,Resolution,Åtgärd
DocType: Employee,Personal Bio,Personligt Bio
DocType: C-Form,IV,IV
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,Medlemskaps-ID
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Ta emot i Warehouse Entry
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Levereras: {0}
DocType: QuickBooks Migrator,Connected to QuickBooks,Ansluten till QuickBooks
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},Vänligen identifiera / skapa konto (Ledger) för typ - {0}
DocType: Bank Statement Transaction Entry,Payable Account,Betalningskonto
DocType: Payment Entry,Type of Payment,Typ av betalning
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,Halvdagsdatum är obligatorisk
DocType: Sales Order,Billing and Delivery Status,Fakturering och leveransstatus
DocType: Job Applicant,Resume Attachment,CV Attachment
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,Återkommande kunder
DocType: Leave Control Panel,Allocate,Fördela
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Skapa variant
DocType: Sales Invoice,Shipping Bill Date,Fraktpostdatum
DocType: Production Plan,Production Plan,Produktionsplan
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Öppnande av fakturaverktyg
DocType: Salary Component,Round to the Nearest Integer,Runda till närmaste heltal
DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Låt varor som inte finns i lagret läggas till i kundvagnen
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Sales Return
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Ange antal i transaktioner baserat på serienummeringång
,Total Stock Summary,Total lageröversikt
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"You can only plan for upto {0} vacancies and budget {1} \
				for {2} as per staffing plan {3} for parent company {4}.",Du kan bara planera upp till {0} lediga tjänster och budget {1} \ för {2} enligt personalplan {3} för moderbolaget {4}.
DocType: Announcement,Posted By,Postat av
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0} to submit,Kvalitetskontroll krävs för att artikel {0} ska skickas in
DocType: Item,Delivered by Supplier (Drop Ship),Levereras av leverantören (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Bekräftelsemeddelande
apps/erpnext/erpnext/config/crm.py,Database of potential customers.,Databas för potentiella kunder.
DocType: Authorization Rule,Customer or Item,Kund eller föremål
apps/erpnext/erpnext/config/accounts.py,Customer database.,Kunddatabas.
DocType: Quotation,Quotation To,Offert Till
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,Medelinkomst
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),Öppning (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py,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.,Standard mätenhet för punkt {0} kan inte ändras direkt eftersom du redan har gjort vissa transaktioner (s) med en annan UOM. Du måste skapa en ny punkt för att använda en annan standard UOM.
DocType: Purchase Invoice,Overseas,Utomlands
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Vänligen ställ in företaget
DocType: Share Balance,Share Balance,Aktiebalans
DocType: Amazon MWS Settings,AWS Access Key ID,AWS Access Key ID
DocType: Production Plan,Download Required Materials,Ladda ner obligatoriskt material
DocType: Employee Tax Exemption Declaration,Monthly House Rent,Månadshyreshus
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Ställ in som klar
DocType: Purchase Order Item,Billed Amt,Fakturerat ant.
DocType: Training Result Employee,Training Result Employee,Utbildning Resultat anställd
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Ett logiskt lager mot vilken lagerposter görs.
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,Kapitalbelopp
DocType: Loan Application,Total Payable Interest,Totalt betalas ränta
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Totalt utestående: {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Contact,Öppen kontakt
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Fakturan Tidrapport
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No & Reference Date is required for {0},Referensnummer och referens Datum krävs för {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Serial no(s) required for serialized item {0},Serienummer krävs för serienummer {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Välj Betalkonto att Bank Entry
apps/erpnext/erpnext/config/accounts.py,Opening and Closing,Öppning och stängning
DocType: Hotel Settings,Default Invoice Naming Series,Standard Faktura Naming Series
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Skapa anställda register för att hantera löv, räkningar och löner"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,An error occurred during the update process,Ett fel uppstod under uppdateringsprocessen
DocType: Restaurant Reservation,Restaurant Reservation,Restaurangbokning
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Items,Dina artiklar
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,Förslagsskrivning
DocType: Payment Entry Deduction,Payment Entry Deduction,Betalning Entry Avdrag
DocType: Service Level Priority,Service Level Priority,Servicenivåprioritet
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Avslutar
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Meddela kunder via e-post
DocType: Item,Batch Number Series,Batch Number Series
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,En annan säljare {0} finns med samma anställningsid
DocType: Employee Advance,Claimed Amount,Skyldigt belopp
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Expire Allocation,Utgå tilldelning
DocType: QuickBooks Migrator,Authorization Settings,Auktoriseringsinställningar
DocType: Travel Itinerary,Departure Datetime,Avgång Datetime
apps/erpnext/erpnext/hub_node/api.py,No items to publish,Inga artiklar att publicera
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Please select Item Code first,Välj först artikelkod
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
DocType: Travel Request Costing,Travel Request Costing,Travel Request Costing
apps/erpnext/erpnext/config/healthcare.py,Masters,Masters
DocType: Employee Onboarding,Employee Onboarding Template,Medarbetare ombord på mall
DocType: Assessment Plan,Maximum Assessment Score,Maximal Assessment Score
apps/erpnext/erpnext/config/accounts.py,Update Bank Transaction Dates,Uppdatera banköverföring Datum
apps/erpnext/erpnext/config/projects.py,Time Tracking,Time Tracking
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICERA FÖR TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Rad {0} # Betalt belopp kan inte vara större än det begärda förskottsbeloppet
DocType: Fiscal Year Company,Fiscal Year Company,Räkenskapsårets Företag
DocType: Packing Slip Item,DN Detail,DN Detalj
DocType: Training Event,Conference,Konferens
DocType: Employee Grade,Default Salary Structure,Standard lönestruktur
DocType: Stock Entry,Send to Warehouse,Skicka till Warehouse
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,svar
DocType: Timesheet,Billed,Fakturerad
DocType: Batch,Batch Description,Batch Beskrivning
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Skapa studentgrupper
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Skapa studentgrupper
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.","Betalning Gateway konto inte skapat, vänligen skapa ett manuellt."
DocType: Supplier Scorecard,Per Year,Per år
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Not eligible for the admission in this program as per DOB,Inte berättigad till antagning i detta program enligt DOB
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,Rad nr {0}: Det går inte att radera artikel {1} som tilldelas kundens inköpsorder.
DocType: Sales Invoice,Sales Taxes and Charges,Försäljnings skatter och avgifter
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
DocType: Vital Signs,Height (In Meter),Höjd (In Meter)
DocType: Student,Sibling Details,syskon Detaljer
DocType: Vehicle Service,Vehicle Service,Vehicle service
DocType: Employee,Reason for Resignation,Anledning till Avgång
DocType: Sales Invoice,Credit Note Issued,Kreditnota utfärdad
DocType: Task,Weight,Vikt
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Journalanteckning Detaljer
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created,{0} banktransaktion (er) skapade
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0} {1} &quot;inte under räkenskapsåret {2}
DocType: Buying Settings,Settings for Buying Module,Inställningar för att köpa Modul
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belong to company {1},Asset {0} inte tillhör företaget {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter Purchase Receipt first,Ange inköpskvitto först
DocType: Buying Settings,Supplier Naming By,Leverantör Naming Genom
DocType: Activity Type,Default Costing Rate,Standardkalkyl betyg
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,Underhållsschema
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Sedan prissättningsregler filtreras bort baserat på kundens, Customer Group, Territory, leverantör, leverantör typ, kampanj, Sales Partner etc."
DocType: Employee Promotion,Employee Promotion Details,Uppgifter om anställningsfrämjande
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Nettoförändring i Inventory
DocType: Employee,Passport Number,Passnummer
DocType: Invoice Discounting,Accounts Receivable Credit Account,Kundfordringar Kreditkonto
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Relation med Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,Chef
DocType: Payment Entry,Payment From / To,Betalning från / till
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Från Fiscal Year
apps/erpnext/erpnext/selling/doctype/customer/customer.py,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nya kreditgränsen är mindre än nuvarande utestående beloppet för kunden. Kreditgräns måste vara minst {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},Vänligen ange konto i lager {0}
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,"""Baserad på"" och ""Gruppera efter"" kan inte vara samma"
DocType: Sales Person,Sales Person Targets,Försäljnings Person Mål
DocType: GSTR 3B Report,December,december
DocType: Work Order Operation,In minutes,På några minuter
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Se tidigare citat
DocType: Issue,Resolution Date,Åtgärds Datum
DocType: Lab Test Template,Compound,Förening
DocType: Opportunity,Probability (%),Sannolikhet (%)
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Dispatch Notification
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Välj Egenskaper
DocType: Course Activity,Course Activity,Kursaktivitet
DocType: Student Batch Name,Batch Name,batch Namn
DocType: Fee Validity,Max number of visit,Max antal besök
DocType: Accounting Dimension Detail,Mandatory For Profit and Loss Account,Obligatoriskt för resultaträkningskonto
,Hotel Room Occupancy,Hotellrumsboende
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please set default Cash or Bank account in Mode of Payment {0},Ställ in standard Kontant eller bankkonto i betalningssätt {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enroll,Skriva in
DocType: GST Settings,GST Settings,GST-inställningar
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Currency should be same as Price List Currency: {0},Valuta bör vara samma som Prislista Valuta: {0}
DocType: Selling Settings,Customer Naming By,Kundnamn på
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Visar eleven som närvarande i Student Monthly Närvaro Rapport
DocType: Depreciation Schedule,Depreciation Amount,avskrivningsbelopp
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,Konvertera till gruppen
DocType: Activity Cost,Activity Type,Aktivitetstyp
DocType: Request for Quotation,For individual supplier,För individuell leverantör
DocType: Workstation,Production Capacity,Produktionskapacitet
DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Company valuta)
,Qty To Be Billed,Antal som ska faktureras
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Levererad Mängd
DocType: Coupon Code,Gift Card,Present kort
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Reserverad antal för produktion: Råvarukvantitet för tillverkning av tillverkningsartiklar.
DocType: Loyalty Point Entry Redemption,Redemption Date,Inlösendatum
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Denna banktransaktion är redan helt avstämd
DocType: Sales Invoice,Packing List,Packlista
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Inköprsorder som ges till leverantörer.
DocType: Contract,Contract Template,Kontraktsmall
DocType: Clinical Procedure Item,Transfer Qty,Överföringsantal
DocType: Purchase Invoice Item,Asset Location,Asset Location
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Från datum kan inte vara större än till datum
DocType: Tax Rule,Shipping Zipcode,Frakt Postnummer
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,Publicering
DocType: Accounts Settings,Report Settings,Rapportinställningar
DocType: Activity Cost,Projects User,Projekt Användare
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Consumed,Förbrukat
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{0}: {1} not found in Invoice Details table,{0}: {1} hittades inte i listan fakturainformation
DocType: Asset,Asset Owner Company,Asset Owner Company
DocType: Company,Round Off Cost Center,Avrunda kostnadsställe
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Servicebesök {0} måste avbrytas innan man kan avbryta kundorder
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,Vad behöver du hjälp med?
DocType: Employee Checkin,Shift Start,Skiftstart
DocType: Appointment Booking Settings,Availability Of Slots,Tillgänglighet till slots
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,Material Transfer
DocType: Cost Center,Cost Center Number,Kostnadscentralnummer
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Det gick inte att hitta sökväg för
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Öppning (Dr)
DocType: Compensatory Leave Request,Work End Date,Arbetstid Slutdatum
DocType: Loan,Applicant,Sökande
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},Bokningstidsstämpel måste vara efter {0}
,GST Itemised Purchase Register,GST Artized Purchase Register
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,Tillämpligt om företaget är ett aktiebolag
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,Expected and Discharge dates cannot be less than Admission Schedule date,Förväntade datum och utskrivningsdatum får inte vara mindre än datum för antagningsplanen
DocType: Course Scheduling Tool,Reschedule,Boka om
DocType: Item Tax Template,Item Tax Template,Objekt skattemall
DocType: Loan,Total Interest Payable,Total ränta
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Anledning till håll
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Landed Cost skatter och avgifter
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Rad {0}: Vänligen ange skattefrihetsskäl i moms och avgifter
DocType: Quality Goal Objective,Quality Goal Objective,Kvalitetsmål Mål
DocType: Work Order Operation,Actual Start Time,Faktisk starttid
DocType: Purchase Invoice Item,Deferred Expense Account,Uppskjuten utgiftskonto
DocType: BOM Operation,Operation Time,Drifttid
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Yta
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,Bas
DocType: Timesheet,Total Billed Hours,Totalt Fakturerade Timmar
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Prissättningsartikelgrupp
DocType: Travel Itinerary,Travel To,Resa till
apps/erpnext/erpnext/config/accounts.py,Exchange Rate Revaluation master.,Valutakursrevaluering master.
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ställ in numreringsserier för närvaro via Setup&gt; Numbering Series
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,Avskrivningsbelopp
DocType: Leave Block List Allow,Allow User,Tillåt användaren
DocType: Journal Entry,Bill No,Fakturanr
DocType: Company,Gain/Loss Account on Asset Disposal,Vinst / Förlust konto på Asset Avfallshantering
DocType: Vehicle Log,Service Details,Service detaljer
DocType: Vehicle Log,Service Details,Service detaljer
DocType: Lab Test Template,Grouped,grupperade
DocType: Selling Settings,Delivery Note Required,Följesedel Krävs
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Inlämning av lönekläder ...
DocType: Bank Guarantee,Bank Guarantee Number,Bankgaranti nummer
DocType: Bank Guarantee,Bank Guarantee Number,Bankgaranti nummer
DocType: Assessment Criteria,Assessment Criteria,Bedömningskriterier
DocType: BOM Item,Basic Rate (Company Currency),Baskurs (Företagsvaluta)
apps/erpnext/erpnext/accounts/doctype/account/account.py,"While creating account for child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA",När du skapar konto för barnföretag {0} hittades inte moderkonto {1}. Skapa det överordnade kontot i motsvarande COA
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Delat utgåva
DocType: Student Attendance,Student Attendance,Student Närvaro
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Inga data att exportera
DocType: Sales Invoice Timesheet,Time Sheet,Tidrapportering
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Återrapportering Råvaror Based On
DocType: Sales Invoice,Port Code,Hamnkod
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reserve Warehouse,Reservlager
DocType: Lead,Lead is an Organization,Bly är en organisation
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Return amount cannot be greater unclaimed amount,Returbeloppet kan inte vara högre icke-krävda belopp
DocType: Guardian Interest,Interest,Intressera
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,pre Sales
DocType: Instructor Log,Other Details,Övriga detaljer
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Suplier,suplier
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Actual Delivery Date,Faktiskt leveransdatum
DocType: Lab Test,Test Template,Testmall
DocType: Restaurant Order Entry Item,Served,Serveras
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Kapitelinformation.
DocType: Account,Accounts,Konton
DocType: Vehicle,Odometer Value (Last),Vägmätare Value (Senaste)
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Mallar med leverantörsspecifika kriterier.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,Marknadsföring
DocType: Sales Invoice,Redeem Loyalty Points,Lösa in lojalitetspoäng
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,Betalning Entry redan har skapats
DocType: Request for Quotation,Get Suppliers,Få leverantörer
DocType: Purchase Receipt Item Supplied,Current Stock,Nuvarande lager
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,Systemet meddelar att man ökar eller minskar mängden eller mängden
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,Förhandsvisning lönebesked
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Skapa tidblad
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Konto {0} har angetts flera gånger
DocType: Account,Expenses Included In Valuation,Kostnader ingår i rapporten
apps/erpnext/erpnext/hooks.py,Purchase Invoices,Köp fakturor
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Du kan bara förnya om ditt medlemskap löper ut inom 30 dagar
DocType: Shopping Cart Settings,Show Stock Availability,Visa lager tillgänglighet
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Ange {0} i tillgångskategori {1} eller företag {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Enligt avsnitt 17 (5)
DocType: Location,Longitude,Longitud
,Absent Student Report,Frånvarorapport student
DocType: Crop,Crop Spacing UOM,Beskära Spacing UOM
DocType: Loyalty Program,Single Tier Program,Single Tier Program
DocType: Woocommerce Settings,Delivery After (Days),Leverans efter (dagar)
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Välj bara om du har inställningar för Cash Flow Mapper-dokument
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,Från adress 1
DocType: Email Digest,Next email will be sent on:,Nästa e-post kommer att skickas på:
DocType: Supplier Scorecard,Per Week,Per vecka
apps/erpnext/erpnext/stock/doctype/item/item.py,Item has variants.,Produkten har varianter.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,Totalt Student
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Produkt  {0} hittades inte
DocType: Bin,Stock Value,Stock Värde
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,Duplicera {0} hittades i tabellen
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,existerar inte företag {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} har avgiftsgiltighet till {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Tree Typ
DocType: Leave Control Panel,Employee Grade (optional),Medarbetarbetyg (valfritt)
DocType: Pricing Rule,Apply Rule On Other,Tillämpa regel på andra
DocType: BOM Explosion Item,Qty Consumed Per Unit,Antal konsumeras per Enhet
DocType: Shift Type,Late Entry Grace Period,Fristid för sen inresa
DocType: GST Account,IGST Account,IGST-konto
DocType: Serial No,Warranty Expiry Date,Garanti Förfallodatum
DocType: Material Request Item,Quantity and Warehouse,Kvantitet och Lager
DocType: Sales Invoice,Commission Rate (%),Provisionsandel (%)
DocType: Asset,Allow Monthly Depreciation,Tillåt månadsvis avskrivning
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Var god välj Program
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Var god välj Program
DocType: Project,Estimated Cost,Beräknad kostnad
DocType: Supplier Quotation,Link to material requests,Länk till material förfrågningar
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish,Publicera
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,Aerospace
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
DocType: Journal Entry,Credit Card Entry,Kreditkorts logg
apps/erpnext/erpnext/config/selling.py,Invoices for Costumers.,Fakturor för kunder.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,Värde
DocType: Asset Category,Depreciation Options,Avskrivningsalternativ
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,Varken plats eller anställd måste vara obligatorisk
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Skapa anställd
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Ogiltig inläggstid
DocType: Salary Component,Condition and Formula,Skick och formel
DocType: Lead,Campaign Name,Kampanjens namn
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Task Completion,På uppdragets slutförande
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},Det finns ingen ledighet mellan {0} och {1}
DocType: Fee Validity,Healthcare Practitioner,Hälso- och sjukvårdspersonal
DocType: Hotel Room,Capacity,Kapacitet
DocType: Travel Request Costing,Expense Type,Kostnadstyp
DocType: Selling Settings,Close Opportunity After Days,Nära möjlighet efter dagar
,Reserved,Reserverat
DocType: Driver,License Details,Licensinformation
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,Fältet från aktieägare kan inte vara tomt
DocType: Leave Allocation,Allocation,Tilldelning
DocType: Purchase Order,Supply Raw Materials,Supply Råvaror
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,Strukturer har tilldelats framgångsrikt
apps/erpnext/erpnext/config/getting_started.py,Create Opening Sales and Purchase Invoices,Skapa öppningsförsäljnings- och köpfakturor
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,Nuvarande Tillgångar
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0} är inte en lagervara
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Vänligen dela din feedback till träningen genom att klicka på &quot;Träningsreaktion&quot; och sedan &quot;Ny&quot;
DocType: Call Log,Caller Information,Information om uppringare
DocType: Mode of Payment Account,Default Account,Standard konto
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,Var god välj Sample Retention Warehouse i Lagerinställningar först
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,Var god välj flerprograms-programtypen för mer än en insamlingsregler.
DocType: Payment Entry,Received Amount (Company Currency),Erhållet belopp (Company valuta)
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Cancelled. Please check your GoCardless Account for more details,Betalning Avbruten. Kontrollera ditt GoCardless-konto för mer information
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Hoppa över material till WIP Warehouse
DocType: Contract,N/A,N / A
DocType: Task Type,Task Type,Uppgiftstyp
DocType: Topic,Topic Content,Ämneinnehåll
DocType: Delivery Settings,Send with Attachment,Skicka med bilagan
DocType: Service Level,Priorities,prioriteringar
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,Välj helgdagar
DocType: Inpatient Record,O Negative,O Negativ
DocType: Work Order Operation,Planned End Time,Planerat Sluttid
DocType: POS Profile,Only show Items from these Item Groups,Visa endast artiklar från dessa artikelgrupper
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction cannot be converted to ledger,Konto med befintlig transaktioner kan inte omvandlas till liggaren
apps/erpnext/erpnext/config/non_profit.py,Memebership Type Details,Memebership Type Detaljer
DocType: Delivery Note,Customer's Purchase Order No,Kundens inköpsorder Nr
DocType: Clinical Procedure,Consume Stock,Konsumera lager
DocType: Budget,Budget Against,budget mot
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Förlorade skäl
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Automaterial Framställningar Generated
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),Arbetstider under vilka Half Day markeras. (Noll att inaktivera)
DocType: Job Card,Total Completed Qty,Totalt slutfört antal
DocType: HR Settings,Auto Leave Encashment,Automatisk lämna kabinett
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,Förlorade
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,Du kan inte ange aktuell kupong i 'Mot Journalposter' kolumnen
DocType: Employee Benefit Application Detail,Max Benefit Amount,Max förmånsbelopp
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Reserverat för tillverkning
DocType: Soil Texture,Sand,Sand
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,Energi
DocType: Opportunity,Opportunity From,Möjlighet Från
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Rad {0}: {1} Serienummer krävs för punkt {2}. Du har angett {3}.
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than delivered quantity,Kan inte ställa in kvantitet mindre än levererad kvantitet
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Välj en tabell
DocType: BOM,Website Specifications,Webbplats Specifikationer
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,Lägg till kontot till rotnivå Företag -% s
DocType: Content Activity,Content Activity,Innehållsaktivitet
DocType: Special Test Items,Particulars,uppgifter
DocType: Employee Checkin,Employee Checkin,Anställd checkin
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}: Från {0} av typen {1}
apps/erpnext/erpnext/config/crm.py,Sends Mails to lead or contact based on a Campaign schedule,Skickar e-post till ledare eller kontakt baserat på ett kampanjschema
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,Rad {0}: Omvandlingsfaktor är obligatoriskt
DocType: Student,A+,A+
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Flera Pris Regler finns med samma kriterier, vänligen lösa konflikter genom att tilldela prioritet. Pris Regler: {0}"
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Valutakursomräkningskonto
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Min Amt kan inte vara större än Max Amt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cannot deactivate or cancel BOM as it is linked with other BOMs,Det går inte att inaktivera eller avbryta BOM eftersom det är kopplat till andra stycklistor
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,Var god välj Företag och Bokningsdatum för att få poster
DocType: Asset,Maintenance,Underhåll
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Få från patientmötet
DocType: Subscriber,Subscriber,Abonnent
DocType: Item Attribute Value,Item Attribute Value,Produkt Attribut Värde
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,Currency Exchange must be applicable for Buying or for Selling.,Valutaväxling måste vara tillämplig för köp eller försäljning.
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Only expired allocation can be cancelled,Endast tilldelad tilldelning kan avbrytas
DocType: Item,Maximum sample quantity that can be retained,Maximal provkvantitet som kan behållas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Rad {0} # Artikel {1} kan inte överföras mer än {2} mot inköpsorder {3}
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,Säljkampanjer.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Unknown Caller,Okänd uppringare
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

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

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Schablonskatt mall som kan tillämpas på alla försäljningstransaktioner. Denna mall kan innehålla en lista över skatte huvuden och även andra kostnader / intäkter huvuden som &quot;Shipping&quot;, &quot;Försäkring&quot;, &quot;Hantera&quot; etc. #### Obs Skattesatsen du definierar här kommer att bli den schablonskatt för alla ** poster **. Om det finns ** artiklar ** som har olika priser, måste de läggas till i ** Punkt skatt ** tabellen i ** Punkt ** mästare. #### Beskrivning av kolumner 1. Beräkning Typ: - Det kan vara på ** Net Totalt ** (som är summan av grundbeloppet). - ** I föregående v Totalt / Belopp ** (för kumulativa skatter eller avgifter). Om du väljer det här alternativet, kommer skatten att tillämpas som en procentandel av föregående rad (i skattetabellen) belopp eller total. - ** Faktisk ** (som nämns). 2. Konto Head: Konto huvudbok enligt vilket denna skatt kommer att bokas 3. Kostnadsställe: Om skatten / avgiften är en inkomst (som sjöfarten) eller kostnader det måste bokas mot ett kostnadsställe. 4. Beskrivning: Beskrivning av skatten (som ska skrivas ut i fakturor / citationstecken). 5. Sätt betyg: skattesats. 6. Belopp Momsbelopp. 7. Totalt: Ackumulerad total till denna punkt. 8. Skriv Row: Om baserad på &quot;Föregående rad Total&quot; kan du välja radnumret som kommer att tas som en bas för denna beräkning (standard är föregående rad). 9. Är denna skatt ingår i Basic Rate ?: Om du markerar detta, betyder det att denna skatt inte kommer att visas under posten tabellen, men kommer att ingå i en basnivå i din huvudfråga tabellen. Detta är användbart när du vill ge ett fast pris (inklusive alla skatter) pris till kunderna."
DocType: Quality Action,Corrective,korrigerande
DocType: Employee,Bank A/C No.,Bank A / C nr
DocType: Quality Inspection Reading,Reading 7,Avläsning 7
DocType: Purchase Invoice,UIN Holders,UIN-innehavare
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,delvis Beställde
DocType: Lab Test,Lab Test,Labb test
DocType: Student Report Generation Tool,Student Report Generation Tool,Generationsverktyg för studentrapporter
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Sjukvård Schedule Time Slot
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,Doc Namn
DocType: Expense Claim Detail,Expense Claim Type,Räknings Typ
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Standardinställningarna för Varukorgen
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Save Item,Spara objekt
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Expense,Ny kostnad
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Ignorera befintligt beställt antal
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Lägg till Timeslots
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Vänligen ange konto i lager {0} eller standardinventariskonto i företag {1}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},Asset skrotas via Journal Entry {0}
DocType: Loan,Interest Income Account,Ränteintäkter Account
DocType: Bank Transaction,Unreconciled,sonade
DocType: Shift Type,Allow check-out after shift end time (in minutes),Tillåt utcheckning efter skiftets sluttid (i minuter)
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,Max fördelar bör vara större än noll för att fördela fördelarna
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Granska inbjudan skickad
DocType: Shift Assignment,Shift Assignment,Shift-uppgift
DocType: Employee Transfer Property,Employee Transfer Property,Anställningsöverföringsfastighet
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Equity/Liability Account cannot be blank,Fältet Kapital / ansvarskonto kan inte vara tomt
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,Från tiden borde vara mindre än till tiden
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Biotechnology,Biotechnology
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
						 to fullfill Sales Order {2}.",Objekt {0} (Serienummer: {1}) kan inte förbrukas som är reserverat \ för att fylla i försäljningsordern {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Maintenance Expenses,Kontor underhållskostnader
,BOM Explorer,BOM Explorer
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Uppdatera priset från Shopify till ERPNext Price List
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Ställa in e-postkonto
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,Ange Artikel först
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Behöver analys
DocType: Asset Repair,Downtime,Driftstopp
DocType: Account,Liability,Ansvar
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sanktionerade Belopp kan inte vara större än fordringsbelopp i raden {0}.
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,Akademisk - termin:
DocType: Salary Detail,Do not include in total,Inkludera inte totalt
DocType: Quiz Activity,Quiz Activity,Quizaktivitet
DocType: Company,Default Cost of Goods Sold Account,Standardkostnad Konto Sålda Varor
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Sample quantity {0} cannot be more than received quantity {1},Provkvantitet {0} kan inte vara mer än mottagen kvantitet {1}
DocType: Employee,Family Background,Familjebakgrund
DocType: Request for Quotation Supplier,Send Email,Skicka Epost
DocType: Quality Goal,Weekday,Veckodag
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid Attachment {0},Varning: Ogiltig Attachment {0}
DocType: Item,Max Sample Quantity,Max provkvantitet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,Inget Tillstånd
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Checklista för kontraktsuppfyllelse
DocType: Vital Signs,Heart Rate / Pulse,Hjärtfrekvens / puls
DocType: Supplier,Default Bank Account,Standard bankkonto
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"To filter based on Party, select Party Type first","För att filtrera baserat på partiet, väljer Party Typ först"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},"""Uppdatera lager"" kan inte klaras av eftersom objekt inte levereras via {0}"
DocType: Vehicle,Acquisition Date,förvärvs~~POS=TRUNC
apps/erpnext/erpnext/regional/italy/utils.py,Nos,Nos
DocType: Item,Items with higher weightage will be shown higher,Produkter med högre medelvikt kommer att visas högre
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Lab Tests and Vital Signs,Lab-test och vitala tecken
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br><br> {0},Följande serienummer skapades: <br><br> {0}
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bankavstämning Detalj
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No employee found,Ingen anställd hittades
DocType: Item,If subcontracted to a vendor,Om underleverantörer till en leverantör
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Studentgruppen är redan uppdaterad.
DocType: HR Settings,Restrict Backdated Leave Application,Begränsa ansökan om utdaterad permission
apps/erpnext/erpnext/config/projects.py,Project Update.,Projektuppdatering.
DocType: SMS Center,All Customer Contact,Alla Kundkontakt
DocType: Location,Tree Details,Tree Detaljerad information
DocType: Marketplace Settings,Registered,Registrerad
DocType: Training Event,Event Status,Händelsestatus
DocType: Volunteer,Availability Timeslot,Tillgänglighet Timeslot
apps/erpnext/erpnext/config/support.py,Support Analytics,Stöd Analytics
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,"If you have any questions, please get back to us.","Om du har några frågor, vänligen komma tillbaka till oss."
DocType: Cash Flow Mapper,Cash Flow Mapper,Cash Flow Mapper
DocType: Item,Website Warehouse,Webbplatslager
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimifakturabelopp
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Kostnadsställe {2} tillhör inte bolaget {3}
apps/erpnext/erpnext/www/lms/program.py,Program {0} does not exist.,Program {0} finns inte.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} cannot be a Group,{0} {1}: konto {2} inte kan vara en grupp
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,Tidrapport {0} är redan slutförts eller avbrutits
DocType: QuickBooks Migrator,QuickBooks Migrator,QuickBooks Migrator
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,Inga uppgifter
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Försäljningsfaktura {0} skapad som betald
DocType: Item Variant Settings,Copy Fields to Variant,Kopiera fält till variant
DocType: Asset,Opening Accumulated Depreciation,Ingående ackumulerade avskrivningar
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js,Score must be less than or equal to 5,Betyg måste vara mindre än eller lika med 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Programmet Inskrivning Tool
apps/erpnext/erpnext/config/accounts.py,C-Form records,C-Form arkiv
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,Aktierna existerar redan
apps/erpnext/erpnext/config/help.py,Customer and Supplier,Kunder och leverantör
DocType: Email Digest,Email Digest Settings,E-postutskick Inställningar
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Thank you for your business!,Tack för din verksamhet!
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Support frågor från kunder.
DocType: Employee Property History,Employee Property History,Anställdas fastighetshistoria
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Variant Baserad på kan inte ändras
DocType: Setup Progress Action,Action Doctype,Åtgärd Doctype
DocType: HR Settings,Retirement Age,Pensionsålder
DocType: Bin,Moving Average Rate,Rörligt medelvärdes hastighet
DocType: Share Transfer,To Shareholder,Till aktieägare
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} mot räkning {1} daterad {2}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,Från staten
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Tilldela löv ...
DocType: Program Enrollment,Vehicle/Bus Number,Fordons- / bussnummer
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Contact,Skapa ny kontakt
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,Kursschema
DocType: GSTR 3B Report,GSTR 3B Report,GSTR 3B-rapport
DocType: Request for Quotation Supplier,Quote Status,Citatstatus
DocType: GoCardless Settings,Webhooks Secret,Webbooks Secret
DocType: Maintenance Visit,Completion Status,Slutförande Status
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Total payments amount can't be greater than {},Det totala betalningsbeloppet kan inte vara större än {}
DocType: Daily Work Summary Group,Select Users,Välj användare
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Hotellrumsprispost
DocType: Loyalty Program Collection,Tier Name,Tier Name
DocType: HR Settings,Enter retirement age in years,Ange pensionsåldern i år
DocType: Job Card,PO-JOB.#####,PO-JOB. #####
DocType: Crop,Target Warehouse,Target Lager
DocType: Payroll Employee Detail,Payroll Employee Detail,Lön Employee Detail
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,Var god välj ett lager
DocType: Cheque Print Template,Starting location from left edge,Startplats från vänstra kanten
,Territory Target Variance Based On Item Group,Territorium Målvarians baserad på artikelgrupp
DocType: Upload Attendance,Import Attendance,Import Närvaro
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,Alla artikelgrupper
DocType: Work Order,Item To Manufacture,Produkt för att tillverka
DocType: Leave Control Panel,Employment Type (optional),Anställningstyp (valfritt)
DocType: Pricing Rule,Threshold for Suggestion,Tröskel för förslag
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},{0} {1} status är {2}
DocType: Water Analysis,Collection Temperature ,Samlingstemperatur
DocType: Employee,Provide Email Address registered in company,Ge e-postadress är registrerad i sällskap
DocType: Shopping Cart Settings,Enable Checkout,göra det möjligt för kassan
apps/erpnext/erpnext/config/help.py,Purchase Order to Payment,Inköpsorder till betalning
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Projicerad Antal
DocType: Sales Invoice,Payment Due Date,Förfallodag
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Reserved Qty: Quantity ordered for sale, but not delivered.","Reserverad antal: Antal som beställts för försäljning, men inte levererat."
DocType: Drug Prescription,Interval UOM,Intervall UOM
DocType: Customer,"Reselect, if the chosen address is edited after save",Återmarkera om den valda adressen redigeras efter spara
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,Punkt Variant {0} finns redan med samma attribut
DocType: Item,Hub Publishing Details,Hub Publishing Detaljer
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',&quot;Öppna&quot;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,Öppna för att göra
DocType: Pricing Rule,Mixed Conditions,Blandade villkor
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary Saved,Samtal Sammanfattning sparad
DocType: Issue,Via Customer Portal,Via kundportalen
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Faktiskt belopp
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,SGST-belopp
DocType: Lab Test Template,Result Format,Resultatformat
DocType: Expense Claim,Expenses,Kostnader
DocType: Service Level,Support Hours,Stödtimmar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Delivery Notes,Följesedlar
DocType: Item Variant Attribute,Item Variant Attribute,Punkt Variant Attribut
,Purchase Receipt Trends,Kvitto Trender
DocType: Payroll Entry,Bimonthly,Varannan månad
DocType: Vehicle Service,Brake Pad,Brake Pad
DocType: Fertilizer,Fertilizer Contents,Innehåll för gödselmedel
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research & Development,Forskning &amp; Utveckling
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,Belopp till fakturera
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Based On Payment Terms,Baserat på betalningsvillkor
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,ERPNext-inställningar
DocType: Company,Registration Details,Registreringsdetaljer
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,Det gick inte att ställa servicenivåavtal {0}.
DocType: Timesheet,Total Billed Amount,Totala fakturerade beloppet
DocType: Item Reorder,Re-Order Qty,Återuppta Antal
DocType: Leave Block List Date,Leave Block List Date,Lämna Blockeringslista Datum
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Parameter för kvalitetsåterkoppling
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Råmaterial kan inte vara samma som huvudartikel
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Totalt tillämpliga avgifter i inköpskvittot Items tabellen måste vara densamma som den totala skatter och avgifter
DocType: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.",Om det är aktiverat kommer systemet att skapa arbetsordern för de exploderade artiklarna mot vilka BOM är tillgänglig.
DocType: Sales Team,Incentives,Sporen
apps/erpnext/erpnext/accounts/general_ledger.py,Values Out Of Sync,Värden utan synk
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Difference Value,Skillnadsvärde
DocType: SMS Log,Requested Numbers,Begärda nummer
DocType: Volunteer,Evening,Kväll
DocType: Quiz,Quiz Configuration,Quizkonfiguration
DocType: Customer Credit Limit,Bypass credit limit check at Sales Order,Bifoga kreditgränskontroll vid Försäljningsorder
DocType: Vital Signs,Normal,Vanligt
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Aktivera användning för Varukorgen &quot;, som Kundvagnen är aktiverad och det bör finnas åtminstone en skattebestämmelse för Varukorgen"
DocType: Sales Invoice Item,Stock Details,Lager Detaljer
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,Projekt Värde
apps/erpnext/erpnext/config/help.py,Point-of-Sale,Butiksförsäljnig
DocType: Fee Schedule,Fee Creation Status,Fee Creation Status
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,Skapa försäljningsorder för att hjälpa dig planera ditt arbete och leverera i tid
DocType: Vehicle Log,Odometer Reading,mätarställning
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Kontosaldo redan i Kredit,du är inte tillåten att ställa in ""Balans måste vara"" som ""Debet '"
DocType: Account,Balance must be,Balans måste vara
,Available Qty,Tillgång Antal
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Standardlager för att skapa försäljningsorder och leveransnotering
DocType: Purchase Taxes and Charges,On Previous Row Total,På föregående v Totalt
DocType: Purchase Invoice Item,Rejected Qty,Avvisad Antal
DocType: Setup Progress Action,Action Field,Åtgärdsområde
DocType: Healthcare Settings,Manage Customer,Hantera kund
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Synkronisera alltid dina produkter från Amazon MWS innan du synkroniserar orderuppgifterna
DocType: Delivery Trip,Delivery Stops,Leveransstopp
DocType: Salary Slip,Working Days,Arbetsdagar
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Kan inte ändra servicestoppdatum för objekt i rad {0}
DocType: Serial No,Incoming Rate,Inkommande betyg
DocType: Packing Slip,Gross Weight,Bruttovikt
DocType: Leave Type,Encashment Threshold Days,Encashment Threshold Days
,Final Assessment Grades,Final Assessment Grades
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,Namnet på ditt företag som du ställer in det här systemet.
DocType: HR Settings,Include holidays in Total no. of Working Days,Inkludera semester i Totalt antal. Arbetsdagar
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py,Setup your Institute in ERPNext,Ställ in ditt institut i ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Växtanalys
DocType: Task,Timeline,tidslinje
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,Håll
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Alternativ artikel
DocType: Shopify Log,Request Data,Förfrågningsuppgifter
DocType: Employee,Date of Joining,Datum för att delta
DocType: Naming Series,Update Series,Uppdatera Serie
DocType: Supplier Quotation,Is Subcontracted,Är utlagt
DocType: Restaurant Table,Minimum Seating,Minsta sätet
DocType: Item Attribute,Item Attribute Values,Produkt Attribut Värden
DocType: Examination Result,Examination Result,Examination Resultat
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Purchase Receipt,Inköpskvitto
,Received Items To Be Billed,Mottagna objekt som ska faktureras
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,Please set default UOM in Stock Settings,Ange standard UOM i lagerinställningar
DocType: Purchase Invoice,Accounting Dimensions,Redovisningsdimensioner
,Subcontracted Raw Materials To Be Transferred,Underleverantörer av råvaror som ska överföras
apps/erpnext/erpnext/config/accounts.py,Currency exchange rate master.,Valutakurs mästare.
,Sales Person Target Variance Based On Item Group,Försäljare Målvariation baserad på artikelgrupp
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},Referens Doctype måste vara en av {0}
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js,Filter Total Zero Qty,Filtrera totalt antal noll
DocType: Work Order,Plan material for sub-assemblies,Planera material för underenheter
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse due to a large amount of entries.,Ställ in filter baserat på artikel eller lager på grund av en stor mängd poster.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,BOM {0} måste vara aktiv
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,Inga objekt tillgängliga för överföring
DocType: Employee Boarding Activity,Activity Name,Aktivitetsnamn
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Ändra Utgivningsdatum
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Slutproduktkvantitet <b>{0}</b> och För kvantitet <b>{1}</b> kan inte vara annorlunda
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Stängning (Öppning + Totalt)
DocType: Delivery Settings,Dispatch Notification Attachment,Dispatch Notification Attachment
DocType: Payroll Entry,Number Of Employees,Antal anställda
DocType: Journal Entry,Depreciation Entry,avskrivningar Entry
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,Välj dokumenttyp först
apps/erpnext/erpnext/stock/doctype/item/item.py,You have to enable auto re-order in Stock Settings to maintain re-order levels.,Du måste aktivera automatisk ombeställning i lagerinställningar för att upprätthålla ombeställningsnivåer.
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,Avbryt Material {0} innan du avbryter detta Underhållsbesök
DocType: Pricing Rule,Rate or Discount,Betygsätt eller rabatt
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Details,Bankuppgifter
DocType: Vital Signs,One Sided,Ensidig
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},Löpnummer {0} inte tillhör punkt {1}
DocType: Purchase Order Item Supplied,Required Qty,Obligatorisk Antal
DocType: Marketplace Settings,Custom Data,Anpassade data
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Lager med befintlig transaktion kan inte konverteras till redovisningen.
DocType: Service Day,Service Day,Servicedag
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Projektöversikt för {0}
apps/erpnext/erpnext/hub_node/api.py,Unable to update remote activity,Det gick inte att uppdatera fjärraktivitet
DocType: Bank Reconciliation,Total Amount,Totala Summan
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,From Date and To Date lie in different Fiscal Year,Från datum till datum ligger olika fiscalår
apps/erpnext/erpnext/healthcare/utils.py,The Patient {0} do not have customer refrence to invoice,Patienten {0} har ingen kundreferens att fakturera
DocType: Quality Feedback Template,Quality Feedback Template,Kvalitetsåterkopplingsmall
apps/erpnext/erpnext/config/education.py,LMS Activity,LMS-aktivitet
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,Internet Publishing
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,Skapa {0} faktura
DocType: Medical Code,Medical Code Standard,Medicinsk kod Standard
DocType: Soil Texture,Clay Composition (%),Lerkomposition (%)
DocType: Item Group,Item Group Defaults,Produktgruppsinställningar
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,Var god spara innan du ansluter uppgiften.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Balans Värde
DocType: Lab Test,Lab Technician,Labbtekniker
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,Försäljning Prislista
DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Om den är markerad kommer en kund att skapas, mappad till patienten. Patientfakturor kommer att skapas mot den här kunden. Du kan också välja befintlig kund medan du skapar patienten."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,Kunden är inte inskriven i något lojalitetsprogram
DocType: Bank Reconciliation,Account Currency,Konto Valuta
DocType: Lab Test,Sample ID,Prov ID
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,Ango Avrundningskonto i bolaget
DocType: Purchase Receipt,Range,Intervall
DocType: Supplier,Default Payable Accounts,Standard avgiftskonton
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is not active or does not exist,Medarbetare {0} är inte aktiv eller existerar inte
DocType: Fee Structure,Components,Komponenter
DocType: Support Search Source,Search Term Param Name,Sök term Param Namn
DocType: Item Barcode,Item Barcode,Produkt Streckkod
DocType: Delivery Trip,In Transit,I transit
DocType: Woocommerce Settings,Endpoints,endpoints
DocType: Shopping Cart Settings,Show Configure Button,Visa inställningsknapp
DocType: Quality Inspection Reading,Reading 6,Avläsning 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot {0} {1} {2} without any negative outstanding invoice,Kan inte {0} {1} {2} utan någon negativ enastående faktura
DocType: Share Transfer,From Folio No,Från Folio nr
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Inköpsfakturan Advancerat
DocType: Shift Type,Every Valid Check-in and Check-out,Varje giltig incheckning och utcheckning
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Credit entry can not be linked with a {1},Rad {0}: kreditering kan inte kopplas till en {1}
apps/erpnext/erpnext/config/accounts.py,Define budget for a financial year.,Definiera budget för budgetåret.
DocType: Shopify Tax Account,ERPNext Account,ERPNext-konto
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.py,Provide the academic year and set the starting and ending date.,Ange läsåret och ange start- och slutdatum.
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,{0} är blockerad så denna transaktion kan inte fortsätta
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Åtgärd om ackumulerad månadsbudget överskrider MR
DocType: Employee,Permanent Address Is,Permanent Adress är
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Enter Supplier,Ange leverantör
DocType: Work Order Operation,Operation completed for how many finished goods?,Driften färdig för hur många färdiga varor?
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},Hälso-och sjukvårdspersonal {0} är inte tillgänglig på {1}
DocType: Payment Terms Template,Payment Terms Template,Betalningsvillkor Mall
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,Varumärket
DocType: Employee Tax Exemption Proof Submission,Rented To Date,Hyrd till datum
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Tillåt flera materialförbrukning
DocType: Employee,Exit Interview Details,Avsluta intervju Detaljer
DocType: Item,Is Purchase Item,Är beställningsobjekt
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Inköpsfaktura
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Tillåt flera materialförbrukning mot en arbetsorder
DocType: GL Entry,Voucher Detail No,Rabatt Detalj nr
DocType: Email Digest,New Sales Invoice,Ny försäljningsfaktura
DocType: Stock Entry,Total Outgoing Value,Totalt Utgående Värde
DocType: Healthcare Practitioner,Appointments,utnämningar
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Åtgärd initierad
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,Öppningsdatum och Slutdatum bör ligga inom samma räkenskapsår
DocType: Lead,Request for Information,Begäran om upplysningar
DocType: Course Activity,Activity Date,Aktivitetsdatum
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} av {}
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Betygsätt med marginal (Företagsvaluta)
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Categories,kategorier
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Synkroniserings Offline fakturor
DocType: Payment Request,Paid,Betalats
DocType: Service Level,Default Priority,Standardprioritet
DocType: Program Fee,Program Fee,Kurskostnad
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Byt ut en särskild BOM i alla andra BOM där den används. Det kommer att ersätta den gamla BOM-länken, uppdatera kostnaden och regenerera &quot;BOM Explosion Item&quot; -tabellen enligt ny BOM. Det uppdaterar också senaste priset i alla BOM."
DocType: Employee Skill Map,Employee Skill Map,Medarbetarkompetens
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,Följande Arbetsorder har skapats:
DocType: Salary Slip,Total in words,Totalt i ord
DocType: Inpatient Record,Discharged,urladdat
DocType: Material Request Item,Lead Time Date,Ledtid datum
,Employee Advance Summary,Sammanfattning av anställd
DocType: Asset,Available-for-use Date,Tillgänglig för användning Datum
DocType: Guardian,Guardian Name,Guardian Namn
DocType: Cheque Print Template,Has Print Format,Har Utskriftsformat
DocType: Support Settings,Get Started Sections,Kom igång sektioner
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-bly-.YYYY.-
DocType: Invoice Discounting,Sanctioned,sanktionerade
,Base Amount,Basbelopp
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Totala bidragsbeloppet: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},Rad # {0}: Ange Löpnummer för punkt {1}
DocType: Payroll Entry,Salary Slips Submitted,Löneskikt skickas in
DocType: Crop Cycle,Crop Cycle,Beskärningscykel
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,"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.","För ""Produktgrupper"" poster, Lager, Serienummer och Batch kommer  att övervägas från ""Packlistan"". Om Lager och Batch inte är samma för alla förpacknings objekt för alla ""Produktgrupper"" , kan dessa värden skrivas in i huvud produkten, kommer värden kopieras till ""Packlistan""."
DocType: Amazon MWS Settings,BR,BR
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,Från plats
DocType: Student Admission,Publish on website,Publicera på webbplats
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Leverantörsfakturor Datum kan inte vara större än Publiceringsdatum
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Subscription,Cancelation Date,Avbokningsdatum
DocType: Purchase Invoice Item,Purchase Order Item,Inköpsorder Artikeln
DocType: Agriculture Task,Agriculture Task,Jordbruksuppgift
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Income,Indirekt inkomst
DocType: Student Attendance Tool,Student Attendance Tool,Student Närvaro Tool
DocType: Restaurant Menu,Price List (Auto created),Prislista (automatiskt skapad)
DocType: Pick List Item,Picked Qty,Plockad antal
DocType: Cheque Print Template,Date Settings,Datum Inställningar
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,En fråga måste ha mer än ett alternativ
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,Varians
DocType: Employee Promotion,Employee Promotion Detail,Arbetstagarreklamdetalj
DocType: Delivery Trip,Driver Email,Förarens e-post
DocType: SMS Center,Total Message(s),Totalt Meddelande (er)
DocType: Share Balance,Purchased,Köpt
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Byt namn på Attribut Värde i Item Attribut.
DocType: Purchase Invoice,Additional Discount Percentage,Ytterligare rabatt Procent
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Visa en lista över alla hjälp videos
DocType: Agriculture Analysis Criteria,Soil Texture,Marktextur
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Välj konto chefen för banken, där kontrollen avsattes."
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Tillåt användare att redigera prislista i transaktioner
DocType: Pricing Rule,Max Qty,Max Antal
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,Skriv ut rapportkort
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice","Rad {0}: Faktura {1} är ogiltig, kan det ställas in / existerar inte. \ Ange en giltig faktura"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Rad {0}: Betalning mot Försäljning / inköpsorder bör alltid märkas i förskott
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Chemical,Kemisk
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Standard Bank / Cash konto kommer att uppdateras automatiskt i Lön Journal Entry när detta läge är valt.
DocType: Quiz,Latest Attempt,Senaste försök
DocType: Quiz Result,Quiz Result,Frågesport Resultat
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total leaves allocated is mandatory for Leave Type {0},Totalt antal tillåtna blad är obligatoriska för avgångstyp {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Priset kan inte vara större än den som används i {1} {2}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Priset kan inte vara större än den som används i {1} {2}
DocType: Workstation,Electricity Cost,Elkostnad
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,Labtestning datetime kan inte vara före datetime samling
DocType: Subscription Plan,Cost,Kosta
DocType: HR Settings,Don't send Employee Birthday Reminders,Skicka inte anställdas födelsedagspåminnelser
DocType: Expense Claim,Total Advance Amount,Total förskottsbelopp
DocType: Delivery Stop,Estimated Arrival,Beräknad ankomsttid
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,Se alla artiklar
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Gå In
DocType: Item,Inspection Criteria,Inspektionskriterier
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,Överfört
DocType: BOM Website Item,BOM Website Item,BOM Website Post
apps/erpnext/erpnext/public/js/setup_wizard.js,Upload your letter head and logo. (you can edit them later).,Ladda upp din brevhuvud och logotyp. (Du kan redigera dem senare).
DocType: Timesheet Detail,Bill,Räkningen
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,Vit
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Ogiltigt företag för transaktion mellan företag.
DocType: SMS Center,All Lead (Open),Alla Ledare (Öppna)
apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py,You can only select a maximum of one option from the list of check boxes.,Du kan bara välja högst ett alternativ från listan med kryssrutor.
DocType: Purchase Invoice,Get Advances Paid,Få utbetalda förskott
DocType: Item,Automatically Create New Batch,Skapa automatiskt nytt parti
DocType: Item,Automatically Create New Batch,Skapa automatiskt nytt parti
DocType: Woocommerce Settings,"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Användaren som kommer att användas för att skapa kunder, varor och försäljningsorder. Den här användaren bör ha relevanta behörigheter."
DocType: Asset Category,Enable Capital Work in Progress Accounting,Aktivera redovisning av pågående kapitalarbete
DocType: POS Field,POS Field,POS-fält
DocType: Supplier,Represents Company,Representerar företaget
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make ,Göra
DocType: Student Admission,Admission Start Date,Antagning startdatum
DocType: Journal Entry,Total Amount in Words,Total mängd i ord
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,Ny anställd
DocType: Lead,Next Contact Date,Nästa Kontakt Datum
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,Öppning Antal
DocType: Healthcare Settings,Appointment Reminder,Avtal påminnelse
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,Ange konto för förändring Belopp
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),För operation {0}: Kvantitet ({1}) kan inte vara greter än mängd som väntar ({2})
DocType: Program Enrollment Tool Student,Student Batch Name,Elev batchnamn
DocType: Holiday List,Holiday List Name,Semester Listnamn
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importera artiklar och UOM: er
DocType: Repayment Schedule,Balance Loan Amount,Balans lånebelopp
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Tillagt till detaljer
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Ledsen, kupongkoden är slut"
DocType: Communication Medium,Catch All,Fånga alla
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,schema Course
DocType: Budget,Applicable on Material Request,Gäller på materialförfrågan
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Optioner
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,Inga föremål tillagda i varukorgen
DocType: Journal Entry Account,Expense Claim,Utgiftsräkning
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,Vill du verkligen vill återställa detta skrotas tillgång?
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Antal för {0}
DocType: Attendance,Leave Application,Ledighetsansöknan
DocType: Patient,Patient Relation,Patientrelation
DocType: Item,Hub Category to Publish,Hub kategori att publicera
DocType: Leave Block List,Leave Block List Dates,Lämna Block Lista Datum
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sales Order {0} has reservation for item {1}, you can
		only deliver reserved {1} against {0}. Serial No {2} cannot
		be delivered","Försäljningsorder {0} har reservation för punkt {1}, du kan bara leverera reserverade {1} mot {0}. Serienummer {2} kan inte levereras"
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Item {0}: {1} qty produced. ,Objekt {0}: {1} producerad antal.
DocType: Sales Invoice,Billing Address GSTIN,Faktureringsadress GSTIN
DocType: Homepage,Hero Section Based On,Hjältesektion baserad på
DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,Totalt stödberättigande HRA-undantag
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,Ogiltig GSTIN! En GSTIN måste ha 15 tecken.
DocType: Assessment Plan,Evaluate,Utvärdera
DocType: Workstation,Net Hour Rate,Netto timmekostnad
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Landad kostnad inköpskvitto
DocType: Supplier Scorecard Period,Criteria,Kriterier
DocType: Packing Slip Item,Packing Slip Item,Följesedels artikel
DocType: Purchase Invoice,Cash/Bank Account,Kontant / Bankkonto
DocType: Travel Itinerary,Train,Tåg
,Delayed Item Report,Försenad artikelrapport
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Kvalificerad ITC
DocType: Healthcare Service Unit,Inpatient Occupancy,Inpatient Occupancy
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish Your First Items,Publicera dina första artiklar
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-.YYYY.-
DocType: Shift Type,Time after the end of shift during which check-out is considered for attendance.,Tid efter avslutad skift under vilken utcheckning övervägs för närvaro.
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Specificera en {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Removed items with no change in quantity or value.,Borttagna objekt med någon förändring i kvantitet eller värde.
DocType: Delivery Note,Delivery To,Leverans till
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,Varianter har skapats i kö.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Arbetsöversikt för {0}
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Den första lämnar godkännaren i listan kommer att ställas in som standardladdare.
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Attributtabell är obligatoriskt
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,Försenade dagar
DocType: Production Plan,Get Sales Orders,Hämta kundorder
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0} kan inte vara negativ
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Anslut till Quickbooks
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Tydliga värden
DocType: Training Event,Self-Study,Självstudie
DocType: POS Closing Voucher,Period End Date,Period Slutdatum
apps/erpnext/erpnext/regional/india/utils.py,Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Transportkvitton nr och datum är obligatoriska för ditt valda transportläge
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,Jordkompositioner lägger inte upp till 100
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount,Rabatt
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Row {0}: {1} is required to create the Opening {2} Invoices,Rad {0}: {1} krävs för att skapa öppningsfakturor {2}
DocType: Membership,Membership,Medlemskap
DocType: Asset,Total Number of Depreciations,Totalt Antal Avskrivningar
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,Debitera A / C-nummer
DocType: Sales Invoice Item,Rate With Margin,Betygsätt med marginal
DocType: Sales Invoice Item,Rate With Margin,Betygsätt med marginal
DocType: Purchase Invoice,Is Return (Debit Note),Är Retur (Debit Not)
DocType: Workstation,Wages,Löner
DocType: Asset Maintenance,Maintenance Manager Name,Underhållsansvarig namn
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,Transaktioner mot företaget finns redan!
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,Begär webbplats
DocType: Agriculture Task,Urgent,Brådskande
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Hämtar poster ......
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},Vänligen ange en giltig rad ID för rad {0} i tabellen {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Unable to find variable: ,Det gick inte att hitta variabel:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a field to edit from numpad,Var god välj ett fält för att redigera från numpad
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,Kan inte vara en anläggningstillgång när lagerbokföringen är skapad.
DocType: Subscription Plan,Fixed rate,Fast ränta
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Erkänna
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,Gå till skrivbordet och börja använda ERPNext
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Betala kvar
DocType: Purchase Invoice Item,Manufacturer,Tillverkare
DocType: Landed Cost Item,Purchase Receipt Item,Inköpskvitto Artikel
DocType: Leave Allocation,Total Leaves Encashed,Totala blad krossade
DocType: POS Profile,Sales Invoice Payment,Fakturan Betalning
DocType: Quality Inspection Template,Quality Inspection Template Name,Kvalitetsinspektionsmallnamn
DocType: Project,First Email,Första Email
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than or equal to Date of Joining,Relief-datum måste vara större än eller lika med Datum för anslutning
DocType: Company,Exception Budget Approver Role,Undantag Budget Approver Rol
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date",När den är inställd kommer den här fakturan att vara kvar tills det angivna datumet
DocType: Cashier Closing,POS-CLO-,POS-CLO-
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Försäljningsbelopp
DocType: Repayment Schedule,Interest Amount,räntebelopp
DocType: Job Card,Time Logs,Tid loggar
DocType: Sales Invoice,Loyalty Amount,Lojalitetsbelopp
DocType: Employee Transfer,Employee Transfer Detail,Anställningsöverföringsdetalj
DocType: Serial No,Creation Document No,Skapande Dokument nr
DocType: Manufacturing Settings,Other Settings,Andra inställningar
DocType: Location,Location Details,Plats detaljer
DocType: Share Transfer,Issue,Problem
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,Uppgifter
DocType: Asset,Scrapped,skrotas
DocType: Appointment Booking Settings,Agents,agenter
DocType: Item,Item Defaults,Objektstandard
DocType: Cashier Closing,Returns,avkastning
DocType: Job Card,WIP Warehouse,WIP Lager
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under maintenance contract upto {1},Löpnummer {0} är under underhållsavtal upp {1}
apps/erpnext/erpnext/config/hr.py,Recruitment,Rekrytering
DocType: Lead,Organization Name,Organisationsnamn
DocType: Support Settings,Show Latest Forum Posts,Visa senaste foruminlägg
DocType: Tax Rule,Shipping State,Frakt State
,Projected Quantity as Source,Projicerade Kvantitet som källa
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item must be added using 'Get Items from Purchase Receipts' button,"Produkt måste tillsättas med hjälp av ""få produkter  från kvitton"" -knappen"
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,Leveransresa
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Överföringstyp
DocType: Pricing Rule,Quantity and Amount,Kvantitet och mängd
DocType: Appointment Booking Settings,Success Redirect URL,Framgång omdirigera URL
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Försäljnings Kostnader
DocType: Diagnosis,Diagnosis,Diagnos
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Standard handla
DocType: Attendance Request,Explanation,Förklaring
DocType: GL Entry,Against,Mot
DocType: Item Default,Sales Defaults,Försäljningsinställningar
DocType: Sales Order Item,Work Order Qty,Arbetsorder Antal
DocType: Item Default,Default Selling Cost Center,Standard Kostnadsställe Försäljning
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,Skiva
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location or To Employee is required while receiving Asset {0},Målplats eller anställd krävs när du får tillgång {0}
DocType: Buying Settings,Material Transferred for Subcontract,Material överfört för underleverantör
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Beställningsdatum
DocType: Email Digest,Purchase Orders Items Overdue,Inköpsorder Föremål Försenade
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,Postnummer
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},Kundorder {0} är {1}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},Välj ränteintäkter konto i lån {0}
DocType: Opportunity,Contact Info,Kontaktinformation
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Göra Stock Inlägg
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Kan inte marknadsföra Medarbetare med status Vänster
DocType: Packing Slip,Net Weight UOM,Nettovikt UOM
DocType: Item Default,Default Supplier,Standard Leverantör
DocType: Loan,Repayment Schedule,återbetalningsplan
DocType: Shipping Rule Condition,Shipping Rule Condition,Frakt Regel skick
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py,End Date can not be less than Start Date,Slutdatum kan inte vara mindre än Startdatum
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice can't be made for zero billing hour,Faktura kan inte göras för noll faktureringstid
DocType: Company,Date of Commencement,Datum för inledande
DocType: Sales Person,Select company name first.,Välj företagsnamn först.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},E-post skickas till {0}
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Offerter mottaget från leverantörer.
DocType: Quality Goal,January-April-July-October,Januari-april-juli-oktober
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,Byt BOM och uppdatera senaste pris i alla BOM
apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},Till {0} | {1} {2}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,This is a root supplier group and cannot be edited.,Detta är en rotleverantörsgrupp och kan inte redigeras.
DocType: Sales Invoice,Driver Name,Förarens namn
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,Medelålder
DocType: Education Settings,Attendance Freeze Date,Dagsfrysningsdatum
DocType: Education Settings,Attendance Freeze Date,Dagsfrysningsdatum
DocType: Payment Request,Inward,Inåt
DocType: Accounting Dimension,Dimension Defaults,Dimension Standardvärden
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimal ledningsålder (dagar)
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimal ledningsålder (dagar)
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Available For Use Date,Tillgängligt för användningsdatum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,alla stycklistor
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Skapa intresse för företagets dagbok
DocType: Company,Parent Company,Moderbolag
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Hotellrum av typen {0} är inte tillgängliga på {1}
apps/erpnext/erpnext/config/manufacturing.py,Compare BOMs for changes in Raw Materials and Operations,Jämför BOM: er för ändringar i råmaterial och operationer
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.js,Document {0} successfully uncleared,Dokument {0} är oklart
DocType: Healthcare Practitioner,Default Currency,Standard Valuta
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Reconcile this account,Förena det här kontot
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,Maximal rabatt för artikel {0} är {1}%
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,Bifoga anpassad kontoplan
DocType: Asset Movement Item,From Employee,Från anställd
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,Import av tjänster
DocType: Driver,Cellphone Number,telefon nummer
DocType: Project,Monitor Progress,Monitor Progress
DocType: Pricing Rule Item Code,Pricing Rule Item Code,Prissättningsartikelkod
apps/erpnext/erpnext/controllers/accounts_controller.py,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Varning: Systemet kommer inte att kontrollera överdebitering, eftersom belopp för punkt {0} i {1} är noll"
DocType: Journal Entry,Make Difference Entry,Skapa Differensinlägg
DocType: Supplier Quotation,Auto Repeat Section,Auto Repeat Section
DocType: Service Level Priority,Response Time,Respons tid
DocType: Upload Attendance,Attendance From Date,Närvaro Från datum
DocType: Appraisal Template Goal,Key Performance Area,Nyckelperformance Områden
DocType: Program Enrollment,Transportation,Transportfordon
apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Ogiltig Attribut
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} måste skickas in
apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-postkampanjer
DocType: Sales Partner,To Track inbound purchase,Att spåra inkommande köp
DocType: Buying Settings,Default Supplier Group,Standardleverantörsgrupp
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Kvantitet måste vara mindre än eller lika med {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Högsta belopp som är berättigat till komponenten {0} överstiger {1}
DocType: Department Approver,Department Approver,Avdelningsgodkännare
DocType: QuickBooks Migrator,Application Settings,Applikationsinställningar
DocType: SMS Center,Total Characters,Totalt Tecken
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,Skapa företag och importera kontot
DocType: Employee Advance,Claimed,hävdade
DocType: Crop,Row Spacing,Row Spacing
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},Välj BOM i BOM fältet för produkt{0}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,There isn't any item variant for the selected item,Det finns ingen varianter för det valda objektet
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form faktura Detalj
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Betalning Avstämning Faktura
DocType: Clinical Procedure,Procedure Template,Procedurmall
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Publish Items,Publicera artiklar
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Bidrag%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"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}",Enligt Köpinställningarna om beställning krävs == &#39;JA&#39; och sedan för att skapa Köpfaktura måste användaren skapa Köporder först för objektet {0}
,HSN-wise-summary of outward supplies,HSN-vis-sammanfattning av utåtriktade varor
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Organisationsnummer som referens. Skattenummer etc.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,Till staten
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,Distributör
DocType: Asset Finance Book,Asset Finance Book,Asset Finance Book
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Varukorgen frakt Regel
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Please setup a default bank account for company {0},Ställ in ett standardkonto för företag {0}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Ställ in &quot;tillämpa ytterligare rabatt på&quot;
DocType: Party Tax Withholding Config,Applicable Percent,Gällande procentsats
,Ordered Items To Be Billed,Beställda varor att faktureras
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,From Range has to be less than To Range,Från Range måste vara mindre än ligga
DocType: Global Defaults,Global Defaults,Globala standardinställningar
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Collaboration Invitation,Projektsamarbete Inbjudan
DocType: Salary Slip,Deductions,Avdrag
DocType: Setup Progress Action,Action Name,Åtgärdsnamn
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Start Year
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.js,Create Loan,Skapa lån
DocType: Purchase Invoice,Start date of current invoice's period,Startdatum för aktuell faktura period
DocType: Shift Type,Process Attendance After,Process Deltagande efter
,IRS 1099,IRS 1099
DocType: Salary Slip,Leave Without Pay,Lämna utan lön
DocType: Payment Request,Outward,Utåt
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On {0} Creation,På {0} skapelse
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Stat / UT-skatt
,Trial Balance for Party,Trial Balance för Party
,Gross and Net Profit Report,Brutto- och nettovinstrapport
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Procedureträd
DocType: Lead,Consultant,Konsult
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Föräldrars lärarmöte närvaro
DocType: Salary Slip,Earnings,Vinster
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,Färdiga artiklar {0} måste anges för Tillverkningstypen
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,Ingående redovisning Balans
,GST Sales Register,GST Försäljningsregister
DocType: Sales Invoice Advance,Sales Invoice Advance,Försäljning Faktura Advance
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Välj domäner
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Shopify Leverantör
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Betalningsfakturaobjekt
DocType: Payroll Entry,Employee Details,Anställdas detaljer
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,Processing XML Files,Bearbetar XML-filer
DocType: Amazon MWS Settings,CN,CN
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Fält kopieras endast över tiden vid skapandet.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Management,Ledning
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Visa {0}
DocType: Cheque Print Template,Payer Settings,Payer Inställningar
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,Inga pågående materialförfrågningar hittades för att länka för de angivna objekten.
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Välj företag först
apps/erpnext/erpnext/accounts/general_ledger.py,Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Konto: <b>{0}</b> är kapital Arbetet pågår och kan inte uppdateras av Journal Entry
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Compare List function takes on list arguments,Funktionen Jämför lista tar listargument
DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Detta kommer att läggas till den punkt koden varianten. Till exempel, om din förkortning är &quot;SM&quot;, och försändelsekoden är &quot;T-TRÖJA&quot;, posten kod varianten kommer att vara &quot;T-Shirt-SM&quot;"
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Nettolön (i ord) kommer att vara synliga när du sparar lönebeskedet.
DocType: Delivery Note,Is Return,Är Returnerad
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,Varning
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,Importerad framgångsrik
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Mål och förfarande
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Startdagen är större än slutdagen i uppgiften &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Retur / debetnota
DocType: Price List Country,Price List Country,Prislista Land
DocType: Production Plan,"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","<a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">Klicka här</a> om du vill veta mer om beräknad mängd."
DocType: Sales Invoice,Set Source Warehouse,Ställ in Source Warehouse
DocType: Tally Migration,UOMs,UOM
DocType: Account Subtype,Account Subtype,Kontotyp
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} giltigt serienummer för objekt {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item Code cannot be changed for Serial No.,Produkt kod kan inte ändras för serienummer
DocType: Purchase Invoice Item,UOM Conversion Factor,UOM Omvandlingsfaktor
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,Ange Post kod för att få Batch nummer
DocType: Loyalty Point Entry,Loyalty Point Entry,Lojalitetspoäng inträde
DocType: Employee Checkin,Shift End,Shift End
DocType: Stock Settings,Default Item Group,Standard Varugrupp
DocType: Job Card Time Log,Time In Mins,Tid i min
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Bevilja information.
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Den här åtgärden kommer att koppla bort detta konto från alla externa tjänster som integrerar ERPNext med dina bankkonton. Det kan inte bli ogjort. Är du säker ?
apps/erpnext/erpnext/config/accounts.py,Supplier database.,Leverantörsdatabas.
DocType: Contract Template,Contract Terms and Conditions,Avtalsvillkor
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,Du kan inte starta om en prenumeration som inte avbryts.
DocType: Account,Balance Sheet,Balansräkning
DocType: Leave Type,Is Earned Leave,Är tjänat löne
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Köporderbelopp
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',"Kostnadcenter för artikel med artikelkod """
DocType: Fee Validity,Valid Till,Giltig till
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Totalt föräldrars lärarmöte
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Betalning läget är inte konfigurerad. Kontrollera, om kontot har satts på läge av betalningar eller på POS profil."
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Samma post kan inte anges flera gånger.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Further accounts can be made under Groups, but entries can be made against non-Groups","Ytterligare konton kan göras inom ramen för grupper, men poster kan göras mot icke-grupper"
DocType: Call Log,Lead,Prospekt
DocType: Email Digest,Payables,Skulder
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
DocType: Email Campaign,Email Campaign For ,E-postkampanj för
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Stock Entry {0} skapades
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,Du har inte tillräckligt med lojalitetspoäng för att lösa in
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,Please set associated account in Tax Withholding Category {0} against Company {1},Vänligen ange tillhörande konto i Skatteavdragskategori {0} mot Företag {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Rad # {0}:  avvisat antal kan inte anmälas för retur
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Ändring av kundgrupp för vald kund är inte tillåtet.
,Purchase Order Items To Be Billed,Inköpsorder Artiklar att faktureras
apps/erpnext/erpnext/controllers/buying_controller.py,Row {1}: Asset Naming Series is mandatory for the auto creation for item {0},Rad {1}: Serien för tillgångsnamn är obligatorisk för automatisk skapande av objektet {0}
DocType: Program Enrollment Tool,Enrollment Details,Inskrivningsdetaljer
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Kan inte ställa in flera standardinställningar för ett företag.
DocType: Customer Group,Credit Limits,Kreditgränser
DocType: Purchase Invoice Item,Net Rate,Netto kostnad
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,Var god välj en kund
DocType: Leave Policy,Leave Allocations,Lämna tilldelningar
DocType: Job Card,Started Time,Startad tid
DocType: Purchase Invoice Item,Purchase Invoice Item,Inköpsfaktura Artiklar
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Stock Ledger inlägg och GL Posterna reposted för valda kvitton
DocType: Student Report Generation Tool,Assessment Terms,Bedömningsvillkor
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,Produkt  1
DocType: Holiday,Holiday,Sommar
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,Lämna typ är galatory
DocType: Support Settings,Close Issue After Days,Nära Problem Efter dagar
,Eway Bill,Eway Bill
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Du måste vara användare med systemhanteraren och objekthanterarens roller för att lägga till användare på Marketplace.
DocType: Attendance,Early Exit,Tidig utgång
DocType: Job Opening,Staffing Plan,Personalplan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,e-Way Bill JSON can only be generated from a submitted document,e-Way Bill JSON kan endast genereras från ett inlämnat dokument
apps/erpnext/erpnext/config/hr.py,Employee Tax and Benefits,Arbetstagarskatt och förmåner
DocType: Bank Guarantee,Validity in Days,Giltighet i dagar
DocType: Bank Guarantee,Validity in Days,Giltighet i dagar
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},C-formen är inte tillämplig för faktura: {0}
DocType: Certified Consultant,Name of Consultant,Namn på konsult
DocType: Payment Reconciliation,Unreconciled Payment Details,Sonade Betalningsinformation
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,Medlemsaktivitet
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Order Count
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Order Count
DocType: Global Defaults,Current Fiscal Year,Innevarande räkenskapsår
DocType: Purchase Invoice,Group same items,Grupp samma objekt
DocType: Purchase Invoice,Disable Rounded Total,Inaktivera avrundat Totalbelopp
DocType: Marketplace Settings,Sync in Progress,Synkronisera pågår
DocType: Department,Parent Department,Föräldraavdelningen
DocType: Loan Application,Repayment Info,återbetalning info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,&#39;poster&#39; kan inte vara tomt
DocType: Maintenance Team Member,Maintenance Role,Underhålls roll
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},Duplicate raden {0} med samma {1}
DocType: Marketplace Settings,Disable Marketplace,Inaktivera Marketplace
DocType: Quality Meeting,Minutes,Minuter
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Featured Items,Dina presenterade artiklar
,Trial Balance,Trial Balans
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Visa klar
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Räkenskapsårets {0} hittades inte
apps/erpnext/erpnext/config/help.py,Setting up Employees,Ställa in Anställda
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Gör lagerinmatning
DocType: Hotel Room Reservation,Hotel Reservation User,Hotellbokningsanvändare
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Ställ in status
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Välj prefix först
DocType: Contract,Fulfilment Deadline,Uppfyllnadsfristen
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Nära dig
DocType: Student,O-,O-
DocType: Subscription Settings,Subscription Settings,Prenumerationsinställningar
DocType: Purchase Invoice,Update Auto Repeat Reference,Uppdatera automatisk repeteringsreferens
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Valfri semesterlista inte inställd för ledighet {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,Forskning
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,Till Adress 2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,Rad {0}: Från tiden måste vara mindre än till tiden
DocType: Maintenance Visit Purpose,Work Done,Arbete Gjort
apps/erpnext/erpnext/controllers/item_variant.py,Please specify at least one attribute in the Attributes table,Ange minst ett attribut i tabellen attribut
DocType: Announcement,All Students,Alla studenter
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,Objektet {0} måste vara en icke-lagervara
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,Se journal
DocType: Cost Center,Lft,Lft
DocType: Grading Scale,Intervals,intervaller
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Avstämda transaktioner
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,Tidigast
DocType: Crop Cycle,Linked Location,Länkad plats
apps/erpnext/erpnext/stock/doctype/item/item.py,"An Item Group exists with same name, please change the item name or rename the item group","Ett varugrupp finns med samma namn, ändra objektets namn eller byta namn på varugrupp"
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Skaffa kallelser
DocType: Designation,Skills,Kompetens
DocType: Crop Cycle,Less than a year,Mindre än ett år
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Student Mobile No.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,Resten av världen
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,The Item {0} cannot have Batch,Item {0} kan inte ha Batch
DocType: Crop,Yield UOM,Utbyte UOM
,Budget Variance Report,Budget Variationsrapport
DocType: Salary Slip,Gross Pay,Bruttolön
DocType: Item,Is Item from Hub,Är objekt från nav
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Healthcare Services,Få artiklar från sjukvårdstjänster
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Finished Qty,Färdigt antal
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,Rad {0}: Aktivitetstyp är obligatorisk.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Dividends Paid,Lämnad utdelning
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Redovisning Ledger
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Amount,Differensbelopp
DocType: Purchase Invoice,Reverse Charge,Omvänd laddning
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Balanserade vinstmedel
DocType: Job Card,Timing Detail,Timing Detail
DocType: Purchase Invoice,05-Change in POS,05-Ändra i POS
DocType: Vehicle Log,Service Detail,tjänsten Detalj
DocType: BOM,Item Description,Produktbeskrivning
DocType: Student Sibling,Student Sibling,Student Syskon
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Payment Mode,Betalningsläget
DocType: Purchase Invoice,Supplied Items,Medföljande tillbehör
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set an active menu for Restaurant {0},Ange en aktiv meny för restaurang {0}
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Kommissionens skattesats%
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Qty To Manufacture,Antal att tillverka
DocType: Email Digest,New Income,ny inkomst
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Lead,Öppen bly
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Behåll samma takt hela inköpscykeln
DocType: Opportunity Item,Opportunity Item,Möjlighet Punkt
DocType: Quality Action,Quality Review,Kvalitetsgranskning
,Student and Guardian Contact Details,Student och Guardian Kontaktuppgifter
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Sammanfoga konto
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Row {0}: For supplier {0} Email Address is required to send email,Row {0}: För leverantören {0} E-postadress krävs för att skicka e-post
DocType: Shift Type,Attendance will be marked automatically only after this date.,Närvaron kommer att markeras automatiskt först efter detta datum.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Tillfällig Öppning
,Employee Leave Balance,Anställd Avgångskostnad
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,Nytt kvalitetsförfarande
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},Saldo konto {0} måste alltid vara {1}
DocType: Patient Appointment,More Info,Mer Information
DocType: Supplier Scorecard,Scorecard Actions,Scorecard Actions
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Leverantör {0} finns inte i {1}
DocType: Purchase Invoice,Rejected Warehouse,Avvisat Lager
DocType: GL Entry,Against Voucher,Mot Kupong
DocType: Item Default,Default Buying Cost Center,Standard Inköpsställe
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Payment,Ny betalning
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","För att få ut det bästa av ERPNext, rekommenderar vi att du tar dig tid och titta på dessa hjälp videor."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),För standardleverantör (tillval)
DocType: Supplier Quotation Item,Lead Time in days,Ledtid i dagar
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Target ({}),Mål ({})
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Accounts Payable Summary,Leverantörsreskontra Sammanfattning
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Not authorized to edit frozen Account {0},Ej tillåtet att redigera fryst konto {0}
apps/erpnext/erpnext/accounts/general_ledger.py,Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Lagervärde ({0}) och kontosaldo ({1}) är inte synkroniserade för konto {2} och det är länkade lager.
DocType: Journal Entry,Get Outstanding Invoices,Hämta utestående fakturor
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Sales Order {0} is not valid,Kundorder {0} är inte giltig
DocType: Supplier Scorecard,Warn for new Request for Quotations,Varna för ny Offertförfrågan
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,Inköpsorder hjälpa dig att planera och följa upp dina inköp
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,Lab Test Prescriptions
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Den totala emissions / Transfer mängd {0} i Material Begäran {1} \ inte kan vara större än efterfrågat antal {2} till punkt {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Small,Liten
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Om Shopify inte innehåller en kund i Order, då du synkroniserar Orders, kommer systemet att överväga standardkund för beställning"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Öppnande av fakturaobjektverktygsartikel
DocType: Cashier Closing Payments,Cashier Closing Payments,Kassaravslutande betalningar
DocType: Education Settings,Employee Number,Anställningsnummer
DocType: Subscription Settings,Cancel Invoice After Grace Period,Avbryt faktura efter grace period
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Case No(s) already in use. Try from Case No {0},Ärendenr är redani bruk. Försök från ärende nr {0}
DocType: Project,% Completed,% Slutfört
,Invoiced Amount (Exculsive Tax),Fakturerat belopp (Exklusive skatt)
DocType: Asset Finance Book,Rate of Depreciation,Avskrivningsgrad
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,Serie nummer
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},Rad {0}: Kvalitetskontroll avvisad för artikel {1}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Produkt  2
DocType: Pricing Rule,Validate Applied Rule,Validera tillämpad regel
DocType: QuickBooks Migrator,Authorization Endpoint,Godkännande slutpunkt
DocType: Employee Onboarding,Notify users by email,Meddela användare via e-post
DocType: Travel Request,International,Internationell
DocType: Training Event,Training Event,utbildning Händelse
DocType: Item,Auto re-order,Auto återbeställning
DocType: Attendance,Late Entry,Sen inresa
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,Totalt Uppnått
DocType: Employee,Place of Issue,Utgivningsplats
DocType: Promotional Scheme,Promotional Scheme Price Discount,Kampanjschema Prisrabatt
DocType: Contract,Contract,Kontrakt
DocType: GSTR 3B Report,May,Maj
DocType: Plant Analysis,Laboratory Testing Datetime,Laboratory Testing Datetime
DocType: Email Digest,Add Quote,Lägg Citat
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},UOM coverfaktor krävs för UOM: {0} i punkt: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Expenses,Indirekta kostnader
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,Rad {0}: Antal är obligatoriskt
DocType: Agriculture Analysis Criteria,Agriculture,Jordbruk
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Skapa försäljningsorder
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Redovisning för tillgång
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,{0} is not a group node. Please select a group node as parent cost center,{0} är inte en gruppnod. Välj en gruppnod som moderkostnadscentrum
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Blockfaktura
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,Mängd att göra
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,Sync basdata
DocType: Asset Repair,Repair Cost,Reparationskostnad
DocType: Quality Meeting Table,Under Review,Under granskning
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Kunde inte logga in
DocType: Coupon Code,Promotional,PR
DocType: Special Test Items,Special Test Items,Särskilda testpunkter
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Du måste vara en användare med systemhanteraren och objekthanterarens roller för att registrera dig på Marketplace.
apps/erpnext/erpnext/config/buying.py,Key Reports,Viktiga rapporter
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Betalningssätt
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,As per your assigned Salary Structure you cannot apply for benefits,Enligt din tilldelade lönestruktur kan du inte ansöka om förmåner
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,Website Bild bör vara en offentlig fil eller webbadress
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,Detta är en rot varugrupp och kan inte ändras.
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,Sammanfoga
DocType: Journal Entry Account,Purchase Order,Inköpsorder
DocType: Vehicle,Fuel UOM,bränsle UOM
DocType: Warehouse,Warehouse Contact Info,Lagrets kontaktinfo
DocType: Payment Entry,Write Off Difference Amount,Skriv differensen Belopp
DocType: Volunteer,Volunteer Name,Frivilligt namn
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},Rader med dubbla förfallodatum i andra rader hittades: {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent","{0}: Anställds e-post hittades inte, därför skickas inte e-post"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},Ingen lönestruktur tilldelad för anställd {0} på angivet datum {1}
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},Fraktregeln gäller inte för land {0}
DocType: Import Supplier Invoice,Import Invoices,Importera fakturor
DocType: Item,Foreign Trade Details,Foreign Trade Detaljer
,Assessment Plan Status,Bedömningsplan status
DocType: Email Digest,Annual Income,Årlig inkomst
DocType: Serial No,Serial No Details,Serial Inga detaljer
DocType: Purchase Invoice Item,Item Tax Rate,Produkt Skattesats
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,Från partnamn
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,Nettolönsmängd
DocType: Pick List,Delivery against Sales Order,Leverans mot försäljningsorder
DocType: Student Group Student,Group Roll Number,Grupprullnummer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only credit accounts can be linked against another debit entry",För {0} kan endast kreditkonton länkas mot en annan debitering
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,Följesedel {0} är inte lämnad
apps/erpnext/erpnext/stock/get_item_details.py,Item {0} must be a Sub-contracted Item,Produkt  {0} måste vara ett underleverantörs produkt
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Equipments,Kapital Utrustning
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Prissättning regel baseras först på ""Lägg till på' fälten, som kan vara artikel, artikelgrupp eller Märke."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please set the Item Code first,Vänligen ange produktkoden först
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Typ
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Totala fördelade procentsats för säljteam bör vara 100
DocType: Subscription Plan,Billing Interval Count,Faktureringsintervallräkning
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Möten och patientmöten
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Värdet saknas
DocType: Employee,Department and Grade,Avdelning och betyg
DocType: Antibiotic,Antibiotic,Antibiotikum
,Team Updates,team Uppdateringar
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,For Supplier,För Leverantör
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Ställa Kontotyp hjälper i att välja detta konto i transaktioner.
DocType: Purchase Invoice,Grand Total (Company Currency),Totalsumma (Företagsvaluta)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Create Print Format,Skapa utskriftsformat
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Avgift skapad
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},Kunde inte hitta någon post kallad {0}
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Objekt filter
DocType: Supplier Scorecard Criteria,Criteria Formula,Kriterier Formel
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,Totalt Utgående
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Det kan bara finnas en frakt Regel skick med 0 eller blank värde för &quot;till värde&quot;
DocType: Bank Statement Transaction Settings Item,Transaction,Transaktion
DocType: Call Log,Duration,Varaktighet
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be positive number",För ett objekt {0} måste kvantiteten vara ett positivt tal
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Obs! Detta här kostnadsställe är en grupp. Det går inte att göra bokföringsposter mot grupper.
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Compensatory leave request days not in valid holidays,Begäran om kompensationsledighet gäller inte i giltiga helgdagar
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,Barnlager existerar för det här lagret. Du kan inte ta bort det här lagret.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Ange <b>Skillnadskonto</b> eller ställ in standardkonto för <b>Justering av lager</b> för företag {0}
DocType: Item,Website Item Groups,Webbplats artikelgrupper
DocType: Purchase Invoice,Total (Company Currency),Totalt (Company valuta)
DocType: Daily Work Summary Group,Reminder,Påminnelse
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,Tillgängligt värde
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,Serienummer {0} in mer än en gång
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Journalanteckning
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,Från GSTIN
DocType: Expense Claim Advance,Unclaimed amount,Oavkrävat belopp
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,{0} objekt pågår
DocType: Workstation,Workstation Name,Arbetsstation Namn
DocType: Grading Scale Interval,Grade Code,grade kod
DocType: POS Item Group,POS Item Group,POS Artikelgrupp
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,Email Digest:,E-postutskick:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Alternative item must not be same as item code,Alternativet får inte vara samma som artikelnumret
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},BOM {0} tillhör inte föremål {1}
DocType: Promotional Scheme,Product Discount Slabs,Produktrabattplattor
DocType: Target Detail,Target Distribution,Target Fördelning
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Slutförande av preliminär bedömning
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Importera parter och adresser
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-omvandlingsfaktor ({0} -&gt; {1}) hittades inte för artikeln: {2}
DocType: Salary Slip,Bank Account No.,Bankkonto nr
DocType: Naming Series,This is the number of the last created transaction with this prefix,Detta är numret på den senast skapade transaktionen med detta prefix
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Scorecard-variabler kan användas, såväl som: {total_score} (den totala poängen från den perioden), {period_number} (antalet perioder till nutid)"
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Skapa inköpsorder
DocType: Quality Inspection Reading,Reading 8,Avläsning 8
DocType: Inpatient Record,Discharge Note,Ansvarsfrihet
DocType: Appointment Booking Settings,Number of Concurrent Appointments,Antal samtidiga möten
apps/erpnext/erpnext/config/desktop.py,Getting Started,Komma igång
DocType: Purchase Invoice,Taxes and Charges Calculation,Skatter och avgifter Beräkning
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Bokförtillgodskrivning automatiskt
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Bokförtillgodskrivning automatiskt
DocType: BOM Operation,Workstation,Arbetsstation
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Offertförfrågan Leverantör
DocType: Healthcare Settings,Registration Message,Registreringsmeddelande
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,Hårdvara
DocType: Prescription Dosage,Prescription Dosage,Receptbelagd dosering
DocType: Appointment Booking Settings,HR Manager,HR-chef
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Välj ett företag
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Enskild ledighet
DocType: Purchase Invoice,Supplier Invoice Date,Leverantörsfakturadatum
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,You need to enable Shopping Cart,Du måste aktivera Varukorgen
DocType: Payment Entry,Writeoff,nedskrivning
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
DocType: HR Settings,<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Exempel:</b> SAL- {first_name} - {date_of_birth.year} <br> Detta kommer att skapa ett lösenord som SAL-Jane-1972
DocType: Stock Settings,Naming Series Prefix,Namn Serie Prefix
DocType: Appraisal Template Goal,Appraisal Template Goal,Bedömning Mall Mål
DocType: Salary Component,Earning,Tjänar
DocType: Supplier Scorecard,Scoring Criteria,Scoringskriterier
DocType: Purchase Invoice,Party Account Currency,Party konto Valuta
DocType: Delivery Trip,Total Estimated Distance,Totalt beräknat avstånd
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Kundfordringar Obetalt konto
DocType: Tally Migration,Tally Company,Tally Company
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,BOM läsare
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Not allowed to create accounting dimension for {0},Det är inte tillåtet att skapa bokföringsdimension för {0}
apps/erpnext/erpnext/templates/emails/training_event.html,Please update your status for this training event,Vänligen uppdatera din status för den här träningsevenemanget
DocType: Item Barcode,EAN,EAN
DocType: Purchase Taxes and Charges,Add or Deduct,Lägg till eller dra av
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Overlapping conditions found between:,Överlappande förhållanden som råder mellan:
DocType: Bank Transaction Mapping,Field in Bank Transaction,Fält i banktransaktion
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,Mot Journal anteckning{0} är redan anpassat mot någon annan kupong
,Inactive Sales Items,Inaktiva försäljningsartiklar
DocType: Quality Review,Additional Information,ytterligare information
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,Totalt ordervärde
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Food,Mat
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 3,Åldringsräckvidd 3
DocType: POS Closing Voucher Details,POS Closing Voucher Details,POS-slutkupongdetaljer
DocType: Bank Account,Is the Default Account,Är standardkontot
DocType: Shopify Log,Shopify Log,Shopify Log
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No communication found.,Ingen kommunikation hittades.
DocType: Inpatient Occupancy,Check In,Checka in
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Skapa betalningsinmatning
DocType: Maintenance Schedule Item,No of Visits,Antal besök
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},Underhållschema {0} existerar mot {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,Inlärning elev
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Currency of the Closing Account must be {0},Valuta avslutnings Hänsyn måste vara {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment overlaps with {0}.<br> {1} has appointment scheduled
			with {2} at {3} having {4} minute(s) duration.",Utnämningen överlappar med {0}. <br> {1} har en tidsplan med {2} kl {3} med {4} minut (er).
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py,Sum of points for all goals should be 100. It is {0},Summan av poäng för alla mål bör vara 100. Det är {0}
DocType: Project,Start and End Dates,Start- och slutdatum
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Kontraktsmall Uppfyllningsvillkor
,Delivered Items To Be Billed,Levererade artiklar att faktureras
DocType: Coupon Code,Maximum Use,Maximal användning
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Öppen BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Lager kan inte ändras för serienummer
DocType: Authorization Rule,Average Discount,Genomsnittlig rabatt
DocType: Pricing Rule,UOM,UOM
DocType: Employee Tax Exemption Declaration,Annual HRA Exemption,Årlig HRA-undantag
DocType: Rename Tool,Utilities,Verktyg
DocType: POS Profile,Accounting,Redovisning
DocType: Asset,Purchase Receipt Amount,Inköpsbelopp
DocType: Employee Separation,Exit Interview Summary,Avsluta intervjuöversikt
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Var god välj satser för batched item
DocType: Asset,Depreciation Schedules,avskrivningstider
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Skapa försäljningsfaktura
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,Icke kvalificerad ITC
DocType: Task,Dependent Tasks,Beroende uppgifter
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,Följande konton kan väljas i GST-inställningar:
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Kvantitet att producera
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be outside leave allocation period,Ansökningstiden kan inte vara utanför ledighet fördelningsperioden
DocType: Activity Cost,Projects,Projekt
DocType: Payment Request,Transaction Currency,transaktionsvaluta
apps/erpnext/erpnext/controllers/buying_controller.py,From {0} | {1} {2},Från {0} | {1} {2}
apps/erpnext/erpnext/public/js/hub/marketplace.js,Some emails are invalid,Vissa e-postmeddelanden är ogiltiga
DocType: Work Order Operation,Operation Description,Drift Beskrivning
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Det går inte att ändra räkenskapsårets Startdatum och Räkenskapsårets Slutdatum när verksamhetsåret sparas.
DocType: Quotation,Shopping Cart,Kundvagn
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Avg Daily Outgoing,Avg Daglig Utgång
DocType: POS Profile,Campaign,Kampanj
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,"{0} will be cancelled automatically on asset cancellation as it was \
					auto generated for Asset {1}",{0} kommer att avbrytas automatiskt vid tillgångsavbrott eftersom det \ auto genererades för tillgång {1}
DocType: Supplier,Name and Type,Namn och typ
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Item Reported,Objekt rapporterat
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Approval Status must be 'Approved' or 'Rejected',"Godkännandestatus måste vara ""Godkänd"" eller ""Avvisad"""
DocType: Healthcare Practitioner,Contacts and Address,Kontakter och adress
DocType: Shift Type,Determine Check-in and Check-out,Bestäm incheckning och utcheckning
DocType: Salary Structure,Max Benefits (Amount),Max förmåner (belopp)
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Lägg till anteckningar
DocType: Purchase Invoice,Contact Person,Kontaktperson
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Ingen data för denna period
DocType: Course Scheduling Tool,Course End Date,Kurs Slutdatum
DocType: Holiday List,Holidays,Helgdagar
DocType: Sales Order Item,Planned Quantity,Planerad Kvantitet
DocType: Water Analysis,Water Analysis Criteria,Vattenanalysskriterier
DocType: Item,Maintain Stock,Behåll Lager
DocType: Terms and Conditions,Applicable Modules,Tillämpliga moduler
DocType: Employee,Prefered Email,Föredragen E
DocType: Student Admission,Eligibility and Details,Behörighet och detaljer
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Ingår i bruttovinsten
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Netto Förändring av anläggningstillgång
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,Reqd Antal
apps/erpnext/erpnext/controllers/accounts_controller.py,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Avgift av typ ""faktiska"" i raden {0} kan inte ingå i artikelomsättningen"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,Från Daterad tid
DocType: Shopify Settings,For Company,För Företag
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"Request for Quotation is disabled to access from portal, for more check portal settings.","Offertförfrågan är inaktiverad att komma åt från portalen, för mer kontroll portalens inställningar."
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Leverantör Scorecard Scorevariabel
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,Köpa mängd
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Company of asset {0} and purchase document {1} doesn't matches.,Företagets tillgång {0} och köpdokumentet {1} matchar inte.
DocType: POS Closing Voucher,Modes of Payment,Betalningsmetoder
DocType: Sales Invoice,Shipping Address Name,Leveransadress Namn
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart of Accounts,Kontoplan
DocType: Material Request,Terms and Conditions Content,Villkor Innehåll
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,There were errors creating Course Schedule,Det fanns fel som skapade kursschema
DocType: Communication Medium,Timeslots,Tidsluckor
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Den första expense-godkännaren i listan kommer att ställas som standard Expense Approver.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,kan inte vara större än 100
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Du måste vara en annan användare än Administratör med systemhanteraren och objekthanterarens roller för att registrera dig på Marketplace.
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,Produkt  {0} är inte en lagervara
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
DocType: Maintenance Visit,Unscheduled,Ledig
DocType: Employee,Owned,Ägs
DocType: Pricing Rule,"Higher the number, higher the priority","Högre nummer, högre prioritet"
,Purchase Invoice Trends,Inköpsfaktura Trender
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,Inga produkter hittade
DocType: Employee,Better Prospects,Bättre prospekt
DocType: Travel Itinerary,Gluten Free,Glutenfri
DocType: Loyalty Program Collection,Minimum Total Spent,Minsta totala utgifter
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"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",Rad # {0}: Batch {1} har endast {2} qty. Var god välj en annan sats som har {3} antal tillgängliga eller dela raden i flera rader för att leverera / utgå från flera satser
DocType: Loyalty Program,Expiry Duration (in days),Förfallotid (i dagar)
DocType: Inpatient Record,Discharge Date,Utskrivningsdatum
DocType: Subscription Plan,Price Determination,Prisbestämning
DocType: Vehicle,License Plate,Registreringsskylt
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,Ny avdelning
DocType: Compensatory Leave Request,Worked On Holiday,Arbetade på semester
DocType: Appraisal,Goals,Mål
DocType: Support Settings,Allow Resetting Service Level Agreement,Tillåt återställning av servicenivåavtal
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Välj POS-profil
DocType: Warranty Claim,Warranty / AMC Status,Garanti / AMC Status
,Accounts Browser,Konton Webbläsare
DocType: Procedure Prescription,Referral,remiss
DocType: Payment Entry Reference,Payment Entry Reference,Betalning Entry Referens
DocType: GL Entry,GL Entry,GL Entry
DocType: Support Search Source,Response Options,Svaralternativ
DocType: Pricing Rule,Apply Multiple Pricing Rules,Tillämpa flera prissättningsregler
DocType: HR Settings,Employee Settings,Personal Inställningar
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Hämtar betalningssystemet
,Batch-Wise Balance History,Batchvis Balans Historik
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Row # {0}: Kan inte ställa in ränta om beloppet är större än fakturerat belopp för punkt {1}.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,Utskriftsinställningar uppdateras i respektive utskriftsformat
DocType: Package Code,Package Code,Package Code
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,Lärling
DocType: Purchase Invoice,Company GSTIN,Företaget GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,Negativ Antal är inte tillåtet
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",Skatte detalj tabell hämtas från punkt mästare som en sträng och lagras i detta område. Används för skatter och avgifter
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,Anställd kan inte anmäla sig själv.
apps/erpnext/erpnext/templates/pages/order.html,Rate:,Betygsätta:
DocType: Bank Account,Change this date manually to setup the next synchronization start date,Ändra detta datum manuellt för att ställa in nästa startdatum för synkronisering
DocType: Leave Type,Max Leaves Allowed,Max löv tillåtet
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Om kontot är fruset, är poster endast tillgängligt för begränsade användare."
DocType: Email Digest,Bank Balance,Banksaldo
apps/erpnext/erpnext/controllers/accounts_controller.py,Accounting Entry for {0}: {1} can only be made in currency: {2},Kontering för {0}: {1} kan endast göras i valuta: {2}
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Lämna godkännare Obligatorisk i lämnaransökan
DocType: Job Opening,"Job profile, qualifications required etc.","Jobb profil, kvalifikationer som krävs osv"
DocType: Journal Entry Account,Account Balance,Balanskonto
apps/erpnext/erpnext/config/accounts.py,Tax Rule for transactions.,Skatte Regel för transaktioner.
DocType: Rename Tool,Type of document to rename.,Typ av dokument för att byta namn.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Lös felet och ladda upp igen.
DocType: Buying Settings,Over Transfer Allowance (%),Överföringsbidrag (%)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Kunden är skyldig mot fordrans konto {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Totala skatter och avgifter (Företags valuta)
DocType: Weather,Weather Parameter,Väderparameter
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,Visa ej avslutad skatteårets P &amp; L balanser
DocType: Item,Asset Naming Series,Asset Naming Series
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/regional/india/utils.py,House rented dates should be atleast 15 days apart,Husets hyrda datum borde vara minst 15 dagar från varandra
DocType: Clinical Procedure Template,Collection Details,Samlingsdetaljer
DocType: POS Profile,Allow Print Before Pay,Tillåt utskrift före betalning
DocType: Linked Soil Texture,Linked Soil Texture,Länkad markstruktur
DocType: Shipping Rule,Shipping Account,Frakt konto
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}: kontot {2} är inaktivt
DocType: GSTR 3B Report,March,Mars
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Banköverföringsuppgifter
DocType: Quality Inspection,Readings,Avläsningar
DocType: Stock Entry,Total Additional Costs,Totalt Merkostnader
DocType: Quality Action,Quality Action,Kvalitetsåtgärd
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Inget av interaktioner
DocType: BOM,Scrap Material Cost(Company Currency),Skrot materialkostnader (Company valuta)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Set Start Time and End Time for  \
					Support Day {0} at index {1}.",Ställ in starttid och sluttid för \ Support Day {0} vid index {1}.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,Sub Assemblies
DocType: Asset,Asset Name,tillgångs Namn
DocType: Employee Boarding Activity,Task Weight,uppgift Vikt
DocType: Shipping Rule Condition,To Value,Att Värdera
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Lägg automatiskt till skatter och avgifter från artikelskattmallen
DocType: Loyalty Program,Loyalty Program Type,Lojalitetsprogramtyp
DocType: Asset Movement,Stock Manager,Lagrets direktör
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source warehouse is mandatory for row {0},Källa lager är obligatoriskt för rad {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,The Payment Term at row {0} is possibly a duplicate.,Betalningstiden i rad {0} är eventuellt en dubblett.
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),Jordbruk (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,Följesedel
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,Kontorshyra
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,Setup SMS-gateway-inställningar
DocType: Disease,Common Name,Vanligt namn
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Tabell för kundåterkoppling
DocType: Employee Boarding Activity,Employee Boarding Activity,Anställd ombordstigningsaktivitet
apps/erpnext/erpnext/public/js/templates/address_list.html,No address added yet.,Ingen adress inlagd ännu.
DocType: Workstation Working Hour,Workstation Working Hour,Arbetsstation arbetstimme
DocType: Vital Signs,Blood Pressure,Blodtryck
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Analyst,Analytiker
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,{0} is not in a valid Payroll Period,{0} är inte i en giltig löneperiod
DocType: Employee Benefit Application,Max Benefits (Yearly),Max fördelar (årlig)
DocType: Item,Inventory,Inventering
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Ladda ner som Json
DocType: Item,Sales Details,Försäljnings Detaljer
DocType: Coupon Code,Used,Begagnade
DocType: Opportunity,With Items,Med artiklar
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanjen &#39;{0}&#39; finns redan för {1} &#39;{2}&#39;
DocType: Asset Maintenance,Maintenance Team,Underhållsteam
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","Ordning i vilka avsnitt som ska visas. 0 är först, 1 är andra och så vidare."
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,In Qty,I Antal
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Bekräfta inskrivna kurs för studenter i studentgruppen
DocType: Item,Item Attribute,Produkt Attribut
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Government,Regeringen
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim {0} already exists for the Vehicle Log,Räkningen {0} finns redan för fordons Log
DocType: Asset Movement Item,Source Location,Källa Plats
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,Institute Namn
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,Ange återbetalningsbeloppet
DocType: Shift Type,Working Hours Threshold for Absent,Tröskel för arbetstid för frånvarande
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Det kan vara en multipelbaserad insamlingsfaktor baserat på den totala spenderingen. Men konverteringsfaktorn för inlösen kommer alltid att vara densamma för alla nivåer.
apps/erpnext/erpnext/config/help.py,Item Variants,Produkt Varianter
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,Tjänster
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,BOM 2,BOM 2
DocType: Payment Order,PMO-,PMO-
DocType: HR Settings,Email Salary Slip to Employee,E-lönebesked till anställd
DocType: Cost Center,Parent Cost Center,Överordnat kostnadsställe
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,Skapa fakturor
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Välj Möjliga Leverantör
DocType: Communication Medium,Communication Medium Type,Kommunikation Medium Type
DocType: Customer,"Select, to make the customer searchable with these fields","Välj, för att göra kunden sökbar med dessa fält"
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Importera leveransanmärkningar från Shopify vid leverans
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,show stängd
DocType: Issue Priority,Issue Priority,Utgåva prioritet
DocType: Leave Ledger Entry,Is Leave Without Pay,Är ledighet utan lön
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,Gstin
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,Asset Kategori är obligatorisk för fast tillgångsposten
DocType: Fee Validity,Fee Validity,Avgift Giltighet
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Payment table,Inga träffar i betalningstabellen
apps/erpnext/erpnext/education/utils.py,This {0} conflicts with {1} for {2} {3},Detta {0} konflikter med {1} för {2} {3}
DocType: Student Attendance Tool,Students HTML,studenter HTML
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,{0}: {1} must be less than {2},{0}: {1} måste vara mindre än {2}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Välj BOM, antal och för lager"
DocType: GST HSN Code,GST HSN Code,GST HSN-kod
DocType: Employee External Work History,Total Experience,Total Experience
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,öppna projekt
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Följesedlar avbryts
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Kassaflöde från investeringsverksamheten
DocType: Program Course,Program Course,program Kurs
DocType: Healthcare Service Unit,Allow Appointments,Tillåt möten
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Freight and Forwarding Charges,"Frakt, spedition Avgifter"
DocType: Homepage,Company Tagline for website homepage,Företag Tagline för webbplats hemsida
DocType: Item Group,Item Group Name,Produkt  Gruppnamn
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,Taken
DocType: Invoice Discounting,Short Term Loan Account,Kortfristigt lånekonto
DocType: Student,Date of Leaving,Datum för att lämna
DocType: Pricing Rule,For Price List,För prislista
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Executive Search,Executive Search
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,Inställning av standardvärden
DocType: Loyalty Program,Auto Opt In (For all customers),Auto Opt In (för alla kunder)
apps/erpnext/erpnext/utilities/activation.py,Create Leads,Skapa Leads
DocType: Maintenance Schedule,Schedules,Scheman
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,POS Profile is required to use Point-of-Sale,POS-profil krävs för att använda Point of Sale
DocType: Cashier Closing,Net Amount,Nettobelopp
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has not been submitted so the action cannot be completed,{0} {1} har inte skickats in så åtgärden kan inte slutföras
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detalj nr
DocType: Support Search Source,Result Route Field,Resultat Ruttfält
DocType: Supplier,PAN,PANORERA
DocType: Employee Checkin,Log Type,Loggtyp
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Ytterligare rabattbeloppet (Företagsvaluta)
DocType: Supplier Scorecard,Supplier Scorecard,Leverantör Scorecard
DocType: Plant Analysis,Result Datetime,Resultat Datetime
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,From employee is required while receiving Asset {0} to a target location,Från anställd krävs medan du får tillgång {0} till en målplats
,Support Hour Distribution,Stödtiddistribution
DocType: Maintenance Visit,Maintenance Visit,Servicebesök
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Stäng lån
DocType: Student,Leaving Certificate Number,Leaving Certificate Number
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}","Avstämning av avtalet, Granska och avbryt faktura {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Tillgänglig Batch Antal vid Lager
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,Uppdatera utskriftsformat
DocType: Bank Account,Is Company Account,Är företagskonto
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Lämna typ {0} är inte inkashable
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit is already defined for the Company {0},Kreditgränsen är redan definierad för företaget {0}
DocType: Landed Cost Voucher,Landed Cost Help,Landad kostnad Hjälp
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-
DocType: Purchase Invoice,Select Shipping Address,Välj leveransadress
DocType: Timesheet Detail,Expected Hrs,Förväntad tid
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Memebership Detaljer
DocType: Leave Block List,Block Holidays on important days.,Block Semester på viktiga dagar.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please input all required Result Value(s),Vänligen ange alla nödvändiga resultatvärden (er)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Kundfordringar Sammanfattning
DocType: POS Closing Voucher,Linked Invoices,Länkade fakturor
DocType: Loan,Monthly Repayment Amount,Månatliga återbetalningen belopp
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Öppna fakturor
DocType: Contract,Contract Details,Kontraktsdetaljer
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,Ställ in användar-ID fältet i en anställd post för att ställa in anställdes Roll
DocType: UOM,UOM Name,UOM Namn
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,Till Adress 1
DocType: GST HSN Code,HSN Code,HSN-kod
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,Bidragsbelopp
DocType: Homepage Section,Section Order,Avsnitt Order
DocType: Inpatient Record,Patient Encounter,Patient Encounter
DocType: Accounts Settings,Shipping Address,Leverans Adress
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Detta verktyg hjälper dig att uppdatera eller rätta mängden och värdering av lager i systemet. Det är oftast används för att synkronisera systemvärden och vad som faktiskt finns i dina lager.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,I Ord kommer att synas när du sparar följesedel.
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,Overifierade Webhook Data
DocType: Water Analysis,Container,Behållare
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} visas flera gånger i rad {2} &amp; {3}
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Following fields are mandatory to create address:,Följande fält är obligatoriska för att skapa adress:
DocType: Item Alternative,Two-way,Tvåvägs
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},Fel vid bearbetning av uppskjuten redovisning för {0}
,Employee Billing Summary,Sammanfattning av fakturering av anställda
DocType: Project,Day to Send,Dag att skicka
DocType: Healthcare Settings,Manage Sample Collection,Hantera provsamling
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,Ange serien som ska användas.
DocType: Patient,Tobacco Past Use,Tidig användning av tobak
DocType: Travel Itinerary,Mode of Travel,Mode av resor
DocType: Sales Invoice Item,Brand Name,Varumärke
DocType: Purchase Receipt,Transporter Details,Transporter Detaljer
DocType: Issue,Service Level Agreement Creation,Servicenivåavtalskapande
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Standardlager krävs för vald post
DocType: Quiz,Passing Score,Godkänd poäng
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,möjlig Leverantör
DocType: Budget,Monthly Distribution,Månads Fördelning
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,Mottagare Lista är tom. Skapa Mottagare Lista
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Ogiltig GSTIN! Ingången du har angett stämmer inte med GSTIN-formatet för UIN-innehavare eller OIDAR-tjänsteleverantörer som inte är bosatta
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Sjukvård (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Produktionsplan för kundorder
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",Ingen aktiv BOM hittades för objektet {0}. Leverans med \ Serienummer kan inte garanteras
DocType: Sales Partner,Sales Partner Target,Sales Partner Target
DocType: Loan Type,Maximum Loan Amount,Maximala lånebeloppet
DocType: Coupon Code,Pricing Rule,Prissättning Regel
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dubbelnummer för student {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dubbelnummer för student {0}
apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Material begäran om att inköpsorder
DocType: Company,Default Selling Terms,Standardförsäljningsvillkor
DocType: Shopping Cart Settings,Payment Success URL,Betalning Framgång URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Rad # {0}: Returnerad artikel {1} existerar inte i {2} {3}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,Bankkonton
,Bank Reconciliation Statement,Bank Avstämning Uttalande
DocType: Patient Encounter,Medical Coding,Medicinsk kodning
DocType: Healthcare Settings,Reminder Message,Påminnelsemeddelande
DocType: Call Log,Lead Name,Prospekt Namn
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,prospektering
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Ingående lagersaldo
DocType: Asset Category Account,Capital Work In Progress Account,Capital Work Progress Account
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Värdetillgång för tillgångar
DocType: Additional Salary,Payroll Date,Lönedatum
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} måste bara finnas en gång
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Lämnar Avsatt framgångsrikt för {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,Inga produkter att packa
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Only .csv and .xlsx files are supported currently,Endast .csv- och .xlsx-filer stöds för närvarande
DocType: Shipping Rule Condition,From Value,Från Värde
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,Tillverknings Kvantitet är obligatorisk
DocType: Loan,Repayment Method,återbetalning Metod
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website",Om markerad startsidan vara standardArtikelGrupp för webbplatsen
DocType: Quality Inspection Reading,Reading 4,Avläsning 4
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,Väntande kvantitet
apps/erpnext/erpnext/utilities/activation.py,"Students are at the heart of the system, add all your students","Eleverna i hjärtat i systemet, lägga till alla dina elever"
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,Medlems-ID
DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,Månadsberättigande belopp
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Rad # {0}: Clearance datum {1} kan inte vara före check Datum {2}
DocType: Asset Maintenance Task,Certificate Required,Certifikat krävs
DocType: Company,Default Holiday List,Standard kalender
DocType: Pricing Rule,Supplier Group,Leverantörsgrupp
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Sammandrag
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},Rad {0}: Från tid och att tiden på {1} överlappar med {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Stock Skulder
DocType: Purchase Invoice,Supplier Warehouse,Leverantör Lager
DocType: Opportunity,Contact Mobile No,Kontakt Mobil nr
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Select Company,Välj företag
,Material Requests for which Supplier Quotations are not created,Material Begäran för vilka leverantörsofferter är inte skapade
apps/erpnext/erpnext/config/crm.py,"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Hjälper dig att hålla reda på kontrakt baserat på leverantör, kund och anställd"
DocType: Company,Discount Received Account,Mottaget rabattkonto
DocType: Appointment Booking Settings,Enable Appointment Scheduling,Aktivera schemaläggning för möten
DocType: Student Report Generation Tool,Print Section,Utskriftsavsnitt
DocType: Staffing Plan Detail,Estimated Cost Per Position,Beräknad kostnad per position
DocType: Employee,HR-EMP-,HR-EMP
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Användaren {0} har ingen standard POS-profil. Kontrollera standard i rad {1} för den här användaren.
DocType: Quality Meeting Minutes,Quality Meeting Minutes,Mötesprotokoll av kvalitet
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Anställningsreferens
DocType: Student Group,Set 0 for no limit,Set 0 för ingen begränsning
DocType: Cost Center,rgt,RGT
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Dagen (s) som du ansöker om ledighet är helgdagar. Du behöver inte ansöka om tjänstledighet.
DocType: Customer,Primary Address and Contact Detail,Primär adress och kontaktdetaljer
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Skicka om Betalning E
apps/erpnext/erpnext/templates/pages/projects.html,New task,Ny uppgift
DocType: Appointment,Appointment,Utnämning
apps/erpnext/erpnext/config/buying.py,Other Reports,andra rapporter
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Var god välj minst en domän.
DocType: Dependent Task,Dependent Task,Beroende Uppgift
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Leveranser till UIN-innehavare
DocType: Shopify Settings,Shopify Tax Account,Shopify Skattekonto
apps/erpnext/erpnext/stock/doctype/item/item.py,Conversion factor for default Unit of Measure must be 1 in row {0},Omvandlingsfaktor för standardmåttenhet måste vara en i raden {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Ledighet av typen {0} inte kan vara längre än {1}
DocType: Delivery Trip,Optimize Route,Optimera Rutt
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Försök att planera verksamheten för X dagar i förväg.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.",{0} lediga tjänster och {1} budget för {2} som redan planerats för dotterbolag på {3}. \ Du kan bara planera upp till {4} lediga tjänster och och budget {5} enligt personalplan {6} för moderbolaget {3}.
DocType: HR Settings,Stop Birthday Reminders,Stop födelsedag Påminnelser
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},Ställ Default Lön betalas konto i bolaget {0}
DocType: Pricing Rule Brand,Pricing Rule Brand,Prissättningsmärke
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Få ekonomisk uppdelning av skatter och avgifter data av Amazon
DocType: SMS Center,Receiver List,Mottagare Lista
DocType: Pricing Rule,Rule Description,Regelbeskrivning
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,Sök Produkt
DocType: Program,Allow Self Enroll,Tillåt självregistrering
DocType: Payment Schedule,Payment Amount,Betalningsbelopp
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Halvdag Datum ska vara mellan Arbete från datum och arbets slutdatum
DocType: Healthcare Settings,Healthcare Service Items,Hälso- och sjukvårdstjänster
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Ogiltig streckkod. Det finns ingen artikel bifogad denna streckkod.
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Förbrukad mängd
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Nettoförändring i Cash
DocType: Assessment Plan,Grading Scale,Betygsskala
apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Mätenhet {0} har angetts mer än en gång i Omvandlingsfaktor Tabell
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,Lager i handen
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Please add the remaining benefits {0} to the application as \
				pro-rata component",Lägg till de övriga fördelarna {0} till programmet som \ pro-rata-komponent
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',Vänligen ange skattekod för den offentliga förvaltningen &#39;% s&#39;
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Issued Items,Kostnad för utfärdade artiklar
DocType: Healthcare Practitioner,Hospital,Sjukhus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity must not be more than {0},Antal får inte vara mer än {0}
DocType: Travel Request Costing,Funded Amount,Finansierat belopp
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Previous Financial Year is not closed,Föregående räkenskapsperiod inte stängd
DocType: Practitioner Schedule,Practitioner Schedule,Utövare Schema
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Ålder (dagar)
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Additional Salary,Additional Salary,Ytterligare lön
DocType: Quotation Item,Quotation Item,Offert Artikel
DocType: Customer,Customer POS Id,Kundens POS-ID
apps/erpnext/erpnext/education/utils.py,Student with email {0} does not exist,Student med e-post {0} finns inte
DocType: Account,Account Name,Kontonamn
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.py,From Date cannot be greater than To Date,Från Datum kan inte vara större än Till Datum
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} quantity {1} cannot be a fraction,Serienummer {0} kvantitet {1} inte kan vara en fraktion
DocType: Pricing Rule,Apply Discount on Rate,Tillämpa rabatt på pris
DocType: Tally Migration,Tally Debtors Account,Tally Debtors Account
DocType: Pricing Rule,Promotional Scheme,Kampanjschema
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Vänligen ange webbadress för WoCommerce Server
DocType: GSTR 3B Report,September,september
DocType: Purchase Order Item,Supplier Part Number,Leverantör Artikelnummer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Conversion rate cannot be 0 or 1,Konverteringskurs kan inte vara 0 eller 1
apps/erpnext/erpnext/accounts/page/bank_reconciliation/linked_payment_header.html,Payment Name,Betalningsnamn
DocType: Share Balance,To No,Till nr
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Atleast one asset has to be selected.,Atleast en tillgång måste väljas.
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,All obligatorisk uppgift för skapande av arbetstagare har ännu inte gjorts.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} är avbruten eller stoppad
DocType: Accounts Settings,Credit Controller,Kreditcontroller
DocType: Loan,Applicant Type,Sökande Typ
DocType: Purchase Invoice,03-Deficiency in services,03-Brister i tjänster
DocType: Healthcare Settings,Default Medical Code Standard,Standard Medical Code Standard
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
DocType: Project Template Task,Project Template Task,Projektmalluppgift
DocType: Accounts Settings,Over Billing Allowance (%),Över faktureringsbidrag (%)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Receipt {0} is not submitted,Inköpskvitto {0} är inte lämnat
DocType: Company,Default Payable Account,Standard betalkonto
apps/erpnext/erpnext/config/website.py,"Settings for online shopping cart such as shipping rules, price list etc.","Inställningar för webbutik som fraktregler, prislista mm"
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0}% Fakturerad
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,Reserverad Antal
DocType: Party Account,Party Account,Parti-konto
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,Var god välj Företag och Beteckning
apps/erpnext/erpnext/config/settings.py,Human Resources,Personal Resurser
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,Övre inkomst
DocType: Item Manufacturer,Item Manufacturer,Punkt Tillverkare
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Lead,Skapa ny bly
DocType: BOM Operation,Batch Size,Satsstorlek
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Avvisa
DocType: Journal Entry Account,Debit in Company Currency,Debet i bolaget Valuta
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Importera framgångsrikt
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.",Materialförfrågan har inte skapats som mängd för redan tillgängliga råmaterial.
DocType: BOM Item,BOM Item,BOM Punkt
DocType: Appraisal,For Employee,För anställd
DocType: Leave Control Panel,Designation (optional),Beteckning (valfritt)
apps/erpnext/erpnext/stock/stock_ledger.py,"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.","Värderingsgrad hittades inte för artikeln {0}, vilket krävs för att göra bokföringsposter för {1} {2}. Om objektet handlar som en nollvärderingspost i {1}, berätta om det i tabellen {1}. I annat fall kan du skapa en inkommande aktietransaktion för artikeln eller nämna värderingsgraden i posten och försök sedan skicka / avbryta den här posten."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Rad {0}: Advance mot Leverantören måste debitera
DocType: Company,Default Values,Standardvärden
DocType: Certification Application,INR,INR
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Behandlar parti-adresser
DocType: Woocommerce Settings,Creation User,Skapande användare
DocType: Quality Procedure,Quality Procedure,Kvalitetsförfarande
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please check the error log for details about the import errors,Kontrollera felloggen för detaljer om importfel
DocType: Bank Transaction,Reconciled,förenas
DocType: Expense Claim,Total Amount Reimbursed,Totala belopp som ersatts
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py,This is based on logs against this Vehicle. See timeline below for details,Detta grundar sig på stockar mot detta fordon. Se tidslinje nedan för mer information
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,Lönedatum kan inte vara mindre än anställdes anslutningsdatum
DocType: Pick List,Item Locations,Objektplatser
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,{0} {1} skapad
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,"Job Openings for designation {0} already open \
					or hiring completed as per Staffing Plan {1}",Jobbmöjligheten för beteckning {0} redan öppen \ eller anställning slutförd enligt anställningsplan {1}
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,You can publish upto 200 items.,Du kan publicera upp till 200 objekt.
DocType: Vital Signs,Constipated,toppad
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Against Supplier Invoice {0} dated {1},Mot leverantörsfakturor {0} den {1}
DocType: Customer,Default Price List,Standard Prislista
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,Asset Rörelse rekord {0} skapades
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Du kan inte ta bort Räkenskapsårets {0}. Räkenskapsårets {0} är satt som standard i Globala inställningar
DocType: Share Transfer,Equity/Liability Account,Eget kapital / Ansvarskonto
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,En kund med samma namn finns redan
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Detta kommer att skicka löneglister och skapa periodiseringsjournalen. Vill du fortsätta?
DocType: Purchase Invoice,Total Net Weight,Total nettovikt
DocType: Purchase Order,Order Confirmation No,Orderbekräftelse nr
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,Nettoförtjänst
DocType: Purchase Invoice,Eligibility For ITC,Stödberättigande för ITC
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Journal Entry,Entry Type,Entry Type
,Customer Credit Balance,Kund tillgodohavande
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,Netto Förändring av leverantörsskulder
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit has been crossed for customer {0} ({1}/{2}),Kreditgränsen har överskridits för kund {0} ({1} / {2})
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Customer required for 'Customerwise Discount',"Kunder krävs för ""Kundrabatt"""
apps/erpnext/erpnext/config/accounts.py,Update bank payment dates with journals.,Uppdatera bankbetalningsdagar med tidskrifter.
,Billed Qty,Fakturerad kvantitet
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,Prissättning
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),Deltagande enhets-ID (biometrisk / RF-tag-ID)
DocType: Quotation,Term Details,Term Detaljer
DocType: Item,Over Delivery/Receipt Allowance (%),Överleverans / kvittobidrag (%)
DocType: Employee Incentive,Employee Incentive,Anställdas incitament
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,Det går inte att registrera mer än {0} studenter för denna elevgrupp.
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),Totalt (utan skatt)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Lödräkning
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Lödräkning
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,Lager tillgänglig
DocType: Manufacturing Settings,Capacity Planning For (Days),Kapacitetsplanering för (Dagar)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,Anskaffning
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,Inget av objekten har någon förändring i kvantitet eller värde.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Obligatoriskt fält - Program
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Obligatoriskt fält - Program
DocType: Special Test Template,Result Component,Resultatkomponent
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,Garantianspråk
,Lead Details,Prospekt Detaljer
DocType: Volunteer,Availability and Skills,Tillgänglighet och färdigheter
DocType: Salary Slip,Loan repayment,Låneåterbetalning
DocType: Share Transfer,Asset Account,Tillgångskonto
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nytt släppdatum borde vara i framtiden
DocType: Purchase Invoice,End date of current invoice's period,Slutdatum för aktuell faktura period
DocType: Lab Test,Technician Name,Tekniker namn
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
					Item {0} is added with and without Ensure Delivery by \
					Serial No.",Kan inte garantera leverans med serienummer som \ Item {0} läggs till med och utan Se till att leverans med \ Serienummer
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Bort länken Betalning på Indragning av faktura
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Nuvarande vägmätare läsning deltagare bör vara större än initial Vägmätarvärde {0}
,Purchase Order Items To Be Received or Billed,Beställningsobjekt som ska tas emot eller faktureras
DocType: Restaurant Reservation,No Show,Icke infinnande
apps/erpnext/erpnext/regional/india/utils.py,You must be a registered supplier to generate e-Way Bill,Du måste vara en registrerad leverantör för att generera e-Way Bill
DocType: Shipping Rule Country,Shipping Rule Country,Frakt Regel Land
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Lämna och närvaro
DocType: Asset,Comprehensive Insurance,Allriskförsäkring
DocType: Maintenance Visit,Partially Completed,Delvis Färdig
apps/erpnext/erpnext/public/js/event.js,Add Leads,Lägg till Leads
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Måttlig känslighet
DocType: Leave Type,Include holidays within leaves as leaves,Inkludera semester inom ledighet som ledighet
DocType: Loyalty Program,Redemption,inlösen
DocType: Sales Invoice,Packed Items,Packade artiklar
DocType: Tally Migration,Vouchers,kuponger
DocType: Tax Withholding Category,Tax Withholding Rates,Skatteavdrag
DocType: Contract,Contract Period,Avtalsperiod
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,Garantianspråk mot serienummer
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total',&#39;Total&#39;
DocType: Shopping Cart Settings,Enable Shopping Cart,Aktivera Varukorgen
DocType: Employee,Permanent Address,Permanent Adress
DocType: Loyalty Program,Collection Tier,Collection Tier
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,Från datumet kan inte vara mindre än anställdes anslutningsdatum
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Förskott som betalats mot {0} {1} kan inte vara större \ än Totalsumma {2}
DocType: Patient,Medication,Medicin
DocType: Production Plan,Include Non Stock Items,Inkludera icke-lagerobjekt
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select item code,Välj artikelkod
DocType: Student Sibling,Studying in Same Institute,Studera i samma institut
DocType: Leave Type,Earned Leave,Förtjänt Avgång
apps/erpnext/erpnext/erpnext_integrations/connectors/shopify_connection.py,Tax Account not specified for Shopify Tax {0},Skattekonto inte specificerat för Shopify skatt {0}
DocType: Employee,Salary Details,Lön Detaljer
DocType: Territory,Territory Manager,Territorium manager
DocType: Packed Item,To Warehouse (Optional),Till Warehouse (tillval)
DocType: GST Settings,GST Accounts,GST-konton
DocType: Payment Entry,Paid Amount (Company Currency),Betald Belopp (Company valuta)
DocType: Purchase Invoice,Additional Discount,Ytterligare rabatt
DocType: Selling Settings,Selling Settings,Försälja Inställningar
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Online Auctions,Online Auktioner
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please specify either Quantity or Valuation Rate or both,Ange antingen Kvantitet eller Värderingsomsättning eller båda
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,Uppfyllelse
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Visa i varukorgen
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Purchase Invoice cannot be made against an existing asset {0},Köpfaktura kan inte göras mot en befintlig tillgång {0}
DocType: Employee Checkin,Shift Actual Start,Skift faktisk start
DocType: Tally Migration,Is Day Book Data Imported,Är dagbokdata importerade
,Purchase Order Items To Be Received or Billed1,Beställningsobjekt som ska tas emot eller faktureras1
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Marketing Expenses,Marknadsföringskostnader
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,{0} units of {1} is not available.,{0} enheter på {1} är inte tillgängliga.
,Item Shortage Report,Produkt Brist Rapportera
DocType: Bank Transaction Payments,Bank Transaction Payments,Banktransaktionsbetalningar
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,Kan inte skapa standardkriterier. Vänligen byt namn på kriterierna
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Vikt nämns \ Vänligen ange ""Vikt UOM"" också"
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,For Month,För månad
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Material Begäran används för att göra detta Lagerinlägg
DocType: Hub User,Hub Password,Navlösenord
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Separat kursbaserad grupp för varje grupp
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Separat kursbaserad grupp för varje grupp
,Sales Partner Target Variance based on Item Group,Försäljningspartner Målvarians baserad på artikelgrupp
apps/erpnext/erpnext/config/support.py,Single unit of an Item.,Enda enhet av ett objekt.
DocType: Fee Category,Fee Category,avgift Kategori
DocType: Agriculture Task,Next Business Day,Nästa affärsdags
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Tilldelade blad
DocType: Drug Prescription,Dosage by time interval,Dosering efter tidsintervall
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Totalt beskattningsbart värde
DocType: Cash Flow Mapper,Section Header,Sektionsrubrik
,Student Fee Collection,Student Fee Collection
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),Utnämningstid (min)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Skapa kontering för varje lagerförändring
DocType: Leave Allocation,Total Leaves Allocated,Totala Löv Avsatt
apps/erpnext/erpnext/public/js/setup_wizard.js,Please enter valid Financial Year Start and End Dates,Ange ett giltigt räkenskapsåret start- och slutdatum
DocType: Employee,Date Of Retirement,Datum för pensionering
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Asset Value,Tillgångsvärde
DocType: Upload Attendance,Get Template,Hämta mall
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Pick List,Plocklista
,Sales Person Commission Summary,Försäljningskommitté Sammanfattning
DocType: Material Request,Transferred,Överförd
DocType: Vehicle,Doors,dörrar
DocType: Healthcare Settings,Collect Fee for Patient Registration,Samla avgift för patientregistrering
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Kan inte ändra attribut efter aktiehandel. Skapa ett nytt objekt och överför lagret till det nya objektet
DocType: Course Assessment Criteria,Weightage,Vikt
DocType: Purchase Invoice,Tax Breakup,Skatteavbrott
DocType: Employee,Joining Details,Registreringsuppgifter
DocType: Member,Non Profit Member,Icke vinstmedlem
DocType: Email Digest,Bank Credit Balance,Bankens kreditbalans
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,"{0} {1}: Kostnadsställe krävs för ""Resultaträkning"" konto {2}. Ange ett standardkostnadsställe för bolaget."
DocType: Payment Schedule,Payment Term,Betalningsvillkor
apps/erpnext/erpnext/selling/doctype/customer/customer.py,A Customer Group exists with same name please change the Customer name or rename the Customer Group,En kundgrupp finns redan med samma namn. Vänligen ändra kundens namn eller byt namn på kundgruppen
DocType: Location,Area,Område
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Ny kontakt
DocType: Company,Company Description,Företagsbeskrivning
DocType: Territory,Parent Territory,Överordnat område
DocType: Purchase Invoice,Place of Supply,Leveransplats
DocType: Quality Inspection Reading,Reading 2,Avläsning 2
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Employee {0} already submited an apllication {1} for the payroll period {2},Anställd {0} har redan lämnat in en ansökan {1} för löneperioden {2}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Material Kvitto
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Skicka / avstämma betalningar
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-
DocType: Homepage,Products,Produkter
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,Få fakturor baserade på filter
DocType: Announcement,Instructor,Instruktör
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Quantity to Manufacture can not be zero for the operation {0},Antalet tillverkning kan inte vara noll för operationen {0}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Välj objekt (tillval)
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,Lojalitetsprogrammet är inte giltigt för det valda företaget
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Avgiftsschema Studentgrupp
DocType: Student,AB+,AB+
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Om denna artikel har varianter, så det kan inte väljas i kundorder etc."
apps/erpnext/erpnext/config/selling.py,Define coupon codes.,Definiera kupongkoder.
DocType: Products Settings,Hide Variants,Dölj varianter
DocType: Lead,Next Contact By,Nästa Kontakt Vid
DocType: Compensatory Leave Request,Compensatory Leave Request,Kompensationsförfrågan
apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Det går inte att överbeställa för artikel {0} i rad {1} mer än {2}. För att tillåta överfakturering, ange tillåtelse i Kontoinställningar"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Kvantitet som krävs för artikel {0} i rad {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Lager {0} kan inte tas bort då kvantitet existerar för artiklar {1}
DocType: Blanket Order,Order Type,Beställ Type
,Item-wise Sales Register,Produktvis säljregister
DocType: Asset,Gross Purchase Amount,Bruttoköpesumma
DocType: Asset,Depreciation Method,avskrivnings Metod
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Är denna skatt inkluderar i Basic kursen?
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,Totalt Target
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Perception Analysis,Perception Analysis
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,Integrerad skatt
DocType: Soil Texture,Sand Composition (%),Sandkomposition (%)
DocType: Job Applicant,Applicant for a Job,Sökande för ett jobb
DocType: Production Plan Material Request,Production Plan Material Request,Produktionsplanen Material Begäran
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Automatic Reconciliation,Automatisk försoning
DocType: Purchase Invoice,Release Date,Utgivningsdatum
DocType: Stock Reconciliation,Reconciliation JSON,Avstämning JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html,Too many columns. Export the report and print it using a spreadsheet application.,Alltför många kolumner. Exportera rapporten och skriva ut det med hjälp av ett kalkylprogram.
DocType: Purchase Invoice Item,Batch No,Batch nr
DocType: Marketplace Settings,Hub Seller Name,Hubb Säljarens namn
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Medarbetarförskott
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Tillåt flera kundorder mot Kundens beställning
DocType: Student Group Instructor,Student Group Instructor,Studentgruppsinstruktör
DocType: Student Group Instructor,Student Group Instructor,Studentgruppsinstruktör
DocType: Grant Application,Assessment  Mark (Out of 10),Bedömningsmärke (av 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2 Mobile No
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Huvud
DocType: GSTR 3B Report,July,juli
apps/erpnext/erpnext/controllers/buying_controller.py,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Följande objekt {0} är inte markerat som {1} objekt. Du kan aktivera dem som {1} -objekt från dess objektmastern
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,Variant
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be negative number",För ett objekt {0} måste kvantitet vara negativt tal
DocType: Naming Series,Set prefix for numbering series on your transactions,Ställ prefix för nummerserie på dina transaktioner
DocType: Employee Attendance Tool,Employees HTML,Anställda HTML
apps/erpnext/erpnext/stock/doctype/item/item.py,Default BOM ({0}) must be active for this item or its template,Standard BOM ({0}) måste vara aktiv för denna artikel eller dess mall
DocType: Employee,Leave Encashed?,Lämna inlösen?
apps/erpnext/erpnext/regional/report/datev/datev.py,<b>From Date</b> is a mandatory filter.,<b>From Date</b> är ett obligatoriskt filter.
DocType: Email Digest,Annual Expenses,årliga kostnader
DocType: Item,Variants,Varianter
DocType: SMS Center,Send To,Skicka Till
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,There is not enough leave balance for Leave Type {0},Det finns inte tillräckligt ledighet balans för Lämna typ {0}
DocType: Payment Reconciliation Payment,Allocated amount,Avsatt mängd
DocType: Sales Team,Contribution to Net Total,Bidrag till Net Total
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Manufactured,Tillverkad
DocType: Sales Invoice Item,Customer's Item Code,Kundens Artikelkod
DocType: Stock Reconciliation,Stock Reconciliation,Lager Avstämning
DocType: Territory,Territory Name,Territorium Namn
DocType: Email Digest,Purchase Orders to Receive,Inköpsorder att ta emot
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work-in-Progress Warehouse is required before Submit,Pågående Arbete - Lager krävs innan du kan Skicka
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You can only have Plans with the same billing cycle in a Subscription,Du kan bara ha planer med samma faktureringsperiod i en prenumeration
DocType: Bank Statement Transaction Settings Item,Mapped Data,Mappad data
DocType: Purchase Order Item,Warehouse and Reference,Lager och referens
DocType: Payroll Period Date,Payroll Period Date,Lön Period Period
DocType: Supplier,Statutory info and other general information about your Supplier,Lagstadgad information och annan allmän information om din leverantör
DocType: Item,Serial Nos and Batches,Serienummer och partier
DocType: Item,Serial Nos and Batches,Serienummer och partier
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Studentgruppsstyrkan
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Studentgruppsstyrkan
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,Mot Journal anteckning {0} inte har någon matchat {1} inlägg
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies",Dotterbolag har redan planerat för {1} lediga tjänster på en budget på {2}. \ Staffing Plan för {0} bör fördela fler lediga platser och budget för {3} än planerat för sina dotterbolag
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Utbildningshändelser
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},Duplicera Löpnummer upp till punkt {0}
DocType: Quality Review Objective,Quality Review Objective,Kvalitetsgranskningsmål
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Spåra ledningar av blykälla.
DocType: Shipping Rule Condition,A condition for a Shipping Rule,En förutsättning för en frakt Regel
DocType: Sales Invoice,e-Way Bill No.,e-Way Bill No.
DocType: GSTR 3B Report,JSON Output,JSON Output
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,Stig på
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Underhållsloggen
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.py,Please set filter based on Item or Warehouse,Ställ filter baserat på punkt eller Warehouse
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Nettovikten av detta paket. (Beräknas automatiskt som summan av nettovikt av objekt)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount amount cannot be greater than 100%,Rabattbeloppet får inte vara större än 100%
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,"Number of new Cost Center, it will be included in the cost center name as a prefix","Antal nya kostnadscenter, det kommer att ingå i kostnadscentrets namn som ett prefix"
DocType: Sales Order,To Deliver and Bill,Att leverera och Bill
DocType: Student Group,Instructors,instruktörer
DocType: GL Entry,Credit Amount in Account Currency,Credit Belopp i konto Valuta
DocType: Stock Entry,Receive at Warehouse,Få på lager
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Redovisningsdimension <b>{0}</b> krävs för kontot &#39;Vinst och förlust&#39; {1}.
DocType: Communication Medium,Voice,Röst
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,BOM {0} måste lämnas in
apps/erpnext/erpnext/config/accounts.py,Share Management,Aktiehantering
DocType: Authorization Control,Authorization Control,Behörighetskontroll
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Rad # {0}: Avslag Warehouse är obligatoriskt mot förkastade Punkt {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Mottagna aktieuppgifter
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,Betalning
apps/erpnext/erpnext/controllers/stock_controller.py,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.",Lager {0} är inte länkat till något konto. Vänligen ange kontot i lageret eller sätt in det vanliga kontot i företaget {1}.
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Hantera order
DocType: Work Order Operation,Actual Time and Cost,Faktisk tid och kostnad
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Material Begäran om maximalt {0} kan göras till punkt {1} mot kundorder {2}
DocType: Amazon MWS Settings,DE,DE
DocType: Crop,Crop Spacing,Beskära Spacing
DocType: Budget,Action if Annual Budget Exceeded on PO,Åtgärd om årlig budget överskrider PO
DocType: Issue,Service Level,Servicenivå
DocType: Student Leave Application,Student Leave Application,Student Lämna Application
DocType: Item,Will also apply for variants,Kommer också att ansöka om varianter
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}","Asset kan inte avbrytas, eftersom det redan är {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},Anställd {0} på Halvdag på {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Total working hours should not be greater than max working hours {0},Totalt arbetstid bör inte vara större än max arbetstid {0}
apps/erpnext/erpnext/templates/pages/task_info.html,On,På
apps/erpnext/erpnext/config/buying.py,Bundle items at time of sale.,Bundlade poster vid tidpunkten för försäljning.
DocType: Products Settings,Product Page,Produkt sida
DocType: Delivery Settings,Dispatch Settings,Dispatch Settings
DocType: Material Request Plan Item,Actual Qty,Faktiska Antal
DocType: Sales Invoice Item,References,Referenser
DocType: Quality Inspection Reading,Reading 10,Avläsning 10
DocType: Item,Barcodes,Streckkoder
DocType: Hub Tracked Item,Hub Node,Nav Nod
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,You have entered duplicate items. Please rectify and try again.,Du har angett dubbletter. Vänligen rätta och försök igen.
DocType: Tally Migration,Is Master Data Imported,Importeras stamdata
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,Associate
DocType: Asset Movement,Asset Movement,Asset Rörelse
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,Arbetsorder {0} måste lämnas in
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,ny vagn
DocType: Taxable Salary Slab,From Amount,Från belopp
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,Produktt {0} är inte en serialiserad Produkt
DocType: Leave Type,Encashment,inlösen
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Select a company,Välj ett företag
DocType: Delivery Settings,Delivery Settings,Leveransinställningar
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Hämta data
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},Max tillåten semester i ledighetstyp {0} är {1}
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish 1 Item,Publicera en artikel
DocType: SMS Center,Create Receiver List,Skapa Mottagare Lista
DocType: Student Applicant,LMS Only,Endast LMS
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,Tillgänglig för användning Datum ska vara efter inköpsdatum
DocType: Vehicle,Wheels,hjul
DocType: Packing Slip,To Package No.,Förpackningens Nej
DocType: Patient Relation,Family,Familj
DocType: Invoice Discounting,Invoice Discounting,Fakturabidrag
DocType: Sales Invoice Item,Deferred Revenue Account,Uppskjuten inkomstkonto
DocType: Production Plan,Material Requests,material Framställningar
DocType: Warranty Claim,Issue Date,Utgivningsdatum
DocType: Activity Cost,Activity Cost,Aktivitetskostnad
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Unmarked Attendance for days,Omärkt närvaro i dagar
DocType: Sales Invoice Timesheet,Timesheet Detail,tidrapport Detalj
DocType: Purchase Receipt Item Supplied,Consumed Qty,Förbrukad Antal
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Telecommunications,Telekommunikation
apps/erpnext/erpnext/setup/doctype/company/test_company.py,No Account matched these filters: {},Inget konto matchade dessa filter: {}
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Faktureringsvaluta måste vara lika med antingen standardbolagets valuta eller parti konto konto valuta
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Anger att paketet är en del av denna leverans (endast utkast)
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,Avslutande balans
DocType: Soil Texture,Loam,Lerjord
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,Rad {0}: Förfallodatum kan inte vara innan bokningsdatum
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Quantity for Item {0} must be less than {1},Kvantitet för artikel {0} måste vara mindre än {1}
,Sales Invoice Trends,Fakturan Trender
DocType: Leave Application,Apply / Approve Leaves,Ansök / Godkänn ledigheter
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,For,För
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Kan hänvisa till rad endast om avgiften är ""På föregående v Belopp"" eller ""Föregående rad Total"""
DocType: Sales Order Item,Delivery Warehouse,Leverans Lager
DocType: Leave Type,Earned Leave Frequency,Intjänad avgångsfrekvens
apps/erpnext/erpnext/config/accounts.py,Tree of financial Cost Centers.,Träd av finansiella kostnadsställen.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Subtyp
DocType: Serial No,Delivery Document No,Leverans Dokument nr
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Se till att leverans är baserad på tillverkat serienummer
DocType: Vital Signs,Furry,furry
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Ställ &quot;Vinst / Förlust konto på Asset Avfallshantering &#39;i sällskap {0}
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Add to Featured Item,Lägg till den utvalda artikeln
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Hämta objekt från kvitton
DocType: Serial No,Creation Date,Skapelsedagen
DocType: GSTR 3B Report,November,november
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Selling must be checked, if Applicable For is selected as {0}","Försäljnings måste kontrolleras, i förekommande fall för väljs som {0}"
DocType: Production Plan Material Request,Material Request Date,Material Request Datum
DocType: Purchase Order Item,Supplier Quotation Item,Leverantör offert Punkt
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,Materialförbrukning är inte inställd på tillverkningsinställningar.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View all issues from {0},Visa alla utgåvor från {0}
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
DocType: Quality Meeting Table,Quality Meeting Table,Mötesbord för kvalitet
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Besök forumet
DocType: Student,Student Mobile Number,Student Mobilnummer
DocType: Item,Has Variants,Har Varianter
DocType: Employee Benefit Claim,Claim Benefit For,Erfordra förmån för
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Uppdatera svar
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Du har redan valt objekt från {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Namn på månadens distribution
DocType: Quality Procedure Process,Quality Procedure Process,Kvalitetsprocessprocess
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,Batch-ID är obligatoriskt
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,Batch-ID är obligatoriskt
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,Please select Customer first,Välj kund först
DocType: Sales Person,Parent Sales Person,Överordnad Försäljningsperson
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,No items to be received are overdue,Inga objekt som ska tas emot är försenade
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The seller and the buyer cannot be the same,Säljaren och köparen kan inte vara samma
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No views yet,Inga visningar än
DocType: Project,Collect Progress,Samla framsteg
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Välj programmet först
DocType: Patient Appointment,Patient Age,Patientåldern
apps/erpnext/erpnext/config/help.py,Managing Projects,Hantera projekt
DocType: Quiz,Latest Highest Score,Senaste högsta poäng
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial no {0} has been already returned,Serienummer {0} har redan returnerats
DocType: Supplier,Supplier of Goods or Services.,Leverantör av varor eller tjänster.
DocType: Budget,Fiscal Year,Räkenskapsår
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only users with the {0} role can create backdated leave applications,Endast användare med {0} -rollen kan skapa backdaterade permissionsprogram
DocType: Asset Maintenance Log,Planned,Planerad
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,En {0} existerar mellan {1} och {2} (
DocType: Vehicle Log,Fuel Price,bränsle~~POS=TRUNC Pris
DocType: BOM Explosion Item,Include Item In Manufacturing,Inkludera objekt i tillverkningen
DocType: Item,Auto Create Assets on Purchase,Skapa tillgångar automatiskt vid köp
DocType: Bank Guarantee,Margin Money,Marginalpengar
DocType: Budget,Budget,Budget
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Ange öppet
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,Fast Asset Objektet måste vara en icke-lagervara.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budget kan inte tilldelas mot {0}, eftersom det inte är en intäkt eller kostnad konto"
DocType: Quality Review Table,Achieved,Uppnått
DocType: Student Admission,Application Form Route,Ansökningsblankett Route
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,End Date of Agreement can't be less than today.,Slutdatum för avtalet kan inte vara mindre än idag.
apps/erpnext/erpnext/public/js/hub/components/CommentInput.vue,Ctrl + Enter to submit,Ctrl + Enter för att skicka
DocType: Healthcare Settings,Patient Encounters in valid days,Patientmöten i giltiga dagar
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,Lämna typ {0} kan inte tilldelas eftersom det lämnar utan lön
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Rad {0}: Tilldelad mängd {1} måste vara mindre än eller lika med att fakturerat utestående belopp {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,I Ord kommer att synas när du sparar fakturan.
DocType: Lead,Follow Up,Uppföljning
apps/erpnext/erpnext/accounts/report/financial_statements.py,Cost Center: {0} does not exist,Kostnadscentrum: {0} finns inte
DocType: Item,Is Sales Item,Är Försäljningsobjekt
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Produktgruppträdet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Check Item master,Produkt {0} är inte inställt för Serial Nos. Kontrollera huvudprodukt
DocType: Maintenance Visit,Maintenance Time,Servicetid
,Amount to Deliver,Belopp att leverera
DocType: Asset,Insurance Start Date,Försäkring Startdatum
DocType: Salary Component,Flexible Benefits,Flexibla fördelar
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,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.,Termen Startdatum kan inte vara tidigare än året Startdatum för läsåret som termen är kopplad (läsåret {}). Rätta datum och försök igen.
apps/erpnext/erpnext/setup/doctype/company/company.js,There were errors.,Det fanns fel.
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,Pinkod
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,Det gick inte att konfigurera standardvärden
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Employee {0} has already applied for {1} between {2} and {3} : ,Anställd {0} har redan ansökt om {1} mellan {2} och {3}:
DocType: Guardian,Guardian Interests,Guardian Intressen
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Uppdatera kontonamn / nummer
DocType: Naming Series,Current Value,Nuvarande Värde
apps/erpnext/erpnext/controllers/accounts_controller.py,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Flera räkenskapsår finns för dagen {0}. Ställ företag under räkenskapsåret
DocType: Education Settings,Instructor Records to be created by,Instruktörsrekord som ska skapas av
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,{0} skapad
DocType: GST Account,GST Account,GST-konto
DocType: Delivery Note Item,Against Sales Order,Mot kundorder
,Serial No Status,Serial No Status
DocType: Payment Entry Reference,Outstanding,Utestående
DocType: Supplier,Warn POs,Varna PO: er
,Daily Timesheet Summary,Daglig Tidrapport Sammandrag
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Rad {0}: Om du vill ställa {1} periodicitet, tidsskillnad mellan från och till dags datum \ måste vara större än eller lika med {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,This is based on stock movement. See {0} for details,Detta är baserat på aktie rörelse. Se {0} för mer information
DocType: Pricing Rule,Selling,Försäljnings
DocType: Payment Entry,Payment Order Status,Betalningsorder Status
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Belopp {0} {1} avräknas mot {2}
DocType: Sales Person,Name and Employee ID,Namn och Anställnings ID
DocType: Promotional Scheme,Promotional Scheme Product Discount,Kampanjschema Produktrabatt
DocType: Website Item Group,Website Item Group,Webbplats Produkt Grupp
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Ingen löneavgift gjord för att lämna in för ovanstående valda kriterier ELLER lön som redan lämnats in
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,Tullar och skatter
DocType: Projects Settings,Projects Settings,Projektinställningar
DocType: Purchase Receipt Item,Batch No!,Batch Nej!
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please enter Reference date,Ange Referensdatum
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,{0} payment entries can not be filtered by {1},{0} betalningsposter kan inte filtreras efter {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tabell för punkt som kommer att visas i Web Site
DocType: Purchase Order Item Supplied,Supplied Qty,Medföljande Antal
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-
DocType: Purchase Order Item,Material Request Item,Material Begäran Produkt
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,Träd artikelgrupper.
DocType: Production Plan,Total Produced Qty,Totalt producerad mängd
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No reviews yet,Inga recensioner än
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot refer row number greater than or equal to current row number for this Charge type,Det går inte att hänvisa till radnr större än eller lika med aktuell rad nummer för denna avgiftstyp
DocType: Asset,Sold,Såld
,Item-wise Purchase History,Produktvis Köphistorik
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Klicka på ""Skapa schema"" för att hämta Löpnummer inlagt för artikel {0}"
DocType: Account,Frozen,Fryst
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,fordonstyp
DocType: Sales Invoice Payment,Base Amount (Company Currency),Basbelopp (företagets valuta)
DocType: Purchase Invoice,Registered Regular,Registrerad regelbunden
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,Råmaterial
DocType: Payment Reconciliation Payment,Reference Row,referens Row
DocType: Installation Note,Installation Time,Installationstid
DocType: Sales Invoice,Accounting Details,Redovisning Detaljer
DocType: Shopify Settings,status html,status html
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Ta bort alla transaktioner för detta företag
DocType: Designation,Required Skills,Erforderliga färdigheter
DocType: Inpatient Record,O Positive,O Positiv
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Investments,Investeringarna
DocType: Issue,Resolution Details,Åtgärds Detaljer
DocType: Leave Ledger Entry,Transaction Type,Överföringstyp
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Acceptanskriterier
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,Ange Material Begäran i ovanstående tabell
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,Inga återbetalningar är tillgängliga för Journal Entry
DocType: Hub Tracked Item,Image List,Bildlista
DocType: Item Attribute,Attribute Name,Attribut Namn
DocType: Subscription,Generate Invoice At Beginning Of Period,Generera faktura vid början av perioden
DocType: BOM,Show In Website,Visa i Webbsida
DocType: Loan Application,Total Payable Amount,Total Betalbelopp
DocType: Task,Expected Time (in hours),Förväntad tid (i timmar)
DocType: Item Reorder,Check in (group),Checka in (grupp)
DocType: Soil Texture,Silt,Slam
,Qty to Order,Antal till Ordern
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Konto huvudet under skuld eller eget kapital, där vinst / förlust bokas"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},En annan budgetpost &quot;{0}&quot; finns redan mot {1} &quot;{2}&quot; och konto &quot;{3}&quot; för verksamhetsåret {4}
apps/erpnext/erpnext/config/projects.py,Gantt chart of all tasks.,Gantt-schema för alla uppgifter.
DocType: Opportunity,Mins to First Response,Minuter till First Response
DocType: Pricing Rule,Margin Type,marginal Type
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0} timmar
DocType: Course,Default Grading Scale,Standardbedömningsskala
DocType: Appraisal,For Employee Name,För anställdes namn
DocType: Holiday List,Clear Table,Rensa Tabell
DocType: Woocommerce Settings,Tax Account,Skattekonto
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Available slots,Tillgängliga luckor
DocType: C-Form Invoice Detail,Invoice No,Faktura Nr
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,Betala
DocType: Room,Room Name,Rums Namn
DocType: Prescription Duration,Prescription Duration,Receptlängd
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Lämna inte kan tillämpas / avbryts innan {0}, som ledighet balans redan har carry-vidarebefordras i framtiden ledighet tilldelningspost {1}"
DocType: Activity Cost,Costing Rate,Kalkylfrekvens
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,Kund adresser och kontakter
DocType: Homepage Section,Section Cards,Avsnittskort
,Campaign Efficiency,Kampanjseffektivitet
DocType: Discussion,Discussion,Diskussion
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Sales Order Submission,På inlämning av orderorder
DocType: Bank Transaction,Transaction ID,Transaktions ID
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Avdragsskatt för ej inlämnad skattebefrielse bevis
DocType: Volunteer,Anytime,när som helst
DocType: Bank Account,Bank Account No,Bankkontonummer
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Anmälan om anställningsskattbefrielse
DocType: Patient,Surgical History,Kirurgisk historia
DocType: Bank Statement Settings Item,Mapped Header,Mapped Header
DocType: Employee,Resignation Letter Date,Avskedsbrev Datum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,Prissättning Regler ytterligare filtreras baserat på kvantitet.
DocType: Woocommerce Settings,"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Detta lager kommer att användas för att skapa försäljningsorder. Fallback-lagret är &quot;Butiker&quot;.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},Ange datum för anslutning till anställd {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},Ange datum för anslutning till anställd {0}
DocType: Inpatient Record,Discharge,Ansvarsfrihet
DocType: Task,Total Billing Amount (via Time Sheet),Totalt Billing Belopp (via Tidrapportering)
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Skapa avgiftsschema
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Upprepa kund Intäkter
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Installera instruktörens namngivningssystem i utbildning&gt; Utbildningsinställningar
DocType: Quiz,Enter 0 to waive limit,Ange 0 för att avstå från gränsen
DocType: Bank Statement Settings,Mapped Items,Mappade objekt
DocType: Amazon MWS Settings,IT,DET
DocType: Chapter,Chapter,Kapitel
DocType: Appointment Booking Settings,"Leave blank for home.
This is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Lämna tomt för hemmet. Detta är relativt till webbadressen, till exempel &quot;om&quot; kommer att omdirigera till &quot;https://yoursitename.com/about&quot;"
,Fixed Asset Register,Fast tillgångsregister
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Standardkonto uppdateras automatiskt i POS-faktura när det här läget är valt.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,Välj BOM och Antal för produktion
DocType: Asset,Depreciation Schedule,avskrivningsplanen
DocType: Bank Reconciliation Detail,Against Account,Mot Konto
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,Halv Dag Datum bör vara mellan Från datum och hittills
DocType: Maintenance Schedule Detail,Actual Date,Faktiskt Datum
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,Ange standardkostnadscentret i {0} företaget.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Daglig projektöversikt för {0}
DocType: Item,Has Batch No,Har Sats nr
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},Årlig Billing: {0}
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify Webhook Detalj
apps/erpnext/erpnext/config/accounts.py,Goods and Services Tax (GST India),Varor och tjänster Skatt (GST Indien)
DocType: Delivery Note,Excise Page Number,Punktnotering sidnummer
DocType: Asset,Purchase Date,inköpsdatum
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Kunde inte generera hemlighet
DocType: Volunteer,Volunteer Type,Volontär typ
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
DocType: Shift Assignment,Shift Type,Skift typ
DocType: Student,Personal Details,Personliga Detaljer
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Exportera e-fakturor
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Asset Depreciation Cost Center' in Company {0},Ställ &quot;Asset Avskrivningar kostnadsställe&quot; i bolaget {0}
,Maintenance Schedules,Underhålls scheman
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,"There are not enough asset created or linked to {0}. \
						Please create or link {1} Assets with respective document.",Det finns inte tillräckligt med tillgångar skapade eller länkade till {0}. \ Skapa eller länka {1} Tillgångar med respektive dokument.
DocType: Pricing Rule,Apply Rule On Brand,Tillämpa regel om märke
DocType: Task,Actual End Date (via Time Sheet),Faktisk Slutdatum (via Tidrapportering)
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,Kan inte stänga uppgift {0} eftersom dess beroende uppgift {1} inte är stängd.
DocType: Soil Texture,Soil Type,Marktyp
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Belopp {0} {1} mot {2} {3}
,Quotation Trends,Offert Trender
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},Produktgruppen nämns inte i huvudprodukten för objektet {0}
DocType: GoCardless Mandate,GoCardless Mandate,GoCardless Mandate
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,Debitering av konto måste vara ett mottagarkonto
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select finance book for the item {0} at row {1},Välj finansbok för posten {0} i rad {1}
DocType: Shipping Rule,Shipping Amount,Fraktbelopp
DocType: Supplier Scorecard Period,Period Score,Periodpoäng
apps/erpnext/erpnext/public/js/event.js,Add Customers,Lägg till kunder
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,Väntande antal
DocType: Lab Test Template,Special,Särskild
DocType: Loyalty Program,Conversion Factor,Omvandlingsfaktor
DocType: Purchase Order,Delivered,Levereras
,Vehicle Expenses,fordons Kostnader
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Skapa Lab Test (s) på Försäljningsfaktura Skicka
DocType: Serial No,Invoice Details,Faktura detaljer
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,Lönestruktur måste lämnas in innan skattereduceringsdeklarationen lämnas in
DocType: Grant Application,Show on Website,Visa på hemsidan
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Börja på
DocType: Hub Tracked Item,Hub Category,Navkategori
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Fordonsnummer
DocType: Loan,Loan Amount,Lånebelopp
DocType: Student Report Generation Tool,Add Letterhead,Lägg till brevpapper
DocType: Program Enrollment,Self-Driving Vehicle,Självkörande fordon
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Leverantörs Scorecard Standing
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Bill of Materials hittades inte för objektet {1}
DocType: Contract Fulfilment Checklist,Requirement,Krav
DocType: Journal Entry,Accounts Receivable,Kundreskontra
DocType: Quality Goal,Objectives,mål
DocType: HR Settings,Role Allowed to Create Backdated Leave Application,Roll tillåten för att skapa backdaterad lämna ansökan
DocType: Travel Itinerary,Meal Preference,matpreferens
,Supplier-Wise Sales Analytics,Leverantör-Wise Sales Analytics
apps/erpnext/erpnext/accounts/doctype/subscription_plan/subscription_plan.py,Billing Interval Count cannot be less than 1,Faktureringsintervall kan inte vara mindre än 1
DocType: Purchase Invoice,Availed ITC Central Tax,Utnyttjade ITC Central Tax
DocType: Sales Invoice,Company Address Name,Företagets adressnamn
DocType: Work Order,Use Multi-Level BOM,Använd Multi-Level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Inkludera avstämnignsanteckningar
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.py,The total allocated amount ({0}) is greated than the paid amount ({1}).,Det totala tilldelade beloppet ({0}) är högre än det betalda beloppet ({1}).
DocType: Landed Cost Voucher,Distribute Charges Based On,Fördela avgifter som grundas på
DocType: Projects Settings,Timesheets,tidrapporter
DocType: HR Settings,HR Settings,HR Inställningar
apps/erpnext/erpnext/config/accounts.py,Accounting Masters,Bokföringsmästare
DocType: Salary Slip,net pay info,nettolön info
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,CESS-belopp
DocType: Woocommerce Settings,Enable Sync,Aktivera synkronisering
DocType: Tax Withholding Rate,Single Transaction Threshold,Enda transaktionströskel
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Detta värde uppdateras i standardförsäljningsprislistan.
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Din vagn är tom
DocType: Email Digest,New Expenses,nya kostnader
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Optimize Route as Driver Address is Missing.,Kan inte optimera rutten eftersom förarens adress saknas.
DocType: Shareholder,Shareholder,Aktieägare
DocType: Purchase Invoice,Additional Discount Amount,Ytterligare rabatt Belopp
DocType: Cash Flow Mapper,Position,Placera
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Hämta artiklar från recept
DocType: Patient,Patient Details,Patientdetaljer
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Leveransens natur
DocType: Inpatient Record,B Positive,B Positiv
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",Maximal nytta av anställd {0} överstiger {1} med summan {2} av tidigare hävdat \ belopp
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,Överfört antal
DocType: Leave Block List Allow,Leave Block List Allow,Lämna Block List Tillåt
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbr can not be blank or space,Förkortning kan inte vara tomt eller mellanslag
DocType: Patient Medical Record,Patient Medical Record,Patient Medical Record
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Kvalitetsmöte agenda
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,Grupp till icke-Group
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,Sport
DocType: Leave Control Panel,Employee (optional),Anställd (valfritt)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Materialförfrågan {0} skickad.
DocType: Loan Type,Loan Name,Loan Namn
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,Totalt Faktisk
DocType: Chart of Accounts Importer,Chart Preview,Diagramförhandsvisning
DocType: Attendance,Shift,Flytta
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Enter API key in Google Settings.,Ange API-nyckeln i Google Inställningar.
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Skapa journalpost
DocType: Student Siblings,Student Siblings,elev Syskon
DocType: Subscription Plan Detail,Subscription Plan Detail,Prenumerationsplandetaljer
DocType: Quality Objective,Unit,Enhet
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,Ange Företag
,Customer Acquisition and Loyalty,Kundförvärv och Lojalitet
DocType: Issue,Response By Variance,Svar av variation
DocType: Asset Maintenance Task,Maintenance Task,Underhållsuppgift
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set B2C Limit in GST Settings.,Ange B2C-gränsvärden i GST-inställningar.
DocType: Marketplace Settings,Marketplace Settings,Marketplaceinställningar
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Lager där du hanterar lager av avvisade föremål
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish {0} Items,Publicera {0} artiklar
apps/erpnext/erpnext/setup/utils.py,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Det gick inte att hitta växelkursen för {0} till {1} för nyckeldatum {2}. Var god skapa en valutautbyteslista manuellt
DocType: POS Profile,Price List,Prislista
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} är nu standard räkenskapsår. Vänligen uppdatera din webbläsare för att ändringen ska träda i kraft.
apps/erpnext/erpnext/projects/doctype/task/task.js,Expense Claims,Räkningar
DocType: Issue,Support,Stöd
DocType: Appointment,Scheduled Time,Schemalagd tid
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Total undantagsbelopp
DocType: Content Question,Question Link,Frågeformulär
,BOM Search,BOM Sök
DocType: Accounting Dimension Detail,Mandatory For Balance Sheet,Obligatoriskt för balansräkningen
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Total förbrukad materialkostnad (via lagerinmatning)
DocType: Subscription,Subscription Period,Prenumerationsperiod
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,Till datum kan inte vara mindre än Från datum
,Delayed Order Report,Försenad orderrapport
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publicera &quot;I lager&quot; eller &quot;Ej i lager&quot; på nav baserat på lager som finns i lageret.
DocType: Vehicle,Fuel Type,Bränsletyp
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Ange valuta i bolaget
DocType: Workstation,Wages per hour,Löner per timme
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurera {0}
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Lagersaldo i Batch {0} kommer att bli negativ {1} till punkt {2} på Warehouse {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Efter Material Framställningar har höjts automatiskt baserat på punkt re-order nivå
apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Konto {0} är ogiltig. Konto Valuta måste vara {1}
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be after employee's relieving Date {1},Från datum {0} kan inte vara efter arbetstagarens avlastningsdatum {1}
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Skapa betalningsuppgifter
DocType: Supplier,Is Internal Supplier,Är Intern Leverantör
DocType: Employee,Create User Permission,Skapa användarbehörighet
apps/erpnext/erpnext/projects/doctype/task/task.py,Task's {0} Start Date cannot be after Project's End Date.,Uppgiftens {0} startdatum kan inte vara efter projektets slutdatum.
DocType: Employee Benefit Claim,Employee Benefit Claim,Anställningsfordran
DocType: Healthcare Settings,Remind Before,Påminn före
apps/erpnext/erpnext/buying/utils.py,UOM Conversion factor is required in row {0},UOM omräkningsfaktor i rad {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Rad # {0}: Referensdokument Type måste vara en av kundorder, försäljningsfakturan eller journalanteckning"
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Lojalitetspoäng = Hur mycket basvaluta?
DocType: Salary Component,Deduction,Avdrag
DocType: Item,Retain Sample,Behåll provet
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,Rad {0}: Från tid och till tid är obligatorisk.
DocType: Stock Reconciliation Item,Amount Difference,mängd Skillnad
apps/erpnext/erpnext/public/js/hub/pages/Buying.vue,This page keeps track of items you want to buy from sellers.,Denna sida håller reda på artiklar du vill köpa från säljare.
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Artikel Pris till för {0} i prislista {1}
DocType: Delivery Stop,Order Information,Beställningsinformation
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,Ange anställnings Id för denna säljare
DocType: Territory,Classification of Customers by region,Klassificering av kunder per region
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,In Production,I produktion
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Skillnad Belopp måste vara noll
DocType: Project,Gross Margin,Bruttomarginal
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} gäller efter {1} arbetsdagar
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,Ange Produktionsartikel först
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Calculated Bank Statement balance,Beräknat Kontoutdrag balans
DocType: Normal Test Template,Normal Test Template,Normal testmall
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,disabled user,inaktiverad användare
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,Offert
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,Kan inte ställa in en mottagen RFQ till No Quote
apps/erpnext/erpnext/regional/report/datev/datev.py,Please create <b>DATEV Settings</b> for Company <b>{}</b>.,<b>Skapa DATEV-inställningar</b> för företag <b>{}</b> .
DocType: Salary Slip,Total Deduction,Totalt Avdrag
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Select an account to print in account currency,Välj ett konto för att skriva ut i kontovaluta
DocType: BOM,Transfer Material Against,Överför material mot
,Production Analytics,produktions~~POS=TRUNC Analytics
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py,This is based on transactions against this Patient. See timeline below for details,Detta baseras på transaktioner mot denna patient. Se tidslinjen nedan för detaljer
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Lånets startdatum och låneperiod är obligatoriskt för att spara fakturabatteringen
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Kostnad Uppdaterad
apps/erpnext/erpnext/regional/india/utils.py,Vehicle Type is required if Mode of Transport is Road,Fordonstyp krävs om transportläget är väg
DocType: Inpatient Record,Date of Birth,Födelsedatum
DocType: Quality Action,Resolutions,beslut
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Item {0} has already been returned,Punkt {0} redan har returnerat
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Räkenskapsåret** representerar budgetåret. Alla bokföringsposter och andra större transaktioner spåras mot **räkenskapsår**.
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Dimension Filter,Måttfilter
DocType: Opportunity,Customer / Lead Address,Kund / Huvudadress
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Leverans Scorecard Setup
DocType: Customer Credit Limit,Customer Credit Limit,Kundkreditgräns
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Bedömningsplan Namn
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Måldetaljer
apps/erpnext/erpnext/regional/italy/setup.py,"Applicable if the company is SpA, SApA or SRL","Tillämpligt om företaget är SpA, SApA eller SRL"
DocType: Work Order Operation,Work Order Operation,Arbetsorderoperation
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Varning: Ogiltig SSL-certifikat på fäst {0}
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,Ställ in detta om kunden är ett offentligt administrationsföretag.
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads","Leads hjälpa dig att få verksamheten, lägga till alla dina kontakter och mer som dina leder"
DocType: Work Order Operation,Actual Operation Time,Faktisk driftstid
DocType: Authorization Rule,Applicable To (User),Är tillämpligt för (Användare)
DocType: Purchase Taxes and Charges,Deduct,Dra av
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,Arbetsbeskrivning
DocType: Student Applicant,Applied,Applicerad
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Details of Outward Supplies and inward supplies liable to reverse charge,Detaljer om leveranser och leveranser tillåtna som kan återvända
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Återuppta
DocType: Sales Invoice Item,Qty as per Stock UOM,Antal per lager UOM
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Guardian2 Namn
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Root Company
DocType: Attendance,Attendance Request,Närvaroförfrågan
DocType: Purchase Invoice,02-Post Sale Discount,02-Försäljningsrabatter
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Håll koll på säljkampanjer. Håll koll på Prospekter, Offerter, kundorder etc från kampanjer för att mäta avkastning på investeringen."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You can't redeem Loyalty Points having more value than the Grand Total.,Du kan inte lösa in Lojalitetspoäng som har mer värde än Grand Total.
DocType: Department Approver,Approver,Godkännare
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,SO Qty,SO Antal
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field To Shareholder cannot be blank,Fältet till aktieägare kan inte vara tomt
DocType: Guardian,Work Address,arbete Adress
DocType: Appraisal,Calculate Total Score,Beräkna Totalsumma
DocType: Employee,Health Insurance,Hälsoförsäkring
DocType: Asset Repair,Manufacturing Manager,Tillverkningsansvarig
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under warranty upto {1},Löpnummer {0} är under garanti upp till {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Minsta tillåtet värde
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,Användaren {0} finns redan
apps/erpnext/erpnext/hooks.py,Shipments,Transporter
DocType: Payment Entry,Total Allocated Amount (Company Currency),Sammanlagda anslaget (Company valuta)
DocType: Purchase Order Item,To be delivered to customer,Som skall levereras till kund
DocType: BOM,Scrap Material Cost,Skrot Material Kostnad
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to any Warehouse,Löpnummer {0} inte tillhör någon Warehouse
DocType: Grant Application,Email Notification Sent,E-postmeddelande skickat
DocType: Purchase Invoice,In Words (Company Currency),I ord (Företagsvaluta)
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,Företaget är manadatoriskt för företagskonto
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Artikelnummer, lager, kvantitet krävs på rad"
DocType: Bank Guarantee,Supplier,Leverantör
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get From,Hämta Från
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,Detta är en rotavdelning och kan inte redigeras.
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Visa betalningsdetaljer
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Varaktighet i dagar
DocType: C-Form,Quarter,Kvartal
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,Diverse Utgifter
DocType: Global Defaults,Default Company,Standard Company
DocType: Company,Transactions Annual History,Transaktioner Årshistoria
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Bank account '{0}' has been synchronized,Bankkonto &#39;{0}&#39; har synkroniserats
apps/erpnext/erpnext/controllers/stock_controller.py,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Utgift eller differens konto är obligatoriskt för punkt {0} som den påverkar totala lagervärdet
DocType: Bank,Bank Name,Bank Namn
DocType: DATEV Settings,Consultant ID,Konsult-ID
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,Lämna fältet tomt för att göra inköpsorder för alla leverantörer
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Inpatient Visit Charge Item
DocType: Vital Signs,Fluid,Vätska
DocType: Leave Application,Total Leave Days,Totalt semesterdagar
DocType: Email Digest,Note: Email will not be sent to disabled users,Obs: E-post kommer inte att skickas till inaktiverade användare
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Antal interaktioner
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Antal interaktioner
DocType: GSTR 3B Report,February,februari
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Alternativ för varianter av varianter
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Välj Företaget ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} är obligatoriskt för punkt {1}
DocType: Payroll Entry,Fortnightly,Var fjortonde dag
DocType: Currency Exchange,From Currency,Från Valuta
DocType: Vital Signs,Weight (In Kilogram),Vikt (i kilogram)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",kapitel / kapitel_namn lämna tomt automatiskt efter att du har sparat kapitel.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Please set GST Accounts in GST Settings,Ange GST-konton i GST-inställningar
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Typ av företag
DocType: Sales Invoice,Consumer,Konsument
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Välj tilldelade beloppet, Faktura Typ och fakturanumret i minst en rad"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,Kostnader för nya inköp
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},Kundorder krävs för punkt {0}
DocType: Grant Application,Grant Description,Grant Beskrivning
DocType: Purchase Invoice Item,Rate (Company Currency),Andel (Företagsvaluta)
DocType: Student Guardian,Others,Annat
DocType: Subscription,Discounts,rabatter
DocType: Bank Transaction,Unallocated Amount,oallokerad Mängd
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Vänligen aktivera Gäller på inköpsorder och gäller vid bokning av faktiska utgifter
apps/erpnext/erpnext/templates/includes/product_page.js,Cannot find a matching Item. Please select some other value for {0}.,Det går inte att hitta en matchande objekt. Välj något annat värde för {0}.
DocType: POS Profile,Taxes and Charges,Skatter och avgifter
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","En produkt eller en tjänst som köps, säljs eller hålls i lager."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js,No more updates,Inga fler uppdateringar
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Det går inte att välja avgiftstyp som ""På föregående v Belopp"" eller ""På föregående v Total"" för första raden"
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-
DocType: Appointment,Phone Number,Telefonnummer
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,This covers all scorecards tied to this Setup,Detta täcker alla scorecards kopplade till denna inställning
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Barn Objekt bör inte vara en produkt Bundle. Ta bort objektet `{0}` och spara
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,Bank
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,Lägg tidrapporter
DocType: Vehicle Service,Service Item,sERVICE
DocType: Bank Guarantee,Bank Guarantee,Bankgaranti
DocType: Bank Guarantee,Bank Guarantee,Bankgaranti
DocType: Payment Request,Transaction Details,Transaktions Detaljer
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,"Klicka på ""Skapa schema"" för att få schemat"
DocType: Item,"Purchase, Replenishment Details","Köp, detaljer om påfyllning"
DocType: Products Settings,Enable Field Filters,Aktivera fältfilter
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Produktkod&gt; Produktgrupp&gt; Märke
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also","""Kundförsett objekt"" kan inte också vara köpobjekt"
DocType: Blanket Order Item,Ordered Quantity,Beställd kvantitet
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""",t.ex. &quot;Bygg verktyg för byggare&quot;
DocType: Grading Scale,Grading Scale Intervals,Betygsskal
DocType: Item Default,Purchase Defaults,Inköpsstandard
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Kunde inte skapa kreditnota automatiskt, var god och avmarkera &quot;Issue Credit Note&quot; och skicka igen"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Added to Featured Items,Tillagd till utvalda artiklar
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,årets vinst
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: kontering för {2} kan endast göras i valuta: {3}
DocType: Fee Schedule,In Process,Pågående
DocType: Authorization Rule,Itemwise Discount,Produktvis rabatt
apps/erpnext/erpnext/config/accounts.py,Tree of financial accounts.,Träd av finansräkenskaperna.
DocType: Cash Flow Mapping,Cash Flow Mapping,Kassaflödesmappning
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0} mot kundorder {1}
DocType: Account,Fixed Asset,Fast tillgångar
DocType: Amazon MWS Settings,After Date,Efter datum
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Serial numrerade Inventory
,Department Analytics,Department Analytics
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,E-post hittades inte i standardkontakt
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Generera hemlighet
DocType: Question,Question,Fråga
DocType: Loan,Account Info,Kontoinformation
DocType: Activity Type,Default Billing Rate,Standardfakturerings betyg
DocType: Fees,Include Payment,Inkludera betalning
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Studentgrupper skapade.
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Studentgrupper skapade.
DocType: Sales Invoice,Total Billing Amount,Totalt Fakturerings Mängd
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Program in the Fee Structure and Student Group {0} are different.,Program i avgiftsstrukturen och studentgruppen {0} är olika.
DocType: Bank Statement Transaction Entry,Receivable Account,Fordran Konto
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,Giltig från datum måste vara mindre än giltig till datum.
DocType: Employee Skill,Evaluation Date,Utvärderingsdatum
DocType: Quotation Item,Stock Balance,Lagersaldo
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,Kundorder till betalning
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,vd
DocType: Purchase Invoice,With Payment of Tax,Med betalning av skatt
DocType: Expense Claim Detail,Expense Claim Detail,Räkningen Detalj
apps/erpnext/erpnext/education/utils.py,You are not allowed to enroll for this course,Du får inte anmäla dig till den här kursen
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLIKAT FÖR LEVERANTÖR
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Ny balans i basvaluta
DocType: Location,Is Container,Är Container
DocType: Crop Cycle,This will be day 1 of the crop cycle,Detta blir dag 1 i grödan
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,Välj rätt konto
DocType: Salary Structure Assignment,Salary Structure Assignment,Lönestrukturuppdrag
DocType: Purchase Invoice Item,Weight UOM,Vikt UOM
apps/erpnext/erpnext/config/accounts.py,List of available Shareholders with folio numbers,Förteckning över tillgängliga aktieägare med folienummer
DocType: Salary Structure Employee,Salary Structure Employee,Lönestruktur anställd
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,Visa variantegenskaper
DocType: Student,Blood Group,Blodgrupp
DocType: Purchase Invoice Item,Page Break,Sidbrytning
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Betalningsgateway-kontot i plan {0} skiljer sig från betalnings gateway-kontot i denna betalningsförfrågan
DocType: Course,Course Name,KURSNAMN
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,Inga skatteinnehållsuppgifter hittades för det aktuella räkenskapsåret.
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Användare som kan godkänna en specifik arbetstagarens ledighet applikationer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Equipments,Kontorsutrustning
DocType: Pricing Rule,Qty,Antal
DocType: Fiscal Year,Companies,Företag
DocType: Supplier Scorecard,Scoring Setup,Scoring Setup
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,Elektronik
DocType: Manufacturing Settings,Raw Materials Consumption,Råvaruförbrukning
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),Debit ({0})
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Höj material Begäran när lager når ombeställningsnivåer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Full-time,Heltid
DocType: Payroll Entry,Employees,Anställda
DocType: Question,Single Correct Answer,Enstaka korrekt svar
DocType: C-Form,Received Date,Mottaget Datum
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Om du har skapat en standardmall i skatter och avgifter Mall, välj en och klicka på knappen nedan."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Grundbelopp (Company valuta)
DocType: Student,Guardians,Guardians
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Betalningsbekräftelse
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Service Start and End Date is required for deferred accounting,Rad # {0}: Servicens start- och slutdatum krävs för uppskjuten redovisning
apps/erpnext/erpnext/regional/india/utils.py,Unsupported GST Category for e-Way Bill JSON generation,Ostödd GST-kategori för e-Way Bill JSON-generation
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Priserna kommer inte att visas om prislista inte är inställd
DocType: Material Request Item,Received Quantity,Mottaget kvantitet
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,To Date must be greater than From Date,Hittills måste vara större än Från datum
DocType: Stock Entry,Total Incoming Value,Totalt Inkommande Värde
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,Debitering krävs
DocType: Clinical Procedure,Inpatient Record,Inpatient Record
apps/erpnext/erpnext/utilities/activation.py,"Timesheets help keep track of time, cost and billing for activites done by your team","Tidrapporter hjälpa till att hålla reda på tid, kostnad och fakturering för aktiviteter som utförts av ditt team"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Purchase Price List,Inköps Prislista
DocType: Communication Medium Timeslot,Employee Group,Medarbetargrupp
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,Datum för transaktion
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard variables.,Mallar med leverantörsspecifika variabler.
DocType: Job Offer Term,Offer Term,Erbjudandet Villkor
DocType: Asset,Quality Manager,Kvalitetsansvarig
DocType: Job Applicant,Job Opening,Jobbmöjlighet
DocType: Employee,Default Shift,Standardskift
DocType: Payment Reconciliation,Payment Reconciliation,Betalning Avstämning
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,Teknik
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},Totalt Obetalda: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Webbplats Operation
DocType: Bank Statement Transaction Payment Item,outstanding_amount,utestående belopp
DocType: Supplier Scorecard,Supplier Score,Leverantörspoäng
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Schema Entré
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Total Payment Request amount cannot be greater than {0} amount,Det totala betalningsbegäran kan inte överstiga {0} belopp
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Kumulativ transaktionströskel
DocType: Promotional Scheme Price Discount,Discount Type,Rabatttyp
DocType: Purchase Invoice Item,Is Free Item,Är gratis artikel
DocType: Buying Settings,Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Procentandel du får överföra mer mot den beställda kvantiteten. Till exempel: Om du har beställt 100 enheter. och din ersättning är 10%, då får du överföra 110 enheter."
DocType: Supplier,Warn RFQs,Varna RFQs
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Explore,Utforska
DocType: BOM,Conversion Rate,Omvandlingsfrekvens
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Sök produkt
,Bank Remittance,Banköverföring
DocType: Cashier Closing,To Time,Till Time
DocType: Invoice Discounting,Loan End Date,Lånets slutdatum
apps/erpnext/erpnext/hr/utils.py,) for {0},) för {0}
DocType: Authorization Rule,Approving Role (above authorized value),Godkännande Roll (ovan auktoriserad värde)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Employee is required while issuing Asset {0},Anställd krävs vid utfärdande av tillgångar {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Kredit till konto måste vara en skuld konto
DocType: Loan,Total Amount Paid,Summa Betald Betalning
DocType: Asset,Insurance End Date,Försäkrings slutdatum
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,"Vänligen välj Studenttillträde, vilket är obligatoriskt för den studerande som betalas"
DocType: Pick List,STO-PICK-.YYYY.-,STO-PICK-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Budgetlista
DocType: Campaign,Campaign Schedules,Kampanjscheman
DocType: Job Card Time Log,Completed Qty,Avslutat Antal
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry",För {0} kan bara debitkonton länkas mot en annan kreditering
DocType: Manufacturing Settings,Allow Overtime,Tillåt övertid
DocType: Training Event Employee,Training Event Employee,Utbildning Händelse anställd
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximala prov - {0} kan behållas för sats {1} och punkt {2}.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Lägg till tidsluckor
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serienummer krävs för objekt {1}. Du har angivit {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Nuvarande värderingensomsättning
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Number of root accounts cannot be less than 4,Antalet root-konton kan inte vara mindre än 4
DocType: Training Event,Advance,Förskott
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,GoCardless betalnings gateway-inställningar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Exchange Gain/Loss,Exchange vinst / förlust
DocType: Opportunity,Lost Reason,Förlorad Anledning
DocType: Amazon MWS Settings,Enable Amazon,Aktivera Amazon
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Account {1} does not belong to company {2},Rad # {0}: Konto {1} hör inte till företag {2}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Det gick inte att hitta DocType {0}
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,Ny adress
DocType: Quality Inspection,Sample Size,Provstorlek
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,Ange Kvitto Dokument
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,All items have already been invoiced,Alla objekt har redan fakturerats
apps/erpnext/erpnext/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.py,Leaves Taken,Löv tagna
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Please specify a valid 'From Case No.',Ange ett giltigt Från ärende nr &quot;
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Further cost centers can be made under Groups but entries can be made against non-Groups,Ytterligare kostnadsställen kan göras i grupperna men poster kan göras mot icke-grupper
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Summa tilldelade löv är flera dagar än maximal fördelning av {0} ledighetstyp för anställd {1} under perioden
DocType: Branch,Branch,Bransch
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)","Andra leveranser utifrån (noll betyg, undantagna)"
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Uppfyllande användare
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Tryckning och Branding
DocType: Company,Total Monthly Sales,Total månadsförsäljning
DocType: Course Activity,Enrollment,Inskrivning
DocType: Payment Request,Subscription Plans,Prenumerationsplaner
DocType: Agriculture Analysis Criteria,Weather,Väder
DocType: Bin,Actual Quantity,Verklig Kvantitet
DocType: Shipping Rule,example: Next Day Shipping,exempel: Nästa dag Leverans
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} not found,Löpnummer {0} hittades inte
DocType: Fee Schedule Program,Fee Schedule Program,Avgiftsschema Program
DocType: Fee Schedule Program,Student Batch,elev Batch
DocType: Pricing Rule,Advanced Settings,Avancerade inställningar
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min betyg
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Hälso- och sjukvårdstjänstenhet
DocType: Training Event Employee,Feedback Submitted,Feedback Inlagd
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},Du har blivit inbjuden att samarbeta i projektet: {0}
DocType: Supplier Group,Parent Supplier Group,Moderbolaget
DocType: Email Digest,Purchase Orders to Bill,Beställningar till Bill
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Ackumulerade värden i koncernföretaget
DocType: Leave Block List Date,Block Date,Block Datum
DocType: Item,You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,Du kan använda valfri Bootstrap 4-markering i det här fältet. Det kommer att visas på din artikelsida.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted","Utgående beskattningsbara leveranser (andra än nollklassificerade, nollvärderade och undantagna"
DocType: Crop,Crop,Beskära
DocType: Purchase Receipt,Supplier Delivery Note,Leverantörsleveransnotering
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Ansök nu
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Typ av bevis
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Faktiskt antal {0} / Vänta antal {1}
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Faktiskt antal {0} / Vänta antal {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-handel GSTIN
DocType: Sales Order,Not Delivered,Inte Levererad
,Bank Clearance Summary,Banken Clearance Sammanfattning
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.","Skapa och hantera dagliga, vecko- och månads epostflöden."
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py,This is based on transactions against this Sales Person. See timeline below for details,Detta baseras på transaktioner mot denna säljare. Se tidslinjen nedan för detaljer
DocType: Appraisal Goal,Appraisal Goal,Bedömning Mål
DocType: Stock Reconciliation Item,Current Amount,nuvarande belopp
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Buildings,Byggnader
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,Bladen har beviljats framgångsrikt
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Invoice,Ny faktura
DocType: Products Settings,Enable Attribute Filters,Aktivera attributfilter
DocType: Fee Schedule,Fee Structure,avgift struktur
DocType: Timesheet Detail,Costing Amount,Kalkyl Mängd
DocType: Student Admission Program,Application Fee,Anmälningsavgift
DocType: Purchase Order Item,Against Blanket Order,Mot filtorder
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Skicka lönebeskedet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Placerad i kö
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,En fråga måste ha åtminstone ett korrekt alternativ
apps/erpnext/erpnext/hooks.py,Purchase Orders,Beställning
DocType: Account,Inter Company Account,Inter Company Account
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import av Bulk
DocType: Sales Partner,Address & Contacts,Adress och kontakter
DocType: SMS Log,Sender Name,Avsändarnamn
DocType: Vital Signs,Very Hyper,Mycket Hyper
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Jordbruksanalys Kriterier
DocType: HR Settings,Leave Approval Notification Template,Lämna godkännandemall för godkännande
DocType: POS Profile,[Select],[Välj]
DocType: Staffing Plan Detail,Number Of Positions,Antal positioner
DocType: Vital Signs,Blood Pressure (diastolic),Blodtryck (diastoliskt)
apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Välj kund.
DocType: SMS Log,Sent To,Skickat Till
DocType: Agriculture Task,Holiday Management,Holiday Management
DocType: Payment Request,Make Sales Invoice,Skapa fakturan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,Mjukvara
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact Date cannot be in the past,Next Kontakt Datum kan inte vara i det förflutna
DocType: Company,For Reference Only.,För referens.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,Välj batchnummer
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},Ogiltigt {0}: {1}
,GSTR-1,GSTR-1
DocType: Fee Validity,Reference Inv,Referens Inv
DocType: Sales Invoice Advance,Advance Amount,Förskottsmängd
DocType: Manufacturing Settings,Capacity Planning,Kapacitetsplanering
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Avrundningsjustering (Företagsvaluta
DocType: Asset,Policy number,Försäkringsnummer
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,&quot;Från datum&quot; krävs
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Tilldela till anställda
DocType: Bank Transaction,Reference Number,Referensnummer
DocType: Employee,New Workplace,Ny Arbetsplats
DocType: Retention Bonus,Retention Bonus,Retention Bonus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Materialförbrukning
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Ange som Stängt
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},Ingen produkt med streckkod {0}
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Justering av tillgångsvärde kan inte bokföras före tillgångs köpdatum <b>{0}</b> .
DocType: Normal Test Items,Require Result Value,Kräver resultatvärde
DocType: Purchase Invoice,Pricing Rules,Priseregler
DocType: Item,Show a slideshow at the top of the page,Visa ett bildspel på toppen av sidan
DocType: Tax Withholding Rate,Tax Withholding Rate,Skattesats
DocType: Pricing Rule,Max Amt,Max Amt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,stycklistor
apps/erpnext/erpnext/stock/doctype/item/item.py,Stores,Butiker
DocType: Project Type,Projects Manager,Projekt Chef
DocType: Serial No,Delivery Time,Leveranstid
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Based On,Åldring Baserad på
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,Avtalet avbröts
DocType: Item,End of Life,Uttjänta
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,"Transferring cannot be done to an Employee. \
						Please enter location where Asset {0} has to be transferred",Överföring kan inte göras till en anställd. \ Vänligen ange plats där tillgången {0} måste överföras
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,Resa
DocType: Student Report Generation Tool,Include All Assessment Group,Inkludera alla bedömningsgrupper
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,Ingen aktiv eller standard lönestruktur hittades för arbetstagare {0} för de givna datum
DocType: Leave Block List,Allow Users,Tillåt användare
DocType: Purchase Order,Customer Mobile No,Kund Mobil nr
DocType: Leave Type,Calculated in days,Beräknas i dagar
DocType: Call Log,Received By,Mottaget av
DocType: Appointment Booking Settings,Appointment Duration (In Minutes),Utnämningstid (inom några minuter)
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Kassaflödesmallar Detaljer
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Lånhantering
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Spåra separat intäkter och kostnader för produkt vertikaler eller divisioner.
DocType: Rename Tool,Rename Tool,Ändrings Verktyget
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,Uppdatera Kostnad
DocType: Item Reorder,Item Reorder,Produkt Ändra ordning
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,GSTR3B-Form
DocType: Sales Invoice,Mode of Transport,Transportsätt
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Visa lönebesked
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Transfermaterial
DocType: Fees,Send Payment Request,Skicka betalningsförfrågan
DocType: Travel Request,Any other details,Eventuella detaljer
DocType: Water Analysis,Origin,Ursprung
apps/erpnext/erpnext/controllers/status_updater.py,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Detta dokument är över gränsen med {0} {1} för posten {4}. Är du göra en annan {3} mot samma {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,Ställ återkommande efter att ha sparat
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,Välj förändringsbelopp konto
DocType: Purchase Invoice,Price List Currency,Prislista Valuta
DocType: Naming Series,User must always select,Användaren måste alltid välja
DocType: Stock Settings,Allow Negative Stock,Tillåt Negativ lager
DocType: Installation Note,Installation Note,Installeringsnotis
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Warehouse-wise Stock,Visa lagermässigt lager
DocType: Soil Texture,Clay,Lera
DocType: Course Topic,Topic,Ämne
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Kassaflöde från finansiering
DocType: Budget Account,Budget Account,budget-konto
DocType: Quality Inspection,Verified By,Verifierad Av
DocType: Travel Request,Name of Organizer,Organisatorens namn
apps/erpnext/erpnext/setup/doctype/company/company.py,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Det går inte att ändra bolagets standardvaluta, eftersom det redan finns transaktioner. Transaktioner måste avbokas att ändra valuta."
DocType: Cash Flow Mapping,Is Income Tax Liability,Är inkomstskattansvar
DocType: Grading Scale Interval,Grade Description,grade Beskrivning
DocType: Clinical Procedure,Is Invoiced,Faktureras
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Skapa skattemall
DocType: Stock Entry,Purchase Receipt No,Inköpskvitto Nr
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Earnest Money,Handpenning
DocType: Sales Invoice, Shipping Bill Number,Fraktsedelsnummer
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset has multiple Asset Movement Entries which has to be \
				cancelled manually to cancel this asset.",Tillgången har flera tillgångsförflyttningar som måste avbrytas manuellt för att avbryta den här tillgången.
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,Skapa lönebeskedet
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,spårbarhet
DocType: Asset Maintenance Log,Actions performed,Åtgärder utförda
DocType: Cash Flow Mapper,Section Leader,Sektionsledare
DocType: Sales Invoice,Transport Receipt No,Transport kvitto nr
DocType: Quiz Activity,Pass,Passera
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Lägg till kontot till företagets rotnivå -
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),Källa fonderna (skulder)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,Källa och målplats kan inte vara samma
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Kvantitet i rad {0} ({1}) måste vara samma som tillverkad mängd {2}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Skillnadskonto måste vara ett konto för tillgång / ansvar, eftersom denna aktieinmatning är en öppningsinmatning"
DocType: Supplier Scorecard Scoring Standing,Employee,Anställd
DocType: Bank Guarantee,Fixed Deposit Number,Fast Deponeringsnummer
DocType: Asset Repair,Failure Date,Fel datum
DocType: Support Search Source,Result Title Field,Resultat Titel Fält
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary,Sammanfattning av samtal
DocType: Sample Collection,Collected Time,Samlad tid
DocType: Employee Skill Map,Employee Skills,Medarbetares färdigheter
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Fuel Expense,Bränsleutgifter
DocType: Company,Sales Monthly History,Försäljning månadshistoria
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,Ange minst en rad i tabellen Skatter och avgifter
DocType: Asset Maintenance Task,Next Due Date,Nästa Förfallodatum
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Välj Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1} är fullt fakturerad
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Vitala tecken
DocType: Payment Entry,Payment Deductions or Loss,Betalnings Avdrag eller förlust
DocType: Soil Analysis,Soil Analysis Criterias,Kriterier för markanalys
apps/erpnext/erpnext/config/settings.py,Standard contract terms for Sales or Purchase.,Standard avtalsvillkor för försäljning eller köp.
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Removed in {0},Rader tas bort i {0}
DocType: Shift Type,Begin check-in before shift start time (in minutes),Börja incheckningen innan skiftets starttid (i minuter)
DocType: BOM Item,Item operation,Artikeloperation
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,Grupp av Voucher
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Are you sure you want to cancel this appointment?,Är du säker på att du vill avbryta detta möte?
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Hotellrumsprispaket
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,Sales Pipeline
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},Ställ in standardkonto i lönedel {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html,Required On,Obligatorisk På
DocType: HR Settings,"If checked, hides and disables Rounded Total field in Salary Slips","Om markerat, döljer och inaktiverar fältet Avrundat totalt i lönesedlar"
DocType: Woocommerce Settings,This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Detta är standardförskjutningen (dagar) för leveransdatum i försäljningsorder. Återkopplingsförskjutningen är 7 dagar från beställningsdatumet.
DocType: Rename Tool,File to Rename,Fil att byta namn på
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},Välj BOM till punkt i rad {0}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Hämta prenumerationsuppdateringar
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py,Account {0} does not match with Company {1} in Mode of Account: {2},Konto {0} matchar inte företaget {1} i Konto: {2}
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},Fastställt BOM {0} finns inte till punkt {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Course: ,Kurs:
DocType: Soil Texture,Sandy Loam,Sandig blandjord
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Underhållsschema {0} måste avbrytas innanman kan dra avbryta kundorder
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,Student LMS-aktivitet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Numbers Created,Serienummer skapade
DocType: POS Profile,Applicable for Users,Gäller för användare
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,Ställer du projekt och alla uppgifter till status {0}?
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Ställ in förskott och fördela (FIFO)
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Inga arbetsorder skapade
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,Lönebesked av personal {0} redan skapats för denna period
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Pharmaceutical,Farmaceutiska
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,Du kan bara skicka lämna kollaps för ett giltigt inkasseringsbelopp
apps/erpnext/erpnext/public/js/hub/pages/SellerItems.vue,Items by ,Artiklar av
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Purchased Items,Kostnad för köpta varor
DocType: Employee Separation,Employee Separation Template,Medarbetarens separationsmall
DocType: Selling Settings,Sales Order Required,Kundorder krävs
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Bli en säljare
,Procurement Tracker,Upphandlingsspårare
DocType: Purchase Invoice,Credit To,Kredit till
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC Reversed
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid authentication error,Fel för autentisering i rutan
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Aktiva Leads / Kunder
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,Lämna tomt för att använda standardleveransnotatformatet
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year End Date should be one year after Fiscal Year Start Date,Räkenskapsårets slutdatum bör vara ett år efter räkenskapsårets startdatum
DocType: Employee Education,Post Graduate,Betygsinlägg
DocType: Quality Meeting,Agenda,Dagordning
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Underhållsschema Detalj
DocType: Supplier Scorecard,Warn for new Purchase Orders,Varning för nya inköpsorder
DocType: Quality Inspection Reading,Reading 9,Avläsning 9
apps/erpnext/erpnext/config/integrations.py,Connect your Exotel Account to ERPNext and track call logs,Anslut ditt Exotel-konto till ERPNext och spåra samtalsloggar
DocType: Supplier,Is Frozen,Är Frozen
DocType: Tally Migration,Processed Files,Bearbetade filer
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,Grupp nod lager är inte tillåtet att välja för transaktioner
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Bokföringsdimension <b>{0}</b> krävs för &#39;Balansräkning&#39; -konto {1}.
DocType: Buying Settings,Buying Settings,Köpinställningar
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM nr för ett Färdigt objekt
DocType: Upload Attendance,Attendance To Date,Närvaro Till Datum
DocType: Request for Quotation Supplier,No Quote,Inget citat
DocType: Support Search Source,Post Title Key,Posttitelnyckel
DocType: Issue,Issue Split From,Problem delad från
DocType: Warranty Claim,Raised By,Höjt av
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,recept
DocType: Payment Gateway Account,Payment Account,Betalningskonto
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,Ange vilket bolag för att fortsätta
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,Nettoförändring av kundfordringar
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,Kompensations Av
DocType: Job Applicant,Accepted,Godkända
DocType: POS Closing Voucher,Sales Invoices Summary,Sammanfattning av försäljningsfakturor
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,Till partnamn
DocType: Grant Application,Organization,Organisation
DocType: Grant Application,Organization,Organisation
DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Grupp efter parti
DocType: SG Creation Tool Course,Student Group Name,Student gruppnamn
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Visa exploderad vy
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Skapa avgifter
apps/erpnext/erpnext/setup/doctype/company/company.js,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.,Se till att du verkligen vill ta bort alla transaktioner för företag. Dina basdata kommer att förbli som det är. Denna åtgärd kan inte ångras.
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,sökresultat
DocType: Homepage Section,Number of Columns,Antal kolumner
DocType: Room,Room Number,Rumsnummer
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Price not found for item {0} in price list {1},Pris hittades inte för artikel {0} i prislistan {1}
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,beställaren
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Ogiltig referens {0} {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Regler för tillämpning av olika kampanjprogram.
DocType: Shipping Rule,Shipping Rule Label,Frakt Regel Etikett
DocType: Journal Entry Account,Payroll Entry,Löneinmatning
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Visa avgifter
apps/erpnext/erpnext/public/js/conf.js,User Forum,Användarforum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,Råvaror kan inte vara tomt.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,Rad # {0} (Betalnings tabell): Beloppet måste vara negativt
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Det gick inte att uppdatera lager, faktura innehåller släppa sjöfarten objekt."
DocType: Contract,Fulfilment Status,Uppfyllningsstatus
DocType: Lab Test Sample,Lab Test Sample,Lab Test Prov
DocType: Item Variant Settings,Allow Rename Attribute Value,Tillåt Byt namn på attributvärde
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Quick Journal Entry
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Amount,Framtida betalningsbelopp
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,You can not change rate if BOM mentioned agianst any item,Du kan inte ändra kurs om BOM nämnts mot någon artikel
DocType: Restaurant,Invoice Series Prefix,Faktura Serie Prefix
DocType: Employee,Previous Work Experience,Tidigare Arbetslivserfarenhet
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Uppdatera kontonummer / namn
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Tilldela lönestruktur
DocType: Support Settings,Response Key List,Response Key List
DocType: Stock Entry,For Quantity,För Antal
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Planned Qty for Item {0} at row {1},Ange planerad Antal till punkt {0} vid rad {1}
DocType: Support Search Source,Result Preview Field,Resultatförhandsgranskningsfält
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,{0} hittade artiklar.
DocType: Item Price,Packing Unit,Förpackningsenhet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} är inte skickad
DocType: Subscription,Trialling,testar
DocType: Sales Invoice Item,Deferred Revenue,Uppskjuten intäkt
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Kontantkonto används för att skapa försäljningsfaktura
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Undantag underkategori
DocType: Member,Membership Expiry Date,Medlemskapets utgångsdatum
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} måste vara negativ i returdokument
DocType: Employee Tax Exemption Proof Submission,Submission Date,Inlämningsdatum
,Minutes to First Response for Issues,Minuter till First Response för frågor
DocType: Purchase Invoice,Terms and Conditions1,Villkor och Conditions1
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of the institute for which you are setting up this system.,Namnet på institutet som du installerar systemet.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Kontering frysta fram till detta datum, ingen kan göra / ändra posten förutom ange roll nedan."
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,Senaste pris uppdaterat i alla BOMs
DocType: Project User,Project Status,Projektstatus
DocType: UOM,Check this to disallow fractions. (for Nos),Markera att tillåta bråkdelar. (För NOS)
DocType: Student Admission Program,Naming Series (for Student Applicant),Naming Series (för Student Sökande)
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Bonusbetalningsdatum kan inte vara ett förflutet datum
DocType: Travel Request,Copy of Invitation/Announcement,Kopia av inbjudan / tillkännagivande
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Utövaren Service Unit Schedule
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has already been billed.,Rad # {0}: Det går inte att ta bort objekt {1} som redan har fakturerats.
DocType: Sales Invoice,Transporter Name,Transportör Namn
DocType: Authorization Rule,Authorized Value,Auktoriserad Värde
DocType: BOM,Show Operations,Visa Operations
,Minutes to First Response for Opportunity,Minuter till First Response för Opportunity
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Absent,Totalt Frånvarande
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item or Warehouse for row {0} does not match Material Request,Produkt eller Lager för rad {0} matchar inte Materialförfrågan
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,Payable Amount,Betalningsbart belopp
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,Måttenhet
DocType: Fiscal Year,Year End Date,År Slutdatum
DocType: Task Depends On,Task Depends On,Uppgift Beror på
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,Möjlighet
DocType: Options,Option,Alternativ
apps/erpnext/erpnext/accounts/general_ledger.py,You can't create accounting entries in the closed accounting period {0},Du kan inte skapa bokföringsposter under den stängda bokföringsperioden {0}
DocType: Operation,Default Workstation,Standard arbetsstation
DocType: Payment Entry,Deductions or Loss,Avdrag eller förlust
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1} är stängd
DocType: Email Digest,How frequently?,Hur ofta?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},Totalt samlat: {0}
DocType: Purchase Receipt,Get Current Stock,Få Nuvarande lager
DocType: Purchase Invoice,ineligible,berättigade
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,Tree of Bill of Materials
DocType: BOM,Exploded Items,Exploderade artiklar
DocType: Student,Joining Date,Registreringsdatum
,Employees working on a holiday,Anställda som arbetar på en semester
,TDS Computation Summary,TDS-beräkningsöversikt
DocType: Share Balance,Current State,Nuvarande tillstånd
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,Mark Närvarande
DocType: Share Transfer,From Shareholder,Från aktieägare
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Greater Than Amount,Mer än beloppet
DocType: Project,% Complete Method,% Komplett metod
apps/erpnext/erpnext/healthcare/setup.py,Drug,Läkemedel
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance start date can not be before delivery date for Serial No {0},Underhåll startdatum kan inte vara före leveransdatum för Löpnummer {0}
DocType: Work Order,Actual End Date,Faktiskt Slutdatum
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Är finansieringskostnadsjustering
DocType: BOM,Operating Cost (Company Currency),Driftskostnad (Company valuta)
DocType: Authorization Rule,Applicable To (Role),Är tillämpligt för (Roll)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Väntar på blad
DocType: BOM Update Tool,Replace BOM,Byt ut BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Kod {0} finns redan
DocType: Patient Encounter,Procedures,Rutiner
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Försäljningsorder är inte tillgängliga för produktion
DocType: Asset Movement,Purpose,Syfte
DocType: Company,Fixed Asset Depreciation Settings,Fast avskrivning Inställningar
DocType: Item,Will also apply for variants unless overrridden,Kommer också att ansöka om varianter såvida inte överskriden
DocType: Purchase Invoice,Advances,Förskott
DocType: HR Settings,Hiring Settings,Anställa inställningar
DocType: Work Order,Manufacture against Material Request,Tillverkning mot Material Begäran
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,Bedömningsgrupp:
DocType: Item Reorder,Request for,Begäran om
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving User cannot be same as user the rule is Applicable To,Godkända användare kan inte vara samma användare som regeln är tillämpad på
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Basic Rate (enligt Stock UOM)
DocType: SMS Log,No of Requested SMS,Antal Begärd SMS
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Leave Without Pay does not match with approved Leave Application records,Lämna utan lön inte stämmer överens med godkända Lämna ansökan registrerar
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Nästa steg
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Saved Items,Sparade objekt
DocType: Travel Request,Domestic,Inhemsk
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Please supply the specified items at the best possible rates,Ange de specificerade poster till bästa möjliga pris
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,Anställningsöverföring kan inte lämnas in före överlämningsdatum
DocType: Certification Application,USD,USD
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,Återstående balans
DocType: Selling Settings,Auto close Opportunity after 15 days,Stäng automatiskt Affärsmöjlighet efter 15 dagar
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Inköpsorder är inte tillåtna för {0} på grund av ett scorecard med {1}.
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} is not a valid {1} code,Streckkoden {0} är inte en giltig {1} kod
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,slut År
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Bly%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Bly%
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,Kontraktets Slutdatum måste vara större än Datum för inträde
DocType: Sales Invoice,Driver,Förare
DocType: Vital Signs,Nutrition Values,Näringsvärden
DocType: Lab Test Template,Is billable,Är fakturerbar
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,En tredjepartsdistributör/återförsäljare/kommissionär/influencer som säljer företagets produkter mot provision.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Purchase Order {1},{0} mot beställning {1}
DocType: Patient,Patient Demographics,Patient Demographics
DocType: Task,Actual Start Date (via Time Sheet),Faktiska startdatum (via Tidrapportering)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,Detta är ett exempel webbplats automatiskt genererade från ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,Åldringsräckvidd 1
DocType: Shopify Settings,Enable Shopify,Aktivera Shopify
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,Det totala förskottsbeloppet får inte vara större än det totala beloppet
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

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

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.","Schablonskatt mall som kan tillämpas på alla köptransaktioner. Denna mall kan innehålla en lista över skatte huvuden och även andra kostnadshuvuden som &quot;Shipping&quot;, &quot;Försäkring&quot;, &quot;Hantera&quot; etc. #### Obs Skattesatsen du definierar här kommer att bli den schablonskatt för alla ** artiklar * *. Om det finns ** artiklar ** som har olika priser, måste de läggas till i ** Punkt skatt ** tabellen i ** Punkt ** mästare. #### Beskrivning av kolumner 1. Beräkning Typ: - Det kan vara på ** Net Totalt ** (som är summan av grundbeloppet). - ** I föregående v Totalt / Belopp ** (för kumulativa skatter eller avgifter). Om du väljer det här alternativet, kommer skatten att tillämpas som en procentandel av föregående rad (i skattetabellen) belopp eller total. - ** Faktisk ** (som nämns). 2. Konto Head: Konto huvudbok enligt vilket denna skatt kommer att bokas 3. Kostnadsställe: Om skatten / avgiften är en inkomst (som sjöfarten) eller kostnader det måste bokas mot ett kostnadsställe. 4. Beskrivning: Beskrivning av skatten (som ska skrivas ut i fakturor / citationstecken). 5. Sätt betyg: skattesats. 6. Belopp Momsbelopp. 7. Totalt: Ackumulerad total till denna punkt. 8. Skriv Row: Om baserad på &quot;Föregående rad Total&quot; kan du välja radnumret som kommer att tas som en bas för denna beräkning (standard är föregående rad). 9. Tänk skatt eller avgift för: I det här avsnittet kan du ange om skatten / avgiften är endast för värdering (inte en del av den totala) eller endast för total (inte tillföra värde till objektet) eller för båda. 10. Lägg till eller dra av: Oavsett om du vill lägga till eller dra av skatten."
DocType: Homepage,Homepage,Hemsida
DocType: Grant Application,Grant Application Details ,Ange ansökningsdetaljer
DocType: Employee Separation,Employee Separation,Anställd separering
DocType: BOM Item,Original Item,Ursprunglig artikel
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Doc Datum
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Arvodes Records Skapad - {0}
DocType: Asset Category Account,Asset Category Account,Tillgångsslag konto
apps/erpnext/erpnext/controllers/item_variant.py,The value {0} is already assigned to an exisiting Item {2}.,Värdet {0} tilldelas redan en befintlig artikel {2}.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,Rad # {0} (Betalnings tabell): Beloppet måste vara positivt
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Det går inte att producera mer artiklar {0} än kundorderns mängd {1}
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,Ingenting ingår i brutto
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill already exists for this document,e-Way Bill finns redan för det här dokumentet
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,Välj Attributvärden
DocType: Purchase Invoice,Reason For Issuing document,Orsak för att utfärda dokument
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,Stock Entry {0} är inte lämnat
DocType: Payment Reconciliation,Bank / Cash Account,Bank / Konto
DocType: Bank Transaction,ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,Nästa Kontakta Vid kan inte vara densamma som den ledande e-postadress
DocType: Tax Rule,Billing City,Fakturerings Ort
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,Tillämpligt om företaget är en individ eller ett innehav
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,Loggtyp krävs för incheckningar som faller i skiftet: {0}.
DocType: Asset,Manual,Manuell
DocType: Tally Migration,Is Master Data Processed,Behandlas stamdata
DocType: Salary Component Account,Salary Component Account,Lönedel konto
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} Operations: {1},{0} Verksamhet: {1}
DocType: Global Defaults,Hide Currency Symbol,Dölj Valutasymbol
apps/erpnext/erpnext/config/non_profit.py,Donor information.,Donorinformation.
apps/erpnext/erpnext/config/accounts.py,"e.g. Bank, Cash, Credit Card","t.ex. bank, kontanter, kreditkort"
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normal vilande blodtryck hos en vuxen är cirka 120 mmHg systolisk och 80 mmHg diastolisk, förkortad &quot;120/80 mmHg&quot;"
DocType: Journal Entry,Credit Note,Kreditnota
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,Färdig bra varukod
apps/erpnext/erpnext/config/desktop.py,Quality,Kvalitet
DocType: Projects Settings,Ignore Employee Time Overlap,Ignorera överlappning av arbetstiden
DocType: Warranty Claim,Service Address,Serviceadress
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Importera stamdata
DocType: Asset Maintenance Task,Calibration,Kalibrering
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} håller företaget stängt
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Fakturerbara timmar
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Lämna statusmeddelande
DocType: Patient Appointment,Procedure Prescription,Förfarande recept
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,Möbler och inventarier
DocType: Travel Request,Travel Type,Rese typ
DocType: Purchase Invoice Item,Manufacture,Tillverkning
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
,Lab Test Report,Lab Test Report
DocType: Employee Benefit Application,Employee Benefit Application,Anställningsförmånsansökan
DocType: Appointment,Unverified,Unverified
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Row({0}): {1} is already discounted in {2},Rad ({0}): {1} är redan rabatterad i {2}
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Det finns ytterligare lönekomponenter.
DocType: Purchase Invoice,Unregistered,Oregistrerad
DocType: Student Applicant,Application Date,Ansökningsdatum
DocType: Salary Component,Amount based on formula,Belopp baserat på formel
DocType: Purchase Invoice,Currency and Price List,Valuta och prislista
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Skapa underhållsbesök
DocType: Opportunity,Customer / Lead Name,Kund / Huvudnamn
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,Utförsäljningsdatum inte nämnt
DocType: Payroll Period,Taxable Salary Slabs,Skattepliktiga löneskivor
DocType: Job Card,Production,Produktion
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Ogiltig GSTIN! Ingången du har angett stämmer inte med formatet för GSTIN.
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Account Value,Kontovärde
DocType: Guardian,Occupation,Ockupation
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Row {0}:Start Date must be before End Date,Rad {0}: Startdatum måste vara före slutdatum
DocType: Salary Component,Max Benefit Amount (Yearly),Max förmånsbelopp (Årlig)
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,TDS-ränta%
DocType: Crop,Planting Area,Planteringsområde
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),Totalt (Antal)
DocType: Installation Note Item,Installed Qty,Installerat antal
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belongs to the location {1},Tillgång {0} hör inte till platsen {1}
,Product Bundle Balance,Produktbuntbalans
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Centralskatt
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,utbildning Resultat
DocType: Purchase Invoice,Is Paid,Är betalad
DocType: Salary Structure,Total Earning,Totalt Tjänar
DocType: Purchase Receipt,Time at which materials were received,Tidpunkt för material mottogs
DocType: Products Settings,Products per Page,Produkter per sida
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity to Manufacture,Kvantitet att tillverka
DocType: Stock Ledger Entry,Outgoing Rate,Utgående betyg
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,eller
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Billing Date,Faktureringsdatum
DocType: Import Supplier Invoice,Import Supplier Invoice,Importera leverantörsfaktura
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Tilldelat belopp kan inte vara negativt
DocType: Import Supplier Invoice,Zip File,Zip fil
DocType: Sales Order,Billing Status,Faktureringsstatus
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Rapportera ett problem
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} quantities of the item <b>{2}</b>, the scheme <b>{3}</b>
			will be applied on the item.",Om du {0} {1} kvantiteter av artikeln <b>{2}</b> kommer schemat <b>{3}</b> att tillämpas på objektet.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,Utility Kostnader
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,90-Högre
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Rad # {0}: Journal Entry {1} har inte hänsyn {2} eller redan matchas mot en annan kupong
DocType: Supplier Scorecard Criteria,Criteria Weight,Kriterier Vikt
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account: {0} is not permitted under Payment Entry,Konto: {0} är inte tillåtet enligt betalningsinmatning
DocType: Production Plan,Ignore Existing Projected Quantity,Ignorera befintligt beräknat antal
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Lämna godkännandemeddelande
DocType: Buying Settings,Default Buying Price List,Standard Inköpslista
DocType: Payroll Entry,Salary Slip Based on Timesheet,Lön Slip Baserat på Tidrapport
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,Köpkurs
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Rad {0}: Ange plats för tillgångsobjektet {1}
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Attendance Marked,Närvaro markerad
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,About the Company,Om företaget
apps/erpnext/erpnext/config/settings.py,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Ange standardvärden som bolaget, Valuta, varande räkenskapsår, etc."
DocType: Payment Entry,Payment Type,Betalning Typ
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Var god välj en sats för objekt {0}. Det går inte att hitta en enda sats som uppfyller detta krav
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Var god välj en sats för objekt {0}. Det går inte att hitta en enda sats som uppfyller detta krav
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,Ingen vinst eller förlust i växelkursen
DocType: Leave Control Panel,Select Employees,Välj Anställda
DocType: Shopify Settings,Sales Invoice Series,Försäljningsfaktura-serien
DocType: Opportunity,Potential Sales Deal,Potentiella säljmöjligheter
DocType: Complaint,Complaints,klagomål
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Arbetsgivarbeskattningsdeklaration
DocType: Payment Entry,Cheque/Reference Date,Check / Referens Datum
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,Inga artiklar med materialförteckning.
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Anpassa hemsektioner
DocType: Purchase Invoice,Total Taxes and Charges,Totala skatter och avgifter
DocType: Payment Entry,Company Bank Account,Företagets bankkonto
DocType: Employee,Emergency Contact,Kontaktinformation I En Nödsituation
DocType: Bank Reconciliation Detail,Payment Entry,betalning Entry
,sales-browser,försäljning-browser
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,Huvudbok
DocType: Drug Prescription,Drug Code,Drogkod
DocType: Target Detail,Target  Amount,Målbeloppet
apps/erpnext/erpnext/education/utils.py,Quiz {0} does not exist,Quiz {0} finns inte
DocType: POS Profile,Print Format for Online,Skriv ut format för online
DocType: Shopping Cart Settings,Shopping Cart Settings,Varukorgen Inställningar
DocType: Journal Entry,Accounting Entries,Bokföringsposter
DocType: Job Card Time Log,Job Card Time Log,Jobbkortets tidlogg
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"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.","Om vald prissättning regel är gjord för &quot;Rate&quot;, kommer den att skriva över Prislista. Prissättning Regelkurs är slutkursen, så ingen ytterligare rabatt ska tillämpas. Därför kommer det i transaktioner som Försäljningsorder, Inköpsorder mm att hämtas i fältet &quot;Rate&quot; istället för &quot;Price List Rate&quot; -fältet."
DocType: Journal Entry,Paid Loan,Betalt lån
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Reserverad antal för underleverantörer: Råvarukvantitet för att tillverka underleverantörer.
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Duplicate Entry. Please check Authorization Rule {0},Duplicera post. Kontrollera autentiseringsregel {0}
DocType: Journal Entry Account,Reference Due Date,Referens förfallodatum
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: Issue,Resolution By,Upplösning av
DocType: Leave Type,Applicable After (Working Days),Gäller efter (arbetsdagar)
apps/erpnext/erpnext/education/doctype/student/student.py,Joining Date can not be greater than Leaving Date,Anslutningsdatum kan inte vara större än Leaving Date
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,Kvitto dokument måste lämnas in
DocType: Purchase Invoice Item,Received Qty,Mottagna Antal
DocType: Stock Entry Detail,Serial No / Batch,Löpnummer / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,Inte betalda och inte levereras
DocType: Product Bundle,Parent Item,Överordnad produkt
DocType: Account,Account Type,Användartyp
DocType: Shopify Settings,Webhooks Details,Webbooks detaljer
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Inga tidrapporter
DocType: GoCardless Mandate,GoCardless Customer,GoCardless kund
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,Lämna typ {0} kan inte bära vidarebefordrade
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Underhållsschema genereras inte för alla objekt. Klicka på ""Generera Schema '"
,To Produce,Att Producera
DocType: Leave Encashment,Payroll,Löner
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","För rad {0} i {1}. Om du vill inkludera {2} i punkt hastighet, rader {3} måste också inkluderas"
DocType: Healthcare Service Unit,Parent Service Unit,Föräldra serviceenhet
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifiering av paketet för leverans (för utskrift)
apps/erpnext/erpnext/support/doctype/issue/issue.js,Service Level Agreement was reset.,Servicenivåavtalet återställdes.
DocType: Bin,Reserved Quantity,Reserverad Kvantitet
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Ange giltig e-postadress
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Ange giltig e-postadress
DocType: Volunteer Skill,Volunteer Skill,Volontärfärdighet
DocType: Bank Reconciliation,Include POS Transactions,Inkludera POS-transaktioner
DocType: Quality Action,Corrective/Preventive,Korrigerande / Förebyggande
DocType: Purchase Invoice,Inter Company Invoice Reference,Interfaktura Referens
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select an item in the cart,Var god välj ett objekt i vagnen
DocType: Landed Cost Voucher,Purchase Receipt Items,Inköpskvitto artiklar
apps/erpnext/erpnext/regional/italy/utils.py,Please set Tax ID for the customer '%s',Ange skatte-ID för kunden &#39;% s&#39;
apps/erpnext/erpnext/config/help.py,Customizing Forms,Anpassa formulären
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,Resterande skuld
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Avskrivningsbelopp under perioden
DocType: Sales Invoice,Is Return (Credit Note),Är Retur (Kreditnot)
DocType: Leave Control Panel,Allocate Leaves,Tilldel löv
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,Funktionshindrade mall får inte vara standardmall
DocType: Pricing Rule,Price or Product Discount,Pris eller produktrabatt
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter planned qty,För rad {0}: Ange planerad mängd
DocType: Account,Income Account,Inkomst konto
DocType: Payment Request,Amount in customer's currency,Belopp i kundens valuta
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery,Leverans
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,Tilldelandestrukturer...
DocType: Stock Reconciliation Item,Current Qty,Aktuellt Antal
DocType: Restaurant Menu,Restaurant Menu,Restaurangmeny
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Lägg till leverantörer
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loyalty Program,Help Section,Hjälpavsnitt
apps/erpnext/erpnext/www/all-products/index.html,Prev,Föregående
DocType: Appraisal Goal,Key Responsibility Area,Nyckelansvar Områden
DocType: Delivery Trip,Distance UOM,Avstånd UOM
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students","Student partier hjälpa dig att spåra närvaro, bedömningar och avgifter för studenter"
DocType: Payment Entry,Total Allocated Amount,Sammanlagda anslaget
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,Ange standardinventeringskonto för evig inventering
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}",Kan inte leverera serienumret {0} av punkt {1} eftersom det är reserverat för \ fullfill Försäljningsorder {2}
DocType: Material Request Plan Item,Material Request Type,Typ av Materialbegäran
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,Skicka Grant Review Email
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","Localstorage är full, inte spara"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Rad {0}: UOM Omvandlingsfaktor är obligatorisk
DocType: Employee Benefit Claim,Claim Date,Ansökningsdatum
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Asset Account cannot be blank,Fältet Tillgångskonto kan inte vara tomt
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Det finns redan en post för objektet {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,Ref
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Du kommer att förlora register över tidigare genererade fakturor. Är du säker på att du vill starta om den här prenumerationen?
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Anmälningsavgift
DocType: Loyalty Program Collection,Loyalty Program Collection,Lojalitetsprogram Samling
DocType: Stock Entry Detail,Subcontracted Item,Underleverantörsartikel
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Student {0} tillhör inte gruppen {1}
DocType: Budget,Cost Center,Kostnadscenter
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,Rabatt #
DocType: Tax Rule,Shipping Country,Frakt Land
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Hide Kundens Tax Id från Försäljningstransaktioner
DocType: Upload Attendance,Upload HTML,Ladda upp HTML
DocType: Employee,Relieving Date,Avgångs Datum
apps/erpnext/erpnext/projects/doctype/project/project.js,Duplicate Project with Tasks,Duplicera projekt med uppgifter
DocType: Purchase Invoice,Total Quantity,Total kvantitet
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.",Prissättning regel görs för att skriva Prislista / definiera rabatt procentsats baserad på vissa kriterier.
apps/erpnext/erpnext/support/doctype/issue/issue.py,Service Level Agreement has been changed to {0}.,Servicenivåavtalet har ändrats till {0}.
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Lager kan endast ändras via lagerposter / följesedel / inköpskvitto
DocType: Employee Education,Class / Percentage,Klass / Procent
DocType: Shopify Settings,Shopify Settings,Shopify-inställningar
DocType: Amazon MWS Settings,Market Place ID,Marknadsplats ID
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,Chef för Marknad och Försäljning
DocType: Video,Vimeo,Vimeo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,Inkomstskatt
DocType: HR Settings,Check Vacancies On Job Offer Creation,Kolla lediga jobb vid skapande av jobb
DocType: Subscription,Cancel At End Of Period,Avbryt vid slutet av perioden
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Egenskapen är redan tillagd
DocType: Item Supplier,Item Supplier,Produkt Leverantör
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,Ange Artikelkod att få batchnr
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},Lojalitetspoäng: {0}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,Please select a value for {0} quotation_to {1},Välj ett värde för {0} offert_till {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items selected for transfer,Inga objekt valda för överföring
apps/erpnext/erpnext/config/buying.py,All Addresses.,Alla adresser.
DocType: Company,Stock Settings,Stock Inställningar
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Sammanslagning är endast möjligt om följande egenskaper är desamma i båda posterna. Är gruppen, Root typ, Företag"
DocType: Vehicle,Electric,Elektrisk
DocType: Task,% Progress,% Framgång
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Gain/Loss on Asset Disposal,Vinst / förlust på Asset Avfallshantering
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Endast studentansökaren med statusen &quot;Godkänd&quot; kommer att väljas i tabellen nedan.
DocType: Tax Withholding Category,Rates,Priser
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Kontonummer för konto {0} är inte tillgängligt. <br> Ställ in din kontoplan korrekt.
DocType: Task,Depends on Tasks,Beror på Uppgifter
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Hantera Kundgruppsträd.
DocType: Normal Test Items,Result Value,Resultatvärde
DocType: Hotel Room,Hotels,hotell
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,Nytt kostnadsställe Namn
DocType: Leave Control Panel,Leave Control Panel,Lämna Kontrollpanelen
DocType: Project,Task Completion,uppgift Slutförande
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,Inte i lager
DocType: Volunteer,Volunteer Skills,Volontärfärdigheter
DocType: Additional Salary,HR User,HR-Konto
DocType: Bank Guarantee,Reference Document Name,Referensdokumentnamn
DocType: Purchase Invoice,Taxes and Charges Deducted,Skatter och avgifter Avdragen
DocType: Support Settings,Issues,Frågor
DocType: Loyalty Program,Loyalty Program Name,Lojalitetsprogramnamn
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},Status måste vara en av {0}
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,Påminnelse om att uppdatera GSTIN Skickat
DocType: Discounted Invoice,Debit To,Debitering
DocType: Restaurant Menu Item,Restaurant Menu Item,Restaurang menyobjekt
DocType: Delivery Note,Required only for sample item.,Krävs endast för provobjekt.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Faktiska Antal Efter transaktion
,Pending SO Items For Purchase Request,I avvaktan på SO Artiklar till inköpsanmodan
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,Student Antagning
apps/erpnext/erpnext/accounts/party.py,{0} {1} is disabled,{0} {1} är inaktiverad
DocType: Supplier,Billing Currency,Faktureringsvaluta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Extra Stor
DocType: Loan,Loan Application,Låneansökan
DocType: Crop,Scientific Name,Vetenskapligt namn
DocType: Healthcare Service Unit,Service Unit Type,Typ av serviceenhet
DocType: Bank Account,Branch Code,Gren-kod
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,Totalt löv
DocType: Customer,"Reselect, if the chosen contact is edited after save",Välj om den valda kontakten är redigerad efter spara
DocType: Quality Procedure,Parent Procedure,Föräldraförfarande
DocType: Patient Encounter,In print,I tryck
DocType: Accounting Dimension,Accounting Dimension,Redovisningsdimension
,Profit and Loss Statement,Resultaträkning
DocType: Bank Reconciliation Detail,Cheque Number,Check Nummer
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,Föremålet som nämns av {0} - {1} faktureras redan
,Sales Browser,Försäljnings Webbläsare
DocType: Journal Entry,Total Credit,Total Credit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Warning: Another {0} # {1} exists against stock entry {2},Varning: En annan {0} # {1} finns mot införande i lager {2}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Local,Lokal
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans and Advances (Assets),Utlåning (tillgångar)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,Gäldenärer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Stor
DocType: Bank Statement Settings,Bank Statement Settings,Bankdeklarationsinställningar
DocType: Shopify Settings,Customer Settings,Kundinställningar
DocType: Homepage Featured Product,Homepage Featured Product,Hemsida Aktuell produkt
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,Visa beställningar
DocType: Marketplace Settings,Marketplace URL (to hide and update label),Marknadsföringsadress (för att dölja och uppdatera etikett)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Alla bedömningsgrupper
apps/erpnext/erpnext/regional/india/utils.py,{} is required to generate e-Way Bill JSON,{} krävs för att generera e-Way Bill JSON
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Ny Lager Namn
DocType: Shopify Settings,App Type,App typ
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Totalt {0} ({1})
DocType: C-Form Invoice Detail,Territory,Territorium
DocType: Pricing Rule,Apply Rule On Item Code,Tillämpa regel om artikelkod
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Ange antal besökare (krävs)
apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Aktiebalansrapport
DocType: Stock Settings,Default Valuation Method,Standardvärderingsmetod
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Avgift
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Visa kumulativ mängd
apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Uppdatering pågår. Det kan ta ett tag.
DocType: Production Plan Item,Produced Qty,Producerad mängd
DocType: Vehicle Log,Fuel Qty,bränsle Antal
DocType: Work Order Operation,Planned Start Time,Planerad starttid
DocType: Course,Assessment,Värdering
DocType: Payment Entry Reference,Allocated,Tilldelad
apps/erpnext/erpnext/config/accounts.py,Close Balance Sheet and book Profit or Loss.,Stäng balansräkning och bokföringsmässig vinst eller förlust.
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,ERPNext could not find any matching payment entry,ERPNext kunde inte hitta någon matchande betalningspost
DocType: Student Applicant,Application Status,ansökan Status
DocType: Additional Salary,Salary Component Type,Lönkomponenttyp
DocType: Sensitivity Test Items,Sensitivity Test Items,Känslighetstestpunkter
DocType: Website Attribute,Website Attribute,Webbplatsattribut
DocType: Project Update,Project Update,Projektuppdatering
DocType: Journal Entry Account,Fees,avgifter
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Ange växelkursen för att konvertera en valuta till en annan
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} is cancelled,Offert {0} avbryts
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Outstanding Amount,Totala utestående beloppet
DocType: Sales Partner,Targets,Mål
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js,Please register the SIREN number in the company information file,Vänligen registrera SIREN-numret i företagsinformationsfilen
DocType: Quality Action Table,Responsible,Ansvarig
DocType: Email Digest,Sales Orders to Bill,Försäljningsorder till Bill
DocType: Price List,Price List Master,Huvudprislista
DocType: GST Account,CESS Account,CESS-konto
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Alla försäljningstransaktioner kan märkas mot flera ** säljare ** så att du kan ställa in och övervaka mål.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,Länk till materialförfrågan
DocType: Quiz,Score out of 100,Betyg av 100
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Forumaktivitet
DocType: Quiz,Grading Basis,Betygsgrund
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,SÅ Nej
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Bankräkning Transaktionsinställningsobjekt
apps/erpnext/erpnext/hr/utils.py,To date can not greater than employee's relieving date,Hittills kan det inte vara större än medarbetarens avlastningsdatum
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},Skapa Kunden från Prospekt {0}
apps/erpnext/erpnext/healthcare/page/patient_history/patient_history.html,Select Patient,Välj patient
DocType: Price List,Applicable for Countries,Gäller Länder
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Parameternamn
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Endast Lämna applikationer med status &#39;Godkänd&#39; och &#39;Avvisad&#39; kan lämnas in
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Skapar dimensioner ...
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},Student gruppnamn är obligatorisk i rad {0}
DocType: Homepage,Products to be shown on website homepage,Produkter som ska visas på startsidan för webbplatsen
DocType: HR Settings,Password Policy,Lösenordspolicy
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,This is a root customer group and cannot be edited.,Detta är en rot kundgrupp och kan inte ändras.
DocType: Student,AB-,AB-
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty must be greater than zero,Det totala slutförda antalet måste vara större än noll
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Åtgärd om ackumulerad månadsbudget överskrider PO
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,Att placera
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select a Sales Person for item: {0},Välj en säljare för artikeln: {0}
DocType: Stock Entry,Stock Entry (Outward GIT),Lagerinmatning (GIT)
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Valutakursomvärdering
DocType: POS Profile,Ignore Pricing Rule,Ignorera Prisregler
DocType: Employee Education,Graduate,Examinera
DocType: Leave Block List,Block Days,Block Dagar
DocType: Appointment,Linked Documents,Länkade dokument
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get item taxes,Ange artikelkod för att få artikelskatter
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule","Fraktadressen har inget land, vilket krävs för denna leveransregel"
DocType: Journal Entry,Excise Entry,Punktnotering
DocType: Bank,Bank Transaction Mapping,Kartläggning av banktransaktioner
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Varning: Kundorder {0} finns redan mot Kundens beställning {1}
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Standard Villkor som kan läggas till försäljning och inköp. Exempel: 1. giltighet erbjudandet. 1. Betalningsvillkor (på förhand på kredit, del förskott etc). 1. Vad är extra (eller betalas av kunden). 1. Säkerhet / användning varning. 1. Garanti om något. 1. Returer Policy. 1. Villkor för leverans, om tillämpligt. 1. Sätt att hantera konflikter, ersättning, ansvar, etc. 1. Adresser och kontaktinformation för ditt företag."
DocType: Homepage Section,Section Based On,Avsnitt baserat på
DocType: Shopping Cart Settings,Show Apply Coupon Code,Visa Använd kupongkod
DocType: Issue,Issue Type,Typ av utgåva
DocType: Attendance,Leave Type,Ledighetstyp
DocType: Purchase Invoice,Supplier Invoice Details,Detaljer leverantörsfaktura
DocType: Agriculture Task,Ignore holidays,Ignorera semester
apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Lägg till / redigera kupongvillkor
apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Utgift / Differens konto ({0}) måste vara ett ""vinst eller förlust"" konto"
DocType: Stock Entry Detail,Stock Entry Child,Lagerinförande barn
DocType: Project,Copied From,Kopierad från
DocType: Project,Copied From,Kopierad från
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,Faktura som redan skapats för alla faktureringstimmar
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},Namn fel: {0}
DocType: Healthcare Service Unit Type,Item Details,Artikel detaljer
DocType: Cash Flow Mapping,Is Finance Cost,Är finansieringskostnad
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance for employee {0} is already marked,Närvaro för anställd {0} är redan märkt
DocType: Packing Slip,If more than one package of the same type (for print),Om mer än ett paket av samma typ (för utskrift)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set default customer in Restaurant Settings,Ange standardkund i Restauranginställningar
,Salary Register,lön Register
DocType: Company,Default warehouse for Sales Return,Standardlager för återförsäljning
DocType: Pick List,Parent Warehouse,moderLager
DocType: Subscription,Net Total,Netto Totalt
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set item's shelf life in days, to set expiry based on manufacturing date plus shelf-life.",Ställ in varans hållbarhet i dagar för att ställa in löptid baserat på tillverkningsdatum plus hållbarhet.
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM not found for Item {0} and Project {1},Standard BOM hittades inte för punkt {0} och projekt {1}
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Rad {0}: Ange betalningsmetod i betalningsschema
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Definiera olika lån typer
DocType: Bin,FCFS Rate,FCFS betyg
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Utestående Belopp
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),Tid (i min)
DocType: Task,Working,Arbetande
DocType: Stock Ledger Entry,Stock Queue (FIFO),Stock kö (FIFO)
DocType: Homepage Section,Section HTML,Avsnitt HTML
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,Budgetår
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{0} does not belong to Company {1},{0} tillhör inte företaget {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve criteria score function for {0}. Make sure the formula is valid.,Det gick inte att lösa kriterierna för funktionen {0}. Se till att formeln är giltig.
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,Kostnad som på
DocType: Healthcare Settings,Out Patient Settings,Ut patientinställningar
DocType: Account,Round Off,Runda Av
DocType: Service Level Priority,Resolution Time,Upplösningstid
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,Mängden måste vara positiv
DocType: Job Card,Requested Qty,Begärt Antal
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The fields From Shareholder and To Shareholder cannot be blank,Fälten från aktieägare och till aktieägare kan inte vara tomma
DocType: Cashier Closing,Cashier Closing,Kassat stängning
DocType: Tax Rule,Use for Shopping Cart,Används för Varukorgen
DocType: Homepage,Homepage Slideshow,Hemsida Bildspel
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Välj serienummer
DocType: BOM Item,Scrap %,Skrot%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Avgifter kommer att fördelas proportionellt baserad på produktantal eller belopp, enligt ditt val"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,Skapa leverantörsoffert
DocType: Travel Request,Require Full Funding,Kräver full finansiering
DocType: Maintenance Visit,Purposes,Ändamål
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-.YYYY.-
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Atleast one item should be entered with negative quantity in return document,Minst ett objekt ska anges med negativt kvantitet i returdokument
DocType: Shift Type,Grace Period Settings For Auto Attendance,Inställningar för nådeperiod för automatisk närvaro
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operation {0} längre än alla tillgängliga arbetstiden i arbetsstation {1}, bryta ner verksamheten i flera operationer"
DocType: Membership,Membership Status,Medlemsstatus
DocType: Travel Itinerary,Lodging Required,Logi krävs
DocType: Promotional Scheme,Price Discount Slabs,Prisrabattplattor
DocType: Stock Reconciliation Item,Current Serial No,Aktuellt serienummer
DocType: Employee,Attendance and Leave Details,Information om närvaro och lämna
,BOM Comparison Tool,BOM-jämförelseverktyg
,Requested,Begärd
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,Anmärkningar
DocType: Asset,In Maintenance,Under underhåll
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Klicka på den här knappen för att dra dina försäljningsorderdata från Amazon MWS.
DocType: Vital Signs,Abdomen,Buk
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,Inga utestående fakturor kräver valutakursvärdering
DocType: Purchase Invoice,Overdue,Försenad
DocType: Account,Stock Received But Not Billed,Stock mottagits men inte faktureras
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Root Hänsyn måste vara en grupp
DocType: Drug Prescription,Drug Prescription,Drug Prescription
DocType: Service Level,Support and Resolution,Support och upplösning
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Gratis artikelkod är inte vald
DocType: Loan,Repaid/Closed,Återbetalas / Stängd
DocType: Amazon MWS Settings,CA,CA
DocType: Item,Total Projected Qty,Totala projicerade Antal
DocType: Monthly Distribution,Distribution Name,Distributions Namn
DocType: Chart of Accounts Importer,Chart Tree,Diagramträd
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Inkludera UOM
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,Material Ansökaningsnr
DocType: Service Level Agreement,Default Service Level Agreement,Standardavtal om servicenivå
DocType: SG Creation Tool Course,Course Code,Kurskod
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,Mer än ett val för {0} är inte tillåtet
DocType: Pick List,Qty of raw materials will be decided based on the qty of the Finished Goods Item,Antal råvaror kommer att bestämmas utifrån antalet färdigvaror
DocType: Location,Parent Location,Parent Location
DocType: POS Settings,Use POS in Offline Mode,Använd POS i offline-läge
apps/erpnext/erpnext/support/doctype/issue/issue.py,Priority has been changed to {0}.,Prioritet har ändrats till {0}.
apps/erpnext/erpnext/accounts/page/pos/pos.js,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} är obligatorisk. Kanske har en valutaväxlingskurs inte skapats för {1} till {2}
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,I takt med vilket vilken kundens valuta omvandlas till företagets basvaluta
DocType: Purchase Invoice Item,Net Rate (Company Currency),Netto kostnad (Företagsvaluta)
DocType: Salary Detail,Condition and Formula Help,Tillstånd och Formel Hjälp
apps/erpnext/erpnext/config/crm.py,Manage Territory Tree.,Hantera Områden.
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,Importera kontoplan från CSV / Excel-filer
DocType: Patient Service Unit,Patient Service Unit,Patient Service Unit
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Försäljning Faktura
DocType: Journal Entry Account,Party Balance,Parti Balans
DocType: Cash Flow Mapper,Section Subtotal,Sektion Subtotal
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,Välj Verkställ rabatt på
DocType: Stock Settings,Sample Retention Warehouse,Provhållningslager
DocType: Company,Default Receivable Account,Standard Mottagarkonto
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Projekterad kvantitetsformel
DocType: Sales Invoice,Deemed Export,Fördjupad export
DocType: Pick List,Material Transfer for Manufacture,Material Transfer för Tillverkning
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Discount Percentage can be applied either against a Price List or for all Price List.,Rabatt Procent kan appliceras antingen mot en prislista eller för alla prislistor.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Accounting Entry for Stock,Kontering för lager
DocType: Lab Test,LabTest Approver,LabTest Approver
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,Du har redan bedömt för bedömningskriterierna {}.
DocType: Vehicle Service,Engine Oil,Motorolja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Arbetsorder skapade: {0}
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set an email id for the Lead {0},Ange ett e-post-id för Lead {0}
DocType: Sales Invoice,Sales Team1,Försäljnings Team1
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,Punkt {0} inte existerar
DocType: Sales Invoice,Customer Address,Kundadress
DocType: Loan,Loan Details,Loan Detaljer
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Misslyckades med att ställa in postbolags fixturer
DocType: Company,Default Inventory Account,Standard Inventory Account
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Folio numren matchar inte
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Betalningsbegäran om {0}
DocType: Item Barcode,Barcode Type,Streckkodstyp
DocType: Antibiotic,Antibiotic Name,Antibiotikumnamn
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Leverantörsgrupp mästare.
DocType: Healthcare Service Unit,Occupancy Status,Behållarstatus
apps/erpnext/erpnext/accounts/dashboard_chart_source/account_balance_timeline/account_balance_timeline.py,Account is not set for the dashboard chart {0},Kontot är inte inställt för instrumentpanelen {0}
DocType: Purchase Invoice,Apply Additional Discount On,Applicera ytterligare rabatt på
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,Välj typ ...
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,Dina biljetter
DocType: Account,Root Type,Root Typ
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,Stäng POS
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},Rad # {0}: Det går inte att returnera mer än {1} till artikel {2}
DocType: Item Group,Show this slideshow at the top of the page,Visa denna bildspel längst upp på sidan
DocType: BOM,Item UOM,Produkt UOM
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Skattebelopp efter rabatt Belopp (Company valuta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},Target lager är obligatoriskt för rad {0}
apps/erpnext/erpnext/config/retail.py,Retail Operations,Återförsäljare
DocType: Cheque Print Template,Primary Settings,primära inställningar
DocType: Attendance Request,Work From Home,Arbeta hemifrån
DocType: Purchase Invoice,Select Supplier Address,Välj Leverantör Adress
apps/erpnext/erpnext/public/js/event.js,Add Employees,Lägg till anställda
DocType: Purchase Invoice Item,Quality Inspection,Kvalitetskontroll
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Small,Extra Liten
DocType: Company,Standard Template,standardmall
DocType: Training Event,Theory,Teori
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Warning: Material Requested Qty is less than Minimum Order Qty,Varning: Material Begärt Antal är mindre än Minimum Antal
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Account {0} is frozen,Kontot {0} är fruset
DocType: Quiz Question,Quiz Question,Frågesportfråga
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Juridisk person / Dotterbolag med en separat kontoplan som tillhör organisationen.
DocType: Payment Request,Mute Email,Mute E
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,"Food, Beverage & Tobacco","Mat, dryck och tobak"
apps/erpnext/erpnext/controllers/buying_controller.py,"Cannot cancel this document as it is linked with submitted asset {0}.\
								Please cancel the it to continue.",Det går inte att avbryta det här dokumentet eftersom det är länkat till den skickade tillgången {0}. \ Avbryt det för att fortsätta.
DocType: Account,Account Number,Kontonummer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Kan bara göra betalning mot ofakturerade {0}
DocType: Call Log,Missed,missade
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Provisionshastighet kan inte vara större än 100
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Duplicera posten mot artikelkoden {0} och tillverkaren {1}
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Tilldela förskott automatiskt (FIFO)
DocType: Volunteer,Volunteer,Volontär
DocType: Buying Settings,Subcontract,Subkontrakt
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,Ange {0} först
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Inga svar från
DocType: Work Order Operation,Actual End Time,Faktiskt Sluttid
DocType: Purchase Invoice Item,Manufacturer Part Number,Tillverkarens varunummer
DocType: Taxable Salary Slab,Taxable Salary Slab,Skattlig löneskiva
DocType: Work Order Operation,Estimated Time and Cost,Beräknad tid och kostnad
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection: {0} is not submitted for the item: {1} in row {2},Kvalitetskontroll: {0} skickas inte in för artikeln: {1} i rad {2}
DocType: Bin,Bin,Bin
DocType: Bank Transaction,Bank Transaction,Banktransaktion
DocType: Crop,Crop Name,Skörda namn
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,Endast användare med {0} -roll kan registrera sig på Marketplace
DocType: SMS Log,No of Sent SMS,Antal skickade SMS
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,Möten och möten
DocType: Antibiotic,Healthcare Administrator,Sjukvårdsadministratör
DocType: Dosage Strength,Dosage Strength,Dosstyrka
DocType: Healthcare Practitioner,Inpatient Visit Charge,Inpatientbesök
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Published Items,Publicerade artiklar
DocType: Account,Expense Account,Utgiftskonto
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,Programvara
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,Färg
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Bedömningsplanskriterier
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,transaktioner
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Förhindra köporder
DocType: Coupon Code,Coupon Name,Kupongnamn
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Mottaglig
DocType: Shift Type,Working Hours Calculation Based On,Beräkningar av arbetstid baserat på
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Offertförfrågan.
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Välj punkt där ""Är Lagervara"" är ""Nej"" och ""Är försäljningsprodukt"" är ""Ja"" och det finns ingen annat produktpaket"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js,Select Customer,Välj kund
DocType: Student Log,Academic,Akademisk
DocType: Patient,Personal and Social History,Personlig och social historia
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,Användare {0} skapad
DocType: Fee Schedule,Fee Breakup for each student,Avgift för varje elev
apps/erpnext/erpnext/controllers/accounts_controller.py,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Totalt förskott ({0}) mot Order {1} kan inte vara större än totalsumman ({2})
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Ändra kod
DocType: Purchase Invoice Item,Valuation Rate,Värderings betyg
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Skapa Varianter
DocType: Vehicle,Diesel,Diesel
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Completed Quantity,Avslutat antal
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Prislista Valuta inte valt
DocType: Quick Stock Balance,Available Quantity,tillgänglig kvantitet
DocType: Purchase Invoice,Availed ITC Cess,Utnyttjade ITC Cess
,Student Monthly Attendance Sheet,Student Monthly Närvaro Sheet
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Fraktregeln gäller endast för Försäljning
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Avskrivningsraden {0}: Nästa avskrivningsdatum kan inte vara före inköpsdatum
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,Projekt Startdatum
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,Tills
DocType: Rename Tool,Rename Log,Ändra logg
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Studentgrupp eller kursplan är obligatorisk
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Studentgrupp eller kursplan är obligatorisk
DocType: Maintenance Visit Purpose,Against Document No,Mot Dokument nr
DocType: BOM,Scrap,Skrot
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,Hantera Försäljning Partners.
DocType: Quality Inspection,Inspection Type,Inspektionstyp
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,All bank transactions have been created,Alla banktransaktioner har skapats
DocType: Fee Validity,Visited yet,Besökt ännu
apps/erpnext/erpnext/public/js/hub/pages/FeaturedItems.vue,You can Feature upto 8 items.,Du kan ha upp till 8 artiklar.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,Lager med befintlig transaktion kan inte konverteras till gruppen.
DocType: Assessment Result Tool,Result HTML,resultat HTML
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Hur ofta ska projektet och företaget uppdateras baserat på försäljningstransaktioner.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,Går ut den
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,The total completed qty({0}) must be equal to qty to manufacture({1}),Det totala slutförda antalet ({0}) måste vara lika med antalet för att tillverka ({1})
apps/erpnext/erpnext/utilities/activation.py,Add Students,Lägg till elever
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},Välj {0}
DocType: C-Form,C-Form No,C-form Nr
DocType: Delivery Stop,Distance,Distans
DocType: Water Analysis,Storage Temperature,Förvaringstemperatur
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Employee Attendance Tool,Unmarked Attendance,omärkt Närvaro
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Skapa betalningsuppgifter ......
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,Forskare
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid public token error,Plaid public token-fel
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Programmet Inskrivning Tool Student
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py,Start date should be less than end date for task {0},Startdatum bör vara mindre än slutdatum för uppgift {0}
,Consolidated Financial Statement,Koncernredovisning
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Namn eller e-post är obligatoriskt
DocType: Instructor,Instructor Log,Instruktörsloggen
DocType: Clinical Procedure,Clinical Procedure,Klinisk procedur
DocType: Shopify Settings,Delivery Note Series,Serie för leveransnotering
DocType: Purchase Order Item,Returned Qty,Återvände Antal
DocType: Student,Exit,Utgång
DocType: Communication Medium,Communication Medium,Kommunikationsmedium
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,Root Type är obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,Misslyckades med att installera förinställningar
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,UOM Konvertering i timmar
DocType: Contract,Signee Details,Signee Detaljer
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} har för närvarande {1} leverantörsanmärkning och offertförfrågan bör ställas med försiktighet!
DocType: Certified Consultant,Non Profit Manager,Non Profit Manager
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} created,Löpnummer {0} skapades
DocType: Homepage,Company Description for website homepage,Beskrivning av företaget för webbplats hemsida
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","För att underlätta för kunderna, kan dessa koder användas i utskriftsformat som fakturor och följesedlar"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Suplier Name,suplier Namn
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,Det gick inte att hämta information för {0}.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Öppningsdatum Journal
DocType: Contract,Fulfilment Terms,Uppfyllningsvillkor
DocType: Sales Invoice,Time Sheet List,Tidrapportering Lista
DocType: Healthcare Settings,Result Printed,Resultat skrivet
DocType: Asset Category Account,Depreciation Expense Account,Avskrivningar konto
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,Provanställning
DocType: Tax Category,Is Inter State,Är interstat
apps/erpnext/erpnext/config/hr.py,Shift Management,Shift Management
DocType: Customer Group,Only leaf nodes are allowed in transaction,Endast huvudnoder är tillåtna i transaktionen
DocType: Project,Total Costing Amount (via Timesheets),Totalkostnadsbelopp (via tidskrifter)
DocType: Department,Expense Approver,Utgiftsgodkännare
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Rad {0}: Advance mot Kunden måste vara kredit
DocType: Quality Meeting,Quality Meeting,Kvalitetsmöte
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Icke-grupp till grupp
DocType: Employee,ERPNext User,ERPNext User
DocType: Coupon Code,Coupon Description,Kupongbeskrivning
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch är obligatorisk i rad {0}
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch är obligatorisk i rad {0}
DocType: Company,Default Buying Terms,Standardköpvillkor
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Inköpskvitto Artikel Levereras
DocType: Amazon MWS Settings,Enable Scheduled Synch,Aktivera schemalagd synkronisering
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,Till Datetime
apps/erpnext/erpnext/config/crm.py,Logs for maintaining sms delivery status,Loggar för att upprätthålla sms leveransstatus
DocType: Accounts Settings,Make Payment via Journal Entry,Gör betalning via Journal Entry
apps/erpnext/erpnext/controllers/item_variant.py,Please do not create more than 500 items at a time,Skapa inte mer än 500 objekt åt gången
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,Tryckt på
DocType: Clinical Procedure Template,Clinical Procedure Template,Klinisk procedurmall
DocType: Item,Inspection Required before Delivery,Inspektion krävs innan leverans
apps/erpnext/erpnext/config/education.py,Content Masters,Innehåll Masters
DocType: Item,Inspection Required before Purchase,Inspektion krävs innan köp
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Väntande Verksamhet
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Skapa labtest
DocType: Patient Appointment,Reminded,påminde
DocType: Homepage Section,Cards,kort
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Visa diagram över konton
DocType: Chapter Member,Chapter Member,Kapitelmedlem
DocType: Material Request Plan Item,Minimum Order Quantity,Minimum antal
apps/erpnext/erpnext/public/js/setup_wizard.js,Your Organization,Din organisation
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Hoppa överlåtetilldelning för följande anställda, eftersom överföringsposter redan existerar mot dem. {0}"
DocType: Fee Component,Fees Category,avgifter Kategori
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,Ange avlösningsdatum.
apps/erpnext/erpnext/controllers/trends.py,Amt,Ant
DocType: Travel Request,"Details of Sponsor (Name, Location)","Detaljer om Sponsor (Namn, Plats)"
DocType: Supplier Scorecard,Notify Employee,Meddela medarbetare
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Ange värde mellan {0} och {1}
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Ange namnet på kampanjen om källförfrågan är kampanjen
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Newspaper Publishers,Tidningsutgivarna
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Framtida datum inte tillåtet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Expected Delivery Date should be after Sales Order Date,Förväntad leveransdatum bör vara efter försäljningsbeställningsdatum
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Reorder Level,Ombeställningsnivå
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Chart Of Accounts Template,Konto Mall
DocType: Attendance,Attendance Date,Närvaro Datum
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},Uppdateringslagret måste vara aktiverat för inköpsfakturan {0}
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},Artikel Pris uppdaterad för {0} i prislista {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Number Created,Serienummer skapat
,DATEV,DATEV
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Lön upplösning baserat på inkomster och avdrag.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be converted to ledger,Konto med underordnade noder kan inte omvandlas till liggaren
DocType: Purchase Invoice Item,Accepted Warehouse,Godkänt lager
DocType: Bank Reconciliation Detail,Posting Date,Bokningsdatum
DocType: Item,Valuation Method,Värderingsmetod
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,One customer can be part of only single Loyalty Program.,En kund kan vara en del av ett enda lojalitetsprogram.
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Mark Halvdag
DocType: Sales Invoice,Sales Team,Sales Team
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,Duplicera post
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the Beneficiary before submittting.,Ange mottagarens namn innan du skickar in.
DocType: Program Enrollment Tool,Get Students,Få studenter
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Bank Data mapper doesn't exist,Bankdata-mapper finns inte
DocType: Serial No,Under Warranty,Under garanti
DocType: Homepage Section,Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,Antal kolumner för detta avsnitt. 3 kort visas per rad om du väljer 3 kolumner.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Fel]
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Reconcile Entries,Förena poster
DocType: Sales Order,In Words will be visible once you save the Sales Order.,I Ord kommer att synas när du sparar kundorder.
,Employee Birthday,Anställd Födelsedag
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0}: Cost Center {1} does not belong to company {2},Rad # {0}: Cost Center {1} tillhör inte företaget {2}
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,Var god välj Slutdatum för slutfört reparation
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Elev Batch Närvaro Tool
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,gräns Korsade
DocType: Appointment Booking Settings,Appointment Booking Settings,Inställningar för bokning av möten
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Schemalagt Upto
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,Deltagandet har markerats som per anställd incheckningar
DocType: Woocommerce Settings,Secret,Hemlighet
DocType: Plaid Settings,Plaid Secret,Plädhemlighet
DocType: Company,Date of Establishment,Datum för etablering
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,Tilldelningskapital
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,En termin med detta &quot;Academic Year &#39;{0} och&quot; Term Name &quot;{1} finns redan. Ändra dessa poster och försök igen.
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}",Eftersom det finns transaktioner mot produkten {0} så kan du inte ändra värdet av {1}
DocType: UOM,Must be Whole Number,Måste vara heltal
DocType: Campaign Email Schedule,Send After (days),Skicka efter (dagar)
DocType: Leave Control Panel,New Leaves Allocated (In Days),Nya Ledigheter Tilldelade (i dagar)
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse not found against the account {0},Lager hittades inte mot kontot {0}
DocType: Purchase Invoice,Invoice Copy,Faktura kopia
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,Serienummer {0} inte existerar
DocType: Sales Invoice Item,Customer Warehouse (Optional),Kund Warehouse (tillval)
DocType: Blanket Order Item,Blanket Order Item,Blankettbeställningsartikel
DocType: Pricing Rule,Discount Percentage,Rabatt Procent
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Reserveras för underleverantörer
DocType: Payment Reconciliation Invoice,Invoice Number,Fakturanummer
DocType: Shopping Cart Settings,Orders,Beställningar
DocType: Travel Request,Event Details,Evenemangsdetaljer
DocType: Department,Leave Approver,Ledighetsgodkännare
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,Var god välj ett parti
DocType: Sales Invoice,Redemption Cost Center,Inlösenkostnadscenter
DocType: QuickBooks Migrator,Scope,Omfattning
DocType: Assessment Group,Assessment Group Name,Bedömning Gruppnamn
DocType: Manufacturing Settings,Material Transferred for Manufacture,Material Överfört för tillverkning
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Lägg till i detaljer
DocType: Travel Itinerary,Taxi,Taxi
DocType: Shopify Settings,Last Sync Datetime,Senast synkroniserad datetime
DocType: Landed Cost Item,Receipt Document Type,Kvitto Document Type
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Förslag / pris offert
DocType: Antibiotic,Healthcare,Sjukvård
DocType: Target Detail,Target Detail,Måldetaljer
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,Enstaka variant
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,All Jobs,alla jobb
DocType: Sales Order,% of materials billed against this Sales Order,% Av material faktureras mot denna kundorder
DocType: Program Enrollment,Mode of Transportation,Transportsätt
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"From a supplier under composition scheme, Exempt and Nil rated","Från en leverantör enligt sammansättningssystem, Exempt och Nil rankade"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,Period Utgående Post
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,Välj avdelning ...
DocType: Pricing Rule,Free Item,Gratis artikel
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Leveranser till skattepliktiga personer
apps/erpnext/erpnext/regional/india/utils.py,Distance cannot be greater than 4000 kms,Avståndet kan inte vara större än 4000 km
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to group,Kostnadsställe med befintliga transaktioner kan inte omvandlas till grupp
DocType: QuickBooks Migrator,Authorization URL,Auktoriseringsadress
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Mängden {0} {1} {2} {3}
DocType: Account,Depreciation,Avskrivningar
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
					to cancel this document","Radera anställden <a href=""#Form/Employee/{0}"">{0}</a> \ för att avbryta detta dokument"
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The number of shares and the share numbers are inconsistent,Antal aktier och aktienumren är inkonsekventa
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),Leverantör (s)
DocType: Employee Attendance Tool,Employee Attendance Tool,Anställd närvaro Tool
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Kreditgräns
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,Avg. Säljes prislista pris
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Samlingsfaktor (= 1 LP)
DocType: Additional Salary,Salary Component,lönedel
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,Betalnings Inlägg {0} är un bundna
DocType: GL Entry,Voucher No,Rabatt nr
,Lead Owner Efficiency,Effektivitet hos ledningsägaren
,Lead Owner Efficiency,Effektivitet hos ledningsägaren
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,Arbetsdag {0} har upprepats.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
				as pro-rata component","Du kan bara hävda en mängd {0}, resten mängden {1} borde vara i programmet \ som pro-rata-komponenten"
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Anställd A / C-nummer
DocType: Amazon MWS Settings,Customer Type,kundtyp
DocType: Compensatory Leave Request,Leave Allocation,Ledighet tilldelad
DocType: Payment Request,Recipient Message And Payment Details,Mottagare Meddelande och betalningsuppgifter
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please select a Delivery Note,Välj en leveransanteckning
DocType: Support Search Source,Source DocType,Källa DocType
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,Öppna en ny biljett
DocType: Training Event,Trainer Email,Trainer E
DocType: Sales Invoice,Transporter,Transporter
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Importera dagboksdata
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,Prioritet {0} har upprepats.
DocType: Restaurant Reservation,No of People,Antal människor
apps/erpnext/erpnext/config/accounts.py,Template of terms or contract.,Mall av termer eller kontrakt.
DocType: Bank Account,Address and Contact,Adress och Kontakt
DocType: Vital Signs,Hyper,Hyper
DocType: Cheque Print Template,Is Account Payable,Är leverantörsskuld
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},Lager kan inte uppdateras mot inköpskvitto {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Skapa leveransresa
DocType: Support Settings,Auto close Issue after 7 days,Stäng automatiskt Problem efter 7 dagar
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Lämna inte kan fördelas före {0}, som ledighet balans redan har carry-vidarebefordras i framtiden ledighet tilldelningspost {1}"
apps/erpnext/erpnext/accounts/party.py,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),OBS: På grund / Referens Datum överstiger tillåtna kundkreditdagar från {0} dag (ar)
DocType: Program Enrollment Tool,Student Applicant,Student Sökande
DocType: Hub Tracked Item,Hub Tracked Item,Navspårad artikel
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL FÖR MOTTAGARE
DocType: Asset Category Account,Accumulated Depreciation Account,Ackumulerade avskrivningar konto
DocType: Certified Consultant,Discuss ID,Diskutera ID
DocType: Stock Settings,Freeze Stock Entries,Frys Lager Inlägg
DocType: Program Enrollment,Boarding Student,Boarding Student
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,Vänligen aktivera gällande bokningskostnader
DocType: Asset Finance Book,Expected Value After Useful Life,Förväntat värde eller återanvändas
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be greater than work order quantity {1},För kvantitet {0} bör inte vara större än mängden arbetsorder {1}
DocType: Item,Reorder level based on Warehouse,Beställningsnivå baserat på Warehouse
DocType: Activity Cost,Billing Rate,Faktureringsfrekvens
,Qty to Deliver,Antal att leverera
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Skapa bidrag till utbetalning
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon kommer att synkronisera data uppdaterat efter det här datumet
,Stock Analytics,Arkiv Analytics
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Verksamheten kan inte lämnas tomt
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,Välj en standardprioritet.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Lab Test (s)
DocType: Maintenance Visit Purpose,Against Document Detail No,Mot Dokument Detalj nr
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Radering är inte tillåtet för land {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Party Type är obligatorisk
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Tillämpa kupongkod
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",För jobbkort {0} kan du bara skriva in materialmaterialöverföringen
DocType: Quality Inspection,Outgoing,Utgående
DocType: Customer Feedback Table,Customer Feedback Table,Kundens feedbacktabell
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Servicenivåavtal.
DocType: Material Request,Requested For,Begärd För
DocType: Quotation Item,Against Doctype,Mot Doctype
apps/erpnext/erpnext/controllers/selling_controller.py,{0} {1} is cancelled or closed,{0} {1} är avbruten eller stängd
DocType: Asset,Calculate Depreciation,Beräkna avskrivningar
DocType: Delivery Note,Track this Delivery Note against any Project,Prenumerera på det här följesedel mot någon Project
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Investing,Nettokassaflöde från Investera
DocType: Purchase Invoice,Import Of Capital Goods,Import av kapitalvaror
DocType: Work Order,Work-in-Progress Warehouse,Pågående Arbete - Lager
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,Asset {0} måste lämnas in
DocType: Fee Schedule Program,Total Students,Totalt antal studenter
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},Publikrekord {0} finns mot Student {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Referens # {0} den {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Avskrivningar Utslagen på grund av avyttring av tillgångar
DocType: Employee Transfer,New Employee ID,Nyanställd ID
DocType: Loan,Member,Medlem
DocType: Work Order Item,Work Order Item,Arbeta beställningsobjekt
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Visa öppningsregister
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,Unlink external integrations,Koppla bort externa integrationer
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Choose a corresponding payment,Välj en motsvarande betalning
DocType: Pricing Rule,Item Code,Produktkod
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Serial No,Warranty / AMC Details,Garanti / AMC Detaljer
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,Välj studenter manuellt för aktivitetsbaserad grupp
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,Välj studenter manuellt för aktivitetsbaserad grupp
DocType: Journal Entry,User Remark,Användar Anmärkning
DocType: Travel Itinerary,Non Diary,Icke-dagbok
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Cannot create Retention Bonus for left Employees,Kan inte skapa kvarhållningsbonus för kvarvarande anställda
DocType: Lead,Market Segment,Marknadssegment
DocType: Agriculture Analysis Criteria,Agriculture Manager,Jordbrukschef
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Paid Amount cannot be greater than total negative outstanding amount {0},Utbetalda beloppet kan inte vara större än den totala negativa utestående beloppet {0}
DocType: Supplier Scorecard Period,Variables,variabler
DocType: Employee Internal Work History,Employee Internal Work History,Anställd interna arbetshistoria
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Dr),Closing (Dr)
DocType: Cheque Print Template,Cheque Size,Check Storlek
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,Löpnummer {0} inte i lager
apps/erpnext/erpnext/config/accounts.py,Tax template for selling transactions.,Skatte mall för att sälja transaktioner.
DocType: Sales Invoice,Write Off Outstanding Amount,Avskrivning utestående belopp
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Account {0} does not match with Company {1},Konto {0} matchar inte företaget {1}
DocType: Education Settings,Current Academic Year,Nuvarande akademiska året
DocType: Education Settings,Current Academic Year,Nuvarande akademiska året
DocType: Stock Settings,Default Stock UOM,Standard Stock UOM
DocType: Asset,Number of Depreciations Booked,Antal Avskrivningar bokat
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,Antal totalt
DocType: Landed Cost Item,Receipt Document,kvitto Dokument
DocType: Employee Education,School/University,Skola / Universitet
DocType: Sales Invoice Item,Available Qty at Warehouse,Tillgång Antal vid Lager
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Billed Amount,Fakturerat antal
DocType: Share Transfer,(including),(inklusive)
DocType: Quality Review Table,Yes/No,Ja Nej
DocType: Asset,Double Declining Balance,Dubbel degressiv
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,Sluten ordning kan inte avbrytas. ÖPPNA för att avbryta.
DocType: Amazon MWS Settings,Synch Products,Synch Products
DocType: Loyalty Point Entry,Loyalty Program,Lojalitetsprogram
DocType: Student Guardian,Father,Far
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Support biljetter
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,'Update Stock' cannot be checked for fixed asset sale,"""Uppdatera lager"" kan inte klaras av för försäljning av anläggningstillgångar"
DocType: Bank Reconciliation,Bank Reconciliation,Bankavstämning
DocType: Attendance,On Leave,tjänstledig
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,Hämta uppdateringar
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: konto {2} tillhör inte företaget {3}
apps/erpnext/erpnext/stock/doctype/item/item.js,Select at least one value from each of the attributes.,Välj minst ett värde från var och en av attributen.
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Please login as a Marketplace User to edit this item.,Logga in som Marketplace-användare för att redigera den här artikeln.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Material Request {0} is cancelled or stopped,Material Begäran {0} avbryts eller stoppas
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,Dispatch State
apps/erpnext/erpnext/config/help.py,Leave Management,Lämna ledning
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,Grupper
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,Grupp per konto
DocType: Purchase Invoice,Hold Invoice,Håll faktura
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Var god välj Medarbetare
DocType: Sales Order,Fully Delivered,Fullt Levererad
DocType: Promotional Scheme Price Discount,Min Amount,Min belopp
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,Lägre intäkter
DocType: Restaurant Order Entry,Current Order,Nuvarande ordning
DocType: Delivery Trip,Driver Address,Förarens adress
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},Källa och mål lager kan inte vara samma för rad {0}
DocType: Account,Asset Received But Not Billed,Tillgång mottagen men ej fakturerad
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Differenskonto måste vara en tillgång / skuld kontotyp, eftersom denna lageravstämning är en öppnings post"
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},Betalats Beloppet får inte vara större än Loan Mängd {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Rad {0} # Tilldelad mängd {1} kan inte vara större än oavkrävat belopp {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Order number required for Item {0},Inköpsordernr som krävs för punkt {0}
DocType: Leave Allocation,Carry Forwarded Leaves,Skicka vidare ledighet
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,'From Date' must be after 'To Date',&quot;Från datum&quot; måste vara efter &quot;Till datum&quot;
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Inga personalplaner hittades för denna beteckning
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,Batch {0} av Objekt {1} är inaktiverat.
DocType: Leave Policy Detail,Annual Allocation,Årlig fördelning
DocType: Travel Request,Address of Organizer,Arrangörens adress
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Välj vårdgivare ...
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Gäller vid anställd ombordstigning
apps/erpnext/erpnext/config/accounts.py,Tax template for item tax rates.,Skattmall för artikelskattesatser.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Varor överförs
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},Det går inte att ändra status som studerande {0} är kopplad med student ansökan {1}
DocType: Asset,Fully Depreciated,helt avskriven
DocType: Item Barcode,UPC-A,UPC-A
,Stock Projected Qty,Lager Projicerad Antal
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Customer {0} does not belong to project {1},Kund {0} tillhör inte projektet {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Markerad Närvaro HTML
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers","Citat är förslag, bud som du har skickat till dina kunder"
DocType: Sales Invoice,Customer's Purchase Order,Kundens beställning
DocType: Clinical Procedure,Patient,Patient
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Bypass kreditkontroll vid Försäljningsorder
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Anställd ombordstigningsaktivitet
DocType: Location,Check if it is a hydroponic unit,Kontrollera om det är en hydroponisk enhet
DocType: Pick List Item,Serial No and Batch,Löpnummer och Batch
DocType: Warranty Claim,From Company,Från Företag
DocType: GSTR 3B Report,January,januari
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,Summan av Mängder av bedömningskriterier måste vara {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,Ställ in Antal Avskrivningar bokat
DocType: Supplier Scorecard Period,Calculations,beräkningar
apps/erpnext/erpnext/public/js/stock_analytics.js,Value or Qty,Värde eller Antal
DocType: Payment Terms Template,Payment Terms,Betalningsvillkor
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,Produktioner Beställningar kan inte höjas för:
DocType: Quality Meeting Minutes,Minute,Minut
DocType: Purchase Invoice,Purchase Taxes and Charges,Inköp skatter och avgifter
DocType: Chapter,Meetup Embed HTML,Meetup Bädda in HTML
DocType: Asset,Insured value,Försäkrade värde
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,POS Closing Voucher Skatter
,Qty to Receive,Antal att ta emot
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Start- och slutdatum inte i en giltig löneperiod, kan inte beräkna {0}."
DocType: Leave Block List,Leave Block List Allowed,Lämna Block List tillåtna
DocType: Grading Scale Interval,Grading Scale Interval,Bedömningsskala Intervall
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim for Vehicle Log {0},Räkningen för fordons Log {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Rabatt (%) på prislista med marginal
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Rabatt (%) på prislista med marginal
DocType: Healthcare Service Unit Type,Rate / UOM,Betygsätt / UOM
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,alla Lager
apps/erpnext/erpnext/hooks.py,Appointment Booking,Bokning av möten
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Nej {0} hittades för Inter Company Transactions.
DocType: Travel Itinerary,Rented Car,Hyrbil
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your Company,Om ditt företag
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Stock Ageing Data,Visa lagringsalternativ
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Tack till kontot måste vara ett balanskonto
DocType: Donor,Donor,Givare
apps/erpnext/erpnext/regional/doctype/gst_hsn_code/gst_hsn_code.js,Update Taxes for Items,Uppdatera skatter för objekt
DocType: Global Defaults,Disable In Words,Inaktivera uttrycker in
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},Offert {0} inte av typen {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Underhållsschema Produkt
DocType: Sales Order,%  Delivered,% Levereras
apps/erpnext/erpnext/education/doctype/fees/fees.js,Please set the Email ID for the Student to send the Payment Request,Ange e-postadressen för studenten för att skicka betalningsförfrågan
DocType: Skill,Skill Name,färdighetsnamn
DocType: Patient,Medical History,Medicinsk historia
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,Checkräknings konto
DocType: Patient,Patient ID,Patient ID
DocType: Practitioner Schedule,Schedule Name,Schema namn
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please enter GSTIN and state for the Company Address {0},Ange GSTIN och ange för företagets adress {0}
DocType: Currency Exchange,For Buying,För köp
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Vid inlämning av inköpsorder
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Lägg till alla leverantörer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rad # {0}: Tilldelad mängd kan inte vara större än utestående belopp.
DocType: Tally Migration,Parties,parterna
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Bläddra BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Säkrade lån
DocType: Purchase Invoice,Edit Posting Date and Time,Redigera Publiceringsdatum och tid
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Ställ Avskrivningar relaterade konton i tillgångsslag {0} eller Company {1}
DocType: Lab Test Groups,Normal Range,Normal Range
DocType: Call Log,Call Duration in seconds,Samtalstid i sekunder
DocType: Academic Term,Academic Year,Akademiskt år
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,Tillgänglig försäljning
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Återbetalning av lojalitetspoäng
apps/erpnext/erpnext/config/accounts.py,Cost Center and Budgeting,Kostnadscentrum och budgetering
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Ingående balans kapital
DocType: Appointment,CRM,CRM
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,Ställ in betalningsschemat
DocType: Pick List,Items under this warehouse will be suggested,Föremål under detta lager kommer att föreslås
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,Återstående
DocType: Appraisal,Appraisal,Värdering
DocType: Loan,Loan Account,Lånekonto
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Giltiga från och giltiga upp till fält är obligatoriska för det kumulativa
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,"For item {0} at row {1}, count of serial numbers does not match with the picked quantity",För artikel {0} i rad {1} stämmer inte serienumret med det utvalda antalet
DocType: Purchase Invoice,GST Details,GST-detaljer
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,Detta bygger på transaktioner mot denna vårdgivare.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},E-post som skickas till leverantören {0}
DocType: Item,Default Sales Unit of Measure,Standardförsäljningsenhet av åtgärd
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,Akademisk - år:
DocType: Inpatient Record,Admission Schedule Date,Datum för tillträde
DocType: Subscription,Past Due Date,Förfallodagen
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Tillåt inte att ange alternativ objekt för objektet {0}
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum upprepas
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Firmatecknare
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC tillgängligt (A) - (B)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Skapa avgifter
DocType: Project,Total Purchase Cost (via Purchase Invoice),Totala inköpskostnaden (via inköpsfaktura)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Välj antal
DocType: Loyalty Point Entry,Loyalty Points,Lojalitetspoäng
DocType: Customs Tariff Number,Customs Tariff Number,Tulltaxan Nummer
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Maximalt undantagsbelopp
DocType: Products Settings,Item Fields,Objektfält
DocType: Patient Appointment,Patient Appointment,Patientavnämning
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving Role cannot be same as role the rule is Applicable To,Godkännande Roll kan inte vara samma som roll regel är tillämplig på
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Unsubscribe from this Email Digest,Avbeställa Facebook Twitter Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Få leverantörer av
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for Item {1},{0} hittades inte för objekt {1}
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},Värdet måste vara mellan {0} och {1}
DocType: Accounts Settings,Show Inclusive Tax In Print,Visa inklusiv skatt i tryck
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,"Bank Account, From Date and To Date are Mandatory","Bankkonto, från-datum och till-datum är obligatoriska"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,Meddelande Skickat
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,Konto med underordnade noder kan inte ställas in som huvudbok
DocType: C-Form,II,II
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Vendor Name,Leverantörsnamn
DocType: Quiz Result,Wrong,Fel
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,I takt med vilket Prislistans valuta omvandlas till kundens basvaluta
DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobelopp (Företagsvaluta)
DocType: Sales Partner,Referral Code,Hänvisningskod
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Det totala förskottsbeloppet får inte vara större än det totala sanktionerade beloppet
DocType: Salary Slip,Hour Rate,Tim värde
apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Aktivera automatisk ombeställning
DocType: Stock Settings,Item Naming By,Produktnamn Genom
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},En annan period Utgående anteckning {0} har gjorts efter {1}
DocType: Work Order,Material Transferred for Manufacturing,Material Överfört för tillverkning
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,Konto {0} existerar inte
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,Välj Lojalitetsprogram
DocType: Project,Project Type,Projekt Typ
apps/erpnext/erpnext/projects/doctype/task/task.py,Child Task exists for this Task. You can not delete this Task.,Barnuppgift finns för denna uppgift. Du kan inte ta bort denna uppgift.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,Antingen mål antal eller målbeloppet är obligatorisk.
apps/erpnext/erpnext/config/projects.py,Cost of various activities,Kostnader för olika aktiviteter
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Inställning Händelser till {0}, eftersom personal bifogas nedan försäljare inte har en användar-ID {1}"
DocType: Timesheet,Billing Details,Faktureringsuppgifter
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,Källa och mål lager måste vara annorlunda
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Betalning misslyckades. Kontrollera ditt GoCardless-konto för mer information
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},Ej tillåtet att uppdatera lagertransaktioner äldre än {0}
DocType: Stock Entry,Inspection Required,Inspektion krävs
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,Ange bankgarantienummer innan du skickar in.
DocType: Sales Order,Fully Billed,Fullt fakturerad
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order cannot be raised against a Item Template,Arbetsorder kan inte höjas mot en objektmall
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,Fraktregel gäller endast för köp
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Cash In Hand,Kontant i hand
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},Leverans lager som krävs för Beställningsvara {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruttovikten på paketet. Vanligtvis nettovikt + förpackningsmaterial vikt. (För utskrift)
DocType: Assessment Plan,Program,Program
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Användare med den här rollen får ställa frysta konton och skapa / ändra bokföringsposter mot frysta konton
DocType: Plaid Settings,Plaid Environment,Plädmiljö
,Project Billing Summary,Projekt faktureringsöversikt
DocType: Vital Signs,Cuts,Cuts
DocType: Serial No,Is Cancelled,Är Inställd
DocType: Student Group,Group Based On,Grupp baserad på
DocType: Student Group,Group Based On,Grupp baserad på
DocType: Journal Entry,Bill Date,Faktureringsdatum
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratory SMS Alerts
DocType: Manufacturing Settings,Over Production for Sales and Work Order,Överproduktion för försäljning och arbetsorder
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,"Service Item,Type,frequency and expense amount are required","SERVICE, typ, frekvens och omkostnadsbelopp krävs"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Även om det finns flera prissättningsregler med högsta prioritet, kommer följande interna prioriteringar tillämpas:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Plantanalys Kriterier
DocType: Cheque Print Template,Cheque Height,Check Höjd
DocType: Supplier,Supplier Details,Leverantör Detaljer
DocType: Setup Progress,Setup Progress,Setup Progress
DocType: Expense Claim,Approval Status,Godkännandestatus
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Från Talet måste vara lägre än värdet i rad {0}
DocType: Program,Intro Video,Introduktionsvideo
DocType: Manufacturing Settings,Default Warehouses for Production,Standardlager för produktion
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Wire Transfer,Elektronisk Överföring
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,From Date must be before To Date,Från Datum måste vara före Till Datum
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,Kontrollera alla
,Issued Items Against Work Order,Utgivna poster mot arbetsorder
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Vacancies cannot be lower than the current openings,Lediga platser kan inte vara lägre än nuvarande öppningar
,BOM Stock Calculated,BOM lager beräknad
DocType: Vehicle Log,Invoice Ref,faktura Ref
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Utgående leveranser utan GST
DocType: Company,Default Income Account,Standard Inkomstkonto
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Patient History,Patienthistoria
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),Oavslutade räkenskapsår Vinst / Förlust (Credit)
DocType: Sales Invoice,Time Sheets,tidrapporter
DocType: Healthcare Service Unit Type,Change In Item,Ändra i artikel
DocType: Payment Gateway Account,Default Payment Request Message,Standardbetalnings Request Message
DocType: Retention Bonus,Bonus Amount,Bonusbelopp
DocType: Item Group,Check this if you want to show in website,Markera det här om du vill visa i hemsida
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Balance ({0}),Balans ({0})
DocType: Loyalty Point Entry,Redeem Against,Lösa in mot
apps/erpnext/erpnext/config/accounts.py,Banking and Payments,Bank- och betalnings
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Vänligen ange API-konsumentnyckel
DocType: Issue,Service Level Agreement Fulfilled,Servicenivåavtal uppfyllt
,Welcome to ERPNext,Välkommen till oss
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Prospekt till offert
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email Reminders will be sent to all parties with email contacts,E-post påminnelser skickas till alla parter med e-postkontakter
DocType: Project,Twice Daily,Två gånger dagligen
DocType: Inpatient Record,A Negative,En negativ
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,Inget mer att visa.
DocType: Lead,From Customer,Från Kunden
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,Samtal
DocType: Employee Tax Exemption Declaration,Declarations,deklarationer
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,partier
DocType: Appointment Booking Settings,Number of days appointments can be booked in advance,Antal dagars möten kan bokas i förväg
DocType: Article,LMS User,LMS-användare
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Leveransplats (staten / UT)
DocType: Purchase Order Item Supplied,Stock UOM,Lager UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Inköpsorder {0} inte lämnad
DocType: Account,Expenses Included In Asset Valuation,Kostnader som ingår i tillgångsvärdet
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalt referensområde för en vuxen är 16-20 andetag / minut (RCP 2012)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Set Response Time and Resolution for Priority {0} at index {1}.,Ställ in responstid och upplösning för prioritet {0} vid index {1}.
DocType: Customs Tariff Number,Tariff Number,tariff Number
DocType: Work Order Item,Available Qty at WIP Warehouse,Tillgänglig mängd vid WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,Projicerad
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},Serienummer {0} tillhör inte Lager {1}
apps/erpnext/erpnext/controllers/status_updater.py,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Obs: Systemet kommer inte att kontrollera över leverans och överbokning till punkt {0} då kvantitet eller belopp är 0
DocType: Issue,Opening Date,Öppningsdatum
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Spara patienten först
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Närvaro har markerats med framgång.
DocType: Program Enrollment,Public Transport,Kollektivtrafik
DocType: Sales Invoice,GST Vehicle Type,GST fordonstyp
DocType: Soil Texture,Silt Composition (%),Siltkomposition (%)
DocType: Journal Entry,Remark,Anmärkning
DocType: Healthcare Settings,Avoid Confirmation,Undvik bekräftelse
DocType: Bank Account,Integration Details,Integrationsdetaljer
DocType: Purchase Receipt Item,Rate and Amount,Andel och Belopp
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account Type for {0} must be {1},Kontotyp för {0} måste vara {1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Calculate Arrival Time as Driver Address is Missing.,Det går inte att beräkna ankomsttiden eftersom förarens adress saknas.
DocType: Education Settings,Current Academic Term,Nuvarande akademisk term
DocType: Education Settings,Current Academic Term,Nuvarande akademisk term
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Rad # {0}: Objekt tillagda
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Service Start Date cannot be greater than Service End Date,Rad # {0}: Service-startdatum kan inte vara större än slutdatum för service
DocType: Sales Order,Not Billed,Inte Billed
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,Både Lagren måste tillhöra samma företag
DocType: Employee Grade,Default Leave Policy,Standardavgångspolicy
DocType: Shopify Settings,Shop URL,Shop URL
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a debtor bank transaction,Den valda betalningsuppgiften bör kopplas till en gäldenärstransaktion
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,Inga kontakter inlagda ännu.
DocType: Communication Medium Timeslot,Communication Medium Timeslot,Kommunikation Medium Timeslot
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Landad Kostnad rabattmängd
,Item Balance (Simple),Artikelbalans (Enkel)
apps/erpnext/erpnext/config/accounts.py,Bills raised by Suppliers.,Räkningar som framförts av leverantörer.
DocType: POS Profile,Write Off Account,Avskrivningskonto
DocType: Patient Appointment,Get prescribed procedures,Få föreskrivna förfaranden
DocType: Sales Invoice,Redemption Account,Inlösenkonto
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,First add items in the Item Locations table,Lägg först till objekt i tabellen Objektplatser
DocType: Pricing Rule,Discount Amount,Rabattbelopp
DocType: Pricing Rule,Period Settings,Periodinställningar
DocType: Purchase Invoice,Return Against Purchase Invoice,Återgå mot inköpsfaktura
DocType: Item,Warranty Period (in days),Garantitiden (i dagar)
DocType: Shift Type,Enable Entry Grace Period,Aktivera ingångsperioden
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Relation med Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Var god välj BOM mot artikel {0}
DocType: Shopping Cart Settings,Show Stock Quantity,Visa lager Antal
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Netto kassaflöde från rörelsen
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Rad # {0}: Status måste vara {1} för fakturabidrag {2}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Produkt  4
DocType: Student Admission,Admission End Date,Antagning Slutdatum
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Underleverantörer
DocType: Journal Entry Account,Journal Entry Account,Journalanteckning konto
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,Student-gruppen
DocType: Shopping Cart Settings,Quotation Series,Offert Serie
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,"An item exists with same name ({0}), please change the item group name or rename the item","Ett objekt finns med samma namn ({0}), ändra objektets varugrupp eller byt namn på objektet"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriterier för markanalys
DocType: Pricing Rule Detail,Pricing Rule Detail,Prissättningsdetalj
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Skapa BOM
DocType: Pricing Rule,Apply Rule On Item Group,Tillämpa regel om artikelgrupp
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,Välj kund
DocType: Employee Tax Exemption Declaration,Total Declared Amount,Totalt deklarerat belopp
DocType: C-Form,I,jag
DocType: Company,Asset Depreciation Cost Center,Avskrivning kostnadsställe
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,{0} objekt hittades.
DocType: Production Plan Sales Order,Sales Order Date,Kundorder Datum
DocType: Sales Invoice Item,Delivered Qty,Levererat Antal
DocType: Assessment Plan,Assessment Plan,Bedömningsplan
DocType: Travel Request,Fully Sponsored,Fullt sponsrad
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Skapa jobbkort
DocType: Quotation,Referral Sales Partner,Referensförsäljningspartner
DocType: Quality Procedure Process,Process Description,Metodbeskrivning
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Kund {0} är skapad.
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,För närvarande finns inget på lager i något lager.
,Payment Period Based On Invoice Date,Betalningstiden Baserad på Fakturadatum
DocType: Sample Collection,No. of print,Antal utskrivningar
apps/erpnext/erpnext/education/doctype/question/question.py,No correct answer is set for {0},Inget korrekt svar är inställt för {0}
DocType: Issue,Response By,Svar av
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Födelsedag Påminnelse
DocType: Chart of Accounts Importer,Chart Of Accounts Importer,Diagram över kontonimportör
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Hotell Rum Bokningsartikel
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Missing Currency Exchange Rates for {0},Saknas valutakurser för {0}
DocType: Employee Health Insurance,Health Insurance Name,Sjukförsäkringsnamn
DocType: Assessment Plan,Examiner,Examinator
DocType: Student,Siblings,Syskon
DocType: Journal Entry,Stock Entry,Stock Entry
DocType: Payment Entry,Payment References,betalnings~~POS=TRUNC Referenser
DocType: Subscription Plan,"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Antal intervaller för intervallfältet, t ex om intervallet är &quot;dagar&quot; och faktureringsintervalsräkning är 3, fakturor kommer att genereras var tredje dag"
DocType: Clinical Procedure Template,Allow Stock Consumption,Tillåt lagerkonsumtion
DocType: Asset,Insurance Details,Insurance Information
DocType: Account,Payable,Betalning sker
DocType: Share Balance,Share Type,Share Type
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,Ange återbetalningstider
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Gäldenär ({0})
DocType: Pricing Rule,Margin,Marginal
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,Nya kunder
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,Bruttovinst%
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,Avtal {0} och Försäljningsfaktura {1} avbröts
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,Möjligheter med blykälla
DocType: Appraisal Goal,Weightage (%),Vikt (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Ändra POS-profil
DocType: Bank Reconciliation Detail,Clearance Date,Clearance Datum
DocType: Delivery Settings,Dispatch Notification Template,Dispatch Notification Template
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Utvärderingsrapport
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Få anställda
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Add your review,Lägg till din recension
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Bruttoköpesumma är obligatorisk
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,Företagets namn är inte samma
DocType: Sales Partner,Address Desc,Adress fallande
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,Party är obligatoriskt
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please set account heads in GST Settings for Compnay {0},Ange kontohuvud i GST-inställningar för Compnay {0}
DocType: Course Topic,Topic Name,ämnet Namn
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,Ange standardmall för meddelandet om godkännandet av godkännande i HR-inställningar.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,Minst en av de sålda eller köpta måste väljas
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Select an employee to get the employee advance.,Välj en anställd för att få arbetstagaren att gå vidare.
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Var god välj ett giltigt datum
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,Välj typ av ditt företag.
DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
<br>
Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
<br>
Descriptive for tests which have multiple result components and corresponding result entry fields. 
<br>
Grouped for test templates which are a group of other test templates.
<br>
No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Enstaka för resultat som endast kräver en enda ingång, resultat UOM och normalvärde <br> Sammansatt för resultat som kräver flera inmatningsfält med motsvarande händelse namn, resultat UOM och normala värden <br> Beskrivande för test som har flera resultatkomponenter och motsvarande resultatinmatningsfält. <br> Grupperas för testmallar som är en grupp andra testmallar. <br> Inget resultat för tester utan resultat. Dessutom skapas inget labtest. t.ex. Delprov för grupperade resultat."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},Rad # {0}: Duplikat post i referenser {1} {2}
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,Där tillverkningsprocesser genomförs.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Examiner,Som granskare
DocType: Company,Default Expense Claim Payable Account,Standardkostnadskrav Betalningsbart konto
DocType: Appointment Type,Default Duration,Standardlängd
DocType: BOM Explosion Item,Source Warehouse,Källa Lager
DocType: Installation Note,Installation Date,Installations Datum
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,Dela Ledger
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Försäljningsfaktura {0} skapad
DocType: Employee,Confirmation Date,Bekräftelsedatum
DocType: Inpatient Occupancy,Check Out,Checka ut
DocType: C-Form,Total Invoiced Amount,Sammanlagt fakturerat belopp
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,Min Antal kan inte vara större än Max Antal
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Account,Accumulated Depreciation,Ackumulerade avskrivningar
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stående namn
DocType: Stock Entry,Customer or Supplier Details,Kund eller leverantör Detaljer
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Asset Value Adjustment,Current Asset Value,Nuvarande tillgångsvärde
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {1},BOM-rekursion: {0} kan inte vara förälder eller barn till {1}
DocType: QuickBooks Migrator,Quickbooks Company ID,QuickBooks företags-ID
DocType: Travel Request,Travel Funding,Resefinansiering
DocType: Employee Skill,Proficiency,Skicklighet
DocType: Loan Application,Required by Date,Krävs Datum
DocType: Purchase Invoice Item,Purchase Receipt Detail,Köp kvitto detalj
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,En länk till alla platser där grödor växer
DocType: Lead,Lead Owner,Prospekt ägaren
DocType: Bin,Requested Quantity,begärda Kvantitet
DocType: Pricing Rule,Party Information,Partiinformation
DocType: Fees,EDU-FEE-.YYYY.-,EDU-fee-.YYYY.-
DocType: Patient,Marital Status,Civilstånd
DocType: Stock Settings,Auto Material Request,Automaterialförfrågan
DocType: Woocommerce Settings,API consumer secret,API konsumenthemlighet
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Finns Batch Antal på From Warehouse
,Received Qty Amount,Mottaget antal belopp
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Summa Avdrag - Loan Återbetalning
DocType: Bank Account,Last Integration Date,Sista integrationsdatum
DocType: Expense Claim,Expense Taxes and Charges,Kostnadsskatter och avgifter
DocType: Bank Account,IBAN,IBAN
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,Aktuell BOM och Nya BOM kan inte vara samma
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,Lön Slip ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,Datum för pensionering måste vara större än Datum för att delta
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Flera varianter
DocType: Sales Invoice,Against Income Account,Mot Inkomst konto
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% Levererad
DocType: Subscription,Trial Period Start Date,Försöksperiodens startdatum
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Produkt  {0}: Beställd st {1} kan inte vara mindre än minimiorder st {2} (definierat i punkt).
DocType: Certification Application,Certified,Auktoriserad
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Månadsdistributions Procent
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,Parti kan bara vara ett av
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,Vänligen nämna Basic och HRA-komponenten i företaget
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Daglig Arbets Sammanfattning Grupp Användare
DocType: Territory,Territory Targets,Territorium Mål
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Sales Invoice,Transporter Info,Transporter info
apps/erpnext/erpnext/accounts/utils.py,Please set default {0} in Company {1},Ställ in default {0} i bolaget {1}
DocType: Cheque Print Template,Starting position from top edge,Utgångsläge från övre kanten
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Same supplier has been entered multiple times,Samma leverantör har angetts flera gånger
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Brutto Vinst / Förlust
,Warehouse wise Item Balance Age and Value,Lagerklassigt objekt Balansålder och värde
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Uppnått ({})
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Inköpsorder Artikelleverans
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,Företagsnamn kan inte vara företag
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,{0} -parametern är ogiltig
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Brevhuvuden för utskriftsmallar.
apps/erpnext/erpnext/config/settings.py,Titles for print templates e.g. Proforma Invoice.,Titlar för utskriftsmallar t.ex. Proforma faktura.
DocType: Program Enrollment,Walking,Gående
DocType: Student Guardian,Student Guardian,Student Guardian
DocType: Member,Member Name,Medlemsnamn
DocType: Stock Settings,Use Naming Series,Använd Naming Series
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,Ingen action
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,Värderingsavgifter kan inte markerats som inklusive
DocType: POS Profile,Update Stock,Uppdatera lager
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,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.,Olika UOM för produkter kommer att leda till felaktiga (Total) Nettovikts värden. Se till att Nettovikt för varje post är i samma UOM.
DocType: Certification Application,Payment Details,Betalningsinformation
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM betyg
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Läser uppladdad fil
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stoppad Arbetsorder kan inte avbrytas, Avbryt den först för att avbryta"
DocType: Coupon Code,Coupon Code,kupongskod
DocType: Asset,Journal Entry for Scrap,Journal Entry för skrot
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Vänligen hämta artikel från följesedel
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Rad {0}: välj arbetsstation mot operationen {1}
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,Journalanteckningar {0} är ej länkade
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0} nummer {1} används redan i konto {2}
apps/erpnext/erpnext/config/crm.py,"Record of all communications of type email, phone, chat, visit, etc.","Register över alla meddelanden av typen e-post, telefon, chatt, besök, etc."
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Leverantör Scorecard Scoring Standing
DocType: Manufacturer,Manufacturers used in Items,Tillverkare som används i artiklar
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,Ange kostnadsställe för avrundning i bolaget
DocType: Purchase Invoice,Terms,Villkor
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Välj dagar
DocType: Academic Term,Term Name,termen Namn
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},Rad {0}: Ange rätt kod på betalningsmetod {1}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),Kredit ({0})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,Skapa lönesedlar ...
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Du kan inte redigera rotknutpunkt.
DocType: Buying Settings,Purchase Order Required,Inköpsorder krävs
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,Timer
,Item-wise Sales History,Produktvis försäljnings historia
DocType: Expense Claim,Total Sanctioned Amount,Totalt sanktione Mängd
,Purchase Analytics,Inköps analyser
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Total flexible benefit component amount {0} should not be less than max benefits {1},Det totala beloppet för flexibel förmån {0} bör inte vara mindre än maxförmåner {1}
DocType: Sales Invoice Item,Delivery Note Item,Följesedel Anteckningspunkt
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,Nuvarande faktura {0} saknas
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: user has not applied the rule {1} on the item {2},Rad {0}: användaren har inte använt regeln {1} på artikeln {2}
DocType: Asset Maintenance Log,Task,Uppgift
DocType: Purchase Taxes and Charges,Reference Row #,Referens Rad #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Batch number is mandatory for Item {0},Batchnummer är obligatoriskt för punkt {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,Detta är en rot säljare och kan inte ändras.
DocType: Salary Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Om det är valt, kommer det angivna eller beräknade värdet i denna komponent inte att bidra till vinst eller avdrag. Men det är värdet kan hänvisas till av andra komponenter som kan läggas till eller dras av."
DocType: Salary Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Om det är valt, kommer det angivna eller beräknade värdet i denna komponent inte att bidra till vinst eller avdrag. Det är dock värdet kan hänvisas till av andra komponenter som kan läggas till eller dras av."
,Stock Ledger,Stock Ledger
DocType: Company,Exchange Gain / Loss Account,Exchange vinst / förlust konto
DocType: Amazon MWS Settings,MWS Credentials,MWS Credentials
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Filtorder från kunder.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},Syfte måste vara en av {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,Fyll i formuläret och spara det
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,Community Forum
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Faktisk antal i lager
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Faktisk antal i lager
DocType: Homepage,"URL for ""All Products""",URL för &quot;Alla produkter&quot;
DocType: Leave Application,Leave Balance Before Application,Ledighets balans innan Ansökan
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,Skicka SMS
DocType: Supplier Scorecard Criteria,Max Score,Max poäng
DocType: Cheque Print Template,Width of amount in word,Bredd av beloppet i ord
DocType: Purchase Order,Get Items from Open Material Requests,Få Artiklar från Open Material Begäran
DocType: Hotel Room Amenity,Billable,Fakturerbar
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Ordered Qty: Quantity ordered for purchase, but not received.","Beställd kvantitet: Kvantitet beställt för köp, men inte mottaget."
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,Behandling av konton och parter
DocType: Lab Test Template,Standard Selling Rate,Standard säljkurs
DocType: Account,Rate at which this tax is applied,I takt med vilken denna skatt tillämpas
DocType: Cash Flow Mapper,Section Name,Avsnittsnamn
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Reorder Qty,Ombeställningskvantitet
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Avskrivningsraden {0}: Förväntat värde efter nyttjandeperioden måste vara större än eller lika med {1}
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Nuvarande jobb Öppningar
DocType: Company,Stock Adjustment Account,Lager Justering Konto
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Avskrivning
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure.py,{0} already has a Parent Procedure {1}.,{0} har redan en överordnad procedur {1}.
DocType: Healthcare Service Unit,Allow Overlap,Tillåt överlappning
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Operation ID,Drift-ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Systemanvändare (inloggning) ID. Om inställt, kommer det att bli standard för alla HR former."
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Enter depreciation details,Ange avskrivningsuppgifter
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}: Från {1}
DocType: Bank Transaction Mapping,Column in Bank File,Kolumn i bankfil
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Lämna ansökan {0} finns redan mot studenten {1}
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Köpt för uppdatering av senaste priset i allt material. Det kan ta några minuter.
DocType: Pick List,Get Item Locations,Hämta objektplatser
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Namn på ett nytt konto. Obs: Vänligen inte skapa konton för kunder och leverantörer
DocType: POS Profile,Display Items In Stock,Visa artiklar i lager
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,Landsvis standard adressmallar
DocType: Payment Order,Payment Order Reference,Betalningsorderreferens
DocType: Water Analysis,Appearance,Utseende
DocType: HR Settings,Leave Status Notification Template,Meddelandemall för status för meddelanden
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,Avg. Prislista för köpprislista
DocType: Sales Order Item,Supplier delivers to Customer,Leverantören levererar till kunden
apps/erpnext/erpnext/config/non_profit.py,Member information.,Medlemsinformation.
DocType: Identification Document Type,Identification Document Type,Identifikationsdokumenttyp
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form/Objekt/{0}) är slut i lager
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Asset Maintenance
,Sales Payment Summary,Försäljningsbetalningssammanfattning
DocType: Restaurant,Restaurant,Restaurang
DocType: Woocommerce Settings,API consumer key,API-konsumentnyckel
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&quot;Datum&quot; krävs
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},På grund / Referens Datum kan inte vara efter {0}
apps/erpnext/erpnext/config/settings.py,Data Import and Export,Data Import och export
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Ledsen, giltighetskupongkoden har gått ut"
DocType: Bank Account,Account Details,Kontouppgifter
DocType: Crop,Materials Required,Material krävs
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Inga studenter Funnet
DocType: Employee Tax Exemption Declaration,Monthly HRA Exemption,Månadlig HRA-undantag
DocType: Clinical Procedure,Medical Department,Medicinska avdelningen
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Early Exits,Totala tidiga utgångar
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Leverantör Scorecard Scoring Criteria
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,Fakturabokningsdatum
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,Sälja
DocType: Purchase Invoice,Rounded Total,Avrundat Totalt
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,Slots för {0} läggs inte till i schemat
DocType: Product Bundle,List items that form the package.,Lista objekt som bildar paketet.
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required while transferring Asset {0},Målplats krävs vid överföring av tillgång {0}
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,Inte tillåten. Avaktivera testmallen
DocType: Sales Invoice,Distance (in km),Avstånd (i km)
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Procentuell Fördelning bör vara lika med 100%
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,Välj bokningsdatum innan du väljer Party
apps/erpnext/erpnext/config/accounts.py,Payment Terms based on conditions,Betalningsvillkor baserade på villkor
DocType: Program Enrollment,School House,School House
DocType: Serial No,Out of AMC,Slut på AMC
DocType: Opportunity,Opportunity Amount,Opportunity Amount
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Profile,Din profil
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Antal Avskrivningar bokat kan inte vara större än Totalt antal Avskrivningar
DocType: Purchase Order,Order Confirmation Date,Orderbekräftelsedatum
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Alla produkter
DocType: Employee Transfer,Employee Transfer Details,Anställningsöverföringsdetaljer
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please contact to the user who have Sales Master Manager {0} role,Vänligen kontakta för användaren som har roll försäljningschef {0}
DocType: Company,Default Cash Account,Standard Konto
DocType: Issue,Ongoing,Pågående
apps/erpnext/erpnext/config/accounts.py,Company (not Customer or Supplier) master.,Företag (inte kund eller leverantör) ledare.
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,This is based on the attendance of this Student,Detta grundar sig på närvaron av denna Student
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,Inga studenter i
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Lägga till fler objekt eller öppna fullständiga formen
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Följesedelsnoteringar {0} måste avbrytas innan du kan avbryta denna kundorder
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Betald belopp + Avskrivningsbelopp kan inte vara större än Totalsumma
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} är inte ett giltigt batchnummer för objekt {1}
apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Ange giltig kupongkod !!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Obs: Det finns inte tillräckligt med ledighetdagar för ledighet typ {0}
DocType: Task,Task Description,Uppgifts beskrivning
DocType: Training Event,Seminar,Seminarium
DocType: Program Enrollment Fee,Program Enrollment Fee,Program inskrivningsavgift
DocType: Item,Supplier Items,Leverantör artiklar
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
DocType: Opportunity,Opportunity Type,Möjlighet Typ
DocType: Asset Movement Item,To Employee,Till anställd
DocType: Employee Transfer,New Company,Nytt företag
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Transaktioner kan bara tas bort av skaparen av bolaget
apps/erpnext/erpnext/accounts/general_ledger.py,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Felaktigt antal Huvudböcker funna. Du kan ha valt fel konto i transaktionen.
DocType: Employee,Prefered Contact Email,Föredragen Kontakta E-post
DocType: Cheque Print Template,Cheque Width,Check Bredd
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Validera försäljningspriset för punkt mot Purchase Rate eller Värderings Rate
DocType: Fee Schedule,Fee Schedule,avgift Schema
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Kolumnetiketter:
DocType: Bank Transaction,Settled,Fast
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursement Date cannot be after Loan Repayment Start Date,Utbetalningsdatum kan inte vara efter startdatum för återbetalning av lån
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,Cess
DocType: Quality Feedback,Parameters,parametrar
DocType: Company,Create Chart Of Accounts Based On,Skapa konto Baserad på
apps/erpnext/erpnext/education/doctype/student/student.py,Date of Birth cannot be greater than today.,Födelsedatum kan inte vara längre fram än i dag.
,Stock Ageing,Lager Åldrande
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Delvis sponsrad, kräver delfinansiering"
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},Student {0} finns mot elev sökande {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Avrundningsjustering (företagsvaluta)
apps/erpnext/erpnext/projects/doctype/task/task.js,Timesheet,tidrapport
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,Sats:
DocType: Volunteer,Afternoon,Eftermiddag
DocType: Loyalty Program,Loyalty Program Help,Lojalitetsprogram Hjälp
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0} {1} &quot;är inaktiverad
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,Ange som Open
DocType: Cheque Print Template,Scanned Cheque,skannad Check
DocType: Timesheet,Total Billable Amount,Totala Fakturerbar Mängd
DocType: Customer,Credit Limit and Payment Terms,Kreditgräns och betalningsvillkor
DocType: Loyalty Program,Collection Rules,Samlingsregler
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,Produkt 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,Order Entry,Orderläggning
DocType: Purchase Order,Customer Contact Email,Kundkontakt Email
DocType: Warranty Claim,Item and Warranty Details,Punkt och garantiinformation
DocType: Chapter,Chapter Members,Kapitelmedlemmar
DocType: Sales Team,Contribution (%),Bidrag (%)
apps/erpnext/erpnext/controllers/accounts_controller.py,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Obs: Betalningpost kommer inte skapas eftersom ""Kontanter eller bankkonto"" angavs inte"
DocType: Clinical Procedure,Nursing User,Sjuksköterska användare
DocType: Employee Benefit Application,Payroll Period,Löneperiod
DocType: Plant Analysis,Plant Analysis Criterias,Plantanalyskriterier
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Batch {1},Serienummer {0} hör inte till batch {1}
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Din e-postadress...
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,Ansvarsområden
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Validity period of this quotation has ended.,Giltighetstiden för denna offert har upphört.
DocType: Expense Claim Account,Expense Claim Account,Räkningen konto
DocType: Account,Capital Work in Progress,Kapitalarbete pågår
DocType: Accounts Settings,Allow Stale Exchange Rates,Tillåt inaktuella valutakurser
DocType: Sales Person,Sales Person Name,Försäljnings Person Namn
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,Please enter atleast 1 invoice in the table,Ange minst 1 faktura i tabellen
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,Inget labtest skapat
DocType: POS Item Group,Item Group,Produkt Grupp
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Studentgrupp:
DocType: Depreciation Schedule,Finance Book Id,Finans bok ID
DocType: Item,Safety Stock,Säkerhetslager
DocType: Healthcare Settings,Healthcare Settings,Sjukvård Inställningar
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Totalt tilldelade blad
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,Framsteg% för en uppgift kan inte vara mer än 100.
DocType: Stock Reconciliation Item,Before reconciliation,Innan avstämning
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},Till {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Skatter och avgifter Added (Company valuta)
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Produkt Skatte Rad {0} måste ha typen Skatt eller intäkt eller kostnad eller Avgiftsbelagd
DocType: Sales Order,Partly Billed,Delvis Faktuerard
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a Fixed Asset Item,Punkt {0} måste vara en fast tillgångspost
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
DocType: Item,Default BOM,Standard BOM
DocType: Project,Total Billed Amount (via Sales Invoices),Totalt fakturerat belopp (via försäljningsfakturor)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,Debiteringsnotering Belopp
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,"There are inconsistencies between the rate, no of shares and the amount calculated","Det finns inkonsekvenser mellan räntan, antal aktier och beräknat belopp"
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,You are not present all day(s) between compensatory leave request days,Du är inte närvarande hela dagen mellan utbetalningsdagar
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,Vänligen ange företagsnamn igen för att bekräfta
DocType: Journal Entry,Printing Settings,Utskriftsinställningar
DocType: Payment Order,Payment Order Type,Betalningsorder Typ
DocType: Employee Advance,Advance Account,Förskottskonto
DocType: Job Offer,Job Offer Terms,Villkor för erbjudandet
DocType: Sales Invoice,Include Payment (POS),Inkluderar Betalning (POS)
DocType: Shopify Settings,eg: frappe.myshopify.com,t.ex. frappe.myshopify.com
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement tracking is not enabled.,Spårning av servicenivåavtal är inte aktiverat.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Debit must be equal to Total Credit. The difference is {0},Totalt Betal måste vara lika med de sammanlagda kredit. Skillnaden är {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Automotive,Fordon
DocType: Vehicle,Insurance Company,Försäkringsbolag
DocType: Asset Category Account,Fixed Asset Account,Fast tillgångskonto
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,Variabel
apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Skatteordning är obligatoriskt, ange skatteordningen i företaget {0}"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,Från Följesedel
DocType: Chapter,Members,medlemmar
DocType: Student,Student Email Address,Student E-postadress
DocType: Item,Hub Warehouse,Hub Warehouse
DocType: Appointment Booking Slots,From Time,Från Tid
DocType: Hotel Settings,Hotel Settings,Hotellinställningar
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,I lager:
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Investment Banking
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cash or Bank Account is mandatory for making payment entry,Kontant eller bankkonto är obligatoriskt för utbetalningensposten
DocType: Education Settings,LMS Settings,LMS-inställningar
DocType: Company,Discount Allowed Account,Rabatt tillåtet konto
DocType: Loyalty Program,Multiple Tier Program,Multiple Tier Program
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Studentadress
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Studentadress
DocType: Purchase Invoice,Price List Exchange Rate,Prislista Växelkurs
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Alla Leverantörsgrupper
DocType: Employee Boarding Activity,Required for Employee Creation,Krävs för anställningsskapande
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Leverantör&gt; Leverantörstyp
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Kontonummer {0} som redan används i konto {1}
DocType: GoCardless Mandate,Mandate,Mandat
DocType: Hotel Room Reservation,Booked,bokade
DocType: Detected Disease,Tasks Created,Uppgifter skapade
DocType: Purchase Invoice Item,Rate,Betygsätt
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,Intern
DocType: Coupon Code,"e.g. ""Summer Holiday 2019 Offer 20""",t.ex. &quot;Sommarsemester 2019 Erbjudande 20&quot;
DocType: Delivery Stop,Address Name,Adressnamn
DocType: Stock Entry,From BOM,Från BOM
DocType: Assessment Code,Assessment Code,bedömning kod
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Basic,Grundläggande
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock transactions before {0} are frozen,Arkiv transaktioner före {0} är frysta
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',"Klicka på ""Skapa schema '"
DocType: Job Card,Current Time,Aktuell tid
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No is mandatory if you entered Reference Date,Referensnummer är obligatoriskt om du har angett referens Datum
DocType: Bank Reconciliation Detail,Payment Document,betalning Dokument
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,Fel vid utvärdering av kriterierna
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,Datum för att delta måste vara större än Födelsedatum
DocType: Subscription,Plans,Plans
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,Öppningsbalans
DocType: Salary Slip,Salary Structure,Lönestruktur
DocType: Account,Bank,Bank
DocType: Job Card,Job Started,Jobb började
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,Flygbolag
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,Problem Material
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,Anslut Shopify med ERPNext
DocType: Production Plan,For Warehouse,För Lager
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Leveransnoteringar {0} uppdaterad
DocType: Employee,Offer Date,Erbjudandet Datum
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,Citat
DocType: Purchase Order,Inter Company Order Reference,Inter Company Order Reference
apps/erpnext/erpnext/accounts/page/pos/pos.js,You are in offline mode. You will not be able to reload until you have network.,Du befinner dig i offline-läge. Du kommer inte att kunna ladda tills du har nätverket.
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Rad # {0}: Antalet ökade med 1
DocType: Account,Include in gross,Inkludera i brutto
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant,Bevilja
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,No Student Groups created.,Inga studentgrupper skapas.
DocType: Purchase Invoice Item,Serial No,Serienummer
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Monthly Repayment Amount cannot be greater than Loan Amount,Månatliga återbetalningen belopp kan inte vara större än Lånebelopp
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please enter Maintaince Details first,Ange servicedetaljer först
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Rad # {0}: Förväntad leveransdatum kan inte vara före inköpsdatum
DocType: Purchase Invoice,Print Language,print Språk
DocType: Salary Slip,Total Working Hours,Totala arbetstiden
DocType: Sales Invoice,Customer PO Details,Kundens PO-uppgifter
apps/erpnext/erpnext/education/utils.py,You are not enrolled in program {0},Du är inte registrerad i programmet {0}
DocType: Stock Entry,Including items for sub assemblies,Inklusive poster för underheter
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Tillfälligt öppnings konto
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Varor i transit
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Ange värde måste vara positiv
DocType: Asset,Finance Books,Finansböcker
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Anställningsskattebefrielsedeklarationskategori
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Alla territorierna
DocType: Lost Reason Detail,Lost Reason Detail,Förlorad anledning detalj
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,Vänligen ange lämnarpolicy för anställd {0} i Anställd / betygsrekord
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Ogiltig blankettorder för den valda kunden och föremålet
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Lägg till flera uppgifter
DocType: Purchase Invoice,Items,Produkter
apps/erpnext/erpnext/crm/doctype/contract/contract.py,End Date cannot be before Start Date.,Slutdatum kan inte vara före startdatum.
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,Student är redan inskriven.
DocType: Fiscal Year,Year Name,År namn
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,There are more holidays than working days this month.,Det finns mer semester än arbetsdagar denna månad.
apps/erpnext/erpnext/controllers/buying_controller.py,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Följande poster {0} är inte markerade som {1} objekt. Du kan aktivera dem som {1} -objekt från dess objektmastern
DocType: Production Plan Item,Product Bundle Item,Produktpaket Punkt
DocType: Sales Partner,Sales Partner Name,Försäljnings Partner Namn
apps/erpnext/erpnext/hooks.py,Request for Quotations,Begäran om Citat
DocType: Payment Reconciliation,Maximum Invoice Amount,Maximal Fakturabelopp
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for empty IBAN,BankAccount.validate_iban () misslyckades för tom IBAN
DocType: Normal Test Items,Normal Test Items,Normala testpunkter
DocType: QuickBooks Migrator,Company Settings,Företagsinställningar
DocType: Additional Salary,Overwrite Salary Structure Amount,Skriv över lönestrukturbeloppet
DocType: Leave Ledger Entry,Leaves,Löv
DocType: Student Language,Student Language,Student Språk
DocType: Cash Flow Mapping,Is Working Capital,Är Arbetskapital
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,Skicka in bevis
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Order / Quot%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Order / Quot%
apps/erpnext/erpnext/config/healthcare.py,Record Patient Vitals,Spela in Patient Vitals
DocType: Fee Schedule,Institution,Institution
DocType: Asset,Partially Depreciated,delvis avskrivna
DocType: Issue,Opening Time,Öppnings Tid
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,From and To dates required,Från och Till datum krävs
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,Värdepapper och råvarubörserna
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,Dokumentsökning
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Standard mätenhet för Variant &quot;{0}&quot; måste vara samma som i Mall &quot;{1}&quot;
DocType: Shipping Rule,Calculate Based On,Beräkna baserad på
DocType: Contract,Unfulfilled,Ouppfylld
DocType: Delivery Note Item,From Warehouse,Från Warehouse
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,Inga anställda för nämnda kriterier
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Inga objekt med Bill of Materials att tillverka
DocType: Shopify Settings,Default Customer,Standardkund
DocType: Sales Stage,Stage Name,Artistnamn
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Dataimport och inställningar
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
DocType: Assessment Plan,Supervisor Name,Supervisor Namn
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Bekräfta inte om mötet är skapat för samma dag
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Ship to State
DocType: Program Enrollment Course,Program Enrollment Course,Program Inskrivningskurs
DocType: Invoice Discounting,Bank Charges,Bankavgifter
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},Användaren {0} är redan tilldelad Healthcare Practitioner {1}
DocType: Purchase Taxes and Charges,Valuation and Total,Värdering och Total
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,Förhandling / Review
DocType: Leave Encashment,Encashment Amount,Encashment Amount
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,styrkort
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,Förfallna partier
DocType: Employee,This will restrict user access to other employee records,Detta kommer att begränsa användaråtkomsten till andra anställningsregister
DocType: Tax Rule,Shipping City,Shipping stad
apps/erpnext/erpnext/regional/india/utils.py,GST HSN Code does not exist for one or more items,GST HSN-kod finns inte för en eller flera objekt
DocType: Quality Procedure Table,Step,Steg
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Variance ({}),Varians ({})
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Rate or Discount is required for the price discount.,Pris eller rabatt krävs för prisrabatten.
DocType: Purchase Invoice,Import Of Service,Import av tjänster
DocType: Education Settings,LMS Title,LMS-titel
DocType: Sales Invoice,Ship,Fartyg
DocType: Staffing Plan Detail,Current Openings,Nuvarande öppningar
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Kassaflöde från rörelsen
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,CGST-belopp
apps/erpnext/erpnext/utilities/activation.py,Create Student,Skapa student
DocType: Asset Movement Item,Asset Movement Item,Objektrörelsepost
DocType: Purchase Invoice,Shipping Rule,Frakt Regel
DocType: Patient Relation,Spouse,Make
DocType: Lab Test Groups,Add Test,Lägg till test
DocType: Manufacturer,Limited to 12 characters,Begränsat till 12 tecken
DocType: Journal Entry,Print Heading,Utskrifts Rubrik
DocType: Quality Action Table,Quality Action Table,Kvalitetstabell
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Totalt kan inte vara noll
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,"""Dagar sedan senaste order"" måste vara större än eller lika med noll"
DocType: Plant Analysis Criteria,Maximum Permissible Value,Maximalt tillåtet värde
apps/erpnext/erpnext/selling/report/item_wise_sales_history/item_wise_sales_history.py,Delivered Quantity,Levererat antal
DocType: Journal Entry Account,Employee Advance,Anställd Advance
DocType: Payroll Entry,Payroll Frequency,löne Frekvens
DocType: Plaid Settings,Plaid Client ID,Plaid Client ID
DocType: Lab Test Template,Sensitivity,Känslighet
DocType: Plaid Settings,Plaid Settings,Plädinställningar
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py,Sync has been temporarily disabled because maximum retries have been exceeded,Synkroniseringen har avaktiverats tillfälligt eftersom högsta försök har överskridits
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,Råmaterial
DocType: Leave Application,Follow via Email,Följ via e-post
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,Växter och maskinerier
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Skattebelopp efter rabatt Belopp
DocType: Patient,Inpatient Status,Inpatient Status
DocType: Asset Finance Book,In Percentage,I procent
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Selected Price List should have buying and selling fields checked.,Den valda prislistan ska ha kontroll och köpfält.
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,Vänligen ange Reqd by Date
DocType: Payment Entry,Internal Transfer,Intern transaktion
DocType: Asset Maintenance,Maintenance Tasks,Underhållsuppgifter
apps/erpnext/erpnext/setup/doctype/territory/territory.py,Either target qty or target amount is mandatory,Antingen mål antal eller målbeloppet är obligatorisk
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Posting Date first,Välj Publiceringsdatum först
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Öppningsdatum ska vara innan Slutdatum
DocType: Travel Itinerary,Flight,Flyg
apps/erpnext/erpnext/public/js/hub/pages/NotFound.vue,Back to home,Tillbaka till hemmet
DocType: Leave Control Panel,Carry Forward,Skicka Vidare
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to ledger,Kostnadsställe med befintliga transaktioner kan inte omvandlas till liggaren
DocType: Budget,Applicable on booking actual expenses,Gäller vid bokning av faktiska utgifter
DocType: Department,Days for which Holidays are blocked for this department.,Dagar då helgdagar är blockerade för denna avdelning.
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext Integrations
DocType: Crop Cycle,Detected Disease,Upptäckt sjukdom
,Produced,Producerat
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Stock Ledger ID,Lagerbok-ID
DocType: Issue,Raised By (Email),Höjt av (e-post)
DocType: Issue,Service Level Agreement,Servicenivåavtal
DocType: Training Event,Trainer Name,Trainer Namn
DocType: Mode of Payment,General,Allmänt
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Senaste kommunikationen
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Senaste kommunikationen
,TDS Payable Monthly,TDS betalas månadsvis
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Köpt för att ersätta BOM. Det kan ta några minuter.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Det går inte att dra bort när kategorin är angedd ""Värdering"" eller ""Värdering och Total"""
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Totala betalningar
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos krävs för Serialiserad Punkt {0}
apps/erpnext/erpnext/config/accounts.py,Match Payments with Invoices,Match Betalningar med fakturor
DocType: Payment Entry,Get Outstanding Invoice,Få en enastående faktura
DocType: Journal Entry,Bank Entry,Bank anteckning
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Uppdaterar varianter ...
DocType: Authorization Rule,Applicable To (Designation),Är tillämpligt för (Destination)
,Profitability Analysis,lönsamhets~~POS=TRUNC
DocType: Fees,Student Email,Student Email
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Utbetalningslån
DocType: Supplier,Prevent POs,Förhindra PO
DocType: Patient,"Allergies, Medical and Surgical History","Allergier, medicinsk och kirurgisk historia"
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,Lägg till i kundvagn
apps/erpnext/erpnext/config/accounts.py,Enable / disable currencies.,Aktivera / inaktivera valutor.
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,Kunde inte skicka in några löneskalor
DocType: Project Template,Project Template,Projektmall
DocType: Exchange Rate Revaluation,Get Entries,Få inlägg
DocType: Production Plan,Get Material Request,Få Material Request
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Postal Expenses,Post Kostnader
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,Försäljningsöversikt
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),Totalt (Amt)
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},Identifiera / skapa konto (grupp) för typ - {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Underhållning &amp; Fritid
,Item Variant Details,Varianter av varianter
DocType: Quality Inspection,Item Serial No,Produkt Löpnummer
DocType: Payment Request,Is a Subscription,Är en prenumeration
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Skapa anställda Records
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,Totalt Närvarande
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
DocType: Drug Prescription,Hour,Timme
DocType: Restaurant Order Entry,Last Sales Invoice,Sista försäljningsfaktura
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},Var god välj Antal mot objekt {0}
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Latest Age,Sent skede
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,Scheduled and Admitted dates can not be less than today,Planerade och godkända datum kan inte vara mindre än idag
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Transfer Material to Supplier,Överföra material till leverantören
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,EMI,EMI
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nya Löpnummer kan inte ha Lager. Lagermåste ställas in av lagerpost eller inköpskvitto
DocType: Lead,Lead Type,Prospekt Typ
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,Skapa offert
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,Du har inte behörighet att godkänna löv på Block Datum
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Begäran om {1}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,All these items have already been invoiced,Alla dessa punkter har redan fakturerats
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,Inga utestående fakturor hittades för {0} {1} som uppfyller de filter du har angett.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Ange ny frisläppningsdatum
DocType: Company,Monthly Sales Target,Månadsförsäljningsmål
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,Inga utestående fakturor hittades
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Kan godkännas av {0}
DocType: Hotel Room,Hotel Room Type,Hotell Rumstyp
DocType: Customer,Account Manager,Kontohanterare
DocType: Issue,Resolution By Variance,Upplösning efter variation
DocType: Leave Allocation,Leave Period,Lämningsperiod
DocType: Item,Default Material Request Type,Standard Material Typ av förfrågan
DocType: Supplier Scorecard,Evaluation Period,Utvärderingsperiod
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,Okänd
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Arbetsorder inte skapad
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"An amount of {0} already claimed for the component {1},\
						 set the amount equal or greater than {2}","En mängd {0} som redan hävdats för komponenten {1}, \ anger summan lika med eller större än {2}"
DocType: Shipping Rule,Shipping Rule Conditions,Frakt härskar Villkor
DocType: Salary Slip Loan,Salary Slip Loan,Lönebetalningslån
DocType: BOM Update Tool,The new BOM after replacement,Den nya BOM efter byte
,Point of Sale,Butiksförsäljning
DocType: Payment Entry,Received Amount,erhållet belopp
DocType: Patient,Widow,Änka
DocType: GST Settings,GSTIN Email Sent On,GSTIN Email Sent On
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop av Guardian
DocType: Bank Account,SWIFT number,Byt nummer
DocType: Payment Entry,Party Name,Party Namn
DocType: POS Closing Voucher,Total Collected Amount,Totalt samlat belopp
DocType: Employee Benefit Application,Benefits Applied,Fördelar tillämpade
DocType: Crop,Planting UOM,Planterar UOM
DocType: Account,Tax,Skatt
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Not Marked,MÄRKLÖS
DocType: Service Level Priority,Response Time Period,Svarstid
DocType: Contract,Signed,Signerad
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Sammanfattning av fakturoröppning
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
DocType: Education Settings,Education Manager,Utbildningschef
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Mellanstatliga leveranser
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minsta längd mellan varje växt i fältet för optimal tillväxt
DocType: Quality Inspection,Report Date,Rapportdatum
DocType: BOM,Routing,Routing
DocType: Serial No,Asset Details,Tillgångsuppgifter
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Förklarade belopp
DocType: Bank Statement Transaction Payment Item,Invoices,Fakturor
DocType: Water Analysis,Type of Sample,Typ av prov
DocType: Batch,Source Document Name,Källdokumentnamn
DocType: Batch,Source Document Name,Källdokumentnamn
DocType: Production Plan,Get Raw Materials For Production,Få råmaterial för produktion
DocType: Job Opening,Job Title,Jobbtitel
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Framtida betalning ref
DocType: Quotation,Additional Discount and Coupon Code,Ytterligare rabatt- och kupongkod
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} indikerar att {1} inte kommer att ge en offert, men alla artiklar \ har offererats. Uppdaterar status för offertförfrågan."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximala prov - {0} har redan behållits för Batch {1} och Item {2} i Batch {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Uppdatera BOM kostnad automatiskt
DocType: Lab Test,Test Name,Testnamn
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinisk procedur förbrukningsartikel
apps/erpnext/erpnext/utilities/activation.py,Create Users,Skapa användare
DocType: Employee Tax Exemption Category,Max Exemption Amount,Max undantagsbelopp
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,Prenumerationer
DocType: Quality Review Table,Objective,Mål
DocType: Supplier Scorecard,Per Month,Per månad
DocType: Education Settings,Make Academic Term Mandatory,Gör akademisk termin Obligatorisk
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Quantity to Manufacture must be greater than 0.,Kvantitet som Tillverkning måste vara större än 0.
apps/erpnext/erpnext/config/crm.py,Visit report for maintenance call.,Besöksrapport för service samtal.
DocType: Stock Entry,Update Rate and Availability,Uppdateringsfrekvens och tillgänglighet
DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,Andel som är tillåtet att ta emot eller leverera mer mot beställt antal. Till exempel: Om du har beställt 100 enheter. och din ersättning är 10% då du får ta emot 110 enheter.
DocType: Shopping Cart Settings,Show Contact Us Button,Visa Kontakta oss-knappen
DocType: Loyalty Program,Customer Group,Kundgrupp
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Nytt parti-id (valfritt)
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Nytt parti-id (valfritt)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},Utgiftskonto är obligatorisk för produkten {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Release date must be in the future,Släppdatum måste vara i framtiden
DocType: BOM,Website Description,Webbplats Beskrivning
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Nettoförändringen i eget kapital
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,Inte tillåten. Avaktivera serviceenhetstypen
apps/erpnext/erpnext/crm/doctype/lead/lead.py,"Email Address must be unique, already exists for {0}","E-postadress måste vara unikt, redan för {0}"
DocType: Serial No,AMC Expiry Date,AMC Förfallodatum
DocType: Asset,Receipt,Mottagande
,Sales Register,Försäljningsregistret
DocType: Daily Work Summary Group,Send Emails At,Skicka e-post Vid
DocType: Quotation Lost Reason,Quotation Lost Reason,Anledning förlorad Offert
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,Generate e-Way Bill JSON,Skapa e-Way Bill JSON
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},Transaktions referensnummer {0} daterad {1}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,Det finns inget att redigera.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,Form View
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Expense Approver Obligatorisk i Kostnadskrav
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Sammanfattning för denna månad och pågående aktiviteter
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},Vänligen sätt in orealiserat Exchange Gain / Loss-konto i företaget {0}
DocType: Customer Group,Customer Group Name,Kundgruppnamn
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Rad {0}: Antalet är inte tillgängligt för {4} i lager {1} vid posten för posten ({2} {3})
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Inga kunder än!
DocType: Quality Procedure Process,Link existing Quality Procedure.,Länka befintligt kvalitetsförfarande.
apps/erpnext/erpnext/config/hr.py,Loans,lån
DocType: Healthcare Service Unit,Healthcare Service Unit,Hälso- och sjukvårdsservice
,Customer-wise Item Price,Kundmässigt artikelpris
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Kassaflödesanalys
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Ingen materiell förfrågan skapad
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Loan Amount cannot exceed Maximum Loan Amount of {0},Lånebeloppet kan inte överstiga Maximal låne Mängd {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,License,Licens
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please remove this Invoice {0} from C-Form {1},Ta bort denna faktura {0} från C-Form {1}
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Välj Överföring om du även vill inkludera föregående räkenskapsårs balans till detta räkenskapsår
DocType: GL Entry,Against Voucher Type,Mot Kupongtyp
DocType: Healthcare Practitioner,Phone (R),Telefon (R)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Ogiltig {0} för transaktion mellan företag.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Tidsspår läggs till
DocType: Products Settings,Attributes,Attributer
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Aktivera mall
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,Ange avskrivningskonto
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,Sista beställningsdatum
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Koppla bort förskottsbetalning vid beställning
DocType: Salary Component,Is Payable,Betalas
DocType: Inpatient Record,B Negative,B Negativ
DocType: Pricing Rule,Price Discount Scheme,Prisrabatt
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Maintenance Status has to be Cancelled or Completed to Submit,Underhållsstatus måste avbrytas eller slutförts för att skicka in
DocType: Amazon MWS Settings,US,oss
DocType: Holiday List,Add Weekly Holidays,Lägg till veckovisa helgdagar
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report Item,Rapportera objekt
DocType: Staffing Plan Detail,Vacancies,Lediga platser
DocType: Hotel Room,Hotel Room,Hotellrum
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},Kontot {0} till inte företaget {1}
DocType: Homepage Section,Use this field to render any custom HTML in the section.,Använd det här fältet för att återge all anpassad HTML i avsnittet.
DocType: Leave Type,Rounding,Avrundning
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Numbers in row {0} does not match with Delivery Note,Serienumren i rad {0} matchar inte med leveransnotering
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Dispensed Amount (Pro-rated)
DocType: Student,Guardian Details,Guardian Detaljer
DocType: C-Form,C-Form,C-Form
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Ogiltig GSTIN! De första två siffrorna i GSTIN bör matcha med statens nummer {0}.
DocType: Agriculture Task,Start Day,Start dag
DocType: Vehicle,Chassis No,chassi nr
DocType: Payment Entry,Initiated,Initierad
DocType: Production Plan Item,Planned Start Date,Planerat startdatum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,Var god välj en BOM
DocType: Purchase Invoice,Availed ITC Integrated Tax,Availed ITC Integrated Tax
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Skapa återbetalningsinmatning
DocType: Purchase Order Item,Blanket Order Rate,Blankett Order Rate
,Customer Ledger Summary,Sammanfattning av kundbok
apps/erpnext/erpnext/hooks.py,Certification,certifiering
DocType: Bank Guarantee,Clauses and Conditions,Klausuler och villkor
DocType: Serial No,Creation Document Type,Skapande Dokumenttyp
DocType: Amazon MWS Settings,ES,ES
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,Få fakturor
apps/erpnext/erpnext/accounts/general_ledger.py,Make Journal Entry,Skapa journalanteckning
DocType: Leave Allocation,New Leaves Allocated,Nya Ledigheter Avsatta
apps/erpnext/erpnext/controllers/trends.py,Project-wise data is not available for Quotation,Projektvis uppgifter finns inte tillgängligt för Offert
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,End on,Sluta på
DocType: Project,Expected End Date,Förväntad Slutdatum
DocType: Budget Account,Budget Amount,budget~~POS=TRUNC
DocType: Donor,Donor Name,Donatornamn
DocType: Journal Entry,Inter Company Journal Entry Reference,Inter Company Journal Entry Reference
DocType: Course,Topics,ämnen
DocType: Tally Migration,Is Day Book Data Processed,Behandlas dagboksdata
DocType: Appraisal Template,Appraisal Template Title,Bedömning mall Titel
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Commercial,Kommersiell
DocType: Patient,Alcohol Current Use,Alkoholströmanvändning
DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,Hus Hyresbetalningsbelopp
DocType: Student Admission Program,Student Admission Program,Studentträningsprogram
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Skattebefrielse kategori
DocType: Payment Entry,Account Paid To,Konto betalt för att
DocType: Subscription Settings,Grace Period,Grace Period
DocType: Item Alternative,Alternative Item Name,Alternativt artikelnamn
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Moderbolaget Punkt {0} får inte vara en lagervara
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Det går inte att skapa en leveransresa från utkast till dokument.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Webbplatslista
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Alla produkter eller tjänster.
DocType: Email Digest,Open Quotations,Öppna citat
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,Fler detaljer
DocType: Supplier Quotation,Supplier Address,Leverantör Adress
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} budget för kontot {1} mot {2} {3} är {4}. Det kommer att överskridas med {5}
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Creating bank entries...,Skapar bankposter ...
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,Ut Antal
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,Serien är obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,Finansiella Tjänster
DocType: Student Sibling,Student ID,Student-ID
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,Olika typer av aktiviteter för Time Loggar
DocType: Opening Invoice Creation Tool,Sales,Försäljning
DocType: Stock Entry Detail,Basic Amount,BASBELOPP
DocType: Training Event,Exam,Examen
DocType: Email Campaign,Email Campaign,E-postkampanj
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,Marknadsfel
DocType: Complaint,Complaint,Klagomål
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},Lager krävs för Lagervara {0}
DocType: Leave Allocation,Unused leaves,Oanvända blad
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,Alla avdelningar
DocType: Healthcare Service Unit,Vacant,Ledig
DocType: Patient,Alcohol Past Use,Alkohol tidigare användning
DocType: Fertilizer Content,Fertilizer Content,Gödselinnehåll
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,No description,Ingen beskrivning
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,Cr
DocType: Tax Rule,Billing State,Faktureringsstaten
DocType: Quality Goal,Monitoring Frequency,Övervaka frekvens
DocType: Share Transfer,Transfer,Överföring
DocType: Quality Action,Quality Feedback,Kvalitetsåterkoppling
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,Arbetsorder {0} måste avbrytas innan du avbryter denna försäljningsorder
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Fetch exploded BOM (including sub-assemblies),Fetch expanderande BOM (inklusive underenheter)
DocType: Authorization Rule,Applicable To (Employee),Är tillämpligt för (anställd)
apps/erpnext/erpnext/controllers/accounts_controller.py,Due Date is mandatory,Förfallodatum är obligatorisk
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,Kan inte ställa in kvantitet mindre än mottagen kvantitet
apps/erpnext/erpnext/controllers/item_variant.py,Increment for Attribute {0} cannot be 0,Påslag för Attribut {0} inte kan vara 0
DocType: Employee Benefit Claim,Benefit Type and Amount,Förmånstyp och belopp
DocType: Delivery Stop,Visited,Besökt
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Rum bokade
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,Slutdatum På datum kan inte vara före nästa kontaktdatum.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Batchposter
DocType: Journal Entry,Pay To / Recd From,Betala Till / RECD Från
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Unpublish Item,Ta bort publicering av artikeln
DocType: Naming Series,Setup Series,Inställnings Serie
DocType: Payment Reconciliation,To Invoice Date,Att fakturadatum
DocType: Bank Account,Contact HTML,Kontakta HTML
DocType: Support Settings,Support Portal,Supportportal
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Registreringsavgift kan inte vara noll
DocType: Disease,Treatment Period,Behandlingsperiod
DocType: Travel Itinerary,Travel Itinerary,Reseplan
apps/erpnext/erpnext/education/api.py,Result already Submitted,Resultatet redan inskickat
apps/erpnext/erpnext/controllers/buying_controller.py,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Reserverat lager är obligatoriskt för artikel {0} i levererade råvaror
,Inactive Customers,inaktiva kunder
DocType: Student Admission Program,Maximum Age,Maximal ålder
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,Vänligen vänta 3 dagar innan du skickar påminnelsen igen.
DocType: Landed Cost Voucher,Purchase Receipts,Kvitton
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,"Upload a bank statement, link or reconcile a bank account","Ladda upp ett kontoutdrag, länk eller förena ett bankkonto"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,Hur prissättning tillämpas?
DocType: Stock Entry,Delivery Note No,Följesedel nr
DocType: Cheque Print Template,Message to show,Meddelande för att visa
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,Detaljhandeln
DocType: Student Attendance,Absent,Frånvarande
DocType: Staffing Plan,Staffing Plan Detail,Bemanningsplandetaljer
DocType: Employee Promotion,Promotion Date,Kampanjdatum
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Leave allocation %s is linked with leave application %s,Ledighetstilldelning% s är kopplad till ledighetsansökan% s
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Produktpaket
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Det gick inte att hitta poäng från {0}. Du måste ha stående poäng som täcker 0 till 100
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},Rad {0}: Ogiltig referens {1}
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set valid GSTIN No. in Company Address for company {0},Ange giltigt GSTIN-nummer i företagets adress för företag {0}
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,Ny plats
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Inköp Skatter och avgifter Mall
DocType: Additional Salary,Date on which this component is applied,Datum då denna komponent tillämpas
DocType: Subscription,Current Invoice Start Date,Nuvarande fakturans startdatum
DocType: Designation Skill,Designation Skill,Beteckning Färdighet
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Import av varor
DocType: Timesheet,TS-,TS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: krävs antingen debet- eller kreditbelopp för {2}
DocType: GL Entry,Remarks,Anmärkningar
DocType: Support Settings,Track Service Level Agreement,Spåra servicenivåavtal
DocType: Hotel Room Amenity,Hotel Room Amenity,Hotell Rumsfaciliteter
apps/erpnext/erpnext/erpnext_integrations/connectors/woocommerce_connection.py,woocommerce - {0},woocommerce - {0}
DocType: Budget,Action if Annual Budget Exceeded on MR,Åtgärd om årlig budget överskrider MR
DocType: Course Enrollment,Course Enrollment,Kursregistrering
DocType: Payment Entry,Account Paid From,Konto betalas från
DocType: Purchase Order Item Supplied,Raw Material Item Code,Råvaru Artikelkod
DocType: Task,Parent Task,Föräldrauppgift
DocType: Project,From Template,Från mall
DocType: Journal Entry,Write Off Based On,Avskrivning Baseras på
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Print and Stationery,Print och brevpapper
DocType: Stock Settings,Show Barcode Field,Show Barcode Field
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,Skicka e-post Leverantörs
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.",Lön redan behandlas för perioden mellan {0} och {1} Lämna ansökningstiden kan inte vara mellan detta datumintervall.
DocType: Fiscal Year,Auto Created,Automatisk skapad
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,Skicka in det här för att skapa anställningsrekordet
DocType: Item Default,Item Default,Objektstandard
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Mellanstatliga leveranser
DocType: Chapter Member,Leave Reason,Lämna anledning
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,IBAN is not valid,IBAN är inte giltig
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Faktura {0} existerar inte längre
DocType: Guardian Interest,Guardian Interest,Guardian intresse
DocType: Volunteer,Availability,Tillgänglighet
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.py,Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Lämnadsansökan är kopplad till ledighetstilldelningar {0}. Permissionsansökan kan inte ställas in som ledighet utan lön
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Ange standardvärden för POS-fakturor
DocType: Employee Training,Training,Utbildning
DocType: Project,Time to send,Tid att skicka
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,This page keeps track of your items in which buyers have showed some interest.,Denna sida håller reda på dina artiklar där köpare har visat ett intresse.
DocType: Timesheet,Employee Detail,anställd Detalj
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Ställ lager för procedur {0}
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,Guardian1 Email ID
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,Guardian1 Email ID
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Error: {0} is mandatory field,Fel: {0} är obligatoriskt fält
DocType: Import Supplier Invoice,Invoice Series,Fakturaserie
DocType: Lab Prescription,Test Code,Testkod
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Inställningar för webbplats hemsida
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} är i vänteläge till {1}
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ är inte tillåtna för {0} på grund av ett styrkort som står för {1}
apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Skapa inköpsfaktura
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Använda löv
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kupongen som används är {1}. Tillåten kvantitet är slut
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Vill du skicka in materialförfrågan
DocType: Job Offer,Awaiting Response,Väntar på svar
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,Ovan
DocType: Support Search Source,Link Options,Länkalternativ
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},Summa belopp {0}
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},Ogiltig attribut {0} {1}
DocType: Supplier,Mention if non-standard payable account,Nämn om inte-standard betalnings konto
DocType: Employee,Emergency Contact Name,kontaktperson för nödfall
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py,Please select the assessment group other than 'All Assessment Groups',Var god välj bedömningsgruppen annan än &quot;Alla bedömningsgrupper&quot;
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Row {0}: Cost center is required for an item {1},Rad {0}: Kostnadscentrum krävs för ett objekt {1}
DocType: Training Event Employee,Optional,Frivillig
DocType: Salary Slip,Earning & Deduction,Vinst &amp; Avdrag
DocType: Agriculture Analysis Criteria,Water Analysis,Vattenanalys
DocType: Sales Order,Skip Delivery Note,Hoppa över leveransanteckning
DocType: Price List,Price Not UOM Dependent,Pris ej UOM beroende
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} varianter skapade.
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Ett standardavtal om servicenivå finns redan.
DocType: Quality Objective,Quality Objective,Kvalitetsmål
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Optional. This setting will be used to filter in various transactions.,Tillval. Denna inställning kommer att användas för att filtrera i olika transaktioner.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Valuation Rate is not allowed,Negativt Värderingsvärde är inte tillåtet
DocType: Holiday List,Weekly Off,Veckovis Av
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,Uppdatera länkad analys
DocType: Fiscal Year,"For e.g. 2012, 2012-13","För t.ex. 2012, 2012-13"
DocType: Purchase Order,Purchase Order Pricing Rule,Beställningsprisregler
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Provisional Profit / Loss (Credit),Preliminär vinst / förlust (Kredit)
DocType: Sales Invoice,Return Against Sales Invoice,Återgå mot fakturan
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,Produkt  5
DocType: Serial No,Creation Time,Skapelsetid
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,Totala intäkter
DocType: Patient,Other Risk Factors,Övriga riskfaktorer
DocType: Sales Invoice,Product Bundle Help,Produktpaket Hjälp
,Monthly Attendance Sheet,Månads Närvaroblad
DocType: Homepage Section Card,Subtitle,Texta
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,Ingen post hittades
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,Kostnad för skrotas Asset
DocType: Employee Checkin,OUT,UT
apps/erpnext/erpnext/controllers/stock_controller.py,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Kostnadsställe är obligatorisk för punkt {2}
DocType: Vehicle,Policy No,policy Nej
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,Få artiklar från produkt Bundle
DocType: Asset,Straight Line,Rak linje
DocType: Project User,Project User,projektAnvändar
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Dela
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Dela
DocType: Tally Migration,Master Data,Basdata
DocType: Employee Transfer,Re-allocate Leaves,Tilldela blad igen
DocType: GL Entry,Is Advance,Är Advancerad
DocType: Job Offer,Applicant Email Address,Sökandens e-postadress
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Anställd livscykel
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Attendance From Date and Attendance To Date is mandatory,Närvaro Från Datum och närvaro hittills är obligatorisk
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter 'Is Subcontracted' as Yes or No,"Ange ""Är underleverantör"" som Ja eller Nej"
DocType: Item,Default Purchase Unit of Measure,Standard inköpsenhet av åtgärd
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Senaste kommunikationsdatum
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Senaste kommunikationsdatum
DocType: Clinical Procedure Item,Clinical Procedure Item,Klinisk procedur Artikel
DocType: Coupon Code,unique e.g. SAVE20  To be used to get discount,unik t.ex. SAVE20 Används för att få rabatt
DocType: Sales Team,Contact No.,Kontakt nr
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,Faktureringsadress är samma som fraktadress
DocType: Bank Reconciliation,Payment Entries,betalningsAnteckningar
DocType: Location,Latitude,Latitud
DocType: Work Order,Scrap Warehouse,skrot Warehouse
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Lager som krävs vid rad nr {0}, ange standardlager för objektet {1} för företaget {2}"
DocType: Work Order,Check if material transfer entry is not required,Kontrollera om materialöverföring inte krävs
DocType: Work Order,Check if material transfer entry is not required,Kontrollera om materialöverföring inte krävs
DocType: Program Enrollment Tool,Get Students From,Få studenter från
apps/erpnext/erpnext/config/help.py,Publish Items on Website,Publicera artiklar på webbplatsen
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Grupp dina elever i omgångar
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,Tilldelat belopp kan inte vara större än ojusterat belopp
DocType: Authorization Rule,Authorization Rule,Auktoriseringsregel
apps/erpnext/erpnext/projects/doctype/project/project.py,Status must be Cancelled or Completed,Status måste avbrytas eller slutföras
DocType: Sales Invoice,Terms and Conditions Details,Villkor Detaljer
DocType: Sales Invoice,Sales Taxes and Charges Template,Försäljnings Skatter och avgifter Mall
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Total (Credit)
DocType: Repayment Schedule,Payment Date,Betalningsdag
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Ny sats antal
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Ny sats antal
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,Kläder &amp; tillbehör
apps/erpnext/erpnext/controllers/accounts_controller.py,Item quantity can not be zero,Artikelkvantitet kan inte vara noll
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve weighted score function. Make sure the formula is valid.,Kunde inte lösa viktad poängfunktion. Se till att formeln är giltig.
DocType: Invoice Discounting,Loan Period (Days),Låneperiod (dagar)
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Beställningsvaror Objekt som inte mottogs i tid
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Number of Order,Antal Beställningar
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner som visar på toppen av produktlista.
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Ange villkor för att beräkna fraktbeloppet
DocType: Program Enrollment,Institute's Bus,Institutets buss
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Roll tillåtas att fastställa frysta konton och Redigera Frysta Inlägg
DocType: Supplier Scorecard Scoring Variable,Path,Väg
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cannot convert Cost Center to ledger as it has child nodes,Det går inte att konvertera kostnadsställe till huvudbok då den har underordnade noder
DocType: Production Plan,Total Planned Qty,Totalt planerat antal
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Transactions already retreived from the statement,Transaktioner har redan återkommit från uttalandet
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,öppnings Värde
DocType: Salary Component,Formula,Formel
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,Seriell #
DocType: Material Request Plan Item,Required Quantity,Mängd som krävs
DocType: Lab Test Template,Lab Test Template,Lab Test Template
apps/erpnext/erpnext/accounts/doctype/accounting_period/accounting_period.py,Accounting Period overlaps with {0},Redovisningsperioden överlappar med {0}
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Försäljningskonto
DocType: Purchase Invoice Item,Total Weight,Totalvikt
DocType: Pick List Item,Pick List Item,Välj listobjekt
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Försäljningsprovision
DocType: Job Offer Term,Value / Description,Värde / Beskrivning
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Rad # {0}: Asset {1} kan inte lämnas, är det redan {2}"
DocType: Tax Rule,Billing Country,Faktureringsland
DocType: Purchase Order Item,Expected Delivery Date,Förväntat leveransdatum
DocType: Restaurant Order Entry,Restaurant Order Entry,Restaurang Order Entry
apps/erpnext/erpnext/accounts/general_ledger.py,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debet och kredit inte är lika för {0} # {1}. Skillnaden är {2}.
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Faktura Separat som förbrukningsvaror
DocType: Budget,Control Action,Kontrollåtgärd
DocType: Asset Maintenance Task,Assign To Name,Tilldela till namn
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,Representationskostnader
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},Öppen föremål {0}
DocType: Asset Finance Book,Written Down Value,Skriftligt nedvärde
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Fakturan {0} måste ställas in innan avbryta denna kundorder
DocType: Clinical Procedure,Age,Ålder
DocType: Sales Invoice Timesheet,Billing Amount,Fakturerings Mängd
DocType: Cash Flow Mapping,Select Maximum Of 1,Välj maximalt 1
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ogiltig mängd som anges för produkten {0}. Kvantitet bör vara större än 0.
DocType: Company,Default Employee Advance Account,Standardansvarig förskottskonto
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Sökningsartikel (Ctrl + i)
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,Konto med befintlig transaktioner kan inte tas bort
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Why do think this Item should be removed?,Varför tror jag att denna artikel ska tas bort?
DocType: Vehicle,Last Carbon Check,Sista Carbon Check
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Rättsskydds
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Var god välj antal på rad
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Arbetsorder {0}: jobbkort hittades inte för operationen {1}
DocType: Purchase Invoice,Posting Time,Boknings Tid
DocType: Timesheet,% Amount Billed,% Belopp fakturerat
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefon Kostnader
DocType: Sales Partner,Logo,Logo
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Markera det här om du vill tvinga användaren att välja en serie innan du sparar. Det blir ingen standard om du kontrollera detta.
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Serial No {0},Ingen produkt med Löpnummer {0}
DocType: Email Digest,Open Notifications,Öppna Meddelanden
DocType: Payment Entry,Difference Amount (Company Currency),Skillnad Belopp (Company valuta)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,Direkta kostnader
DocType: Pricing Rule Detail,Child Docname,Barndokumentnamn
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,Nya kund Intäkter
apps/erpnext/erpnext/config/support.py,Service Level.,Servicenivå.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,Resekostnader
DocType: Maintenance Visit,Breakdown,Nedbrytning
DocType: Travel Itinerary,Vegetarian,Vegetarian
DocType: Patient Encounter,Encounter Date,Mötesdatum
DocType: Work Order,Update Consumed Material Cost In Project,Uppdatera förbrukat materialkostnad i projektet
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Konto: {0} med valuta: kan inte väljas {1}
DocType: Bank Statement Transaction Settings Item,Bank Data,Bankuppgifter
DocType: Purchase Receipt Item,Sample Quantity,Provkvantitet
DocType: Bank Guarantee,Name of Beneficiary,Stödmottagarens namn
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Uppdatera BOM-kostnad automatiskt via Scheduler, baserat på senaste värderingsfrekvens / prislista / senaste inköpshastighet för råvaror."
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
,BOM Items and Scraps,BOM-artiklar och rester
DocType: Bank Reconciliation Detail,Cheque Date,Check Datum
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Förälder konto {1} tillhör inte företaget: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Successfully deleted all transactions related to this company!,Framgångsrikt bort alla transaktioner i samband med detta företag!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As on Date,Som på Date
DocType: Additional Salary,HR,HR
DocType: Course Enrollment,Enrollment Date,Inskrivningsdatum
DocType: Healthcare Settings,Out Patient SMS Alerts,Ut Patient SMS Alerts
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,Skyddstillsyn
DocType: Company,Sales Settings,Försäljningsinställningar
DocType: Program Enrollment Tool,New Academic Year,Nytt läsår
DocType: Supplier Scorecard,Load All Criteria,Ladda alla kriterier
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Return / Credit Note,Retur / kreditnota
DocType: Stock Settings,Auto insert Price List rate if missing,Diskinmatning Prislista ränta om saknas
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Paid Amount,Sammanlagda belopp som betalats
DocType: GST Settings,B2C Limit,B2C begränsning
DocType: Job Card,Transferred Qty,Överfört Antal
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a creditor bank transaction,Den valda betalningsposten bör kopplas till en kreditgivarbanktransaktion
DocType: POS Closing Voucher,Amount in Custody,Belopp i vårdnad
apps/erpnext/erpnext/config/help.py,Navigating,Navigera
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.js,Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Lösenordspolicyn kan inte innehålla mellanslag eller samtidig bindestreck. Formatet omstruktureras automatiskt
DocType: Quotation Item,Planning,Planering
DocType: Salary Component,Depends on Payment Days,Beror på betalningsdagar
DocType: Contract,Signee,signee
DocType: Share Balance,Issued,Utfärdad
DocType: Loan,Repayment Start Date,Återbetalning Startdatum
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,Studentaktivitet
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,Leverantör Id
DocType: Payment Request,Payment Gateway Details,Betalning Gateway Detaljer
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Kvantitet bör vara större än 0
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Pris eller produktrabattplattor krävs
DocType: Journal Entry,Cash Entry,Kontantinlägg
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,Child nodes can be only created under 'Group' type nodes,Underordnade noder kan endast skapas under &quot;grupp&quot; typ noder
DocType: Attendance Request,Half Day Date,Halvdag Datum
DocType: Academic Year,Academic Year Name,Akademisk - läsårets namn
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,{0} får inte göra transaktioner med {1}. Vänligen ändra företag.
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_sub_category/employee_tax_exemption_sub_category.py,Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Det maximala undantagsbeloppet kan inte vara högre än det maximala undantagsbeloppet {0} för skattefrihetskategori {1}
DocType: Sales Partner,Contact Desc,Kontakt Desc
DocType: Email Digest,Send regular summary reports via Email.,Skicka regelbundna sammanfattande rapporter via e-post.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},Ställ in standardkonto i räkningen typ {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,Tillgängliga löv
DocType: Assessment Result,Student Name,Elevs namn
DocType: Hub Tracked Item,Item Manager,Produktansvarig
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,Lön Betalning
DocType: GSTR 3B Report,April,april
apps/erpnext/erpnext/config/crm.py,Helps you manage appointments with your leads,Hjälper dig att hantera möten med dina leads
DocType: Plant Analysis,Collection Datetime,Samling Datetime
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Work Order,Total Operating Cost,Totala driftskostnaderna
apps/erpnext/erpnext/controllers/selling_controller.py,Note: Item {0} entered multiple times,Obs: Punkt {0} inlagd flera gånger
apps/erpnext/erpnext/config/buying.py,All Contacts.,Alla kontakter.
DocType: Accounting Period,Closed Documents,Stängda dokument
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Hantera avtalsfaktura skickar och avbryter automatiskt för patientmottagning
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Lägg till kort eller anpassade avsnitt på hemsidan
DocType: Patient Appointment,Referring Practitioner,Refererande utövare
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Training Event:,Träningsevenemang:
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Företagetsförkortning
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,Användare {0} inte existerar
DocType: Payment Term,Day(s) after invoice date,Dag (er) efter fakturadatum
apps/erpnext/erpnext/setup/doctype/company/company.js,Date of Commencement should be greater than Date of Incorporation,Datum för inledande bör vara större än datum för införlivande
DocType: Contract,Signed On,Inloggad
DocType: Bank Account,Party Type,Parti Typ
DocType: Discounted Invoice,Discounted Invoice,Rabatterad faktura
DocType: Payment Schedule,Payment Schedule,Betalningsplan
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},Ingen anställd hittades för det givna anställdas fältvärde. &#39;{}&#39;: {}
DocType: Item Attribute Value,Abbreviation,Förkortning
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Betalning Entry redan existerar
DocType: Course Content,Quiz,Frågesport
DocType: Subscription,Trial Period End Date,Pröva period Slutdatum
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,Inte auktoriserad eftersom {0} överskrider gränser
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,Börja ange data härifrån:
DocType: Serial No,Asset Status,Asset Status
DocType: Sales Invoice,Over Dimensional Cargo (ODC),Över dimensionell last (ODC)
DocType: Restaurant Order Entry,Restaurant Table,Restaurangbord
DocType: Hotel Room,Hotel Manager,Hotell chef
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Skapa studentbatch
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Ställ skatt Regel för varukorgen
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.py,There are no vacancies under staffing plan {0},Det finns inga lediga platser inom personalplanen {0}
DocType: Purchase Invoice,Taxes and Charges Added,Skatter och avgifter Added
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Avskrivningsraden {0}: Nästa avskrivningsdatum kan inte vara före tillgängliga datum
,Sales Funnel,Försäljning tratt
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Förkortning är obligatorisk
DocType: Project,Task Progress,Task framsteg
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kundvagn
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Bank account {0} already exists and could not be created again,Bankkonto {0} finns redan och kunde inte skapas igen
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Missed,Samtal saknas
DocType: Certified Consultant,GitHub ID,GitHub ID
DocType: Staffing Plan,Total Estimated Budget,Totalt beräknad budget
,Qty to Transfer,Antal Transfer
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,Offerter till prospekt eller kunder
DocType: Stock Settings,Role Allowed to edit frozen stock,Roll tillåtet att redigera fryst lager
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,Alla kundgrupper
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,ackumulerade månads
DocType: Attendance Request,On Duty,I tjänst
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} är obligatorisk. Kanske har en valutaväxlingskurs inte skapats för {1} till {2}.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Staffing Plan {0} already exist for designation {1},Personalplan {0} finns redan för beteckning {1}
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Skatte Mall är obligatorisk.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Goods are already received against the outward entry {0},Varor har redan mottagits mot utgången {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Last Issue,Sista utgåvan
apps/erpnext/erpnext/regional/doctype/import_supplier_invoice/import_supplier_invoice.py,XML Files Processed,XML-filer bearbetade
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,Konto {0}: Förälder konto {1} existerar inte
DocType: Bank Account,Mask,Mask
DocType: POS Closing Voucher,Period Start Date,Periodens startdatum
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Prislista värde (Företagsvaluta)
DocType: Products Settings,Products Settings,produkter Inställningar
,Item Price Stock,Produktpris Lager
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Att göra kundbaserade incitamentsprogram.
DocType: Lab Prescription,Test Created,Test Skapad
DocType: Healthcare Settings,Custom Signature in Print,Anpassad signatur i utskrift
DocType: Account,Temporary,Tillfällig
DocType: Material Request Plan Item,Customer Provided,Kund tillhandahålls
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,Kund LPO nr
DocType: Amazon MWS Settings,Market Place Account Group,Marknadsplats Kontokoncern
DocType: Program,Courses,Kurser
DocType: Monthly Distribution Percentage,Percentage Allocation,Procentuell Fördelning
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,Sekreterare
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,Hus hyrda datum krävs för undantag beräkning
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Om inaktivera, &quot;uttrycker in&quot; fältet inte kommer att vara synlig i någon transaktion"
DocType: Quality Review Table,Quality Review Table,Kvalitetsöversiktstabell
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,This action will stop future billing. Are you sure you want to cancel this subscription?,Den här åtgärden stoppar framtida fakturering. Är du säker på att du vill avbryta denna prenumeration?
DocType: Serial No,Distinct unit of an Item,Distinkt enhet för en försändelse
DocType: Supplier Scorecard Criteria,Criteria Name,Kriterier Namn
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,Vänligen ange företaget
DocType: Procedure Prescription,Procedure Created,Förfarande skapat
DocType: Pricing Rule,Buying,Köpa
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Sjukdomar och gödselmedel
DocType: HR Settings,Employee Records to be created by,Personal register som skall skapas av
DocType: Inpatient Record,AB Negative,AB Negativ
DocType: POS Profile,Apply Discount On,Tillämpa rabatt på
DocType: Member,Membership Type,typ av medlemskap
,Reqd By Date,Reqd Efter datum
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,Borgenärer
DocType: Assessment Plan,Assessment Name,bedömning Namn
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,Rad # {0}: Löpnummer är obligatorisk
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Produktvis Skatte Detalj
DocType: Employee Onboarding,Job Offer,Jobberbjudande
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,Institute Förkortning
,Item-wise Price List Rate,Produktvis Prislistavärde
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Leverantör Offert
apps/erpnext/erpnext/crm/doctype/appointment_booking_settings/appointment_booking_settings.py,The difference between from time and To Time must be a multiple of Appointment,Skillnaden mellan tid och tid måste vara en mångfald av utnämningen
apps/erpnext/erpnext/config/support.py,Issue Priority.,Utgåva prioritet.
DocType: Quotation,In Words will be visible once you save the Quotation.,I Ord kommer att synas när du sparar offerten.
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},Kvantitet ({0}) kan inte vara en fraktion i rad {1}
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},Kvantitet ({0}) kan inte vara en fraktion i rad {1}
DocType: Contract,Unsigned,Osignerad
DocType: Selling Settings,Each Transaction,Varje transaktion
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},Streckkod {0} används redan i punkt {1}
DocType: Shift Type,The time before the shift end time when check-out is considered as early (in minutes).,Tiden före skiftets sluttid när utcheckning betraktas som tidigt (i minuter).
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,Regler för att lägga fraktkostnader.
DocType: Hotel Room,Extra Bed Capacity,Extra säng kapacitet
apps/erpnext/erpnext/config/hr.py,Performance,Prestanda
DocType: Import Supplier Invoice,Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Klicka på knappen Importera fakturor när zip-filen har bifogats dokumentet. Eventuella fel relaterade till bearbetning visas i felloggen.
DocType: Item,Opening Stock,ingående lager
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Kunden är obligatoriskt
DocType: Lab Test,Result Date,Resultatdatum
DocType: Purchase Order,To Receive,Att Motta
DocType: Leave Period,Holiday List for Optional Leave,Semesterlista för valfritt semester
DocType: Item Tax Template,Tax Rates,Skattesatser
DocType: Asset,Asset Owner,Tillgångsägare
DocType: Item,Website Content,Webbplatsinnehåll
DocType: Bank Account,Integration ID,Integrations-ID
DocType: Purchase Invoice,Reason For Putting On Hold,Anledning för att sätta på sig
DocType: Employee,Personal Email,Personligt E-post
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,Totalt Varians
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Om det är aktiverat, kommer systemet att skicka bokföringsposter för inventering automatiskt."
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() accepted invalid IBAN {},BankAccount.validate_iban () accepterade ogiltiga IBAN {}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,Brokerage
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,Närvaro för arbetstagare {0} är redan märkt för denna dag
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'","i protokollet Uppdaterad via ""Tidslog"""
DocType: Customer,From Lead,Från Prospekt
DocType: Amazon MWS Settings,Synch Orders,Synkroniseringsorder
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,Order släppts för produktion.
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,Välj räkenskapsår ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profil som krävs för att göra POS inlägg
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Lojalitetspoäng kommer att beräknas utifrån den förbrukade gjorda (via försäljningsfakturaen), baserat på nämnda samlingsfaktor."
DocType: Program Enrollment Tool,Enroll Students,registrera studenter
DocType: Pricing Rule,Coupon Code Based,Baserad på kupongkod
DocType: Company,HRA Settings,HRA-inställningar
DocType: Homepage,Hero Section,Hjältesektion
DocType: Employee Transfer,Transfer Date,Överföringsdatum
DocType: Lab Test,Approved Date,Godkänd datum
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,Standardförsäljnings
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Atleast one warehouse is mandatory,Minst ett lager är obligatorisk
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,"Configure Item Fields like UOM, Item Group, Description and No of Hours.","Konfigurera objektfält som UOM, Produktgrupp, Beskrivning och Antal timmar."
DocType: Certification Application,Certification Status,Certifieringsstatus
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,Marknad
DocType: Travel Itinerary,Travel Advance Required,Resefordran krävs
DocType: Subscriber,Subscriber Name,Abonnentens namn
DocType: Serial No,Out of Warranty,Ingen garanti
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Mappad datatyp
DocType: BOM Update Tool,Replace,Ersätt
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Inga produkter hittades.
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish More Items,Publicera fler artiklar
apps/erpnext/erpnext/support/doctype/issue/issue.py,This Service Level Agreement is specific to Customer {0},Detta servicenivåavtal är specifikt för kund {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} mot faktura {1}
DocType: Antibiotic,Laboratory User,Laboratorieanvändare
DocType: Request for Quotation Item,Project Name,Projektnamn
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,Ange kundadress
DocType: Customer,Mention if non-standard receivable account,Nämn om icke-standardiserade fordran konto
DocType: Bank,Plaid Access Token,Plaid Access Token
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Please add the remaining benefits {0} to any of the existing component,Lägg till de övriga fördelarna {0} till någon av befintliga komponenter
DocType: Journal Entry Account,If Income or Expense,Om intäkter eller kostnader
DocType: Course Topic,Course Topic,Kursens ämne
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/pos_closing_voucher.py,POS Closing Voucher alreday exists for {0} between date {1} and {2},POS Closing Voucher alreday finns för {0} mellan datum {1} och {2}
DocType: Bank Statement Transaction Entry,Matching Invoices,Matchande fakturor
DocType: Work Order,Required Items,nödvändiga objekt
DocType: Stock Ledger Entry,Stock Value Difference,Stock Värde Skillnad
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item Row {0}: {1} {2} does not exist in above '{1}' table,Artikelraden {0}: {1} {2} existerar inte i ovanstående &quot;{1}&quot; -tabell
apps/erpnext/erpnext/config/help.py,Human Resource,Personal administration
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Betalning Avstämning Betalning
DocType: Disease,Treatment Task,Behandlingsuppgift
DocType: Payment Order Reference,Bank Account Details,Bankkontouppgifter
DocType: Purchase Order Item,Blanket Order,Blankett Order
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Repayment Amount must be greater than ,Återbetalningsbeloppet måste vara större än
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,Skattefordringar
DocType: BOM Item,BOM No,BOM nr
apps/erpnext/erpnext/public/js/hub/components/edit_details_dialog.js,Update Details,Uppdatera detaljer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Journal Entry {0} does not have account {1} or already matched against other voucher,Journalanteckning {0} har inte konto {1} eller redan matchad mot andra kuponger
DocType: Item,Moving Average,Rörligt medelvärde
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,Fördel
DocType: BOM Update Tool,The BOM which will be replaced,BOM som kommer att ersättas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Electronic Equipments,elektronisk utrustning
DocType: Asset,Maintenance Required,Underhåll krävs
DocType: Account,Debit,Debit-
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leaves must be allocated in multiples of 0.5,"Ledigheter ska fördelas i multiplar av 0,5"
DocType: Work Order,Operation Cost,Driftkostnad
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,Identifiera beslutsfattare
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Outstanding Amt,Utestående Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Uppsatta mål Punkt Gruppvis för säljare.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Lager Äldre än [dagar]
DocType: Payment Entry,Payment Ordered,Betalningsbeställd
DocType: Asset Maintenance Team,Maintenance Team Name,Underhållsgruppsnamn
DocType: Driving License Category,Driver licence class,Körkort
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"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.","Om två eller flera Prissättningsregler hittas baserat på ovanstående villkor, tillämpas prioritet . Prioritet är ett tal mellan 0 till 20, medan standardvärdet är noll (tom). Högre siffra innebär det kommer att ha företräde om det finns flera prissättningsregler med samma villkor."
apps/erpnext/erpnext/controllers/trends.py,Fiscal Year: {0} does not exists,Räkenskapsårets: {0} inte existerar
DocType: Currency Exchange,To Currency,Till Valuta
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Tillåt följande användarna att godkänna ledighetsansökningar för grupp dagar.
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Lifecycle,Livscykel
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Payment Document Type,Betalningsdokumenttyp
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Försäljningsfrekvensen för objektet {0} är lägre än dess {1}. Försäljningsfrekvensen bör vara minst {2}
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Försäljningsfrekvensen för objektet {0} är lägre än dess {1}. Försäljningsfrekvensen bör vara minst {2}
DocType: Designation Skill,Skill,Skicklighet
DocType: Subscription,Taxes,Skatter
DocType: Purchase Invoice Item,Weight Per Unit,Vikt per enhet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Betald och inte levererats
DocType: QuickBooks Migrator,Default Cost Center,Standardkostnadsställe
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Växla filter
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in company {1},Ställ in {0} i företag {1}
apps/erpnext/erpnext/config/stock.py,Stock Transactions,aktietransaktioner
DocType: Budget,Budget Accounts,budget-konton
DocType: Employee,Internal Work History,Intern Arbetserfarenhet
DocType: Bank Statement Transaction Entry,New Transactions,Nya transaktioner
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Ackumulerade avskrivningar Belopp
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Privatkapital
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Leverantörs Scorecard Variable
DocType: Shift Type,Working Hours Threshold for Half Day,Tröskel för arbetstider för halv dag
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},Var god skapa kvitto eller inköpsfaktura för objektet {0}
DocType: Job Card,Material Transferred,Material överfört
DocType: Employee Advance,Due Advance Amount,Förskottsbelopp
DocType: Maintenance Visit,Customer Feedback,Kund Feedback
DocType: Account,Expense,Utgift
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,Värdering kan inte vara större än maximal poäng
DocType: Support Search Source,Source Type,Källtyp
DocType: Course Content,Course Content,Kursinnehåll
DocType: Item Attribute,From Range,Från räckvidd
DocType: BOM,Set rate of sub-assembly item based on BOM,Ange sats för delmonteringsobjekt baserat på BOM
DocType: Inpatient Occupancy,Invoiced,faktureras
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,WooCommerce-produkter
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},Syntax error i formel eller tillstånd: {0}
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,Punkt {0} ignoreras eftersom det inte är en lagervara
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","För att inte tillämpa prissättning regel i en viss transaktion, bör alla tillämpliga prissättning regler inaktiveras."
DocType: Payment Term,Day(s) after the end of the invoice month,Dag (er) efter fakturamånadens slut
DocType: Assessment Group,Parent Assessment Group,Parent Assessment Group
DocType: Employee Checkin,Shift Actual End,Skift faktisk slut
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,Jobb
,Sales Order Trends,Försäljningsorder Trender
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,The 'From Package No.' field must neither be empty nor it's value less than 1.,&quot;Från paketnummer&quot; Fältet får inte vara tomt eller det är värdet mindre än 1.
DocType: Employee,Held On,Höll På
DocType: Job Card,Production Item,Produktions artikel
,Employee Information,Anställd Information
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},Hälso-och sjukvårdspersonal är inte tillgänglig på {0}
DocType: Stock Entry Detail,Additional Cost,Extra kostnad
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Voucher No, if grouped by Voucher",Kan inte filtrera baserat på kupong nr om grupperad efter kupong
DocType: Quality Inspection,Incoming,Inkommande
apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,Standardskattmallar för försäljning och inköp skapas.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Bedömningsresultatrekord {0} existerar redan.
DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Exempel: ABCD. #####. Om serier är inställda och batchnummer inte nämns i transaktioner, kommer automatiskt batchnummer att skapas baserat på denna serie. Om du alltid vill uttryckligen ange parti nr för det här objektet, lämna det här tomt. Obs! Den här inställningen kommer att prioriteras över namngivningssprefixet i lagerinställningar."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Utgående beskattningsbara leveranser (noll betyg)
DocType: BOM,Materials Required (Exploded),Material som krävs (Expanderad)
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,baserat på
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Submit Review,Skicka recension
DocType: Contract,Party User,Party-användare
apps/erpnext/erpnext/controllers/buying_controller.py,Assets not created for <b>{0}</b>. You will have to create asset manually.,Tillgångar som inte skapats för <b>{0}</b> . Du måste skapa tillgångar manuellt.
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Vänligen ange Företagets filter tomt om Group By är &quot;Company&quot;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Publiceringsdatum kan inte vara framtida tidpunkt
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Rad # {0}: Löpnummer {1} inte stämmer överens med {2} {3}
DocType: Stock Entry,Target Warehouse Address,Mållageradress
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Tillfällig ledighet
DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Tiden före skiftets starttid under vilken anställdens incheckning övervägs för närvaro.
DocType: Agriculture Task,End Day,Slutdag
DocType: Batch,Batch ID,Batch-ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},Obs: {0}
DocType: Stock Settings,Action if Quality inspection is not submitted,Åtgärd om kvalitetskontroll inte lämnas in
,Delivery Note Trends,Följesedel Trender
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Veckans Sammanfattning
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,I lager Antal
,Daily Work Summary Replies,Dagliga Arbets Sammanfattning Svar
DocType: Delivery Trip,Calculate Estimated Arrival Times,Beräkna uppskattade ankomsttider
apps/erpnext/erpnext/accounts/general_ledger.py,Account: {0} can only be updated via Stock Transactions,Konto: {0} kan endast uppdateras via aktietransaktioner
DocType: Student Group Creation Tool,Get Courses,få Banor
DocType: Tally Migration,ERPNext Company,ERPNext Company
DocType: Shopify Settings,Webhooks,Webhooks
DocType: Bank Account,Party,Parti
DocType: Healthcare Settings,Patient Name,Patientnamn
DocType: Variant Field,Variant Field,Variant Field
DocType: Asset Movement Item,Target Location,Målplats
DocType: Sales Order,Delivery Date,Leveransdatum
DocType: Opportunity,Opportunity Date,Möjlighet Datum
DocType: Employee,Health Insurance Provider,Sjukförsäkringsleverantör
DocType: Service Level,Holiday List (ignored during SLA calculation),Semesterlista (ignoreras under SLA-beräkningen)
DocType: Products Settings,Show Availability Status,Visa tillgänglighet Status
DocType: Purchase Receipt,Return Against Purchase Receipt,Återgå mot inköpskvitto
DocType: Water Analysis,Person Responsible,Ansvarig person
DocType: Request for Quotation Item,Request for Quotation Item,Offertförfrågan Punkt
DocType: Purchase Order,To Bill,Till Bill
DocType: Material Request,% Ordered,% Beställt
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",För kursbaserad studentgrupp kommer kursen att valideras för varje student från de inskrivna kurser i programinsökan.
DocType: Employee Grade,Employee Grade,Anställd grad
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Ackord
DocType: GSTR 3B Report,June,juni
DocType: Share Balance,From No,Från nr
DocType: Shift Type,Early Exit Grace Period,Period för tidig utgång
DocType: Task,Actual Time (in Hours),Faktisk tid (i timmar)
DocType: Employee,History In Company,Historia Företaget
DocType: Customer,Customer Primary Address,Kundens primära adress
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Connected,Samtal ansluten
apps/erpnext/erpnext/config/crm.py,Newsletters,Nyhetsbrev
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Referensnummer.
DocType: Drug Prescription,Description/Strength,Beskrivning / Styrka
apps/erpnext/erpnext/config/hr.py,Energy Point Leaderboard,Energy Point Leaderboard
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Skapa ny betalning / journalinmatning
DocType: Certification Application,Certification Application,Certifieringsansökan
DocType: Leave Type,Is Optional Leave,Är Valfritt Lämna
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Förklara förlorad
DocType: Share Balance,Is Company,Är Företag
DocType: Pricing Rule,Same Item,Samma artikel
DocType: Stock Ledger Entry,Stock Ledger Entry,Lager Ledger Entry
DocType: Quality Action Resolution,Quality Action Resolution,Kvalitetsåtgärd upplösning
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} på halvdags ledighet på {1}
DocType: Department,Leave Block List,Lämna Block List
DocType: Purchase Invoice,Tax ID,Skatte ID
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Column must be blank,Produkt  {0} är inte inställt för Serial Nos. Kolumn måste vara tom
apps/erpnext/erpnext/regional/india/utils.py,Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,Antingen GST-transporter-ID eller fordonsnummer krävs om transportläget är väg
DocType: Accounts Settings,Accounts Settings,Kontoinställningar
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,Godkänna
DocType: Loyalty Program,Customer Territory,Kundområde
DocType: Email Digest,Sales Orders to Deliver,Försäljningsorder att leverera
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Number of new Account, it will be included in the account name as a prefix","Antal nya konton, det kommer att ingå i kontonamnet som ett prefix"
DocType: Maintenance Team Member,Team Member,Lagmedlem
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Fakturor utan leveransplats
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,Inget resultat att skicka in
DocType: Customer,Sales Partner and Commission,Försäljningen Partner och kommissionen
DocType: Loan,Rate of Interest (%) / Year,Hastighet av intresse (%) / år
,Project Quantity,projekt Kvantitet
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'",Totalt {0} för alla objekt är noll kan vara du bör ändra &#39;Fördela avgifter bygger på&#39;
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,Hittills kan inte vara mindre än från datum
DocType: Opportunity,To Discuss,Att Diskutera
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} to complete this transaction.,{0} enheter av {1} behövs i {2} för att slutföra denna transaktion.
DocType: Loan Type,Rate of Interest (%) Yearly,Hastighet av intresse (%) Årlig
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,Kvalitetsmål.
DocType: Support Settings,Forum URL,Forumadress
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,Tillfälliga konton
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},Källplacering krävs för tillgången {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,Svart
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosions Punkt
DocType: Shareholder,Contact List,Kontaktlista
DocType: Account,Auditor,Redigerare
DocType: Project,Frequency To Collect Progress,Frekvens för att samla framsteg
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,{0} objekt producerade
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} läggs inte till i tabellen
DocType: Payment Entry,Party Bank Account,Partibankonto
DocType: Cheque Print Template,Distance from top edge,Avståndet från den övre kanten
DocType: POS Closing Voucher Invoices,Quantity of Items,Antal objekt
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List {0} is disabled or does not exist,Prislista {0} är inaktiverad eller inte existerar
DocType: Purchase Invoice,Return,Återgå
DocType: Account,Disable,Inaktivera
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,Verk betalning krävs för att göra en betalning
DocType: Task,Pending Review,Väntar På Granskning
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.","Redigera i hel sida för fler alternativ som tillgångar, serienummer, partier etc."
DocType: Leave Type,Maximum Continuous Days Applicable,Maximala kontinuerliga dagar gäller
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Åldringsområde 4
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} är inte inskriven i batch {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}","Tillgångs {0} kan inte skrotas, eftersom det redan är {1}"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,Kontroller krävs
DocType: Task,Total Expense Claim (via Expense Claim),Totalkostnadskrav (via utgiftsräkning)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Absent,Mark Frånvarande
DocType: Job Applicant Source,Job Applicant Source,Jobbsökande källa
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,IGST-belopp
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Misslyckades med att konfigurera företaget
DocType: Asset Repair,Asset Repair,Asset Repair
DocType: Warehouse,Warehouse Type,Lagertyp
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Rad {0}: Valuta för BOM # {1} bör vara lika med den valda valutan {2}
DocType: Journal Entry Account,Exchange Rate,Växelkurs
DocType: Patient,Additional information regarding the patient,Ytterligare information om patienten
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Sales Order {0} is not submitted,Kundorder {0} är inte lämnat
DocType: Homepage,Tag Line,Tag Linje
DocType: Fee Component,Fee Component,avgift Komponent
apps/erpnext/erpnext/config/hr.py,Fleet Management,Fleet Management
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,Grödor &amp; Lands
DocType: Shift Type,Enable Exit Grace Period,Aktivera Exit Grace Period
DocType: Cheque Print Template,Regular,Regelbunden
DocType: Fertilizer,Density (if liquid),Densitet (om vätska)
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,Total weightage av alla kriterier för bedömning måste vara 100%
DocType: Purchase Order Item,Last Purchase Rate,Senaste Beställningsvärde
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,"Asset {0} cannot be received at a location and \
							given to employee in a single movement",Tillgång {0} kan inte tas emot på en plats och \ ges till anställd i en enda rörelse
DocType: GSTR 3B Report,August,augusti
DocType: Account,Asset,Tillgång
DocType: Quality Goal,Revised On,Reviderad den
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock cannot exist for Item {0} since has variants,Stock kan inte existera till punkt {0} sedan har varianter
DocType: Healthcare Practitioner,Mobile,Mobil
DocType: Issue,Reset Service Level Agreement,Återställ avtal om servicenivå
,Sales Person-wise Transaction Summary,Försäljningen person visa transaktion Sammanfattning
DocType: Training Event,Contact Number,Kontaktnummer
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} does not exist,Lager {0} existerar inte
DocType: Cashier Closing,Custody,Vårdnad
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Beslutsunderlag för anställningsskattbefrielse
DocType: Monthly Distribution,Monthly Distribution Percentages,Månadsdistributions Procentsatser
apps/erpnext/erpnext/stock/doctype/batch/batch.py,The selected item cannot have Batch,Det valda alternativet kan inte ha Batch
DocType: Delivery Note,% of materials delivered against this Delivery Note,% Av material som levereras mot detta följesedel
DocType: Asset Maintenance Log,Has Certificate,Har certifikat
DocType: Appointment,Customer Details,Kunduppgifter
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Skriv ut IRS 1099-formulär
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Kontrollera om tillgången kräver förebyggande underhåll eller kalibrering
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Företagets förkortning får inte ha mer än 5 tecken
DocType: Employee,Reports to,Rapporter till
,Unpaid Expense Claim,Obetald räkningen
DocType: Payment Entry,Paid Amount,Betalt belopp
DocType: Assessment Plan,Supervisor,Handledare
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Retention Stock Entry
,Available Stock for Packing Items,Tillgängligt lager för förpackningsprodukter
DocType: Item Variant,Item Variant,Produkt Variant
DocType: Employee Skill Map,Trainings,träningar
,Work Order Stock Report,Arbetsordningsbeståndsrapport
DocType: Purchase Receipt,Auto Repeat Detail,Auto Repeat Detail
DocType: Assessment Result Tool,Assessment Result Tool,Bedömningsresultatverktyg
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Som tillsynsman
DocType: Leave Policy Detail,Leave Policy Detail,Lämna policy detaljer
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Punkt
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Inlämnade order kan inte tas bort
DocType: Leave Control Panel,Department (optional),Avdelning (valfritt)
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Kontosaldo redan i Debit, du är inte tillåten att ställa ""Balans måste vara"" som ""Kredit"""
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} worth item <b>{2}</b>, the scheme <b>{3}</b> will be applied on the item.
				",Om du {0} {1} värt objekt <b>{2}</b> kommer schemat <b>{3}</b> att tillämpas på objektet.
DocType: Customer Feedback,Quality Management,Kvalitetshantering
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,Punkt {0} har inaktiverats
DocType: Project,Total Billable Amount (via Timesheets),Totala fakturabeloppet (via tidstabeller)
DocType: Agriculture Task,Previous Business Day,Tidigare företagsdag
DocType: Loan,Repay Fixed Amount per Period,Återbetala fast belopp per period
DocType: Employee,Health Insurance No,Sjukförsäkring nr
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Skattebefrielse bevis
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},Vänligen ange antal förpackningar för artikel {0}
DocType: Quality Procedure,Processes,processer
DocType: Shift Type,First Check-in and Last Check-out,Första incheckning och sista utcheckning
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Totala skattepliktiga beloppet
DocType: Employee External Work History,Employee External Work History,Anställd Extern Arbetserfarenhet
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Jobbkort {0} skapat
DocType: Opening Invoice Creation Tool,Purchase,Inköp
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,Balans Antal
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Villkoren kommer att tillämpas på alla valda objekt kombinerade.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Mål kan inte vara tomt
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,Inskrivning av studenter
DocType: Item Group,Parent Item Group,Överordnad produktgrupp
DocType: Appointment Type,Appointment Type,Avtalstyp
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{0} för {1}
DocType: Healthcare Settings,Valid number of days,Giltigt antal dagar
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Kostnadsställen
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Starta om prenumerationen
DocType: Linked Plant Analysis,Linked Plant Analysis,Länkad analys av växter
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,Transporter ID
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,Värde proposition
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,I takt med vilket leverantörens valuta omvandlas till företagets basvaluta
DocType: Purchase Invoice Item,Service End Date,Service Slutdatum
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Row #{0}: Timings conflicts with row {1},Rad # {0}: Konflikt med tider rad {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Tillåt nollvärderingsfrekvens
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Tillåt nollvärderingsfrekvens
DocType: Bank Guarantee,Receiving,Tar emot
DocType: Training Event Employee,Invited,inbjuden
apps/erpnext/erpnext/config/accounts.py,Setup Gateway accounts.,Setup Gateway konton.
apps/erpnext/erpnext/config/integrations.py,Connect your bank accounts to ERPNext,Anslut dina bankkonton till ERPNext
DocType: Employee,Employment Type,Anställnings Typ
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Gör projekt från en mall.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,Fasta tillgångar
DocType: Payment Entry,Set Exchange Gain / Loss,Ställ Exchange vinst / förlust
,GST Purchase Register,GST inköpsregister
,Cash Flow,Pengaflöde
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Combined invoice portion must equal 100%,Kombinerad fakturahandel måste vara lika med 100%
DocType: Item Default,Default Expense Account,Standardutgiftskonto
DocType: GST Account,CGST Account,CGST-konto
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Email ID,Student E ID
DocType: Employee,Notice (days),Observera (dagar)
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,POS Closing Voucher Fakturor
DocType: Tax Rule,Sales Tax Template,Moms Mall
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Ladda ner JSON
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Betala mot förmånskrav
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,Uppdatera kostnadscentrums nummer
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,Välj objekt för att spara fakturan
DocType: Employee,Encashment Date,Inlösnings Datum
DocType: Training Event,Internet,internet
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Seller Information,Säljarinformation
DocType: Special Test Template,Special Test Template,Särskild testmall
DocType: Account,Stock Adjustment,Lager för justering
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Default Activity Cost exists for Activity Type - {0},Standard Aktivitetskostnad existerar för Aktivitetstyp - {0}
DocType: Work Order,Planned Operating Cost,Planerade driftkostnader
DocType: Academic Term,Term Start Date,Term Startdatum
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Authentication Failed,Autentisering misslyckades
apps/erpnext/erpnext/config/accounts.py,List of all share transactions,Lista över alla aktie transaktioner
DocType: Supplier,Is Transporter,Är Transporter
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,Importera försäljningsfaktura från Shopify om betalning är markerad
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Oppräknare
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Både provperiodens startdatum och provperiodens slutdatum måste ställas in
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Genomsnitt
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Totala betalningsbeloppet i betalningsplanen måste vara lika med Grand / Rounded Total
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate","""Kundförsett objekt"" kan inte ha värderingskurs"
DocType: Subscription Plan Detail,Plan,Planen
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Bank Statement balance as per General Ledger,Kontoutdrag balans per huvudbok
DocType: Job Applicant,Applicant Name,Sökandes Namn
DocType: Authorization Rule,Customer / Item Name,Kund / artikelnamn
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

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

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

Note: BOM = Bill of Materials","Grupp ** artiklar ** till en annan ** Artkel **. Detta är användbart om du vill bunta vissa ** artiklar ** i ett paket och du behålla lager av de packade ** artiklarna ** och inte den sammanlagda ** artikeln **. Paketets ** Artiklar ** kommer att ha ""Är Lagervara"" som ""Nej"" och ""Är säljprodukt"" som ""Ja"". Till exempel: Om du säljer bärbara datorer och Ryggsäckar separat och har ett speciellt pris om kunden köper båda, sedan Laptop + Backpack kommer att bli en ny produkt Bundle Punkt. Obs! BOM = Bill of Materials"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No is mandatory for Item {0},Löpnummer är obligatoriskt för punkt {0}
DocType: Website Attribute,Attribute,Attribut
DocType: Staffing Plan Detail,Current Count,Aktuell räkning
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,Ange från / till intervallet
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,Öppning {0} Faktura skapad
DocType: Serial No,Under AMC,Enligt AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Item valuation rate is recalculated considering landed cost voucher amount,Produkt värderingsvärdet omräknas pga angett rabattvärde
apps/erpnext/erpnext/config/selling.py,Default settings for selling transactions.,Standardinställningar för att försäljnings transaktioner.
DocType: Guardian,Guardian Of ,väktare
DocType: Grading Scale Interval,Threshold,Tröskel
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filtrera anställda efter (valfritt)
DocType: BOM Update Tool,Current BOM,Aktuell BOM
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Balans (Dr - Cr)
DocType: Pick List,Qty of Finished Goods Item,Antal färdigvaror
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,Lägg till Serienr
DocType: Work Order Item,Available Qty at Source Warehouse,Tillgänglig kvantitet vid källlagret
apps/erpnext/erpnext/config/support.py,Warranty,Garanti
DocType: Purchase Invoice,Debit Note Issued,Debetnota utfärdad
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,"Search by item code, serial number, batch no or barcode","Sök efter artikelnummer, serienummer, batchnummer eller streckkod"
DocType: Work Order,Warehouses,Lager
DocType: Shift Type,Last Sync of Checkin,Senaste synkronisering av Checkin
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,Lägg till en ny adress
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,{0} tillgång kan inte överföras
DocType: Hotel Room Pricing,Hotel Room Pricing,Hotellrumspriser
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Det går inte att markera Inpatient Record Discharged, det finns Fakturerade Fakturor {0}"
DocType: Subscription,Days Until Due,Dagar fram till förfall
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Denna artikel är en variant av {0} (mall).
DocType: Workstation,per hour,per timme
DocType: Blanket Order,Purchasing,Köp av
DocType: Announcement,Announcement,Meddelande
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Customer LPO,Kund LPO
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",För gruppbaserad studentgrupp kommer studentenbatchen att valideras för varje student från programansökan.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Lager kan inte tas bort som lagrets huvudbok  existerar för det här lagret.
apps/erpnext/erpnext/public/js/setup_wizard.js,Distribution,Fördelning
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee status cannot be set to 'Left' as following employees are currently reporting to this employee:&nbsp;,Anställdestatus kan inte ställas in som &quot;Vänster&quot; eftersom följande anställda för närvarande rapporterar till den anställda:
DocType: Journal Entry Account,Loan,Lån
DocType: Expense Claim Advance,Expense Claim Advance,Expense Claim Advance
DocType: Lab Test,Report Preference,Rapportpreferens
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,Frivillig information.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Projektledare
,Quoted Item Comparison,Citerade föremål Jämförelse
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},Överlappa i poäng mellan {0} och {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,Skicka
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Max discount allowed for item: {0} is {1}%,Max rabatt tillåtet för objektet: {0} är {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Net Asset value as on,Substansvärdet på
DocType: Crop,Produce,Producera
DocType: Hotel Settings,Default Taxes and Charges,Standard skatter och avgifter
DocType: Account,Receivable,Fordran
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Rad # {0}: Inte tillåtet att byta leverantör som beställning redan existerar
DocType: Stock Entry,Material Consumption for Manufacture,Materialförbrukning för tillverkning
DocType: Item Alternative,Alternative Item Code,Alternativ produktkod
DocType: Appointment Booking Settings,Notify Via Email,Meddela via e-post
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Roll som får godkänna transaktioner som överstiger kreditgränser.
DocType: Production Plan,Select Items to Manufacture,Välj produkter i Tillverkning
DocType: Delivery Stop,Delivery Stop,Leveransstopp
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time","Basdata synkronisering, kan det ta lite tid"
DocType: Material Request Plan Item,Material Issue,Materialproblem
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Free item not set in the pricing rule {0},Gratisobjekt inte fastställt i prisregeln {0}
DocType: Employee Education,Qualification,Kvalifikation
DocType: Item Price,Item Price,Produkt Pris
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Soap &amp; tvättmedel
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Employee {0} does not belongs to the company {1},Anställd {0} tillhör inte företaget {1}
DocType: BOM,Show Items,Visa artiklar
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Duplicerad skattedeklaration av {0} för perioden {1}
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,Från Tiden kan inte vara större än då.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,Vill du anmäla alla kunder via e-post?
DocType: Subscription Plan,Billing Interval,Faktureringsintervall
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,Motion Picture &amp; Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,Beställde
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,Återuppta
DocType: Salary Detail,Component,Komponent
DocType: Video,YouTube,Youtube
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py,Row {0}: {1} must be greater than 0,Rad {0}: {1} måste vara större än 0
DocType: Assessment Criteria,Assessment Criteria Group,Bedömningskriteriegrupp
DocType: Healthcare Settings,Patient Name By,Patientnamn Av
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},Periodiseringsjournalen Inträde för löner från {0} till {1}
DocType: Sales Invoice Item,Enable Deferred Revenue,Aktivera uppskjuten intäkt
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},Ingående ackumulerade avskrivningar måste vara mindre än lika med {0}
DocType: Appointment Booking Settings,Appointment Details,Utnämningsuppgifter
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Finished Product,Färdig produkt
DocType: Warehouse,Warehouse Name,Lager Namn
DocType: Naming Series,Select Transaction,Välj transaktion
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Ange Godkännande roll eller godkänna Användare
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Servicenivåavtal med entitetstyp {0} och enhet {1} finns redan.
DocType: Journal Entry,Write Off Entry,Avskrivningspost
DocType: BOM,Rate Of Materials Based On,Hastighet av material baserade på
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.",Om det är aktiverat är fältet Academic Term obligatoriskt i Programinmälningsverktyget.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Värden för undantagna, nollklassade och icke-GST-leveranser"
apps/erpnext/erpnext/regional/report/datev/datev.py,<b>Company</b> is a mandatory filter.,<b>Företaget</b> är ett obligatoriskt filter.
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Avmarkera alla
DocType: Purchase Taxes and Charges,On Item Quantity,På artikelkvantitet
DocType: POS Profile,Terms and Conditions,Villkor
DocType: Asset,Booked Fixed Asset,Bokad fast tillgång
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,To Date should be within the Fiscal Year. Assuming To Date = {0},Till Datum bör ligga inom räkenskapsåret. Förutsatt att Dag = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Här kan du behålla längd, vikt, allergier, medicinska problem etc"
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts...,Skapa konton ...
DocType: Leave Block List,Applies to Company,Gäller Företag
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot cancel because submitted Stock Entry {0} exists,Det går inte att avbryta eftersom lämnad Lagernotering {0} existerar
DocType: Loan,Disbursement Date,utbetalning Datum
DocType: Service Level Agreement,Agreement Details,Avtal detaljer
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Start Date of Agreement can't be greater than or equal to End Date.,Startdatum för avtal kan inte vara större än eller lika med slutdatum.
DocType: BOM Update Tool,Update latest price in all BOMs,Uppdatera senaste priset i alla BOMs
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,Klar
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,Vårdjournal
DocType: Vehicle,Vehicle,Fordon
DocType: Purchase Invoice,In Words,I Ord
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,To date needs to be before from date,Hittills måste vara före från datum
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,Ange bankens eller utlåningsinstitutets namn innan du skickar in.
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,{0} måste skickas in
DocType: POS Profile,Item Groups,artikelgrupper
DocType: Company,Standard Working Hours,Standard arbetstider
DocType: Sales Order Item,For Production,För produktion
DocType: Payment Request,payment_url,payment_url
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Balans i kontovaluta
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please add a Temporary Opening account in Chart of Accounts,Lägg till ett tillfälligt öppnings konto i kontoplan
DocType: Customer,Customer Primary Contact,Kund Primärkontakt
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Lead%
DocType: Bank Guarantee,Bank Account Info,Bankkontoinformation
DocType: Bank Guarantee,Bank Guarantee Type,Bankgaranti Typ
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for valid IBAN {},BankAccount.validate_iban () misslyckades med giltigt IBAN {}
DocType: Payment Schedule,Invoice Portion,Fakturahandel
,Asset Depreciations and Balances,Asset Avskrivningar och saldon
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},Belopp {0} {1} överförs från {2} till {3}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} har inte ett vårdgivarschema. Lägg till det i Vårdgivare
DocType: Sales Invoice,Get Advances Received,Få erhållna förskott
DocType: Email Digest,Add/Remove Recipients,Lägg till / ta bort mottagare
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js,"To set this Fiscal Year as Default, click on 'Set as Default'","För att ställa denna verksamhetsåret som standard, klicka på &quot;Ange som standard&quot;"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,Beloppet av TDS dras av
DocType: Production Plan,Include Subcontracted Items,Inkludera underleverantörer
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,Gå med
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Brist Antal
DocType: Purchase Invoice,Input Service Distributor,Distributör av ingångsservice
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Punkt variant {0} finns med samma attribut
DocType: Loan,Repay from Salary,Repay från Lön
DocType: Exotel Settings,API Token,API-token
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Begärande betalning mot {0} {1} för mängden {2}
DocType: Additional Salary,Salary Slip,Lön Slip
apps/erpnext/erpnext/support/doctype/issue/issue.py,Allow Resetting Service Level Agreement from Support Settings.,Tillåt återställning av servicenivåavtal från supportinställningar.
apps/erpnext/erpnext/projects/doctype/task/task.py,{0} can not be greater than {1},{0} kan inte vara större än {1}
DocType: Lead,Lost Quotation,förlorade Offert
DocType: Pricing Rule,Margin Rate or Amount,Marginal snabbt eller hur mycket
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,&quot;Till datum&quot; krävs
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,Faktisk antal: tillgängligt antal i lagret.
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Skapa följesedlar efter paket som skall levereras. Används för att meddela kollinummer, paketets innehåll och dess vikt."
DocType: Sales Invoice Item,Sales Order Item,Försäljning Beställningsvara
DocType: Salary Slip,Payment Days,Betalningsdagar
DocType: Stock Settings,Convert Item Description to Clean HTML,Konvertera artikelbeskrivning för att rena HTML
DocType: Patient,Dormant,Vilande
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Avdragsskatt för oanställda anställningsförmåner
DocType: Salary Slip,Total Interest Amount,Summa räntebelopp
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,Lager med underordnade noder kan inte omvandlas till liggaren
DocType: BOM,Manage cost of operations,Hantera kostnaderna för verksamheten
DocType: Accounts Settings,Stale Days,Stale Days
DocType: Travel Itinerary,Arrival Datetime,Ankomst Datetime
DocType: Tax Rule,Billing Zipcode,Fakturering Postnummer
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
DocType: Crop,Row Spacing UOM,Row Spacing UOM
DocType: Assessment Result Detail,Assessment Result Detail,Detaljer Bedömningsresultat
DocType: Employee Education,Employee Education,Anställd Utbildning
DocType: Service Day,Workday,Arbetsdag
apps/erpnext/erpnext/setup/doctype/terms_and_conditions/terms_and_conditions.py,At least one of the Applicable Modules should be selected,Åtminstone en av de tillämpliga modulerna ska väljas
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Dubblett grupp finns i posten grupptabellen
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Tree of Quality Procedures.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,"There's no Employee with Salary Structure: {0}. \
			Assign {1} to an Employee to preview Salary Slip",Det finns ingen anställd med lönestruktur: {0}. \ Tilldela {1} till en anställd för att förhandsgranska Salary Slip
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,Det behövs för att hämta produktdetaljer.
DocType: Fertilizer,Fertilizer Name,Namn på gödselmedel
DocType: Salary Slip,Net Pay,Nettolön
DocType: Cash Flow Mapping Accounts,Account,Konto
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} has already been received,Serienummer {0} redan har mottagits
,Requested Items To Be Transferred,Efterfrågade artiklar som ska överföras
DocType: Expense Claim,Vehicle Log,fordonet Log
DocType: Sales Invoice,Is Discounted,Är rabatterad
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,Åtgärd om ackumulerad månadsbudget överskrider faktiska
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Skapa separat betalningsanmälan mot förmånskrav
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Förekomst av feber (temp&gt; 38,5 ° C eller upprepad temperatur&gt; 38 ° C / 100,4 ° F)"
DocType: Customer,Sales Team Details,Försäljnings Team Detaljer
apps/erpnext/erpnext/accounts/page/pos/pos.js,Delete permanently?,Ta bort permanent?
DocType: Expense Claim,Total Claimed Amount,Totalt yrkade beloppet
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,Potentiella möjligheter för att sälja.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,{} is an invalid Attendance Status.,{} är en ogiltig närvarostatus.
DocType: Shareholder,Folio no.,Folio nr.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},Ogiltigt {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,Sjukskriven
DocType: Email Digest,Email Digest,E-postutskick
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,"As raw materials projected quantity is more than required quantity, there is no need to create material request.
			Still if you want to make material request, kindly enable <b>Ignore Existing Projected Quantity</b> checkbox","Eftersom den beräknade mängden råmaterial är mer än den erforderliga mängden, finns det inget behov att skapa materialförfrågan. Om du vill göra materialförfrågan, aktivera vänligen kryssrutan <b>Ignorera befintligt projicerat antal</b>"
DocType: Delivery Note,Billing Address Name,Faktureringsadress Namn
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Varuhus
,Item Delivery Date,Leveransdatum för artikel
DocType: Selling Settings,Sales Update Frequency,Försäljnings uppdateringsfrekvens
DocType: Production Plan,Material Requested,Material som begärs
DocType: Warehouse,PIN,STIFT
DocType: Bin,Reserved Qty for sub contract,Reserverad Antal för delkontrakt
DocType: Patient Service Unit,Patinet Service Unit,Patinet Service Unit
DocType: Sales Invoice,Base Change Amount (Company Currency),Basförändring Belopp (Company valuta)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,Inga bokföringsposter för följande lager
apps/erpnext/erpnext/shopping_cart/cart.py,Only {0} in stock for item {1},Endast {0} i lager för artikel {1}
DocType: Account,Chargeable,Avgift
DocType: Company,Change Abbreviation,Ändra Förkortning
DocType: Contract,Fulfilment Details,Uppfyllningsdetaljer
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Betala {0} {1}
DocType: Employee Onboarding,Activities,verksamhet
DocType: Expense Claim Detail,Expense Date,Utgiftsdatum
DocType: Item,No of Months,Antal månader
DocType: Item,Max Discount (%),Max rabatt (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,Kreditdagar kan inte vara ett negativt tal
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Upload a statement,Ladda upp ett uttalande
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report this item,Rapportera det här objektet
DocType: Purchase Invoice Item,Service Stop Date,Servicestoppdatum
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,Sista beställningsmängd
DocType: Cash Flow Mapper,e.g Adjustments for:,t.ex. justeringar för:
apps/erpnext/erpnext/stock/doctype/item/item.py," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item",{0} Det behållna provet är baserat på en batch. Kontrollera att batchnummer finns för att behålla provet på objektet.
DocType: Task,Is Milestone,Är Milestone
DocType: Certification Application,Yet to appear,Ändå att visas
DocType: Delivery Stop,Email Sent To,Email skickat till
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Lönestruktur hittades inte för anställd {0} och datum {1}
DocType: Job Card Item,Job Card Item,Jobbkortsartikel
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Tillåt kostnadscentrum vid inmatning av balansräkningskonto
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Sammanfoga med befintligt konto
DocType: Budget,Warn,Varna
apps/erpnext/erpnext/erpnext_integrations/connectors/woocommerce_connection.py,Stores - {0},Butiker - {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Alla objekt har redan överförts för denna arbetsorder.
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Alla andra anmärkningar, anmärkningsvärt ansträngning som ska gå i registren."
DocType: Bank Account,Company Account,Företagskonto
DocType: Asset Maintenance,Manufacturing User,Tillverkningsanvändare
DocType: Purchase Invoice,Raw Materials Supplied,Råvaror Levereras
DocType: Subscription Plan,Payment Plan,Betalningsplan
DocType: Bank Transaction,Series,Serie
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Currency of the price list {0} must be {1} or {2},Valutan i prislistan {0} måste vara {1} eller {2}
apps/erpnext/erpnext/config/accounts.py,Subscription Management,Prenumerationshantering
DocType: Appraisal,Appraisal Template,Bedömning mall
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,Att stifta kod
DocType: Soil Texture,Ternary Plot,Ternary Plot
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,Markera det här för att aktivera en schemalagd daglig synkroniseringsrutin via schemaläggaren
DocType: Item Group,Item Classification,Produkt Klassificering
apps/erpnext/erpnext/templates/pages/home.html,Publications,publikationer
DocType: Driver,License Number,Licensnummer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Servicebesökets syfte
DocType: Stock Entry,Stock Entry Type,Lagerinmatningstyp
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Faktura Patient Registration
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,Allmän huvudbok
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,Till räkenskapsår
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,Se prospekts
DocType: Program Enrollment Tool,New Program,nytt program
DocType: Item Attribute Value,Attribute Value,Attribut Värde
DocType: POS Closing Voucher Details,Expected Amount,Förväntad mängd
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Skapa flera
,Itemwise Recommended Reorder Level,Produktvis Rekommenderad Ombeställningsnivå
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,Anställd {0} i betyg {1} har ingen standardlovspolicy
DocType: Salary Detail,Salary Detail,lön Detalj
DocType: Email Digest,New Purchase Invoice,Ny inköpsfaktura
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,Välj {0} först
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Tillagt {0} användare
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Less Than Amount,Mindre än belopp
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent",När det gäller program med flera nivåer kommer kunderna automatiskt att tilldelas den aktuella tiern enligt deras tillbringade
DocType: Appointment Type,Physician,Läkare
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,Batch {0} av Punkt {1} har löpt ut.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,samråd
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Slutade bra
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Artikelpriset visas flera gånger baserat på prislista, leverantör / kund, valuta, artikel, UOM, antal och datum."
DocType: Sales Invoice,Commission,Kommissionen
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) kan inte vara större än den planerade kvantiteten ({2}) i arbetsorder {3}
DocType: Certification Application,Name of Applicant,Sökandes namn
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Tidrapportering för tillverkning.
DocType: Quick Stock Balance,Quick Stock Balance,Snabb lagerbalans
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Delsumma
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Kan inte ändra Variantegenskaper efter aktiehandel. Du måste skapa ett nytt objekt för att göra detta.
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA-mandat
DocType: Healthcare Practitioner,Charges,Kostnader
DocType: Production Plan,Get Items For Work Order,Få artiklar för arbetsorder
DocType: Salary Detail,Default Amount,Standard Mängd
DocType: Lab Test Template,Descriptive,Beskrivande
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,Lagret hittades inte i systemet
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Month's Summary,Månadens Sammanfattning
DocType: Quality Inspection Reading,Quality Inspection Reading,Kvalitetskontroll Läsning
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,`Freeze Stocks Older Than` should be smaller than %d days.,"""Frys lager äldre än"" bör vara mindre än %d dagar."
DocType: Tax Rule,Purchase Tax Template,Köp Tax Mall
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Earliest Age,Tidigaste ålder
DocType: Quality Goal,Revision,Revision
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Hälsovårdstjänster
,Project wise Stock Tracking,Projektvis lager Spårning
DocType: DATEV Settings,Regional,Regional
apps/erpnext/erpnext/config/healthcare.py,Laboratory,Laboratorium
DocType: UOM Category,UOM Category,UOM Kategori
DocType: Clinical Procedure Item,Actual Qty (at source/target),Faktiska Antal (vid källa/mål)
DocType: Item Customer Detail,Ref Code,Referenskod
DocType: Accounts Settings,Address used to determine Tax Category in transactions.,Adress som används för att bestämma skattekategori i transaktioner.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,Kundgrupp krävs i POS-profil
DocType: HR Settings,Payroll Settings,Sociala Inställningar
apps/erpnext/erpnext/config/accounts.py,Match non-linked Invoices and Payments.,Matcha ej bundna fakturor och betalningar.
DocType: POS Settings,POS Settings,POS-inställningar
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,Beställa
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Skapa faktura
DocType: Email Digest,New Purchase Orders,Nya beställningar
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Root kan inte ha en överordnat kostnadsställe
DocType: POS Closing Voucher,Expense Details,Kostnadsinformation
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,Välj märke ...
apps/erpnext/erpnext/public/js/setup_wizard.js,Non Profit (beta),Non-profit (beta)
apps/erpnext/erpnext/portal/doctype/products_settings/products_settings.py,"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Filterfält Rad # {0}: Fältnamn <b>{1}</b> måste vara av typen &quot;Länk&quot; eller &quot;Tabell MultiSelect&quot;
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,Ackumulerade avskrivningar som på
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Anställningsskatt undantagskategori
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Beloppet bör inte vara mindre än noll.
DocType: Sales Invoice,C-Form Applicable,C-Form Tillämplig
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Operation Time must be greater than 0 for Operation {0},Operation Time måste vara större än 0 för drift {0}
DocType: Support Search Source,Post Route String,Skriv ruttsträng
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,Warehouse är obligatoriskt
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to create website,Misslyckades med att skapa webbplats
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM Omvandlings Detalj
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,Antagning och registrering
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Retention Stock Entry already created or Sample Quantity not provided,Retention Stock Entry redan skapad eller Provkvantitet ej angiven
DocType: Program,Program Abbreviation,program Förkortning
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Group by Voucher (Consolidated)
DocType: HR Settings,Encrypt Salary Slips in Emails,Kryptera lönesedlar i e-postmeddelanden
DocType: Question,Multiple Correct Answer,Flera korrekt svar
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Charges are updated in Purchase Receipt against each item,Avgifter uppdateras i inköpskvitto för varje post
DocType: Warranty Claim,Resolved By,Åtgärdad av
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,Schemaläggningsavgift
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Checkar och Insättningar rensas felaktigt
DocType: Homepage Section Card,Homepage Section Card,Hemsida avsnitt kort
,Amount To Be Billed,Belopp som ska faktureras
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: You can not assign itself as parent account,Konto {0}: Du kan inte tilldela sig själv som förälder konto
DocType: Purchase Invoice Item,Price List Rate,Prislista värde
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,Skapa kund citat
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,Servicestoppdatum kan inte vara efter service Slutdatum
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Visa &quot;i lager&quot; eller &quot;Inte i lager&quot; som bygger på lager tillgängliga i detta lager.
apps/erpnext/erpnext/config/manufacturing.py,Bill of Materials (BOM),Bill of Materials (BOM)
DocType: Item,Average time taken by the supplier to deliver,Genomsnittlig tid det tar för leverantören att leverera
DocType: Travel Itinerary,Check-in Date,Inchecknings datum
DocType: Sample Collection,Collected By,Samlad By
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,bedömning Resultat
DocType: Hotel Room Package,Hotel Room Package,Hotellrumspaket
DocType: Employee Transfer,Employee Transfer,Medarbetaröverföring
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Hours,Timmar
apps/erpnext/erpnext/templates/emails/confirm_appointment.html,A new appointment has been created for you with {0},En ny möte har skapats för dig med {0}
DocType: Project,Expected Start Date,Förväntat startdatum
DocType: Purchase Invoice,04-Correction in Invoice,04-Korrigering i faktura
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,Arbetsorder som redan är skapad för alla artiklar med BOM
DocType: Bank Account,Party Details,Fest Detaljer
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Variant Detaljer Report
DocType: Setup Progress Action,Setup Progress Action,Inställning Progress Action
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Köpa prislista
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,Ta bort alternativ om avgifter inte är tillämpade för denna post
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,Avbryt prenumeration
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Maintenance Status as Completed or remove Completion Date,Vänligen välj Underhållsstatus som Slutförd eller ta bort Slutdatum
DocType: Supplier,Default Payment Terms Template,Standardbetalningsvillkor Mall
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Transaction currency must be same as Payment Gateway currency,Transaktions valutan måste vara samma som Payment Gateway valuta
DocType: Payment Entry,Receive,Receive
DocType: Employee Benefit Application Detail,Earning Component,Tjäna komponent
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Bearbetar objekt och UOM: er
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',Vänligen ange skatte-ID eller skattekod för företaget &#39;% s&#39;
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,citat:
DocType: Contract,Partially Fulfilled,Delvis uppnått
DocType: Maintenance Visit,Fully Completed,Helt Avslutad
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Specialtecken utom &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; Och &quot;}&quot; är inte tillåtna i namnserien"
DocType: Purchase Invoice Item,Is nil rated or exempted,Är noll klassificerad eller undantagen
DocType: Employee,Educational Qualification,Utbildnings Kvalificering
DocType: Workstation,Operating Costs,Operations Kostnader
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Currency for {0} must be {1},Valuta för {0} måste vara {1}
DocType: Shift Type,Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Markera närvaro baserat på &quot;Personal Checkin&quot; för anställda som tilldelats detta skift.
DocType: Asset,Disposal Date,bortskaffande Datum
DocType: Service Level,Response and Resoution Time,Svarstid och avgångstid
DocType: Employee Leave Approver,Employee Leave Approver,Anställd Lämna godkännare
apps/erpnext/erpnext/stock/doctype/item/item.py,Row {0}: An Reorder entry already exists for this warehouse {1},Rad {0}: En Beställnings post finns redan för detta lager {1}
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Please enter the designation,Vänligen ange beteckningen
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,"Cannot declare as lost, because Quotation has been made.","Det går inte att ange som förlorad, eftersom Offert har gjorts."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Get Outstanding Documents,Få framstående dokument
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Artiklar för begäran av råmaterial
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,CWIP-konto
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,utbildning Feedback
apps/erpnext/erpnext/config/accounts.py,Tax Withholding rates to be applied on transactions.,Skatteavdrag som ska tillämpas på transaktioner.
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Leverantörs Scorecard Criteria
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},Välj startdatum och slutdatum för punkt {0}
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
,Amount to Receive,Belopp som ska tas emot
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Kursen är obligatorisk i rad {0}
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,From date can not be greater than than To date,Från datum kan inte vara större än till datum
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To date cannot be before from date,Hittills inte kan vara före startdatum
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Icke-GST-inuti
DocType: Employee Group Table,Employee Group Table,Tabell över anställda
DocType: Packed Item,Prevdoc DocType,Prevdoc DocType
DocType: Cash Flow Mapper,Section Footer,Avsnitt Footer
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Lägg till / redigera priser
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Arbetstagarreklam kan inte skickas före kampanjdatum
DocType: Batch,Parent Batch,Föräldragrupp
DocType: Cheque Print Template,Cheque Print Template,Check utskriftsmall
DocType: Salary Component,Is Flexible Benefit,Är flexibel fördel
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Kontoplan på Kostnadsställen
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Antal dagar efter fakturadatum har förflutit innan du avbryter prenumerationen eller prenumerationen som obetald
DocType: Clinical Procedure Template,Sample Collection,Provsamling
,Requested Items To Be Ordered,Efterfrågade artiklar Beställningsvara
DocType: Price List,Price List Name,Pris Listnamn
DocType: Delivery Stop,Dispatch Information,Dispatch Information
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from submitted document,e-Way Bill JSON kan endast genereras från det skickade dokumentet
DocType: Blanket Order,Manufacturing,Tillverkning
,Ordered Items To Be Delivered,Beställda varor som skall levereras
DocType: Account,Income,Inkomst
DocType: Industry Type,Industry Type,Industrityp
apps/erpnext/erpnext/templates/includes/cart.js,Something went wrong!,Något gick snett!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,Varning: Ledighetsansökan innehåller följande block datum
DocType: Bank Statement Settings,Transaction Data Mapping,Transaktionsdata kartläggning
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,Fakturan {0} har redan lämnats in
DocType: Salary Component,Is Tax Applicable,Är skatt tillämplig
DocType: Supplier Scorecard Scoring Criteria,Score,Göra
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,Räkenskapsårets {0} inte existerar
DocType: Asset Maintenance Log,Completion Date,Slutförande Datum
DocType: Purchase Invoice Item,Amount (Company Currency),Belopp (Företagsvaluta)
DocType: Program,Is Featured,Visas
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Fetching...,Hämtar ...
DocType: Agriculture Analysis Criteria,Agriculture User,Jordbrukare
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Giltigt till datum kan inte vara före transaktionsdatum
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} enheter av {1} behövs i {2} på {3} {4} för {5} för att slutföra denna transaktion.
DocType: Fee Schedule,Student Category,elev Kategori
DocType: Announcement,Student,Elev
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Lager kvantitet till startproceduren är inte tillgänglig i lageret. Vill du spela in en Stock Transfer
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Nya {0} prisregler skapas
DocType: Shipping Rule,Shipping Rule Type,Leveransregel Typ
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,"Company, Payment Account, From Date and To Date is mandatory","Företag, Betalkonto, Från datum till datum är obligatoriskt"
DocType: Company,Budget Detail,Budgetdetalj
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,Ange meddelandet innan du skickar
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,Ställa in företag
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Of the supplies shown in 3.1 (a) above, details of inter-State supplies made to unregisterd
	persons, composition taxable persons and UIN holders","Av de leveranser som anges i 3.1 a ovan, detaljer om leveranser mellan stater som gjorts till oregistrerade personer, skattskyldiga personer och UIN-innehavare"
apps/erpnext/erpnext/regional/doctype/gst_hsn_code/gst_hsn_code.js,Item taxes updated,Produktskatter uppdaterade
DocType: Education Settings,Enable LMS,Aktivera LMS
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICERA FÖR LEVERANTÖR
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,Spara rapporten igen för att bygga om eller uppdatera
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot delete item {1} which has already been received,Rad nr {0}: Det går inte att ta bort objekt {1} som redan har tagits emot
DocType: Service Level Agreement,Response and Resolution Time,Svar och upplösningstid
DocType: Asset,Custodian,Väktare
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,Butikförsäljnings profil
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,{0} should be a value between 0 and 100,{0} bör vara ett värde mellan 0 och 100
apps/erpnext/erpnext/crm/doctype/appointment_booking_settings/appointment_booking_settings.py,<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>Från tid</b> kan inte vara senare än <b>till tid</b> för {0}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},Betalning av {0} från {1} till {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies liable to reverse charge (other than 1 & 2 above),Tillåtna leveranser som kan återföras (andra än 1 och 2 ovan)
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Köporderbelopp (företagsvaluta)
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Importera kontoplan från en csv-fil
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Unsecured Loans,Lån utan säkerhet
DocType: Cost Center,Cost Center Name,Kostnadcenter Namn
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Max arbetstid mot tidrapport
DocType: Shift Type,Strictly based on Log Type in Employee Checkin,Strikt baserat på loggtyp i anställd incheckning
DocType: Maintenance Schedule Detail,Scheduled Date,Planerat datum
apps/erpnext/erpnext/projects/doctype/task/task.py,Task's {0} End Date cannot be after Project's End Date.,Uppgiftens {0} slutdatum kan inte vara efter projektets slutdatum.
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Meddelanden som är större än 160 tecken delas in i flera meddelanden
DocType: Purchase Receipt Item,Received and Accepted,Mottagit och godkänt
,GST Itemised Sales Register,GST Artized Sales Register
DocType: Staffing Plan,Staffing Plan Details,Personalplaneringsdetaljer
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Löpnummer serviceavtal löper ut
DocType: Employee Health Insurance,Employee Health Insurance,Anställd Sjukförsäkring
DocType: Appointment Booking Settings,Agent Details,Agentinformation
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You cannot credit and debit same account at the same time,Du kan inte kreditera och debitera samma konto på samma gång
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Vuxna puls är överallt mellan 50 och 80 slag per minut.
DocType: Naming Series,Help HTML,Hjälp HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Creation Tool
DocType: Item,Variant Based On,Variant Based On
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total weightage assigned should be 100%. It is {0},Totalt weightage delas ska vara 100%. Det är {0}
DocType: Loyalty Point Entry,Loyalty Program Tier,Lojalitetsprogram Tier
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Cannot set as Lost as Sales Order is made.,Kan inte ställa in då Förlorad kundorder är gjord.
DocType: Request for Quotation Item,Supplier Part No,Leverantör varunummer
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Anledning till håll:
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Det går inte att dra när kategori är för &quot;Värdering&quot; eller &quot;Vaulation och Total&quot;
apps/erpnext/erpnext/public/js/hub/components/reviews.js,Anonymous,Anonym
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,Mottagen från
DocType: Lead,Converted,Konverterad
DocType: Item,Has Serial No,Har Löpnummer
DocType: Stock Entry Detail,PO Supplied Item,PO medlevererad artikel
DocType: BOM,Quality Inspection Required,Kvalitetskontroll krävs
DocType: Employee,Date of Issue,Utgivningsdatum
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"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}",Enligt Köpinställningar om inköp krävs == &#39;JA&#39; och sedan för att skapa Köpfaktura måste användaren skapa Köp kvittot först för punkt {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},Rad # {0}: Ställ Leverantör för punkt {1}
DocType: Global Defaults,Default Distance Unit,Standarddistansenhet
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,V {0}: Timmar Värdet måste vara större än noll.
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,Website Bild {0} fäst till punkt {1} kan inte hittas
DocType: Asset,Assets,Tillgångar
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,Dator
DocType: Item,List this Item in multiple groups on the website.,Lista detta objekt i flera grupper på webbplatsen.
DocType: Subscription,Current Invoice End Date,Aktuell faktura Slutdatum
DocType: Payment Term,Due Date Based On,Förfallodatum baserad på
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Please set default customer group and territory in Selling Settings,Ange standard kundgrupp och -område i Säljinställningar
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} does not exist,{0} {1} existerar inte
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please check Multi Currency option to allow accounts with other currency,Kontrollera flera valutor möjlighet att tillåta konton med annan valuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item: {0} does not exist in the system,Produkt: {0} existerar inte i systemet
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,Du har inte behörighet att ställa in Frysta värden
DocType: Payment Reconciliation,Get Unreconciled Entries,Hämta ej verifierade Anteckningar
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},Anställd {0} är kvar på {1}
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Inga återbetalningar valdes för Journal Entry
DocType: Purchase Invoice,GST Category,GST-kategori
DocType: Payment Reconciliation,From Invoice Date,Från fakturadatum
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,Budgetar
DocType: Invoice Discounting,Disbursed,Utbetalt
DocType: Healthcare Settings,Laboratory Settings,Laboratorieinställningar
DocType: Clinical Procedure,Service Unit,Serviceenhet
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Framgångsrikt sätta leverantör
DocType: Leave Encashment,Leave Encashment,Lämna inlösen
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Vad gör den?
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Uppgifter har skapats för att hantera {0} sjukdomen (på rad {1})
DocType: Crop,Byproducts,biprodukter
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,Till Warehouse
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,Alla Student Antagning
,Average Commission Rate,Genomsnittligt commisionbetyg
DocType: Share Balance,No of Shares,Antal aktier
DocType: Taxable Salary Slab,To Amount,Till belopp
apps/erpnext/erpnext/stock/doctype/item/item.py,'Has Serial No' can not be 'Yes' for non-stock item,&quot;Har Löpnummer&quot; kan inte vara &quot;ja&quot; för icke Beställningsvara
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,Välj Status
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,Närvaro kan inte markeras för framtida datum
DocType: Support Search Source,Post Description Key,Post Beskrivning Key
DocType: Pricing Rule,Pricing Rule Help,Prissättning Regel Hjälp
DocType: School House,House Name,Hus-namn
DocType: Fee Schedule,Total Amount per Student,Summa belopp per student
DocType: Opportunity,Sales Stage,Försäljningsstadiet
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,Kundpost
DocType: Purchase Taxes and Charges,Account Head,Kontohuvud
DocType: Company,HRA Component,HRA komponent
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,Elektrisk
apps/erpnext/erpnext/utilities/activation.py,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Lägg till resten av din organisation som dina användare. Du kan också bjuda in Kunder till din portal genom att lägga till dem från Kontakter
DocType: Stock Entry,Total Value Difference (Out - In),Total Value Skillnad (Out - In)
DocType: Employee Checkin,Location / Device ID,Plats / enhets-ID
DocType: Grant Application,Requested Amount,Begärt belopp
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Rad {0}: Växelkurser är obligatorisk
DocType: Invoice Discounting,Bank Charges Account,Bankkontokonto
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,User ID not set for Employee {0},Användar-ID inte satt för anställd {0}
DocType: Vehicle,Vehicle Value,fordons Värde
DocType: Crop Cycle,Detected Diseases,Upptäckta sjukdomar
DocType: Stock Entry,Default Source Warehouse,Standardkälla Lager
DocType: Item,Customer Code,Kund kod
DocType: Bank,Data Import Configuration,Dataimportkonfiguration
DocType: Asset Maintenance Task,Last Completion Date,Sista slutdatum
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,Dagar sedan senast Order
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,Debitering av kontot måste vara ett balanskonto
DocType: Vital Signs,Coated,Överdragen
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Rad {0}: Förväntat värde efter nyttjandeperioden måste vara mindre än bruttoinköpsbeloppet
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},Ange {0} för adress {1}
DocType: GoCardless Settings,GoCardless Settings,GoCardless-inställningar
apps/erpnext/erpnext/controllers/stock_controller.py,Create Quality Inspection for Item {0},Skapa kvalitetskontroll för artikel {0}
DocType: Leave Block List,Leave Block List Name,Lämna Blocklistnamn
apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Perpetual inventory required for the company {0} to view this report.,Envarig inventering krävs för att företaget {0} ska kunna se denna rapport.
DocType: Certified Consultant,Certification Validity,Certifikat Giltighet
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Insurance Startdatum bör vara mindre än försäkring Slutdatum
DocType: Support Settings,Service Level Agreements,Service Level Agreements
DocType: Shopping Cart Settings,Display Settings,Bildskärmsinställningar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,Stock Tillgångar
DocType: Restaurant,Active Menu,Aktiv meny
DocType: Accounting Dimension Detail,Default Dimension,Standarddimension
DocType: Target Detail,Target Qty,Mål Antal
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Mot lån: {0}
DocType: Shopping Cart Settings,Checkout Settings,kassa Inställningar
DocType: Student Attendance,Present,Närvarande
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,Följesedel {0} får inte lämnas
DocType: HR Settings,"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Lönesedjan som skickas till den anställda kommer att vara lösenordsskyddad, lösenordet kommer att genereras baserat på lösenordspolicyn."
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Closing Account {0} must be of type Liability / Equity,Utgående konto {0} måste vara av typen Ansvar / Equity
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},Lönebesked av personal {0} redan skapats för tidrapporten {1}
DocType: Vehicle Log,Odometer,Vägmätare
DocType: Production Plan Item,Ordered Qty,Beställde Antal
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is disabled,Punkt {0} är inaktiverad
DocType: Stock Settings,Stock Frozen Upto,Lager Fryst Upp
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,BOM does not contain any stock item,BOM inte innehåller någon lagervara
DocType: Chapter,Chapter Head,Kapitelhuvud
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Search for a payment,Sök efter en betalning
DocType: Payment Term,Month(s) after the end of the invoice month,Månad (er) efter fakturamånadens slut
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Lönestruktur ska ha flexibla förmånskomponenter för att fördela förmånsbeloppet
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Projektverksamhet / uppgift.
DocType: Vital Signs,Very Coated,Mycket belagd
DocType: Tax Category,Source State,Källstat
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),Endast skattepåverkan (kan inte kräva men en del av skattepliktig inkomst)
apps/erpnext/erpnext/www/book_appointment/index.html,Book Appointment,Boka tid
DocType: Vehicle Log,Refuelling Details,Tanknings Detaljer
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Labresultatets datetime kan inte vara innan du testar datetime
DocType: Delivery Trip,Use Google Maps Direction API to optimize route,Använd Google Maps Direction API för att optimera rutten
DocType: POS Profile,Allow user to edit Discount,Tillåt användaren att redigera rabatt
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Få kunder från
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per rules 42 & 43 of CGST Rules,Enligt reglerna 42 och 43 i CGST-reglerna
DocType: Purchase Invoice Item,Include Exploded Items,Inkludera explosiva artiklar
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Buying must be checked, if Applicable For is selected as {0}","Köp måste anges, i förekommande fall väljs som {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Discount must be less than 100,Rabatt måste vara mindre än 100
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Start Time can't be greater than or equal to End Time \
					for {0}.",Starttid kan inte vara större än eller lika med sluttid \ för {0}.
DocType: Shipping Rule,Restrict to Countries,Begränsa till länder
DocType: Shift Type,Alternating entries as IN and OUT during the same shift,Växlande poster som IN och UT under samma skift
DocType: Shopify Settings,Shared secret,Delad hemlighet
DocType: Amazon MWS Settings,Synch Taxes and Charges,Synchskatter och avgifter
apps/erpnext/erpnext/accounts/general_ledger.py,Please create adjustment Journal Entry for amount {0} ,Skapa justeringsjournal för belopp {0}
DocType: Purchase Invoice,Write Off Amount (Company Currency),Skriv engångsavgift (Company valuta)
DocType: Sales Invoice Timesheet,Billing Hours,fakturerings Timmar
DocType: Project,Total Sales Amount (via Sales Order),Totala försäljningsbelopp (via försäljningsorder)
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Row {0}: Invalid Item Tax Template for item {1},Rad {0}: Ogiltig artikelskattmall för artikel {1}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM for {0} not found,Standard BOM för {0} hittades inte
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Startdatum för budgetåret bör vara ett år tidigare än slutdatum för budgetåret
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Rad # {0}: Ställ in beställningsmängd
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,Tryck på objekt för att lägga till dem här
DocType: Course Enrollment,Program Enrollment,programmet Inskrivning
apps/erpnext/erpnext/controllers/item_variant.py,Rename Not Allowed,Byt namn inte tillåtet
DocType: Share Transfer,To Folio No,Till Folio nr
DocType: Landed Cost Voucher,Landed Cost Voucher,Landad Kostnad rabatt
apps/erpnext/erpnext/config/accounts.py,Tax Category for overriding tax rates.,Skattekategori för överskridande skattesatser.
apps/erpnext/erpnext/public/js/queries.js,Please set {0},Ställ in {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} är inaktiv student
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} är inaktiv student
DocType: Employee,Health Details,Hälsa Detaljer
DocType: Coupon Code,Coupon Type,Kupongtyp
DocType: Leave Encashment,Encashable days,Encashable dagar
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,För att skapa en betalningsförfrågan krävs referensdokument
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,För att skapa en betalningsförfrågan krävs referensdokument
DocType: Soil Texture,Sandy Clay,Sandig Clay
DocType: Grant Application,Assessment  Manager,Bedömningschef
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Allocate Payment Amount,Tilldela Betalningsbelopp
DocType: Subscription Plan,Subscription Plan,Prenumerationsplan
DocType: Employee External Work History,Salary,Lön
DocType: Serial No,Delivery Document Type,Leverans Dokumenttyp
DocType: Sales Order,Partly Delivered,Delvis Levererad
DocType: Item Variant Settings,Do not update variants on save,Uppdatera inte varianter på spara
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py,Custmer Group,Custmer Group
DocType: Email Digest,Receivables,Fordringar
DocType: Lead Source,Lead Source,bly Källa
DocType: Customer,Additional information regarding the customer.,Ytterligare information om kunden.
DocType: Quality Inspection Reading,Reading 5,Avläsning 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} är associerad med {2}, men partkonto är {3}"
DocType: Bank Statement Settings Item,Bank Header,Bankrubrik
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Visa labtester
DocType: Hub Users,Hub Users,Hub-användare
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Underhållsdatum
DocType: Purchase Invoice Item,Rejected Serial No,Avvisat Serienummer
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Year start date or end date is overlapping with {0}. To avoid please set company,År startdatum eller slutdatum överlappar med {0}. För att undvika ställ företag
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},Vänligen ange lednamnet i bly {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Start date should be less than end date for Item {0},Startdatum bör vara mindre än slutdatumet för punkt {0}
DocType: Shift Type,Auto Attendance Settings,Inställningar för automatisk deltagande
DocType: Item,"Example: ABCD.#####
If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Exempel:. ABCD ##### Om serien är inställd och Löpnummer inte nämns i transaktioner, skapas automatiska serienummer  utifrån denna serie. Om du alltid vill ange serienumren för denna artikel. lämna det tomt."
DocType: Upload Attendance,Upload Attendance,Ladda upp Närvaro
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,BOM och tillverkningskvantitet krävs
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,Åldringsräckvidd 2
DocType: SG Creation Tool Course,Max Strength,max Styrka
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Installera förinställningar
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,No Delivery Note selected for Customer {},Ingen leveransnotering vald för kund {}
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Added in {0},Rader tillagda i {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,Anställd {0} har inget maximalt förmånsbelopp
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,Välj objekt baserat på leveransdatum
DocType: Grant Application,Has any past Grant Record,Har någon tidigare Grant Record
,Sales Analytics,Försäljnings Analytics
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},Tillgängliga {0}
,Prospects Engaged But Not Converted,Utsikter Engaged Men Not Converted
,Prospects Engaged But Not Converted,Utsikter Engaged Men Not Converted
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,"{2} <b>{0}</b> has submitted Assets.\
								Remove Item <b>{1}</b> from table to continue.",{2} <b>{0}</b> har skickat in tillgångar. \ Ta bort objekt <b>{1}</b> från tabellen för att fortsätta.
DocType: Manufacturing Settings,Manufacturing Settings,Tillverknings Inställningar
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Parameter för kvalitetsåterkopplingsmall
apps/erpnext/erpnext/config/settings.py,Setting up Email,Ställa in e-post
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Mobile No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter default currency in Company Master,Ange standardvaluta i Bolaget
DocType: Stock Entry Detail,Stock Entry Detail,Stock Entry Detalj
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,Dagliga påminnelser
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Se alla öppna biljetter
DocType: Brand,Brand Defaults,Standard för varumärke
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Hälso- och sjukvårdstjänstenhet
DocType: Pricing Rule,Product,Produkt
DocType: Products Settings,Home Page is Products,Hemsida är produkter
,Asset Depreciation Ledger,Avskrivning Ledger
DocType: Salary Structure,Leave Encashment Amount Per Day,Lämna inkräkningsbelopp per dag
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,För hur mycket spenderat = 1 Lojalitetspoäng
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},Skatt Regel Konflikter med {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,New Account Name,Nytt kontonamn
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Råvaror Levererans Kostnad
DocType: Selling Settings,Settings for Selling Module,Inställningar för att sälja Modul
DocType: Hotel Room Reservation,Hotel Room Reservation,Hotellrum Bokning
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,Kundtjänst
DocType: BOM,Thumbnail,Miniatyr
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Inga kontakter med e-postadresser hittades.
DocType: Item Customer Detail,Item Customer Detail,Produktdetaljer kund
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum benefit amount of employee {0} exceeds {1},Maximal förmånsbelopp för anställd {0} överstiger {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more than days in the period,Totalt tilldelade bladen är mer än dagar under perioden
DocType: Linked Soil Analysis,Linked Soil Analysis,Länkad jordanalys
DocType: Pricing Rule,Percentage,Procentsats
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Item {0} must be a stock Item,Produkt {0} måste vara en lagervara
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Standard Work In Progress Warehouse
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Scheman för {0} överlappar, vill du fortsätta efter att ha skurit överlappade slitsar?"
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Grant Leaves
DocType: Restaurant,Default Tax Template,Standardskattemall
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Studenter har anmält sig
DocType: Fees,Student Details,Studentuppgifter
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Detta är standard UOM som används för artiklar och försäljningsorder. Fallback UOM är &quot;Nos&quot;.
DocType: Purchase Invoice Item,Stock Qty,Lager Antal
DocType: Purchase Invoice Item,Stock Qty,Lager Antal
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Ctrl+Enter to submit,Ctrl + Enter för att skicka in
DocType: Contract,Requires Fulfilment,Kräver Uppfyllande
DocType: QuickBooks Migrator,Default Shipping Account,Standard Fraktkonto
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please set a Supplier against the Items to be considered in the Purchase Order.,Vänligen ställ in en leverantör mot de artiklar som ska beaktas i inköpsorder.
DocType: Loan,Repayment Period in Months,Återbetalning i månader
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,Fel: Inte ett giltigt id?
DocType: Naming Series,Update Series Number,Uppdatera Serie Nummer
DocType: Account,Equity,Eget kapital
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: ""Resultaträkning"" kontotyp {2} är inte tillåtet i inledande post"
DocType: Job Offer,Printing Details,Utskrifter Detaljer
DocType: Task,Closing Date,Slutdatum
DocType: Sales Order Item,Produced Quantity,Producerat Kvantitet
DocType: Item Price,Quantity  that must be bought or sold per UOM,Mängd som måste köpas eller säljas per UOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,Ingenjör
DocType: Promotional Scheme Price Discount,Max Amount,Maxbelopp
DocType: Journal Entry,Total Amount Currency,Totalt Belopp Valuta
DocType: Pricing Rule,Min Amt,Min Amt
DocType: Item,Is Customer Provided Item,Är kunden tillhandahållen artikel
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Sök Sub Assemblies
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Item Code required at Row No {0},Produkt kod krävs vid Radnr {0}
DocType: GST Account,SGST Account,SGST-konto
DocType: Sales Partner,Partner Type,Partner Typ
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,Faktisk
DocType: Appointment,Skype ID,Skype ID
DocType: Restaurant Menu,Restaurant Manager,Restaurangchef
DocType: Call Log,Call Log,Samtalslogg
DocType: Authorization Rule,Customerwise Discount,Kundrabatt
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Tidrapport för uppgifter.
DocType: Purchase Invoice,Against Expense Account,Mot utgiftskonto
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Installation Note {0} has already been submitted,Installeringsnotis {0} har redan lämnats in
DocType: BOM,Raw Material Cost (Company Currency),Råvarukostnad (företagets valuta)
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},Hus hyra betalade dagar överlappande med {0}
DocType: GSTR 3B Report,October,oktober
DocType: Bank Reconciliation,Get Payment Entries,Få Betalnings Inlägg
DocType: Quotation Item,Against Docname,Mot doknamn
DocType: SMS Center,All Employee (Active),Personal (aktiv)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,Detaljerad anledning
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,Visa nu
DocType: BOM,Raw Material Cost,Råvarukostnad
DocType: Woocommerce Settings,Woocommerce Server URL,Webbadress för Woocommerce Server
DocType: Item Reorder,Re-Order Level,Återuppta nivå
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Dra full skatt på vald lönedatum
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Shopify Skatt / Frakt Titel
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,Gantt-Schema
DocType: Crop Cycle,Cycle Type,Cykeltyp
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,Deltid
DocType: Employee,Applicable Holiday List,Tillämplig kalender
DocType: Employee,Cheque,Check
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Synchronize this account,Synkronisera det här kontot
DocType: Training Event,Employee Emails,Medarbetare e-post
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,Serie Uppdaterad
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,Rapporttyp är obligatorisk
DocType: Item,Serial Number Series,Serial Number Series
,Sales Partner Transaction Summary,Försäljningspartners transaktionsöversikt
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},Lager är obligatoriskt för Lagervara {0} i rad {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Retail & Wholesale,Detaljhandel och grossisthandel
DocType: Issue,First Responded On,Först svarade den
DocType: Website Item Group,Cross Listing of Item in multiple groups,Kors Notering av punkt i flera grupper
DocType: Employee Tax Exemption Declaration,Other Incomes,Andra inkomster
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Räkenskapsårets Startdatum och Räkenskapsårets Slutdatum är redan inställd under räkenskapsåret {0}
DocType: Projects Settings,Ignore User Time Overlap,Ignorera överlappning av användartid
DocType: Accounting Period,Accounting Period,Redovisningsperiod
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Clearance Datum uppdateras
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Split Batch
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Split Batch
DocType: Stock Settings,Batch Identification,Batchidentifikation
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Framgångsrikt Avstämt
DocType: Request for Quotation Supplier,Download PDF,Hämta PDF
DocType: Work Order,Planned End Date,Planerat Slutdatum
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Dold lista som behåller listan över kontakter som är kopplade till aktieägare
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Aktuell växelkurs
DocType: Item,"Sales, Purchase, Accounting Defaults","Försäljning, Inköp, Redovisningsstandard"
DocType: Accounting Dimension Detail,Accounting Dimension Detail,Redovisningsdimensiondetalj
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Donor Typ information.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} på ledighet på {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,Tillgängligt för användning datum krävs
DocType: Request for Quotation,Supplier Detail,leverantör Detalj
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Fel i formel eller ett tillstånd: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoiced Amount,Fakturerade belopp
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Kriterievikter måste lägga till upp till 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,Närvaro
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,lager
DocType: Sales Invoice,Update Billed Amount in Sales Order,Uppdatera fakturerat belopp i försäljningsorder
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Contact Seller,Kontakta säljaren
DocType: BOM,Materials,Material
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Om inte markerad, måste listan läggas till varje avdelning där den måste tillämpas."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,Bokningsdatum och bokningstid är obligatorisk
apps/erpnext/erpnext/config/accounts.py,Tax template for buying transactions.,Skatte mall för att köpa transaktioner.
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Please login as a Marketplace User to report this item.,Logga in som Marketplace-användare för att rapportera detta objekt.
,Sales Partner Commission Summary,Sammanfattning av försäljningspartnerkommissionen
,Item Prices,Produktpriser
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,I Ord kommer att synas när du sparar beställningen.
DocType: Holiday List,Add to Holidays,Lägg till helgdagar
DocType: Woocommerce Settings,Endpoint,Slutpunkt
DocType: Period Closing Voucher,Period Closing Voucher,Period Utgående Rabattkoder
DocType: Patient Encounter,Review Details,Granska detaljer
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Aktieägaren tillhör inte detta företag
DocType: Dosage Form,Dosage Form,Doseringsform
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set up the Campaign Schedule in the Campaign {0},Ställ in kampanjschemat i kampanjen {0}
apps/erpnext/erpnext/config/buying.py,Price List master.,Huvudprislista.
DocType: Task,Review Date,Kontroll Datum
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Mark attendance as <b></b>,Markera närvaro som <b></b>
DocType: BOM,Allow Alternative Item,Tillåt alternativ artikel
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,Köpskvitto har inget objekt som behåller provet är aktiverat för.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Fakturor Grand Total
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serie för tillgångsavskrivning (Journal Entry)
DocType: Membership,Member Since,Medlem sedan
DocType: Purchase Invoice,Advance Payments,Förskottsbetalningar
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},Tidsloggar krävs för jobbkortet {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Välj hälsovårdstjänst
DocType: Purchase Taxes and Charges,On Net Total,På Net Totalt
apps/erpnext/erpnext/controllers/item_variant.py,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Värde för Attribut {0} måste vara inom intervallet {1} till {2} i steg om {3} till punkt {4}
DocType: Pricing Rule,Product Discount Scheme,Produktrabatt
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No issue has been raised by the caller.,Ingen fråga har tagits upp av den som ringer.
DocType: Restaurant Reservation,Waitlisted,väntelistan
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Undantagskategori
apps/erpnext/erpnext/accounts/doctype/account/account.py,Currency can not be changed after making entries using some other currency,Valuta kan inte ändras efter att ha gjort poster med någon annan valuta
DocType: Shipping Rule,Fixed,Fast
DocType: Vehicle Service,Clutch Plate,kopplingslamell
DocType: Tally Migration,Round Off Account,Avrunda konto
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,Administrativa kostnader
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,Konsultering
DocType: Subscription Plan,Based on price list,Baserat på prislista
DocType: Customer Group,Parent Customer Group,Överordnad kundgrupp
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from Sales Invoice,e-Way Bill JSON kan endast genereras från försäljningsfaktura
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Maximum attempts for this quiz reached!,Maximala försök för denna frågesport uppnåddes!
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,Prenumeration
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Avgift skapande väntar
DocType: Project Template Task,Duration (Days),Varaktighet (dagar)
DocType: Appraisal Goal,Score Earned,Betyg förtjänat
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Uppsägningstid
DocType: Asset Category,Asset Category Name,Asset Kategori Namn
apps/erpnext/erpnext/setup/doctype/territory/territory.js,This is a root territory and cannot be edited.,Detta är en rot territorium och kan inte ändras.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,New Sales Person Name,Ny försäljnings Person Namn
DocType: Packing Slip,Gross Weight UOM,Bruttovikt UOM
DocType: Employee Transfer,Create New Employee Id,Skapa nyanställd id
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,Ange detaljer
apps/erpnext/erpnext/templates/pages/home.html,By {0},Av {0}
DocType: Travel Itinerary,Travel From,Resa från
DocType: Asset Maintenance Task,Preventive Maintenance,Förebyggande underhåll
DocType: Delivery Note Item,Against Sales Invoice,Mot fakturan
DocType: Purchase Invoice,07-Others,07-Annat
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please enter serial numbers for serialized item ,Vänligen ange serienumren för seriell post
DocType: Bin,Reserved Qty for Production,Reserverad Kvantitet för produktion
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Lämna avmarkerad om du inte vill överväga batch medan du gör kursbaserade grupper.
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Lämna avmarkerad om du inte vill överväga batch medan du gör kursbaserade grupper.
DocType: Asset,Frequency of Depreciation (Months),Frekvens av avskrivningar (månader)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,KUNDKONTO
DocType: Landed Cost Item,Landed Cost Item,Landad kostnadspost
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js,Show zero values,Visa nollvärden
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Antal av objekt som erhålls efter tillverkning / ompackning från givna mängder av råvaror
DocType: Lab Test,Test Group,Testgrupp
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,"Issuing cannot be done to a location. \
						Please enter employee who has issued Asset {0}",Utgivning kan inte göras till en plats. \ Vänligen ange anställd som har utfärdat tillgång {0}
DocType: Service Level Agreement,Entity,Entitet
DocType: Payment Reconciliation,Receivable / Payable Account,Fordran / Betal konto
DocType: Delivery Note Item,Against Sales Order Item,Mot Försäljningvara
DocType: Company,Company Logo,Företagslogotyp
DocType: QuickBooks Migrator,Default Warehouse,Standard Lager
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Budget kan inte tilldelas mot gruppkonto {0}
DocType: Shopping Cart Settings,Show Price,Visa pris
DocType: Healthcare Settings,Patient Registration,Patientregistrering
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Please enter parent cost center,Ange huvud kostnadsställe
DocType: Delivery Note,Print Without Amount,Skriv ut utan Belopp
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Depreciation Date,avskrivnings Datum
,Work Orders in Progress,Arbetsorder pågår
DocType: Issue,Support Team,Support Team
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),Ut (i dagar)
DocType: Appraisal,Total Score (Out of 5),Totalt Betyg (Out of 5)
DocType: Student Attendance Tool,Batch,Batch
DocType: Support Search Source,Query Route String,Query Route String
DocType: Tally Migration,Day Book Data,Dagboksdata
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Uppdateringsfrekvens enligt senaste köp
DocType: Donor,Donor Type,Givartyp
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Automatisk upprepa dokument uppdaterad
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,Balans
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Var god välj Företaget
DocType: Employee Checkin,Skip Auto Attendance,Hoppa över auto deltagande
DocType: BOM,Job Card,Jobbkort
DocType: Room,Seating Capacity,sittplatser
DocType: Issue,ISS-,ISS
DocType: Item,Is Non GST,Är icke GST
DocType: Lab Test Groups,Lab Test Groups,Lab Test Grupper
apps/erpnext/erpnext/config/accounts.py,Profitability,lönsamhet
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,Party Type och Party är obligatorisk för {0} konto
DocType: Project,Total Expense Claim (via Expense Claims),Totalkostnadskrav (via räkningar)
DocType: GST Settings,GST Summary,GST Sammanfattning
apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py,Please enable default incoming account before creating Daily Work Summary Group,Vänligen aktivera standard inkommande konto innan du skapar dagliga arbetsöversiktskoncernen
DocType: Assessment Result,Total Score,Totalpoäng
DocType: Crop Cycle,ISO 8601 standard,ISO 8601-standarden
DocType: Journal Entry,Debit Note,Debetnota
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,Du kan bara lösa in maximala {0} poäng i denna ordning.
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,Vänligen ange API konsumenthemlighet
DocType: Stock Entry,As per Stock UOM,Per Stock UOM
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Inte Utgången
DocType: Student Log,Achievement,Prestation
DocType: Asset,Insurer,Försäkringsgivare
DocType: Batch,Source Document Type,Källdokumenttyp
DocType: Batch,Source Document Type,Källdokumenttyp
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Following course schedules were created,Följande kursplaner skapades
DocType: Employee Onboarding,Employee Onboarding,Anställd ombordstigning
DocType: Journal Entry,Total Debit,Totalt bankkort
DocType: Travel Request Costing,Sponsored Amount,Sponsrat belopp
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Standard färdigvarulagret
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,Var god välj Patient
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,Försäljnings person
DocType: Hotel Room Package,Amenities,Bekvämligheter
DocType: Accounts Settings,Automatically Fetch Payment Terms,Hämta automatiskt betalningsvillkor
DocType: QuickBooks Migrator,Undeposited Funds Account,Oavsett fondkonto
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Multipla standard betalningssätt är inte tillåtet
DocType: Sales Invoice,Loyalty Points Redemption,Lojalitetspoäng Inlösen
,Appointment Analytics,Utnämningsanalys
DocType: Lead,Blog Subscriber,Blogg Abonnent
DocType: Guardian,Alternate Number,alternativt nummer
DocType: Assessment Plan Criteria,Maximum Score,maximal Score
apps/erpnext/erpnext/config/settings.py,Create rules to restrict transactions based on values.,Skapa regler för att begränsa transaktioner som grundar sig på värderingar.
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Kontantströmsmappningskonton
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,Grupprull nr
DocType: Quality Goal,Revision and Revised On,Revision och omarbetad
DocType: Batch,Manufacturing Date,Tillverkningsdatum
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Avgiftsköp misslyckades
DocType: Opening Invoice Creation Tool,Create Missing Party,Skapa saknade parti
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Total budget
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Lämna tomma om du gör elever grupper per år
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Lämna tomma om du gör elever grupper per år
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Om markerad, Totalt antal. arbetsdagar kommer att omfatta helgdagar, och detta kommer att minska värdet av lönen per dag"
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Det gick inte att lägga till domän
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","För att tillåta över mottagning / leverans, uppdatera &quot;Över kvitto / leveransbidrag&quot; i lagerinställningar eller artikeln."
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Appar som använder nuvarande nyckel kommer inte att kunna komma åt, är du säker?"
DocType: Subscription Settings,Prorate,prorata
DocType: Purchase Invoice,Total Advance,Totalt Advance
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Ändra mallkod
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Termen Slutdatum kan inte vara tidigare än Term startdatum. Rätta datum och försök igen.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Citaträkning
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Citaträkning
DocType: Bank Statement Transaction Entry,Bank Statement,Bankredovisning
DocType: Employee Benefit Claim,Max Amount Eligible,Maxbelopp Stödberättigande
,BOM Stock Report,BOM Stock Report
DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",Om det inte finns någon tilldelad tidslucka kommer kommunikationen att hanteras av denna grupp
DocType: Stock Reconciliation Item,Quantity Difference,kvantitet Skillnad
DocType: Opportunity Item,Basic Rate,Baskurs
DocType: GL Entry,Credit Amount,Kreditbelopp
,Electronic Invoice Register,Elektroniskt fakturaregister
DocType: Cheque Print Template,Signatory Position,tecknaren Position
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Ange som förlorade
DocType: Timesheet,Total Billable Hours,Totalt debiterbara timmar
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,Antal dagar som abonnenten måste betala fakturor som genereras av denna prenumeration
apps/erpnext/erpnext/projects/doctype/project/project.py,Use a name that is different from previous project name,Använd ett namn som skiljer sig från tidigare projektnamn
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Ansökningsdetaljer för anställda
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Kvitto Notera
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,Detta grundar sig på transaktioner mot denna kund. Se tidslinje nedan för mer information
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Skapa materialförfrågan
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Start- och slutdatum som inte finns i en giltig löneperiod, kan inte beräkna {0}"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Rad {0}: Tilldelad mängd {1} måste vara mindre än eller lika med betalning Entry belopp {2}
DocType: Program Enrollment Tool,New Academic Term,Ny akademisk term
,Course wise Assessment Report,Kursfattig bedömningsrapport
DocType: Customer Feedback Template,Customer Feedback Template,Kundens feedbackmall
DocType: Purchase Invoice,Availed ITC State/UT Tax,Availed ITC State / UT Skatt
DocType: Tax Rule,Tax Rule,Skatte Rule
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Behåll samma takt hela säljcykeln
apps/erpnext/erpnext/hub_node/api.py,Please login as another user to register on Marketplace,Vänligen logga in som en annan användare för att registrera dig på Marketplace
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planera tidsloggar utanför planerad arbetstid.
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Kunder i kö
DocType: Driver,Issuing Date,Utgivningsdatum
DocType: Procedure Prescription,Appointment Booked,Avtal bokat
DocType: Student,Nationality,Nationalitet
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,konfigurera
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Skicka in denna arbetsorder för vidare bearbetning.
,Items To Be Requested,Produkter att begäras
DocType: Company,Allow Account Creation Against Child Company,Tillåt att konto skapas mot barnföretag
DocType: Company,Company Info,Företagsinfo
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Välj eller lägga till en ny kund
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Cost center is required to book an expense claim,Kostnadsställe krävs för att boka en räkningen
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Application of Funds (Assets),Tillämpning av medel (tillgångar)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,Detta är baserat på närvaron av detta till anställda
DocType: Payment Request,Payment Request Type,Betalningsförfrågan Typ
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Mark Attendance
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Bankkortkonto
DocType: Fiscal Year,Year Start Date,År Startdatum
DocType: Additional Salary,Employee Name,Anställd Namn
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restaurang Order Entry Item
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created and {1} errors,{0} banktransaktioner skapade och {1} fel
DocType: Purchase Invoice,Rounded Total (Company Currency),Avrundat Totalt (Företagsvaluta)
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,Det går inte att konvertera till koncernen eftersom Kontotyp valts.
DocType: Quiz,Max Attempts,Max försök
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has been modified. Please refresh.,{0} {1} har ändrats. Vänligen uppdatera.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Stoppa användare från att göra Lämna program på följande dagarna.
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Om obegränsat upphörande för lojalitetspoängen, håll utlåtningstiden tom eller 0."
DocType: Asset Maintenance Team,Maintenance Team Members,Underhållspersonal
DocType: Coupon Code,Validity and Usage,Giltighet och användning
DocType: Loyalty Point Entry,Purchase Amount,Köpesumma
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}",Kan inte leverera serienumret {0} av objektet {1} eftersom det är reserverat \ för att fylla i försäljningsordern {2}
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Supplier Quotation {0} created,Leverantör Offert {0} skapades
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,End år kan inte vara före startåret
DocType: Employee Benefit Application,Employee Benefits,Ersättningar till anställda
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,Anställnings-ID
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packed quantity must equal quantity for Item {0} in row {1},Packad kvantitet måste vara samma kvantitet för punkt {0} i rad {1}
DocType: Work Order,Manufactured Qty,Tillverkas Antal
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},Aktierna existerar inte med {0}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Select Difference Account,Välj Skillnadskonto
DocType: Sales Partner Type,Sales Partner Type,Försäljningspartner typ
DocType: Purchase Order,Set Reserve Warehouse,Ställ Reserve Warehouse
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,Faktura skapad
DocType: Asset,Out of Order,Trasig
DocType: Purchase Receipt Item,Accepted Quantity,Godkänd kvantitet
DocType: Projects Settings,Ignore Workstation Time Overlap,Ignorera överlappning av arbetsstationen
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},Vänligen ange ett standardkalender för anställd {0} eller Company {1}
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Timing,timing
apps/erpnext/erpnext/accounts/party.py,{0}: {1} does not exists,{0}: {1} existerar inte
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,Välj batchnummer
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,Till GSTIN
apps/erpnext/erpnext/config/accounts.py,Bills raised to Customers.,Fakturor till kunder.
DocType: Healthcare Settings,Invoice Appointments Automatically,Fakturaavnämningar automatiskt
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Id,Projekt Id
DocType: Salary Component,Variable Based On Taxable Salary,Variabel baserad på beskattningsbar lön
DocType: Company,Basic Component,Grundkomponent
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Rad nr {0}: Beloppet kan inte vara större än utestående beloppet mot utgiftsräkning {1}. I avvaktan på Beloppet är {2}
DocType: Patient Service Unit,Medical Administrator,Medicinsk administratör
DocType: Assessment Plan,Schedule,Tidtabell
DocType: Account,Parent Account,Moderbolaget konto
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,Lönestrukturuppdrag för anställda finns redan
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,Tillgängligt
DocType: Quality Inspection Reading,Reading 3,Avläsning 3
DocType: Stock Entry,Source Warehouse Address,Källa lageradress
DocType: GL Entry,Voucher Type,Rabatt Typ
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Future Payments,Framtida betalningar
DocType: Amazon MWS Settings,Max Retry Limit,Max Retry Limit
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Prislista hittades inte eller avaktiverad
DocType: Content Activity,Last Activity ,sista aktiviteten
DocType: Student Applicant,Approved,Godkänd
DocType: Pricing Rule,Price,Pris
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',"Anställd sparkades på {0} måste ställas in som ""lämnat"""
DocType: Guardian,Guardian,väktare
apps/erpnext/erpnext/support/doctype/issue/issue.js,All communications including and above this shall be moved into the new Issue,All kommunikation inklusive och ovanför ska flyttas till den nya Issue
DocType: Salary Detail,Tax on additional salary,Skatt på extra lön
DocType: Item Alternative,Item Alternative,Alternativ Alternativ
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Standardinkomstkonton som ska användas om den inte anges i vårdpraktiseraren för att boka Avtalskostnader.
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,Den totala bidragsprocenten bör vara lika med 100
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Skapa saknad kund eller leverantör.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Appraisal {0} created for Employee {1} in the given date range,Bedömning {0} skapades för anställd {1} på visst datumintervall
DocType: Academic Term,Education,Utbildning
DocType: Payroll Entry,Salary Slips Created,Löneglister skapade
DocType: Inpatient Record,Expected Discharge,Förväntad utsläpp
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Del,del
DocType: Selling Settings,Campaign Naming By,Kampanj namnges av
DocType: Employee,Current Address Is,Nuvarande adress är
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,ändrad
DocType: Travel Request,Identification Document Number,Identifikationsdokumentnummer
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.","Tillval. Ställer företagets standardvaluta, om inte annat anges."
DocType: Sales Invoice,Customer GSTIN,Kund GSTIN
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,Lista över sjukdomar som upptäckts på fältet. När den väljs kommer den automatiskt att lägga till en lista över uppgifter för att hantera sjukdomen
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,BOM 1,BOM 1
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Asset Id,Tillgångs-id
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,This is a root healthcare service unit and cannot be edited.,Detta är en root healthcare service enhet och kan inte redigeras.
DocType: Asset Repair,Repair Status,Reparationsstatus
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Requested Qty: Quantity requested for purchase, but not ordered.","Antal efterfrågade: Antal som begärs för köp, men inte beställt."
,Subcontracted Item To Be Received,Underleverantör som ska tas emot
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Lägg till försäljningspartners
apps/erpnext/erpnext/config/accounts.py,Accounting journal entries.,Redovisning journalanteckningar.
DocType: Travel Request,Travel Request,Travel Request
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,Systemet hämtar alla poster om gränsvärdet är noll.
DocType: Delivery Note Item,Available Qty at From Warehouse,Tillgång Antal på From Warehouse
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,Välj Anställningsregister först.
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,Närvaro inte inlämnad för {0} eftersom det är en semester.
DocType: POS Profile,Account for Change Amount,Konto för förändring Belopp
DocType: QuickBooks Migrator,Connecting to QuickBooks,Anslutning till QuickBooks
DocType: Exchange Rate Revaluation,Total Gain/Loss,Totala vinst / förlust
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Pick List,Skapa plocklista
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Rad {0}: Party / konto stämmer inte med {1} / {2} i {3} {4}
DocType: Employee Promotion,Employee Promotion,Medarbetarreklam
DocType: Maintenance Team Member,Maintenance Team Member,Underhållspersonal
DocType: Agriculture Analysis Criteria,Soil Analysis,Jordanalys
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Course Code: ,Kurskod:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Expense Account,Ange utgiftskonto
DocType: Quality Action Resolution,Problem,Problem
DocType: Account,Stock,Lager
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Rad # {0}: Referensdokument Type måste vara en av inköpsorder, inköpsfaktura eller journalanteckning"
DocType: Employee,Current Address,Nuvarande Adress
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Om artikeln är en variant av ett annat objekt kommer beskrivning, bild, prissättning, skatter etc att ställas från mallen om inte annat uttryckligen anges"
DocType: Production Plan Item,Make Work Order for Sub Assembly Items,Gör arbetsorder för undermonteringsartiklar
DocType: Serial No,Purchase / Manufacture Details,Inköp / Tillverknings Detaljer
DocType: Assessment Group,Assessment Group,bedömning gruppen
DocType: Stock Entry,Per Transferred,Per överförd
apps/erpnext/erpnext/config/help.py,Batch Inventory,Sats Inventory
DocType: Sales Invoice,GST Transporter ID,GST Transporter ID
DocType: Procedure Prescription,Procedure Name,Procedurens namn
DocType: Employee,Contract End Date,Kontrakts Slutdatum
DocType: Amazon MWS Settings,Seller ID,Säljar-ID
DocType: Sales Order,Track this Sales Order against any Project,Prenumerera på det här kundorder mot varje Project
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Bankredovisning Transaktionsangivelse
DocType: Sales Invoice Item,Discount and Margin,Rabatt och marginal
DocType: Lab Test,Prescription,Recept
DocType: Import Supplier Invoice,Upload XML Invoices,Ladda upp XML-fakturor
DocType: Company,Default Deferred Revenue Account,Standard uppskjutna intäkter konto
DocType: Project,Second Email,Andra e-postadressen
DocType: Budget,Action if Annual Budget Exceeded on Actual,Åtgärd om årlig budget överskred på faktiska
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,Inte Tillgänglig
DocType: Pricing Rule,Min Qty,Min Antal
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,Inaktivera mall
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Transaktionsdatum
DocType: Production Plan Item,Planned Qty,Planerade Antal
DocType: Project Template Task,Begin On (Days),Börja på (dagar)
DocType: Quality Action,Preventive,Förebyggande
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Leveranser till oregistrerade personer
DocType: Company,Date of Incorporation,Datum för upptagande
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Totalt Skatt
DocType: Manufacturing Settings,Default Scrap Warehouse,Standard skrotlager
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Senaste inköpspriset
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,För Kvantitet (Tillverkad Antal) är obligatorisk
DocType: Stock Entry,Default Target Warehouse,Standard Valt Lager
DocType: Purchase Invoice,Net Total (Company Currency),Netto Totalt (Företagsvaluta)
DocType: Sales Invoice,Air,Luft
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Året Slutdatum kan inte vara tidigare än året Startdatum. Rätta datum och försök igen.
DocType: Purchase Order,Set Target Warehouse,Ställ in Target Warehouse
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0} finns inte i valfri semesterlista
DocType: Amazon MWS Settings,JP,JP
DocType: BOM,Scrap Items,skrot Items
DocType: Work Order,Actual Start Date,Faktiskt startdatum
DocType: Sales Order,% of materials delivered against this Sales Order,% Av material som levereras mot denna kundorder
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Hoppa över lönestrukturuppdrag för följande anställda, eftersom lönestrukturuppdraget redan finns mot dem. {0}"
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Generera materialförfrågningar (MRP) och arbetsorder.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Ange standard betalningssätt
DocType: Stock Entry Detail,Against Stock Entry,Mot aktieinmatning
DocType: Grant Application,Withdrawn,kallas
DocType: Support Search Source,Support Search Source,Stöd sökkälla
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,chargeble
DocType: Project,Gross Margin %,Bruttomarginal%
DocType: BOM,With Operations,Med verksamhet
DocType: Support Search Source,Post Route Key List,Skriv in ruttlängdslistan
apps/erpnext/erpnext/accounts/party.py,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Bokföringsposter har redan gjorts i valuta {0} för företag {1}. Välj en fordran eller skuld konto med valuta {0}.
DocType: Asset,Is Existing Asset,Är befintlig tillgång
DocType: Salary Component,Statistical Component,Statistisk komponent
DocType: Salary Component,Statistical Component,Statistisk komponent
DocType: Warranty Claim,If different than customer address,Om annan än kundens adress
DocType: Purchase Invoice,Without Payment of Tax,Utan betalning av skatt
DocType: BOM Operation,BOM Operation,BOM Drift
DocType: Purchase Taxes and Charges,On Previous Row Amount,På föregående v Belopp
DocType: Options,Is Correct,Är korrekt
DocType: Item,Has Expiry Date,Har förfallodatum
apps/erpnext/erpnext/config/support.py,Issue Type.,Problemtyp.
DocType: POS Profile,POS Profile,POS-Profil
DocType: Training Event,Event Name,Händelsenamn
DocType: Healthcare Practitioner,Phone (Office),Telefon (Office)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Kan inte lämna in, Anställda kvar för att markera närvaro"
DocType: Inpatient Record,Admission,Tillträde
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Antagning för {0}
DocType: Shift Type,Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,Senast känd framgångsrik synkronisering av anställd incheckning Återställ detta bara om du är säker på att alla loggar synkroniseras från alla platser. Vänligen ändra inte detta om du är osäker.
apps/erpnext/erpnext/config/accounts.py,"Seasonality for setting budgets, targets etc.","Säsongs för att fastställa budgeten, mål etc."
apps/erpnext/erpnext/www/all-products/index.html,No values,Inga värden
DocType: Supplier Scorecard Scoring Variable,Variable Name,Variabelt namn
apps/erpnext/erpnext/stock/get_item_details.py,"Item {0} is a template, please select one of its variants","Punkt {0} är en mall, välj en av dess varianter"
DocType: Purchase Invoice Item,Deferred Expense,Uppskjuten kostnad
apps/erpnext/erpnext/public/js/hub/pages/Messages.vue,Back to Messages,Tillbaka till meddelanden
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be before employee's joining Date {1},Från datum {0} kan inte vara före anställdes datum {1}
DocType: Purchase Invoice Item,Asset Category,tillgångsslag
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Nettolön kan inte vara negativ
DocType: Purchase Order,Advance Paid,Förskottsbetalning
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Överproduktionsprocent för försäljningsorder
DocType: Item Group,Item Tax,Produkt Skatt
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Material till leverantören
DocType: Soil Texture,Loamy Sand,Lerig sand
,Lost Opportunity,Förlorad möjlighet
DocType: Accounts Settings,Determine Address Tax Category From,Bestäm adressskattekategori från
DocType: Production Plan,Material Request Planning,Material Beställningsplanering
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Punkt Faktura
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Treshold {0}% appears more than once,Tröskel {0}% visas mer än en gång
DocType: Expense Claim,Employees Email Id,Anställdas E-post Id
DocType: Employee Attendance Tool,Marked Attendance,Marked Närvaro
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,Nuvarande Åtaganden
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,Timern översteg de angivna timmarna.
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,Skicka mass SMS till dina kontakter
DocType: Inpatient Record,A Positive,En positiv
DocType: Program,Program Name,program~~POS=TRUNC
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Värdera skatt eller avgift för
DocType: Driver,Driving License Category,Körkortskategori
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Faktiska Antal är obligatorisk
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} har för närvarande {1} leverantörsanmärkning och inköpsorder till denna leverantör bör utfärdas med försiktighet!
DocType: Asset Maintenance Team,Asset Maintenance Team,Asset Maintenance Team
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} har skickats in framgångsrikt
DocType: Loan,Loan Type,lånetyp
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,Kreditkort
DocType: Quality Goal,Quality Goal,Kvalitetsmål
DocType: BOM,Item to be manufactured or repacked,Produkt som skall tillverkas eller packas
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Syntaxfel i skick: {0}
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
DocType: Employee Education,Major/Optional Subjects,Stora / valfria ämnen
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please Set Supplier Group in Buying Settings.,Ange leverantörsgrupp i köpinställningar.
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Driver,Suspended,Upphängd
DocType: Training Event,Attendees,Deltagare
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Här kan du behålla familje detaljer som namn och ockupationen av förälder, make och barn"
DocType: Academic Term,Term End Date,Term Slutdatum
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Skatter och avgifter Avgår (Company valuta)
DocType: Item Group,General Settings,Allmänna Inställningar
DocType: Article,Article,Artikel
apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Ange kupongkod !!
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Från valuta och till valuta kan inte vara samma
DocType: Taxable Salary Slab,Percent Deduction,Procentavdrag
DocType: GL Entry,To Rename,Att byta namn
DocType: Stock Entry,Repack,Packa om
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,Välj för att lägga till serienummer.
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',Vänligen ange skattekod för kunden &#39;% s&#39;
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Var god välj Företaget först
DocType: Item Attribute,Numeric Values,Numeriska värden
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Fäst Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,lager~~POS=TRUNC
DocType: Customer,Commission Rate,Provisionbetyg
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Framgångsrikt skapade betalningsuppgifter
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Skapade {0} scorecards för {1} mellan:
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py,Not permitted. Please disable the Procedure Template,Inte tillåtet. Avaktivera procedurmallen
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"Payment Type must be one of Receive, Pay and Internal Transfer",Betalning Type måste vara en av mottagning Betala och intern överföring
DocType: Travel Itinerary,Preferred Area for Lodging,Önskat område för logi
apps/erpnext/erpnext/config/agriculture.py,Analytics,Analytics
DocType: Salary Detail,Additional Amount,Ytterligare belopp
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Kundvagnen är tom
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",Artikel {0} har ingen serienummer. Endast seriliserade artiklar \ kan ha leverans baserat på serienummer
DocType: Vehicle,Model,Modell
DocType: Work Order,Actual Operating Cost,Faktisk driftkostnad
DocType: Payment Entry,Cheque/Reference No,Check / referensnummer
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,Hämta baserat på FIFO
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Root kan inte redigeras.
DocType: Item,Units of Measure,Måttenheter
DocType: Employee Tax Exemption Declaration,Rented in Metro City,Hyrd i Metro City
DocType: Supplier,Default Tax Withholding Config,Standardskatteavdrag Konfig
DocType: Manufacturing Settings,Allow Production on Holidays,Tillåt Produktion på helgdagar
DocType: Sales Invoice,Customer's Purchase Order Date,Kundens inköpsorder Datum
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Stock,Kapital Lager
DocType: Asset,Default Finance Book,Standard finansbok
DocType: Shopping Cart Settings,Show Public Attachments,Visa offentliga bilagor
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Redigera publiceringsdetaljer
DocType: Packing Slip,Package Weight Details,Paket Vikt Detaljer
DocType: Leave Type,Is Compensatory,Är kompensatorisk
DocType: Restaurant Reservation,Reservation Time,Bokningstid
DocType: Payment Gateway Account,Payment Gateway Account,Betalning Gateway konto
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Efter betalning avslutad omdirigera användare till valda sidan.
DocType: Company,Existing Company,befintliga Company
DocType: Healthcare Settings,Result Emailed,Resultat Emailed
DocType: Item Tax Template Detail,Item Tax Template Detail,Objekt skatt mall mall
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Skattekategori har ändrats till &quot;Totalt&quot; eftersom alla artiklar är poster som inte är lagret
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,To date can not be equal or less than from date,Hittills kan det inte vara lika eller mindre än från datumet
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Inget att ändra
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,En ledare kräver antingen en persons namn eller en organisations namn
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,Välj en csv-fil
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,Fel i vissa rader
DocType: Holiday List,Total Holidays,Totalt helgdagar
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,Missande e-postmall för leverans. Ange en i Leveransinställningar.
DocType: Student Leave Application,Mark as Present,Mark som Present
DocType: Supplier Scorecard,Indicator Color,Indikatorfärg
DocType: Purchase Order,To Receive and Bill,Ta emot och Bill
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,Rad # {0}: Reqd by Date kan inte vara före Transaktionsdatum
DocType: Asset Maintenance,Select Serial No,Välj serienummer
DocType: Pricing Rule,Is Cumulative,Är kumulativ
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,Designer
apps/erpnext/erpnext/config/accounts.py,Terms and Conditions Template,Villkor Mall
DocType: Delivery Trip,Delivery Details,Leveransdetaljer
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Please fill in all the details to generate Assessment Result.,Fyll i alla detaljer för att generera bedömningsresultat.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cost Center is required in row {0} in Taxes table for type {1},Kostnadsställe krävs rad {0} i skatte tabellen för typ {1}
DocType: Terms and Conditions,Terms and Conditions Help,Villkor Hjälp
,Item-wise Purchase Register,Produktvis Inköpsregister
DocType: Loyalty Point Entry,Expiry Date,Utgångsdatum
DocType: Healthcare Settings,Employee name and designation in print,Anställdsnamn och beteckning i tryck
apps/erpnext/erpnext/config/buying.py,Supplier Addresses and Contacts,Leverantör adresser och kontakter
,accounts-browser,konton-browser
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,Vänligen välj kategori först
apps/erpnext/erpnext/config/projects.py,Project master.,Projektchef.
DocType: Contract,Contract Terms,Kontraktsvillkor
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Fortsätt konfigurationen
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Visa inte någon symbol som $ etc bredvid valutor.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Maximal förmånsbelopp för komponent {0} överstiger {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),(Halv Dag)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Behandla stamdata
DocType: Payment Term,Credit Days,Kreditdagar
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,Var god välj Patient för att få Lab Test
DocType: Exotel Settings,Exotel Settings,Exotel-inställningar
DocType: Leave Ledger Entry,Is Carry Forward,Är Överförd
DocType: Shift Type,Working hours below which Absent is marked. (Zero to disable),Arbetstid under vilka frånvaro markeras. (Noll att inaktivera)
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Send a message,Skicka ett meddelande
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Hämta artiklar från BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Ledtid dagar
DocType: Cash Flow Mapping,Is Income Tax Expense,Är inkomstskattkostnad
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,Din beställning är ute för leverans!
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Kolla här om studenten är bosatt vid institutets vandrarhem.
DocType: Course,Hero Image,Hjältebild
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,Ange kundorder i tabellen ovan
,Stock Summary,lager Sammanfattning
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Överföra en tillgång från ett lager till ett annat
DocType: Vehicle,Petrol,Bensin
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Återstående förmåner (årlig)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,Bill of Materials
DocType: Shift Type,The time after the shift start time when check-in is considered as late (in minutes).,Tiden efter skiftets starttid när incheckning betraktas som sent (i minuter).
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Rad {0}: Parti Typ och Parti krävs för obetalda / konto {1}
DocType: Employee,Leave Policy,Lämna policy
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Uppdatera objekt
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,Ref Datum
DocType: Employee,Reason for Leaving,Anledning för att lämna
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View call log,Visa samtalslogg
DocType: BOM Operation,Operating Cost(Company Currency),Driftskostnad (Company valuta)
DocType: Loan Application,Rate of Interest,RÄNTEFOT
DocType: Expense Claim Detail,Sanctioned Amount,Sanktionerade Belopp
DocType: Item,Shelf Life In Days,Hållbarhet i dagar
DocType: GL Entry,Is Opening,Är Öppning
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Unable to find the time slot in the next {0} days for the operation {1}.,Det gick inte att hitta tidsluckan under de kommande {0} dagarna för operationen {1}.
DocType: Department,Expense Approvers,Expense Approvers
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Debit entry can not be linked with a {1},Rad {0}: debitering kan inte kopplas till en {1}
DocType: Journal Entry,Subscription Section,Prenumerationsavsnitt
apps/erpnext/erpnext/controllers/buying_controller.py,{0} Asset{2} Created for <b>{1}</b>,{0} Tillgång {2} Skapad för <b>{1}</b>
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} does not exist,Kontot {0} existerar inte
DocType: Training Event,Training Program,Träningsprogram
DocType: Account,Cash,Kontanter
DocType: Sales Invoice,Unpaid and Discounted,Obetald och rabatterad
DocType: Employee,Short biography for website and other publications.,Kort biografi för webbplatsen och andra publikationer.
