diff --git a/erpnext/translations/nl.csv b/erpnext/translations/nl.csv
index b7bb6fd..7e262fd 100644
--- a/erpnext/translations/nl.csv
+++ b/erpnext/translations/nl.csv
@@ -1,5841 +1,5999 @@
-b'DocType: Employee',b'Salary Mode',b'Salaris Modus'
-b'DocType: Patient',b'Divorced',b'Gescheiden'
-b'DocType: Buying Settings',b'Allow Item to be added multiple times in a transaction',b'Toestaan Item om meerdere keren in een transactie worden toegevoegd'
-b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33',b'Cancel Material Visit {0} before cancelling this Warranty Claim',b'Annuleren Materiaal Bezoek {0} voor het annuleren van deze Garantie Claim'
-b'apps/erpnext/erpnext/config/education.py +118',b'Assessment Reports',b'Beoordelingsrapporten'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19',b'Consumer Products',b'Consumentenproducten'
-b'DocType: Purchase Receipt',b'Subscription Detail',b'Abonnement Detail'
-b'DocType: Supplier Scorecard',b'Notify Supplier',b'Meld Leverancier in'
-b'DocType: Item',b'Customer Items',b'Klant Items'
-b'DocType: Project',b'Costing and Billing',b'Kostenberekening en facturering'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +48',b'Account {0}: Parent account {1} can not be a ledger',b'Rekening {0}: Bovenliggende rekening {1} kan geen grootboek zijn'
-b'DocType: Item',b'Publish Item to hub.erpnext.com',b'Publiceer Item om hub.erpnext.com'
-b'apps/erpnext/erpnext/config/setup.py +88',b'Email Notifications',b'E-mail Notificaties'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26',b'Evaluation',b'evaluatie'
-b'DocType: Item',b'Default Unit of Measure',b'Standaard Eenheid'
-b'DocType: SMS Center',b'All Sales Partner Contact',b'Alle Sales Partner Contact'
-b'DocType: Employee',b'Leave Approvers',b'Verlof goedkeurders'
-b'DocType: Sales Partner',b'Dealer',b'Dealer'
-b'DocType: Work Order',b'WO-',b'WO-'
-b'DocType: Consultation',b'Investigations',b'onderzoeken'
-b'DocType: Restaurant Order Entry',b'Click Enter To Add',b'Klik op Enter om toe te voegen'
-b'DocType: Employee',b'Rented',b'Verhuurd'
-b'DocType: Purchase Order',b'PO-',b'PO'
-b'DocType: Vehicle Service',b'Mileage',b'Mileage'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +253',b'Do you really want to scrap this asset?',b'Wilt u dit actief echt schrappen?'
-b'DocType: Drug Prescription',b'Update Schedule',b'Update Schema'
-b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44',b'Select Default Supplier',b'Selecteer Standaard Leverancier'
-b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37',b'Currency is required for Price List {0}',b'Munt is nodig voor prijslijst {0}'
-b'DocType: Sales Taxes and Charges Template',b'* Will be calculated in the transaction.',b'* Zal worden berekend in de transactie.'
-b'DocType: Purchase Order',b'Customer Contact',b'Contactpersoon Klant'
-b'DocType: Patient Appointment',b'Check availability',b'Beschikbaarheid controleren'
-b'DocType: Job Applicant',b'Job Applicant',b'Sollicitant'
-b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6',b'This is based on transactions against this Supplier. See timeline below for details',b'Dit is gebaseerd op transacties tegen deze leverancier. Zie tijdlijn hieronder voor meer informatie'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120',b'Legal',b'Wettelijk'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191',b'Actual type tax cannot be included in Item rate in row {0}',b'Werkelijke soort belasting kan niet worden opgenomen in post tarief in rij {0}'
-b'DocType: Bank Guarantee',b'Customer',b'Klant'
-b'DocType: Purchase Receipt Item',b'Required By',b'Benodigd op'
-b'DocType: Delivery Note',b'Return Against Delivery Note',b'Terug Tegen Delivery Note'
-b'DocType: Purchase Order',b'% Billed',b'% Gefactureerd'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43',b'Exchange Rate must be same as {0} {1} ({2})',b'Wisselkoers moet hetzelfde zijn als zijn {0} {1} ({2})'
-b'DocType: Sales Invoice',b'Customer Name',b'Klantnaam'
-b'DocType: Vehicle',b'Natural Gas',b'Natuurlijk gas'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64',b'Bank account cannot be named as {0}',b'Bankrekening kan niet worden genoemd als {0}'
-b'DocType: Account',b'Heads (or groups) against which Accounting Entries are made and balances are maintained.',b'Hoofden (of groepen) waartegen de boekingen worden gemaakt en saldi worden gehandhaafd.'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196',b'Outstanding for {0} cannot be less than zero ({1})',b'Openstaand bedrag voor {0} mag niet kleiner zijn dan nul ({1})'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348',b'There are no submitted Salary Slips to process.',b'Er zijn geen loonslips ingediend om te verwerken.'
-b'DocType: Manufacturing Settings',b'Default 10 mins',b'Standaard 10 min'
-b'DocType: Leave Type',b'Leave Type Name',b'Verlof Type Naam'
-b'apps/erpnext/erpnext/templates/pages/projects.js +62',b'Show open',b'Toon geopend'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8',b'It is necessary to take this action today itself for the above mentioned recurring',b'Het is noodzakelijk om deze actie vandaag zelf te nemen voor bovengenoemde herhalende'
-b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156',b'Series Updated Successfully',b'Reeks succesvol bijgewerkt'
-b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6',b'Checkout',b'Uitchecken'
-b'DocType: Pricing Rule',b'Apply On',b'toepassing op'
-b'DocType: Item Price',b'Multiple Item prices.',b'Meerdere Artikelprijzen .'
-,b'Purchase Order Items To Be Received',b'Inkooporder Artikelen nog te ontvangen'
-b'DocType: SMS Center',b'All Supplier Contact',b'Alle Leverancier Contact'
-b'DocType: Support Settings',b'Support Settings',b'ondersteuning Instellingen'
-b'apps/erpnext/erpnext/projects/doctype/project/project.py +75',b'Expected End Date can not be less than Expected Start Date',b'Verwachte Einddatum kan niet minder dan verwacht Startdatum zijn'
-b'apps/erpnext/erpnext/utilities/transaction_base.py +121',b'Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ',b'Rij # {0}: Beoordeel moet hetzelfde zijn als zijn {1}: {2} ({3} / {4})'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241',b'New Leave Application',b'Nieuwe Verlofaanvraag'
-,b'Batch Item Expiry Status',b'Batch Item Vervaldatum Status'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184',b'Bank Draft',b'Bankcheque'
-b'DocType: Membership',b'membership validaty section',b'lidmaatschapsvalidatie'
-b'DocType: Mode of Payment Account',b'Mode of Payment Account',b'Modus van Betaalrekening'
-b'DocType: Consultation',b'Consultation',b'Overleg'
-b'DocType: Accounts Settings',b'Show Payment Schedule in Print',b'Toon betalingsschema in Print'
-b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19',b'Sales and Returns',b'Verkoop en retourneren'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +56',b'Show Variants',b'Toon Varianten'
-b'DocType: Academic Term',b'Academic Term',b'Academisch semester'
-b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14',b'Material',b'Materiaal'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66',b'Making website',b'Website maken'
-b'DocType: Opening Invoice Creation Tool Item',b'Quantity',b'Hoeveelheid'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546',b'Accounts table cannot be blank.',b'Rekeningtabel mag niet leeg zijn.'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154',b'Loans (Liabilities)',b'Leningen (Passiva)'
-b'DocType: Employee Education',b'Year of Passing',b'Voorbije Jaar'
-b'DocType: Item',b'Country of Origin',b'Land van herkomst'
-b'DocType: Soil Texture',b'Soil Texture Criteria',b'Bodemtextuurcriteria'
-b'apps/erpnext/erpnext/templates/includes/product_page.js +25',b'In Stock',b'Op Voorraad'
-b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16',b'Primary Contact Details',b'Primaire contactgegevens'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46',b'Open Issues',b'Open Issues'
-b'DocType: Production Plan Item',b'Production Plan Item',b'Productie Plan Artikel'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +149',b'User {0} is already assigned to Employee {1}',b'Gebruiker {0} is al aan Werknemer toegewezen {1}'
-b'DocType: Lab Test Groups',b'Add new line',b'Voeg een nieuwe regel toe'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31',b'Health Care',b'Gezondheidszorg'
-b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65',b'Delay in payment (Days)',b'Vertraging in de betaling (Dagen)'
-b'DocType: Payment Terms Template Detail',b'Payment Terms Template Detail',b'Betalingsvoorwaarden sjabloondetail'
-b'DocType: Hotel Room Reservation',b'Guest Name',b'Gast naam'
-b'DocType: Lab Prescription',b'Lab Prescription',b'Lab Prescription'
-,b'Delay Days',b'Vertragingen dagen'
-b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26',b'Service Expense',b'dienst Expense'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899',b'Serial Number: {0} is already referenced in Sales Invoice: {1}',b'Serienummer: {0} is reeds verwezen in de verkoopfactuur: {1}'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889',b'Invoice',b'Factuur'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145',b'Make Retention Stock Entry',b'Maak retentie aandelenboeking'
-b'DocType: Purchase Invoice Item',b'Item Weight Details',b'Item Gewicht Details'
-b'DocType: Asset Maintenance Log',b'Periodicity',b'Periodiciteit'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21',b'Fiscal Year {0} is required',b'Boekjaar {0} is vereist'
-b'DocType: Crop Cycle',b'The minimum distance between rows of plants for optimum growth',b'De minimale afstand tussen rijen planten voor optimale groei'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21',b'Defense',b'Defensie'
-b'DocType: Salary Component',b'Abbr',b'Afk'
-b'DocType: Appraisal Goal',b'Score (0-5)',b'Score (0-5)'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225',b'Row {0}: {1} {2} does not match with {3}',b'Rij {0}: {1} {2} niet overeenkomt met {3}'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77',b'Row # {0}:',b'Rij # {0}:'
-b'DocType: Timesheet',b'Total Costing Amount',b'Totaal bedrag Costing'
-b'DocType: Delivery Note',b'Vehicle No',b'Voertuig nr.'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163',b'Please select Price List',b'Selecteer Prijslijst'
-b'DocType: Accounts Settings',b'Currency Exchange Settings',b'Valutaveursinstellingen'
-b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94',b'Row #{0}: Payment document is required to complete the trasaction',b'Row # {0}: Betaling document is vereist om de trasaction voltooien'
-b'DocType: Work Order Operation',b'Work In Progress',b'Onderhanden Werk'
-b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13',b'Please select date',b'Kies een datum'
-b'DocType: Daily Work Summary Group',b'Holiday List',b'Holiday Lijst'
-b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88',b'Please setup numbering series for Attendance via Setup &gt; Numbering Series',b'Stel nummeringsreeksen in voor Aanwezigheid via Setup&gt; Nummeringserie'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127',b'Accountant',b'Accountant'
-b'DocType: Hub Settings',b'Selling Price List',b'Verkoopprijslijst'
-b'DocType: Patient',b'Tobacco Current Use',b'Tabaksgebruik'
-b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56',b'Selling Rate',b'Verkoopcijfers'
-b'DocType: Cost Center',b'Stock User',b'Aandeel Gebruiker'
-b'DocType: Soil Analysis',b'(Ca+Mg)/K',b'(Ca + Mg) / K'
-b'DocType: Company',b'Phone No',b'Telefoonnummer'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239',b'New {0}: #{1}',b'Nieuwe {0}: # {1}'
-b'DocType: Delivery Trip',b'Initial Email Notification Sent',b'E-mailkennisgeving verzonden'
-,b'Sales Partners Commission',b'Verkoop Partners Commissie'
-b'DocType: Soil Texture',b'Sandy Clay Loam',b'Sandy Clay Loam'
-b'DocType: Purchase Invoice',b'Rounding Adjustment',b'Afrondingsaanpassing'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +46',b'Abbreviation cannot have more than 5 characters',b'Afkorting kan niet meer dan 5 tekens lang zijn'
-b'DocType: Physician Schedule Time Slot',b'Physician Schedule Time Slot',b'Tijdschema voor arts Schema'
-b'DocType: Payment Request',b'Payment Request',b'Betalingsverzoek'
-b'DocType: Asset',b'Value After Depreciation',b'Restwaarde'
-b'DocType: Student',b'O+',b'O +'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8',b'Related',b'Verwant'
-b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43',"b""Attendance date can not be less than employee's joining date""",b'Aanwezigheid datum kan niet lager zijn dan het samenvoegen van de datum werknemer zijn'
-b'DocType: Grading Scale',b'Grading Scale Name',b'Grading Scale Naam'
-b'DocType: Subscription',b'Repeat on Day',b'Herhaal op dag'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.js +41',b'This is a root account and cannot be edited.',b'Dit is een basisrekening en kan niet worden bewerkt.'
-b'DocType: Sales Invoice',b'Company Address',b'bedrijfsadres'
-b'DocType: BOM',b'Operations',b'Bewerkingen'
-b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38',b'Cannot set authorization on basis of Discount for {0}',b'Kan de autorisatie niet instellen op basis van korting voor {0}'
-b'DocType: Rename Tool',"b'Attach .csv file with two columns, one for the old name and one for the new name'","b'Bevestig .csv-bestand met twee kolommen, \xc3\xa9\xc3\xa9n voor de oude naam en \xc3\xa9\xc3\xa9n voor de nieuwe naam'"
-b'apps/erpnext/erpnext/accounts/utils.py +73',b'{0} {1} not in any active Fiscal Year.',b'{0} {1} in geen enkel actief fiscale jaar.'
-b'DocType: Packed Item',b'Parent Detail docname',b'Bovenliggende Detail docname'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69',"b'Reference: {0}, Item Code: {1} and Customer: {2}'","b'Referentie: {0}, Artikelcode: {1} en klant: {2}'"
-b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Kg',b'kg'
-b'apps/erpnext/erpnext/config/hr.py +45',b'Opening for a Job.',b'Vacature voor een baan.'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114',b'BOM is not specified for subcontracting item {0} at row {1}',b'Stuklijst is niet gespecificeerd voor uitbesteding van item {0} in rij {1}'
-b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149',b'{0} Result submittted',b'{0} Resultaat ingediend'
-b'DocType: Item Attribute',b'Increment',b'Aanwas'
-b'apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74',b'Timespan',b'Tijdspanne'
-b'apps/erpnext/erpnext/public/js/stock_analytics.js +58',b'Select Warehouse...',b'Kies Warehouse ...'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6',b'Advertising',b'Adverteren'
-b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22',b'Same Company is entered more than once',b'Hetzelfde bedrijf is meer dan \xc3\xa9\xc3\xa9n keer ingevoerd'
-b'DocType: Patient',b'Married',b'Getrouwd'
-b'apps/erpnext/erpnext/accounts/party.py +41',b'Not permitted for {0}',b'Niet toegestaan voor {0}'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593',b'Get items from',b'Krijgen items uit'
-b'DocType: Price List',b'Price Not UOM Dependant',b'Prijs niet afhankelijk van UOM'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467',b'Stock cannot be updated against Delivery Note {0}',b'Voorraad kan niet worden bijgewerkt obv Vrachtbrief {0}'
-b'apps/erpnext/erpnext/templates/pages/home.py +25',b'Product {0}',b'Product {0}'
-b'apps/erpnext/erpnext/templates/generators/item_group.html +43',b'No items listed',b'Geen artikelen vermeld'
-b'DocType: Asset Repair',b'Error Description',b'Foutbeschrijving'
-b'DocType: Payment Reconciliation',b'Reconcile',b'Afletteren'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30',b'Grocery',b'Kruidenierswinkel'
-b'DocType: Quality Inspection Reading',b'Reading 1',b'Meting 1'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40',b'Pension Funds',b'pensioenfondsen'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +91',b'Next Depreciation Date cannot be before Purchase Date',b'Volgende afschrijvingen datum kan niet v\xc3\xb3\xc3\xb3r Aankoopdatum'
-b'DocType: Crop',b'Perennial',b'eeuwigdurend'
-b'DocType: Consultation',b'Consultation Date',b'Raadplegingsdatum'
-b'DocType: Accounts Settings',b'Use Custom Cash Flow Format',b'Gebruik aangepaste kasstroomindeling'
-b'DocType: SMS Center',b'All Sales Person',b'Alle Sales Person'
-b'DocType: Monthly Distribution',b'**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.',b'** Maandelijkse Distributie ** helpt u om de begroting / Target verdelen over maanden als u de seizoensgebondenheid in uw bedrijf.'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1753',b'Not items found',b'Niet artikelen gevonden'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184',b'Salary Structure Missing',b'Salarisstructuur Missing'
-b'DocType: Lead',b'Person Name',b'Persoon Naam'
-b'DocType: Sales Invoice Item',b'Sales Invoice Item',b'Verkoopfactuur Artikel'
-b'DocType: Account',b'Credit',b'Krediet'
-b'DocType: POS Profile',b'Write Off Cost Center',b'Afschrijvingen kostenplaats'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +117',"b'e.g. ""Primary School"" or ""University""'",b'bijvoorbeeld &quot;Primary School&quot; of &quot;University&quot;'
-b'apps/erpnext/erpnext/config/stock.py +28',b'Stock Reports',b'Stock Reports'
-b'DocType: Warehouse',b'Warehouse Detail',b'Magazijn Detail'
-b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33',b'The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',b'De Term Einddatum kan niet later dan het jaar Einddatum van het studiejaar waarop de term wordt gekoppeld zijn (Academisch Jaar {}). Corrigeer de data en probeer het opnieuw.'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +269',"b'""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item'","b'""Is vaste activa"" kan niet worden uitgeschakeld, als Asset record bestaat voor dit item'"
-b'DocType: Delivery Trip',b'Departure Time',b'Vertrektijd'
-b'DocType: Vehicle Service',b'Brake Oil',b'remolie'
-b'DocType: Tax Rule',b'Tax Type',b'Belasting Type'
-,b'Completed Work Orders',b'Voltooide werkorders'
-b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +581',b'Taxable Amount',b'Belastbaar bedrag'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160',b'You are not authorized to add or update entries before {0}',b'U bent niet bevoegd om items toe te voegen of bij te werken voor {0}'
-b'DocType: BOM',b'Item Image (if not slideshow)',b'Artikel Afbeelding (indien niet diashow)'
-b'DocType: Work Order Operation',b'(Hour Rate / 60) * Actual Operation Time',b'(Uurtarief / 60) * Werkelijk Gepresteerde Tijd'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103',b'Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry',b'Rij # {0}: Referentiedocumenttype moet \xc3\xa9\xc3\xa9n van de kostenrekening of het journaalboekje zijn'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975',b'Select BOM',b'Select BOM'
-b'DocType: SMS Log',b'SMS Log',b'SMS Log'
-b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Delivered Items',b'Kosten van geleverde zaken'
-b'apps/erpnext/erpnext/config/hr.py +127',b'Manage advance amount given to the Employee',b'Beheer vooraf bedrag gegeven aan de werknemer'
-b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38',b'The holiday on {0} is not between From Date and To Date',b'De vakantie op {0} is niet tussen Van Datum en To Date'
-b'DocType: Student Log',b'Student Log',b'student Log'
-b'apps/erpnext/erpnext/config/buying.py +165',b'Templates of supplier standings.',b'Sjablonen van leveranciers standings.'
-b'DocType: Lead',b'Interested',b'Ge\xc3\xafnteresseerd'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216',b'Opening',b'Opening'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32',b'From {0} to {1}',b'Van {0} tot {1}'
-b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234',b'Program: ',b'Programma:'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50',b'Failed to setup taxes',b'Het instellen van belastingen is mislukt'
-b'DocType: Item',b'Copy From Item Group',b'Kopi\xc3\xabren van Item Group'
-b'DocType: Delivery Trip',b'Delivery Notification',b'Bezorg notificatie'
-b'DocType: Journal Entry',b'Opening Entry',b'Opening Entry'
-b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25',b'Account Pay Only',b'Rekening betalen enkel'
-b'DocType: Employee Loan',b'Repay Over Number of Periods',b'Terug te betalen gedurende een aantal perioden'
-b'DocType: Stock Entry',b'Additional Costs',b'Bijkomende kosten'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +138',b'Account with existing transaction can not be converted to group.',b'Rekening met bestaande transactie kan niet worden omgezet naar een groep .'
-b'DocType: Lead',b'Product Enquiry',b'Product Aanvraag'
-b'DocType: Education Settings',b'Validate Batch for Students in Student Group',b'Batch valideren voor studenten in de studentengroep'
-b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35',b'No leave record found for employee {0} for {1}',b'Geen verlof gevonden record voor werknemer {0} voor {1}'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23',b'Please enter company first',b'Vul aub eerst bedrijf in'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365',b'Please select Company first',b'Selecteer Company eerste'
-b'DocType: Employee Education',b'Under Graduate',b'Student zonder graad'
-b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27',b'Target On',b'Doel op'
-b'DocType: BOM',b'Total Cost',b'Totale kosten'
-b'DocType: Soil Analysis',b'Ca/K',b'Ca / K'
-b'DocType: Journal Entry Account',b'Employee Loan',b'werknemer Loan'
-b'DocType: Fee Schedule',b'Send Payment Request Email',b'Stuur een e-mail voor betalingsverzoek'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268',b'Item {0} does not exist in the system or has expired',b'Artikel {0} bestaat niet in het systeem of is verlopen'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44',b'Real Estate',b'Vastgoed'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1',b'Statement of Account',b'Rekeningafschrift'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41',b'Pharmaceuticals',b'Farmacie'
-b'DocType: Purchase Invoice Item',b'Is Fixed Asset',b'Is vaste activa'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273',"b'Available qty is {0}, you need {1}'","b'Beschikbare aantal is {0}, moet u {1}'"
-b'DocType: Expense Claim Detail',b'Claim Amount',b'Claim Bedrag'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +653',b'Work Order has been {0}',b'Werkorder is {0}'
-b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56',b'Duplicate customer group found in the cutomer group table',b'Duplicate klantengroep in de cutomer groep tafel'
-b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31',b'Supplier Type / Supplier',b'Leverancier Type / leverancier'
-b'DocType: Naming Series',b'Prefix',b'Voorvoegsel'
-b'apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7',b'Event Location',b'Gebeurtenis Locatie'
-b'DocType: Asset Settings',b'Asset Settings',b'Activuminstellingen'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68',b'Consumable',b'Verbruiksartikelen'
-b'DocType: Student',b'B-',b'B-'
-b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98',b'Successfully unregistered.',b'Succesvol afgemeld.'
-b'DocType: Assessment Result',b'Grade',b'Rang'
-b'DocType: Restaurant Table',b'No of Seats',b'Aantal zitplaatsen'
-b'DocType: Subscription',"b'To add dynamic subject, use jinja tags like\n\n<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>'","b'Om dynamisch onderwerp toe te voegen, gebruik jinja tags zoals <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>'"
-b'DocType: Sales Invoice Item',b'Delivered By Supplier',b'Geleverd door Leverancier'
-b'DocType: Asset Maintenance Task',b'Asset Maintenance Task',b'Asset Maintenance Task'
-b'DocType: SMS Center',b'All Contact',b'Alle Contact'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232',b'Annual Salary',b'Jaarsalaris'
-b'DocType: Daily Work Summary',b'Daily Work Summary',b'Dagelijks Werk Samenvatting'
-b'DocType: Period Closing Voucher',b'Closing Fiscal Year',b'Het sluiten van het fiscale jaar'
-b'apps/erpnext/erpnext/accounts/party.py +392',b'{0} {1} is frozen',b'{0} {1} is bevroren'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +140',b'Please select Existing Company for creating Chart of Accounts',b'Kies een bestaand bedrijf voor het maken van Rekeningschema'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80',b'Stock Expenses',b'Voorraadkosten'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Selecteer Target Warehouse'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Selecteer Target Warehouse'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.js +80',b'Please enter Preferred Contact Email',b'Vul Preferred Contact E-mail'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxNum',b'CompAuxNum'
-b'DocType: Journal Entry',b'Contra Entry',b'Contra Entry'
-b'DocType: Journal Entry Account',b'Credit in Company Currency',b'Credit Company in Valuta'
-b'DocType: Lab Test UOM',b'Lab Test UOM',b'Lab Test UOM'
-b'DocType: Delivery Note',b'Installation Status',b'Installatie Status'
-b'DocType: BOM',b'Quality Inspection Template',b'Kwaliteitscontrolesjabloon'
-b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135',b'Do you want to update attendance?<br>Present: {0}\\\n\t\t\t\t\t<br>Absent: {1}',b'Wilt u aanwezig updaten? <br> Aanwezig: {0} \\ <br> Afwezig: {1}'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +334',b'Accepted + Rejected Qty must be equal to Received quantity for Item {0}',b'Geaccepteerde + Verworpen Aantal moet gelijk zijn aan Ontvangen aantal zijn voor Artikel {0}'
-b'DocType: Request for Quotation',b'RFQ-',b'RFQ-'
-b'DocType: Item',b'Supply Raw Materials for Purchase',b'Supply Grondstoffen voor Aankoop'
-b'DocType: Agriculture Analysis Criteria',b'Fertilizer',b'Kunstmest'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152',b'At least one mode of payment is required for POS invoice.',b'Ten minste \xc3\xa9\xc3\xa9n wijze van betaling is vereist voor POS factuur.'
-b'DocType: Products Settings',b'Show Products as a List',b'Producten weergeven als een lijst'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +532',b'Item {0} is not active or end of life has been reached',b'ARtikel {0} is niet actief of heeft einde levensduur bereikt'
-b'DocType: Student Admission Program',b'Minimum Age',b'Minimum leeftijd'
-b'apps/erpnext/erpnext/utilities/user_progress.py +190',b'Example: Basic Mathematics',b'Voorbeeld: Basiswiskunde'
-b'DocType: Customer',b'Primary Address',b'hoofdadres'
-b'DocType: Production Plan',b'Material Request Detail',b'Materiaal Verzoek Detail'
-b'DocType: Selling Settings',b'Default Quotation Validity Days',b'Standaard prijsofferte dagen'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +800',"b'To include tax in row {0} in Item rate, taxes in rows {1} must also be included'","b'Om Belastingen op te nemen in het Artikeltarief in rij {0}, moeten de belastingen in rijen {1} ook worden opgenomen'"
-b'apps/erpnext/erpnext/config/hr.py +223',b'Settings for HR Module',b'Instellingen voor HR Module'
-b'DocType: SMS Center',b'SMS Center',b'SMS Center'
-b'DocType: Sales Invoice',b'Change Amount',b'Change Bedrag'
-b'DocType: GST Settings',b'Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.',b'Factuurwaarde instellen voor B2C. B2CL en B2CS berekend op basis van deze factuurwaarde.'
-b'DocType: BOM Update Tool',b'New BOM',b'Nieuwe Eenheid'
-b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36',b'Show only POS',b'Toon alleen POS'
-b'DocType: Driver',b'Driving License Categories',b'Rijbewijscategorie\xc3\xabn'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118',b'Please enter Delivery Date',b'Vul de Leveringsdatum in'
-b'DocType: Depreciation Schedule',b'Make Depreciation Entry',b'Maak Afschrijvingen Entry'
-b'DocType: Appraisal Template Goal',b'KRA',b'KRA'
-b'DocType: Lead',b'Request Type',b'Aanvraag type'
-b'apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17',b'Make Employee',b'maak Employee'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14',b'Broadcasting',b'Uitzenden'
-b'apps/erpnext/erpnext/config/accounts.py +313',b'Setup mode of POS (Online / Offline)',b'Setup-modus van POS (online / offline)'
-b'DocType: Manufacturing Settings',b'Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order',b'Hiermee wordt het maken van tijdregistraties tegen werkorders uitgeschakeld. Bewerkingen worden niet getraceerd op werkorder'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191',b'Execution',b'Uitvoering'
-b'apps/erpnext/erpnext/config/manufacturing.py +62',b'Details of the operations carried out.',b'Details van de uitgevoerde handelingen.'
-b'DocType: Asset Maintenance Log',b'Maintenance Status',b'Onderhoud Status'
-b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10',b'Membership Details',b'Lidmaatschap details'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56',b'{0} {1}: Supplier is required against Payable account {2}',b'{0} {1}: Leverancier is vereist tegen Te Betalen account {2}'
-b'apps/erpnext/erpnext/config/selling.py +52',b'Items and Pricing',b'Artikelen en prijzen'
-b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2',b'Total hours: {0}',b'Totaal aantal uren: {0}'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43',b'From Date should be within the Fiscal Year. Assuming From Date = {0}',b'Van Datum moet binnen het boekjaar zijn. Er vanuit gaande dat Van Datum {0} is'
-b'DocType: Drug Prescription',b'Interval',b'Interval'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253',b'Preference',b'Voorkeur'
-b'DocType: Grant Application',b'Individual',b'Individueel'
-b'DocType: Academic Term',b'Academics User',b'Academici Gebruiker'
-b'DocType: Cheque Print Template',b'Amount In Figure',b'Bedrag In figuur'
-b'DocType: Employee Loan Application',b'Loan Info',b'Loan Info'
-b'apps/erpnext/erpnext/config/maintenance.py +12',b'Plan for maintenance visits.',b'Plan voor onderhoud bezoeken.'
-b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Period',b'Leverancier Scorecard Periode'
-b'DocType: Share Transfer',b'Share Transfer',b'Deel overdracht'
-b'DocType: POS Profile',b'Customer Groups',b'Doelgroepen'
-b'apps/erpnext/erpnext/public/js/financial_statements.js +51',b'Financial Statements',b'Jaarrekening'
-b'DocType: Guardian',b'Students',b'leerlingen'
-b'apps/erpnext/erpnext/config/selling.py +91',b'Rules for applying pricing and discount.',b'Regels voor de toepassing van prijzen en kortingen .'
-b'DocType: Daily Work Summary',b'Daily Work Summary Group',b'Daily Work Summary Group'
-b'DocType: Physician Schedule',b'Time Slots',b'Time Slots'
-b'apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14',b'Price List must be applicable for Buying or Selling',b'Prijslijst moet van toepassing zijn op Inkoop of Verkoop'
-b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79',b'Installation date cannot be before delivery date for Item {0}',b'De installatie mag niet v\xc3\xb3\xc3\xb3r leveringsdatum voor post {0}'
-b'DocType: Pricing Rule',b'Discount on Price List Rate (%)',b'Korting op de prijslijst Rate (%)'
-b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112',b'Item Template',b'Artikel sjabloon'
-b'apps/erpnext/erpnext/healthcare/setup.py +215',b'Biochemistry',b'Biochemie'
-b'DocType: Job Offer',b'Select Terms and Conditions',b'Select Voorwaarden'
-b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72',b'Out Value',b'out Value'
-b'DocType: Production Plan',b'Sales Orders',b'Verkooporders'
-b'DocType: Purchase Taxes and Charges',b'Valuation',b'Waardering'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +390',b'Set as Default',b'Instellen als standaard'
-b'DocType: Production Plan',b'PLN-',b'PLN-'
-,b'Purchase Order Trends',b'Inkooporder Trends'
-b'apps/erpnext/erpnext/utilities/user_progress.py +78',b'Go to Customers',b'Ga naar klanten'
-b'DocType: Hotel Room Reservation',b'Late Checkin',b'Late check-in'
-b'apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7',b'The request for quotation can be accessed by clicking on the following link',b'Het verzoek voor een offerte kan worden geopend door te klikken op de volgende link'
-b'apps/erpnext/erpnext/config/hr.py +81',b'Allocate leaves for the year.',b'Toewijzen verloven voor het gehele jaar.'
-b'DocType: SG Creation Tool Course',b'SG Creation Tool Course',b'SG Creation Tool Course'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275',b'Insufficient Stock',b'onvoldoende Stock'
-b'DocType: Manufacturing Settings',b'Disable Capacity Planning and Time Tracking',b'Uitschakelen Capacity Planning en Time Tracking'
-b'DocType: Email Digest',b'New Sales Orders',b'Nieuwe Verkooporders'
-b'DocType: Bank Guarantee',b'Bank Account',b'Bankrekening'
-b'DocType: Leave Type',b'Allow Negative Balance',b'Laat negatief saldo'
-b'apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13',"b""You cannot delete Project Type 'External'""",b'U kunt projecttype &#39;extern&#39; niet verwijderen'
-b'DocType: Employee',b'Create User',b'Gebruiker aanmaken'
-b'DocType: Selling Settings',b'Default Territory',b'Standaard Regio'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53',b'Television',b'televisie'
-b'DocType: Work Order Operation',"b""Updated via 'Time Log'""","b""Bijgewerkt via 'Time Log'"""
-b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +430',b'Advance amount cannot be greater than {0} {1}',b'Advance bedrag kan niet groter zijn dan {0} {1}'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalCode',b'JournalCode'
-b'DocType: Naming Series',b'Series List for this Transaction',b'Reeks voor deze transactie'
-b'DocType: Company',b'Enable Perpetual Inventory',b'Perpetual Inventory inschakelen'
-b'DocType: Company',b'Default Payroll Payable Account',b'Default Payroll Payable Account'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51',b'Update Email Group',b'Pas E-Group'
-b'DocType: Sales Invoice',b'Is Opening Entry',b'Wordt Opening Entry'
-b'DocType: Lab Test Template',"b'If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. '","b'Als het selectievakje niet is ingeschakeld, verschijnt het item niet in de verkoopfactuur, maar kan u deze gebruiken bij het maken van groepsopdrachten.'"
-b'DocType: Customer Group',b'Mention if non-standard receivable account applicable',b'Vermeld als niet-standaard te ontvangen houdend met de toepasselijke'
-b'DocType: Course Schedule',b'Instructor Name',b'instructeur Naam'
-b'DocType: Supplier Scorecard',b'Criteria Setup',b'Criteria Setup'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206',b'For Warehouse is required before Submit',b'Voor Magazijn is vereist voor het Indienen'
-b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8',b'Received On',b'Ontvangen op'
-b'DocType: Sales Partner',b'Reseller',b'Reseller'
-b'DocType: Codification Table',b'Medical Code',b'Medisch code'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20',b'Please enter Company',b'Vul Bedrijf in'
-b'DocType: Delivery Note Item',b'Against Sales Invoice Item',b'Tegen Sales Invoice Item'
-b'DocType: Agriculture Analysis Criteria',b'Linked Doctype',b'Gekoppeld Doctype'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44',b'Net Cash from Financing',b'De netto kasstroom uit financieringsactiviteiten'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2375',"b'LocalStorage is full , did not save'","b'LocalStorage vol is, niet te redden'"
-b'DocType: Lead',b'Address & Contact',b'Adres &amp; Contact'
-b'DocType: Leave Allocation',b'Add unused leaves from previous allocations',b'Voeg ongebruikte bladeren van de vorige toewijzingen'
-b'DocType: Sales Partner',b'Partner website',b'partner website'
-b'DocType: Restaurant Order Entry',b'Add Item',b'Item toevoegen'
-b'DocType: Lab Test',b'Custom Result',b'Aangepast resultaat'
-b'DocType: Delivery Stop',b'Contact Name',b'Contact Naam'
-b'DocType: Course Assessment Criteria',b'Course Assessment Criteria',b'Cursus Beoordelingscriteria'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18',b'Tax Id: ',b'BTW-nummer:'
-b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216',b'Student ID: ',b'Student-ID:'
-b'DocType: POS Customer Group',b'POS Customer Group',b'POS Customer Group'
-b'DocType: Land Unit',b'Land Unit describing various land assets',b'Landeenheid beschrijft verschillende terreinen'
-b'DocType: Cheque Print Template',b'Line spacing for amount in words',b'Regelafstand voor het bedrag in woorden'
-b'DocType: Vehicle',b'Additional Details',b'Overige gegevens'
-b'apps/erpnext/erpnext/templates/generators/bom.html +85',b'No description given',b'Geen beschrijving gegeven'
-b'apps/erpnext/erpnext/config/buying.py +13',b'Request for purchase.',b'Inkoopaanvraag'
-b'DocType: Lab Test',b'Submitted Date',b'Datum indienen'
-b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6',b'This is based on the Time Sheets created against this project',b'Dit is gebaseerd op de Time Sheets gemaakt tegen dit project'
-,b'Open Work Orders',b'Open werkorders'
-b'DocType: Payment Term',b'Credit Months',b'Kredietmaanden'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409',b'Net Pay cannot be less than 0',b'Nettoloon kan niet lager zijn dan 0'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',"b'To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription'","b'Om te stoppen met het verzenden van herhaalde foutmeldingen van het systeem, hebben we het veld Uitgeschakeld in het abonnement gecontroleerd'"
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +121',b'Relieving Date must be greater than Date of Joining',b'Ontslagdatum moet groter zijn dan datum van indiensttreding'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240',b'Leaves per Year',b'Verlaat per jaar'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130',"b""Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.""","b""Rij {0}: Kijk 'Is Advance' tegen Account {1} als dit is een voorschot binnenkomst."""
-b'apps/erpnext/erpnext/stock/utils.py +219',b'Warehouse {0} does not belong to company {1}',b'Magazijn {0} behoort niet tot bedrijf {1}'
-b'DocType: Email Digest',b'Profit & Loss',b'Verlies'
-b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Litre',b'liter'
-b'DocType: Task',b'Total Costing Amount (via Time Sheet)',b'Totaal bedrag Costing (via Urenregistratie)'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76',b'Please setup Students under Student Groups',b'Stel de studenten onder Student Groups in'
-b'DocType: Item Website Specification',b'Item Website Specification',b'Artikel Website Specificatie'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449',b'Leave Blocked',b'Verlof Geblokkeerd'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +740',b'Item {0} has reached its end of life on {1}',b'Artikel {0} heeft het einde van zijn levensduur bereikt op {1}'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83',b'Bank Entries',b'Bank Gegevens'
-b'DocType: Crop',b'Annual',b'jaar-'
-b'DocType: Stock Reconciliation Item',b'Stock Reconciliation Item',b'Voorraad Afletteren Artikel'
-b'DocType: Stock Entry',b'Sales Invoice No',b'Verkoopfactuur nr.'
-b'DocType: Material Request Item',b'Min Order Qty',b'Minimum Aantal'
-b'DocType: Student Group Creation Tool Course',b'Student Group Creation Tool Course',b'Student Group Creation Tool Course'
-b'DocType: Lead',b'Do Not Contact',b'Neem geen contact op'
-b'apps/erpnext/erpnext/utilities/user_progress.py +210',b'People who teach at your organisation',b'Mensen die lesgeven op uw organisatie'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135',b'Software Developer',b'Software Ontwikkelaar'
-b'DocType: Item',b'Minimum Order Qty',b'Minimum bestel aantal'
-b'DocType: Pricing Rule',b'Supplier Type',b'Leverancier Type'
-b'DocType: Course Scheduling Tool',b'Course Start Date',b'Cursus Startdatum'
-,b'Student Batch-Wise Attendance',b'Student Batch-Wise Attendance'
-b'DocType: POS Profile',b'Allow user to edit Rate',b'Zodat de gebruiker te bewerken Rate'
-b'DocType: Item',b'Publish in Hub',b'Publiceren in Hub'
-b'DocType: Student Admission',b'Student Admission',b'student Toelating'
-,b'Terretory',b'Regio'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +762',b'Item {0} is cancelled',b'Artikel {0} is geannuleerd'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064',b'Material Request',b'Materiaal Aanvraag'
-b'DocType: Bank Reconciliation',b'Update Clearance Date',b'Werk Clearance Datum bij'
-,b'GSTR-2',b'GSTR-2'
-b'DocType: Item',b'Purchase Details',b'Inkoop Details'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407',"b""Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}""",b'Item {0} niet gevonden in &#39;Raw Materials geleverd&#39; tafel in Purchase Order {1}'
-b'DocType: Salary Slip',b'Total Principal Amount',b'Totaal hoofdbedrag'
-b'DocType: Student Guardian',b'Relation',b'Relatie'
-b'DocType: Student Guardian',b'Mother',b'Moeder'
-b'DocType: Restaurant Reservation',b'Reservation End Time',b'Eindtijd van reservering'
-b'DocType: Crop',b'Biennial',b'tweejarig'
-b'apps/erpnext/erpnext/config/selling.py +18',b'Confirmed orders from Customers.',b'Bevestigde orders van klanten.'
-b'DocType: Purchase Receipt Item',b'Rejected Quantity',b'Afgewezen Aantal'
-b'apps/erpnext/erpnext/education/doctype/fees/fees.py +80',b'Payment request {0} created',b'Betalingsverzoek {0} gemaakt'
-b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Open Orders',b'Openstaande bestellingen'
-b'apps/erpnext/erpnext/healthcare/setup.py +255',b'Low Sensitivity',b'Lage gevoeligheid'
-b'DocType: Notification Control',b'Notification Control',b'Notificatie Beheer'
-b'apps/erpnext/erpnext/templates/emails/training_event.html +17',b'Please confirm once you have completed your training',b'Bevestig alstublieft nadat u uw opleiding hebt voltooid'
-b'DocType: Lead',b'Suggestions',b'Suggesties'
-b'DocType: Territory',b'Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.',b'Set Item Group-wise budgetten op dit gebied. U kunt ook seizoensinvloeden door de Distribution.'
-b'DocType: Payment Term',b'Payment Term Name',b'Betalingstermijn'
-b'DocType: Healthcare Settings',b'Create documents for sample collection',b'Maak documenten voor het verzamelen van samples'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276',b'Payment against {0} {1} cannot be greater than Outstanding Amount {2}',b'Betaling tegen {0} {1} kan niet groter zijn dan openstaande bedrag te zijn {2}'
-b'DocType: Shareholder',b'Address HTML',b'Adres HTML'
-b'DocType: Lead',b'Mobile No.',b'Mobiel nummer'
-b'DocType: Maintenance Schedule',b'Generate Schedule',b'Genereer Plan'
-b'DocType: Purchase Invoice Item',b'Expense Head',b'Kosten Hoofd'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138',b'Please select Charge Type first',b'Selecteer eerst een Charge Type'
-b'DocType: Crop',"b'You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. '","b'U kunt hier alle taken defini\xc3\xabren die voor dit gewas moeten worden uitgevoerd. Het dagveld wordt gebruikt om de dag te vermelden waarop de taak moet worden uitgevoerd, waarbij 1 de eerste dag is, enzovoort.'"
-b'DocType: Student Group Student',b'Student Group Student',b'Student Group Student'
-b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Latest',b'laatst'
-b'DocType: Asset Maintenance Task',b'2 Yearly',b'2 Jaarlijks'
-b'DocType: Education Settings',b'Education Settings',b'Onderwijsinstellingen'
-b'DocType: Vehicle Service',b'Inspection',b'Inspectie'
-b'DocType: Supplier Scorecard Scoring Standing',b'Max Grade',b'Max Grade'
-b'DocType: Email Digest',b'New Quotations',b'Nieuwe Offertes'
-b'DocType: HR Settings',b'Emails salary slip to employee based on preferred email selected in Employee',b'Emails loonstrook van medewerkers op basis van de voorkeur e-mail geselecteerd in Employee'
-b'DocType: Employee',b'The first Leave Approver in the list will be set as the default Leave Approver',b'De eerste Verlofgoedkeurder in de lijst wordt als de standaard Verlofgoedkeurder ingesteld'
-b'DocType: Tax Rule',b'Shipping County',b'verzending County'
-b'apps/erpnext/erpnext/config/desktop.py +167',b'Learn',b'Leren'
-b'DocType: Asset',b'Next Depreciation Date',b'Volgende Afschrijvingen Date'
-b'apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3',b'Activity Cost per Employee',b'Activiteitskosten per werknemer'
-b'DocType: Accounts Settings',b'Settings for Accounts',b'Instellingen voor accounts'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673',b'Supplier Invoice No exists in Purchase Invoice {0}',b'Leverancier factuur nr bestaat in Purchase Invoice {0}'
-b'apps/erpnext/erpnext/config/selling.py +118',b'Manage Sales Person Tree.',b'Beheer Sales Person Boom .'
-b'DocType: Job Applicant',b'Cover Letter',b'Voorblad'
-b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37',b'Outstanding Cheques and Deposits to clear',b'Uitstekende Cheques en Deposito&#39;s te ontruimen'
-b'DocType: Item',b'Synced With Hub',b'Gesynchroniseerd met Hub'
-b'DocType: Driver',b'Fleet Manager',b'Fleet Manager'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542',b'Row #{0}: {1} can not be negative for item {2}',b'Row # {0}: {1} kan niet negatief voor producten van post {2}'
-b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59',b'Wrong Password',b'Verkeerd Wachtwoord'
-b'DocType: Item',b'Variant Of',b'Variant van'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406',"b""Completed Qty can not be greater than 'Qty to Manufacture'""","b""Voltooid aantal mag niet groter zijn dan 'Aantal te produceren'"""
-b'DocType: Period Closing Voucher',b'Closing Account Head',b'Sluiten Account Hoofd'
-b'DocType: Employee',b'External Work History',b'Externe Werk Geschiedenis'
-b'apps/erpnext/erpnext/projects/doctype/task/task.py +111',b'Circular Reference Error',b'Kringverwijzing Error'
-b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206',b'Student Report Card',b'Studentenrapportkaart'
-b'DocType: Appointment Type',b'Is Inpatient',b'Is een pati\xc3\xabnt'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55',b'Guardian1 Name',b'Guardian1 Naam'
-b'DocType: Delivery Note',b'In Words (Export) will be visible once you save the Delivery Note.',b'In woorden (Export) wordt zichtbaar zodra u de vrachtbrief opslaat.'
-b'DocType: Cheque Print Template',b'Distance from left edge',b'Afstand van linkerrand'
-b'apps/erpnext/erpnext/utilities/bot.py +29',b'{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2})',b'{0} eenheden van [{1}] (#Vorm/Item/{1}) gevonden in [{2}](#Vorm/Magazijn/{2})'
-b'DocType: Lead',b'Industry',b'Industrie'
-b'DocType: Employee',b'Job Profile',b'Functieprofiel'
-b'DocType: BOM Item',b'Rate & Amount',b'Tarief en Bedrag'
-b'apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6',b'This is based on transactions against this Company. See timeline below for details',b'Dit is gebaseerd op transacties tegen dit bedrijf. Zie de tijdlijn hieronder voor details'
-b'DocType: Stock Settings',b'Notify by Email on creation of automatic Material Request',b'Notificeer per e-mail bij automatisch aanmaken van Materiaal Aanvraag'
-b'apps/erpnext/erpnext/healthcare/setup.py +259',b'Resistant',b'Resistant'
-b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77',b'Please set Hotel Room Rate on {}',b'Stel de hotelkamerprijs in op {}'
-b'DocType: Journal Entry',b'Multi Currency',b'Valuta'
-b'DocType: Opening Invoice Creation Tool',b'Invoice Type',b'Factuur Type'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939',b'Delivery Note',b'Vrachtbrief'
-b'DocType: Consultation',b'Encounter Impression',b'Encounter Impression'
-b'apps/erpnext/erpnext/config/learn.py +82',b'Setting up Taxes',b'Het opzetten van Belastingen'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134',b'Cost of Sold Asset',b'Kosten van Verkochte Asset'
-b'DocType: Volunteer',b'Morning',b'Ochtend'
-b'apps/erpnext/erpnext/accounts/utils.py +350',b'Payment Entry has been modified after you pulled it. Please pull it again.',b'Betaling Bericht is gewijzigd nadat u het getrokken. Neem dan trekt het weer.'
-b'DocType: Program Enrollment Tool',b'New Student Batch',b'Nieuwe studentenbatch'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +479',b'{0} entered twice in Item Tax',b'{0} twee keer opgenomen in Artikel BTW'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113',b'Summary for this week and pending activities',b'Samenvatting voor deze week en in afwachting van activiteiten'
-b'DocType: Student Applicant',b'Admitted',b'toegelaten'
-b'DocType: Workstation',b'Rent Cost',b'Huurkosten'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81',b'Amount After Depreciation',b'Bedrag na afschrijvingen'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97',b'Upcoming Calendar Events',b'Aankomende Gebeurtenissen'
-b'apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1',b'Variant Attributes',b'Variant Attributen'
-b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85',b'Please select month and year',b'Selecteer maand en jaar'
-b'DocType: Employee',b'Company Email',b'Bedrijf e-mail'
-b'DocType: GL Entry',b'Debit Amount in Account Currency',b'Debet Bedrag in account Valuta'
-b'DocType: Supplier Scorecard',b'Scoring Standings',b'Scoring Standings'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Bestellingswaarde'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Bestellingswaarde'
-b'apps/erpnext/erpnext/config/accounts.py +27',b'Bank/Cash transactions against party or for internal transfer',b'Bank / Cash-transacties tegen de partij of voor interne overplaatsing'
-b'DocType: Shipping Rule',b'Valid for Countries',b'Geldig voor Landen'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +55',"b""This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set""","b""Dit artikel is een sjabloon en kunnen niet worden gebruikt bij transacties. Item attributen zal worden gekopieerd naar de varianten tenzij 'No Copy' is ingesteld"""
-b'DocType: Grant Application',b'Grant Application',b'Subsidieaanvraag'
-b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69',b'Total Order Considered',b'Totaal Bestel Beschouwd'
-b'apps/erpnext/erpnext/config/hr.py +243',"b'Employee designation (e.g. CEO, Director etc.).'","b'Werknemer aanduiding ( bijv. CEO , directeur enz. ) .'"
-b'DocType: Sales Invoice',"b""Rate at which Customer Currency is converted to customer's base currency""",b'Koers waarmee de Klant Valuta wordt omgerekend naar de basisvaluta van de klant.'
-b'DocType: Course Scheduling Tool',b'Course Scheduling Tool',b'Course Scheduling Tool'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +623',b'Row #{0}: Purchase Invoice cannot be made against an existing asset {1}',b'Rij # {0}: Aankoop factuur kan niet worden ingediend tegen een bestaand actief {1}'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257',b'[Urgent] Error while creating recurring %s for %s',b'[Urgent] Fout bij het maken van terugkerende% s voor% s'
-b'DocType: Land Unit',b'LInked Analysis',b'Ge\xc3\xafntegreerde analyse'
-b'DocType: Item Tax',b'Tax Rate',b'Belastingtarief'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73',b'Application period cannot be across two allocation records',b'De toepassingsperiode kan niet over twee toewijzingsrecords lopen'
-b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59',b'{0} already allocated for Employee {1} for period {2} to {3}',b'{0} reeds toegewezen voor Employee {1} voor periode {2} te {3}'
-b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141',b'Purchase Invoice {0} is already submitted',b'Inkoopfactuur {0} is al ingediend'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92',b'Row # {0}: Batch No must be same as {1} {2}',b'Rij # {0}: Batch Geen moet hetzelfde zijn als zijn {1} {2}'
-b'DocType: Material Request Plan Item',b'Material Request Plan Item',b'Artikel plan voor artikelaanvraag'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52',b'Convert to non-Group',b'Converteren naar non-Group'
-b'DocType: Project Update',b'Good/Steady',b'Goed / Steady'
-b'DocType: C-Form Invoice Detail',b'Invoice Date',b'Factuurdatum'
-b'DocType: GL Entry',b'Debit Amount',b'Debet Bedrag'
-b'apps/erpnext/erpnext/accounts/party.py +248',b'There can only be 1 Account per Company in {0} {1}',b'Er kan slechts 1 account per Bedrijf in zijn {0} {1}'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426',b'Please see attachment',b'Zie bijlage'
-b'DocType: Purchase Order',b'% Received',b'% Ontvangen'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3',b'Create Student Groups',b'Maak Student Groepen'
-b'DocType: Volunteer',b'Weekends',b'weekends'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Credit Note Amount',b'Credit Note Bedrag'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187',b'{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3}',b'{0} ({1}) kan niet groter zijn dan de geplande quanitity ({2}) in werkorder {3}'
-b'DocType: Setup Progress Action',b'Action Document',b'Actie Document'
-b'DocType: Chapter Member',b'Website URL',b'Website URL'
-,b'Finished Goods',b'Gereed Product'
-b'DocType: Delivery Note',b'Instructions',b'Instructies'
-b'DocType: Quality Inspection',b'Inspected By',b'Ge\xc3\xafnspecteerd door'
-b'DocType: Asset Maintenance Log',b'Maintenance Type',b'Onderhoud Type'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45',b'{0} - {1} is not enrolled in the Course {2}',b'{0} - {1} is niet ingeschreven in de cursus {2}'
-b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225',b'Student Name: ',b'Studenten naam:'
-b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59',b'Serial No {0} does not belong to Delivery Note {1}',b'Serienummer {0} behoort niet tot Vrachtbrief {1}'
-b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97',"b""There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.""","b'Er lijkt een probleem te zijn met de GoCardless-configuratie van de server. Maakt u zich geen zorgen, in het geval van een fout, wordt het bedrag teruggestort op uw account.'"
-b'apps/erpnext/erpnext/templates/pages/demo.html +47',b'ERPNext Demo',b'ERPNext Demo'
-b'apps/erpnext/erpnext/public/js/utils/item_selector.js +20',b'Add Items',b'Items toevoegen'
-b'DocType: Item Quality Inspection Parameter',b'Item Quality Inspection Parameter',b'Artikel Kwaliteitsinspectie Parameter'
-b'DocType: Depreciation Schedule',b'Schedule Date',b'Plan datum'
-b'apps/erpnext/erpnext/config/hr.py +116',"b'Earnings, Deductions and other Salary components'","b'De winst, aftrekposten en andere looncomponenten'"
-b'DocType: Packed Item',b'Packed Item',b'Levering Opmerking Verpakking Item'
-b'DocType: Job Offer Term',b'Job Offer Term',b'Biedingsperiode'
-b'apps/erpnext/erpnext/config/buying.py +65',b'Default settings for buying transactions.',b'Standaardinstellingen voor Inkooptransacties .'
-b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29',b'Activity Cost exists for Employee {0} against Activity Type - {1}',b'Activiteit Kosten bestaat voor Employee {0} tegen Activity Type - {1}'
-b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Verplicht veld - Ontvang studenten van'
-b'DocType: Program Enrollment',b'Enrolled courses',b'Ingeschreven cursussen'
-b'DocType: Currency Exchange',b'Currency Exchange',b'Wisselkoersen'
-b'DocType: Opening Invoice Creation Tool Item',b'Item Name',b'Artikelnaam'
-b'DocType: Authorization Rule',b'Approving User  (above authorized value)',b'Goedkeuren gebruiker (boven de toegestane waarde)'
-b'DocType: Email Digest',b'Credit Balance',b'Batig saldo'
-b'DocType: Employee',b'Widowed',b'Weduwe'
-b'DocType: Request for Quotation',b'Request for Quotation',b'Offerte'
-b'DocType: Healthcare Settings',b'Require Lab Test Approval',b'Vereist laboratoriumtest goedkeuring'
-b'DocType: Salary Slip Timesheet',b'Working Hours',b'Werkuren'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59',b'Total Outstanding',b'Totaal uitstekend'
-b'DocType: Naming Series',b'Change the starting / current sequence number of an existing series.',b'Wijzig het start-/ huidige volgnummer van een bestaande serie.'
-b'DocType: Dosage Strength',b'Strength',b'Kracht'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1534',b'Create a new Customer',b'Maak een nieuwe klant'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59',"b'If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.'","b'Als er meerdere prijzen Regels blijven die gelden, worden gebruikers gevraagd om Prioriteit handmatig instellen om conflicten op te lossen.'"
-b'apps/erpnext/erpnext/utilities/activation.py +90',b'Create Purchase Orders',b'Maak Bestellingen'
-,b'Purchase Register',b'Inkoop Register'
-b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116',b'Patient not found',b'Pati\xc3\xabnt niet gevonden'
-b'DocType: Scheduling Tool',b'Rechedule',b'Rechedule'
-b'DocType: Landed Cost Item',b'Applicable Charges',b'Toepasselijke kosten'
-b'DocType: Workstation',b'Consumable Cost',b'Verbruiksartikel kostprijs'
-b'DocType: Purchase Receipt',b'Vehicle Date',b'Voertuiggegegevns'
-b'DocType: Student Log',b'Medical',b'medisch'
-b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175',b'Reason for losing',b'Reden voor het verliezen'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.js +52',b'Update Account Number',b'Accountnummer bijwerken'
-b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +44',b'Lead Owner cannot be same as the Lead',b'Lead eigenaar kan niet hetzelfde zijn als de lead zijn'
-b'apps/erpnext/erpnext/accounts/utils.py +356',b'Allocated amount can not greater than unadjusted amount',b'Toegekende bedrag kan niet hoger zijn dan niet-gecorrigeerde bedrag'
-b'DocType: Announcement',b'Receiver',b'Ontvanger'
-b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83',b'Workstation is closed on the following dates as per Holiday List: {0}',b'Werkstation is gesloten op de volgende data als per Holiday Lijst: {0}'
-b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32',b'Opportunities',b'Kansen'
-b'DocType: Lab Test Template',b'Single',b'Enkele'
-b'DocType: Salary Slip',b'Total Loan Repayment',b'Totaal aflossing van de lening'
-b'DocType: Account',b'Cost of Goods Sold',b'Kostprijs verkochte goederen'
-b'DocType: Subscription',b'Yearly',b'Jaarlijks'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230',b'Please enter Cost Center',b'Vul kostenplaats in'
-b'DocType: Drug Prescription',b'Dosage',b'Dosering'
-b'DocType: Journal Entry Account',b'Sales Order',b'Verkooporder'
-b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69',b'Avg. Selling Rate',b'Gem. Verkoopkoers'
-b'DocType: Assessment Plan',b'Examiner Name',b'Examinator Naam'
-b'DocType: Lab Test Template',b'No Result',b'Geen resultaat'
-b'DocType: Purchase Invoice Item',b'Quantity and Rate',b'Hoeveelheid en Tarief'
-b'DocType: Delivery Note',b'% Installed',b'% Ge\xc3\xafnstalleerd'
-b'apps/erpnext/erpnext/utilities/user_progress.py +230',b'Classrooms/ Laboratories etc where lectures can be scheduled.',"b'Klaslokalen / Laboratories etc, waar lezingen kunnen worden gepland.'"
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46',b'Please enter company name first',b'Vul aub eerst de naam van het bedrijf in'
-b'DocType: Purchase Invoice',b'Supplier Name',b'Leverancier Naam'
-b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25',b'Read the ERPNext Manual',b'Lees de ERPNext Manual'
-b'DocType: Purchase Invoice',b'01-Sales Return',b'01-verkoopretour'
-b'DocType: Account',b'Is Group',b'Is Group'
-b'DocType: Email Digest',b'Pending Purchase Orders',b'In afwachting van Bestellingen'
-b'DocType: Stock Settings',b'Automatically Set Serial Nos based on FIFO',b'Automatisch instellen serienummers op basis van FIFO'
-b'DocType: Accounts Settings',b'Check Supplier Invoice Number Uniqueness',b'Controleer Leverancier Factuurnummer Uniqueness'
-b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34',b'Primary Address Details',b'Primaire adresgegevens'
-b'DocType: Vehicle Service',b'Oil Change',b'Olie vervanging'
-b'DocType: Asset Maintenance Log',b'Asset Maintenance Log',b'Asset-onderhoudslogboek'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57',"b""'To Case No.' cannot be less than 'From Case No.'""","b""'Tot Zaak nr' kan niet minder zijn dan 'Van Zaak nr'"""
-b'DocType: Chapter',b'Non Profit',b'Non-Profit'
-b'DocType: Production Plan',b'Not Started',b'Niet gestart'
-b'DocType: Lead',b'Channel Partner',b'Channel Partner'
-b'DocType: Account',b'Old Parent',b'Oude Parent'
-b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Verplicht veld - Academiejaar'
-b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Verplicht veld - Academiejaar'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220',b'{0} {1} is not associated with {2} {3}',b'{0} {1} is niet gekoppeld aan {2} {3}'
-b'DocType: Notification Control',b'Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.',b'Pas de inleidende tekst aan die meegaat als een deel van die e-mail. Elke transactie heeft een aparte inleidende tekst.'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176',b'Please set default payable account for the company {0}',b'Stel alsjeblieft de standaard betaalbare rekening voor het bedrijf in {0}'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +511',b'Transaction not allowed against stopped Work Order {0}',b'Transactie niet toegestaan tegen gestopte werkorder {0}'
-b'DocType: Setup Progress Action',b'Min Doc Count',b'Min Doc Count'
-b'apps/erpnext/erpnext/config/manufacturing.py +84',b'Global settings for all manufacturing processes.',b'Algemene instellingen voor alle productieprocessen.'
-b'DocType: Accounts Settings',b'Accounts Frozen Upto',b'Rekeningen bevroren tot'
-b'DocType: SMS Log',b'Sent On',b'Verzonden op'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +700',b'Attribute {0} selected multiple times in Attributes Table',b'Kenmerk {0} meerdere keren geselecteerd in Attributes Tabel'
-b'DocType: HR Settings',b'Employee record is created using selected field. ',b'Werknemer regel wordt gemaakt met behulp van geselecteerd veld.'
-b'DocType: Sales Order',b'Not Applicable',b'Niet van toepassing'
-b'apps/erpnext/erpnext/config/hr.py +70',b'Holiday master.',b'Vakantie meester .'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85',b'Opening Invoice Item',b'Factuuritem openen'
-b'DocType: Request for Quotation Item',b'Required Date',b'Benodigd op datum'
-b'DocType: Delivery Note',b'Billing Address',b'Factuuradres'
-b'DocType: BOM',b'Costing',b'Costing'
-b'DocType: Tax Rule',b'Billing County',b'Billing County'
-b'DocType: Purchase Taxes and Charges',"b'If checked, the tax amount will be considered as already included in the Print Rate / Print Amount'","b'Indien aangevinkt, zal de BTW-bedrag worden beschouwd als reeds in de Print Tarief / Print Bedrag'"
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceRef',b'PieceRef'
-b'DocType: Request for Quotation',b'Message for Supplier',b'Boodschap voor Supplier'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40',b'Work Order',b'Werkorder'
-b'DocType: Driver',b'DRIVER-.#####',b'BESTUURDER-.#####'
-b'DocType: Sales Invoice',b'Total Qty',b'Totaal Aantal'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 Email ID'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 Email ID'
-b'DocType: Item',b'Show in Website (Variant)',b'Show in Website (Variant)'
-b'DocType: Employee',b'Health Concerns',b'Gezondheidszorgen'
-b'DocType: Payroll Entry',b'Select Payroll Period',b'Selecteer Payroll Periode'
-b'DocType: Purchase Invoice',b'Unpaid',b'Onbetaald'
-b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49',b'Reserved for sale',b'Gereserveerd voor verkoop'
-b'DocType: Packing Slip',b'From Package No.',b'Van Pakket No'
-b'DocType: Item Attribute',b'To Range',b'Om Bereik'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29',b'Securities and Deposits',"b""Effecten en Deposito's"""
-b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46',"b""Can't change valuation method, as there are transactions against some items which does not have it's own valuation method""","b'Kan de waarderingsmethode niet wijzigen, aangezien er transacties zijn tegen sommige items die geen eigen waarderingsmethode hebben'"
-b'DocType: Student Report Generation Tool',b'Attended by Parents',b'Bijgewoond door ouders'
-b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82',b'Total leaves allocated is mandatory',b'Totaal bladeren toegewezen is verplicht'
-b'DocType: Patient',b'AB Positive',b'AB Positief'
-b'DocType: Job Opening',b'Description of a Job Opening',b'Omschrijving van een Vacature'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110',b'Pending activities for today',b'Afwachting van activiteiten voor vandaag'
-b'apps/erpnext/erpnext/config/hr.py +24',b'Attendance record.',b'Aanwezigheid record.'
-b'DocType: Salary Structure',b'Salary Component for timesheet based payroll.',b'Salaris Component voor rooster gebaseerde payroll.'
-b'DocType: Sales Order Item',b'Used for Production Plan',b'Gebruikt voor Productie Plan'
-b'DocType: Employee Loan',b'Total Payment',b'Totale betaling'
-b'DocType: Manufacturing Settings',b'Time Between Operations (in mins)',b'Time Between Operations (in minuten)'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132',b'{0} {1} is cancelled so the action cannot be completed',b'{0} {1} is geannuleerd dus de actie kan niet voltooid worden'
-b'DocType: Customer',b'Buyer of Goods and Services.',b'Koper van goederen en diensten.'
-b'DocType: Journal Entry',b'Accounts Payable',b'Crediteuren'
-b'DocType: Patient',b'Allergies',b'allergie\xc3\xabn'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33',b'The selected BOMs are not for the same item',b'De geselecteerde stuklijsten zijn niet voor hetzelfde item'
-b'DocType: Supplier Scorecard Standing',b'Notify Other',b'Meld andere aan'
-b'DocType: Vital Signs',b'Blood Pressure (systolic)',b'Bloeddruk (systolisch)'
-b'DocType: Pricing Rule',b'Valid Upto',b'Geldig Tot'
-b'DocType: Training Event',b'Workshop',b'werkplaats'
-b'DocType: Supplier Scorecard Scoring Standing',b'Warn Purchase Orders',b'Waarschuwing Aankooporders'
-b'apps/erpnext/erpnext/utilities/user_progress.py +67',b'List a few of your customers. They could be organizations or individuals.',b'Lijst een paar van uw klanten. Ze kunnen organisaties of personen .'
-b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23',b'Enough Parts to Build',b'Genoeg Parts te bouwen'
-b'DocType: POS Profile User',b'POS Profile User',b'POS-profielgebruiker'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128',b'Direct Income',b'Directe Inkomsten'
-b'DocType: Patient Appointment',b'Date TIme',b'Datum Tijd'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45',"b'Can not filter based on Account, if grouped by Account'","b'Kan niet filteren op basis van Rekening, indien gegroepeerd op Rekening'"
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130',b'Administrative Officer',b'Boekhouder'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39',b'Setting up company and taxes',b'Opzetten van bedrijf en belastingen'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Selecteer de cursus'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Selecteer de cursus'
-b'DocType: Codification Table',b'Codification Table',b'Codificatie Tabel'
-b'DocType: Timesheet Detail',b'Hrs',b'hrs'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349',b'Please select Company',b'Selecteer Company'
-b'DocType: Stock Entry Detail',b'Difference Account',b'Verschillenrekening'
-b'DocType: Purchase Invoice',b'Supplier GSTIN',b'Leverancier GSTIN'
-b'apps/erpnext/erpnext/projects/doctype/task/task.py +47',b'Cannot close task as its dependant task {0} is not closed.',b'Kan taak niet afsluiten als haar afhankelijke taak {0} niet is afgesloten.'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435',b'Please enter Warehouse for which Material Request will be raised',b'Vul magazijn in waarvoor Materiaal Aanvragen zullen worden ingediend.'
-b'DocType: Work Order',b'Additional Operating Cost',b'Additionele Operationele Kosten'
-b'DocType: Lab Test Template',b'Lab Routine',b'Lab Routine'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20',b'Cosmetics',b'Cosmetica'
-b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18',b'Please select Completion Date for Completed Asset Maintenance Log',b'Selecteer de voltooiingsdatum voor het uitgevoerde onderhoudslogboek'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +552',"b'To merge, following properties must be same for both items'","b'Om samen te voegen, moeten de volgende eigenschappen hetzelfde zijn voor beide artikelen'"
-b'DocType: Shipping Rule',b'Net Weight',b'Netto Gewicht'
-b'DocType: Employee',b'Emergency Phone',b'Noodgeval Telefoonnummer'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82',b'{0} {1} does not exist.',b'{0} {1} bestaat niet.'
-b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29',b'Buy',b'Kopen'
-,b'Serial No Warranty Expiry',b'Serienummer Garantie Afloop'
-b'DocType: Sales Invoice',b'Offline POS Name',b'Offline POS Naam'
-b'apps/erpnext/erpnext/utilities/user_progress.py +180',b'Student Application',b'Studentenaanvraag'
-b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Gelieve te defini\xc3\xabren cijfer voor drempel 0%'
-b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Gelieve te defini\xc3\xabren cijfer voor drempel 0%'
-b'DocType: Sales Order',b'To Deliver',b'Bezorgen'
-b'DocType: Purchase Invoice Item',b'Item',b'Artikel'
-b'apps/erpnext/erpnext/healthcare/setup.py +256',b'High Sensitivity',b'Hoge gevoeligheid'
-b'apps/erpnext/erpnext/config/non_profit.py +48',b'Volunteer Type information.',b'Type vrijwilliger informatie.'
-b'DocType: Cash Flow Mapping Template',b'Cash Flow Mapping Template',b'Cash Flow Mapping Template'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2555',b'Serial no item cannot be a fraction',b'Serial geen item kan niet een fractie te zijn'
-b'DocType: Journal Entry',b'Difference (Dr - Cr)',b'Verschil (Db - Cr)'
-b'DocType: Account',b'Profit and Loss',b'Winst en Verlies'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104',"b'Not permitted, configure Lab Test Template as required'","b'Niet toegestaan, configureer Lab-testsjabloon zoals vereist'"
-b'DocType: Patient',b'Risk Factors',b'Risicofactoren'
-b'DocType: Patient',b'Occupational Hazards and Environmental Factors',b'Beroepsgevaren en milieufactoren'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239',b'Stock Entries already created for Work Order ',b'Voorraadinvoer al gemaakt voor werkorder'
-b'DocType: Vital Signs',b'Respiratory rate',b'Ademhalingsfrequentie'
-b'apps/erpnext/erpnext/config/stock.py +334',b'Managing Subcontracting',b'Managing Subcontracting'
-b'DocType: Vital Signs',b'Body Temperature',b'Lichaamstemperatuur'
-b'DocType: Project',b'Project will be accessible on the website to these users',b'Project zal toegankelijk op de website van deze gebruikers'
-b'DocType: Detected Disease',b'Disease',b'Ziekte'
-b'apps/erpnext/erpnext/config/projects.py +29',b'Define Project type.',b'Definieer projecttype.'
-b'DocType: Supplier Scorecard',b'Weighting Function',b'Gewicht Functie'
-b'DocType: Physician',b'OP Consulting Charge',b'OP Consulting Charge'
-b'apps/erpnext/erpnext/utilities/user_progress.py +28',b'Setup your ',b'Setup uw'
-b'DocType: Student Report Generation Tool',b'Show Marks',b'Markeringen tonen'
-b'DocType: Quotation',"b""Rate at which Price list currency is converted to company's base currency""",b'Koers waarmee Prijslijst valuta wordt omgerekend naar de basis bedrijfsvaluta'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +70',b'Account {0} does not belong to company: {1}',b'Rekening {0} behoort niet tot bedrijf: {1}'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +52',b'Abbreviation already used for another company',b'Afkorting al gebruikt voor een ander bedrijf'
-b'DocType: Selling Settings',b'Default Customer Group',b'Standaard Klant Groep'
-b'DocType: Asset Repair',b'ARLOG-',b'ARLOG-'
-b'DocType: Global Defaults',"b""If disable, 'Rounded Total' field will not be visible in any transaction""","b""Indien uitgevinkt, zal het 'Afgerond Totaal' veld niet zichtbaar zijn in een transactie"""
-b'DocType: BOM',b'Operating Cost',b'Operationele kosten'
-b'DocType: Crop',b'Produced Items',b'Geproduceerde items'
-b'DocType: Sales Order Item',b'Gross Profit',b'Bruto Winst'
-b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49',b'Increment cannot be 0',b'Toename kan niet worden 0'
-b'DocType: Company',b'Delete Company Transactions',b'Verwijder Company Transactions'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364',b'Reference No and Reference Date is mandatory for Bank transaction',b'Referentienummer en Reference Data is verplicht voor Bank transactie'
-b'DocType: Purchase Receipt',b'Add / Edit Taxes and Charges',b'Toevoegen / Bewerken Belastingen en Heffingen'
-b'DocType: Payment Entry Reference',b'Supplier Invoice No',b'Factuurnr. Leverancier'
-b'DocType: Territory',b'For reference',b'Ter referentie'
-b'DocType: Healthcare Settings',b'Appointment Confirmation',b'Afspraak bevestiging'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158',"b'Cannot delete Serial No {0}, as it is used in stock transactions'","b'Kan Serienummer {0} niet verwijderen, omdat het wordt gebruikt in voorraadtransacties'"
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256',b'Closing (Cr)',b'Sluiten (Cr)'
-b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1',b'Hello',b'Hallo'
-b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118',b'Move Item',b'Item verplaatsen'
-b'DocType: Serial No',b'Warranty Period (Days)',b'Garantieperiode (dagen)'
-b'DocType: Installation Note Item',b'Installation Note Item',b'Installatie Opmerking Item'
-b'DocType: Production Plan Item',b'Pending Qty',b'In afwachting Aantal'
-b'DocType: Budget',b'Ignore',b'Negeren'
-b'apps/erpnext/erpnext/accounts/party.py +396',b'{0} {1} is not active',b'{0} {1} is niet actief'
-b'apps/erpnext/erpnext/config/accounts.py +272',b'Setup cheque dimensions for printing',b'Setup check afmetingen voor afdrukken'
-b'DocType: Salary Slip',b'Salary Slip Timesheet',b'Loonstrook Timesheet'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +160',b'Supplier Warehouse mandatory for sub-contracted Purchase Receipt',b'Leverancier Magazijn verplicht voor uitbesteedde Ontvangstbewijs'
-b'DocType: Pricing Rule',b'Valid From',b'Geldig van'
-b'DocType: Sales Invoice',b'Total Commission',b'Totaal Commissie'
-b'DocType: Pricing Rule',b'Sales Partner',b'Verkoop Partner'
-b'apps/erpnext/erpnext/config/buying.py +150',b'All Supplier scorecards.',b'Alle leveranciers scorecards.'
-b'DocType: Buying Settings',b'Purchase Receipt Required',b'Ontvangstbevestiging Verplicht'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188',b'Target warehouse in row {0} must be same as Work Order',b'Targetmagazijn in rij {0} moet hetzelfde zijn als werkorder'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +155',b'Valuation Rate is mandatory if Opening Stock entered',b'Valuation Rate is verplicht als Opening Stock ingevoerd'
-b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143',b'No records found in the Invoice table',b'Geen records gevonden in de factuur tabel'
-b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34',b'Please select Company and Party Type first',b'Selecteer Company en Party Type eerste'
-b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31',"b'Already set default in pos profile {0} for user {1}, kindly disabled default'","b'Al ingesteld standaard in pos profiel {0} voor gebruiker {1}, vriendelijk uitgeschakeld standaard'"
-b'apps/erpnext/erpnext/config/accounts.py +293',b'Financial / accounting year.',b'Financi\xc3\xable / boekjaar .'
-b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9',b'Accumulated Values',b'Geaccumuleerde waarden'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162',"b'Sorry, Serial Nos cannot be merged'","b'Sorry , serienummers kunnen niet worden samengevoegd'"
-b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72',b'Territory is Required in POS Profile',b'Territory is verplicht in POS Profiel'
-b'DocType: Supplier',b'Prevent RFQs',b'Voorkom RFQs'
-b'apps/erpnext/erpnext/utilities/activation.py +83',b'Make Sales Order',b'Maak verkooporder'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168',b'Salary Slip submitted for period from {0} to {1}',b'Salarisslip ingediend voor een periode van {0} tot {1}'
-b'DocType: Project Task',b'Project Task',b'Project Task'
-,b'Lead Id',b'Lead Id'
-b'DocType: C-Form Invoice Detail',b'Grand Total',b'Algemeen totaal'
-b'DocType: Assessment Plan',b'Course',b'cursus'
-b'DocType: Timesheet',b'Payslip',b'loonstrook'
-b'apps/erpnext/erpnext/public/js/pos/pos.html +4',b'Item Cart',b'Item winkelwagen'
-b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38',b'Fiscal Year Start Date should not be greater than Fiscal Year End Date',b'Boekjaar Startdatum mag niet groter zijn dan het Boekjaar Einddatum'
-b'DocType: Issue',b'Resolution',b'Oplossing'
-b'DocType: C-Form',b'IV',b'IV'
-b'apps/erpnext/erpnext/templates/pages/order.html +76',b'Delivered: {0}',b'Geleverd: {0}'
-b'DocType: Expense Claim',b'Payable Account',b'Verschuldigd Account'
-b'DocType: Payment Entry',b'Type of Payment',b'Type van Betaling'
-b'DocType: Sales Order',b'Billing and Delivery Status',b'Factuur- en leverstatus'
-b'DocType: Job Applicant',b'Resume Attachment',b'Resume Attachment'
-b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58',b'Repeat Customers',b'Terugkerende klanten'
-b'DocType: Leave Control Panel',b'Allocate',b'Toewijzen'
-b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108',b'Create Variant',b'Maak een variant'
-b'DocType: Sales Invoice',b'Shipping Bill Date',b'Verzendingsbiljetdatum'
-b'DocType: Production Plan',b'Production Plan',b'Productieplan'
-b'DocType: Opening Invoice Creation Tool',b'Opening Invoice Creation Tool',b'Opening factuur creatie tool'
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853',b'Sales Return',b'Terugkerende verkoop'
-b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96',"b""Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period""",b'Opmerking: Totaal toegewezen bladeren {0} mag niet kleiner zijn dan die reeds zijn goedgekeurd bladeren zijn {1} voor de periode'
-,b'Total Stock Summary',b'Totale voorraadoverzicht'
-b'DocType: Announcement',b'Posted By',b'Gepost door'
-b'DocType: Item',b'Delivered by Supplier (Drop Ship)',b'Geleverd door Leverancier (Drop Ship)'
-b'DocType: Healthcare Settings',b'Confirmation Message',b'Bevestigingsbericht'
-b'apps/erpnext/erpnext/config/crm.py +12',b'Database of potential customers.',b'Database van potenti\xc3\xable klanten.'
-b'DocType: Authorization Rule',b'Customer or Item',b'Klant of Item'
-b'apps/erpnext/erpnext/config/selling.py +28',b'Customer database.',b'Klantenbestand.'
-b'DocType: Quotation',b'Quotation To',b'Offerte Voor'
-b'DocType: Lead',b'Middle Income',b'Modaal Inkomen'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228',b'Opening (Cr)',b'Opening ( Cr )'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +872',b'Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.',"b'Standaard maateenheid voor post {0} kan niet direct worden gewijzigd, omdat je al enkele transactie (s) met een andere UOM hebben gemaakt. U moet een nieuwe post naar een andere Standaard UOM gebruik maken.'"
-b'apps/erpnext/erpnext/accounts/utils.py +354',b'Allocated amount can not be negative',b'Toegekende bedrag kan niet negatief zijn'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Stel het bedrijf alstublieft in'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Stel het bedrijf alstublieft in'
-b'DocType: Share Balance',b'Share Balance',b'Share Balance'
-b'DocType: Purchase Order Item',b'Billed Amt',b'Gefactureerd Bedr'
-b'DocType: Training Result Employee',b'Training Result Employee',b'Training Resultaat Werknemer'
-b'DocType: Warehouse',b'A logical Warehouse against which stock entries are made.',b'Een logisch Magazijn waartegen voorraadboekingen worden gemaakt.'
-b'DocType: Repayment Schedule',b'Principal Amount',b'hoofdsom'
-b'DocType: Employee Loan Application',b'Total Payable Interest',b'Totaal verschuldigde rente'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57',b'Total Outstanding: {0}',b'Totaal Uitstaande: {0}'
-b'DocType: Sales Invoice Timesheet',b'Sales Invoice Timesheet',b'Sales Invoice Timesheet'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118',b'Reference No & Reference Date is required for {0}',b'Referentienummer en referentiedatum nodig is voor {0}'
-b'DocType: Payroll Entry',b'Select Payment Account to make Bank Entry',b'Selecteer Betaalrekening aan Bank Entry maken'
-b'DocType: Hotel Settings',b'Default Invoice Naming Series',b'Standaard Invoice Naming Series'
-b'apps/erpnext/erpnext/utilities/activation.py +136',"b'Create Employee records to manage leaves, expense claims and payroll'","b'Maak Employee records bladeren, declaraties en salarisadministratie beheren'"
-b'DocType: Restaurant Reservation',b'Restaurant Reservation',b'Restaurant reservering'
-b'DocType: Land Unit',b'Land Unit Name',b'Land Eenheid Naam'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190',b'Proposal Writing',b'Voorstel Schrijven'
-b'DocType: Payment Entry Deduction',b'Payment Entry Deduction',b'Betaling Entry Aftrek'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14',b'Wrapping up',b'Afsluiten'
-b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35',b'Notify Customers via Email',b'Breng klanten op de hoogte via e-mail'
-b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35',b'Another Sales Person {0} exists with the same Employee id',b'Een andere Sales Person {0} bestaat met dezelfde werknemer id'
-b'DocType: Employee Advance',b'Claimed Amount',b'Geclaimd bedrag'
-b'apps/erpnext/erpnext/config/education.py +180',b'Masters',b'Stamdata'
-b'DocType: Assessment Plan',b'Maximum Assessment Score',b'Maximum Assessment Score'
-b'apps/erpnext/erpnext/config/accounts.py +138',b'Update Bank Transaction Dates',b'Update Bank transactiedata'
-b'apps/erpnext/erpnext/config/projects.py +41',b'Time Tracking',b'tijdregistratie'
-b'DocType: Purchase Invoice',b'DUPLICATE FOR TRANSPORTER',b'DUPLICATE VOOR TRANSPORTOR'
-b'apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49',b'Row {0}# Paid Amount cannot be greater than requested advance amount',b'Rij {0} # Het betaalde bedrag kan niet groter zijn dan het gevraagde voorschotbedrag'
-b'DocType: Fiscal Year Company',b'Fiscal Year Company',b'Fiscale Jaar Company'
-b'DocType: Packing Slip Item',b'DN Detail',b'DN Detail'
-b'DocType: Training Event',b'Conference',b'Conferentie'
-b'DocType: Timesheet',b'Billed',b'Gefactureerd'
-b'DocType: Batch',b'Batch Description',b'Batch Beschrijving'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Leergroepen cre\xc3\xabren'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Leergroepen cre\xc3\xabren'
-b'apps/erpnext/erpnext/accounts/utils.py +727',"b'Payment Gateway Account not created, please create one manually.'","b'Payment Gateway-account aangemaakt, dan kunt u een handmatig maken.'"
-b'DocType: Supplier Scorecard',b'Per Year',b'Per jaar'
-b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51',b'Not eligible for the admission in this program as per DOB',b'Komt niet in aanmerking voor de toelating in dit programma volgens DOB'
-b'DocType: Sales Invoice',b'Sales Taxes and Charges',b'Verkoop Belasting en Toeslagen'
-b'DocType: Employee',b'Organization Profile',b'organisatie Profiel'
-b'DocType: Vital Signs',b'Height (In Meter)',b'Hoogte (in meter)'
-b'DocType: Student',b'Sibling Details',b'sibling Details'
-b'DocType: Vehicle Service',b'Vehicle Service',b'voertuig'
-b'apps/erpnext/erpnext/config/setup.py +101',b'Automatically triggers the feedback request based on conditions.',b'Automatisch leidt tot de feedback verzoek op basis van de omstandigheden.'
-b'DocType: Employee',b'Reason for Resignation',b'Reden voor ontslag'
-b'apps/erpnext/erpnext/config/hr.py +152',b'Template for performance appraisals.',b'Sjabloon voor functioneringsgesprekken .'
-b'DocType: Sales Invoice',b'Credit Note Issued',b'Credit Note Uitgegeven'
-b'DocType: Project Task',b'Weight',b'Gewicht'
-b'DocType: Payment Reconciliation',b'Invoice/Journal Entry Details',b'Factuur / Journal Entry Details'
-b'apps/erpnext/erpnext/accounts/utils.py +83',"b""{0} '{1}' not in Fiscal Year {2}""","b""{0} '{1} ' niet in het boekjaar {2}"""
-b'DocType: Buying Settings',b'Settings for Buying Module',b'Instellingen voor het kopen van Module'
-b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21',b'Asset {0} does not belong to company {1}',b'Asset {0} niet behoort tot bedrijf {1}'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70',b'Please enter Purchase Receipt first',b'Vul Kwitantie eerste'
-b'DocType: Buying Settings',b'Supplier Naming By',b'Leverancier Benaming Door'
-b'DocType: Activity Type',b'Default Costing Rate',b'Standaard Costing Rate'
-b'DocType: Maintenance Schedule',b'Maintenance Schedule',b'Onderhoudsschema'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36',"b'Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.'","b'Dan worden prijsregels uitgefilterd op basis van Klant, Klantgroep, Regio,  Leverancier, Leverancier Type, Campagne, Verkooppartner, etc.'"
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29',b'Net Change in Inventory',b'Netto wijziging in Inventory'
-b'apps/erpnext/erpnext/config/hr.py +162',b'Employee Loan Management',b'Employee Lening Beheer'
-b'DocType: Employee',b'Passport Number',b'Paspoortnummer'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60',b'Relation with Guardian2',b'Relatie met Guardian2'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124',b'Manager',b'Manager'
-b'DocType: Payment Entry',b'Payment From / To',b'Betaling van / naar'
-b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +170',b'New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0}',b'New kredietlimiet lager is dan de huidige uitstaande bedrag voor de klant. Kredietlimiet moet minstens zijn {0}'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428',b'Please set account in Warehouse {0}',b'Stel een account in in Magazijn {0}'
-b'apps/erpnext/erpnext/controllers/trends.py +39',"b""'Based On' and 'Group By' can not be same""","b""'Gebaseerd op' en 'Groepeer per' kunnen niet hetzelfde zijn"""
-b'DocType: Sales Person',b'Sales Person Targets',b'Verkoper Doelen'
-b'DocType: Installation Note',b'IN-',b'IN-'
-b'DocType: Work Order Operation',b'In minutes',b'In minuten'
-b'DocType: Issue',b'Resolution Date',b'Oplossing Datum'
-b'DocType: Lab Test Template',b'Compound',b'samenstelling'
-b'DocType: Student Batch Name',b'Batch Name',b'batch Naam'
-b'DocType: Fee Validity',b'Max number of visit',b'Max. Aantal bezoeken'
-,b'Hotel Room Occupancy',b'Hotel Kamer bezetting'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358',b'Timesheet created:',b'Rooster gemaakt:'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931',b'Please set default Cash or Bank account in Mode of Payment {0}',b'Stel een standaard Kas- of Bankrekening in bij Betaalwijze {0}'
-b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24',b'Enroll',b'Inschrijven'
-b'DocType: GST Settings',b'GST Settings',b'GST instellingen'
-b'DocType: Selling Settings',b'Customer Naming By',b'Klant Naming Door'
-b'DocType: Student Leave Application',b'Will show the student as Present in Student Monthly Attendance Report',b'Zal de student zoals aanwezig in Student Maandelijkse Rapport Aanwezigheid tonen'
-b'DocType: Depreciation Schedule',b'Depreciation Amount',b'afschrijvingen Bedrag'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56',b'Convert to Group',b'Converteren naar Groep'
-b'DocType: Delivery Trip',b'TOUR-.#####',b'TOUR-.#####'
-b'DocType: Activity Cost',b'Activity Type',b'Activiteit Type'
-b'DocType: Request for Quotation',b'For individual supplier',b'Voor individuele leverancier'
-b'DocType: BOM Operation',b'Base Hour Rate(Company Currency)',b'Base Uur Rate (Company Munt)'
-b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47',b'Delivered Amount',b'Afgeleverd Bedrag'
-b'DocType: Quotation Item',b'Item Balance',b'Item Balance'
-b'DocType: Sales Invoice',b'Packing List',b'Paklijst'
-b'apps/erpnext/erpnext/config/buying.py +28',b'Purchase Orders given to Suppliers.',b'Inkooporders voor leveranciers.'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43',b'Publishing',b'Publishing'
-b'DocType: Accounts Settings',b'Report Settings',b'Rapportinstellingen'
-b'DocType: Activity Cost',b'Projects User',b'Projecten Gebruiker'
-b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Consumed',b'Verbruikt'
-b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158',b'{0}: {1} not found in Invoice Details table',b'{0}: {1} niet gevonden in Factuur Details tabel'
-b'DocType: Asset',b'Asset Owner Company',b'Asset Owner Company'
-b'DocType: Company',b'Round Off Cost Center',b'Afronden kostenplaats'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242',b'Maintenance Visit {0} must be cancelled before cancelling this Sales Order',b'Onderhoud Bezoek {0} moet worden geannuleerd voordat het annuleren van deze verkooporder'
-b'DocType: Asset Maintenance Log',b'AML-',b'AML-'
-b'DocType: Item',b'Material Transfer',b'Materiaal Verplaatsing'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24',b'Could not find path for ',b'Kan pad niet vinden voor'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221',b'Opening (Dr)',b'Opening ( Dr )'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39',b'Posting timestamp must be after {0}',b'Plaatsing timestamp moet na {0} zijn'
-b'apps/erpnext/erpnext/config/accounts.py +39',b'To make recurring documents',b'Om terugkerende documenten te maken'
-,b'GST Itemised Purchase Register',b'GST Itemized Purchase Register'
-b'DocType: Course Scheduling Tool',b'Reschedule',b'Afspraak verzetten'
-b'DocType: Employee Loan',b'Total Interest Payable',b'Totaal te betalen rente'
-b'DocType: Landed Cost Taxes and Charges',b'Landed Cost Taxes and Charges',b'Vrachtkosten belastingen en toeslagen'
-b'DocType: Work Order Operation',b'Actual Start Time',b'Werkelijke Starttijd'
-b'DocType: BOM Operation',b'Operation Time',b'Operatie Tijd'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316',b'Finish',b'Afwerking'
-b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412',b'Base',b'Baseren'
-b'DocType: Timesheet',b'Total Billed Hours',b'Totaal gefactureerd Hours'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1530',b'Write Off Amount',b'Afschrijvingsbedrag'
-b'DocType: Leave Block List Allow',b'Allow User',b'Door gebruiker toestaan'
-b'DocType: Journal Entry',b'Bill No',b'Factuur nr'
-b'DocType: Company',b'Gain/Loss Account on Asset Disposal',b'Winst / verliesrekening op de verkoop van activa'
-b'DocType: Vehicle Log',b'Service Details',b'Service Details'
-b'DocType: Subscription',b'Quarterly',b'Kwartaal'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47',b'EcritureLib',b'EcritureLib'
-b'DocType: Lab Test Template',b'Grouped',b'gegroepeerd'
-b'DocType: Selling Settings',b'Delivery Note Required',b'Vrachtbrief Verplicht'
-b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Bankgarantie Nummer'
-b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Bankgarantie Nummer'
-b'DocType: Assessment Criteria',b'Assessment Criteria',b'Beoordelingscriteria'
-b'DocType: BOM Item',b'Basic Rate (Company Currency)',b'Basis Tarief (Bedrijfs Valuta)'
-b'DocType: Student Attendance',b'Student Attendance',b'student Attendance'
-b'DocType: Sales Invoice Timesheet',b'Time Sheet',b'Urenregistratie'
-b'DocType: Manufacturing Settings',b'Backflush Raw Materials Based On',b'Grondstoffen afgeboekt op basis van'
-b'DocType: Sales Invoice',b'Port Code',b'Poortcode'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957',b'Reserve Warehouse',b'Magazijn reserveren'
-b'DocType: Lead',b'Lead is an Organization',b'Lead is een organisatie'
-b'DocType: Guardian Interest',b'Interest',b'Interesseren'
-b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10',b'Pre Sales',b'Voorverkoop'
-b'DocType: Instructor Log',b'Other Details',b'Andere Details'
-b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18',b'Suplier',b'suplier'
-b'DocType: Lab Test',b'Test Template',b'Test sjabloon'
-b'DocType: Restaurant Order Entry Item',b'Served',b'geserveerd'
-b'apps/erpnext/erpnext/config/non_profit.py +13',b'Chapter information.',b'Hoofdstuk informatie.'
-b'DocType: Account',b'Accounts',b'Rekeningen'
-b'DocType: Vehicle',b'Odometer Value (Last)',b'Kilometerstand (Laatste)'
-b'apps/erpnext/erpnext/config/buying.py +160',b'Templates of supplier scorecard criteria.',b'Templates van leveranciers scorecard criteria.'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109',b'Marketing',b'Marketing'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303',b'Payment Entry is already created',b'Betaling Entry is al gemaakt'
-b'DocType: Request for Quotation',b'Get Suppliers',b'Krijg leveranciers'
-b'DocType: Purchase Receipt Item Supplied',b'Current Stock',b'Huidige voorraad'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +610',b'Row #{0}: Asset {1} does not linked to Item {2}',b'Rij # {0}: Asset {1} is niet gekoppeld aan artikel {2}'
-b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15',b'Please setup Instructor Naming System in Education &gt; Education Settings',b'Stel het systeem voor instructeursbenaming in Onderwijs&gt; Onderwijsinstellingen in'
-b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394',b'Preview Salary Slip',b'Voorbeschouwing loonstrook'
-b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54',b'Account {0} has been entered multiple times',b'Account {0} is meerdere keren ingevoerd'
-b'DocType: Account',b'Expenses Included In Valuation',b'Kosten inbegrepen in waardering'
-b'apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37',b'You can only renew if your membership expires within 30 days',b'U kunt alleen verlengen als uw lidmaatschap binnen 30 dagen verloopt'
-b'DocType: Land Unit',b'Longitude',b'Lengtegraad'
-,b'Absent Student Report',b'Studenten afwezigheidsrapport'
-b'DocType: Crop',b'Crop Spacing UOM',b'Gewasafstand UOM'
-b'DocType: Accounts Settings',b'Only select if you have setup Cash Flow Mapper documents',b'Selecteer alleen als u Cash Flow Mapper-documenten hebt ingesteld'
-b'DocType: Email Digest',b'Next email will be sent on:',b'Volgende e-mail wordt verzonden op:'
-b'DocType: Supplier Scorecard',b'Per Week',b'Per week'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +666',b'Item has variants.',b'Item heeft varianten.'
-b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154',b'Total Student',b'Totaal student'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65',b'Item {0} not found',b'Artikel {0} niet gevonden'
-b'DocType: Bin',b'Stock Value',b'Voorraad Waarde'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +239',b'Company {0} does not exist',b'Company {0} bestaat niet'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40',b'{0} has fee validity till {1}',b'{0} heeft geldigheid tot {1}'
-b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54',b'Tree Type',b'Boom Type'
-b'DocType: BOM Explosion Item',b'Qty Consumed Per Unit',b'Aantal verbruikt per eenheid'
-b'DocType: GST Account',b'IGST Account',b'IGST-account'
-b'DocType: Serial No',b'Warranty Expiry Date',b'Garantie Vervaldatum'
-b'DocType: Material Request Item',b'Quantity and Warehouse',b'Hoeveelheid en magazijn'
-b'DocType: Hub Settings',b'Unregister',b'Afmelden'
-b'DocType: Sales Invoice',b'Commission Rate (%)',b'Commissie Rate (%)'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Selecteer alsjeblieft Programma'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Selecteer alsjeblieft Programma'
-b'DocType: Project',b'Estimated Cost',b'Geschatte kosten'
-b'DocType: Purchase Order',b'Link to material requests',b'Koppeling naar materiaal aanvragen'
-b'DocType: Hub Settings',b'Publish',b'Publiceren'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7',b'Aerospace',b'Ruimtevaart'
-,b'Fichier des Ecritures Comptables [FEC]',b'Fichier des Ecritures Comptables [FEC]'
-b'DocType: Journal Entry',b'Credit Card Entry',b'Kredietkaart invoer'
-b'apps/erpnext/erpnext/config/accounts.py +57',b'Company and Accounts',b'Bedrijf en Accounts'
-b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70',b'In Value',b'in Value'
-b'DocType: Asset Settings',b'Depreciation Options',b'Afschrijvingsopties'
-b'apps/erpnext/erpnext/utilities/transaction_base.py +35',b'Invalid Posting Time',b'Ongeldige boekingstijd'
-b'DocType: Lead',b'Campaign Name',b'Campagnenaam'
-b'DocType: Hotel Room',b'Capacity',b'Capaciteit'
-b'DocType: Selling Settings',b'Close Opportunity After Days',b'Sluiten Opportunity Na Days'
-,b'Reserved',b'gereserveerd'
-b'DocType: Driver',b'License Details',b'Licentie details'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85',b'The field From Shareholder cannot be blank',b'Het veld Van Aandeelhouder mag niet leeg zijn'
-b'DocType: Purchase Order',b'Supply Raw Materials',b'Supply Grondstoffen'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10',b'Current Assets',b'Vlottende Activa'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121',b'{0} is not a stock Item',b'{0} is geen voorraad artikel'
-b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6',"b""Please share your feedback to the training by clicking on 'Training Feedback' and then 'New'""",b'Deel alstublieft uw feedback aan de training door op &#39;Training Feedback&#39; te klikken en vervolgens &#39;New&#39;'
-b'DocType: Mode of Payment Account',b'Default Account',b'Standaardrekening'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +273',b'Please select Sample Retention Warehouse in Stock Settings first',b'Selecteer eerst Sample Retention Warehouse in Stock Settings'
-b'DocType: Payment Entry',b'Received Amount (Company Currency)',b'Ontvangen bedrag (Company Munt)'
-b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192',b'Lead must be set if Opportunity is made from Lead',b'Lead moet worden ingesteld als de opportuniteit is gemaakt obv een lead'
-b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136',b'Payment Cancelled. Please check your GoCardless Account for more details',b'Betaling geannuleerd. Controleer uw GoCardless-account voor meer informatie'
-b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29',b'Please select weekly off day',b'Selecteer wekelijkse vrije dag'
-b'DocType: Patient',b'O Negative',b'O Negatief'
-b'DocType: Work Order Operation',b'Planned End Time',b'Geplande Eindtijd'
-,b'Sales Person Target Variance Item Group-Wise',b'Sales Person Doel Variance Post Group - Wise'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +93',b'Account with existing transaction cannot be converted to ledger',b'Rekening met bestaande transactie kan niet worden geconverteerd naar grootboek'
-b'apps/erpnext/erpnext/config/non_profit.py +33',b'Memebership Type Details',b'Type details voor lidmaatschapstype'
-b'DocType: Delivery Note',"b""Customer's Purchase Order No""",b'Inkoopordernummer van Klant'
-b'DocType: Budget',b'Budget Against',b'budget Against'
-b'DocType: Employee',b'Cell Number',b'Mobiel nummer'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450',"b""There's no employee for the given criteria. Check that Salary Slips have not already been created.""",b'Er is geen medewerker voor de gegeven criteria. Controleer of salarisstroken nog niet zijn gemaakt.'
-b'apps/erpnext/erpnext/stock/reorder_item.py +194',b'Auto Material Requests Generated',b'Auto Materiaal Verzoeken Vernieuwd'
-b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7',b'Lost',b'Verloren'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152',"b""You can not enter current voucher in 'Against Journal Entry' column""","b""U kan geen 'Voucher' invoeren in een 'Tegen Journal Entry' kolom"""
-b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50',b'Reserved for manufacturing',b'Gereserveerd voor productie'
-b'DocType: Soil Texture',b'Sand',b'Zand'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25',b'Energy',b'Energie'
-b'DocType: Opportunity',b'Opportunity From',b'Opportuniteit Van'
-b'apps/erpnext/erpnext/config/hr.py +98',b'Monthly salary statement.',b'Maandsalaris overzicht.'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887',b'Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.',b'Rij {0}: {1} Serienummers vereist voor item {2}. U heeft {3} verstrekt.'
-b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79',b'Please select a table',b'Selecteer een tafel'
-b'DocType: BOM',b'Website Specifications',b'Website Specificaties'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78',"b""{0} is an invalid email address in 'Recipients'""",b'{0} is een ongeldig e-mailadres in &#39;Ontvangers&#39;'
-b'DocType: Special Test Items',b'Particulars',b'bijzonderheden'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24',b'{0}: From {0} of type {1}',b'{0}: Van {0} van type {1}'
-b'DocType: Warranty Claim',b'CI-',b'CI-'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +300',b'Row {0}: Conversion Factor is mandatory',b'Rij {0}: Conversie Factor is verplicht'
-b'DocType: Student',b'A+',b'A+'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344',"b'Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}'","b'Meerdere Prijs Regels bestaat met dezelfde criteria, dan kunt u conflicten op te lossen door het toekennen van prioriteit. Prijs Regels: {0}'"
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519',b'Cannot deactivate or cancel BOM as it is linked with other BOMs',b'Kan stuklijst niet deactiveren of annuleren aangezien het is gelinkt met andere stuklijsten.'
-b'DocType: Asset',b'Maintenance',b'Onderhoud'
-b'DocType: Item Attribute Value',b'Item Attribute Value',b'Item Atribuutwaarde'
-b'apps/erpnext/erpnext/projects/doctype/project/project.py +406',b'Please Update your Project Status',b'Werk uw projectstatus bij'
-b'DocType: Item',b'Maximum sample quantity that can be retained',b'Maximum aantal monsters dat kan worden bewaard'
-b'DocType: Project Update',b'How is the Project Progressing Right Now?',b'Hoe verloopt het project nu?'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418',b'Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3}',b'Rij {0} # artikel {1} kan niet meer dan {2} worden overgedragen tegen bestelling {3}'
-b'apps/erpnext/erpnext/config/selling.py +158',b'Sales campaigns.',b'Verkoop campagnes'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117',b'Make Timesheet',b'maak Timesheet'
-b'DocType: Sales Taxes and Charges Template',"b'Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.'","b'Standaard belasting sjabloon die kan worden toegepast op alle verkooptransacties. Deze sjabloon kan lijst van fiscale hoofden en ook andere kosten / baten koppen als ""Verzenden"", ""Verzekering"" bevatten, ""Omgaan met"" enz \n\n #### Opmerking \n\n Het belastingtarief u defini\xc3\xabren hier zal het normale belastingtarief voor alle ** Items worden **. Als er ** Items ** dat verschillende tarieven hebben, moeten ze worden toegevoegd in de ** Item Tax ** tafel in de ** Item ** meester.\n\n #### Beschrijving van Kolommen \n\n 1. Berekening Type: \n - Dit kan op ** Netto Totaal ** (dat is de som van het basisbedrag).\n - ** Op Vorige Row Total / Bedrag ** (voor cumulatieve belastingen of heffingen). Als u deze optie selecteert, zal de belasting worden berekend als een percentage van de vorige rij (in de fiscale tabel) bedrag of totaal.\n - ** Werkelijke ** (zoals vermeld).\n 2. Account Head: De Account grootboek waaronder deze belasting \n 3 zal worden geboekt. Cost Center: Als de belasting / heffing is een inkomen (zoals de scheepvaart) of kosten die het nodig heeft tegen een kostenplaats worden geboekt.\n 4. Beschrijving: Beschrijving van de belasting (die zullen worden afgedrukt in de facturen / offertes).\n 5. Rate: belastingtarief.\n 6. Bedrag: BTW bedrag.\n 7. Totaal: Cumulatief totaal op dit punt.\n 8. Voer Row: Als op basis van ""Vorige Row Total"" kunt u het rijnummer die zullen worden genomen als basis voor deze berekening (standaard is de vorige rij) te selecteren.\n 9. Is dit inbegrepen in de Basic Rate ?: Indien u dit controleren, betekent dit dat deze belasting niet onder het item tafel zal worden getoond, maar zal worden opgenomen in het basistarief in uw belangrijkste punt tafel. Dit is handig wanneer u wilt geven een platte prijs (inclusief alle belastingen) prijs aan klanten.'"
-b'DocType: Employee',b'Bank A/C No.',b'Bank A / C nr.'
-b'DocType: Bank Guarantee',b'Project',b'Project'
-b'DocType: Quality Inspection Reading',b'Reading 7',b'Meting 7'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9',b'Partially Ordered',b'gedeeltelijk Bestelde'
-b'DocType: Lab Test',b'Lab Test',b'Laboratoriumtest'
-b'DocType: Student Report Generation Tool',b'Student Report Generation Tool',b'Studentenrapport-generatietool'
-b'DocType: Expense Claim Detail',b'Expense Claim Type',b'Kostendeclaratie Type'
-b'DocType: Shopping Cart Settings',b'Default settings for Shopping Cart',b'Standaardinstellingen voor Winkelwagen'
-b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27',b'Add Timeslots',b'Voeg tijdsloten toe'
-b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138',b'Asset scrapped via Journal Entry {0}',b'Asset gesloopt via Journal Entry {0}'
-b'DocType: Employee Loan',b'Interest Income Account',b'Rentebaten Account'
-b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58',b'Review Invitation Sent',b'Review Uitnodiging verzonden'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13',b'Biotechnology',b'Biotechnologie'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109',b'Office Maintenance Expenses',b'Gebouwen Onderhoudskosten'
-b'apps/erpnext/erpnext/utilities/user_progress.py +54',b'Go to ',b'Ga naar'
-b'apps/erpnext/erpnext/config/learn.py +47',b'Setting up Email Account',b'Het opzetten van e-mailaccount'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21',b'Please enter Item first',b'Vul eerst artikel in'
-b'DocType: Asset Repair',b'Downtime',b'uitvaltijd'
-b'DocType: Account',b'Liability',b'Verplichting'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220',b'Sanctioned Amount cannot be greater than Claim Amount in Row {0}.',b'Gesanctioneerde bedrag kan niet groter zijn dan Claim Bedrag in Row {0}.'
-b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11',b'Academic Term: ',b'Academische termijn:'
-b'DocType: Salary Detail',b'Do not include in total',b'Neem niet alles mee'
-b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206',b'Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series',b'Stel Naming Series in voor {0} via Setup&gt; Instellingen&gt; Serie benoemen'
-b'DocType: Company',b'Default Cost of Goods Sold Account',b'Standaard kosten van verkochte goederen Account'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1019',b'Sample quantity {0} cannot be more than received quantity {1}',b'Voorbeeldhoeveelheid {0} kan niet meer dan ontvangen aantal {1} zijn'
-b'apps/erpnext/erpnext/stock/get_item_details.py +369',b'Price List not selected',b'Prijslijst niet geselecteerd'
-b'DocType: Employee',b'Family Background',b'Familie Achtergrond'
-b'DocType: Request for Quotation Supplier',b'Send Email',b'E-mail verzenden'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +228',b'Warning: Invalid Attachment {0}',b'Waarschuwing: Invalid Attachment {0}'
-b'DocType: Item',b'Max Sample Quantity',b'Max. Aantal monsters'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766',b'No Permission',b'Geen toestemming'
-b'DocType: Vital Signs',b'Heart Rate / Pulse',b'Hartslag / Pulse'
-b'DocType: Company',b'Default Bank Account',b'Standaard bankrekening'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59',"b'To filter based on Party, select Party Type first'","b'Om te filteren op basis van Party, selecteer Party Typ eerst'"
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48',"b""'Update Stock' can not be checked because items are not delivered via {0}""","b""'Bijwerken voorraad' kan niet worden aangevinkt omdat items niet worden geleverd via {0}"""
-b'DocType: Vehicle',b'Acquisition Date',b'Aankoopdatum'
-b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Nos',b'Nrs'
-b'DocType: Item',b'Items with higher weightage will be shown higher',b'Items met een hogere weightage hoger zal worden getoond'
-b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14',b'Lab Tests and Vital Signs',b'Lab-tests en vitale functies'
-b'DocType: Bank Reconciliation Detail',b'Bank Reconciliation Detail',b'Bank Aflettering Detail'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +614',b'Row #{0}: Asset {1} must be submitted',b'Rij # {0}: Asset {1} moet worden ingediend'
-b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40',b'No employee found',b'Geen werknemer gevonden'
-b'DocType: Subscription',b'Stopped',b'Gestopt'
-b'DocType: Item',b'If subcontracted to a vendor',b'Als uitbesteed aan een leverancier'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Studentgroep is al bijgewerkt.'
-b'apps/erpnext/erpnext/config/projects.py +18',b'Project Update.',b'Project update.'
-b'DocType: SMS Center',b'All Customer Contact',b'Alle Customer Contact'
-b'DocType: Land Unit',b'Tree Details',b'Tree Details'
-b'DocType: Training Event',b'Event Status',b'event Status'
-b'DocType: Volunteer',b'Availability Timeslot',b'Beschikbaarheid Timeslot'
-,b'Support Analytics',b'Support Analyse'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365',"b'If you have any questions, please get back to us.'","b'Mocht u nog vragen hebben, dan kunt u weer terug naar ons.'"
-b'DocType: Cash Flow Mapper',b'Cash Flow Mapper',b'Cash Flow Mapper'
-b'DocType: Item',b'Website Warehouse',b'Website Magazijn'
-b'DocType: Payment Reconciliation',b'Minimum Invoice Amount',b'Minimum Factuurbedrag'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111',b'{0} {1}: Cost Center {2} does not belong to Company {3}',b'{0} {1}: kostenplaats {2} behoort niet tot Company {3}'
-b'apps/erpnext/erpnext/utilities/user_progress.py +92',b'Upload your letter head (Keep it web friendly as 900px by 100px)',b'Upload uw briefhoofd (houd het webvriendelijk als 900px bij 100px)'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88',b'{0} {1}: Account {2} cannot be a Group',b'{0} {1}: Account {2} kan geen Group zijn'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63',"b""Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table""",b'Item Row {IDX}: {doctype} {DocName} bestaat niet in bovenstaande &#39;{} doctype&#39; table'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295',b'Timesheet {0} is already completed or cancelled',b'Timesheet {0} is al voltooid of geannuleerd'
-b'apps/erpnext/erpnext/templates/pages/projects.html +42',b'No tasks',b'geen taken'
-b'DocType: Item Variant Settings',b'Copy Fields to Variant',b'Kopieer velden naar variant'
-b'DocType: Asset',b'Opening Accumulated Depreciation',b'Het openen van de cumulatieve afschrijvingen'
-b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49',b'Score must be less than or equal to 5',b'Score moet lager dan of gelijk aan 5 zijn'
-b'DocType: Program Enrollment Tool',b'Program Enrollment Tool',b'Programma Inschrijving Tool'
-b'apps/erpnext/erpnext/config/accounts.py +335',b'C-Form records',b'C -Form records'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73',b'The shares already exist',b'De aandelen bestaan al'
-b'apps/erpnext/erpnext/config/selling.py +316',b'Customer and Supplier',b'Klant en leverancier'
-b'DocType: Email Digest',b'Email Digest Settings',b'E-mail Digest Instellingen'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367',b'Thank you for your business!',b'Bedankt voor uw zaken!'
-b'apps/erpnext/erpnext/config/support.py +12',b'Support queries from customers.',b'Support vragen van klanten.'
-b'DocType: Setup Progress Action',b'Action Doctype',b'Actie Doctype'
-b'DocType: HR Settings',b'Retirement Age',b'Pensioenleeftijd'
-b'DocType: Bin',b'Moving Average Rate',b'Moving Average Rate'
-b'DocType: Production Plan',b'Select Items',b'Selecteer Artikelen'
-b'DocType: Share Transfer',b'To Shareholder',b'Aan de aandeelhouder'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372',b'{0} against Bill {1} dated {2}',b'{0} tegen Factuur {1} gedateerd {2}'
-b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Institution',b'Setup instelling'
-b'DocType: Program Enrollment',b'Vehicle/Bus Number',b'Voertuig- / busnummer'
-b'apps/erpnext/erpnext/education/doctype/course/course.js +17',b'Course Schedule',b'Course Schedule'
-b'DocType: Request for Quotation Supplier',b'Quote Status',b'Offerte Status'
-b'DocType: GoCardless Settings',b'Webhooks Secret',b'Webhooks geheim'
-b'DocType: Maintenance Visit',b'Completion Status',b'Voltooiingsstatus'
-b'DocType: Daily Work Summary Group',b'Select Users',b'Selecteer gebruikers'
-b'DocType: Hotel Room Pricing Item',b'Hotel Room Pricing Item',b'Prijsbepaling Hotelkamer'
-b'DocType: HR Settings',b'Enter retirement age in years',b'Voer de pensioengerechtigde leeftijd in jaren'
-b'DocType: Crop',b'Target Warehouse',b'Doel Magazijn'
-b'DocType: Payroll Employee Detail',b'Payroll Employee Detail',b'Loonwerknemersdetail'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128',b'Please select a warehouse',b'Selecteer een magazijn'
-b'DocType: Cheque Print Template',b'Starting location from left edge',b'Startlocatie van linkerrand'
-b'DocType: Item',b'Allow over delivery or receipt upto this percent',b'Laat dan levering of ontvangst upto deze procent'
-b'DocType: Stock Entry',b'STE-',b'STEREO'
-b'DocType: Upload Attendance',b'Import Attendance',b'Import Toeschouwers'
-b'apps/erpnext/erpnext/public/js/pos/pos.html +124',b'All Item Groups',b'Alle Artikel Groepen'
-b'apps/erpnext/erpnext/config/setup.py +89',b'Automatically compose message on submission of transactions.',b'Bericht automatisch samenstellen overlegging van transacties .'
-b'DocType: Work Order',b'Item To Manufacture',b'Artikel te produceren'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteLib',b'CompteLib'
-b'apps/erpnext/erpnext/buying/utils.py +80',b'{0} {1} status is {2}',b'{0} {1} status {2}'
-b'DocType: Water Analysis',b'Collection Temperature ',b'Verzamelingstemperatuur'
-b'DocType: Employee',b'Provide Email Address registered in company',b'Zorg voor e-mailadres in bedrijf geregistreerd'
-b'DocType: Shopping Cart Settings',b'Enable Checkout',b'inschakelen Afrekenen'
-b'apps/erpnext/erpnext/config/learn.py +202',b'Purchase Order to Payment',b'Aanschaffen om de betaling'
-b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48',b'Projected Qty',b'Verwachte Aantal'
-b'DocType: Sales Invoice',b'Payment Due Date',b'Betaling Vervaldatum'
-b'DocType: Drug Prescription',b'Interval UOM',b'Interval UOM'
-b'DocType: Customer',"b'Reselect, if the chosen address is edited after save'","b'Selecteer opnieuw, als het gekozen adres is bewerkt na opslaan'"
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +522',b'Item Variant {0} already exists with same attributes',b'Artikel Variant {0} bestaat al met dezelfde kenmerken'
-b'DocType: Item',b'Hub Publishing Details',b'Hub publicatie details'
-b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117',"b""'Opening'""",b'&#39;Opening&#39;'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130',b'Open To Do',b'Open To Do'
-b'DocType: Notification Control',b'Delivery Note Message',b'Vrachtbrief Bericht'
-b'DocType: Lab Test Template',b'Result Format',b'Resultaatformaat'
-b'DocType: Expense Claim',b'Expenses',b'Uitgaven'
-b'DocType: Item Variant Attribute',b'Item Variant Attribute',b'Artikel Variant Kenmerk'
-,b'Purchase Receipt Trends',b'Ontvangstbevestiging Trends'
-b'DocType: Payroll Entry',b'Bimonthly',b'Tweemaandelijks'
-b'DocType: Vehicle Service',b'Brake Pad',b'Brake Pad'
-b'DocType: Fertilizer',b'Fertilizer Contents',b'Kunstmest Inhoud'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119',b'Research & Development',b'Research & Development'
-b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20',b'Amount to Bill',b'Neerkomen op Bill'
-b'DocType: Company',b'Registration Details',b'Registratie Details'
-b'DocType: Timesheet',b'Total Billed Amount',b'Totaal factuurbedrag'
-b'DocType: Item Reorder',b'Re-Order Qty',b'Re-order Aantal'
-b'DocType: Leave Block List Date',b'Leave Block List Date',b'Laat Block List Datum'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94',b'BOM #{0}: Raw material cannot be same as main Item',b'BOM # {0}: Ruw materiaal kan niet hetzelfde zijn als hoofdartikel'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92',b'Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges',b'Totaal van toepassing zijnde kosten in Kwitantie Items tabel moet hetzelfde zijn als de totale belastingen en heffingen'
-b'DocType: Sales Team',b'Incentives',b'Incentives'
-b'DocType: SMS Log',b'Requested Numbers',b'Gevraagde Numbers'
-b'DocType: Volunteer',b'Evening',b'Avond'
-b'DocType: Customer',b'Bypass credit limit check at Sales Order',b'Creditlimietcontrole overslaan op klantorder'
-b'apps/erpnext/erpnext/config/hr.py +147',b'Performance appraisal.',b'Beoordeling van de prestaties.'
-b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100',"b""Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart""","b'Inschakelen &quot;Gebruik voor Winkelwagen &#39;, zoals Winkelwagen is ingeschakeld en er moet minstens \xc3\xa9\xc3\xa9n Tax Rule voor Winkelwagen zijn'"
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +412',"b'Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.'","b'Betaling Entry {0} is verbonden met de Orde {1}, controleer dan of het als tevoren in deze factuur moet worden getrokken.'"
-b'DocType: Sales Invoice Item',b'Stock Details',b'Voorraad Details'
-b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29',b'Project Value',b'Project Waarde'
-b'apps/erpnext/erpnext/config/selling.py +326',b'Point-of-Sale',b'Verkooppunt'
-b'DocType: Fee Schedule',b'Fee Creation Status',b'Fee Creation Status'
-b'DocType: Vehicle Log',b'Odometer Reading',b'kilometerstand'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +116',"b""Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'""","b""Accountbalans reeds in Credit, 'Balans moet zijn' mag niet als 'Debet' worden ingesteld"""
-b'DocType: Account',b'Balance must be',b'Saldo moet worden'
-b'DocType: Hub Settings',b'Publish Pricing',b'Publiceer Pricing'
-b'DocType: Notification Control',b'Expense Claim Rejected Message',b'Kostendeclaratie afgewezen Bericht'
-,b'Available Qty',b'Beschikbaar Aantal'
-b'DocType: Purchase Taxes and Charges',b'On Previous Row Total',b'Aantal van volgende rij'
-b'DocType: Purchase Invoice Item',b'Rejected Qty',b'afgewezen Aantal'
-b'DocType: Setup Progress Action',b'Action Field',b'Actieveld'
-b'DocType: Healthcare Settings',b'Manage Customer',b'Klant beheren'
-b'DocType: Delivery Trip',b'Delivery Stops',b'Levering stopt'
-b'DocType: Salary Slip',b'Working Days',b'Werkdagen'
-b'DocType: Serial No',b'Incoming Rate',b'Inkomende Rate'
-b'DocType: Packing Slip',b'Gross Weight',b'Bruto Gewicht'
-,b'Final Assessment Grades',b'Eindbeoordeling'
-b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47',b'Enable Hub',b'Hub inschakelen'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +110',b'The name of your company for which you are setting up this system.',b'De naam van uw bedrijf waar u het systeem voor op zet.'
-b'DocType: HR Settings',b'Include holidays in Total no. of Working Days',b'Feestdagen opnemen in totaal aantal werkdagen.'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108',b'Setup your Institute in ERPNext',b'Stel uw instituut op in ERPNext'
-b'DocType: Agriculture Analysis Criteria',b'Plant Analysis',b'Plantanalyse'
-b'DocType: Job Applicant',b'Hold',b'Houden'
-b'DocType: Project Update',b'Progress Details',b'Voortgangsdetails'
-b'DocType: Employee',b'Date of Joining',b'Datum van indiensttreding'
-b'DocType: Naming Series',b'Update Series',b'Reeksen bijwerken'
-b'DocType: Supplier Quotation',b'Is Subcontracted',b'Wordt uitbesteed'
-b'DocType: Restaurant Table',b'Minimum Seating',b'Minimum aantal zitplaatsen'
-b'DocType: Item Attribute',b'Item Attribute Values',b'Item Attribuutwaarden'
-b'DocType: Examination Result',b'Examination Result',b'examenresultaat'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845',b'Purchase Receipt',b'Ontvangstbevestiging'
-,b'Received Items To Be Billed',b'Ontvangen artikelen nog te factureren'
-b'apps/erpnext/erpnext/config/accounts.py +303',b'Currency exchange rate master.',b'Wisselkoers stam.'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209',b'Reference Doctype must be one of {0}',b'Referentie Doctype moet een van {0}'
-b'apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46',b'Filter Total Zero Qty',b'Filter totaal aantal nul'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341',b'Unable to find Time Slot in the next {0} days for Operation {1}',b'Kan Time Slot in de volgende {0} dagen voor Operatie vinden {1}'
-b'DocType: Work Order',b'Plan material for sub-assemblies',b'Plan materiaal voor onderdelen'
-b'apps/erpnext/erpnext/config/selling.py +97',b'Sales Partners and Territory',b'Sales Partners en Territory'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +600',b'BOM {0} must be active',b'Stuklijst {0} moet actief zijn'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414',b'No Items available for transfer',b'Geen items beschikbaar voor overdracht'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218',b'Closing (Opening + Total)',b'Sluiten (Opening + totaal)'
-b'DocType: Journal Entry',b'Depreciation Entry',b'afschrijvingen Entry'
-b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32',b'Please select the document type first',b'Selecteer eerst het documenttype'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65',b'Cancel Material Visits {0} before cancelling this Maintenance Visit',b'Annuleren Materiaal Bezoeken {0} voor het annuleren van deze Maintenance Visit'
-b'DocType: Crop Cycle',b'ISO 8016 standard',b'ISO 8016-norm'
-b'DocType: Pricing Rule',b'Rate or Discount',b'Tarief of korting'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213',b'Serial No {0} does not belong to Item {1}',b'Serienummer {0} behoort niet tot Artikel {1}'
-b'DocType: Purchase Receipt Item Supplied',b'Required Qty',b'Benodigde hoeveelheid'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126',b'Warehouses with existing transaction can not be converted to ledger.',b'Warehouses met bestaande transactie kan niet worden geconverteerd naar grootboek.'
-b'DocType: Bank Reconciliation',b'Total Amount',b'Totaal bedrag'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32',b'Internet Publishing',b'internet Publishing'
-b'DocType: Prescription Duration',b'Number',b'Aantal'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25',b'Creating {0} Invoice',b'{0} factuur aanmaken'
-b'DocType: Medical Code',b'Medical Code Standard',b'Medische Code Standaard'
-b'DocType: Soil Texture',b'Clay Composition (%)',b'Kleisamenstelling (%)'
-b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81',b'Please save before assigning task.',b'Sla op voordat u een taak toewijst.'
-b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74',b'Balance Value',b'Balans Waarde'
-b'DocType: Lab Test',b'Lab Technician',b'Laboratorium technicus'
-b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38',b'Sales Price List',b'Sales Prijslijst'
-b'DocType: Healthcare Settings',"b'If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.'","b'Als gecontroleerd, wordt een klant aangemaakt, aangepast aan Pati\xc3\xabnt. Pati\xc3\xabntfacturen worden aangemaakt tegen deze klant. U kunt ook de bestaande klant selecteren bij het maken van een pati\xc3\xabnt.'"
-b'DocType: Bank Reconciliation',b'Account Currency',b'Account Valuta'
-b'DocType: Lab Test',b'Sample ID',b'Voorbeeld ID'
-b'apps/erpnext/erpnext/accounts/general_ledger.py +167',b'Please mention Round Off Account in Company',b'Vermeld Ronde Off Account in Company'
-b'DocType: Purchase Receipt',b'Range',b'Reeks'
-b'DocType: Supplier',b'Default Payable Accounts',b'Standaard Crediteuren Accounts'
-b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49',b'Employee {0} is not active or does not exist',b'Werknemer {0} is niet actief of bestaat niet'
-b'DocType: Fee Structure',b'Components',b'Components'
-b'DocType: Item Barcode',b'Item Barcode',b'Artikel Barcode'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +329',b'Please enter Asset Category in Item {0}',b'Vul Asset Categorie op post {0}'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +661',b'Item Variants {0} updated',b'Item Varianten {0} bijgewerkt'
-b'DocType: Quality Inspection Reading',b'Reading 6',b'Meting 6'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9',"b'to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field\nof this'","b'gegenereerd worden. Als u vertraagd bent, moet u het veld &#39;Herhalen op dag van maand&#39; handmatig wijzigen'"
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961',b'Cannot {0} {1} {2} without any negative outstanding invoice',b'Kan niet {0} {1} {2} zonder negatieve openstaande factuur'
-b'DocType: Share Transfer',b'From Folio No',b'Van Folio Nee'
-b'DocType: Purchase Invoice Advance',b'Purchase Invoice Advance',b'Inkoopfactuur Voorschot'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199',b'Row {0}: Credit entry can not be linked with a {1}',b'Rij {0}: kan creditering niet worden gekoppeld met een {1}'
-b'apps/erpnext/erpnext/config/accounts.py +246',b'Define budget for a financial year.',b'Definieer budget voor een boekjaar.'
-b'DocType: Lead',b'LEAD-',b'LOOD-'
-b'DocType: Employee',b'Permanent Address Is',b'Vast Adres is'
-b'DocType: Work Order Operation',b'Operation completed for how many finished goods?',b'Operatie afgerond voor hoeveel eindproducten?'
-b'DocType: Payment Terms Template',b'Payment Terms Template',b'Betalingscondities sjabloon'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +51',b'The Brand',b'De Brand'
-b'DocType: Employee',b'Exit Interview Details',b'Exit Gesprek Details'
-b'DocType: Item',b'Is Purchase Item',b'Is inkoopartikel'
-b'DocType: Journal Entry Account',b'Purchase Invoice',b'Inkoopfactuur'
-b'DocType: Stock Ledger Entry',b'Voucher Detail No',b'Voucher Detail nr'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +789',b'New Sales Invoice',b'Nieuwe Sales Invoice'
-b'DocType: Stock Entry',b'Total Outgoing Value',b'Totaal uitgaande waardeoverdrachten'
-b'DocType: Physician',b'Appointments',b'afspraken'
-b'apps/erpnext/erpnext/public/js/account_tree_grid.js +223',b'Opening Date and Closing Date should be within same Fiscal Year',b'Openingsdatum en de uiterste datum moet binnen dezelfde fiscale jaar'
-b'DocType: Lead',b'Request for Information',b'Informatieaanvraag'
-,b'LeaderBoard',b'Scorebord'
-b'DocType: Sales Invoice Item',b'Rate With Margin (Company Currency)',b'Tarief met marge (bedrijfsvaluta)'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +802',b'Sync Offline Invoices',b'Sync Offline Facturen'
-b'DocType: Payment Request',b'Paid',b'Betaald'
-b'DocType: Program Fee',b'Program Fee',b'programma Fee'
-b'DocType: BOM Update Tool',"b'Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.'","b'Vervang een bepaalde BOM in alle andere BOM&#39;s waar het wordt gebruikt. Het zal de oude BOM link vervangen, update kosten en regenereren &quot;BOM Explosion Item&quot; tabel zoals per nieuwe BOM. Ook wordt de laatste prijs bijgewerkt in alle BOM&#39;s.'"
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447',b'The following Work Orders were created:',b'De volgende werkorders zijn gemaakt:'
-b'DocType: Salary Slip',b'Total in words',b'Totaal in woorden'
-b'DocType: Material Request Item',b'Lead Time Date',b'Lead Tijd Datum'
-,b'Employee Advance Summary',b'Medewerker Advance Summary'
-b'DocType: Asset',b'Available-for-use Date',b'Beschikbaar voor gebruik Datum'
-b'DocType: Guardian',b'Guardian Name',b'Naam pleegouder'
-b'DocType: Cheque Print Template',b'Has Print Format',b'Heeft Print Format'
-b'DocType: Employee Loan',b'Sanctioned',b'Sanctioned'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +75',b' is mandatory. Maybe Currency Exchange record is not created for ',b'is verplicht. Misschien is dit Valuta record niet gemaakt voor'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139',b'Row #{0}: Please specify Serial No for Item {1}',b'Rij #{0}: Voer serienummer in voor artikel {1}'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54',b'Supplier &gt; Supplier Type',b'Leverancier&gt; leverancier type'
-b'DocType: Crop Cycle',b'Crop Cycle',b'Crop Cycle'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633',"b""For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.""","b'Voor &#39;Product Bundel&#39; items, Warehouse, Serienummer en Batch Geen zal worden beschouwd van de &#39;Packing List&#39; tafel. Als Warehouse en Batch Geen zijn hetzelfde voor alle verpakking items voor welke &#39;Product Bundle&#39; punt, kunnen die waarden in de belangrijkste Item tafel worden ingevoerd, wordt waarden worden gekopieerd naar &quot;Packing List &#39;tafel.'"
-b'DocType: Student Admission',b'Publish on website',b'Publiceren op de website'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651',b'Supplier Invoice Date cannot be greater than Posting Date',b'Leverancier Factuurdatum kan niet groter zijn dan Posting Date'
-b'DocType: Purchase Invoice Item',b'Purchase Order Item',b'Inkooporder Artikel'
-b'DocType: Agriculture Task',b'Agriculture Task',b'Landbouwtaak'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132',b'Indirect Income',b'Indirecte Inkomsten'
-b'DocType: Student Attendance Tool',b'Student Attendance Tool',b'Student Attendance Tool'
-b'DocType: Restaurant Menu',b'Price List (Auto created)',b'Prijslijst (automatisch aangemaakt)'
-b'DocType: Cheque Print Template',b'Date Settings',b'date Settings'
-b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48',b'Variance',b'Variantie'
-,b'Company Name',b'Bedrijfsnaam'
-b'DocType: SMS Center',b'Total Message(s)',b'Totaal Bericht(en)'
-b'DocType: Share Balance',b'Purchased',b'Gekocht'
-b'DocType: Item Variant Settings',b'Rename Attribute Value in Item Attribute.',b'Kenmerkwaarde in itemkenmerk wijzigen.'
-b'DocType: Purchase Invoice',b'Additional Discount Percentage',b'Extra Korting Procent'
-b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24',b'View a list of all the help videos',b'Bekijk een overzicht van alle hulp video&#39;s'
-b'DocType: Agriculture Analysis Criteria',b'Soil Texture',b'Bodemstructuur'
-b'DocType: Bank Reconciliation',b'Select account head of the bank where cheque was deposited.',b'Selecteer hoofdrekening van de bank waar cheque werd gedeponeerd.'
-b'DocType: Selling Settings',b'Allow user to edit Price List Rate in transactions',b'Zodat de gebruiker te bewerken prijslijst Rate bij transacties'
-b'DocType: Pricing Rule',b'Max Qty',b'Max Aantal'
-b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25',b'Print Report Card',b'Rapportkaart afdrukken'
-b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30',"b'Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \\\n\t\t\t\t\t\tPlease enter a valid Invoice'","b'Rij {0}: Invoice {1} is ongeldig, het zou kunnen worden opgezegd / niet bestaat. \\ Voer een geldige factuur'"
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132',b'Row {0}: Payment against Sales/Purchase Order should always be marked as advance',b'Rij {0}: Betaling tegen Sales / Purchase Order moet altijd worden gemarkeerd als voorschot'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16',b'Chemical',b'Chemisch'
-b'DocType: Salary Component Account',b'Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.',b'Default Bank / Cash account wordt automatisch bijgewerkt in Salaris Journal Entry als deze modus wordt geselecteerd.'
-b'DocType: BOM',b'Raw Material Cost(Company Currency)',b'Grondstofkosten (Company Munt)'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Rij # {0}: De tarief kan niet groter zijn dan de tarief die wordt gebruikt in {1} {2}'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Rij # {0}: De tarief kan niet groter zijn dan de tarief die wordt gebruikt in {1} {2}'
-b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Meter',b'Meter'
-b'DocType: Workstation',b'Electricity Cost',b'elektriciteitskosten'
-b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23',b'Lab testing datetime cannot be before collection datetime',b'Labetesten van datetime kan niet v\xc3\xb3\xc3\xb3r verzameling datetime zijn'
-b'DocType: HR Settings',"b""Don't send Employee Birthday Reminders""",b'Stuur geen Werknemer verjaardagsherinneringen'
-b'DocType: Expense Claim',b'Total Advance Amount',b'Totaal voorschotbedrag'
-b'DocType: Delivery Stop',b'Estimated Arrival',b'Geschatte aankomst'
-b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34',b'Save Settings',b'Instellingen opslaan'
-b'DocType: Delivery Stop',b'Notified by Email',b'Aangemeld per e-mail'
-b'DocType: Item',b'Inspection Criteria',b'Inspectie Criteria'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14',b'Transfered',b'Overgebrachte'
-b'DocType: BOM Website Item',b'BOM Website Item',b'BOM Website Item'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +52',b'Upload your letter head and logo. (you can edit them later).',b'Upload uw brief hoofd en logo. (Je kunt ze later bewerken).'
-b'DocType: Timesheet Detail',b'Bill',b'Bill'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +88',b'Next Depreciation Date is entered as past date',b'Volgende Afschrijvingen Date wordt ingevoerd als datum in het verleden'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208',b'White',b'Wit'
-b'DocType: SMS Center',b'All Lead (Open)',b'Alle Leads (Open)'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270',b'Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3})',b'Rij {0}: Aantal niet beschikbaar voor {4} in het magazijn van {1} op het plaatsen van tijd van de invoer ({2} {3})'
-b'apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18',b'You can only select a maximum of one option from the list of check boxes.',b'U kunt maximaal \xc3\xa9\xc3\xa9n optie selecteren in de lijst met selectievakjes.'
-b'DocType: Purchase Invoice',b'Get Advances Paid',b'Get betaalde voorschotten'
-b'DocType: Item',b'Automatically Create New Batch',b'Maak automatisch een nieuwe partij aan'
-b'DocType: Item',b'Automatically Create New Batch',b'Maak automatisch een nieuwe partij aan'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635',b'Assigning {0} to {1} (row {2})',b'{0} toewijzen aan {1} (rij {2})'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Make ',b'Maken'
-b'DocType: Student Admission',b'Admission Start Date',b'Entree Startdatum'
-b'DocType: Journal Entry',b'Total Amount in Words',b'Totaal bedrag in woorden'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29',b'New Employee',b'Nieuwe medewerker'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7',"b""There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.""",b'Er is een fout opgetreden . Een mogelijke reden zou kunnen zijn dat u het formulier niet hebt opgeslagen. Neem contact op met Support als het probleem aanhoudt .'
-b'apps/erpnext/erpnext/templates/pages/cart.html +5',b'My Cart',b'Mijn winkelwagen'
-b'apps/erpnext/erpnext/controllers/selling_controller.py +130',b'Order Type must be one of {0}',b'Order Type moet \xc3\xa9\xc3\xa9n van {0} zijn'
-b'DocType: Lead',b'Next Contact Date',b'Volgende Contact Datum'
-b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36',b'Opening Qty',b'Opening Aantal'
-b'DocType: Healthcare Settings',b'Appointment Reminder',b'Benoemingsherinnering'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478',b'Please enter Account for Change Amount',b'Vul Account for Change Bedrag'
-b'DocType: Program Enrollment Tool Student',b'Student Batch Name',b'Student batchnaam'
-b'DocType: Consultation',b'Doctor',b'dokter'
-b'DocType: Holiday List',b'Holiday List Name',b'Holiday Lijst Naam'
-b'DocType: Repayment Schedule',b'Balance Loan Amount',b'Balans Leningsbedrag'
-b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14',b'Schedule Course',b'Schedule Course'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236',b'Stock Options',b'Aandelenopties'
-b'DocType: Buying Settings',b'Disable Fetching Last Purchase Details in Purchase Order',b'Schakel het ophalen van de laatste aankoopdetails in de bestelling uit'
-b'DocType: Journal Entry Account',b'Expense Claim',b'Kostendeclaratie'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +267',b'Do you really want to restore this scrapped asset?',b'Wilt u deze schrapte activa echt herstellen?'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381',b'Qty for {0}',b'Aantal voor {0}'
-b'DocType: Leave Application',b'Leave Application',b'Verlofaanvraag'
-b'DocType: Patient',b'Patient Relation',b'Pati\xc3\xabntrelatie'
-b'apps/erpnext/erpnext/config/hr.py +80',b'Leave Allocation Tool',b'Verlof Toewijzing Tool'
-b'DocType: Item',b'Hub Category to Publish',b'Hubcategorie om te publiceren'
-b'DocType: Leave Block List',b'Leave Block List Dates',b'Laat Block List Data'
-b'DocType: Sales Invoice',b'Billing Address GSTIN',b'Factuuradres GSTIN'
-b'DocType: Assessment Plan',b'Evaluate',b'schatten'
-b'DocType: Workstation',b'Net Hour Rate',b'Netto uurtarief'
-b'DocType: Landed Cost Purchase Receipt',b'Landed Cost Purchase Receipt',b'Vrachtkosten Inkoop Ontvangstbewijs'
-b'DocType: Company',b'Default Terms',b'Default Voorwaarden'
-b'DocType: Supplier Scorecard Period',b'Criteria',b'criteria'
-b'DocType: Packing Slip Item',b'Packing Slip Item',b'Pakbon Artikel'
-b'DocType: Purchase Invoice',b'Cash/Bank Account',b'Kas/Bankrekening'
-b'apps/erpnext/erpnext/public/js/queries.js +96',b'Please specify a {0}',b'Geef een {0}'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73',b'Removed items with no change in quantity or value.',b'Verwijderde items met geen verandering in de hoeveelheid of waarde.'
-b'DocType: Delivery Note',b'Delivery To',b'Leveren Aan'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +415',b'Variant creation has been queued.',b'Het maken van varianten is in de wachtrij geplaatst.'
-b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100',b'Work Summary for {0}',b'Werkoverzicht voor {0}'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +696',b'Attribute table is mandatory',b'Attributentabel is verplicht'
-b'DocType: Production Plan',b'Get Sales Orders',b'Get Verkooporders'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68',b'{0} can not be negative',b'{0} kan niet negatief zijn'
-b'DocType: Training Event',b'Self-Study',b'Zelfstudie'
-b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27',b'Soil compositions do not add up to 100',b'Bodemsamenstellingen tellen niet op tot 100'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558',b'Discount',b'Korting'
-b'DocType: Membership',b'Membership',b'Lidmaatschap'
-b'DocType: Asset',b'Total Number of Depreciations',b'Totaal aantal Afschrijvingen'
-b'DocType: Sales Invoice Item',b'Rate With Margin',b'Beoordeel met marges'
-b'DocType: Workstation',b'Wages',b'Loon'
-b'DocType: Asset Maintenance',b'Maintenance Manager Name',b'Naam onderhoudsmanager'
-b'DocType: Agriculture Task',b'Urgent',b'Dringend'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174',b'Please specify a valid Row ID for row {0} in table {1}',b'Geef een geldige rij-ID voor rij {0} in tabel {1}'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84',b'Unable to find variable: ',b'Kan variabele niet vinden:'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +794',b'Please select a field to edit from numpad',b'Selecteer alstublieft een veld om van numpad te bewerken'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +264',b'Cannot be a fixed asset item as Stock Ledger is created.',b'Kan geen vast activumartikel zijn omdat het grootboek Voorraad wordt gecre\xc3\xaberd.'
-b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23',b'Go to the Desktop and start using ERPNext',b'Ga naar het bureaublad om aan de slag te gaan met ERPNext'
-b'DocType: Item',b'Manufacturer',b'Fabrikant'
-b'DocType: Landed Cost Item',b'Purchase Receipt Item',b'Ontvangstbevestiging Artikel'
-b'DocType: Purchase Receipt',b'PREC-RET-',b'PREC-terugwerkende'
-b'DocType: POS Profile',b'Sales Invoice Payment',b'Sales Invoice Betaling'
-b'DocType: Quality Inspection Template',b'Quality Inspection Template Name',b'Kwaliteit inspectiesjabloon naam'
-b'DocType: Project',b'First Email',b'Eerste e-mail'
-b'DocType: Production Plan Item',b'Reserved Warehouse in Sales Order / Finished Goods Warehouse',b'Gereserveerd Magazijn in Verkooporder / Magazijn Gereed Product'
-b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71',b'Selling Amount',b'Selling Bedrag'
-b'DocType: Repayment Schedule',b'Interest Amount',b'Interestbedrag'
-b'DocType: Serial No',b'Creation Document No',b'Aanmaken Document nr'
-b'DocType: Share Transfer',b'Issue',b'Kwestie'
-b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11',b'Records',b'archief'
-b'DocType: Asset',b'Scrapped',b'gesloopt'
-b'DocType: Purchase Invoice',b'Returns',b'opbrengst'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42',b'WIP Warehouse',b'WIP Warehouse'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195',b'Serial No {0} is under maintenance contract upto {1}',b'Serienummer {0} valt binnen onderhoudscontract tot {1}'
-b'apps/erpnext/erpnext/config/hr.py +35',b'Recruitment',b'Werving'
-b'DocType: Lead',b'Organization Name',b'Naam van de Organisatie'
-b'DocType: Tax Rule',b'Shipping State',b'Scheepvaart State'
-,b'Projected Quantity as Source',b'Geprojecteerd Hoeveelheid als Bron'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61',"b""Item must be added using 'Get Items from Purchase Receipts' button""","b""Het punt moet worden toegevoegd met behulp van 'Get Items uit Aankoopfacturen' knop"""
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858',b'Delivery Trip',b'Levering reis'
-b'DocType: Student',b'A-',b'A-'
-b'DocType: Share Transfer',b'Transfer Type',b'Overdrachtstype'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117',b'Sales Expenses',b'Verkoopkosten'
-b'DocType: Consultation',b'Diagnosis',b'Diagnose'
-b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18',b'Standard Buying',b'Standard kopen'
-b'DocType: GL Entry',b'Against',b'Tegen'
-b'DocType: Item',b'Default Selling Cost Center',b'Standaard Verkoop kostenplaats'
-b'apps/erpnext/erpnext/public/js/pos/pos.html +85',b'Disc',b'Schijf'
-b'DocType: Sales Partner',b'Implementation Partner',b'Implementatie Partner'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1624',b'ZIP Code',b'Postcode'
-b'apps/erpnext/erpnext/controllers/selling_controller.py +252',b'Sales Order {0} is {1}',b'Sales Order {0} is {1}'
-b'DocType: Opportunity',b'Contact Info',b'Contact Info'
-b'apps/erpnext/erpnext/config/stock.py +319',b'Making Stock Entries',b'Maken Stock Inzendingen'
-b'DocType: Packing Slip',b'Net Weight UOM',b'Netto Gewicht Eenheid'
-b'DocType: Item',b'Default Supplier',b'Standaardleverancier'
-b'DocType: Manufacturing Settings',b'Over Production Allowance Percentage',b'Over Production Allowance Percentage'
-b'DocType: Employee Loan',b'Repayment Schedule',b'Terugbetalingsschema'
-b'DocType: Shipping Rule Condition',b'Shipping Rule Condition',b'Verzendregel Voorwaarde'
-b'DocType: Holiday List',b'Get Weekly Off Dates',b'Ontvang wekelijkse Uit Data'
-b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33',b'End Date can not be less than Start Date',b'Einddatum kan niet vroeger zijn dan startdatum'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337',"b""Invoice can't be made for zero billing hour""",b'De factuur kan niet worden gemaakt voor uren facturering'
-b'DocType: Sales Person',b'Select company name first.',b'Kies eerst een bedrijfsnaam.'
-b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189',b'Email sent to {0}',b'E-mail verzonden naar {0}'
-b'apps/erpnext/erpnext/config/buying.py +23',b'Quotations received from Suppliers.',b'Offertes ontvangen van leveranciers.'
-b'apps/erpnext/erpnext/config/manufacturing.py +74',b'Replace BOM and update latest price in all BOMs',b'Vervang BOM en update de laatste prijs in alle BOM&#39;s'
-b'apps/erpnext/erpnext/controllers/selling_controller.py +27',b'To {0} | {1} {2}',b'Naar {0} | {1} {2}'
-b'DocType: Delivery Trip',b'Driver Name',b'Naam van de bestuurder'
-b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40',b'Average Age',b'Gemiddelde Leeftijd'
-b'DocType: Education Settings',b'Attendance Freeze Date',b'Bijwonen Vries Datum'
-b'DocType: Education Settings',b'Attendance Freeze Date',b'Bijwonen Vries Datum'
-b'apps/erpnext/erpnext/utilities/user_progress.py +110',b'List a few of your suppliers. They could be organizations or individuals.',b'Lijst een paar van uw leveranciers . Ze kunnen organisaties of personen .'
-b'apps/erpnext/erpnext/templates/pages/home.html +31',b'View All Products',b'Bekijk alle producten'
-b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimum leeftijd (dagen)'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60',b'All BOMs',b'alle stuklijsten'
-b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35',b'Hotel Rooms of type {0} are unavailable on {1}',b'Hotelkamers van het type {0} zijn niet beschikbaar op {1}'
-b'DocType: Patient',b'Default Currency',b'Standaard valuta'
-b'DocType: Expense Claim',b'From Employee',b'Van Medewerker'
-b'DocType: Driver',b'Cellphone Number',b'mobiel nummer'
-b'DocType: Project',b'Monitor Progress',b'Voortgang in de gaten houden'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +472',b'Warning: System will not check overbilling since amount for Item {0} in {1} is zero',b'Waarschuwing: Het systeem zal niet controleren overbilling sinds bedrag voor post {0} in {1} nul'
-b'DocType: Journal Entry',b'Make Difference Entry',b'Maak Verschil Entry'
-b'DocType: Upload Attendance',b'Attendance From Date',b'Aanwezigheid Van Datum'
-b'DocType: Appraisal Template Goal',b'Key Performance Area',b'Key Performance Area'
-b'DocType: Program Enrollment',b'Transportation',b'Vervoer'
-b'apps/erpnext/erpnext/controllers/item_variant.py +94',b'Invalid Attribute',b'ongeldige attribuut'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240',b'{0} {1} must be submitted',b'{0} {1} moet worden ingediend'
-b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159',b'Quantity must be less than or equal to {0}',b'Hoeveelheid moet kleiner dan of gelijk aan {0}'
-b'DocType: SMS Center',b'Total Characters',b'Totaal Tekens'
-b'DocType: Employee Advance',b'Claimed',b'beweerde'
-b'DocType: Crop',b'Row Spacing',b'Rijafstand'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +164',b'Please select BOM in BOM field for Item {0}',b'Selecteer BOM in BOM veld voor post {0}'
-b'DocType: C-Form Invoice Detail',b'C-Form Invoice Detail',b'C-Form Factuurspecificatie'
-b'DocType: Payment Reconciliation Invoice',b'Payment Reconciliation Invoice',b'Afletteren Factuur'
-b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38',b'Contribution %',b'Bijdrage %'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215',"b""As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}""","b""Conform de Aankoop Instellingen indien Aankoop Order Vereist == 'JA', dient de gebruiker eerst een Aankoop Order voor item {0} aan te maken om een Aankoop Factuur aan te kunnen maken"""
-b'DocType: Company',b'Company registration numbers for your reference. Tax numbers etc.',"b'Registratienummers van de onderneming voor uw referentie. Fiscale nummers, enz.'"
-b'DocType: Sales Partner',b'Distributor',b'Distributeur'
-b'DocType: Shopping Cart Shipping Rule',b'Shopping Cart Shipping Rule',b'Winkelwagen Verzenden Regel'
-b'apps/erpnext/erpnext/public/js/controllers/transaction.js +71',"b""Please set 'Apply Additional Discount On'""",b'Stel &#39;Solliciteer Extra Korting op&#39;'
-,b'Ordered Items To Be Billed',b'Bestelde artikelen te factureren'
-b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46',b'From Range has to be less than To Range',b'Van Range moet kleiner zijn dan om het bereik'
-b'DocType: Global Defaults',b'Global Defaults',b'Global Standaardwaarden'
-b'apps/erpnext/erpnext/projects/doctype/project/project.py +230',b'Project Collaboration Invitation',b'Project Uitnodiging Collaboration'
-b'DocType: Salary Slip',b'Deductions',b'Inhoudingen'
-b'DocType: Leave Allocation',b'LAL/',b'LAL /'
-b'DocType: Setup Progress Action',b'Action Name',b'Actie Naam'
-b'apps/erpnext/erpnext/public/js/financial_statements.js +75',b'Start Year',b'Start Jaar'
-b'apps/erpnext/erpnext/regional/india/utils.py +25',b'First 2 digits of GSTIN should match with State number {0}',b'De eerste 2 cijfers van GSTIN moeten overeenkomen met staat nummer {0}'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68',b'PDC/LC',b'PDC / LC'
-b'DocType: Purchase Invoice',"b""Start date of current invoice's period""",b'Begindatum van de huidige factuurperiode'
-b'DocType: Salary Slip',b'Leave Without Pay',b'Onbetaald verlof'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385',b'Capacity Planning Error',b'Capacity Planning Fout'
-,b'Trial Balance for Party',b'Trial Balance voor Party'
-b'DocType: Lead',b'Consultant',b'Consultant'
-b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356',b'Parents Teacher Meeting Attendance',b'Ouders Teacher Meeting presentielijst'
-b'DocType: Salary Slip',b'Earnings',b'Verdiensten'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +441',b'Finished Item {0} must be entered for Manufacture type entry',b'Afgewerkte product {0} moet worden ingevoerd voor het type Productie binnenkomst'
-b'apps/erpnext/erpnext/config/learn.py +87',b'Opening Accounting Balance',b'Het openen van Accounting Balance'
-,b'GST Sales Register',b'GST Sales Register'
-b'DocType: Sales Invoice Advance',b'Sales Invoice Advance',b'Verkoopfactuur Voorschot'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552',b'Nothing to request',b'Niets aan te vragen'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +18',b'Select your Domains',b'Selecteer uw domeinen'
-b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34',"b""Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3}""",b'Een andere Budget plaat &#39;{0}&#39; bestaat al tegen {1} {2} &#39;voor het fiscale jaar {3}'
-b'DocType: Item Variant Settings',b'Fields will be copied over only at time of creation.',b'Velden worden alleen gekopieerd op het moment van creatie.'
-b'DocType: Setup Progress Action',b'Domains',b'Domeinen'
-b'apps/erpnext/erpnext/projects/doctype/task/task.py +41',"b""'Actual Start Date' can not be greater than 'Actual End Date'""","b""'Werkelijke Startdatum' kan niet groter zijn dan 'Werkelijke Einddatum'"""
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117',b'Management',b'Beheer'
-b'DocType: Cheque Print Template',b'Payer Settings',b'Payer Instellingen'
-b'DocType: Item Attribute Value',"b'This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""'","b'Dit zal worden toegevoegd aan de Code van het punt van de variant. Bijvoorbeeld, als je de afkorting is ""SM"", en de artikelcode is ""T-SHIRT"", de artikelcode van de variant zal worden ""T-SHIRT-SM""'"
-b'DocType: Salary Slip',b'Net Pay (in words) will be visible once you save the Salary Slip.',b'Nettoloon (in woorden) zal zichtbaar zijn zodra de Salarisstrook wordt opgeslagen.'
-b'DocType: Purchase Invoice',b'Is Return',b'Is Return'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',b'Caution',b'Voorzichtigheid'
-b'apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17',"b""Start day is greater than end day in task '{0}'""",b'Startdag is groter dan einddag in taak &#39;{0}&#39;'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815',b'Return / Debit Note',b'Return / betaalkaart Note'
-b'DocType: Price List Country',b'Price List Country',b'Prijslijst Land'
-b'DocType: Item',b'UOMs',b'UOMs'
-b'apps/erpnext/erpnext/stock/utils.py +212',b'{0} valid serial nos for Item {1}',b'{0} geldig serienummers voor Artikel {1}'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57',b'Item Code cannot be changed for Serial No.',b'Artikelcode kan niet worden gewijzigd voor Serienummer'
-b'DocType: Purchase Invoice Item',b'UOM Conversion Factor',b'Eenheid Omrekeningsfactor'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40',b'Please enter Item Code to get Batch Number',b'Vul de artikelcode voor Batch Number krijgen'
-b'DocType: Stock Settings',b'Default Item Group',b'Standaard Artikelgroep'
-b'DocType: Employee Loan',b'Partially Disbursed',b'gedeeltelijk uitbetaald'
-b'apps/erpnext/erpnext/config/non_profit.py +73',b'Grant information.',b'Informatie verstrekken.'
-b'apps/erpnext/erpnext/config/buying.py +38',b'Supplier database.',b'Leverancierbestand'
-b'DocType: Account',b'Balance Sheet',b'Balans'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750',"b""Cost Center For Item with Item Code '""","b""Kostenplaats Item met Item Code '"""
-b'DocType: Fee Validity',b'Valid Till',b'Geldig tot'
-b'DocType: Student Report Generation Tool',b'Total Parents Teacher Meeting',b'Totale ouder lerarenbijeenkomst'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2516',"b'Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.'","b'Betaling Mode is niet geconfigureerd. Controleer, of rekening is ingesteld op de wijze van betalingen of op POS Profile.'"
-b'apps/erpnext/erpnext/buying/utils.py +74',b'Same item cannot be entered multiple times.',b'Hetzelfde item kan niet meerdere keren worden ingevoerd.'
-b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30',"b'Further accounts can be made under Groups, but entries can be made against non-Groups'","b'Verdere accounts kan worden gemaakt onder groepen, maar items kunnen worden gemaakt tegen niet-Groepen'"
-b'DocType: Lead',b'Lead',b'Lead'
-b'DocType: Email Digest',b'Payables',b'Schulden'
-b'DocType: Course',b'Course Intro',b'cursus Intro'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +105',b'Stock Entry {0} created',b'Stock Entry {0} aangemaakt'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +306',b'Row #{0}: Rejected Qty can not be entered in Purchase Return',b'Rij # {0}: Afgekeurd Aantal niet in Purchase Return kunnen worden ingevoerd'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +182',b'Changing Customer Group for the selected Customer is not allowed.',b'Het wijzigen van de klantengroep voor de geselecteerde klant is niet toegestaan.'
-,b'Purchase Order Items To Be Billed',b'Inkooporder Artikelen nog te factureren'
-b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63',b'Updating estimated arrival times.',b'Bijwerken geschatte aankomsttijden.'
-b'DocType: Program Enrollment Tool',b'Enrollment Details',b'Inschrijfgegevens'
-b'DocType: Purchase Invoice Item',b'Net Rate',b'Net Rate'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152',b'Please select a customer',b'Selecteer een klant alsjeblieft'
-b'DocType: Purchase Invoice Item',b'Purchase Invoice Item',b'Inkoopfactuur Artikel'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58',b'Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts',b'Voorraad boekingen en Journaalposten worden opnieuw geboekt voor de geselecteerde Ontvangstbewijzen'
-b'DocType: Student Report Generation Tool',b'Assessment Terms',b'Beoordelingsvoorwaarden'
-b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8',b'Item 1',b'Punt 1'
-b'DocType: Holiday',b'Holiday',b'Feestdag'
-b'DocType: Support Settings',b'Close Issue After Days',b'Sluiten Probleem Na Days'
-b'DocType: Leave Control Panel',b'Leave blank if considered for all branches',b'Laat leeg indien dit voor alle vestigingen is'
-b'DocType: Bank Guarantee',b'Validity in Days',b'Geldigheid in dagen'
-b'DocType: Bank Guarantee',b'Validity in Days',b'Geldigheid in dagen'
-b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21',b'C-form is not applicable for Invoice: {0}',b'C-vorm is niet van toepassing voor de factuur: {0}'
-b'DocType: Payment Reconciliation',b'Unreconciled Payment Details',b'Niet overeenstemmende betalingsgegevens'
-b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6',b'Member Activity',b'Ledenactiviteit'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Order Count'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Order Count'
-b'DocType: Global Defaults',b'Current Fiscal Year',b'Huidige fiscale jaar'
-b'DocType: Purchase Order',b'Group same items',b'Groep dezelfde items'
-b'DocType: Purchase Invoice',b'Disable Rounded Total',b'Deactiveer Afgerond Totaal'
-b'DocType: Employee Loan Application',b'Repayment Info',b'terugbetaling Info'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448',"b""'Entries' cannot be empty""","b""'Invoer' kan niet leeg zijn"""
-b'DocType: Maintenance Team Member',b'Maintenance Role',b'Onderhoudsrol'
-b'apps/erpnext/erpnext/utilities/transaction_base.py +92',b'Duplicate row {0} with same {1}',b'Dubbele rij {0} met dezelfde {1}'
-,b'Trial Balance',b'Proefbalans'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443',b'Fiscal Year {0} not found',b'Boekjaar {0} niet gevonden'
-b'apps/erpnext/erpnext/config/hr.py +309',b'Setting up Employees',b'Het opzetten van Werknemers'
-b'DocType: Sales Order',b'SO-',b'ZO-'
-b'DocType: Hotel Room Reservation',b'Hotel Reservation User',b'Hotelreservering Gebruiker'
-b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158',b'Please select prefix first',b'Selecteer eerst een voorvoegsel'
-b'DocType: Student',b'O-',b'O-'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189',b'Research',b'onderzoek'
-b'DocType: Maintenance Visit Purpose',b'Work Done',b'Afgerond Werk'
-b'apps/erpnext/erpnext/controllers/item_variant.py +35',b'Please specify at least one attribute in the Attributes table',b'Gelieve ten minste \xc3\xa9\xc3\xa9n attribuut in de tabel attributen opgeven'
-b'DocType: Announcement',b'All Students',b'Alle studenten'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +45',b'Item {0} must be a non-stock item',b'Item {0} moet een niet-voorraad artikel zijn'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +18',b'View Ledger',b'Bekijk Grootboek'
-b'DocType: Grading Scale',b'Intervals',b'intervallen'
-b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Earliest',b'Vroegst'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +526',"b'An Item Group exists with same name, please change the item name or rename the item group'","b'Een artikel Group bestaat met dezelfde naam , moet u de naam van het item of de naam van de artikelgroep'"
-b'DocType: Crop Cycle',b'Less than a year',b'Minder dan een jaar'
-b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52',b'Student Mobile No.',b'Student Mobile No.'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105',b'Rest Of The World',b'Rest van de Wereld'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81',b'The Item {0} cannot have Batch',b'De Punt {0} kan niet Batch hebben'
-b'DocType: Crop',b'Yield UOM',b'Opbrengst UOM'
-,b'Budget Variance Report',b'Budget Variantie Rapport'
-b'DocType: Salary Slip',b'Gross Pay',b'Brutoloon'
-b'DocType: Item',b'Is Item from Hub',b'Is item van Hub'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118',b'Row {0}: Activity Type is mandatory.',b'Rij {0}: Activiteit Type is verplicht.'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166',b'Dividends Paid',b'Dividenden betaald'
-b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36',b'Accounting Ledger',b'Boekhoudboek'
-b'DocType: Stock Reconciliation',b'Difference Amount',b'Verschil Bedrag'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107',b'Dr {0} on Leave on {1}',b'Dr {0} bij Verlof op {1}'
-b'DocType: Purchase Invoice',b'Reverse Charge',b'Reverse Charge'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172',b'Retained Earnings',b'Ingehouden winsten'
-b'DocType: Purchase Invoice',b'05-Change in POS',b'05-Verandering in POS'
-b'DocType: Vehicle Log',b'Service Detail',b'dienst Detail'
-b'DocType: BOM',b'Item Description',b'Artikelomschrijving'
-b'DocType: Student Sibling',b'Student Sibling',b'student Sibling'
-b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18',b'Payment Mode',b'Betaling Mode'
-b'DocType: Purchase Invoice',b'Supplied Items',b'Geleverde Artikelen'
-b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85',b'Please set an active menu for Restaurant {0}',b'Stel een actief menu in voor Restaurant {0}'
-b'DocType: Student',b'STUD.',b'Stud.'
-b'DocType: Work Order',b'Qty To Manufacture',b'Aantal te produceren'
-b'DocType: Email Digest',b'New Income',b'nieuwe Inkomen'
-b'DocType: Buying Settings',b'Maintain same rate throughout purchase cycle',b'Handhaaf zelfde tarief gedurende inkoopcyclus'
-b'DocType: Opportunity Item',b'Opportunity Item',b'Opportuniteit artikel'
-,b'Student and Guardian Contact Details',b'Student and Guardian Contactgegevens'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53',b'Row {0}: For supplier {0} Email Address is required to send email',b'Rij {0}: Voor leveranciers {0} e-mailadres is vereist om e-mail te sturen'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72',b'Temporary Opening',b'Tijdelijke Opening'
-b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10',b'View Hub',b'Hub bekijken'
-,b'Employee Leave Balance',b'Werknemer Verlof Balans'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147',b'Balance for Account {0} must always be {1}',b'Saldo van rekening {0} moet altijd {1} zijn'
-b'DocType: Patient Appointment',b'More Info',b'Meer info'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180',b'Valuation Rate required for Item in row {0}',b'Valuation Rate vereist voor post in rij {0}'
-b'DocType: Supplier Scorecard',b'Scorecard Actions',b'Scorecard Acties'
-b'apps/erpnext/erpnext/utilities/user_progress.py +169',b'Example: Masters in Computer Science',b'Voorbeeld: Masters in Computer Science'
-b'DocType: Purchase Invoice',b'Rejected Warehouse',b'Afgewezen Magazijn'
-b'DocType: GL Entry',b'Against Voucher',b'Tegen Voucher'
-b'DocType: Item',b'Default Buying Cost Center',b'Standaard Inkoop kostenplaats'
-b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6',"b'To get the best out of ERPNext, we recommend that you take some time and watch these help videos.'","b'Om het beste uit ERPNext krijgen, raden wij u aan wat tijd te nemen en te kijken deze hulp video&#39;s.'"
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +76',b' to ',b'naar'
-b'DocType: Supplier Quotation Item',b'Lead Time in days',b'Levertijd in dagen'
-b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70',b'Accounts Payable Summary',b'Crediteuren Samenvatting'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326',b'Payment of salary from {0} to {1}',b'De betaling van het salaris van {0} tot {1}'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213',b'Not authorized to edit frozen Account {0}',b'Niet bevoegd om bevroren rekening te bewerken {0}'
-b'DocType: Journal Entry',b'Get Outstanding Invoices',b'Get openstaande facturen'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84',b'Sales Order {0} is not valid',b'Verkooporder {0} is niet geldig'
-b'DocType: Supplier Scorecard',b'Warn for new Request for Quotations',b'Waarschuw voor nieuw verzoek om offertes'
-b'apps/erpnext/erpnext/utilities/activation.py +91',b'Purchase orders help you plan and follow up on your purchases',b'Inkooporders helpen bij het plannen en opvolgen van uw aankopen'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151',b'Lab Test Prescriptions',b'Lab Test Prescriptions'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166',b'The total Issue / Transfer quantity {0} in Material Request {1}  \\\n\t\t\t\t\t\t\tcannot be greater than requested quantity {2} for Item {3}',b'De totale Issue / Transfer hoeveelheid {0} in Materiaal Request {1} \\ kan niet groter zijn dan de gevraagde hoeveelheid {2} voor post zijn {3}'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197',b'Small',b'Klein'
-b'DocType: Opening Invoice Creation Tool Item',b'Opening Invoice Creation Tool Item',b'Het item voor het cre\xc3\xabren van facturen openen'
-b'DocType: Education Settings',b'Employee Number',b'Werknemer Nummer'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67',b'Case No(s) already in use. Try from Case No {0}',b'Zaak nr. ( s ) al in gebruik. Probeer uit Zaak nr. {0}'
-b'DocType: Project',b'% Completed',b'% Voltooid'
-,b'Invoiced Amount (Exculsive Tax)',b'Factuurbedrag (excl BTW)'
-b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14',b'Item 2',b'Punt 2'
-b'DocType: Supplier',b'SUPP-',b'SUPP-'
-b'DocType: Training Event',b'Training Event',b'training Event'
-b'DocType: Item',b'Auto re-order',b'Auto re-order'
-b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59',b'Total Achieved',b'Totaal Bereikt'
-b'DocType: Employee',b'Place of Issue',b'Plaats van uitgifte'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101',b'Contract',b'Contract'
-b'DocType: Plant Analysis',b'Laboratory Testing Datetime',b'Laboratoriumtest Datetime'
-b'DocType: Email Digest',b'Add Quote',b'Quote voegen'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +987',b'UOM coversion factor required for UOM: {0} in Item: {1}',b'Eenheid Omrekeningsfactor is nodig voor eenheid: {0} in Artikel: {1}'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92',b'Indirect Expenses',b'Indirecte Kosten'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98',b'Row {0}: Qty is mandatory',b'Rij {0}: Aantal is verplicht'
-b'DocType: Agriculture Analysis Criteria',b'Agriculture',b'landbouw'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +794',b'Sync Master Data',b'Sync Master Data'
-b'DocType: Asset Repair',b'Repair Cost',b'reparatiekosten'
-b'apps/erpnext/erpnext/utilities/user_progress.py +138',b'Your Products or Services',b'Uw producten of diensten'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15',b'Failed to login',b'Inloggen mislukt'
-b'DocType: Special Test Items',b'Special Test Items',b'Speciale testartikelen'
-b'DocType: Mode of Payment',b'Mode of Payment',b'Wijze van betaling'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +202',b'Website Image should be a public file or website URL',b'Website Afbeelding moet een openbaar bestand of website URL zijn'
-b'DocType: Student Applicant',b'AP',b'AP'
-b'DocType: Purchase Invoice Item',b'BOM',b'BOM'
-b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37',b'This is a root item group and cannot be edited.',b'Dit is een basis artikelgroep en kan niet worden bewerkt .'
-b'DocType: Journal Entry Account',b'Purchase Order',b'Inkooporder'
-b'DocType: Vehicle',b'Fuel UOM',b'Fuel UOM'
-b'DocType: Warehouse',b'Warehouse Contact Info',b'Magazijn Contact Info'
-b'DocType: Payment Entry',b'Write Off Difference Amount',b'Schrijf Off Verschil Bedrag'
-b'DocType: Volunteer',b'Volunteer Name',b'Vrijwilligers naam'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434',"b'{0}: Employee email not found, hence email not sent'","b'{0}: Employee e-mail niet gevonden, dus geen e-mail verzonden'"
-b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85',b'Shipping rule not applicable for country {0}',b'Verzendregel niet van toepassing voor land {0}'
-b'DocType: Item',b'Foreign Trade Details',b'Buitenlandse Handel Details'
-,b'Assessment Plan Status',b'Beoordelingsplan Status'
-b'DocType: Email Digest',b'Annual Income',b'Jaarlijks inkomen'
-b'DocType: Serial No',b'Serial No Details',b'Serienummer Details'
-b'DocType: Purchase Invoice Item',b'Item Tax Rate',b'Artikel BTW-tarief'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89',b'Please select Physician and Date',b'Selecteer alsjeblieft arts en datum'
-b'DocType: Student Group Student',b'Group Roll Number',b'Groepsrolnummer'
-b'DocType: Student Group Student',b'Group Roll Number',b'Groepsrolnummer'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145',"b'For {0}, only credit accounts can be linked against another debit entry'","b'Voor {0}, kan alleen credit accounts worden gekoppeld tegen een andere debetboeking'"
-b'apps/erpnext/erpnext/projects/doctype/project/project.py +84',b'Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly',b'Totaal van alle taak gewichten moeten 1. Pas gewichten van alle Project taken dienovereenkomstig'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588',b'Delivery Note {0} is not submitted',b'Vrachtbrief {0} is niet ingediend'
-b'apps/erpnext/erpnext/stock/get_item_details.py +148',b'Item {0} must be a Sub-contracted Item',b'Artikel {0} moet een uitbesteed artikel zijn'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43',b'Capital Equipments',b'Kapitaalgoederen'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33',"b""Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.""","b""Prijsbepalingsregel wordt eerst geselecteerd op basis van 'Toepassen op' veld, dat kan zijn artikel, artikelgroep of merk."""
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246',b'Please set the Item Code first',b'Stel eerst de productcode in'
-b'DocType: Item',b'ITEM-',b'ITEM-'
-b'apps/erpnext/erpnext/controllers/selling_controller.py +123',b'Total allocated percentage for sales team should be 100',b'Totaal toegewezen percentage voor verkoopteam moet 100 zijn'
-b'DocType: Sales Invoice Item',b'Edit Description',b'Bewerken Beschrijving'
-b'DocType: Antibiotic',b'Antibiotic',b'Antibioticum'
-,b'Team Updates',b'team updates'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912',b'For Supplier',b'voor Leverancier'
-b'DocType: Account',b'Setting Account Type helps in selecting this Account in transactions.',b'Instellen Account Type helpt bij het selecteren van deze account in transacties.'
-b'DocType: Purchase Invoice',b'Grand Total (Company Currency)',b'Grand Total (Company Munt)'
-b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Create Print Format',b'Maak Print Format'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5',b'Fee Created',b'Fee gemaakt'
-b'apps/erpnext/erpnext/utilities/bot.py +39',b'Did not find any item called {0}',b'Item met de naam {0} niet gevonden'
-b'DocType: Supplier Scorecard Criteria',b'Criteria Formula',b'Criteria Formule'
-b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Total Outgoing',b'Totaal Uitgaande'
-b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39',"b'There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""'","b'Er kan maar \xc3\xa9\xc3\xa9n Verzendregel Voorwaarde met 0 of blanco waarde zijn voor ""To Value ""'"
-b'DocType: Authorization Rule',b'Transaction',b'Transactie'
-b'DocType: Patient Appointment',b'Duration',b'Looptijd'
-b'apps/erpnext/erpnext/controllers/status_updater.py +160',"b'For an item {0}, quantity must be positive number'",b'Voor een artikel {0} moet het aantal positief zijn'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27',b'Note: This Cost Center is a Group. Cannot make accounting entries against groups.',b'Opmerking: Deze kostenplaats is een groep. Kan geen boekingen aanmaken voor groepen.'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53',b'Child warehouse exists for this warehouse. You can not delete this warehouse.',b'Child magazijn bestaat voor dit magazijn. U kunt dit magazijn niet verwijderen.'
-b'DocType: Item',b'Website Item Groups',b'Website Artikelgroepen'
-b'DocType: Purchase Invoice',b'Total (Company Currency)',b'Totaal (Company valuta)'
-b'DocType: Daily Work Summary Group',b'Reminder',b'Herinnering'
-b'apps/erpnext/erpnext/stock/utils.py +207',b'Serial number {0} entered more than once',b'Serienummer {0} meer dan eens ingevoerd'
-b'DocType: Journal Entry',b'Journal Entry',b'Journaalpost'
-b'DocType: Expense Claim Advance',b'Unclaimed amount',b'Niet-opge\xc3\xabist bedrag'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148',b'{0} items in progress',b'{0} items in progress'
-b'DocType: Workstation',b'Workstation Name',b'Naam van werkstation'
-b'DocType: Grading Scale Interval',b'Grade Code',b'Grade Code'
-b'DocType: POS Item Group',b'POS Item Group',b'POS Item Group'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17',b'Email Digest:',b'E-mail Digest:'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613',b'BOM {0} does not belong to Item {1}',b'Stuklijst {0} behoort niet tot Artikel {1}'
-b'DocType: Sales Partner',b'Target Distribution',b'Doel Distributie'
-b'DocType: Purchase Invoice',b'06-Finalization of Provisional assessment',b'06-Finalisatie van voorlopige beoordeling'
-b'DocType: Salary Slip',b'Bank Account No.',b'Bankrekeningnummer'
-b'DocType: Naming Series',b'This is the number of the last created transaction with this prefix',b'Dit is het nummer van de laatst gemaakte transactie met dit voorvoegsel'
-b'DocType: Supplier Scorecard',"b'Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n'","b'Scorecard variabelen kunnen worden gebruikt, evenals: {total_score} (de totale score van die periode), {period_number} (het aantal dagen dat de dag is)'"
-b'DocType: Quality Inspection Reading',b'Reading 8',b'Meting 8'
-b'DocType: Sales Partner',b'Agent',b'Agent'
-b'DocType: Purchase Invoice',b'Taxes and Charges Calculation',b'Belastingen en Toeslagen berekenen'
-b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Automatische afschrijving van de activa van de boekwaarde'
-b'DocType: BOM Operation',b'Workstation',b'Werkstation'
-b'DocType: Request for Quotation Supplier',b'Request for Quotation Supplier',b'Offerte Supplier'
-b'DocType: Healthcare Settings',b'Registration Message',b'Registratie Bericht'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154',b'Hardware',b'hardware'
-b'DocType: Prescription Dosage',b'Prescription Dosage',b'Voorschrift Dosering'
-b'DocType: Attendance',b'HR Manager',b'HR Manager'
-b'apps/erpnext/erpnext/accounts/party.py +175',b'Please select a Company',b'Selecteer aub een andere vennootschap'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92',b'Privilege Leave',b'Bijzonder Verlof'
-b'DocType: Purchase Invoice',b'Supplier Invoice Date',b'Factuurdatum Leverancier'
-b'DocType: Asset Settings',b'This value is used for pro-rata temporis calculation',b'Deze waarde wordt gebruikt voor pro-rata temporisberekening'
-b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90',b'You need to enable Shopping Cart',b'U moet Winkelwagen activeren.'
-b'DocType: Payment Entry',b'Writeoff',b'Afschrijven'
-b'DocType: Stock Settings',b'Naming Series Prefix',b'Reeks voorvoegsel naamgeving'
-b'DocType: Appraisal Template Goal',b'Appraisal Template Goal',b'Beoordeling Sjabloon Doel'
-b'DocType: Salary Component',b'Earning',b'Verdienen'
-b'DocType: Supplier Scorecard',b'Scoring Criteria',b'Scoring Criteria'
-b'DocType: Purchase Invoice',b'Party Account Currency',b'Party account Valuta'
-,b'BOM Browser',b'BOM Browser'
-b'apps/erpnext/erpnext/templates/emails/training_event.html +13',b'Please update your status for this training event',b'Update uw status voor dit trainingsevenement'
-b'DocType: Item Barcode',b'EAN',b'EAN'
-b'DocType: Purchase Taxes and Charges',b'Add or Deduct',b'Toevoegen of aftrekken'
-b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148',b'Overlapping conditions found between:',b'Overlappende voorwaarden gevonden tussen :'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187',b'Against Journal Entry {0} is already adjusted against some other voucher',b'Tegen Journal Entry {0} is al aangepast tegen enkele andere voucher'
-b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68',b'Total Order Value',b'Totale orderwaarde'
-b'apps/erpnext/erpnext/demo/setup/setup_data.py +328',b'Food',b'Voeding'
-b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57',b'Ageing Range 3',b'Vergrijzing Range 3'
-b'DocType: Maintenance Schedule Item',b'No of Visits',b'Aantal bezoeken'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165',b'Maintenance Schedule {0} exists against {1}',b'Onderhoudsplan {0} bestaat tegen {1}'
-b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36',b'Enrolling student',b'student die zich inschrijft'
-b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33',b'Currency of the Closing Account must be {0}',b'Valuta van de Closing rekening moet worden {0}'
-b'apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21',b'Sum of points for all goals should be 100. It is {0}',b'Som van de punten voor alle doelen moeten zijn 100. Het is {0}'
-b'DocType: Project',b'Start and End Dates',b'Begin- en einddatum'
-,b'Delivered Items To Be Billed',b'Geleverde Artikelen nog te factureren'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16',b'Open BOM {0}',b'Open BOM {0}'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60',b'Warehouse cannot be changed for Serial No.',b'Magazijn kan niet worden gewijzigd voor Serienummer'
-b'DocType: Authorization Rule',b'Average Discount',b'Gemiddelde korting'
-b'DocType: Project Update',b'Great/Quickly',b'Great / Snel'
-b'DocType: Purchase Invoice Item',b'UOM',b'UOM'
-b'DocType: Rename Tool',b'Utilities',b'Utilities'
-b'DocType: POS Profile',b'Accounting',b'Boekhouding'
-b'DocType: Employee',b'EMP/',b'EMP /'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133',b'Please select batches for batched item ',b'Selecteer batches voor batched item'
-b'DocType: Asset',b'Depreciation Schedules',b'afschrijvingen Roosters'
-b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192',b'Following accounts might be selected in GST Settings:',b'Volgende accounts kunnen worden geselecteerd in GST-instellingen:'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70',b'Application period cannot be outside leave allocation period',b'Aanvraagperiode kan buiten verlof toewijzingsperiode niet'
-b'DocType: Activity Cost',b'Projects',b'Projecten'
-b'DocType: Payment Request',b'Transaction Currency',b'transactie Munt'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +30',b'From {0} | {1} {2}',b'Van {0} | {1} {2}'
-b'DocType: Work Order Operation',b'Operation Description',b'Operatie Beschrijving'
-b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34',b'Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.',b'Kan boekjaar startdatum en einddatum niet wijzigen eenmaal het boekjaar is opgeslagen.'
-b'DocType: Quotation',b'Shopping Cart',b'Winkelwagen'
-b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Avg Daily Outgoing',b'Gem Daily Uitgaande'
-b'DocType: POS Profile',b'Campaign',b'Campagne'
-b'DocType: Supplier',b'Name and Type',b'Naam en Type'
-b'DocType: Physician',b'Contacts and Address',b'Contacten en adres'
-b'DocType: Purchase Invoice',b'Contact Person',b'Contactpersoon'
-b'apps/erpnext/erpnext/projects/doctype/task/task.py +38',"b""'Expected Start Date' can not be greater than 'Expected End Date'""","b""'Verwacht Startdatum' kan niet groter zijn dan 'Verwachte Einddatum'"""
-b'DocType: Course Scheduling Tool',b'Course End Date',b'Cursus Einddatum'
-b'DocType: Holiday List',b'Holidays',b'Feestdagen'
-b'DocType: Sales Order Item',b'Planned Quantity',b'Gepland Aantal'
-b'DocType: Purchase Invoice Item',b'Item Tax Amount',b'Artikel BTW-bedrag'
-b'DocType: Water Analysis',b'Water Analysis Criteria',b'Criteria voor wateranalyse'
-b'DocType: Item',b'Maintain Stock',b'Handhaaf Stock'
-b'DocType: Employee',b'Prefered Email',b'Prefered Email'
-b'DocType: Student Admission',b'Eligibility and Details',b'Geschiktheid en details'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38',b'Net Change in Fixed Asset',b'Netto wijziging in vaste activa'
-b'DocType: Leave Control Panel',b'Leave blank if considered for all designations',b'Laat leeg indien overwogen voor alle aanduidingen'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +806',"b""Charge of type 'Actual' in row {0} cannot be included in Item Rate""","b""Charge van het type ' Actual ' in rij {0} kan niet worden opgenomen in Item Rate"""
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382',b'Max: {0}',b'Max: {0}'
-b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'From Datetime',b'Van Datetime'
-b'DocType: Email Digest',b'For Company',b'Voor Bedrijf'
-b'apps/erpnext/erpnext/config/support.py +17',b'Communication log.',b'Communicatie log.'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195',"b'Request for Quotation is disabled to access from portal, for more check portal settings.'","b'Offerte is uitgeschakeld om de toegang van portal, voor meer controle portaal instellingen.'"
-b'DocType: Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable',b'Leverancier Scorecard Scorevariabele'
-b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72',b'Buying Amount',b'Aankoop Bedrag'
-b'DocType: Sales Invoice',b'Shipping Address Name',b'Verzenden Adres Naam'
-b'DocType: Material Request',b'Terms and Conditions Content',b'Algemene Voorwaarden Inhoud'
-b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18',b'There were errors creating Course Schedule',b'Er zijn fouten opgetreden bij het maken van cursusplanning'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581',b'cannot be greater than 100',b'mag niet groter zijn dan 100'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +752',b'Item {0} is not a stock Item',b'Artikel {0} is geen voorraadartikel'
-b'DocType: Maintenance Visit',b'Unscheduled',b'Ongeplande'
-b'DocType: Employee',b'Owned',b'Eigendom'
-b'DocType: Salary Detail',b'Depends on Leave Without Pay',b'Afhankelijk van onbetaald verlof'
-b'DocType: Pricing Rule',"b'Higher the number, higher the priority'","b'Hoe hoger het getal, hoe hoger de prioriteit'"
-,b'Purchase Invoice Trends',b'Inkoopfactuur Trends'
-b'DocType: Employee',b'Better Prospects',b'Betere vooruitzichten'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +217',"b'Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches'","b'Rij # {0}: De partij {1} heeft slechts {2} aantal. Selecteer alstublieft een andere partij die {3} beschikbaar heeft of verdeel de rij in meerdere rijen, om te leveren / uit te voeren vanuit meerdere batches'"
-b'DocType: Vehicle',b'License Plate',b'Nummerplaat'
-b'DocType: Appraisal',b'Goals',b'Doelen'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +353',b'Select POS Profile',b'Selecteer POS-profiel'
-b'DocType: Warranty Claim',b'Warranty / AMC Status',b'Garantie / AMC Status'
-,b'Accounts Browser',b'Rekeningen Verkenner'
-b'DocType: Payment Entry Reference',b'Payment Entry Reference',b'Betaling Entry Reference'
-b'DocType: GL Entry',b'GL Entry',b'GL Entry'
-b'DocType: HR Settings',b'Employee Settings',b'Werknemer Instellingen'
-,b'Batch-Wise Balance History',b'Batchgewijze balansgeschiedenis'
-b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73',b'Print settings updated in respective print format',b'Print instellingen bijgewerkt in de respectievelijke gedrukte vorm'
-b'DocType: Package Code',b'Package Code',b'Package Code'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105',b'Apprentice',b'leerling'
-b'DocType: Purchase Invoice',b'Company GSTIN',b'Bedrijf GSTIN'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105',b'Negative Quantity is not allowed',b'Negatieve Hoeveelheid is niet toegestaan'
-b'DocType: Purchase Invoice Item',b'Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges',b'Belasting detail tafel haalden van post meester als een string en opgeslagen in dit gebied.\n Gebruikt voor en -heffingen'
-b'DocType: Supplier Scorecard Period',b'SSC-',b'SSC-'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +159',b'Employee cannot report to himself.',b'Werknemer kan niet rapporteren aan zichzelf.'
-b'DocType: Account',"b'If the account is frozen, entries are allowed to restricted users.'","b'Als de rekening is bevroren, kunnen boekingen alleen door daartoe bevoegde gebruikers gedaan worden.'"
-b'DocType: Email Digest',b'Bank Balance',b'Banksaldo'
-b'apps/erpnext/erpnext/accounts/party.py +240',b'Accounting Entry for {0}: {1} can only be made in currency: {2}',b'Rekening ingave voor {0}: {1} kan alleen worden gedaan in valuta: {2}'
-b'DocType: Job Opening',"b'Job profile, qualifications required etc.'","b'Functieprofiel, benodigde kwalificaties enz.'"
-b'DocType: Journal Entry Account',b'Account Balance',b'Rekeningbalans'
-b'apps/erpnext/erpnext/config/accounts.py +183',b'Tax Rule for transactions.',b'Fiscale Regel voor transacties.'
-b'DocType: Rename Tool',b'Type of document to rename.',b'Type document te hernoemen.'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53',b'{0} {1}: Customer is required against Receivable account {2}',b'{0} {1}: een klant is vereist voor Te Ontvangen rekening {2}'
-b'DocType: Purchase Invoice',b'Total Taxes and Charges (Company Currency)',b'Totaal belastingen en toeslagen (Bedrijfsvaluta)'
-b'DocType: Weather',b'Weather Parameter',b'Weerparameter'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60',"b""Show unclosed fiscal year's P&L balances""",b'Toon ongesloten fiscale jaar P &amp; L saldi'
-b'DocType: Lab Test Template',b'Collection Details',b'Collectie Details'
-b'DocType: POS Profile',b'Allow Print Before Pay',b'Sta Print v\xc3\xb3\xc3\xb3r betalen toe'
-b'DocType: Land Unit',b'Linked Soil Texture',b'Gekoppelde bodemtextuur'
-b'DocType: Shipping Rule',b'Shipping Account',b'Verzending Rekening'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92',b'{0} {1}: Account {2} is inactive',b'{0} {1}: Account {2} is niet actief'
-b'apps/erpnext/erpnext/utilities/activation.py +82',b'Make Sales Orders to help you plan your work and deliver on-time',b'Maak verkooporders om u te helpen uw werk en leveren op tijd'
-b'DocType: Quality Inspection',b'Readings',b'Lezingen'
-b'DocType: Stock Entry',b'Total Additional Costs',b'Totaal Bijkomende kosten'
-b'DocType: Course Schedule',b'SH',b'SH'
-b'DocType: BOM',b'Scrap Material Cost(Company Currency)',b'Scrap Materiaal Kosten (Company Munt)'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66',b'Sub Assemblies',b'Uitbesteed werk'
-b'DocType: Asset',b'Asset Name',b'Asset Naam'
-b'DocType: Project',b'Task Weight',b'Task Weight'
-b'DocType: Shipping Rule Condition',b'To Value',b'Tot Waarde'
-b'DocType: Asset Movement',b'Stock Manager',b'Stock Manager'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171',b'Source warehouse is mandatory for row {0}',b'Bron magazijn is verplicht voor rij {0}'
-b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38',b'The Payment Term at row {0} is possibly a duplicate.',b'De betalingstermijn op rij {0} is mogelijk een duplicaat.'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +30',b'Agriculture (beta)',b'Landbouw (b\xc3\xa8ta)'
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863',b'Packing Slip',b'Pakbon'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110',b'Office Rent',b'Kantoorhuur'
-b'apps/erpnext/erpnext/config/setup.py +111',b'Setup SMS gateway settings',b'Instellingen SMS gateway'
-b'DocType: Disease',b'Common Name',b'Gemeenschappelijke naam'
-b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61',b'Import Failed!',b'Importeren mislukt!'
-b'apps/erpnext/erpnext/public/js/templates/address_list.html +20',b'No address added yet.',b'Nog geen adres toegevoegd.'
-b'DocType: Workstation Working Hour',b'Workstation Working Hour',b'Werkstation Werkuur'
-b'DocType: Vital Signs',b'Blood Pressure',b'Bloeddruk'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125',b'Analyst',b'analist'
-b'DocType: Item',b'Inventory',b'Voorraad'
-b'DocType: Item',b'Sales Details',b'Verkoop Details'
-b'DocType: Quality Inspection',b'QI-',b'Qi-'
-b'DocType: Opportunity',b'With Items',b'Met Items'
-b'DocType: Asset Maintenance',b'Maintenance Team',b'Onderhoudsteam'
-b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'In Qty',b'in Aantal'
-b'DocType: Education Settings',b'Validate Enrolled Course for Students in Student Group',b'Valideer ingeschreven cursus voor studenten in de studentengroep'
-b'DocType: Notification Control',b'Expense Claim Rejected',b'Kostendeclaratie afgewezen'
-b'DocType: Item',b'Item Attribute',b'Item Attribute'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147',b'Government',b'Overheid'
-b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40',b'Expense Claim {0} already exists for the Vehicle Log',b'Declaratie {0} bestaat al voor de Vehicle Log'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +64',b'Institute Name',b'naam van het instituut'
-b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117',b'Please enter repayment Amount',b'Vul hier terug te betalen bedrag'
-b'apps/erpnext/erpnext/config/stock.py +309',b'Item Variants',b'Item Varianten'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +29',b'Services',b'Services'
-b'DocType: HR Settings',b'Email Salary Slip to Employee',b'E-mail loonstrook te Employee'
-b'DocType: Cost Center',b'Parent Cost Center',b'Bovenliggende kostenplaats'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041',b'Select Possible Supplier',b'Stel mogelijke Leverancier'
-b'DocType: Sales Invoice',b'Source',b'Bron'
-b'DocType: Customer',"b'Select, to make the customer searchable with these fields'","b'Selecteer, om de klant doorzoekbaar te maken met deze velden'"
-b'apps/erpnext/erpnext/templates/pages/projects.html +31',b'Show closed',b'Toon gesloten'
-b'DocType: Leave Type',b'Is Leave Without Pay',b'Is onbetaald verlof'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +261',b'Asset Category is mandatory for Fixed Asset item',b'Asset Categorie is verplicht voor post der vaste activa'
-b'DocType: Fee Validity',b'Fee Validity',b'Geldigheidsgeldigheid'
-b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146',b'No records found in the Payment table',b'Geen records gevonden in de betaling tabel'
-b'apps/erpnext/erpnext/education/utils.py +19',b'This {0} conflicts with {1} for {2} {3}',b'Deze {0} in strijd is met {1} voor {2} {3}'
-b'DocType: Student Attendance Tool',b'Students HTML',b'studenten HTML'
-b'DocType: POS Profile',b'Apply Discount',b'Solliciteer Discount'
-b'DocType: GST HSN Code',b'GST HSN Code',b'GST HSN-code'
-b'DocType: Employee External Work History',b'Total Experience',b'Total Experience'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70',b'Open Projects',b'Open Projects'
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295',b'Packing Slip(s) cancelled',b'Pakbon(nen) geannuleerd'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36',b'Cash Flow from Investing',b'De cashflow uit investeringsactiviteiten'
-b'DocType: Program Course',b'Program Course',b'programma Course'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99',b'Freight and Forwarding Charges',b'Vracht-en verzendkosten'
-b'DocType: Homepage',b'Company Tagline for website homepage',b'Company Tag voor website homepage'
-b'DocType: Item Group',b'Item Group Name',b'Artikel groepsnaam'
-b'apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27',b'Taken',b'Ingenomen'
-b'DocType: Student',b'Date of Leaving',b'Datum waarop het vaartuig'
-b'DocType: Pricing Rule',b'For Price List',b'Voor Prijslijst'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27',b'Executive Search',b'Executive Search'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55',b'Setting defaults',b'Standaardwaarden instellen'
-b'apps/erpnext/erpnext/utilities/activation.py +63',b'Create Leads',b'Maak Leads'
-b'DocType: Maintenance Schedule',b'Schedules',b'Schema'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +468',b'POS Profile is required to use Point-of-Sale',b'POS-profiel is vereist om Point-of-Sale te gebruiken'
-b'DocType: Purchase Invoice Item',b'Net Amount',b'Netto Bedrag'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141',b'{0} {1} has not been submitted so the action cannot be completed',b'{0} {1} is niet ingediend dus de actie kan niet voltooid worden'
-b'DocType: Purchase Order Item Supplied',b'BOM Detail No',b'Stuklijst Detail nr.'
-b'DocType: Landed Cost Voucher',b'Additional Charges',b'Extra kosten'
-b'DocType: Purchase Invoice',b'Additional Discount Amount (Company Currency)',b'Extra korting Bedrag (Company valuta)'
-b'DocType: Supplier Scorecard',b'Supplier Scorecard',b'Leverancier Scorecard'
-b'DocType: Plant Analysis',b'Result Datetime',b'Resultaat Datetime'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.js +21',b'Please create new account from Chart of Accounts.',b'Maak nieuwe rekening van Rekeningschema.'
-,b'Support Hour Distribution',b'Support Hour Distribution'
-b'DocType: Maintenance Visit',b'Maintenance Visit',b'Onderhoud Bezoek'
-b'DocType: Student',b'Leaving Certificate Number',b'Leaving Certificate Number'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58',"b'Appointment cancelled, Please review and cancel the invoice {0}'","b'Afspraak geannuleerd, Controleer en annuleer de factuur {0}'"
-b'DocType: Sales Invoice Item',b'Available Batch Qty at Warehouse',b'Verkrijgbaar Aantal Batch bij Warehouse'
-b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Update Print Format',b'Bijwerken Print Format'
-b'DocType: Landed Cost Voucher',b'Landed Cost Help',b'Vrachtkosten Help'
-b'DocType: Purchase Invoice',b'Select Shipping Address',b'Selecteer Verzendadres'
-b'apps/erpnext/erpnext/config/non_profit.py +28',b'Memebership Details',b'Gegevens over lidmaatschap'
-b'DocType: Leave Block List',b'Block Holidays on important days.',b'Blokkeer vakantie op belangrijke dagen.'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220',b'Please input all required Result Value(s)',b'Voer alle vereiste resultaatwaarde (n) in'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106',b'Accounts Receivable Summary',b'Debiteuren Samenvatting'
-b'DocType: Employee Loan',b'Monthly Repayment Amount',b'Maandelijks te betalen bedrag'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9',b'Opening Invoices',b'Facturen openen'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +195',b'Please set User ID field in an Employee record to set Employee Role',b'Stel User ID veld in een Werknemer record Werknemer Rol stellen'
-b'DocType: UOM',b'UOM Name',b'Eenheid Naam'
-b'DocType: GST HSN Code',b'HSN Code',b'HSN-code'
-b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39',b'Contribution Amount',b'Bijdrage hoeveelheid'
-b'DocType: Purchase Invoice',b'Shipping Address',b'Verzendadres'
-b'DocType: Stock Reconciliation',b'This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.',b'Deze tool helpt u om te werken of te repareren de hoeveelheid en de waardering van de voorraad in het systeem. Het wordt meestal gebruikt om het systeem waarden en wat in uw magazijnen werkelijk bestaat synchroniseren.'
-b'DocType: Delivery Note',b'In Words will be visible once you save the Delivery Note.',b'In Woorden zijn zichtbaar zodra u de vrachtbrief opslaat.'
-b'DocType: Expense Claim',b'EXP',b'EXP'
-b'DocType: Water Analysis',b'Container',b'houder'
-b'apps/erpnext/erpnext/education/utils.py +50',b'Student {0} - {1} appears Multiple times in row {2} & {3}',b'Student {0} - {1} meerdere keren in rij {2} en {3}'
-b'DocType: Project',b'Day to Send',b'Dag om te verzenden'
-b'DocType: Healthcare Settings',b'Manage Sample Collection',b'Beheer voorbeeldsamenwerking'
-b'DocType: Production Plan',b'Ignore Existing Ordered Quantity',b'Bestaande bestelde hoeveelheid negeren'
-b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66',b'Please set the series to be used.',b'Stel de reeks in die moet worden gebruikt.'
-b'DocType: Patient',b'Tobacco Past Use',b'Gebruik van tabak achteraf'
-b'DocType: Sales Invoice Item',b'Brand Name',b'Merknaam'
-b'DocType: Purchase Receipt',b'Transporter Details',b'Transporter Details'
-b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55',b'User {0} is already assigned to Physician {1}',b'Gebruiker {0} is al toegewezen aan Arts {1}'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2700',b'Default warehouse is required for selected item',b'Standaard magazijn is nodig voor geselecteerde punt'
-b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Box',b'Doos'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038',b'Possible Supplier',b'mogelijke Leverancier'
-b'DocType: Budget',b'Monthly Distribution',b'Maandelijkse Verdeling'
-b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68',b'Receiver List is empty. Please create Receiver List',b'Ontvanger Lijst is leeg. Maak Ontvanger Lijst'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +31',b'Healthcare (beta)',b'Gezondheidszorg (beta)'
-b'DocType: Production Plan Sales Order',b'Production Plan Sales Order',b'Productie Plan Verkooporder'
-b'DocType: Sales Partner',b'Sales Partner Target',b'Verkoop Partner Doel'
-b'DocType: Loan Type',b'Maximum Loan Amount',b'Maximum Leningen'
-b'DocType: Pricing Rule',b'Pricing Rule',b'Prijsbepalingsregel'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Dubbele rolnummer voor student {0}'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Dubbele rolnummer voor student {0}'
-b'DocType: Budget',b'Action if Annual Budget Exceeded',b'Actie als jaarlijkse begroting overschreden'
-b'apps/erpnext/erpnext/config/learn.py +197',b'Material Request to Purchase Order',b'Materiaal aanvragen tot Purchase Order'
-b'DocType: Shopping Cart Settings',b'Payment Success URL',b'Betaling Succes URL'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81',b'Row # {0}: Returned Item {1} does not exists in {2} {3}',b'Rij # {0}: Teruggekeerde Item {1} bestaat niet in {2} {3}'
-b'DocType: Purchase Receipt',b'PREC-',b'PREC-'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16',b'Bank Accounts',b'Bankrekeningen'
-,b'Bank Reconciliation Statement',b'Bank Aflettering Statement'
-b'DocType: Consultation',b'Medical Coding',b'Medische codering'
-b'DocType: Healthcare Settings',b'Reminder Message',b'Herinnering Bericht'
-,b'Lead Name',b'Lead Naam'
-,b'POS',b'POS'
-b'DocType: C-Form',b'III',b'III'
-b'apps/erpnext/erpnext/config/stock.py +314',b'Opening Stock Balance',b'Het openen Stock Balance'
-b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58',b'{0} must appear only once',b'{0} mag slechts eenmaal voorkomen'
-b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59',b'Leaves Allocated Successfully for {0}',b'Verlof succesvol toegewezen aan {0}'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42',b'No Items to pack',b'Geen Artikelen om te verpakken'
-b'DocType: Shipping Rule Condition',b'From Value',b'Van Waarde'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +606',b'Manufacturing Quantity is mandatory',b'Productie Aantal is verplicht'
-b'DocType: Employee Loan',b'Repayment Method',b'terugbetaling Method'
-b'DocType: Products Settings',"b'If checked, the Home page will be the default Item Group for the website'","b'Indien aangevinkt, zal de startpagina de standaard Item Group voor de website'"
-b'DocType: Quality Inspection Reading',b'Reading 4',b'Meting 4'
-b'apps/erpnext/erpnext/config/hr.py +132',b'Claims for company expense.',b'Claims voor bedrijfsonkosten'
-b'apps/erpnext/erpnext/utilities/activation.py +118',"b'Students are at the heart of the system, add all your students'","b'Studenten worden in het hart van het systeem, voegt al jouw leerlingen'"
-b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97',b'Row #{0}: Clearance date {1} cannot be before Cheque Date {2}',b'Rij # {0}: Clearance date {1} kan niet v\xc3\xb3\xc3\xb3r Cheque Date {2}'
-b'DocType: Asset Maintenance Task',b'Certificate Required',b'Certificaat vereist'
-b'DocType: Company',b'Default Holiday List',b'Standaard Vakantiedagen Lijst'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196',b'Row {0}: From Time and To Time of {1} is overlapping with {2}',b'Rij {0}: Van tijd en de tijd van de {1} overlapt met {2}'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145',b'Stock Liabilities',b'Voorraad Verplichtingen'
-b'DocType: Purchase Invoice',b'Supplier Warehouse',b'Leverancier Magazijn'
-b'DocType: Opportunity',b'Contact Mobile No',b'Contact Mobiele nummer'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399',b'Select Company',b'Selecteer Bedrijf'
-,b'Material Requests for which Supplier Quotations are not created',b'Materiaal Aanvragen waarvoor Leverancier Offertes niet zijn gemaakt'
-b'DocType: Student Report Generation Tool',b'Print Section',b'Print sectie'
-b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34',"b""User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.""",b'Gebruiker {0} heeft geen standaard POS-profiel. Schakel Standaard in rij {1} voor deze gebruiker in.'
-b'DocType: Student Group',b'Set 0 for no limit',b'Stel 0 voor geen limiet'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122',b'The day(s) on which you are applying for leave are holidays. You need not apply for leave.',b'De dag (en) waarop je solliciteert verlof zijn vakantie. U hoeft niet voor verlof.'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64',b'Row {idx}: {field} is required to create the Opening {invoice_type} Invoices',b'Rij {idx}: {field} is vereist om de opening {invoice_type} facturen te maken'
-b'DocType: Customer',b'Primary Address and Contact Detail',b'Primaire adres en contactgegevens'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20',b'Resend Payment Email',b'E-mail opnieuw te verzenden Betaling'
-b'apps/erpnext/erpnext/templates/pages/projects.html +27',b'New task',b'Nieuwe taak'
-b'DocType: Consultation',b'Appointment',b'Afspraak'
-b'apps/erpnext/erpnext/utilities/activation.py +74',b'Make Quotation',b'Maak Offerte'
-b'apps/erpnext/erpnext/config/education.py +230',b'Other Reports',b'andere rapporten'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +39',b'Please select at least one domain.',b'Selecteer minimaal \xc3\xa9\xc3\xa9n domein.'
-b'DocType: Dependent Task',b'Dependent Task',b'Afhankelijke taak'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +444',b'Conversion factor for default Unit of Measure must be 1 in row {0}',b'Conversiefactor voor Standaard meeteenheid moet 1 zijn in rij {0}'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188',b'Leave of type {0} cannot be longer than {1}',b'Verlof van type {0} kan niet langer zijn dan {1}'
-b'DocType: Manufacturing Settings',b'Try planning operations for X days in advance.',b'Probeer plan operaties voor X dagen van tevoren.'
-b'DocType: HR Settings',b'Stop Birthday Reminders',b'Stop verjaardagsherinneringen'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235',b'Please set Default Payroll Payable Account in Company {0}',b'Stel Default Payroll Payable account in Company {0}'
-b'DocType: SMS Center',b'Receiver List',b'Ontvanger Lijst'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1094',b'Search Item',b'Zoekitem'
-b'DocType: Payment Schedule',b'Payment Amount',b'Betaling Bedrag'
-b'DocType: Patient Appointment',b'Referring Physician',b'Verwijzende arts'
-b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46',b'Consumed Amount',b'Verbruikte hoeveelheid'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100',b'Net Change in Cash',b'Netto wijziging in cash'
-b'DocType: Assessment Plan',b'Grading Scale',b'Grading Scale'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +438',b'Unit of Measure {0} has been entered more than once in Conversion Factor Table',b'Eenheid {0} is meer dan eens ingevoerd in Conversie Factor Tabel'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +639',b'Already completed',b'Reeds voltooid'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33',b'Stock In Hand',b'Voorraad in de hand'
-b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64',b'Import Successful!',b'Importeren succesvol!'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29',b'Payment Request already exists {0}',b'Betalingsverzoek bestaat al {0}'
-b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Issued Items',b'Kosten van Items Afgegeven'
-b'DocType: Physician',b'Hospital',b'Ziekenhuis'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385',b'Quantity must not be more than {0}',b'Hoeveelheid mag niet meer zijn dan {0}'
-b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117',b'Previous Financial Year is not closed',b'Vorig boekjaar is niet gesloten'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46',b'Age (Days)',b'Leeftijd (dagen)'
-b'DocType: Quotation Item',b'Quotation Item',b'Offerte Artikel'
-b'DocType: Customer',b'Customer POS Id',b'Klant POS-id'
-b'DocType: Account',b'Account Name',b'Rekening Naam'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40',b'From Date cannot be greater than To Date',b'Vanaf de datum kan niet groter zijn dan tot nu toe'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198',b'Serial No {0} quantity {1} cannot be a fraction',b'Serienummer {0} hoeveelheid {1} moet een geheel getal zijn'
-b'apps/erpnext/erpnext/config/buying.py +43',b'Supplier Type master.',b'Leverancier Type stam.'
-b'DocType: Purchase Order Item',b'Supplier Part Number',b'Leverancier Onderdeelnummer'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108',b'Conversion rate cannot be 0 or 1',b'Succespercentage kan niet 0 of 1 zijn'
-b'DocType: Share Balance',b'To No',b'Naar Nee'
-b'DocType: Subscription',b'Reference Document',b'Referentie document'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229',b'{0} {1} is cancelled or stopped',b'{0} {1} is geannuleerd of gestopt'
-b'DocType: Accounts Settings',b'Credit Controller',b'Credit Controller'
-b'DocType: Grant Application',b'Applicant Type',b'aanvrager Type'
-b'DocType: Purchase Invoice',b'03-Deficiency in services',b'03-Deficiency in services'
-b'DocType: Delivery Note',b'Vehicle Dispatch Date',b'Voertuig Vertrekdatum'
-b'DocType: Healthcare Settings',b'Default Medical Code Standard',b'Standaard Medische Code Standaard'
-b'DocType: Purchase Invoice Item',b'HSN/SAC',b'HSN / SAC'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237',b'Purchase Receipt {0} is not submitted',b'Ontvangstbevestiging {0} is niet ingediend'
-b'DocType: Company',b'Default Payable Account',b'Standaard Payable Account'
-b'apps/erpnext/erpnext/config/website.py +17',"b'Settings for online shopping cart such as shipping rules, price list etc.'","b'Instellingen voor online winkelwagentje zoals scheepvaart regels, prijslijst enz.'"
-b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +113',b'{0}% Billed',b'{0}% gefactureerd'
-b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18',b'Reserved Qty',b'Gereserveerde Hoeveelheid'
-b'DocType: Party Account',b'Party Account',b'Party Account'
-b'apps/erpnext/erpnext/config/setup.py +122',b'Human Resources',b'Human Resources'
-b'DocType: Lead',b'Upper Income',b'Bovenste Inkomen'
-b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17',b'Reject',b'afwijzen'
-b'DocType: Journal Entry Account',b'Debit in Company Currency',b'Debet in Company Valuta'
-b'DocType: BOM Item',b'BOM Item',b'Stuklijst Artikel'
-b'DocType: Appraisal',b'For Employee',b'Voor Werknemer'
-b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49',b'Make Disbursement Entry',b'Maak uitbetaling Entry'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138',b'Row {0}: Advance against Supplier must be debit',b'Rij {0}: Advance tegen Leverancier worden debiteren'
-b'DocType: Company',b'Default Values',b'Standaard Waarden'
-b'DocType: Membership',b'INR',b'INR'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60',b'{frequency} Digest',b'{Frequentie} Digest'
-b'DocType: Expense Claim',b'Total Amount Reimbursed',b'Totaal bedrag terug!'
-b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5',b'This is based on logs against this Vehicle. See timeline below for details',b'Dit is gebaseerd op stammen tegen dit voertuig. Zie tijdlijn hieronder voor meer informatie'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90',b'Against Supplier Invoice {0} dated {1}',b'Tegen Leverancier Factuur {0} gedateerd {1}'
-b'DocType: Customer',b'Default Price List',b'Standaard Prijslijst'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +322',b'Asset Movement record {0} created',b'Asset bewegingsartikel {0} aangemaakt'
-b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51',b'You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings',b'Je kunt niet verwijderen boekjaar {0}. Boekjaar {0} is ingesteld als standaard in Global Settings'
-b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20',b'A customer with the same name already exists',b'Er bestaat al een klant met dezelfde naam'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185',b'This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?',b'Dit zal loonstrookjes indienen en een periodedagboek aanmaken. Wil je doorgaan?'
-b'DocType: Purchase Invoice',b'Total Net Weight',b'Totale netto gewicht'
-b'DocType: Purchase Invoice',b'Eligibility For ITC',b'Geschiktheid voor ITC'
-b'DocType: Journal Entry',b'Entry Type',b'Entry Type'
-,b'Customer Credit Balance',b'Klant Kredietsaldo'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28',b'Net Change in Accounts Payable',b'Netto wijziging in Accounts Payable'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'EcritureLet',b'EcritureLet'
-b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +209',b'Credit limit has been crossed for customer {0} ({1}/{2})',b'Kredietlimiet is overschreden voor klant {0} ({1} / {2})'
-b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42',"b""Customer required for 'Customerwise Discount'""","b""Klant nodig voor 'Klantgebaseerde Korting'"""
-b'apps/erpnext/erpnext/config/accounts.py +140',b'Update bank payment dates with journals.',b'Bijwerken bank betaaldata met journaalposten'
-b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21',b'Pricing',b'pricing'
-b'DocType: Quotation',b'Term Details',b'Voorwaarde Details'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30',b'Cannot enroll more than {0} students for this student group.',b'Kan niet meer dan {0} studenten voor deze groep studenten inschrijven.'
-b'apps/erpnext/erpnext/templates/print_formats/includes/total.html +4',b'Total (Without Tax)',b'Totaal (zonder BTW)'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'Loodtelling'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'Loodtelling'
-b'apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15',b'{0} must be greater than 0',b'{0} moet groter zijn dan 0'
-b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30',b'Stock Available',b'Beschikbare voorraad'
-b'DocType: Manufacturing Settings',b'Capacity Planning For (Days)',b'Capacity Planning Voor (Dagen)'
-b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10',b'Procurement',b'Inkoop'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66',b'None of the items have any change in quantity or value.',b'Geen van de items hebben een verandering in hoeveelheid of waarde.'
-b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Verplicht veld - Programma'
-b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Verplicht veld - Programma'
-b'DocType: Special Test Template',b'Result Component',b'Resultaatcomponent'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46',b'Warranty Claim',b'Garantie Claim'
-,b'Lead Details',b'Lead Details'
-b'DocType: Volunteer',b'Availability and Skills',b'Beschikbaarheid en vaardigheden'
-b'DocType: Salary Slip',b'Loan repayment',b'Lening terugbetaling'
-b'DocType: Purchase Invoice',"b""End date of current invoice's period""",b'Einddatum van de huidige factuurperiode'
-b'DocType: Pricing Rule',b'Applicable For',b'Toepasselijk voor'
-b'DocType: Lab Test',b'Technician Name',b'Technicus Naam'
-b'DocType: Accounts Settings',b'Unlink Payment on Cancellation of Invoice',b'Ontkoppelen Betaling bij annulering van de factuur'
-b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16',b'Current Odometer reading entered should be greater than initial Vehicle Odometer {0}',b'Huidige kilometerstand ingevoerd moet groter zijn dan de initi\xc3\xable kilometerstand van het voertuig zijn {0}'
-b'DocType: Restaurant Reservation',b'No Show',b'Geen voorstelling'
-b'DocType: Shipping Rule Country',b'Shipping Rule Country',b'Verzenden Regel Land'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10',b'Leave and Attendance',b'Verlaat en Aanwezigheid'
-b'DocType: Maintenance Visit',b'Partially Completed',b'Gedeeltelijk afgesloten'
-b'apps/erpnext/erpnext/healthcare/setup.py +257',b'Moderate Sensitivity',b'Gematigde gevoeligheid'
-b'DocType: Leave Type',b'Include holidays within leaves as leaves',b'Inclusief vakantie binnen bladeren als bladeren'
-b'DocType: Sales Invoice',b'Packed Items',b'Verpakt Items'
-b'apps/erpnext/erpnext/config/support.py +27',b'Warranty Claim against Serial No.',b'Garantie Claim tegen Serienummer'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197',"b""'Total'""",b'&#39;Totaal&#39;'
-b'DocType: Shopping Cart Settings',b'Enable Shopping Cart',b'Inschakelen Winkelwagen'
-b'DocType: Employee',b'Permanent Address',b'Vast Adres'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260',b'Advance paid against {0} {1} cannot be greater \\\n\t\t\t\t\t\tthan Grand Total {2}',b'Voorschot betaald tegen {0} {1} kan niet groter zijn \\ dan eindtotaal {2}'
-b'DocType: Consultation',b'Medication',b'geneesmiddel'
-b'DocType: Production Plan',b'Include Non Stock Items',b'Niet-voorraadartikelen opnemen'
-b'DocType: Project Update',b'Challenging/Slow',b'Uitdagende / Slow'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147',b'Please select item code',b'Selecteer artikelcode'
-b'DocType: Student Sibling',b'Studying in Same Institute',b'Het bestuderen in hetzelfde instituut'
-b'DocType: Territory',b'Territory Manager',b'Regio Manager'
-b'DocType: Packed Item',b'To Warehouse (Optional)',b'Om Warehouse (optioneel)'
-b'DocType: GST Settings',b'GST Accounts',b'GST-accounts'
-b'DocType: Payment Entry',b'Paid Amount (Company Currency)',b'Betaald bedrag (Bedrijfsvaluta)'
-b'DocType: Purchase Invoice',b'Additional Discount',b'EXTRA KORTING'
-b'DocType: Selling Settings',b'Selling Settings',b'Verkoop Instellingen'
-b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83',b'Confirm Action',b'Bevestig actie'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39',b'Online Auctions',b'online Veilingen'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100',b'Please specify either Quantity or Valuation Rate or both',b'Specificeer ofwel Hoeveelheid of Waarderingstarief of beide'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18',b'Fulfillment',b'Vervulling'
-b'apps/erpnext/erpnext/templates/generators/item.html +82',b'View in Cart',b'Bekijk in winkelwagen'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103',b'Marketing Expenses',b'Marketingkosten'
-,b'Item Shortage Report',b'Artikel Tekort Rapport'
-b'apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15',"b""Can't create standard criteria. Please rename the criteria""",b'Kan geen standaardcriteria maken. Wijzig de naam van de criteria'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +311',"b'Weight is mentioned,\\nPlease mention ""Weight UOM"" too'","b'Het gewicht wordt vermeld, \\n Vermeld ""Gewicht UOM"" te'"
-b'DocType: Stock Entry Detail',b'Material Request used to make this Stock Entry',b'Materiaal Aanvraag is gebruikt om deze Voorraad  Entry te maken'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +68',b'Next Depreciation Date is mandatory for new asset',b'Volgende Afschrijvingen Date is verplicht voor nieuwe aanwinst'
-b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Afzonderlijke cursusgroep voor elke partij'
-b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Afzonderlijke cursusgroep voor elke partij'
-b'apps/erpnext/erpnext/config/support.py +32',b'Single unit of an Item.',b'Enkel exemplaar van een artikel.'
-b'DocType: Fee Category',b'Fee Category',b'fee Categorie'
-b'DocType: Agriculture Task',b'Next Business Day',b'Volgende werkdag'
-b'DocType: Drug Prescription',b'Dosage by time interval',b'Dosering per tijdsinterval'
-b'DocType: Cash Flow Mapper',b'Section Header',b'Sectiekoptekst'
-,b'Student Fee Collection',b'Student Fee Collection'
-b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24',b'Appointment Duration (mins)',b'Benoemingsduur (minuten)'
-b'DocType: Accounts Settings',b'Make Accounting Entry For Every Stock Movement',b'Maak boekhoudkundige afschrijving voor elke Stock Movement'
-b'DocType: Leave Allocation',b'Total Leaves Allocated',b'Totaal Verlofdagen Toegewezen'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163',b'Warehouse required at Row No {0}',b'Warehouse vereist bij Row Geen {0}'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +145',b'Please enter valid Financial Year Start and End Dates',b'Voer geldige boekjaar begin- en einddatum'
-b'DocType: Employee',b'Date Of Retirement',b'Pensioneringsdatum'
-b'DocType: Upload Attendance',b'Get Template',b'Get Sjabloon'
-b'DocType: Material Request',b'Transferred',b'overgedragen'
-b'DocType: Vehicle',b'Doors',b'deuren'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117',b'ERPNext Setup Complete!',b'ERPNext Setup is voltooid!'
-b'DocType: Healthcare Settings',b'Collect Fee for Patient Registration',b'Verzamelkosten voor pati\xc3\xabntregistratie'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +678',b'Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item',b'Kan attributen na beurstransactie niet wijzigen. Maak een nieuw artikel en breng aandelen over naar het nieuwe item'
-b'DocType: Course Assessment Criteria',b'Weightage',b'Weging'
-b'DocType: Purchase Invoice',b'Tax Breakup',b'Belastingverdeling'
-b'DocType: Packing Slip',b'PS-',b'PS-'
-b'DocType: Member',b'Non Profit Member',b'Non-profitlid'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67',"b""{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.""","b""{0} {1}: kostenplaats is nodig voor 'Winst- en verliesrekening' account {2}. Gelieve een standaard kostenplaats voor de onderneming op te zetten."""
-b'DocType: Payment Schedule',b'Payment Term',b'Betalingstermijn'
-b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +160',b'A Customer Group exists with same name please change the Customer name or rename the Customer Group',b'Een Klantgroep met dezelfde naam bestaat. Gelieve de naam van de Klant of de Klantgroep  wijzigen'
-b'DocType: Land Unit',b'Area',b'Gebied'
-b'apps/erpnext/erpnext/public/js/templates/contact_list.html +37',b'New Contact',b'Nieuw contact'
-b'DocType: Territory',b'Parent Territory',b'Bovenliggende Regio'
-b'DocType: Purchase Invoice',b'Place of Supply',b'Plaats van levering'
-b'DocType: Quality Inspection Reading',b'Reading 2',b'Meting 2'
-b'DocType: Stock Entry',b'Material Receipt',b'Materiaal ontvangst'
-b'DocType: Homepage',b'Products',b'producten'
-b'DocType: Announcement',b'Instructor',b'Instructeur'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61',b'Select Item (optional)',b'Selecteer item (optioneel)'
-b'DocType: Fee Schedule Student Group',b'Fee Schedule Student Group',b'Fee Schedule Student Group'
-b'DocType: Student',b'AB+',b'AB+'
-b'DocType: Item',"b'If this item has variants, then it cannot be selected in sales orders etc.'","b'Als dit item heeft varianten, dan kan het niet worden geselecteerd in verkooporders etc.'"
-b'DocType: Lead',b'Next Contact By',b'Volgende Contact Door'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325',b'Quantity required for Item {0} in row {1}',b'Benodigde hoeveelheid voor item {0} in rij {1}'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45',b'Warehouse {0} can not be deleted as quantity exists for Item {1}',b'Magazijn {0} kan niet worden verwijderd als er voorraad is voor artikel {1}'
-b'DocType: Quotation',b'Order Type',b'Order Type'
-,b'Item-wise Sales Register',b'Artikelgebaseerde Verkoop Register'
-b'DocType: Asset',b'Gross Purchase Amount',b'Gross Aankoopbedrag'
-b'apps/erpnext/erpnext/utilities/user_progress.py +39',b'Opening Balances',b'Opening Saldi'
-b'DocType: Asset',b'Depreciation Method',b'afschrijvingsmethode'
-b'DocType: Purchase Taxes and Charges',b'Is this Tax included in Basic Rate?',b'Is dit inbegrepen in de Basic Rate?'
-b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Target',b'Totaal Doel'
-b'DocType: Soil Texture',b'Sand Composition (%)',b'Zandsamenstelling (%)'
-b'DocType: Job Applicant',b'Applicant for a Job',b'Aanvrager van een baan'
-b'DocType: Production Plan Material Request',b'Production Plan Material Request',b'Productie Plan Materiaal aanvragen'
-b'DocType: Stock Reconciliation',b'Reconciliation JSON',b'Aflettering JSON'
-b'apps/erpnext/erpnext/accounts/report/financial_statements.html +3',b'Too many columns. Export the report and print it using a spreadsheet application.',b'Teveel kolommen. Exporteer het rapport en druk het af via een Spreadsheet programma.'
-b'DocType: Purchase Invoice Item',b'Batch No',b'Partij nr.'
-b'DocType: Selling Settings',"b""Allow multiple Sales Orders against a Customer's Purchase Order""",b'Kunnen meerdere verkooporders tegen een klant bestelling'
-b'DocType: Student Group Instructor',b'Student Group Instructor',b'Student Groep Instructeur'
-b'DocType: Student Group Instructor',b'Student Group Instructor',b'Student Groep Instructeur'
-b'DocType: Grant Application',b'Assessment  Mark (Out of 10)',b'Beoordelingstabel (van de 10)'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61',b'Guardian2 Mobile No',b'Guardian2 Mobile No'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +218',b'Main',b'Hoofd'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +72',b'Variant',b'Variant'
-b'DocType: Naming Series',b'Set prefix for numbering series on your transactions',b'Instellen voorvoegsel voor nummerreeksen voor uw transacties'
-b'DocType: Employee Attendance Tool',b'Employees HTML',b'medewerkers HTML'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +458',b'Default BOM ({0}) must be active for this item or its template',b'Default BOM ({0}) moet actief voor dit artikel of zijn template'
-b'DocType: Employee',b'Leave Encashed?',b'Verlof verzilverd?'
-b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32',b'Opportunity From field is mandatory',"b'""Opportuniteit Van"" veld is verplicht'"
-b'DocType: Email Digest',b'Annual Expenses',b'jaarlijkse kosten'
-b'DocType: Item',b'Variants',b'Varianten'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1148',b'Make Purchase Order',b'Maak inkooporder'
-b'DocType: SMS Center',b'Send To',b'Verzenden naar'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133',b'There is not enough leave balance for Leave Type {0}',b'Er is niet genoeg verlofsaldo voor Verlof type {0}'
-b'DocType: Payment Reconciliation Payment',b'Allocated amount',b'Toegewezen bedrag'
-b'DocType: Sales Team',b'Contribution to Net Total',b'Bijdrage aan Netto Totaal'
-b'DocType: Sales Invoice Item',"b""Customer's Item Code""",b'Artikelcode van Klant'
-b'DocType: Stock Reconciliation',b'Stock Reconciliation',b'Voorraad Aflettering'
-b'DocType: Territory',b'Territory Name',b'Regio Naam'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204',b'Work-in-Progress Warehouse is required before Submit',b'Werk in uitvoering Magazijn is vereist alvorens in te dienen'
-b'apps/erpnext/erpnext/config/hr.py +40',b'Applicant for a Job.',b'Kandidaat voor een baan.'
-b'DocType: Purchase Order Item',b'Warehouse and Reference',b'Magazijn en Referentie'
-b'DocType: Supplier',b'Statutory info and other general information about your Supplier',b'Wettelijke info en andere algemene informatie over uw leverancier'
-b'DocType: Item',b'Serial Nos and Batches',b'Serienummers en batches'
-b'DocType: Item',b'Serial Nos and Batches',b'Serienummers en batches'
-b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'Studentengroep Sterkte'
-b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'Studentengroep Sterkte'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261',b'Against Journal Entry {0} does not have any unmatched {1} entry',b'Tegen Journal Entry {0} heeft geen onge\xc3\xabvenaarde {1} binnenkomst hebben'
-b'apps/erpnext/erpnext/config/hr.py +142',b'Appraisals',b'taxaties'
-b'apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8',b'Training Events',b'Trainingsevenementen'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205',b'Duplicate Serial No entered for Item {0}',b'Dubbel Serienummer ingevoerd voor Artikel {0}'
-b'apps/erpnext/erpnext/config/selling.py +179',b'Track Leads by Lead Source.',b'Leads bijhouden op leadbron.'
-b'DocType: Shipping Rule Condition',b'A condition for a Shipping Rule',b'Een voorwaarde voor een Verzendregel'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +167',b'Please enter ',b'Kom binnen alstublieft'
-b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43',b'Maintenance Log',b'Onderhoudslogboek'
-b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236',b'Please set filter based on Item or Warehouse',b'Stel filter op basis van artikel of Warehouse'
-b'DocType: Packing Slip',b'The net weight of this package. (calculated automatically as sum of net weight of items)',b'Het nettogewicht van dit pakket. (Wordt automatisch berekend als de som van de netto-gewicht van de artikelen)'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +802',b'Discount amount cannot be greater than 100%',b'Kortingsbedrag kan niet groter zijn dan 100%'
-b'DocType: Sales Order',b'To Deliver and Bill',b'Te leveren en Bill'
-b'DocType: Student Group',b'Instructors',b'instructeurs'
-b'DocType: GL Entry',b'Credit Amount in Account Currency',b'Credit Bedrag in account Valuta'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +603',b'BOM {0} must be submitted',b'Stuklijst {0} moet worden ingediend'
-b'apps/erpnext/erpnext/config/accounts.py +460',b'Share Management',b'Share Management'
-b'DocType: Authorization Control',b'Authorization Control',b'Autorisatie controle'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +317',b'Row #{0}: Rejected Warehouse is mandatory against rejected Item {1}',b'Rij # {0}: Afgekeurd Warehouse is verplicht tegen verworpen Item {1}'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Payment',b'Betaling'
-b'apps/erpnext/erpnext/controllers/stock_controller.py +92',"b'Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.'","b'Magazijn {0} is niet gekoppeld aan een account, vermeld alstublieft het account in het magazijnrecord of stel de standaard inventaris rekening in bedrijf {1}.'"
-b'apps/erpnext/erpnext/utilities/activation.py +81',b'Manage your orders',b'Beheer uw bestellingen'
-b'DocType: Work Order Operation',b'Actual Time and Cost',b'Werkelijke Tijd en kosten'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56',b'Material Request of maximum {0} can be made for Item {1} against Sales Order {2}',b'Materiaal Aanvraag van maximaal {0} kan worden gemaakt voor Artikel {1} tegen Verkooporder {2}'
-b'DocType: Crop',b'Crop Spacing',b'Uitsnede bijsnijden'
-b'DocType: Course',b'Course Abbreviation',b'cursus Afkorting'
-b'DocType: Student Leave Application',b'Student Leave Application',b'Student verlofaanvraag'
-b'DocType: Item',b'Will also apply for variants',b'Geldt ook voor varianten'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +217',"b'Asset cannot be cancelled, as it is already {0}'","b'Asset kan niet worden geannuleerd, want het is al {0}'"
-b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29',b'Employee {0} on Half day on {1}',b'Employee {0} op een halve dag op {1}'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42',b'Total working hours should not be greater than max working hours {0}',b'Totaal aantal werkuren mag niet groter zijn dan max werktijden {0}'
-b'apps/erpnext/erpnext/templates/pages/task_info.html +90',b'On',b'Op'
-b'apps/erpnext/erpnext/config/selling.py +62',b'Bundle items at time of sale.',b'Bundel artikelen op moment van verkoop.'
-b'DocType: Material Request Plan Item',b'Actual Qty',b'Werkelijk aantal'
-b'DocType: Sales Invoice Item',b'References',b'Referenties'
-b'DocType: Quality Inspection Reading',b'Reading 10',b'Meting 10'
-b'DocType: Item',b'Barcodes',b'Barcodes'
-b'DocType: Hub Category',b'Hub Node',b'Hub Node'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78',b'You have entered duplicate items. Please rectify and try again.',b'U hebt dubbele artikelen ingevoerd. Aub aanpassen en opnieuw proberen.'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129',b'Associate',b'associ\xc3\xabren'
-b'DocType: Asset Movement',b'Asset Movement',b'Asset Movement'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508',b'Work Order {0} must be submitted',b'Werkorder {0} moet worden ingediend'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2214',b'New Cart',b'nieuwe winkelwagen'
-b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44',b'Item {0} is not a serialized Item',b'Artikel {0} is geen seriegebonden artikel'
-b'DocType: SMS Center',b'Create Receiver List',b'Maak Ontvanger Lijst'
-b'DocType: Vehicle',b'Wheels',b'Wheels'
-b'DocType: Packing Slip',b'To Package No.',b'Naar pakket nr'
-b'DocType: Patient Relation',b'Family',b'Familie'
-b'DocType: Production Plan',b'Material Requests',b'materiaal aanvragen'
-b'DocType: Warranty Claim',b'Issue Date',b'Uitgiftedatum'
-b'DocType: Activity Cost',b'Activity Cost',b'Activiteit Kosten'
-b'DocType: Sales Invoice Timesheet',b'Timesheet Detail',b'Timesheet Detail'
-b'DocType: Purchase Receipt Item Supplied',b'Consumed Qty',b'Verbruikt aantal'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52',b'Telecommunications',b'telecommunicatie'
-b'apps/erpnext/erpnext/accounts/party.py +263',"b""Billing currency must be equal to either default company's currency or party account currency""",b'Factuurvaluta moet gelijk zijn aan de valuta van het standaardbedrijf of de valuta van het partijaccount'
-b'DocType: Packing Slip',b'Indicates that the package is a part of this delivery (Only Draft)',b'Geeft aan dat het pakket een onderdeel is van deze levering (alleen ontwerp)'
-b'DocType: Soil Texture',b'Loam',b'Leem'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +705',b'Row {0}: Due Date cannot be before posting date',b'Rij {0}: vervaldatum kan niet v\xc3\xb3\xc3\xb3r de boekingsdatum zijn'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36',b'Make Payment Entry',b'Betalen Entry'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129',b'Quantity for Item {0} must be less than {1}',b'Hoeveelheid voor artikel {0} moet kleiner zijn dan {1}'
-,b'Sales Invoice Trends',b'Verkoopfactuur Trends'
-b'DocType: Leave Application',b'Apply / Approve Leaves',b'Toepassing / Goedkeuren Leaves'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'For',b'Voor'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167',"b""Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'""","b""Kan de rij enkel verwijzen bij het aanrekeningstype 'Hoeveelheid vorige rij' of 'Totaal vorige rij'"""
-b'DocType: Sales Order Item',b'Delivery Warehouse',b'Levering magazijn'
-b'apps/erpnext/erpnext/config/accounts.py +241',b'Tree of financial Cost Centers.',b'Boom van de financi\xc3\xable Cost Centers.'
-b'DocType: Serial No',b'Delivery Document No',b'Leveringsdocument nr.'
-b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191',"b""Please set 'Gain/Loss Account on Asset Disposal' in Company {0}""",b'Stel &#39;winst / verliesrekening op de verkoop van activa in Company {0}'
-b'DocType: Landed Cost Voucher',b'Get Items From Purchase Receipts',b'Krijg items uit Aankoopfacturen'
-b'DocType: Serial No',b'Creation Date',b'Aanmaakdatum'
-b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33',b'Item {0} appears multiple times in Price List {1}',b'Artikel {0} verschijnt meerdere keren in prijslijst {1}'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41',"b'Selling must be checked, if Applicable For is selected as {0}'","b'Verkoop moet zijn aangevinkt, indien ""Van toepassing voor"" is geselecteerd als {0}'"
-b'DocType: Production Plan Material Request',b'Material Request Date',b'Materiaal Aanvraagdatum'
-b'DocType: Purchase Order Item',b'Supplier Quotation Item',b'Leverancier Offerte Artikel'
-b'DocType: Student',b'Student Mobile Number',b'Student Mobile Number'
-b'DocType: Item',b'Has Variants',b'Heeft Varianten'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +488',"b'Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings'","b'Kan niet overbilleren voor item {0} in rij {1} meer dan {2}. Om overrekening toe te staan, stel in Voorraad Instellingen in'"
-b'apps/erpnext/erpnext/templates/emails/training_event.html +11',b'Update Response',b'Update reactie'
-b'apps/erpnext/erpnext/public/js/utils.js +232',b'You have already selected items from {0} {1}',b'U heeft reeds geselecteerde items uit {0} {1}'
-b'DocType: Monthly Distribution',b'Name of the Monthly Distribution',b'Naam van de verdeling per maand'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Batch ID is verplicht'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Batch ID is verplicht'
-b'DocType: Sales Person',b'Parent Sales Person',b'Parent Sales Person'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100',b'The seller and the buyer cannot be the same',b'De verkoper en de koper kunnen niet hetzelfde zijn'
-b'DocType: Project',b'Collect Progress',b'Verzamel vooruitgang'
-b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24',b'Select the program first',b'Selecteer eerst het programma'
-b'DocType: Patient Appointment',b'Patient Age',b'Pati\xc3\xabnt leeftijd'
-b'apps/erpnext/erpnext/config/learn.py +253',b'Managing Projects',b'Managing Projects'
-b'DocType: Supplier',b'Supplier of Goods or Services.',b'Leverancier van goederen of diensten.'
-b'DocType: Budget',b'Fiscal Year',b'Boekjaar'
-b'DocType: Asset Maintenance Log',b'Planned',b'Gepland'
-b'DocType: Healthcare Settings',b'Default receivable accounts to be used if not set in Patient to book Consultation charges.',b'Standaard debiteurenrekening die gebruikt moet worden indien niet in Pati\xc3\xabnt ingesteld om te reserveren.'
-b'DocType: Vehicle Log',b'Fuel Price',b'Fuel Price'
-b'DocType: Budget',b'Budget',b'Begroting'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65',b'Set Open',b'Stel Open'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +258',b'Fixed Asset Item must be a non-stock item.',b'Fixed Asset punt moet een niet-voorraad artikel zijn.'
-b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50',"b""Budget cannot be assigned against {0}, as it's not an Income or Expense account""","b'Budget kan niet worden toegewezen tegen {0}, want het is geen baten of lasten rekening'"
-b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51',b'Achieved',b'Bereikt'
-b'DocType: Student Admission',b'Application Form Route',b'Aanvraagformulier Route'
-b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66',b'Territory / Customer',b'Regio / Klantenservice'
-b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44',b'Leave Type {0} cannot be allocated since it is leave without pay',b'Laat Type {0} kan niet worden toegewezen omdat het te verlaten zonder te betalen'
-b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167',b'Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2}',b'Rij {0}: Toegewezen bedrag {1} moet kleiner zijn dan of gelijk aan openstaande bedrag te factureren {2}'
-b'DocType: Sales Invoice',b'In Words will be visible once you save the Sales Invoice.',b'In Woorden zijn zichtbaar zodra u de Verkoopfactuur opslaat.'
-b'DocType: Lead',b'Follow Up',b'Opvolgen'
-b'DocType: Item',b'Is Sales Item',b'Is verkoopartikel'
-b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21',b'Item Group Tree',b'Artikel groepstructuur'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69',b'Item {0} is not setup for Serial Nos. Check Item master',b'Artikel {0} is niet ingesteld voor serienummers. Controleer Artikelstam'
-b'DocType: Maintenance Visit',b'Maintenance Time',b'Onderhoud Tijd'
-,b'Amount to Deliver',b'Bedrag te leveren'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335',b'Same item has been entered multiple times. {0}',b'Hetzelfde item is meerdere keren ingevoerd. {0}'
-b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30',b'The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',b'De Term Start datum kan niet eerder dan het jaar startdatum van het studiejaar waarop de term wordt gekoppeld zijn (Academisch Jaar {}). Corrigeer de data en probeer het opnieuw.'
-b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190',b'There were errors.',b'Er zijn fouten opgetreden.'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166',b'Employee {0} has already applied for {1} between {2} and {3} : ',b'Werknemer {0} heeft al een aanvraag ingediend voor {1} tussen {2} en {3}:'
-b'DocType: Guardian',b'Guardian Interests',b'Guardian Interesses'
-b'DocType: Naming Series',b'Current Value',b'Huidige waarde'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +273',b'Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year',b'Meerdere fiscale jaar bestaan voor de datum {0}. Stel onderneming in het fiscale jaar'
-b'DocType: Education Settings',b'Instructor Records to be created by',b'Instructor Records te cre\xc3\xabren door'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229',b'{0} created',b'{0} aangemaakt'
-b'DocType: GST Account',b'GST Account',b'GST-account'
-b'DocType: Delivery Note Item',b'Against Sales Order',b'Tegen klantorder'
-,b'Serial No Status',b'Serienummer Status'
-b'DocType: Payment Entry Reference',b'Outstanding',b'uitstekend'
-b'DocType: Supplier',b'Warn POs',b'Waarschuwing POs'
-,b'Daily Timesheet Summary',b'Dagelijks Timesheet Samenvatting'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137',"b'Row {0}: To set {1} periodicity, difference between from and to date \\\n\t\t\t\t\t\tmust be greater than or equal to {2}'","b'Rij {0}: Instellen {1} periodiciteit, tijdsverschil tussen begin- en einddatum \\\n groter dan of gelijk aan {2}'"
-b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6',b'This is based on stock movement. See {0} for details',b'Dit is gebaseerd op voorraad beweging. Zie {0} voor meer informatie'
-b'DocType: Pricing Rule',b'Selling',b'Verkoop'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392',b'Amount {0} {1} deducted against {2}',b'Bedrag {0} {1} in mindering gebracht tegen {2}'
-b'DocType: Employee',b'Salary Information',b'Salaris Informatie'
-b'DocType: Sales Person',b'Name and Employee ID',b'Naam en Werknemer ID'
-b'apps/erpnext/erpnext/accounts/party.py +308',b'Due Date cannot be before Posting Date',b'Vervaldatum mag niet voor de boekingsdatum zijn'
-b'DocType: Website Item Group',b'Website Item Group',b'Website Artikel Groep'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463',b'No salary slip found to submit for the above selected criteria OR salary slip already submitted',b'Geen salarisstrook gevonden om in te dienen voor de hierboven geselecteerde criteria OF salarisstrook al ingediend'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150',b'Duties and Taxes',b'Invoerrechten en Belastingen'
-b'DocType: Projects Settings',b'Projects Settings',b'Projectinstellingen'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356',b'Please enter Reference date',b'Vul Peildatum in'
-b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44',b'{0} payment entries can not be filtered by {1}',b'{0} betaling items kunnen niet worden gefilterd door {1}'
-b'DocType: Item Website Specification',b'Table for Item that will be shown in Web Site',b'Tafel voor post die in Web Site zal worden getoond'
-b'DocType: Purchase Order Item Supplied',b'Supplied Qty',b'Meegeleverde Aantal'
-b'DocType: Purchase Order Item',b'Material Request Item',b'Materiaal Aanvraag Artikel'
-b'apps/erpnext/erpnext/config/selling.py +75',b'Tree of Item Groups.',b'Boom van Artikelgroepen .'
-b'DocType: Production Plan',b'Total Produced Qty',b'Totaal geproduceerd aantal'
-b'DocType: Payroll Entry',b'Get Employee Details',b'Krijg medewerkersgegevens'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177',b'Cannot refer row number greater than or equal to current row number for this Charge type',b'Kan niet verwijzen rij getal groter dan of gelijk aan de huidige rijnummer voor dit type Charge'
-b'DocType: Asset',b'Sold',b'uitverkocht'
-,b'Item-wise Purchase History',b'Artikelgebaseerde Inkoop Geschiedenis'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230',"b""Please click on 'Generate Schedule' to fetch Serial No added for Item {0}""","b""Klik op 'Genereer Planning' om serienummer op te halen voor Artikel {0}"""
-b'DocType: Account',b'Frozen',b'Bevroren'
-b'DocType: Sales Invoice Payment',b'Base Amount (Company Currency)',b'Basisbedrag (Company Munt)'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928',b'Raw Materials',b'Grondstoffen'
-b'DocType: Payment Reconciliation Payment',b'Reference Row',b'Referentie Row'
-b'DocType: Installation Note',b'Installation Time',b'Installatie Tijd'
-b'DocType: Sales Invoice',b'Accounting Details',b'Boekhouding Details'
-b'apps/erpnext/erpnext/setup/doctype/company/company.js +113',b'Delete all the Transactions for this Company',b'Verwijder alle transacties voor dit bedrijf'
-b'DocType: Patient',b'O Positive',b'O Positief'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68',b'Investments',b'Investeringen'
-b'DocType: Issue',b'Resolution Details',b'Oplossing Details'
-b'apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3',b'Allocations',b'Toekenningen'
-b'DocType: Item Quality Inspection Parameter',b'Acceptance Criteria',b'Acceptatiecriteria'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159',b'Please enter Material Requests in the above table',b'Vul Materiaal Verzoeken in de bovenstaande tabel'
-b'DocType: Item Attribute',b'Attribute Name',b'Attribuutnaam'
-b'DocType: BOM',b'Show In Website',b'Toon in Website'
-b'DocType: Shopping Cart Settings',b'Show Quantity in Website',b'Toon Hoeveelheid in Website'
-b'DocType: Employee Loan Application',b'Total Payable Amount',b'Totaal te betalen bedrag'
-b'DocType: Task',b'Expected Time (in hours)',b'Verwachte Tijd (in uren)'
-b'DocType: Item Reorder',b'Check in (group)',b'Check-in (groeps)'
-b'DocType: Soil Texture',b'Silt',b'Slib'
-,b'Qty to Order',b'Aantal te bestellen'
-b'DocType: Period Closing Voucher',"b'The account head under Liability or Equity, in which Profit/Loss will be booked'","b'De rekening hoofd onder Aansprakelijkheid of Equity, waarbij winst / verlies zal worden geboekt'"
-b'apps/erpnext/erpnext/config/projects.py +36',b'Gantt chart of all tasks.',b'Gantt-diagram van alle taken.'
-b'DocType: Opportunity',b'Mins to First Response',b'Minuten naar First Response'
-b'DocType: Pricing Rule',b'Margin Type',b'marge Type'
-b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15',b'{0} hours',b'{0} uren'
-b'DocType: Course',b'Default Grading Scale',b'Default Grading Scale'
-b'DocType: Appraisal',b'For Employee Name',b'Voor Naam werknemer'
-b'DocType: Holiday List',b'Clear Table',b'Wis Tabel'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119',b'Available slots',b'Beschikbare slots'
-b'DocType: C-Form Invoice Detail',b'Invoice No',b'Factuur nr.'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363',b'Make Payment',b'Betaling maken'
-b'DocType: Room',b'Room Name',b'Kamer naam'
-b'DocType: Prescription Duration',b'Prescription Duration',b'Voorschrift Duur'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81',"b'Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Verlaat niet kan worden toegepast / geannuleerd voordat {0}, als verlof balans al-carry doorgestuurd in de toekomst toewijzing verlof record is {1}'"
-b'DocType: Activity Cost',b'Costing Rate',b'Costing Rate'
-b'apps/erpnext/erpnext/config/selling.py +234',b'Customer Addresses And Contacts',b'Klant adressen en contacten'
-,b'Campaign Efficiency',b'Campagne-effici\xc3\xabntie'
-b'DocType: Discussion',b'Discussion',b'Discussie'
-b'DocType: Payment Entry',b'Transaction ID',b'Transactie ID'
-b'DocType: Volunteer',b'Anytime',b'Anytime'
-b'DocType: Patient',b'Surgical History',b'Chirurgische Geschiedenis'
-b'DocType: Employee',b'Resignation Letter Date',b'Ontslagbrief Datum'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39',b'Pricing Rules are further filtered based on quantity.',b'Prijsbepalingsregels worden verder gefilterd op basis van aantal.'
-b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127',b'Not Set',b'niet ingesteld'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Stel de datum van aansluiting in voor werknemer {0}'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Stel de datum van aansluiting in voor werknemer {0}'
-b'DocType: Task',b'Total Billing Amount (via Time Sheet)',b'Totaal Billing Bedrag (via Urenregistratie)'
-b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61',b'Repeat Customer Revenue',b'Terugkerende klanten Opbrengsten'
-b'DocType: Soil Texture',b'Silty Clay Loam',b'Silty Clay Loam'
-b'DocType: Chapter',b'Chapter',b'Hoofdstuk'
-b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Pair',b'paar'
-b'DocType: Mode of Payment Account',b'Default account will be automatically updated in POS Invoice when this mode is selected.',b'Het standaardaccount wordt automatisch bijgewerkt in POS Invoice wanneer deze modus is geselecteerd.'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970',b'Select BOM and Qty for Production',b'Selecteer BOM en Aantal voor productie'
-b'DocType: Asset',b'Depreciation Schedule',b'afschrijving Schedule'
-b'apps/erpnext/erpnext/config/selling.py +124',b'Sales Partner Addresses And Contacts',b'Verkooppartneradressen en contactpersonen'
-b'DocType: Bank Reconciliation Detail',b'Against Account',b'Tegen Rekening'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52',b'Half Day Date should be between From Date and To Date',b'Halve dag datum moet zijn tussen Van Datum en To Date'
-b'DocType: Maintenance Schedule Detail',b'Actual Date',b'Werkelijke Datum'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139',b'Please set the Default Cost Center in {0} company.',b'Stel het standaard kostenplaatsadres in {0} bedrijf in.'
-b'DocType: Item',b'Has Batch No',b'Heeft Batch nr.'
-b'apps/erpnext/erpnext/public/js/utils.js +106',b'Annual Billing: {0}',b'Jaarlijkse Billing: {0}'
-b'apps/erpnext/erpnext/config/accounts.py +200',b'Goods and Services Tax (GST India)',b'Goederen en Diensten Belasting (GST India)'
-b'DocType: Delivery Note',b'Excise Page Number',b'Accijnzen Paginanummer'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227',"b'Company, From Date and To Date is mandatory'","b'Company, Van Datum en tot op heden is verplicht'"
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33',b'Get from Consultation',b'Krijg van raadpleging'
-b'DocType: Asset',b'Purchase Date',b'aankoopdatum'
-b'DocType: Volunteer',b'Volunteer Type',b'Vrijwilligers type'
-b'DocType: Student',b'Personal Details',b'Persoonlijke Gegevens'
-b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193',"b""Please set 'Asset Depreciation Cost Center' in Company {0}""",b'Stel &#39;Asset Afschrijvingen Cost Center&#39; in Company {0}'
-,b'Maintenance Schedules',b'Onderhoudsschema&#39;s'
-b'DocType: Task',b'Actual End Date (via Time Sheet)',b'Werkelijke Einddatum (via Urenregistratie)'
-b'DocType: Soil Texture',b'Soil Type',b'Grondsoort'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387',b'Amount {0} {1} against {2} {3}',b'Bedrag {0} {1} tegen {2} {3}'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277',b'New Message',b'Nieuw bericht'
-,b'Quotation Trends',b'Offerte Trends'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160',b'Item Group not mentioned in item master for item {0}',b'Artikelgroep niet genoemd in Artikelstam voor Artikel {0}'
-b'DocType: GoCardless Mandate',b'GoCardless Mandate',b'GoCardless Mandate'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368',b'Debit To account must be a Receivable account',b'Debet Om rekening moet een vordering-account'
-b'DocType: Shipping Rule',b'Shipping Amount',b'Verzendbedrag'
-b'DocType: Supplier Scorecard Period',b'Period Score',b'Periode Score'
-b'apps/erpnext/erpnext/utilities/user_progress.py +66',b'Add Customers',b'Voeg klanten toe'
-b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Pending Amount',b'In afwachting van Bedrag'
-b'DocType: Lab Test Template',b'Special',b'speciaal'
-b'DocType: Purchase Order Item Supplied',b'Conversion Factor',b'Conversiefactor'
-b'DocType: Purchase Order',b'Delivered',b'Geleverd'
-,b'Vehicle Expenses',b'Voertuig kosten'
-b'DocType: Serial No',b'Invoice Details',b'Factuurgegevens'
-b'DocType: Grant Application',b'Show on Website',b'Weergeven op website'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +212',b'Expected value after useful life must be greater than or equal to {0}',b'Verwachtingswaarde na levensduur groter dan of gelijk aan {0}'
-b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29',b'Start on',b'Begin maar'
-b'DocType: Hub Category',b'Hub Category',b'Hubcategorie'
-b'DocType: Purchase Invoice',b'SEZ',b'SEZ'
-b'DocType: Purchase Receipt',b'Vehicle Number',b'Voertuig Aantal'
-b'DocType: Employee Loan',b'Loan Amount',b'Leenbedrag'
-b'DocType: Student Report Generation Tool',b'Add Letterhead',b'Voeg briefhoofd toe'
-b'DocType: Program Enrollment',b'Self-Driving Vehicle',b'Zelfrijdend voertuig'
-b'DocType: Supplier Scorecard Standing',b'Supplier Scorecard Standing',b'Leverancier Scorecard Standing'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443',b'Row {0}: Bill of Materials not found for the Item {1}',b'Rij {0}: Bill of Materials niet gevonden voor het artikel {1}'
-b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98',b'Total allocated leaves {0} cannot be less than already approved leaves {1} for the period',b'Totaal toegewezen bladeren {0} kan niet lager zijn dan die reeds zijn goedgekeurd bladeren {1} voor de periode'
-b'DocType: Journal Entry',b'Accounts Receivable',b'Debiteuren'
-,b'Supplier-Wise Sales Analytics',b'Leverancier-gebaseerde Verkoop Analyse'
-b'DocType: Purchase Invoice',b'Availed ITC Central Tax',b'Gebruikmaken van ITC Central Tax'
-b'DocType: Salary Structure',b'Select employees for current Salary Structure',b'Selecteer medewerkers voor de huidige beloningsstructuur'
-b'DocType: Sales Invoice',b'Company Address Name',b'Bedrijfs Adres Naam'
-b'DocType: Work Order',b'Use Multi-Level BOM',b'Gebruik Multi-Level Stuklijst'
-b'DocType: Bank Reconciliation',b'Include Reconciled Entries',b'Omvatten Reconciled Entries'
-b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Ouderlijke cursus (laat leeg, als dit niet deel uitmaakt van de ouderopleiding)'"
-b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Ouderlijke cursus (laat leeg, als dit niet deel uitmaakt van de ouderopleiding)'"
-b'DocType: Leave Control Panel',b'Leave blank if considered for all employee types',b'Laat leeg indien overwogen voor alle werknemer soorten'
-b'DocType: Landed Cost Voucher',b'Distribute Charges Based On',b'Verdeel Toeslagen op basis van'
-b'DocType: Projects Settings',b'Timesheets',b'timesheets'
-b'DocType: HR Settings',b'HR Settings',b'HR-instellingen'
-b'DocType: Salary Slip',b'net pay info',b'nettoloon info'
-b'DocType: Lab Test Template',b'This value is updated in the Default Sales Price List.',b'Deze waarde is bijgewerkt in de standaard verkoopprijslijst.'
-b'DocType: Email Digest',b'New Expenses',b'nieuwe Uitgaven'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79',b'PDC/LC Amount',b'PDC / LC Bedrag'
-b'DocType: Shareholder',b'Shareholder',b'Aandeelhouder'
-b'DocType: Purchase Invoice',b'Additional Discount Amount',b'Extra korting Bedrag'
-b'DocType: Cash Flow Mapper',b'Position',b'Positie'
-b'DocType: Patient',b'Patient Details',b'Patient Details'
-b'DocType: Patient',b'B Positive',b'B positief'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +596',"b'Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.'",b'Rij # {0}: Aantal moet 1 als item is een vaste activa. Gebruik aparte rij voor meerdere aantal.'
-b'DocType: Leave Block List Allow',b'Leave Block List Allow',b'Laat Block List Laat'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +317',b'Abbr can not be blank or space',b'Abbr kan niet leeg of ruimte'
-b'DocType: Patient Medical Record',b'Patient Medical Record',b'Patient Medical Record'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.js +68',b'Group to Non-Group',b'Groep om Non-groep'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50',b'Sports',b'Sport'
-b'DocType: Loan Type',b'Loan Name',b'lening Naam'
-b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Actual',b'Totaal Werkelijke'
-b'DocType: Lab Test UOM',b'Test UOM',b'Test UOM'
-b'DocType: Student Siblings',b'Student Siblings',b'student Broers en zussen'
-b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Unit',b'eenheid'
-b'apps/erpnext/erpnext/stock/get_item_details.py +138',b'Please specify Company',b'Specificeer Bedrijf'
-,b'Customer Acquisition and Loyalty',b'Klantenwerving en behoud'
-b'DocType: Asset Maintenance Task',b'Maintenance Task',b'Onderhoudstaak'
-b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118',b'Please set B2C Limit in GST Settings.',b'Stel B2C-limiet in GST-instellingen in.'
-b'DocType: Purchase Invoice',b'Warehouse where you are maintaining stock of rejected items',b'Magazijn waar u voorraad bijhoudt van afgewezen artikelen'
-b'DocType: Work Order',b'Skip Material Transfer',b'Materiaaloverdracht overslaan'
-b'DocType: Work Order',b'Skip Material Transfer',b'Materiaaloverdracht overslaan'
-b'apps/erpnext/erpnext/setup/utils.py +109',b'Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually',b'Kan wisselkoers voor {0} tot {1} niet vinden voor de sleuteldatum {2}. Cre\xc3\xaber alsjeblieft een valuta-wisselrecord'
-b'DocType: POS Profile',b'Price List',b'Prijslijst'
-b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22',b'{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.',b'{0} is nu het standaard Boekjaar. Ververs uw browser om de wijziging door te voeren .'
-b'apps/erpnext/erpnext/projects/doctype/task/task.js +45',b'Expense Claims',b'Declaraties'
-b'DocType: Issue',b'Support',b'Support'
-,b'BOM Search',b'BOM Zoeken'
-b'DocType: Project',b'Total Consumed Material Cost  (via Stock Entry)',b'Totale verbruikte materiaalkosten (via voorraadinvoer)'
-b'DocType: Item',"b'Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.'",b'Publiceer &#39;In voorraad&#39; of &#39;Niet op voorraad&#39; op Hub op basis van de voorraad die beschikbaar is in dit magazijn.'
-b'DocType: Vehicle',b'Fuel Type',b'Brandstoftype'
-b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27',b'Please specify currency in Company',b'Omschrijf valuta Company'
-b'DocType: Workstation',b'Wages per hour',b'Loon per uur'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47',b'Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}',b'Voorraadbalans in Batch {0} zal negatief worden {1} voor Artikel {2} in Magazijn {3}'
-b'apps/erpnext/erpnext/templates/emails/reorder_item.html +1',"b""Following Material Requests have been raised automatically based on Item's re-order level""",b'Volgende Material Aanvragen werden automatisch verhoogd op basis van re-order niveau-item'
-b'DocType: Email Digest',b'Pending Sales Orders',b'In afwachting van klantorders'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +312',b'Account {0} is invalid. Account Currency must be {1}',b'Account {0} is ongeldig. Account Valuta moet {1} zijn'
-b'DocType: Healthcare Settings',b'Remind Before',b'Herinner je alvast'
-b'apps/erpnext/erpnext/buying/utils.py +34',b'UOM Conversion factor is required in row {0}',b'Eenheid Omrekeningsfactor is vereist in rij {0}'
-b'DocType: Production Plan Item',b'material_request_item',b'material_request_item'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087',"b'Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry'","b'Rij # {0}: Reference document moet een van Sales Order, verkoopfactuur of Inboeken zijn'"
-b'DocType: Salary Component',b'Deduction',b'Aftrek'
-b'DocType: Item',b'Retain Sample',b'Bewaar monster'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115',b'Row {0}: From Time and To Time is mandatory.',b'Rij {0}: Van tijd en binnen Tijd is verplicht.'
-b'DocType: Stock Reconciliation Item',b'Amount Difference',b'bedrag Verschil'
-b'apps/erpnext/erpnext/stock/get_item_details.py +356',b'Item Price added for {0} in Price List {1}',b'Item Prijs toegevoegd {0} in de prijslijst {1}'
-b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8',b'Please enter Employee Id of this sales person',b'Vul Employee Id van deze verkoper'
-b'DocType: Territory',b'Classification of Customers by region',b'Indeling van de klanten per regio'
-b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71',b'In Production',b'In de maak'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65',b'Difference Amount must be zero',b'Verschil Bedrag moet nul zijn'
-b'DocType: Project',b'Gross Margin',b'Bruto Marge'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61',b'Please enter Production Item first',b'Vul eerst Productie Artikel in'
-b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45',b'Calculated Bank Statement balance',b'Berekende bankafschrift balans'
-b'DocType: Normal Test Template',b'Normal Test Template',b'Normaal Testsjabloon'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64',b'disabled user',b'Uitgeschakelde gebruiker'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919',b'Quotation',b'Offerte'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984',b'Cannot set a received RFQ to No Quote',b'Kan geen ontvangen RFQ zonder citaat instellen'
-b'DocType: Quotation',b'QTN-',b'QTN-'
-b'DocType: Salary Slip',b'Total Deduction',b'Totaal Aftrek'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18',b'Select an account to print in account currency',b'Selecteer een account om in rekeningsvaluta af te drukken'
-,b'Production Analytics',b'Production Analytics'
-b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6',b'This is based on transactions against this Patient. See timeline below for details',b'Dit is gebaseerd op transacties tegen deze pati\xc3\xabnt. Zie de tijdlijn hieronder voor details'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204',b'Cost Updated',b'Kosten Bijgewerkt'
-b'DocType: Patient',b'Date of Birth',b'Geboortedatum'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133',b'Item {0} has already been returned',b'Artikel {0} is al geretourneerd'
-b'DocType: Fiscal Year',b'**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.',b'**Boekjaar** staat voor een financieel jaar. Alle boekingen en andere belangrijke transacties worden bijgehouden in **boekjaar**.'
-b'DocType: Opportunity',b'Customer / Lead Address',b'Klant / Lead Adres'
-b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Setup',b'Leveranciers Scorecard Setup'
-b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133',b'Assessment Plan Name',b'Beoordeling plannaam'
-b'DocType: Work Order Operation',b'Work Order Operation',b'Werkorder operatie'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +233',b'Warning: Invalid SSL certificate on attachment {0}',b'Waarschuwing: Ongeldig SSL certificaat op attachment {0}'
-b'apps/erpnext/erpnext/utilities/activation.py +64',"b'Leads help you get business, add all your contacts and more as your leads'","b'Leads u helpen om zaken, voeg al uw contacten en nog veel meer als uw leads'"
-b'DocType: Work Order Operation',b'Actual Operation Time',b'Werkelijke Operatie Duur'
-b'DocType: Authorization Rule',b'Applicable To (User)',b'Van toepassing zijn op (Gebruiker)'
-b'DocType: Purchase Taxes and Charges',b'Deduct',b'Aftrekken'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238',b'Job Description',b'Functiebeschrijving'
-b'DocType: Student Applicant',b'Applied',b'Toegepast'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874',b'Re-open',b'Heropenen'
-b'DocType: Sales Invoice Item',b'Qty as per Stock UOM',b'Aantal per Voorraad eenheid'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59',b'Guardian2 Name',b'Guardian2 Naam'
-b'DocType: Purchase Invoice',b'02-Post Sale Discount',b'Korting na verkoop'
-b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132',"b'Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series'","b'Speciale tekens behalve ""-"" ""."", ""#"", en ""/"" niet toegestaan in de reeks'"
-b'DocType: Campaign',"b'Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.'","b'Blijf op de hoogte van Sales Campaigns. Blijf op de hoogte van Leads, Offertes, Sales Order etc van campagnes te meten Return on Investment.'"
-,b'SO Qty',b'VO Aantal'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91',b'The field To Shareholder cannot be blank',b'Het veld Naar aandeelhouder mag niet leeg zijn'
-b'DocType: Guardian',b'Work Address',b'Werk adres'
-b'DocType: Appraisal',b'Calculate Total Score',b'Bereken Totaalscore'
-b'DocType: Health Insurance',b'Health Insurance',b'Ziektekostenverzekering'
-b'DocType: Asset Repair',b'Manufacturing Manager',b'Productie Manager'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191',b'Serial No {0} is under warranty upto {1}',b'Serienummer {0} is onder garantie tot {1}'
-b'DocType: Plant Analysis Criteria',b'Minimum Permissible Value',b'Minimaal toelaatbare waarde'
-b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41',b'User {0} already exists',b'Gebruiker {0} bestaat al'
-b'apps/erpnext/erpnext/hooks.py +109',b'Shipments',b'Zendingen'
-b'DocType: Payment Entry',b'Total Allocated Amount (Company Currency)',b'Totaal toegewezen bedrag (Company Munt)'
-b'DocType: Purchase Order Item',b'To be delivered to customer',b'Om de klant te leveren'
-b'DocType: BOM',b'Scrap Material Cost',b'Scrap Materiaal Cost'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227',b'Serial No {0} does not belong to any Warehouse',b'Serienummer {0} niet behoren tot een Warehouse'
-b'DocType: Grant Application',b'Email Notification Sent',b'E-mailmelding verzonden'
-b'DocType: Purchase Invoice',b'In Words (Company Currency)',b'In Woorden (Bedrijfsvaluta)'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018',"b'Item Code, warehouse, quantity are required on row'","b'Artikelcode, magazijn, aantal is verplicht op rij'"
-b'DocType: Pricing Rule',b'Supplier',b'Leverancier'
-b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41',b'Show Payment Details',b'Toon betalingsgegevens'
-b'DocType: Consultation',b'Consultation Time',b'Raadplegingstijd'
-b'DocType: C-Form',b'Quarter',b'Kwartaal'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106',b'Miscellaneous Expenses',b'Diverse Kosten'
-b'DocType: Global Defaults',b'Default Company',b'Standaard Bedrijf'
-b'apps/erpnext/erpnext/controllers/stock_controller.py +227',b'Expense or Difference account is mandatory for Item {0} as it impacts overall stock value',b'Kosten- of verschillenrekening is verplicht voor artikel {0} omdat het invloed heeft op de totale voorraadwaarde'
-b'DocType: Payment Request',b'PR',b'PR'
-b'DocType: Cheque Print Template',b'Bank Name',b'Banknaam'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30',b'-Above',b'-Boven'
-b'DocType: Employee Loan',b'Employee Loan Account',b'Werknemer Leningsrekening'
-b'DocType: Leave Application',b'Total Leave Days',b'Totaal verlofdagen'
-b'DocType: Email Digest',b'Note: Email will not be sent to disabled users',b'Opmerking: E-mail wordt niet verzonden naar uitgeschakelde gebruikers'
-b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Aantal interacties'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +105',b'Item Variant Settings',b'Item Variant Settings'
-b'apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37',b'Select Company...',b'Selecteer Bedrijf ...'
-b'DocType: Leave Control Panel',b'Leave blank if considered for all departments',b'Laat leeg indien dit voor alle afdelingen is'
-b'apps/erpnext/erpnext/config/hr.py +228',"b'Types of employment (permanent, contract, intern etc.).'","b'Vormen van dienstverband (permanent, contract, stage, etc. ) .'"
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434',b'{0} is mandatory for Item {1}',b'{0} is verplicht voor Artikel {1}'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136',"b'Item {0}: {1} qty produced, '","b'Artikel {0}: {1} aantal geproduceerd,'"
-b'DocType: Payroll Entry',b'Fortnightly',b'van twee weken'
-b'DocType: Currency Exchange',b'From Currency',b'Van Valuta'
-b'DocType: Vital Signs',b'Weight (In Kilogram)',b'Gewicht (in kilogram)'
-b'DocType: Chapter',b'chapters/chapter_name\nleave blank automatically set after saving chapter.',b'hoofdstukken / hoofdstuknaam blanco laten automatisch ingesteld na hoofdstuk opslaan.'
-b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202',b'Please set GST Accounts in GST Settings',b'Stel GST-accounts in via GST-instellingen'
-b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31',b'Type of Business',b'Soort bedrijf'
-b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171',"b'Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row'","b'Selecteer toegewezen bedrag, Factuur Type en factuurnummer in tenminste \xc3\xa9\xc3\xa9n rij'"
-b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128',b'Cost of New Purchase',b'Kosten van nieuwe aankoop'
-b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35',b'All tasks for the detected diseases were imported',b'Alle taken voor de gedetecteerde ziekten werden ge\xc3\xafmporteerd'
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97',b'Sales Order required for Item {0}',b'Verkooporder nodig voor Artikel {0}'
-b'DocType: Grant Application',b'Grant Description',b'Grant Description'
-b'DocType: Purchase Invoice Item',b'Rate (Company Currency)',b'Tarief (Bedrijfsvaluta)'
-b'DocType: Student Guardian',b'Others',b'anderen'
-b'DocType: Payment Entry',b'Unallocated Amount',b'Niet-toegewezen bedrag'
-b'apps/erpnext/erpnext/templates/includes/product_page.js +91',b'Cannot find a matching Item. Please select some other value for {0}.',b'Kan een bijpassende Item niet vinden. Selecteer een andere waarde voor {0}.'
-b'DocType: POS Profile',b'Taxes and Charges',b'Belastingen en Toeslagen'
-b'DocType: Item',"b'A Product or a Service that is bought, sold or kept in stock.'","b'Een Product of een Dienst dat wordt gekocht, verkocht of in voorraad wordt gehouden.'"
-b'apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44',b'No more updates',b'Niet meer updates'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171',"b""Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row""","b""Kan het type lading niet selecteren als 'On Vorige Row Bedrag ' of ' On Vorige Row Totaal ' voor de eerste rij"""
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6',b'This covers all scorecards tied to this Setup',b'Dit omvat alle scorecards die aan deze Setup zijn gekoppeld'
-b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29',b'Child Item should not be a Product Bundle. Please remove item `{0}` and save',b'Onderliggend item mag geen productbundel zijn. Gelieve item `{0}` te verwijderen en op te slaan'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12',b'Banking',b'Bankieren'
-b'apps/erpnext/erpnext/utilities/activation.py +108',b'Add Timesheets',b'Voeg Timesheets'
-b'DocType: Vehicle Service',b'Service Item',b'dienst Item'
-b'DocType: Bank Guarantee',b'Bank Guarantee',b'Bankgarantie'
-b'DocType: Bank Guarantee',b'Bank Guarantee',b'Bankgarantie'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39',"b""Please click on 'Generate Schedule' to get schedule""","b""Klik op 'Genereer Planning' om planning te krijgen"""
-b'DocType: Bin',b'Ordered Quantity',b'Bestelde hoeveelheid'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +118',"b'e.g. ""Build tools for builders""'","b'bijv. ""Bouwgereedschap voor bouwers ""'"
-b'DocType: Grading Scale',b'Grading Scale Intervals',b'Grading afleeseenheden'
-b'apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39',b'Profit for the year',b'Jaarwinst'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125',b'{0} {1}: Accounting Entry for {2} can only be made in currency: {3}',b'{0} {1}: Accounting Entry voor {2} kan alleen worden gemaakt in valuta: {3}'
-b'DocType: Fee Schedule',b'In Process',b'In Process'
-b'DocType: Authorization Rule',b'Itemwise Discount',b'Artikelgebaseerde Korting'
-b'apps/erpnext/erpnext/config/accounts.py +75',b'Tree of financial accounts.',b'Boom van de financi\xc3\xable rekeningen.'
-b'DocType: Cash Flow Mapping',b'Cash Flow Mapping',b'Cash Flow Mapping'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364',b'{0} against Sales Order {1}',b'{0} tegen Verkooporder {1}'
-b'DocType: Account',b'Fixed Asset',b'Vast Activum'
-b'apps/erpnext/erpnext/config/stock.py +324',b'Serialized Inventory',b'Geserialiseerde Inventory'
-b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74',b'Email not found in default contact',b'E-mailadres niet gevonden in standaardcontact'
-b'DocType: Employee Loan',b'Account Info',b'Account informatie'
-b'DocType: Activity Type',b'Default Billing Rate',b'Default Billing Rate'
-b'DocType: Fees',b'Include Payment',b'Inclusief betaling'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Studentgroepen aangemaakt.'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Studentgroepen aangemaakt.'
-b'DocType: Sales Invoice',b'Total Billing Amount',b'Totaal factuurbedrag'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50',b'Program in the Fee Structure and Student Group {0} are different.',b'Het programma in de kostenstructuur en studentengroep {0} verschilt.'
-b'DocType: Fee Schedule',b'Receivable Account',b'Vorderingen Account'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +618',b'Row #{0}: Asset {1} is already {2}',b'Rij # {0}: Asset {1} al {2}'
-b'DocType: Quotation Item',b'Stock Balance',b'Voorraad Saldo'
-b'apps/erpnext/erpnext/config/selling.py +321',b'Sales Order to Payment',b'Sales om de betaling'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123',b'CEO',b'Directeur'
-b'DocType: Purchase Invoice',b'With Payment of Tax',b'Met betaling van de belasting'
-b'DocType: Expense Claim Detail',b'Expense Claim Detail',b'Kostendeclaratie Detail'
-b'DocType: Purchase Invoice',b'TRIPLICATE FOR SUPPLIER',b'TRIPLICATE VOOR LEVERANCIER'
-b'DocType: Land Unit',b'Is Container',b'Is Container'
-b'DocType: Crop Cycle',b'This will be day 1 of the crop cycle',b'Dit wordt dag 1 van de gewascyclus'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871',b'Please select correct account',b'Selecteer juiste account'
-b'DocType: Purchase Invoice Item',b'Weight UOM',b'Gewicht Eenheid'
-b'apps/erpnext/erpnext/config/accounts.py +466',b'List of available Shareholders with folio numbers',b'Lijst met beschikbare aandeelhouders met folionummers'
-b'DocType: Salary Structure Employee',b'Salary Structure Employee',b'Salarisstructuur Employee'
-b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45',b'Show Variant Attributes',b'Show Variant Attributes'
-b'DocType: Student',b'Blood Group',b'Bloedgroep'
-b'DocType: Course',b'Course Name',b'Cursus naam'
-b'DocType: Employee Leave Approver',"b""Users who can approve a specific employee's leave applications""",b'Gebruikers die verlofaanvragen een bepaalde werknemer kan goedkeuren'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52',b'Office Equipments',b'Kantoor Apparatuur'
-b'DocType: Purchase Invoice Item',b'Qty',b'Aantal'
-b'DocType: Fiscal Year',b'Companies',b'Bedrijven'
-b'DocType: Supplier Scorecard',b'Scoring Setup',b'Scoring instellen'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24',b'Electronics',b'elektronica'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326',b'Debit ({0})',b'Debet ({0})'
-b'DocType: Stock Settings',b'Raise Material Request when stock reaches re-order level',b'Maak Materiaal Aanvraag wanneer voorraad daalt tot onder het bestelniveau'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98',b'Full-time',b'Full-time'
-b'DocType: Payroll Entry',b'Employees',b'werknemers'
-b'DocType: Employee',b'Contact Details',b'Contactgegevens'
-b'DocType: C-Form',b'Received Date',b'Ontvangstdatum'
-b'DocType: Delivery Note',"b'If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.'","b'Als u een standaard template in Sales en -heffingen Template hebt gemaakt, selecteert u een en klik op de knop hieronder.'"
-b'DocType: BOM Scrap Item',b'Basic Amount (Company Currency)',b'Basisbedrag (Company Munt)'
-b'DocType: Student',b'Guardians',b'Guardians'
-b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13',b'Payment Confirmation',b'Betalingsbevestiging'
-b'DocType: Shopping Cart Settings',b'Prices will not be shown if Price List is not set',b'De prijzen zullen niet worden weergegeven als prijslijst niet is ingesteld'
-b'DocType: Stock Entry',b'Total Incoming Value',b'Totaal Inkomende Waarde'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362',b'Debit To is required',b'Debet Om vereist'
-b'apps/erpnext/erpnext/utilities/activation.py +109',"b'Timesheets help keep track of time, cost and billing for activites done by your team'","b'Timesheets helpen bijhouden van de tijd, kosten en facturering voor activiteiten gedaan door uw team'"
-b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'Purchase Price List',b'Purchase Price List'
-b'apps/erpnext/erpnext/config/buying.py +155',b'Templates of supplier scorecard variables.',b'Sjablonen van leveranciers scorecard variabelen.'
-b'DocType: Job Offer Term',b'Offer Term',b'Aanbod Term'
-b'DocType: Asset',b'Quality Manager',b'Quality Manager'
-b'DocType: Job Applicant',b'Job Opening',b'Vacature'
-b'DocType: Payment Reconciliation',b'Payment Reconciliation',b'Afletteren'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153',"b""Please select Incharge Person's name""",b'Selecteer de naam van de Verantwoordelijk Persoon'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51',b'Technology',b'technologie'
-b'DocType: Hub Settings',b'Unregister from Hub',b'Afmelden bij Hub'
-b'apps/erpnext/erpnext/public/js/utils.js +108',b'Total Unpaid: {0}',b'Totaal Onbetaalde: {0}'
-b'DocType: BOM Website Operation',b'BOM Website Operation',b'BOM Website Operation'
-b'DocType: Supplier Scorecard',b'Supplier Score',b'Leverancierscore'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +213',b'Total Invoiced Amt',b'Totale gefactureerde Amt'
-b'DocType: Supplier',b'Warn RFQs',b'Waarschuw RFQs'
-b'DocType: BOM',b'Conversion Rate',b'Conversion Rate'
-b'apps/erpnext/erpnext/templates/pages/product_search.html +3',b'Product Search',b'product zoeken'
-b'DocType: Assessment Plan',b'To Time',b'Tot Tijd'
-b'DocType: Authorization Rule',b'Approving Role (above authorized value)',b'Goedkeuren Rol (boven de toegestane waarde)'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118',b'Credit To account must be a Payable account',b'Credit Om rekening moet een betalend account zijn'
-b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43',b'Please select Student Admission which is mandatory for the paid student applicant',b'Selecteer een studententoelating die verplicht is voor de betaalde student-aanvrager'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355',b'BOM recursion: {0} cannot be parent or child of {2}',b'Stuklijst recursie: {0} mag niet ouder of kind zijn van {2}'
-b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21',b'Please select a Price List to publish pricing',b'Selecteer een prijslijst om prijzen te publiceren'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38',b'Budget List',b'Budgetlijst'
-b'DocType: Work Order Operation',b'Completed Qty',b'Voltooid aantal'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148',"b'For {0}, only debit accounts can be linked against another credit entry'","b'Voor {0}, kan alleen debet accounts worden gekoppeld tegen een andere creditering'"
-b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27',b'Price List {0} is disabled',b'Prijslijst {0} is uitgeschakeld'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127',b'Row {0}: Completed Qty cannot be more than {1} for operation {2}',b'Rij {0}: Voltooid Aantal kan niet meer zijn dan {1} voor de bediening {2}'
-b'DocType: Manufacturing Settings',b'Allow Overtime',b'Laat Overwerk'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Serialized Item {0} kan niet worden bijgewerkt met Stock Reconciliation, gebruik dan Voorraadinvoer'"
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Serialized Item {0} kan niet worden bijgewerkt met Stock Reconciliation, gebruik dan Voorraadinvoer'"
-b'DocType: Training Event Employee',b'Training Event Employee',b'Training Event Medewerker'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031',b'Maximum Samples - {0} can be retained for Batch {1} and Item {2}.',b'Maximum aantal voorbeelden - {0} kan worden bewaard voor batch {1} en item {2}.'
-b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7',b'Add Time Slots',b'Voeg tijdslots toe'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201',b'{0} Serial Numbers required for Item {1}. You have provided {2}.',b'{0} serienummers vereist voor post {1}. U hebt verstrekt {2}.'
-b'DocType: Stock Reconciliation Item',b'Current Valuation Rate',b'Huidige Valuation Rate'
-b'DocType: Training Event',b'Advance',b'Van te voren'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'for making recurring again.',b'om weer terug te keren.'
-b'apps/erpnext/erpnext/config/erpnext_integrations.py +13',b'GoCardless payment gateway settings',b'GoCardless betalingsgateway-instellingen'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122',b'Exchange Gain/Loss',b'Exchange winst / verlies'
-b'DocType: Opportunity',b'Lost Reason',b'Reden van verlies'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +265',b'Row #{0}: Account {1} does not belong to company {2}',b'Rij # {0}: account {1} hoort niet bij bedrijf {2}'
-b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30',b'Unable to find DocType {0}',b'Kon DocType {0} niet vinden'
-b'apps/erpnext/erpnext/public/js/templates/address_list.html +22',b'New Address',b'Nieuw adres'
-b'DocType: Quality Inspection',b'Sample Size',b'Monster grootte'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47',b'Please enter Receipt Document',b'Vul Ontvangst Document'
-b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369',b'All items have already been invoiced',b'Alle items zijn reeds gefactureerde'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49',"b""Please specify a valid 'From Case No.'""","b""Geef een geldig 'Van Zaaknummer'"""
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24',b'Further cost centers can be made under Groups but entries can be made against non-Groups',"b'Verdere kostenplaatsen kan in groepen worden gemaakt, maar items kunnen worden gemaakt tegen niet-Groepen'"
-b'apps/erpnext/erpnext/config/setup.py +66',b'Users and Permissions',b'Gebruikers en machtigingen'
-b'DocType: Vehicle Log',b'VLOG.',b'VLOG.'
-b'DocType: Branch',b'Branch',b'Tak'
-b'DocType: Soil Analysis',b'Ca/(K+Ca+Mg)',b'Ca / (K + Ca + Mg)'
-b'DocType: Delivery Trip',b'Fulfillment User',b'Vervul gebruiker'
-b'apps/erpnext/erpnext/config/setup.py +61',b'Printing and Branding',b'Printen en Branding'
-b'DocType: Company',b'Total Monthly Sales',b'Totale maandelijkse omzet'
-b'DocType: Agriculture Analysis Criteria',b'Weather',b'Weer'
-b'DocType: Bin',b'Actual Quantity',b'Werkelijke hoeveelheid'
-b'DocType: Shipping Rule',b'example: Next Day Shipping',b'Bijvoorbeeld: Next Day Shipping'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187',b'Serial No {0} not found',b'Serienummer {0} niet gevonden'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291',b'Subscription has been {0}',b'Abonnement is {0}'
-b'DocType: Fee Schedule Program',b'Fee Schedule Program',b'Fee Schedule Programma'
-b'DocType: Fee Schedule Program',b'Student Batch',b'student Batch'
-b'apps/erpnext/erpnext/utilities/activation.py +119',b'Make Student',b'maak Student'
-b'DocType: Supplier Scorecard Scoring Standing',b'Min Grade',b'Min Grade'
-b'apps/erpnext/erpnext/projects/doctype/project/project.py +218',b'You have been invited to collaborate on the project: {0}',b'U bent uitgenodigd om mee te werken aan het project: {0}'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157',b'Physician not available on {0}',b'Arts niet beschikbaar op {0}'
-b'DocType: Leave Block List Date',b'Block Date',b'Blokeer Datum'
-b'DocType: Crop',b'Crop',b'Gewas'
-b'DocType: Purchase Receipt',b'Supplier Delivery Note',b'Leveranciersleveringsnota'
-b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70',b'Apply Now',b'Nu toepassen'
-b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Werkelijk Aantal {0} / Aantal Wachten {1}'
-b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Werkelijk Aantal {0} / Aantal Wachten {1}'
-b'DocType: Purchase Invoice',b'E-commerce GSTIN',b'E-commerce GSTIN'
-b'DocType: Sales Order',b'Not Delivered',b'Niet geleverd'
-,b'Bank Clearance Summary',b'Bankbewaring samenvatting'
-b'apps/erpnext/erpnext/config/setup.py +106',"b'Create and manage daily, weekly and monthly email digests.'","b'Aanmaken en beheren van dagelijkse, wekelijkse en maandelijkse e-mail samenvattingen.'"
-b'DocType: Appraisal Goal',b'Appraisal Goal',b'Beoordeling Doel'
-b'DocType: Stock Reconciliation Item',b'Current Amount',b'Huidige hoeveelheid'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58',b'Buildings',b'Gebouwen'
-b'DocType: Fee Schedule',b'Fee Structure',b'fee Structuur'
-b'DocType: Timesheet Detail',b'Costing Amount',b'Costing Bedrag'
-b'DocType: Student Admission Program',b'Application Fee',b'Aanvraagkosten'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52',b'Submit Salary Slip',b'Indienen salarisstrook'
-b'apps/erpnext/erpnext/controllers/selling_controller.py +137',b'Maxiumm discount for Item {0} is {1}%',b'Maximum korting voor artikel {0} is {1} %'
-b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16',b'Import in Bulk',b'Import in bulk'
-b'DocType: Sales Partner',b'Address & Contacts',b'Adres & Contacten'
-b'DocType: SMS Log',b'Sender Name',b'Naam afzender'
-b'DocType: Agriculture Analysis Criteria',b'Agriculture Analysis Criteria',b'Criteria voor landbouwanalyse'
-b'DocType: POS Profile',b'[Select]',b'[Selecteer]'
-b'DocType: Vital Signs',b'Blood Pressure (diastolic)',b'Bloeddruk (diastolische)'
-b'DocType: SMS Log',b'Sent To',b'Verzenden Naar'
-b'DocType: Agriculture Task',b'Holiday Management',b'Vakantie Management'
-b'DocType: Payment Request',b'Make Sales Invoice',b'Maak verkoopfactuur'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61',b'Softwares',b'softwares'
-b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +53',b'Next Contact Date cannot be in the past',b'Volgende Contact datum kan niet in het verleden'
-b'DocType: Company',b'For Reference Only.',b'Alleen voor referentie.'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112',b'Physician {0} not available on {1}',b'Arts {0} niet beschikbaar op {1}'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2581',b'Select Batch No',b'Selecteer batchnummer'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61',b'Invalid {0}: {1}',b'Ongeldige {0}: {1}'
-,b'GSTR-1',b'GSTR-1'
-b'DocType: Purchase Invoice',b'PINV-RET-',b'PINV-terugwerkende'
-b'DocType: Fee Validity',b'Reference Inv',b'Referentie Inv'
-b'DocType: Sales Invoice Advance',b'Advance Amount',b'Voorschot Bedrag'
-b'DocType: Manufacturing Settings',b'Capacity Planning',b'Capaciteit Planning'
-b'DocType: Supplier Quotation',b'Rounding Adjustment (Company Currency',b'Afronding aanpassing (bedrijfsmunt'
-b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43',"b""'From Date' is required""","b""'Van Datum' is vereist"""
-b'DocType: Journal Entry',b'Reference Number',b'Referentienummer'
-b'DocType: Employee',b'Employment Details',b'Dienstverband Details'
-b'DocType: Employee',b'New Workplace',b'Nieuwe werkplek'
-b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17',b'Set as Closed',b'Instellen als Gesloten'
-b'apps/erpnext/erpnext/stock/get_item_details.py +127',b'No Item with Barcode {0}',b'Geen Artikel met Barcode {0}'
-b'DocType: Normal Test Items',b'Require Result Value',b'Vereiste resultaatwaarde'
-b'DocType: Item',b'Show a slideshow at the top of the page',b'Laat een diavoorstelling zien aan de bovenkant van de pagina'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532',b'Boms',b'Boms'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +162',b'Stores',b'Winkels'
-b'DocType: Project Type',b'Projects Manager',b'Projecten Manager'
-b'DocType: Serial No',b'Delivery Time',b'Levertijd'
-b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33',b'Ageing Based On',b'Vergrijzing Based On'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61',b'Appointment cancelled',b'Benoeming geannuleerd'
-b'DocType: Item',b'End of Life',b'End of Life'
-b'apps/erpnext/erpnext/demo/setup/setup_data.py +331',b'Travel',b'reizen'
-b'DocType: Student Report Generation Tool',b'Include All Assessment Group',b'Inclusief alle beoordelingsgroep'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183',b'No active or default Salary Structure found for employee {0} for the given dates',b'Geen actieve of default salarisstructuur gevonden voor werknemer {0} de uitgekozen datum'
-b'DocType: Leave Block List',b'Allow Users',b'Gebruikers toestaan'
-b'DocType: Purchase Order',b'Customer Mobile No',b'Klant Mobile Geen'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1',b'Recurring',b'Terugkerende'
-b'DocType: Cash Flow Mapping Template Details',b'Cash Flow Mapping Template Details',b'Cash Flow Mapping Template-details'
-b'DocType: Cost Center',b'Track separate Income and Expense for product verticals or divisions.',b'Volg afzonderlijke baten en lasten over het product verticalen of divisies.'
-b'DocType: Rename Tool',b'Rename Tool',b'Hernoem Tool'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72',b'Update Cost',b'Kosten bijwerken'
-b'DocType: Item Reorder',b'Item Reorder',b'Artikel opnieuw ordenen'
-b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463',b'Show Salary Slip',b'Show loonstrook'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849',b'Transfer Material',b'Verplaats Materiaal'
-b'DocType: Fees',b'Send Payment Request',b'Verzend betalingsverzoek'
-b'DocType: BOM',"b'Specify the operations, operating cost and give a unique Operation no to your operations.'","b'Geef de operaties, operationele kosten en geef een unieke operatienummer aan uw activiteiten .'"
-b'DocType: Water Analysis',b'Origin',b'Oorsprong'
-b'apps/erpnext/erpnext/controllers/status_updater.py +204',b'This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?',b'Dit document is dan limiet van {0} {1} voor punt {4}. Bent u het maken van een andere {3} tegen dezelfde {2}?'
-b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1154',b'Please set recurring after saving',b'Stel terugkerende na het opslaan'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769',b'Select change amount account',b'Selecteer verandering bedrag rekening'
-b'DocType: Purchase Invoice',b'Price List Currency',b'Prijslijst Valuta'
-b'DocType: Naming Series',b'User must always select',b'Gebruiker moet altijd kiezen'
-b'DocType: Stock Settings',b'Allow Negative Stock',b'Laat Negatieve voorraad'
-b'DocType: Installation Note',b'Installation Note',b'Installatie Opmerking'
-b'DocType: Soil Texture',b'Clay',b'Klei'
-b'DocType: Topic',b'Topic',b'Onderwerp'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45',b'Cash Flow from Financing',b'De cashflow uit financi\xc3\xable activiteiten'
-b'DocType: Budget Account',b'Budget Account',b'budget account'
-b'DocType: Quality Inspection',b'Verified By',b'Geverifieerd door'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +78',"b""Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.""",b'Kan standaard valuta van het bedrijf niet veranderen want er zijn bestaande transacties. Transacties moeten worden geannuleerd om de standaard valuta te wijzigen.'
-b'DocType: Cash Flow Mapping',b'Is Income Tax Liability',b'Is de aansprakelijkheid van de inkomstenbelasting'
-b'DocType: Grading Scale Interval',b'Grade Description',b'Grade Beschrijving'
-b'DocType: Stock Entry',b'Purchase Receipt No',b'Ontvangstbevestiging nummer'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30',b'Earnest Money',b'Onderpand'
-b'DocType: Sales Invoice',b' Shipping Bill Number',b'Scheepsbriefnummer'
-b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34',b'Traceability',b'traceerbaarheid'
-b'DocType: Asset Maintenance Log',b'Actions performed',b'Uitgevoerde acties'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51',b'Customer &gt; Customer Group &gt; Territory',b'Klant&gt; Klantengroep&gt; Gebied'
-b'DocType: Cash Flow Mapper',b'Section Leader',b'Sectieleider'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137',b'Source of Funds (Liabilities)',b'Bron van Kapitaal (Passiva)'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +431',b'Quantity in row {0} ({1}) must be same as manufactured quantity {2}',b'Hoeveelheid in rij {0} ({1}) moet hetzelfde zijn als geproduceerde hoeveelheid {2}'
-b'DocType: Supplier Scorecard Scoring Standing',b'Employee',b'Werknemer'
-b'DocType: Asset Repair',b'Failure Date',b'Failure Date'
-b'DocType: Sample Collection',b'Collected Time',b'Verzamelde tijd'
-b'DocType: Company',b'Sales Monthly History',b'Verkoop Maandelijkse Geschiedenis'
-b'DocType: Asset Maintenance Task',b'Next Due Date',b'volgende vervaldatum'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214',b'Select Batch',b'Selecteer batch'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244',b'{0} {1} is fully billed',b'{0} {1} is volledig gefactureerd'
-b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31',b'Vital Signs',b'Vital Signs'
-b'DocType: Training Event',b'End Time',b'Eindtijd'
-b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63',b'Active Salary Structure {0} found for employee {1} for the given dates',b'Actieve salarisstructuur {0} gevonden voor werknemer {1} de uitgekozen datum'
-b'DocType: Payment Entry',b'Payment Deductions or Loss',b'Betaling Aftrek of verlies'
-b'DocType: Soil Analysis',b'Soil Analysis Criterias',b'Bodemanalyse Criterias'
-b'apps/erpnext/erpnext/config/setup.py +42',b'Standard contract terms for Sales or Purchase.',b'Standaard contractvoorwaarden voor Verkoop of Inkoop .'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +112',b'Group by Voucher',b'Groep volgens Voucher'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233',b'Are you sure you want to cancel this appointment?',b'Weet je zeker dat je deze afspraak wilt annuleren?'
-b'DocType: Hotel Room Pricing Package',b'Hotel Room Pricing Package',b'Prijsarrangement hotelkamer'
-b'apps/erpnext/erpnext/config/crm.py +6',b'Sales Pipeline',b'Sales Pipeline'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201',b'Please set default account in Salary Component {0}',b'Stel standaard account aan Salaris Component {0}'
-b'apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7',b'Required On',b'Vereist op'
-b'DocType: Rename Tool',b'File to Rename',b'Bestand naar hernoemen'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200',b'Please select BOM for Item in Row {0}',b'Selecteer BOM voor post in rij {0}'
-b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28',b'Account {0} does not match with Company {1} in Mode of Account: {2}',b'Rekening {0} komt niet overeen met Bedrijf {1} in Rekeningmodus: {2}'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +464',b'Specified BOM {0} does not exist for Item {1}',b'Gespecificeerde Stuklijst {0} bestaat niet voor Artikel {1}'
-b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301',b'Course: ',b'Cursus:'
-b'DocType: Soil Texture',b'Sandy Loam',b'Zandige leem'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232',b'Maintenance Schedule {0} must be cancelled before cancelling this Sales Order',b'Onderhoudsschema {0} moet worden geannuleerd voordat het annuleren van deze verkooporder'
-b'DocType: POS Profile',b'Applicable for Users',b'Toepasbaar voor gebruikers'
-b'DocType: Notification Control',b'Expense Claim Approved',b'Kostendeclaratie Goedgekeurd'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231',b'No Work Orders created',b'Geen werkorders aangemaakt'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321',b'Salary Slip of employee {0} already created for this period',b'Loonstrook van de werknemer {0} al gemaakt voor deze periode'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155',b'Pharmaceutical',b'Farmaceutisch'
-b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Cost of Purchased Items',b'Kosten van gekochte artikelen'
-b'DocType: Selling Settings',b'Sales Order Required',b'Verkooporder Vereist'
-b'DocType: Purchase Invoice',b'Credit To',b'Met dank aan'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceDate',b'PieceDate'
-b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31',b'Active Leads / Customers',b'Actieve Leads / Klanten'
-b'DocType: Employee Education',b'Post Graduate',b'Post Doctoraal'
-b'DocType: Maintenance Schedule Detail',b'Maintenance Schedule Detail',b'Onderhoudsschema Detail'
-b'DocType: Supplier Scorecard',b'Warn for new Purchase Orders',b'Waarschuw voor nieuwe inkooporders'
-b'DocType: Quality Inspection Reading',b'Reading 9',b'Meting 9'
-b'DocType: Supplier',b'Is Frozen',b'Is Bevroren'
-b'apps/erpnext/erpnext/stock/utils.py +224',b'Group node warehouse is not allowed to select for transactions',b'Groep knooppunt magazijn is niet toegestaan om te kiezen voor transacties'
-b'DocType: Buying Settings',b'Buying Settings',b'Inkoop Instellingen'
-b'DocType: Stock Entry Detail',b'BOM No. for a Finished Good Item',b'Stuklijst nr voor een Gereed Product Artikel'
-b'DocType: Upload Attendance',b'Attendance To Date',b'Aanwezigheid graag:'
-b'DocType: Request for Quotation Supplier',b'No Quote',b'Geen citaat'
-b'DocType: Warranty Claim',b'Raised By',b'Opgevoed door'
-b'DocType: Payment Gateway Account',b'Payment Account',b'Betaalrekening'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909',b'Please specify Company to proceed',b'Specificeer Bedrijf om verder te gaan'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27',b'Net Change in Accounts Receivable',b'Netto wijziging in Debiteuren'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88',b'Compensatory Off',b'compenserende Off'
-b'DocType: Job Offer',b'Accepted',b'Geaccepteerd'
-b'DocType: Grant Application',b'Organization',b'Organisatie'
-b'DocType: BOM Update Tool',b'BOM Update Tool',b'BOM Update Tool'
-b'DocType: SG Creation Tool Course',b'Student Group Name',b'Student Group Name'
-b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17',b'Show exploded view',b'Show exploded view'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7',b'Creating Fees',b'Fees cre\xc3\xabren'
-b'apps/erpnext/erpnext/setup/doctype/company/company.js +91',b'Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.',b'Zorg ervoor dat u echt wilt alle transacties voor dit bedrijf te verwijderen. Uw stamgegevens zal blijven zoals het is. Deze actie kan niet ongedaan gemaakt worden.'
-b'apps/erpnext/erpnext/templates/pages/product_search.html +21',b'Search Results',b'Zoekresultaten'
-b'DocType: Room',b'Room Number',b'Kamernummer'
-b'apps/erpnext/erpnext/utilities/transaction_base.py +107',b'Invalid reference {0} {1}',b'Ongeldige referentie {0} {1}'
-b'DocType: Shipping Rule',b'Shipping Rule Label',b'Verzendregel Label'
-b'DocType: Journal Entry Account',b'Payroll Entry',b'Payroll Entry'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75',b'View Fees Records',b'Bekijk tarieven Records'
-b'apps/erpnext/erpnext/setup/doctype/company/company.js +35',b'Make Tax Template',b'Maak belastingsjabloon'
-b'apps/erpnext/erpnext/public/js/conf.js +28',b'User Forum',b'Gebruikers Forum'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319',b'Raw Materials cannot be blank.',b'Grondstoffen kan niet leeg zijn.'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498',"b'Could not update stock, invoice contains drop shipping item.'","b'Kon niet bijwerken voorraad, factuur bevat daling van de scheepvaart punt.'"
-b'DocType: Lab Test Sample',b'Lab Test Sample',b'Lab Test Sample'
-b'DocType: Item Variant Settings',b'Allow Rename Attribute Value',b'Toestaan Rename attribuutwaarde toestaan'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491',b'Quick Journal Entry',b'Quick Journal Entry'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200',b'You can not change rate if BOM mentioned agianst any item',b'U kunt het tarief niet veranderen als een artikel Stuklijst-gerelateerd is.'
-b'DocType: Restaurant',b'Invoice Series Prefix',b'Prefix voor factuurreeks'
-b'DocType: Employee',b'Previous Work Experience',b'Vorige Werkervaring'
-b'DocType: Stock Entry',b'For Quantity',b'Voor Aantal'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205',b'Please enter Planned Qty for Item {0} at row {1}',b'Vul Gepland Aantal in voor artikel {0} op rij {1}'
-b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93',b'Google Maps integration is not enabled',b'Integratie met Google Maps is niet ingeschakeld'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241',b'{0} {1} is not submitted',b'{0} {1} is niet ingediend'
-b'DocType: Member',b'Membership Expiry Date',b'Vervaldatum lidmaatschap'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131',b'{0} must be negative in return document',b'{0} moet negatief zijn in teruggave document'
-,b'Minutes to First Response for Issues',b'Minuten naar First Response voor problemen'
-b'DocType: Purchase Invoice',b'Terms and Conditions1',b'Algemene Voorwaarden1'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +109',b'The name of the institute for which you are setting up this system.',b'De naam van het instituut waarvoor u het opzetten van dit systeem.'
-b'DocType: Accounts Settings',"b'Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.'","b'Boekingen bevroren tot deze datum, niemand kan / de boeking wijzigen behalve de hieronder gespecificeerde rol.'"
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116',b'Please save the document before generating maintenance schedule',b'Sla het document op voordat u het onderhoudsschema genereert'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30',b'Latest price updated in all BOMs',b'Laatste prijs bijgewerkt in alle BOM&#39;s'
-b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28',b'Project Status',b'Project Status'
-b'DocType: UOM',b'Check this to disallow fractions. (for Nos)',b'Aanvinken om delingen te verbieden.'
-b'DocType: Student Admission Program',b'Naming Series (for Student Applicant)',b'Naming Series (voor Student Aanvrager)'
-b'DocType: Delivery Note',b'Transporter Name',b'Vervoerder Naam'
-b'DocType: Authorization Rule',b'Authorized Value',b'Authorized Value'
-b'DocType: BOM',b'Show Operations',b'Toon Operations'
-,b'Minutes to First Response for Opportunity',b'Minuten naar First Response voor Opportunity'
-b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Absent',b'Totaal Afwezig'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +862',b'Item or Warehouse for row {0} does not match Material Request',b'Artikel of Magazijn voor rij {0} komt niet overeen met Materiaal Aanvraag'
-b'apps/erpnext/erpnext/config/stock.py +191',b'Unit of Measure',b'Meeteenheid'
-b'DocType: Fiscal Year',b'Year End Date',b'Jaar Einddatum'
-b'DocType: Task Depends On',b'Task Depends On',b'Taak Hangt On'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026',b'Opportunity',b'Opportunity'
-b'DocType: Operation',b'Default Workstation',b'Standaard Werkstation'
-b'DocType: Notification Control',b'Expense Claim Approved Message',b'Kostendeclaratie Goedgekeurd Bericht'
-b'DocType: Payment Entry',b'Deductions or Loss',b'Aftrek of verlies'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247',b'{0} {1} is closed',b'{0} {1} is gesloten'
-b'DocType: Email Digest',b'How frequently?',b'Hoe vaak?'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55',b'Total Collected: {0}',b'Totaal verzameld: {0}'
-b'DocType: Purchase Receipt',b'Get Current Stock',b'Get Huidige voorraad'
-b'DocType: Purchase Invoice',b'ineligible',b'niet in aanmerking komen'
-b'apps/erpnext/erpnext/config/manufacturing.py +46',b'Tree of Bill of Materials',b'Boom van de Bill of Materials'
-b'DocType: Student',b'Joining Date',b'Datum indiensttreding'
-,b'Employees working on a holiday',b'Werknemers die op vakantie'
-b'DocType: Share Balance',b'Current State',b'Huidige toestand'
-b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152',b'Mark Present',b'Mark Present'
-b'DocType: Share Transfer',b'From Shareholder',b'Van aandeelhouder'
-b'DocType: Project',b'% Complete Method',b'% Voltooid Methode'
-b'apps/erpnext/erpnext/healthcare/setup.py +181',b'Drug',b'drug'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200',b'Maintenance start date can not be before delivery date for Serial No {0}',b'Onderhoud startdatum kan niet voor de leveringsdatum voor Serienummer {0}'
-b'DocType: Work Order',b'Actual End Date',b'Werkelijke Einddatum'
-b'DocType: Cash Flow Mapping',b'Is Finance Cost Adjustment',b'Is aanpassing van financi\xc3\xable kosten'
-b'DocType: BOM',b'Operating Cost (Company Currency)',b'Bedrijfskosten (Company Munt)'
-b'DocType: Purchase Invoice',b'PINV-',b'PINV-'
-b'DocType: Authorization Rule',b'Applicable To (Role)',b'Van toepassing zijn op (Rol)'
-b'DocType: BOM Update Tool',b'Replace BOM',b'Vervang BOM'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110',b'Code {0} already exist',b'Code {0} bestaat al'
-b'DocType: Employee Advance',b'Purpose',b'Doel'
-b'DocType: Company',b'Fixed Asset Depreciation Settings',b'Fixed Asset Afschrijvingen Instellingen'
-b'DocType: Item',b'Will also apply for variants unless overrridden',b'Geldt ook voor varianten tenzij overrridden'
-b'DocType: Purchase Invoice',b'Advances',b'Vooruitgang'
-b'DocType: Work Order',b'Manufacture against Material Request',b'Fabricage tegen Material Request'
-b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14',b'Assessment Group: ',b'Evaluatiegroep:'
-b'DocType: Item Reorder',b'Request for',b'Verzoek tot'
-b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32',b'Approving User cannot be same as user the rule is Applicable To',b'Goedkeuring van Gebruiker kan niet hetzelfde zijn als gebruiker de regel is van toepassing op'
-b'DocType: Stock Entry Detail',b'Basic Rate (as per Stock UOM)',b'Basistarief (per eenheid)'
-b'DocType: SMS Log',b'No of Requested SMS',b'Aantal gevraagde SMS'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246',b'Leave Without Pay does not match with approved Leave Application records',b'Onbetaald verlof komt niet overeen met de goedgekeurde verlofaanvraag verslagen'
-b'DocType: Campaign',b'Campaign-.####',b'Campagne-.####'
-b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21',b'Next Steps',b'Volgende stappen'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796',b'Please supply the specified items at the best possible rates',b'Gelieve de opgegeven items aan de best mogelijke prijzen'
-b'DocType: Membership',b'USD',b'Amerikaanse Dollar'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28',b'Make Invoice',b'Maak Factuur'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80',b'Remaining Balance',b'Resterende saldo'
-b'DocType: Selling Settings',b'Auto close Opportunity after 15 days',b'Auto dicht Opportunity na 15 dagen'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86',b'Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.',b'Aankooporders zijn niet toegestaan voor {0} door een scorecard van {1}.'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +498',b'Barcode {0} is not a valid {1} code',b'Barcode {0} is geen geldige {1} code'
-b'apps/erpnext/erpnext/public/js/financial_statements.js +83',b'End Year',b'Eindjaar'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / Lead%'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / Lead%'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +124',b'Contract End Date must be greater than Date of Joining',b'Contract Einddatum moet groter zijn dan datum van indiensttreding zijn'
-b'DocType: Driver',b'Driver',b'Bestuurder'
-b'DocType: Vital Signs',b'Nutrition Values',b'Voedingswaarden'
-b'DocType: Lab Test Template',b'Is billable',b'Is facturabel'
-b'DocType: Delivery Note',b'DN-',b'DN'
-b'DocType: Sales Partner',b'A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.',b'Een derde partij distributeur / dealer / commissionair / affiliate / reseller die uw producten voor een commissie verkoopt.'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376',b'{0} against Purchase Order {1}',b'{0} tegen Inkooporder {1}'
-b'DocType: Patient',b'Patient Demographics',b'Patient Demographics'
-b'DocType: Task',b'Actual Start Date (via Time Sheet)',b'Werkelijke Startdatum (via Urenregistratie)'
-b'apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15',b'This is an example website auto-generated from ERPNext',"b'Dit is een voorbeeld website, automatisch gegenereerd door ERPNext'"
-b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43',b'Ageing Range 1',b'Vergrijzing Range 1'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212',b'Total advance amount cannot be greater than total claimed amount',b'Het totale voorschotbedrag kan niet groter zijn dan het totaalbedrag waarvoor een claim is ingediend'
-b'DocType: Purchase Taxes and Charges Template',"b'Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.'","b'Standaard belasting sjabloon die kan worden toegepast op alle inkooptransacties. Deze sjabloon kan lijst van fiscale hoofden en ook andere kosten koppen als ""Verzenden"", ""Verzekering"" bevatten, ""Omgaan met"" enz \n\n #### Opmerking \n\n De belastingdruk die u hier definieert zal het normale belastingtarief voor alle ** Items worden **. Als er ** Items ** dat verschillende tarieven hebben, moeten ze worden toegevoegd in de ** Item Tax ** tafel in de ** Item ** meester.\n\n #### Beschrijving van Kolommen \n\n 1. Berekening Type: \n - Dit kan op ** Netto Totaal ** (dat is de som van het basisbedrag).\n - ** Op Vorige Row Total / Bedrag ** (voor cumulatieve belastingen of heffingen). Als u deze optie selecteert, zal de belasting worden berekend als een percentage van de vorige rij (in de fiscale tabel) bedrag of totaal.\n - ** Werkelijke ** (zoals vermeld).\n 2. Account Head: De Account grootboek waaronder deze belasting \n 3 zal worden geboekt. Cost Center: Als de belasting / heffing is een inkomen (zoals de scheepvaart) of kosten die het nodig heeft tegen een kostenplaats worden geboekt.\n 4. Beschrijving: Beschrijving van de belasting (die zullen worden afgedrukt in de facturen / offertes).\n 5. Rate: belastingtarief.\n 6. Bedrag: BTW bedrag.\n 7. Totaal: Cumulatief totaal op dit punt.\n 8. Voer Row: Als op basis van ""Vorige Row Total"" kunt u het rijnummer die zullen worden genomen als basis voor deze berekening (standaard is de vorige rij) te selecteren.\n 9. Overweeg Tax of Charge voor: In dit gedeelte kunt u aangeven of de belasting / heffing is alleen voor de waardering (geen deel uit van het totaal) of alleen voor de totale (voegt niets toe aan het item) of voor beide.\n 10. Toe te voegen of Trek: Of u wilt toevoegen of aftrekken van de belasting.'"
-b'DocType: Homepage',b'Homepage',b'Startpagina'
-b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68',b'Select Physician...',b'Selecteer arts ...'
-b'DocType: Grant Application',b'Grant Application Details ',b'Aanvraagdetails toekennen'
-b'DocType: Purchase Receipt Item',b'Recd Quantity',b'Benodigde hoeveelheid'
-b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65',b'Fee Records Created - {0}',b'Fee Records Gemaakt - {0}'
-b'DocType: Asset Category Account',b'Asset Category Account',b'Asset Categorie Account'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913',b'Row #{0} (Payment Table): Amount must be positive',b'Rij # {0} (betalingstabel): bedrag moet positief zijn'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteNum',b'CompteNum'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137',b'Cannot produce more Item {0} than Sales Order quantity {1}',b'Kan niet meer produceren van Artikel {0} dan de Verkooporder hoeveelheid {1}'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +391',b'Select Attribute Values',b'Selecteer kenmerkwaarden'
-b'DocType: Purchase Invoice',b'Reason For Issuing document',b'Reden voor afgifte document'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539',b'Stock Entry {0} is not submitted',b'Stock Entry {0} is niet ingediend'
-b'DocType: Payment Reconciliation',b'Bank / Cash Account',b'Bank- / Kasrekening'
-b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +47',b'Next Contact By cannot be same as the Lead Email Address',b'Volgende Contact Door het kan niet hetzelfde zijn als de Lead e-mailadres'
-b'DocType: Tax Rule',b'Billing City',b'Stad'
-b'DocType: Asset',b'Manual',b'handboek'
-b'DocType: Salary Component Account',b'Salary Component Account',b'Salaris Component Account'
-b'DocType: Global Defaults',b'Hide Currency Symbol',b'Verberg Valutasymbool'
-b'apps/erpnext/erpnext/config/non_profit.py +58',b'Donor information.',b'Donorinformatie.'
-b'apps/erpnext/erpnext/config/accounts.py +330',"b'e.g. Bank, Cash, Credit Card'","b'bijv. Bank, Kas, Credit Card'"
-b'DocType: Lead Source',b'Source Name',b'Bron naam'
-b'DocType: Vital Signs',"b'Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""'","b'Normale rustende bloeddruk bij een volwassene is ongeveer 120 mmHg systolisch en 80 mmHg diastolisch, afgekort &quot;120/80 mmHg&quot;'"
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +119',"b'Set items shelf life in days, to set expiry based on manufacturing_date plus self life'","b'Stel de houdbaarheid van items in dagen in, om de vervaldatum in te stellen op basis van manufacturing_date plus zelfredzaamheid'"
-b'DocType: Journal Entry',b'Credit Note',b'Creditnota'
-b'DocType: Projects Settings',b'Ignore Employee Time Overlap',b'Negeer overlap tussen werknemerstijd'
-b'DocType: Warranty Claim',b'Service Address',b'Service Adres'
-b'DocType: Asset Maintenance Task',b'Calibration',b'ijking'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97',b'{0} is a company holiday',b'{0} is een bedrijfsvakantie'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49',b'Furnitures and Fixtures',b'Meubels en Wedstrijden'
-b'DocType: Item',b'Manufacture',b'Fabricage'
-b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Company',b'Setup Company'
-,b'Lab Test Report',b'Lab Test Report'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13',b'Please Delivery Note first',b'Gelieve Afleveringsbon eerste'
-b'DocType: Student Applicant',b'Application Date',b'Application Date'
-b'DocType: Salary Detail',b'Amount based on formula',b'Bedrag op basis van de formule'
-b'DocType: Purchase Invoice',b'Currency and Price List',b'Valuta en Prijslijst'
-b'DocType: Opportunity',b'Customer / Lead Name',b'Klant / Lead Naam'
-b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115',b'Clearance Date not mentioned',b'Ontruiming Datum niet vermeld'
-b'apps/erpnext/erpnext/config/manufacturing.py +7',b'Production',b'productie'
-b'DocType: Guardian',b'Occupation',b'Bezetting'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74',b'Row {0}:Start Date must be before End Date',b'Rij {0} : Start Datum moet voor Einddatum zijn'
-b'DocType: Crop',b'Planting Area',b'Plant gebied'
-b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Qty)',b'Totaal (Aantal)'
-b'DocType: Installation Note Item',b'Installed Qty',b'Aantal ge\xc3\xafnstalleerd'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4',b'This could be because of some invalid Email Addresses in the',b'Dit kan zijn door sommige ongeldige e-mailadressen in de'
-b'apps/erpnext/erpnext/utilities/user_progress.py +31',b'You added ',b'Jij voegde toe'
-b'DocType: Purchase Taxes and Charges',b'Parenttype',b'Parenttype'
-b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10',b'Training Result',b'training Resultaat'
-b'DocType: Purchase Invoice',b'Is Paid',b'Is betaald'
-b'DocType: Salary Structure',b'Total Earning',b'Totale Winst'
-b'DocType: Purchase Receipt',b'Time at which materials were received',b'Tijdstip waarop materialen zijn ontvangen'
-b'DocType: Products Settings',b'Products per Page',b'Producten per pagina'
-b'DocType: Stock Ledger Entry',b'Outgoing Rate',b'Uitgaande Rate'
-b'apps/erpnext/erpnext/config/hr.py +233',b'Organization branch master.',b'Organisatie tak meester .'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +313',b' or ',b'of'
-b'DocType: Sales Order',b'Billing Status',b'Factuurstatus'
-b'apps/erpnext/erpnext/public/js/conf.js +32',b'Report an Issue',b'Issue melden?'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120',b'Utility Expenses',b'Utiliteitskosten'
-b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64',b'90-Above',b'90-Boven'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252',b'Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher',b'Rij # {0}: Journal Entry {1} heeft geen account {2} of al vergeleken met een ander voucher'
-b'DocType: Supplier Scorecard Criteria',b'Criteria Weight',b'Criteria Gewicht'
-b'DocType: Buying Settings',b'Default Buying Price List',b'Standaard Inkoop Prijslijst'
-b'DocType: Payroll Entry',b'Salary Slip Based on Timesheet',b'Salarisstrook Op basis van Timesheet'
-b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43',b'Buying Rate',b'Koopsnelheid'
-b'DocType: Notification Control',b'Sales Order Message',b'Verkooporder Bericht'
-b'apps/erpnext/erpnext/config/setup.py +15',"b'Set Default Values like Company, Currency, Current Fiscal Year, etc.'","b'Instellen Standaardwaarden zoals Bedrijf , Valuta , huidige boekjaar , etc.'"
-b'DocType: Payment Entry',b'Payment Type',b'Betaling Type'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',b'Selecteer een partij voor item {0}. Kan geen enkele batch vinden die aan deze eis voldoet'
-b'DocType: Hub Category',b'Parent Category',b'Bovenliggende categorie'
-b'DocType: Payroll Entry',b'Select Employees',b'Selecteer Medewerkers'
-b'DocType: Opportunity',b'Potential Sales Deal',b'Potenti\xc3\xable Sales Deal'
-b'DocType: Complaint',b'Complaints',b'klachten'
-b'DocType: Payment Entry',b'Cheque/Reference Date',b'Cheque / Reference Data'
-b'DocType: Purchase Invoice',b'Total Taxes and Charges',b'Totaal belastingen en toeslagen'
-b'DocType: Employee',b'Emergency Contact',b'Noodgeval Contact'
-b'DocType: Bank Reconciliation Detail',b'Payment Entry',b'betaling Entry'
-,b'sales-browser',b'sales-browser'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.js +79',b'Ledger',b'Grootboek'
-b'DocType: Patient Medical Record',b'PMR-',b'PMR-'
-b'DocType: Drug Prescription',b'Drug Code',b'Drug Code'
-b'DocType: Target Detail',b'Target  Amount',b'Streefbedrag'
-b'DocType: POS Profile',b'Print Format for Online',b'Afdrukformaat voor online'
-b'DocType: Shopping Cart Settings',b'Shopping Cart Settings',b'Winkelwagen Instellingen'
-b'DocType: Journal Entry',b'Accounting Entries',b'Boekingen'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17',"b""If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.""","b'Als de geselecteerde prijsbepalingsregel is gemaakt voor &#39;Tarief&#39;, overschrijft deze de prijslijst. Prijzen Regel tarief is het laatste tarief, dus geen verdere korting moet worden toegepast. Daarom wordt het bij transacties zoals klantorder, inkooporder, enz. Opgehaald in het veld &#39;Tarief&#39; in plaats van het veld &#39;Prijslijstsnelheid&#39;.'"
-b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24',b'Duplicate Entry. Please check Authorization Rule {0}',b'Dubbele invoer. Controleer Autorisatie Regel {0}'
-b'DocType: Journal Entry Account',b'Reference Due Date',b'Referentie vervaldag'
-b'DocType: Purchase Order',b'Ref SQ',b'Ref SQ'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55',b'Receipt document must be submitted',b'Ontvangst document moet worden ingediend'
-b'DocType: Purchase Invoice Item',b'Received Qty',b'Ontvangen Aantal'
-b'DocType: Stock Entry Detail',b'Serial No / Batch',b'Serienummer / Batch'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340',b'Not Paid and Not Delivered',b'Niet betaald en niet geleverd'
-b'DocType: Product Bundle',b'Parent Item',b'Bovenliggend Artikel'
-b'DocType: Account',b'Account Type',b'Rekening Type'
-b'DocType: Delivery Note',b'DN-RET-',b'DN-terugwerkende'
-b'apps/erpnext/erpnext/templates/pages/projects.html +58',b'No time sheets',b'Geen tijd sheets'
-b'DocType: GoCardless Mandate',b'GoCardless Customer',b'GoCardless klant'
-b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123',b'Leave Type {0} cannot be carry-forwarded',b'Verlaat Type {0} kan niet worden doorgestuurd dragen-'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215',"b""Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'""","b""Onderhoudsschema wordt niet gegenereerd voor alle items . Klik op ' Generate Schedule'"""
-,b'To Produce',b'Produceren'
-b'apps/erpnext/erpnext/config/hr.py +93',b'Payroll',b'Loonlijst'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196',"b'For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included'","b'Voor rij {0} in {1}. Om {2} onder in punt tarief, rijen {3} moet ook opgenomen worden'"
-b'DocType: Patient Service Unit',b'Parent Service Unit',b'Parent Service Unit'
-b'apps/erpnext/erpnext/utilities/activation.py +101',b'Make User',b'maak Gebruiker'
-b'DocType: Packing Slip',b'Identification of the package for the delivery (for print)',b'Identificatie van het pakket voor de levering (voor afdrukken)'
-b'DocType: Bin',b'Reserved Quantity',b'Gereserveerde Hoeveelheid'
-b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Vul alstublieft een geldig e-mailadres in'
-b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Vul alstublieft een geldig e-mailadres in'
-b'DocType: Volunteer Skill',b'Volunteer Skill',b'Vrijwillige vaardigheid'
-b'DocType: Bank Reconciliation',b'Include POS Transactions',b'POS-transacties opnemen'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +784',b'Please select an item in the cart',b'Selecteer een item in de winkelwagen'
-b'DocType: Landed Cost Voucher',b'Purchase Receipt Items',b'Ontvangstbevestiging Artikelen'
-b'apps/erpnext/erpnext/config/learn.py +21',b'Customizing Forms',b'Aanpassen Formulieren'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74',b'Arrear',b'achterstand'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158',b'Depreciation Amount during the period',b'Afschrijvingen bedrag gedurende de periode'
-b'apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43',b'Disabled template must not be default template',b'Gehandicapte template mag niet standaard template'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314',b'For row {0}: Enter planned qty',b'Voor rij {0}: Voer het geplande aantal in'
-b'DocType: Shareholder',b'SH-',b'SH'
-b'DocType: Account',b'Income Account',b'Inkomstenrekening'
-b'DocType: Payment Request',"b""Amount in customer's currency""",b'Bedrag in de valuta van de klant'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825',b'Delivery',b'Levering'
-b'DocType: Volunteer',b'Weekdays',b'Doordeweekse dagen'
-b'DocType: Stock Reconciliation Item',b'Current Qty',b'Huidige Aantal'
-b'DocType: Restaurant Menu',b'Restaurant Menu',b'Restaurant Menu'
-b'apps/erpnext/erpnext/templates/generators/item_group.html +36',b'Prev',b'Vorige'
-b'DocType: Appraisal Goal',b'Key Responsibility Area',b'Key verantwoordelijkheid Area'
-b'apps/erpnext/erpnext/utilities/activation.py +127',"b'Student Batches help you track attendance, assessments and fees for students'","b'Student Batches helpen bijhouden opkomst, evaluaties en kosten voor studenten'"
-b'DocType: Payment Entry',b'Total Allocated Amount',b'Totaal toegewezen bedrag'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +151',b'Set default inventory account for perpetual inventory',b'Stel standaard inventaris rekening voor permanente inventaris'
-b'DocType: Item Reorder',b'Material Request Type',b'Materiaal Aanvraag Type'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252',b'Accural Journal Entry for salaries from {0} to {1}',b'Accural Journal Entry voor de salarissen van {0} tot {1}'
-b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17',b'Send Grant Review Email',b'Verstuur Grant Review Email'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +848',"b'LocalStorage is full, did not save'","b'LocalStorage vol is, niet te redden'"
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100',b'Row {0}: UOM Conversion Factor is mandatory',b'Rij {0}: Verpakking Conversie Factor is verplicht'
-b'apps/erpnext/erpnext/utilities/user_progress.py +235',b'Room Capacity',b'Kamer capaciteit'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95',b'Ref',b'Ref'
-b'DocType: Lab Test',b'LP-',b'LP-'
-b'DocType: Healthcare Settings',b'Registration Fee',b'Zonder registratie'
-b'DocType: Budget',b'Cost Center',b'Kostenplaats'
-b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45',b'Voucher #',b'Coupon #'
-b'DocType: Notification Control',b'Purchase Order Message',b'Inkooporder Bericht'
-b'DocType: Tax Rule',b'Shipping Country',b'Verzenden Land'
-b'DocType: Selling Settings',"b""Hide Customer's Tax Id from Sales Transactions""",b'Hide Klant het BTW-nummer van Verkooptransacties'
-b'DocType: Upload Attendance',b'Upload HTML',b'Upload HTML'
-b'DocType: Employee',b'Relieving Date',b'Ontslagdatum'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14',"b'Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.'","b'Prijsbepalingsregel overschrijft de prijslijst / defininieer een kortingspercentage, gebaseerd op een aantal criteria.'"
-b'DocType: Serial No',b'Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt',b'Magazijn kan alleen via Voorraad Invoer / Vrachtbrief / Ontvangstbewijs worden veranderd'
-b'DocType: Employee Education',b'Class / Percentage',b'Klasse / Percentage'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134',b'Head of Marketing and Sales',b'Hoofd Marketing en Verkoop'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72',b'Income Tax',b'Inkomstenbelasting'
-b'apps/erpnext/erpnext/config/selling.py +174',b'Track Leads by Industry Type.',b'Houd Leads bij per de industrie type.'
-b'apps/erpnext/erpnext/utilities/user_progress.py +101',b'Go to Letterheads',b'Ga naar Briefhoofden'
-b'DocType: Item Supplier',b'Item Supplier',b'Artikel Leverancier'
-b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1255',b'Please enter Item Code to get batch no',b'Vul de artikelcode  in om batchnummer op te halen'
-b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880',b'Please select a value for {0} quotation_to {1}',b'Selecteer een waarde voor {0} quotation_to {1}'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419',b'No Items selected for transfer',b'Geen items geselecteerd voor overdracht'
-b'apps/erpnext/erpnext/config/selling.py +46',b'All Addresses.',b'Alle adressen.'
-b'DocType: Company',b'Stock Settings',b'Voorraad Instellingen'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +183',"b'Merging is only possible if following properties are same in both records. Is Group, Root Type, Company'","b'Samenvoegen kan alleen als volgende eigenschappen in beide registers. Is Group, Root Type, Company'"
-b'DocType: Vehicle',b'Electric',b'elektrisch'
-b'DocType: Task',b'% Progress',b'% Voortgang'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123',b'Gain/Loss on Asset Disposal',b'Winst / verlies op de verkoop van activa'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117',b'Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.',b'Accountnummer voor account {0} is niet beschikbaar. <br> Stel uw rekeningschema correct in.'
-b'DocType: Task',b'Depends on Tasks',b'Hangt af van Taken'
-b'apps/erpnext/erpnext/config/selling.py +36',b'Manage Customer Group Tree.',b'Beheer Customer Group Boom .'
-b'DocType: Shopping Cart Settings',b'Attachments can be shown without enabling the shopping cart',b'Bijlagen kunnen worden getoond zonder de winkelwagentje in te schakelen'
-b'DocType: Normal Test Items',b'Result Value',b'Resultaat Waarde'
-b'DocType: Hotel Room',b'Hotels',b'hotels'
-b'DocType: Supplier Quotation',b'SQTN-',b'SQTN-'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22',b'New Cost Center Name',b'Nieuwe Kostenplaats Naam'
-b'DocType: Leave Control Panel',b'Leave Control Panel',b'Verlof Configuratiescherm'
-b'DocType: Project',b'Task Completion',b'Task Completion'
-b'apps/erpnext/erpnext/templates/includes/product_page.js +22',b'Not in Stock',b'Niet op voorraad'
-b'DocType: Volunteer',b'Volunteer Skills',b'Vrijwilligersvaardigheden'
-b'DocType: Appraisal',b'HR User',b'HR Gebruiker'
-b'DocType: Purchase Invoice',b'Taxes and Charges Deducted',b'Belastingen en Toeslagen Afgetrokken'
-b'apps/erpnext/erpnext/hooks.py +142',b'Issues',b'Kwesties'
-b'apps/erpnext/erpnext/controllers/status_updater.py +12',b'Status must be one of {0}',b'Status moet \xc3\xa9\xc3\xa9n zijn van {0}'
-b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64',b'Reminder to update GSTIN Sent',b'Herinnering om GSTIN verzonden te updaten'
-b'DocType: Sales Invoice',b'Debit To',b'Debitering van'
-b'DocType: Restaurant Menu Item',b'Restaurant Menu Item',b'Restaurant Menu-item'
-b'DocType: Delivery Note',b'Required only for sample item.',b'Alleen benodigd voor Artikelmonster.'
-b'DocType: Stock Ledger Entry',b'Actual Qty After Transaction',b'Werkelijke Aantal Na Transactie'
-,b'Pending SO Items For Purchase Request',b'In afwachting van Verkoop Artikelen voor Inkoopaanvraag'
-b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35',b'Student Admissions',b'studentenadministratie'
-b'apps/erpnext/erpnext/accounts/party.py +388',b'{0} {1} is disabled',b'{0} {1} is uitgeschakeld'
-b'DocType: Supplier',b'Billing Currency',b'Valuta'
-b'DocType: Sales Invoice',b'SINV-RET-',b'SINV-terugwerkende'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200',b'Extra Large',b'Extra Groot'
-b'DocType: Crop',b'Scientific Name',b'Wetenschappelijke naam'
-b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Leaves',b'Totaal Leaves'
-b'DocType: Customer',"b'Reselect, if the chosen contact is edited after save'","b'Selecteer opnieuw, als het gekozen contact is bewerkt na opslaan'"
-b'DocType: Consultation',b'In print',b'In druk'
-,b'Profit and Loss Statement',b'Winst-en verliesrekening'
-b'DocType: Bank Reconciliation Detail',b'Cheque Number',b'Cheque nummer'
-,b'Sales Browser',b'Verkoop verkenner'
-b'DocType: Journal Entry',b'Total Credit',b'Totaal Krediet'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542',b'Warning: Another {0} # {1} exists against stock entry {2}',b'Waarschuwing: Een andere {0} # {1} bestaat tegen voorraad binnenkomst {2}'
-b'apps/erpnext/erpnext/utilities/user_progress_utils.py +66',b'Local',b'Lokaal'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26',b'Loans and Advances (Assets)',b'Leningen en voorschotten (Activa)'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12',b'Debtors',b'Debiteuren'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199',b'Large',b'Groot'
-b'DocType: Homepage Featured Product',b'Homepage Featured Product',b'Homepage Featured Product'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248',b'All Assessment Groups',b'Alle Assessment Groepen'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15',b'New Warehouse Name',b'Nieuwe Warehouse Naam'
-b'apps/erpnext/erpnext/accounts/report/financial_statements.py +259',b'Total {0} ({1})',b'Totaal {0} ({1})'
-b'DocType: C-Form Invoice Detail',b'Territory',b'Regio'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151',b'Please mention no of visits required',b'Vermeld het benodigde aantal bezoeken'
-b'DocType: Stock Settings',b'Default Valuation Method',b'Standaard Waarderingsmethode'
-b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26',b'Fee',b'honorarium'
-b'apps/erpnext/erpnext/setup/doctype/company/company.js +154',b'Update in progress. It might take a while.',b'Update wordt uitgevoerd. Het kan even duren.'
-b'DocType: Production Plan Item',b'Produced Qty',b'Geproduceerd aantal'
-b'DocType: Vehicle Log',b'Fuel Qty',b'brandstof Aantal'
-b'DocType: Stock Entry',b'Target Warehouse Name',b'Target Warehouse Name'
-b'DocType: Work Order Operation',b'Planned Start Time',b'Geplande Starttijd'
-b'DocType: Course',b'Assessment',b'Beoordeling'
-b'DocType: Payment Entry Reference',b'Allocated',b'Toegewezen'
-b'apps/erpnext/erpnext/config/accounts.py +267',b'Close Balance Sheet and book Profit or Loss.',b'Sluiten Balans en boek Winst of verlies .'
-b'DocType: Student Applicant',b'Application Status',b'Application Status'
-b'DocType: Sensitivity Test Items',b'Sensitivity Test Items',b'Gevoeligheid Test Items'
-b'DocType: Project Update',b'Project Update',b'Project update'
-b'DocType: Fees',b'Fees',b'vergoedingen'
-b'DocType: Currency Exchange',b'Specify Exchange Rate to convert one currency into another',b'Specificeer Wisselkoers om een valuta om te zetten in een andere'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159',b'Quotation {0} is cancelled',b'Offerte {0} is geannuleerd'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119',b'Total Outstanding Amount',b'Totale uitstaande bedrag'
-b'DocType: Sales Partner',b'Targets',b'Doelen'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54',b'Please register the SIREN number in the company information file',b'Registreer het SIREN-nummer in het bedrijfsinformatiedossier'
-b'DocType: Price List',b'Price List Master',b'Prijslijst Master'
-b'DocType: GST Account',b'CESS Account',b'CESS-account'
-b'DocType: Sales Person',b'All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.',"b'Alle Verkoop Transacties kunnen worden gelabeld tegen meerdere ** Sales Personen **, zodat u kunt instellen en controleren doelen.'"
-,b'S.O. No.',b'VO nr'
-b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241',b'Please create Customer from Lead {0}',b'Maak Klant van Lead {0}'
-b'apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3',b'Select Patient',b'Selecteer Pati\xc3\xabnt'
-b'DocType: Price List',b'Applicable for Countries',b'Toepasselijk voor Landen'
-b'DocType: Supplier Scorecard Scoring Variable',b'Parameter Name',b'Parameter Naam'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52',b'Student Group Name is mandatory in row {0}',b'Student groepsnaam is verplicht in de rij {0}'
-b'DocType: Homepage',b'Products to be shown on website homepage',b'Producten die worden getoond op de website homepage'
-b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13',b'This is a root customer group and cannot be edited.',b'Dit is een basis klantgroep en kan niet worden bewerkt .'
-b'DocType: Student',b'AB-',b'AB-'
-b'DocType: POS Profile',b'Ignore Pricing Rule',b'Negeer Prijsregel'
-b'DocType: Employee Education',b'Graduate',b'Afstuderen'
-b'DocType: Leave Block List',b'Block Days',b'Blokeer Dagen'
-b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83',"b'Shipping Address does not have country, which is required for this Shipping Rule'","b'Verzendadres heeft geen land, wat nodig is voor deze verzendregel'"
-b'DocType: Journal Entry',b'Excise Entry',b'Accijnzen Boeking'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65',"b""Warning: Sales Order {0} already exists against Customer's Purchase Order {1}""",b'Waarschuwing: Sales Order {0} bestaat al tegen Klant Bestelling {1}'
-b'DocType: Terms and Conditions',"b'Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.'","b""Algemene Voorwaarden die kunnen worden toegevoegd aan de verkopen en aankopen.\n\n Voorbeelden: \n\n 1. Geldigheid van het aanbod.\n 1. Betalingscondities (In Advance, op krediet, een deel vooraf etc).\n 1. Wat is extra (of ten laste van de Klant).\n 1. Veiligheid / gebruik waarschuwing.\n 1. Garantie indien van toepassing.\n 1. Returns Policy '.\n 1. Termen van de scheepvaart, indien van toepassing.\n 1. Methoden voor het aanpakken geschillen, schadevergoeding, aansprakelijkheid, enz. \n 1. Adres en contactgegevens van uw bedrijf."""
-b'DocType: Issue',b'Issue Type',b'Uitgiftetype'
-b'DocType: Attendance',b'Leave Type',b'Verlof Type'
-b'DocType: Purchase Invoice',b'Supplier Invoice Details',b'Leverancier Invoice Details'
-b'DocType: Agriculture Task',b'Ignore holidays',b'Vakantie negeren'
-b'apps/erpnext/erpnext/controllers/stock_controller.py +233',"b""Expense / Difference account ({0}) must be a 'Profit or Loss' account""","b""Kosten- / Verschillenrekening ({0}) moet een 'Winst of Verlies' rekening zijn."""
-b'DocType: Project',b'Copied From',b'Gekopieerd van'
-b'DocType: Project',b'Copied From',b'Gekopieerd van'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340',b'Invoice already created for all billing hours',b'Factuur al gemaakt voor alle factureringsuren'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96',b'Name error: {0}',b'Naam fout: {0}'
-b'DocType: Cash Flow Mapping',b'Is Finance Cost',b'Zijn financi\xc3\xable kosten'
-b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18',b'Attendance for employee {0} is already marked',b'Aanwezigheid voor werknemer {0} is al gemarkeerd'
-b'DocType: Packing Slip',b'If more than one package of the same type (for print)',b'Als er meer dan een pakket van hetzelfde type (voor afdrukken)'
-b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27',b'Please set default customer in Restaurant Settings',b'Stel de standaardklant in in restaurantinstellingen'
-,b'Salary Register',b'salaris Register'
-b'DocType: Warehouse',b'Parent Warehouse',b'Parent Warehouse'
-b'DocType: C-Form Invoice Detail',b'Net Total',b'Netto Totaal'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +546',b'Default BOM not found for Item {0} and Project {1}',b'Standaard BOM niet gevonden voor Item {0} en Project {1}'
-b'apps/erpnext/erpnext/config/hr.py +168',b'Define various loan types',b'Definieer verschillende soorten lening'
-b'DocType: Bin',b'FCFS Rate',b'FCFS Rate'
-b'DocType: Opening Invoice Creation Tool Item',b'Outstanding Amount',b'Openstaand Bedrag'
-b'apps/erpnext/erpnext/templates/generators/bom.html +71',b'Time(in mins)',b'Tijd (in minuten)'
-b'DocType: Project Task',b'Working',b'Werkzaam'
-b'DocType: Stock Ledger Entry',b'Stock Queue (FIFO)',b'Voorraad rij (FIFO)'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +127',b'Financial Year',b'Financieel jaar'
-b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46',b'{0} does not belong to Company {1}',b'{0} behoort niet tot Bedrijf {1}'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66',b'Could not solve criteria score function for {0}. Make sure the formula is valid.',b'Kan de criteria score functie voor {0} niet oplossen. Zorg ervoor dat de formule geldig is.'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122',b'Cost as on',b'Kosten Op'
-b'DocType: Healthcare Settings',b'Out Patient Settings',b'Out Patient Settings'
-b'DocType: Account',b'Round Off',b'Afronden'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259',b'Quantity must be positive',b'De hoeveelheid moet positief zijn'
-b'DocType: Material Request Plan Item',b'Requested Qty',b'Aangevraagde Hoeveelheid'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96',b'The fields From Shareholder and To Shareholder cannot be blank',b'De velden Van Aandeelhouder en Aandeelhouder mogen niet leeg zijn'
-b'DocType: Tax Rule',b'Use for Shopping Cart',b'Gebruik voor de Winkelwagen'
-b'apps/erpnext/erpnext/controllers/item_variant.py +101',b'Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}',b'Waarde {0} voor Attribute {1} bestaat niet in de lijst van geldige Punt Attribute Values voor post {2}'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79',b'Select Serial Numbers',b'Selecteer serienummers'
-b'DocType: BOM Item',b'Scrap %',b'Scrap%'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46',"b'Charges will be distributed proportionately based on item qty or amount, as per your selection'","b'Kosten zullen worden proportioneel gedistribueerd op basis van punt aantal of de hoeveelheid, als per uw selectie'"
-b'DocType: Maintenance Visit',b'Purposes',b'Doeleinden'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112',b'Atleast one item should be entered with negative quantity in return document',b'Minstens \xc3\xa9\xc3\xa9n punt moet in ruil document worden ingevoerd met een negatieve hoeveelheid'
-b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71',"b'Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations'","b'Operation {0} langer dan alle beschikbare werktijd in werkstation {1}, breken de operatie in meerdere operaties'"
-b'DocType: Membership',b'Membership Status',b'Lidmaatschapsstatus'
-,b'Requested',b'Aangevraagd'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93',b'No Remarks',b'Geen Opmerkingen'
-b'DocType: Asset',b'In Maintenance',b'In onderhoud'
-b'DocType: Purchase Invoice',b'Overdue',b'Achterstallig'
-b'DocType: Account',b'Stock Received But Not Billed',b'Voorraad ontvangen maar nog niet gefactureerd'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +84',b'Root Account must be a group',b'Root account moet een groep'
-b'DocType: Drug Prescription',b'Drug Prescription',b'Drug Prescription'
-b'DocType: Fees',b'FEE.',b'FEE.'
-b'DocType: Employee Loan',b'Repaid/Closed',b'Afgelost / Gesloten'
-b'DocType: Item',b'Total Projected Qty',b'Totale geraamde Aantal'
-b'DocType: Monthly Distribution',b'Distribution Name',b'Distributie Naam'
-b'apps/erpnext/erpnext/stock/stock_ledger.py +477',"b'Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry'","b'Waarderingspercentage niet gevonden voor het item {0}, die vereist is om boekhoudkundige vermeldingen voor {1} {2} te doen. Als het item als een nulwaarderingspercentage in de {1} wordt verwerkt, vermeld dan dat in de {1} Item tabel. Anders kunt u een inkomende voorraadtransactie voor het item maken of een waarderingspercentage vermelden in het Item-record, en probeer dan deze invoer te verzenden / annuleren'"
-b'DocType: Course',b'Course Code',b'cursus Code'
-b'apps/erpnext/erpnext/controllers/stock_controller.py +337',b'Quality Inspection required for Item {0}',b'Kwaliteitscontrole vereist voor Artikel {0}'
-b'DocType: POS Settings',b'Use POS in Offline Mode',b'Gebruik POS in de offline modus'
-b'DocType: Supplier Scorecard',b'Supplier Variables',b'Leveranciersvariabelen'
-b'DocType: Quotation',"b""Rate at which customer's currency is converted to company's base currency""",b'Koers waarmee de Klant Valuta wordt omgerekend naar de basis bedrijfsvaluta'
-b'DocType: Purchase Invoice Item',b'Net Rate (Company Currency)',b'Net Rate (Company Valuta)'
-b'DocType: Salary Detail',b'Condition and Formula Help',b'Toestand en Formula Help'
-b'apps/erpnext/erpnext/config/selling.py +105',b'Manage Territory Tree.',b'Beheer Grondgebied Boom.'
-b'DocType: Patient Service Unit',b'Patient Service Unit',b'Patient Service Unit'
-b'DocType: Journal Entry Account',b'Sales Invoice',b'Verkoopfactuur'
-b'DocType: Journal Entry Account',b'Party Balance',b'Partij Balans'
-b'DocType: Cash Flow Mapper',b'Section Subtotal',b'Sectie Subtotaal'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +498',b'Please select Apply Discount On',b'Selecteer Apply Korting op'
-b'DocType: Stock Settings',b'Sample Retention Warehouse',b'Sample Retention Warehouse'
-b'DocType: Company',b'Default Receivable Account',b'Standaard Vordering Account'
-b'DocType: Physician Schedule',b'Physician Schedule',b'Arts schema'
-b'DocType: Purchase Invoice',b'Deemed Export',b'Geachte export'
-b'DocType: Stock Entry',b'Material Transfer for Manufacture',b'Materiaal Verplaatsing voor Productie'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20',b'Discount Percentage can be applied either against a Price List or for all Price List.',b'Kortingspercentage kan worden toegepast tegen een prijslijst of voor alle prijslijsten.'
-b'DocType: Subscription',b'Half-yearly',b'Halfjaarlijks'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407',b'Accounting Entry for Stock',b'Boekingen voor Voorraad'
-b'DocType: Lab Test',b'LabTest Approver',b'LabTest Approver'
-b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61',b'You have already assessed for the assessment criteria {}.',b'U heeft al beoordeeld op de beoordelingscriteria {}.'
-b'DocType: Vehicle Service',b'Engine Oil',b'Motorolie'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1005',b'Work Orders Created: {0}',b'Werkorders aangemaakt: {0}'
-b'DocType: Sales Invoice',b'Sales Team1',b'Verkoop Team1'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +547',b'Item {0} does not exist',b'Artikel {0} bestaat niet'
-b'DocType: Sales Invoice',b'Customer Address',b'Klant Adres'
-b'DocType: Employee Loan',b'Loan Details',b'Loan Details'
-b'DocType: Company',b'Default Inventory Account',b'Standaard Inventaris Account'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192',b'The folio numbers are not matching',b'De folionummers komen niet overeen'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124',b'Row {0}: Completed Qty must be greater than zero.',b'Rij {0}: Voltooid Aantal moet groter zijn dan nul.'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262',b'Payment Request for {0}',b'Betalingsverzoek voor {0}'
-b'DocType: Item Barcode',b'Barcode Type',b'Streepjescodetype'
-b'DocType: Antibiotic',b'Antibiotic Name',b'Antibiotische naam'
-b'DocType: Purchase Invoice',b'Apply Additional Discount On',b'Breng Extra Korting op'
-b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66',b'Select Type...',b'Selecteer type...'
-b'DocType: Crop Cycle',b'A link to all the Land Units in which the Crop is growing',b'Een link naar alle landeenheden waarin het gewas groeit'
-b'DocType: Account',b'Root Type',b'Root Type'
-b'DocType: Item',b'FIFO',b'FIFO'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136',b'Row # {0}: Cannot return more than {1} for Item {2}',b'Rij # {0}: Kan niet meer dan terugkeren {1} voor post {2}'
-b'DocType: Item Group',b'Show this slideshow at the top of the page',b'Laat deze slideshow aan de bovenkant van de pagina'
-b'DocType: BOM',b'Item UOM',b'Artikel Eenheid'
-b'DocType: Sales Taxes and Charges',b'Tax Amount After Discount Amount (Company Currency)',b'Belasting Bedrag na korting Bedrag (Company valuta)'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177',b'Target warehouse is mandatory for row {0}',b'Doel magazijn is verplicht voor rij {0}'
-b'DocType: Cheque Print Template',b'Primary Settings',b'Primaire Instellingen'
-b'DocType: Purchase Invoice',b'Select Supplier Address',b'Select Leverancier Adres'
-b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397',b'Add Employees',b'Werknemers toevoegen'
-b'DocType: Purchase Invoice Item',b'Quality Inspection',b'Kwaliteitscontrole'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196',b'Extra Small',b'Extra Small'
-b'DocType: Company',b'Standard Template',b'Standard Template'
-b'DocType: Training Event',b'Theory',b'Theorie'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806',b'Warning: Material Requested Qty is less than Minimum Order Qty',b'Waarschuwing: Materiaal Aanvraag Aantal is minder dan Minimum Bestelhoeveelheid'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211',b'Account {0} is frozen',b'Rekening {0} is bevroren'
-b'DocType: Company',b'Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.',b'Rechtspersoon / Dochteronderneming met een aparte Rekeningschema behoren tot de Organisatie.'
-b'DocType: Payment Request',b'Mute Email',b'Mute-mail'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29',"b'Food, Beverage & Tobacco'","b'Voeding, Drank en Tabak'"
-b'DocType: Account',b'Account Number',b'Rekeningnummer'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752',b'Can only make payment against unbilled {0}',b'Kan alleen betaling uitvoeren voor ongefactureerde {0}'
-b'apps/erpnext/erpnext/controllers/selling_controller.py +102',b'Commission rate cannot be greater than 100',b'Commissietarief kan niet groter zijn dan 100'
-b'DocType: Volunteer',b'Volunteer',b'Vrijwilliger'
-b'DocType: Stock Entry',b'Subcontract',b'Subcontract'
-b'apps/erpnext/erpnext/public/js/utils/party.js +166',b'Please enter {0} first',b'Voer {0} eerste'
-b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104',b'No replies from',b'Geen antwoorden van'
-b'DocType: Work Order Operation',b'Actual End Time',b'Werkelijke Eindtijd'
-b'DocType: Item',b'Manufacturer Part Number',b'Onderdeelnummer fabrikant'
-b'DocType: Work Order Operation',b'Estimated Time and Cost',b'Geschatte Tijd en Kosten'
-b'DocType: Bin',b'Bin',b'Bak'
-b'DocType: Crop',b'Crop Name',b'Gewasnaam'
-b'DocType: SMS Log',b'No of Sent SMS',b'Aantal gestuurde SMS'
-b'DocType: Antibiotic',b'Healthcare Administrator',b'Gezondheidszorg Administrator'
-b'apps/erpnext/erpnext/utilities/user_progress.py +47',b'Set a Target',b'Stel een doel in'
-b'DocType: Dosage Strength',b'Dosage Strength',b'Dosis Sterkte'
-b'DocType: Account',b'Expense Account',b'Kostenrekening'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49',b'Software',b'software'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203',b'Colour',b'Kleur'
-b'DocType: Assessment Plan Criteria',b'Assessment Plan Criteria',b'Assessment Plan Criteria'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +118',b'Expiry date is mandatory for selected item',b'De vervaldatum is verplicht voor het geselecteerde artikel'
-b'DocType: Supplier Scorecard Scoring Standing',b'Prevent Purchase Orders',b'Voorkom aankopen'
-b'apps/erpnext/erpnext/healthcare/setup.py +258',b'Susceptible',b'vatbaar'
-b'DocType: Patient Appointment',b'Scheduled',b'Geplande'
-b'apps/erpnext/erpnext/config/buying.py +18',b'Request for quotation.',b'Aanvraag voor een offerte.'
-b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13',"b'Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle'","b'Selecteer Item, waar &quot;Is Stock Item&quot; is &quot;Nee&quot; en &quot;Is Sales Item&quot; is &quot;Ja&quot; en er is geen enkel ander product Bundle'"
-b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148',b'Select Customer',b'Selecteer klant'
-b'DocType: Student Log',b'Academic',b'Academisch'
-b'DocType: Patient',b'Personal and Social History',b'Persoonlijke en sociale geschiedenis'
-b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51',b'User {0} created',b'Gebruiker {0} gemaakt'
-b'DocType: Fee Schedule',b'Fee Breakup for each student',b'Fee Breakup voor elke student'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +541',b'Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2})',b'Totaal vooraf ({0}) tegen Orde {1} kan niet groter zijn dan de Grand totaal zijn ({2})'
-b'DocType: Sales Partner',b'Select Monthly Distribution to unevenly distribute targets across months.',b'Selecteer Maandelijkse Distribution om ongelijk te verdelen doelen in heel maanden.'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78',b'Change Code',b'Wijzig code'
-b'DocType: Purchase Invoice Item',b'Valuation Rate',b'Waardering Tarief'
-b'DocType: Stock Reconciliation',b'SR/',b'SR /'
-b'DocType: Vehicle',b'Diesel',b'Diesel'
-b'apps/erpnext/erpnext/stock/get_item_details.py +388',b'Price List Currency not selected',b'Prijslijst Valuta nog niet geselecteerd'
-b'DocType: Purchase Invoice',b'Availed ITC Cess',b'Beschikbaar ITC Cess'
-,b'Student Monthly Attendance Sheet',b'Student Maandelijkse presentielijst'
-b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96',b'Shipping rule only applicable for Selling',b'Verzendregel alleen van toepassing op verkopen'
-b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30',b'Project Start Date',b'Project Start Datum'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23',b'Until',b'Totdat'
-b'DocType: Rename Tool',b'Rename Log',b'Hernoemen Log'
-b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Studentgroep of cursusschema is verplicht'
-b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Studentgroep of cursusschema is verplicht'
-b'DocType: HR Settings',b'Maintain Billing Hours and Working Hours Same on Timesheet',b'Maintain Billing en werktijden Same op Timesheet'
-b'DocType: Maintenance Visit Purpose',b'Against Document No',b'Tegen Document nr.'
-b'DocType: BOM',b'Scrap',b'stukje'
-b'apps/erpnext/erpnext/utilities/user_progress.py +217',b'Go to Instructors',b'Ga naar instructeurs'
-b'apps/erpnext/erpnext/config/selling.py +110',b'Manage Sales Partners.',b'Beheer Verkoop Partners.'
-b'DocType: Quality Inspection',b'Inspection Type',b'Inspectie Type'
-b'DocType: Fee Validity',b'Visited yet',b'Nog bezocht'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134',b'Warehouses with existing transaction can not be converted to group.',b'Warehouses met bestaande transactie kan niet worden geconverteerd naar groep.'
-b'DocType: Assessment Result Tool',b'Result HTML',b'resultaat HTML'
-b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35',b'Expires On',b'Verloopt op'
-b'apps/erpnext/erpnext/utilities/activation.py +117',b'Add Students',b'Studenten toevoegen'
-b'apps/erpnext/erpnext/public/js/utils.js +270',b'Please select {0}',b'Selecteer {0}'
-b'DocType: C-Form',b'C-Form No',b'C-vorm nr.'
-b'DocType: BOM',b'Exploded_items',b'Uitgeklapte Artikelen'
-b'apps/erpnext/erpnext/utilities/user_progress.py +139',b'List your products or services that you buy or sell.',b'Maak een overzicht van uw producten of diensten die u koopt of verkoopt.'
-b'DocType: Water Analysis',b'Storage Temperature',b'Bewaar temperatuur'
-b'DocType: Employee Attendance Tool',b'Unmarked Attendance',b'Ongemerkte aanwezigheid'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137',b'Researcher',b'onderzoeker'
-b'DocType: Program Enrollment Tool Student',b'Program Enrollment Tool Student',b'Programma Inschrijving Tool Student'
-b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16',b'Start date should be less than end date for task {0}',b'Startdatum moet minder zijn dan de einddatum voor taak {0}'
-b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25',b'Name or Email is mandatory',b'Naam of E-mail is verplicht'
-b'DocType: Member',b'MEM-',b'MEM-'
-b'DocType: Instructor',b'Instructor Log',b'Instructeurslogboek'
-b'DocType: Purchase Order Item',b'Returned Qty',b'Terug Aantal'
-b'DocType: Student',b'Exit',b'Uitgang'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +156',b'Root Type is mandatory',b'Root Type is verplicht'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29',b'Failed to install presets',b'Kan presets niet installeren'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44',"b'{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.'","b'{0} heeft momenteel een {1} leverancierscore kaart, en RFQs aan deze leverancier moeten met voorzichtigheid worden uitgegeven.'"
-b'DocType: Chapter',b'Non Profit Manager',b'Non-profit manager'
-b'DocType: BOM',b'Total Cost(Company Currency)',b'Total Cost (Company Munt)'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315',b'Serial No {0} created',b'Serienummer {0} aangemaakt'
-b'DocType: Homepage',b'Company Description for website homepage',b'Omschrijving bedrijf voor website homepage'
-b'DocType: Item Customer Detail',"b'For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes'","b'Voor het gemak van de klanten, kunnen deze codes worden gebruikt in gedrukte formaten zoals facturen en de leveringsbonnen'"
-b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18',b'Suplier Name',b'suplier Naam'
-b'apps/erpnext/erpnext/accounts/report/financial_statements.py +174',b'Could not retrieve information for {0}.',b'Kan informatie niet ophalen voor {0}.'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134',b'Opening Entry Journal',b'Opening dagboek'
-b'DocType: Sales Invoice',b'Time Sheet List',b'Urenregistratie List'
-b'DocType: Employee',b'You can enter any date manually',b'U kunt elke datum handmatig ingeven'
-b'DocType: Healthcare Settings',b'Result Printed',b'Resultaat afgedrukt'
-b'DocType: Asset Category Account',b'Depreciation Expense Account',b'Afschrijvingen Account'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233',b'Probationary Period',b'Proeftijd'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32',b'View {0}',b'Bekijk {0}'
-b'DocType: Customer Group',b'Only leaf nodes are allowed in transaction',b'Alleen leaf nodes zijn toegestaan in transactie'
-b'DocType: Project',b'Total Costing Amount (via Timesheets)',b'Totale kostenbedrag (via urenstaten)'
-b'DocType: Employee Advance',b'Expense Approver',b'Onkosten Goedkeurder'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136',b'Row {0}: Advance against Customer must be credit',b'Rij {0}: Advance tegen Klant moet krediet'
-b'DocType: Project',b'Hourly',b'ieder uur'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.js +89',b'Non-Group to Group',b'Non-groep tot groep'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Partij is verplicht in rij {0}'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Partij is verplicht in rij {0}'
-b'DocType: Purchase Receipt Item Supplied',b'Purchase Receipt Item Supplied',b'Ontvangstbevestiging Artikel geleverd'
-b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'To Datetime',b'Om Datetime'
-b'apps/erpnext/erpnext/config/selling.py +302',b'Logs for maintaining sms delivery status',b'Logs voor het behoud van sms afleverstatus'
-b'DocType: Accounts Settings',b'Make Payment via Journal Entry',b'Betalen via Journal Entry'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +223',b'Printed On',b'Gedrukt op'
-b'DocType: Item',b'Inspection Required before Delivery',b'Inspectie vereist voordat Delivery'
-b'DocType: Item',b'Inspection Required before Purchase',b'Inspectie vereist voordat Purchase'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93',b'Pending Activities',b'Afwachting Activiteiten'
-b'DocType: Patient Appointment',b'Reminded',b'herinnerd'
-b'DocType: Patient',b'PID-',b'PID'
-b'DocType: Chapter Member',b'Chapter Member',b'Hoofdstuklid'
-b'DocType: Material Request Plan Item',b'Minimum Order Quantity',b'Minimum bestelhoeveelheid'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +106',b'Your Organization',b'Uw organisatie'
-b'DocType: Fee Component',b'Fees Category',b'vergoedingen Categorie'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +134',b'Please enter relieving date.',b'Vul het verlichten datum .'
-b'apps/erpnext/erpnext/controllers/trends.py +149',b'Amt',b'Amt'
-b'DocType: Supplier Scorecard',b'Notify Employee',b'Meld de medewerker in kennis'
-b'DocType: Opportunity',b'Enter name of campaign if source of enquiry is campaign',b'Voer de naam van de campagne in als bron van onderzoek Campagne is'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38',b'Newspaper Publishers',b'Kranten Uitgeverijen'
-b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30',b'Select Fiscal Year',b'Selecteer het fiscale jaar'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115',b'Expected Delivery Date should be after Sales Order Date',b'Verwachte leveringsdatum moet na verkoopdatum zijn'
-b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42',b'Reorder Level',b'Bestelniveau'
-b'DocType: Company',b'Chart Of Accounts Template',b'Rekeningschema Template'
-b'DocType: Attendance',b'Attendance Date',b'Aanwezigheid Datum'
-b'apps/erpnext/erpnext/stock/get_item_details.py +352',b'Item Price updated for {0} in Price List {1}',b'Item Prijs bijgewerkt voor {0} in prijslijst {1}'
-b'DocType: Salary Structure',b'Salary breakup based on Earning and Deduction.',b'Salaris verbreken op basis Verdienen en Aftrek.'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +128',b'Account with child nodes cannot be converted to ledger',b'Rekening met onderliggende nodes kunnen niet worden omgezet naar grootboek'
-b'DocType: Purchase Invoice Item',b'Accepted Warehouse',b'Geaccepteerd Magazijn'
-b'DocType: Bank Reconciliation Detail',b'Posting Date',b'Plaatsingsdatum'
-b'DocType: Item',b'Valuation Method',b'Waardering Methode'
-b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203',b'Mark Half Day',b'Mark Halve dag'
-b'DocType: Sales Invoice',b'Sales Team',b'Verkoop Team'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87',b'Duplicate entry',b'Dubbele invoer'
-b'DocType: Program Enrollment Tool',b'Get Students',b'krijg Studenten'
-b'DocType: Serial No',b'Under Warranty',b'Binnen Garantie'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516',b'[Error]',b'[Fout]'
-b'DocType: Sales Order',b'In Words will be visible once you save the Sales Order.',b'In Woorden zijn zichtbaar zodra u de Verkooporder opslaat.'
-,b'Employee Birthday',b'Werknemer Verjaardag'
-b'apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14',b'Please select Completion Date for Completed Repair',b'Selecteer de voltooiingsdatum voor de voltooide reparatie'
-b'DocType: Student Batch Attendance Tool',b'Student Batch Attendance Tool',b'Student Batch Attendance Tool'
-b'apps/erpnext/erpnext/controllers/status_updater.py +213',b'Limit Crossed',b'Limit Crossed'
-b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22',b'Scheduled Upto',b'Geplande Tot'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55',b'Venture Capital',b'Venture Capital'
-b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40',"b""An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.""",b'Een wetenschappelijke term met deze &#39;Academisch Jaar&#39; {0} en &#39;Term Name&#39; {1} bestaat al. Wijzig deze ingangen en probeer het opnieuw.'
-b'DocType: UOM',b'Must be Whole Number',b'Moet heel getal zijn'
-b'DocType: Leave Control Panel',b'New Leaves Allocated (In Days)',b'Nieuwe Verloven Toegewezen (in dagen)'
-b'DocType: Purchase Invoice',b'Invoice Copy',b'Factuurkopie'
-b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49',b'Serial No {0} does not exist',b'Serienummer {0} bestaat niet'
-b'DocType: Sales Invoice Item',b'Customer Warehouse (Optional)',b'Customer Warehouse (optioneel)'
-b'DocType: Pricing Rule',b'Discount Percentage',b'Kortingspercentage'
-b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51',b'Reserved for sub contracting',b'Gereserveerd voor onderaanneming'
-b'DocType: Payment Reconciliation Invoice',b'Invoice Number',b'Factuurnummer'
-b'DocType: Shopping Cart Settings',b'Orders',b'Bestellingen'
-b'DocType: Employee Leave Approver',b'Leave Approver',b'Verlof goedkeurder'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285',b'Please select a batch',b'Selecteer een batch alsjeblieft'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalLib',b'JournalLib'
-b'DocType: Assessment Group',b'Assessment Group Name',b'Assessment Group Name'
-b'DocType: Manufacturing Settings',b'Material Transferred for Manufacture',b'Overgedragen materiaal voor vervaardiging'
-b'DocType: Landed Cost Item',b'Receipt Document Type',b'Ontvangst Document Type'
-b'DocType: Daily Work Summary Settings',b'Select Companies',b'Selecteer Bedrijven'
-b'DocType: Antibiotic',b'Healthcare',b'Gezondheidszorg'
-b'DocType: Target Detail',b'Target Detail',b'Doel Detail'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +65',b'Single Variant',b'Enkele variant'
-b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24',b'All Jobs',b'alle vacatures'
-b'DocType: Sales Order',b'% of materials billed against this Sales Order',b'% van de materialen in rekening gebracht voor deze Verkooporder'
-b'DocType: Program Enrollment',b'Mode of Transportation',b'Wijze van vervoer'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49',b'Period Closing Entry',b'Periode sluitpost'
-b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72',b'Select Department...',b'Selecteer afdeling ...'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38',b'Cost Center with existing transactions can not be converted to group',b'Kostenplaats met bestaande transacties kan niet worden omgezet in groep'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374',b'Amount {0} {1} {2} {3}',b'Bedrag {0} {1} {2} {3}'
-b'DocType: Account',b'Depreciation',b'Afschrijvingskosten'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102',b'The number of shares and the share numbers are inconsistent',b'Het aantal aandelen en de aandelenaantallen zijn inconsistent'
-b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49',b'Supplier(s)',b'Leverancier(s)'
-b'DocType: Employee Attendance Tool',b'Employee Attendance Tool',b'Employee Attendance Tool'
-b'DocType: Guardian Student',b'Guardian Student',b'Guardian Student'
-b'DocType: Supplier',b'Credit Limit',b'Kredietlimiet'
-b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Selling Price List Rate',b'Gem. Prijslijst tarief verkopen'
-b'DocType: Salary Component',b'Salary Component',b'salaris Component'
-b'apps/erpnext/erpnext/accounts/utils.py +495',b'Payment Entries {0} are un-linked',b'Betaling Entries {0} zijn un-linked'
-b'DocType: GL Entry',b'Voucher No',b'Voucher nr.'
-,b'Lead Owner Efficiency',b'Leideneigenaar Efficiency'
-,b'Lead Owner Efficiency',b'Leideneigenaar Efficiency'
-b'DocType: Leave Allocation',b'Leave Allocation',b'Verlof Toewijzing'
-b'DocType: Payment Request',b'Recipient Message And Payment Details',b'Ontvanger Bericht en betalingsgegevens'
-b'DocType: Training Event',b'Trainer Email',b'trainer Email'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550',b'Material Requests {0} created',b'Materiaal Aanvragen {0} aangemaakt'
-b'DocType: Restaurant Reservation',b'No of People',b'Nee van mensen'
-b'apps/erpnext/erpnext/config/selling.py +164',b'Template of terms or contract.',b'Sjabloon voor contractvoorwaarden'
-b'DocType: Purchase Invoice',b'Address and Contact',b'Adres en contactgegevens'
-b'DocType: Cheque Print Template',b'Is Account Payable',b'Is Account Payable'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276',b'Stock cannot be updated against Purchase Receipt {0}',b'Stock kan niet worden bijgewerkt tegen Kwitantie {0}'
-b'DocType: Support Settings',b'Auto close Issue after 7 days',b'Auto dicht Issue na 7 dagen'
-b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71',"b'Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Verlof kan niet eerder worden toegewezen {0}, als verlof balans al-carry doorgestuurd in de toekomst toewijzing verlof record is {1}'"
-b'apps/erpnext/erpnext/accounts/party.py +317',b'Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)',b'Opmerking: Vanwege / Reference Data overschrijdt toegestaan klantenkrediet dagen door {0} dag (en)'
-b'apps/erpnext/erpnext/education/doctype/program/program.js +8',b'Student Applicant',b'student Aanvrager'
-b'DocType: Purchase Invoice',b'ORIGINAL FOR RECIPIENT',b'ORIGINEEL VOOR RECEPIENT'
-b'DocType: Asset Category Account',b'Accumulated Depreciation Account',b'Cumulatieve afschrijvingen Rekening'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11',b'This email is autogenerated',b'Deze email is autogenerated'
-b'DocType: Stock Settings',b'Freeze Stock Entries',b'Freeze Stock Entries'
-b'DocType: Program Enrollment',b'Boarding Student',b'Boarding Student'
-b'DocType: Asset',b'Expected Value After Useful Life',b'Verwachte waarde Na Nuttig Life'
-b'DocType: Item',b'Reorder level based on Warehouse',b'Bestelniveau gebaseerd op Warehouse'
-b'DocType: Activity Cost',b'Billing Rate',b'Billing Rate'
-,b'Qty to Deliver',b'Aantal te leveren'
-,b'Stock Analytics',b'Voorraad Analyses'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523',b'Operations cannot be left blank',b'Operations kan niet leeg zijn'
-b'DocType: Maintenance Visit Purpose',b'Against Document Detail No',b'Tegen Document Detail nr'
-b'apps/erpnext/erpnext/regional/__init__.py +11',b'Deletion is not permitted for country {0}',b'Verwijderen is niet toegestaan voor land {0}'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110',b'Party Type is mandatory',b'Party Type is verplicht'
-b'DocType: Quality Inspection',b'Outgoing',b'Uitgaande'
-b'DocType: Material Request',b'Requested For',b'Aangevraagd voor'
-b'DocType: Quotation Item',b'Against Doctype',b'Tegen Doctype'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +404',b'{0} {1} is cancelled or closed',b'{0} {1} is geannuleerd of gesloten'
-b'DocType: Asset',b'Calculate Depreciation',b'Bereken afschrijving'
-b'DocType: Delivery Note',b'Track this Delivery Note against any Project',b'Track this Delivery Note against any Project'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35',b'Net Cash from Investing',b'De netto kasstroom uit investeringsactiviteiten'
-b'DocType: Work Order',b'Work-in-Progress Warehouse',b'Onderhanden Werk Magazijn'
-b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111',b'Asset {0} must be submitted',b'Asset {0} moet worden ingediend'
-b'DocType: Fee Schedule Program',b'Total Students',b'Totaal studenten'
-b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56',b'Attendance Record {0} exists against Student {1}',b'Attendance Record {0} bestaat tegen Student {1}'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354',b'Reference #{0} dated {1}',b'Referentie #{0} gedateerd {1}'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164',b'Depreciation Eliminated due to disposal of assets',b'Afschrijvingen Uitgeschakeld als gevolg van verkoop van activa'
-b'DocType: Member',b'Member',b'Lid'
-b'apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15',b'Manage Addresses',b'Beheer Adressen'
-b'DocType: Work Order Item',b'Work Order Item',b'Werkorderitem'
-b'DocType: Pricing Rule',b'Item Code',b'Artikelcode'
-b'DocType: Serial No',b'Warranty / AMC Details',b'Garantie / AMC Details'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',b'Selecteer studenten handmatig voor de activiteit gebaseerde groep'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',b'Selecteer studenten handmatig voor de activiteit gebaseerde groep'
-b'DocType: Journal Entry',b'User Remark',b'Gebruiker Opmerking'
-b'DocType: Lead',b'Market Segment',b'Marktsegment'
-b'DocType: Agriculture Analysis Criteria',b'Agriculture Manager',b'Landbouwmanager'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966',b'Paid Amount cannot be greater than total negative outstanding amount {0}',b'Betaalde bedrag kan niet groter zijn dan de totale negatieve openstaande bedrag {0}'
-b'DocType: Supplier Scorecard Period',b'Variables',b'Variabelen'
-b'DocType: Employee Internal Work History',b'Employee Internal Work History',b'Werknemer Interne Werk Geschiedenis'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249',b'Closing (Dr)',b'Sluiten (Db)'
-b'DocType: Cheque Print Template',b'Cheque Size',b'Cheque Size'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232',b'Serial No {0} not in stock',b'Serienummer {0} niet op voorraad'
-b'apps/erpnext/erpnext/config/selling.py +169',b'Tax template for selling transactions.',b'Belasting sjabloon voor verkooptransacties.'
-b'DocType: Sales Invoice',b'Write Off Outstanding Amount',b'Afschrijving uitstaande bedrag'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27',b'Account {0} does not match with Company {1}',b'Rekening {0} komt niet overeen met Bedrijf {1}'
-b'DocType: Education Settings',b'Current Academic Year',b'Huidig Academisch Jaar'
-b'DocType: Stock Settings',b'Default Stock UOM',b'Standaard Voorraad Eenheid'
-b'DocType: Asset',b'Number of Depreciations Booked',b'Aantal Afschrijvingen Geboekt'
-b'apps/erpnext/erpnext/public/js/pos/pos.html +71',b'Qty Total',b'Aantal Totaal'
-b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32',b'Against Employee Loan: {0}',b'Tegen Werknemer lening: {0}'
-b'DocType: Landed Cost Item',b'Receipt Document',b'ontvangst Document'
-b'DocType: Employee Education',b'School/University',b'School / Universiteit'
-b'DocType: Payment Request',b'Reference Details',b'Reference Details'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +56',b'Expected Value After Useful Life must be less than Gross Purchase Amount',b'Verwachte waarde na Praktische Het leven moet minder dan Gross Aankoopbedrag zijn'
-b'DocType: Sales Invoice Item',b'Available Qty at Warehouse',b'Qty bij Warehouse'
-b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Billed Amount',b'Gefactureerd Bedrag'
-b'DocType: Share Transfer',b'(including)',b'(inclusief)'
-b'DocType: Asset',b'Double Declining Balance',b'Double degressief'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180',b'Closed order cannot be cancelled. Unclose to cancel.',b'Gesloten bestelling kan niet worden geannuleerd. Openmaken om te annuleren.'
-b'DocType: Student Guardian',b'Father',b'Vader'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +627',"b""'Update Stock' cannot be checked for fixed asset sale""",b'&#39;Bijwerken Stock&#39; kan niet worden gecontroleerd op vaste activa te koop'
-b'DocType: Bank Reconciliation',b'Bank Reconciliation',b'Bank Aflettering'
-b'DocType: Attendance',b'On Leave',b'Met verlof'
-b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7',b'Get Updates',b'Blijf op de hoogte'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96',b'{0} {1}: Account {2} does not belong to Company {3}',b'{0} {1}: Account {2} behoort niet tot Company {3}'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +397',b'Select at least one value from each of the attributes.',b'Selecteer ten minste \xc3\xa9\xc3\xa9n waarde uit elk van de kenmerken.'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166',b'Material Request {0} is cancelled or stopped',b'Materiaal Aanvraag {0} is geannuleerd of gestopt'
-b'apps/erpnext/erpnext/config/hr.py +314',b'Leave Management',b'Laat management'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +118',b'Group by Account',b'Groeperen volgens Rekening'
-b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21',b'Please select Employee',b'Selecteer werknemer'
-b'DocType: Sales Order',b'Fully Delivered',b'Volledig geleverd'
-b'DocType: Lead',b'Lower Income',b'Lager inkomen'
-b'DocType: Restaurant Order Entry',b'Current Order',b'Huidige bestelling'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196',b'Source and target warehouse cannot be same for row {0}',b'Bron- en doelmagazijn kan niet hetzelfde zijn voor de rij {0}'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243',"b'Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry'","b'Verschil moet Account een type Asset / Liability rekening zijn, aangezien dit Stock Verzoening is een opening Entry'"
-b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107',b'Disbursed Amount cannot be greater than Loan Amount {0}',b'Uitbetaalde bedrag kan niet groter zijn dan Leningen zijn {0}'
-b'apps/erpnext/erpnext/utilities/user_progress.py +176',b'Go to Programs',b'Ga naar Programma&#39;s'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205',b'Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}',b'Rij {0} # Toegewezen hoeveelheid {1} kan niet groter zijn dan het niet-opge\xc3\xabiste bedrag {2}'
-b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89',b'Purchase Order number required for Item {0}',b'Inkoopordernummer nodig voor Artikel {0}'
-b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18',"b""'From Date' must be after 'To Date'""","b""'Van Datum' moet na 'Tot Datum' zijn"""
-b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39',b'Cannot change status as student {0} is linked with student application {1}',b'Kan niet status als student te veranderen {0} is gekoppeld aan student toepassing {1}'
-b'DocType: Asset',b'Fully Depreciated',b'volledig is afgeschreven'
-b'DocType: Item Barcode',b'UPC-A',b'UPC-A'
-,b'Stock Projected Qty',b'Verwachte voorraad hoeveelheid'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444',b'Customer {0} does not belong to project {1}',b'Klant {0} behoort niet tot project {1}'
-b'DocType: Employee Attendance Tool',b'Marked Attendance HTML',b'Marked Attendance HTML'
-b'apps/erpnext/erpnext/utilities/activation.py +73',"b'Quotations are proposals, bids you have sent to your customers'","b'Offertes zijn voorstellen, biedingen u uw klanten hebben gestuurd'"
-b'DocType: Sales Invoice',"b""Customer's Purchase Order""",b'Klant Bestelling'
-b'DocType: Consultation',b'Patient',b'Geduldig'
-b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47',b'Bypass credit check at Sales Order ',b'Bypass credit check op klantorder'
-b'DocType: Land Unit',b'Check if it is a hydroponic unit',b'Controleer of het een hydrocultuur is'
-b'apps/erpnext/erpnext/config/stock.py +109',b'Serial No and Batch',b'Serienummer en Batch'
-b'DocType: Warranty Claim',b'From Company',b'Van Bedrijf'
-b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52',b'Sum of Scores of Assessment Criteria needs to be {0}.',b'Som van de scores van de beoordelingscriteria moet {0} te zijn.'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +77',b'Please set Number of Depreciations Booked',b'Stel Aantal geboekte afschrijvingen'
-b'DocType: Supplier Scorecard Period',b'Calculations',b'berekeningen'
-b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86',b'Value or Qty',b'Waarde of Aantal'
-b'DocType: Payment Terms Template',b'Payment Terms',b'Betaalvoorwaarden'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449',b'Productions Orders cannot be raised for:',b'Productions Bestellingen kunnen niet worden verhoogd voor:'
-b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Minute',b'minuut'
-b'DocType: Purchase Invoice',b'Purchase Taxes and Charges',b'Inkoop Belastingen en Toeslagen'
-b'DocType: Chapter',b'Meetup Embed HTML',b'Meetup HTML insluiten'
-b'apps/erpnext/erpnext/utilities/user_progress.py +121',b'Go to Suppliers',b'Ga naar leveranciers'
-,b'Qty to Receive',b'Aantal te ontvangen'
-b'DocType: Leave Block List',b'Leave Block List Allowed',b'Laat toegestaan Block List'
-b'DocType: Grading Scale Interval',b'Grading Scale Interval',b'Grading Scale Interval'
-b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49',b'Expense Claim for Vehicle Log {0}',b'Declaratie voor voertuig Inloggen {0}'
-b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Korting (%) op prijslijst tarief met marges'
-b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Korting (%) op prijslijst tarief met marges'
-b'apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59',b'All Warehouses',b'Alle magazijnen'
-b'DocType: Sales Partner',b'Retailer',b'Retailer'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115',b'Credit To account must be a Balance Sheet account',b'Credit Om rekening moet een balansrekening zijn'
-b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118',b'All Supplier Types',b'Alle Leverancier Types'
-b'DocType: Donor',b'Donor',b'schenker'
-b'DocType: Global Defaults',b'Disable In Words',b'Uitschakelen In Woorden'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +60',b'Item Code is mandatory because Item is not automatically numbered',b'Artikelcode is verplicht omdat Artikel niet automatisch is genummerd'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98',b'Quotation {0} not of type {1}',b'Offerte {0} niet van het type {1}'
-b'DocType: Maintenance Schedule Item',b'Maintenance Schedule Item',b'Onderhoudsschema Item'
-b'DocType: Sales Order',b'%  Delivered',b'% Geleverd'
-b'apps/erpnext/erpnext/education/doctype/fees/fees.js +105',b'Please set the Email ID for the Student to send the Payment Request',b'Stel het e-mail-ID voor de student in om het betalingsverzoek te verzenden'
-b'DocType: Patient',b'Medical History',b'Medische Geschiedenis'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157',b'Bank Overdraft Account',b'Bank Kredietrekening'
-b'DocType: Patient',b'Patient ID',b'Patient ID'
-b'DocType: Physician Schedule',b'Schedule Name',b'Schema Naam'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48',b'Make Salary Slip',b'Maak Salarisstrook'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840',b'Add All Suppliers',b'Voeg alle leveranciers toe'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94',b'Row #{0}: Allocated Amount cannot be greater than outstanding amount.',b'Rij # {0}: Toegewezen bedrag mag niet groter zijn dan het uitstaande bedrag.'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75',b'Browse BOM',b'Bladeren BOM'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155',b'Secured Loans',b'Leningen met onderpand'
-b'DocType: Purchase Invoice',b'Edit Posting Date and Time',b'Wijzig Posting Datum en tijd'
-b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101',b'Please set Depreciation related Accounts in Asset Category {0} or Company {1}',b'Stel afschrijvingen gerelateerd Accounts in Vermogensbeheer categorie {0} of Company {1}'
-b'DocType: Lab Test Groups',b'Normal Range',b'Normaal bereik'
-b'DocType: Academic Term',b'Academic Year',b'Academisch jaar'
-b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Available Selling',b'Beschikbare verkoop'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169',b'Opening Balance Equity',b'Opening Balance Equity'
-b'DocType: Lead',b'CRM',b'CRM'
-b'DocType: Purchase Invoice',b'N',b'N'
-b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175',b'Remaining',b'resterende'
-b'DocType: Appraisal',b'Appraisal',b'Beoordeling'
-b'DocType: Purchase Invoice',b'GST Details',b'GST Details'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156',b'Email sent to supplier {0}',b'E-mail verzonden naar leverancier {0}'
-b'DocType: Item',b'Default Sales Unit of Measure',b'Standaard Verkoopeenheid van Maatregel'
-b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9',b'Academic Year: ',b'Academiejaar:'
-b'DocType: Opportunity',b'OPTY-',b'OPTY-'
-b'apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19',b'Date is repeated',b'Datum wordt herhaald'
-b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27',b'Authorized Signatory',b'Geautoriseerd ondertekenaar'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64',b'Create Fees',b'Fees maken'
-b'DocType: Project',b'Total Purchase Cost (via Purchase Invoice)',b'Totale aanschafkosten (via Purchase Invoice)'
-b'DocType: Training Event',b'Start Time',b'Starttijd'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400',b'Select Quantity',b'Kies aantal'
-b'DocType: Customs Tariff Number',b'Customs Tariff Number',b'Douanetariefnummer'
-b'DocType: Patient Appointment',b'Patient Appointment',b'Patient Benoeming'
-b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34',b'Approving Role cannot be same as role the rule is Applicable To',b'Goedkeuring Rol kan niet hetzelfde zijn als de rol van de regel is van toepassing op'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64',b'Unsubscribe from this Email Digest',b'Afmelden bij dit e-mailoverzicht'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830',b'Get Suppliers By',b'Ontvang leveranciers door'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173',b'{0} not found for Item {1}',b'{0} niet gevonden voor item {1}'
-b'apps/erpnext/erpnext/utilities/user_progress.py +197',b'Go to Courses',b'Ga naar cursussen'
-b'DocType: Accounts Settings',b'Show Inclusive Tax In Print',b'Toon Inclusive Tax In Print'
-b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17',"b'Bank Account, From Date and To Date are Mandatory'","b'Bankrekening, van datum en tot datum zijn verplicht'"
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28',b'Message Sent',b'bericht verzonden'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +98',b'Account with child nodes cannot be set as ledger',b'Rekening met de onderliggende knooppunten kan niet worden ingesteld als grootboek'
-b'DocType: C-Form',b'II',b'II'
-b'DocType: Sales Invoice',"b""Rate at which Price list currency is converted to customer's base currency""",b'Koers waarmee Prijslijst valuta wordt omgerekend naar de basisvaluta van de klant'
-b'DocType: Purchase Invoice Item',b'Net Amount (Company Currency)',b'Nettobedrag (Company valuta)'
-b'DocType: Physician',b'Physician Schedules',b'Arts Schedules'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215',b'Total advance amount cannot be greater than total sanctioned amount',b'Het totale voorschotbedrag kan niet hoger zijn dan het totale gesanctioneerde bedrag'
-b'DocType: Salary Slip',b'Hour Rate',b'Uurtarief'
-b'DocType: Stock Settings',b'Item Naming By',b'Artikel benoeming door'
-b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46',b'Another Period Closing Entry {0} has been made after {1}',b'Een ander Periode sluitpost {0} is gemaakt na {1}'
-b'DocType: Work Order',b'Material Transferred for Manufacturing',b'Materiaal Overgedragen voor Manufacturing'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41',b'Account {0} does not exists',b'Rekening {0} bestaat niet'
-b'DocType: Project',b'Project Type',b'Project Type'
-b'apps/erpnext/erpnext/projects/doctype/task/task.py +153',b'Child Task exists for this Task. You can not delete this Task.',b'Child Task bestaat voor deze taak. U kunt deze taak niet verwijderen.'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'DateLet',b'DateLet'
-b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16',b'Either target qty or target amount is mandatory.',b'Ofwel doelwit aantal of streefbedrag is verplicht.'
-b'apps/erpnext/erpnext/config/projects.py +56',b'Cost of various activities',b'Kosten van verschillende activiteiten'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60',"b'Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}'","b'Instellen Events naar {0}, omdat de werknemer die aan de onderstaande Sales Personen die niet beschikt over een gebruikers-ID {1}'"
-b'DocType: Timesheet',b'Billing Details',b'Billing Details'
-b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163',b'Source and target warehouse must be different',b'Bron en doel magazijn moet verschillen'
-b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140',b'Payment Failed. Please check your GoCardless Account for more details',b'Betaling mislukt. Controleer uw GoCardless-account voor meer informatie'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101',b'Not allowed to update stock transactions older than {0}',b'Niet toegestaan om voorraadtransacties ouder dan  {0} bij te werken'
-b'DocType: BOM',b'Inspection Required',b'Inspectie Verplicht'
-b'DocType: Purchase Invoice Item',b'PR Detail',b'PR Detail'
-b'DocType: Driving License Category',b'Class',b'Klasse'
-b'DocType: Sales Order',b'Fully Billed',b'Volledig gefactureerd'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426',b'Work Order cannot be raised against a Item Template',b'Werkopdracht kan niet worden verhoogd met een itemsjabloon'
-b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101',b'Shipping rule only applicable for Buying',b'Verzendregel alleen van toepassing voor kopen'
-b'DocType: Vital Signs',b'BMI',b'BMI'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20',b'Cash In Hand',b'Contanten in de hand'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137',b'Delivery warehouse required for stock item {0}',b'Levering magazijn vereist voor voorraad artikel {0}'
-b'DocType: Packing Slip',b'The gross weight of the package. Usually net weight + packaging material weight. (for print)',b'Het bruto gewicht van het pakket. Meestal nettogewicht + verpakkingsmateriaal gewicht. (Voor afdrukken)'
-b'DocType: Assessment Plan',b'Program',b'Programma'
-b'DocType: Accounts Settings',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts'
-b'DocType: Serial No',b'Is Cancelled',b'Is Geannuleerd'
-b'DocType: Student Group',b'Group Based On',b'Groep Gebaseerd op'
-b'DocType: Student Group',b'Group Based On',b'Groep Gebaseerd op'
-b'DocType: Journal Entry',b'Bill Date',b'Factuurdatum'
-b'DocType: Healthcare Settings',b'Laboratory SMS Alerts',b'Laboratorium SMS Alerts'
-b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20',"b'Service Item,Type,frequency and expense amount are required'","b'Service Punt, Type, de frequentie en de kosten bedragen nodig zijn'"
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45',"b'Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:'","b'Als er meerdere Prijsbepalings Regels zijn met de hoogste prioriteit, dan wordt de volgende interene prioriteit gehanteerd:'"
-b'DocType: Plant Analysis Criteria',b'Plant Analysis Criteria',b'Criteria voor plantanalyse'
-b'DocType: Cheque Print Template',b'Cheque Height',b'Cheque Hoogte'
-b'DocType: Supplier',b'Supplier Details',b'Leverancier Details'
-b'DocType: Setup Progress',b'Setup Progress',b'Setup Progress'
-b'DocType: Hub Settings',b'Publish Items to Hub',b'Publiceer Artikelen toevoegen aan Hub'
-b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35',b'From value must be less than to value in row {0}',b'Van waarde moet minder zijn dan waarde in rij {0}'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182',b'Wire Transfer',b'overboeking'
-b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92',b'Check all',b'Alles aanvinken'
-,b'Issued Items Against Work Order',b'Uitgegeven items tegen werkorder'
-b'DocType: Vehicle Log',b'Invoice Ref',b'factuur Ref'
-b'DocType: Company',b'Default Income Account',b'Standaard Inkomstenrekening'
-b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32',b'Customer Group / Customer',b'Klantengroep / Klant'
-b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37',b'Unclosed Fiscal Years Profit / Loss (Credit)',b'Unclosed Boekjaren winst / verlies (Credit)'
-b'DocType: Sales Invoice',b'Time Sheets',b'Time Sheets'
-b'DocType: Lab Test Template',b'Change In Item',b'Wijzigen In Item'
-b'DocType: Payment Gateway Account',b'Default Payment Request Message',b'Standaard bericht Payment Request'
-b'DocType: Item Group',b'Check this if you want to show in website',b'Aanvinken om weer te geven op de website'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338',b'Balance ({0})',b'Saldo ({0})'
-b'apps/erpnext/erpnext/config/accounts.py +134',b'Banking and Payments',b'Bank en betalingen'
-,b'Welcome to ERPNext',b'Welkom bij ERPNext'
-b'apps/erpnext/erpnext/config/learn.py +102',b'Lead to Quotation',b'Leiden tot Offerte'
-b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34',b'Email Reminders will be sent to all parties with email contacts',b'E-mailherinneringen worden verzonden naar alle partijen met e-mailcontacten'
-b'DocType: Project',b'Twice Daily',b'Tweemaal daags'
-b'DocType: Patient',b'A Negative',b'Een negatief'
-b'apps/erpnext/erpnext/templates/includes/product_list.js +45',b'Nothing more to show.',b'Niets meer te zien.'
-b'DocType: Lead',b'From Customer',b'Van Klant'
-b'apps/erpnext/erpnext/demo/setup/setup_data.py +327',b'Calls',b'Oproepen'
-b'apps/erpnext/erpnext/utilities/user_progress.py +143',b'A Product',b'Een product'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207',b'Batches',b'batches'
-b'apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34',b'Make Fee Schedule',b'Maak een kostenplan'
-b'DocType: Purchase Order Item Supplied',b'Stock UOM',b'Voorraad Eenheid'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233',b'Purchase Order {0} is not submitted',b'Inkooporder {0} is niet ingediend'
-b'DocType: Vital Signs',b'Normal reference range for an adult is 16\xe2\x80\x9320 breaths/minute (RCP 2012)',b'Normaal referentiebereik voor een volwassene is 16-20 ademhalingen / minuut (RCP 2012)'
-b'DocType: Customs Tariff Number',b'Tariff Number',b'tarief Aantal'
-b'DocType: Work Order Item',b'Available Qty at WIP Warehouse',b'Beschikbaar Aantal bij WIP Warehouse'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +39',b'Projected',b'verwachte'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222',b'Serial No {0} does not belong to Warehouse {1}',b'Serienummer {0} behoort niet tot Magazijn {1}'
-b'apps/erpnext/erpnext/controllers/status_updater.py +177',b'Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0',b'Opmerking : Het systeem controleert niet over- levering en overboeking voor post {0} als hoeveelheid of bedrag 0'
-b'DocType: Notification Control',b'Quotation Message',b'Offerte Bericht'
-b'DocType: Employee Loan',b'Employee Loan Application',b'Werknemer lening aanvraag'
-b'DocType: Issue',b'Opening Date',b'Openingsdatum'
-b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86',b'Please save the patient first',b'Sla de pati\xc3\xabnt alstublieft eerst op'
-b'apps/erpnext/erpnext/education/api.py +80',b'Attendance has been marked successfully.',b'Aanwezigheid is met succes gemarkeerd.'
-b'DocType: Program Enrollment',b'Public Transport',b'Openbaar vervoer'
-b'DocType: Soil Texture',b'Silt Composition (%)',b'Silt-samenstelling (%)'
-b'DocType: Journal Entry',b'Remark',b'Opmerking'
-b'DocType: Healthcare Settings',b'Avoid Confirmation',b'Vermijd bevestiging'
-b'DocType: Purchase Receipt Item',b'Rate and Amount',b'Tarief en Bedrag'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176',b'Account Type for {0} must be {1}',b'Rekening Type voor {0} moet {1}'
-b'DocType: Healthcare Settings',b'Default income accounts to be used if not set in Physician to book Consultation charges.',b'Standaardinkomensrekeningen die gebruikt moeten worden indien niet in de arts ingesteld om te reserveren.'
-b'apps/erpnext/erpnext/config/hr.py +55',b'Leaves and Holiday',b'Bladeren en vakantie'
-b'DocType: Education Settings',b'Current Academic Term',b'Huidige academische term'
-b'DocType: Education Settings',b'Current Academic Term',b'Huidige academische term'
-b'DocType: Sales Order',b'Not Billed',b'Niet in rekening gebracht'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76',b'Both Warehouse must belong to same Company',b'Beide magazijnen moeten tot hetzelfde bedrijf behoren'
-b'apps/erpnext/erpnext/public/js/templates/contact_list.html +34',b'No contacts added yet.',b'Nog geen contacten toegevoegd.'
-b'DocType: Purchase Invoice Item',b'Landed Cost Voucher Amount',b'Vrachtkosten Voucher Bedrag'
-,b'Item Balance (Simple)',b'Artikel saldo (eenvoudig)'
-b'apps/erpnext/erpnext/config/accounts.py +17',b'Bills raised by Suppliers.',b'Facturen van leveranciers.'
-b'DocType: POS Profile',b'Write Off Account',b'Afschrijvingsrekening'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Debit Note Amt',b'Debietnota Amt'
-b'apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5',b'Discount Amount',b'Korting Bedrag'
-b'DocType: Purchase Invoice',b'Return Against Purchase Invoice',b'Terug Tegen Purchase Invoice'
-b'DocType: Item',b'Warranty Period (in days)',b'Garantieperiode (in dagen)'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61',b'Failed to set defaults',b'Instellen van standaardwaarden mislukt'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56',b'Relation with Guardian1',b'Relatie met Guardian1'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +786',b'Please select BOM against item {0}',b'Selecteer een stuklijst met item {0}'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18',b'Make Invoices',b'Facturen maken'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23',b'Net Cash from Operations',b'De netto kasstroom uit operationele activiteiten'
-b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26',b'Item 4',b'Punt 4'
-b'DocType: Student Admission',b'Admission End Date',b'Toelating Einddatum'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30',b'Sub-contracting',b'Uitbesteding'
-b'DocType: Journal Entry Account',b'Journal Entry Account',b'Dagboek rekening'
-b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3',b'Student Group',b'student Group'
-b'DocType: Shopping Cart Settings',b'Quotation Series',b'Offerte Series'
-b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57',"b'An item exists with same name ({0}), please change the item group name or rename the item'","b'Een item bestaat met dezelfde naam ( {0} ) , wijzigt u de naam van het item groep of hernoem het item'"
-b'DocType: Soil Analysis Criteria',b'Soil Analysis Criteria',b'Bodemanalysecriteria'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2041',b'Please select customer',b'Maak een keuze van de klant'
-b'DocType: C-Form',b'I',b'ik'
-b'DocType: Company',b'Asset Depreciation Cost Center',b'Asset Afschrijvingen kostenplaats'
-b'DocType: Production Plan Sales Order',b'Sales Order Date',b'Verkooporder Datum'
-b'DocType: Sales Invoice Item',b'Delivered Qty',b'Geleverd Aantal'
-b'DocType: Assessment Plan',b'Assessment Plan',b'assessment Plan'
-b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90',b'Customer {0} is created.',b'Klant {0} is gemaakt.'
-b'DocType: Stock Settings',b'Limit Percent',b'Limit Procent'
-b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82',b' Currently no stock available in any warehouse',b'Momenteel geen voorraad beschikbaar in een magazijn'
-,b'Payment Period Based On Invoice Date',b'Betaling Periode gebaseerd op factuurdatum'
-b'DocType: Sample Collection',b'No. of print',b'Aantal afdrukken'
-b'DocType: Hotel Room Reservation Item',b'Hotel Room Reservation Item',b'Hotelkamerreserveringsitem'
-b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58',b'Missing Currency Exchange Rates for {0}',b'Ontbrekende Wisselkoersen voor {0}'
-b'DocType: Health Insurance',b'Health Insurance Name',b'Ziekteverzekeringsnaam'
-b'DocType: Assessment Plan',b'Examiner',b'Examinator'
-b'DocType: Student',b'Siblings',b'broers en zussen'
-b'DocType: Journal Entry',b'Stock Entry',b'Voorraadtransactie'
-b'DocType: Payment Entry',b'Payment References',b'betaling Referenties'
-b'DocType: C-Form',b'C-FORM-',b'C-vorm-'
-b'DocType: Vehicle',b'Insurance Details',b'verzekering Details'
-b'DocType: Account',b'Payable',b'betaalbaar'
-b'DocType: Share Balance',b'Share Type',b'Type delen'
-b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113',b'Please enter Repayment Periods',b'Vul de aflossingsperiode'
-b'apps/erpnext/erpnext/shopping_cart/cart.py +378',b'Debtors ({0})',b'Debiteuren ({0})'
-b'DocType: Pricing Rule',b'Margin',b'Marge'
-b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57',b'New Customers',b'Nieuwe klanten'
-b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74',b'Gross Profit %',b'Brutowinst%'
-b'DocType: Appraisal Goal',b'Weightage (%)',b'Weging (%)'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +503',b'Change POS Profile',b'POS-profiel wijzigen'
-b'DocType: Bank Reconciliation Detail',b'Clearance Date',b'Clearance Datum'
-b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7',b'Assessment Report',b'Beoordelingsverslag'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +59',b'Gross Purchase Amount is mandatory',b'Gross Aankoopbedrag is verplicht'
-b'apps/erpnext/erpnext/setup/doctype/company/company.js +95',b'Company name not same',b'Bedrijfsnaam niet hetzelfde'
-b'DocType: Lead',b'Address Desc',b'Adres Omschr'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113',b'Party is mandatory',b'Party is verplicht'
-b'DocType: Journal Entry',b'JV-',b'JV-'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +712',b'Rows with duplicate due dates in other rows were found: {list}',b'Rijen met dubbele vervaldatums in andere rijen zijn gevonden: {lijst}'
-b'DocType: Topic',b'Topic Name',b'topic Naam'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37',b'Atleast one of the Selling or Buying must be selected',b'Tenminste een van de verkopen of aankopen moeten worden gekozen'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290',b'Select an employee to get the employee advance.',b'Selecteer een medewerker om de werknemer voor te bereiden.'
-b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56',b'Please select a valid Date',b'Selecteer een geldige datum alstublieft'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +36',b'Select the nature of your business.',b'Selecteer de aard van uw bedrijf.'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +24',b'Please setup Employee Naming System in Human Resource &gt; HR Settings',b'Stel Employee Naming System in Human Resource&gt; HR-instellingen in'
-b'DocType: Lab Test Template',"b'Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.'","b""Single voor resultaten die alleen een enkele invoer vereisen, resultaat UOM en normale waarde <br> Verbonden voor resultaten die meerdere invoervelden vereisen met overeenkomstige gebeurtenisnamen, resulteren UOM's en normale waarden <br> Beschrijvend voor tests die meerdere resultaatcomponenten en bijbehorende resultaatinvoervelden bevatten. <br> Gegroepeerd voor test templates die een groep andere test templates zijn. <br> Geen resultaat voor tests zonder resultaten. Ook is er geen Lab Test gemaakt. bv. Subtests voor Gegroepeerde resultaten."""
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86',b'Row #{0}: Duplicate entry in References {1} {2}',b'Rij # {0}: Duplicate entry in Referenties {1} {2}'
-b'apps/erpnext/erpnext/config/manufacturing.py +57',b'Where manufacturing operations are carried.',b'Waar de productie-activiteiten worden uitgevoerd.'
-b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18',b'As Examiner',b'Als examinator'
-b'DocType: Appointment Type',b'Default Duration',b'Standaard duur'
-b'DocType: Asset Movement',b'Source Warehouse',b'Bron Magazijn'
-b'DocType: Installation Note',b'Installation Date',b'Installatie Datum'
-b'apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30',b'Share Ledger',b'Deel Ledger'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +606',b'Row #{0}: Asset {1} does not belong to company {2}',b'Rij # {0}: Asset {1} hoort niet bij bedrijf {2}'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206',b'Sales Invoice {0} created',b'Verkoopfactuur {0} gemaakt'
-b'DocType: Employee',b'Confirmation Date',b'Bevestigingsdatum'
-b'DocType: C-Form',b'Total Invoiced Amount',b'Totaal Gefactureerd bedrag'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50',b'Min Qty can not be greater than Max Qty',b'Min Aantal kan niet groter zijn dan Max Aantal zijn'
-b'DocType: Soil Texture',b'Silty Clay',b'Leemklei'
-b'DocType: Account',b'Accumulated Depreciation',b'Cumulatieve afschrijvingen'
-b'DocType: Supplier Scorecard Scoring Standing',b'Standing Name',b'Staande naam'
-b'DocType: Stock Entry',b'Customer or Supplier Details',b'Klant of leverancier Details'
-b'DocType: Employee Loan Application',b'Required by Date',b'Vereist door Date'
-b'DocType: Lead',b'Lead Owner',b'Lead Eigenaar'
-b'DocType: Production Plan',b'Sales Orders Detail',b'Detail verkooporders'
-b'DocType: Bin',b'Requested Quantity',b'gevraagde hoeveelheid'
-b'DocType: Patient',b'Marital Status',b'Burgerlijke staat'
-b'DocType: Stock Settings',b'Auto Material Request',b'Automatisch Materiaal Request'
-b'DocType: Delivery Note Item',b'Available Batch Qty at From Warehouse',b'Beschikbaar Aantal Batch bij Van Warehouse'
-b'DocType: Customer',b'CUST-',b'CUST-'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Idevise',b'Idevise'
-b'DocType: Salary Slip',b'Gross Pay - Total Deduction - Loan Repayment',b'Brutoloon - Total Aftrek - aflossing van de lening'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29',b'Current BOM and New BOM can not be same',b'Huidige Stuklijst en Nieuwe Stuklijst kunnen niet hetzelfde zijn'
-b'apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47',b'Salary Slip ID',b'Loonstrook ID'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +118',b'Date Of Retirement must be greater than Date of Joining',b'Pensioneringsdatum moet groter zijn dan datum van indiensttreding'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +68',b'Multiple Variants',b'Meerdere varianten'
-b'DocType: Sales Invoice',b'Against Income Account',b'Tegen Inkomstenrekening'
-b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +117',b'{0}% Delivered',b'{0}% Geleverd'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107',b'Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).',b'Item {0}: Bestelde aantal {1} kan niet kleiner dan de minimale afname {2} (gedefinieerd in punt) zijn.'
-b'DocType: Monthly Distribution Percentage',b'Monthly Distribution Percentage',b'Maandelijkse Verdeling Percentage'
-b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49',b'Please login as another user.',b'Meld u aan als een andere gebruiker.'
-b'DocType: Daily Work Summary Group User',b'Daily Work Summary Group User',b'Daily Work Summary Group User'
-b'DocType: Territory',b'Territory Targets',b'Regio Doelen'
-b'DocType: Soil Analysis',b'Ca/Mg',b'Ca / Mg'
-b'DocType: Delivery Note',b'Transporter Info',b'Vervoerder Info'
-b'apps/erpnext/erpnext/accounts/utils.py +502',b'Please set default {0} in Company {1}',b'Stel default {0} in Company {1}'
-b'DocType: Cheque Print Template',b'Starting position from top edge',b'Uitgangspositie van bovenrand'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33',b'Same supplier has been entered multiple times',b'Dezelfde leverancier is meerdere keren ingevoerd'
-b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152',b'Gross Profit / Loss',b'Bruto winst / verlies'
-,b'Warehouse wise Item Balance Age and Value',b'Magazijnbeheer Artikelbalans Leeftijd en waarde'
-b'DocType: Purchase Order Item Supplied',b'Purchase Order Item Supplied',b'Inkooporder Artikel geleverd'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +94',b'Company Name cannot be Company',b'Bedrijfsnaam kan niet bedrijf zijn'
-b'apps/erpnext/erpnext/config/setup.py +27',b'Letter Heads for print templates.',b'Briefhoofden voor print sjablonen.'
-b'apps/erpnext/erpnext/config/setup.py +32',b'Titles for print templates e.g. Proforma Invoice.',b'Titels voor print sjablonen bijv. Proforma Factuur.'
-b'DocType: Program Enrollment',b'Walking',b'wandelen'
-b'DocType: Student Guardian',b'Student Guardian',b'student Guardian'
-b'DocType: Member',b'Member Name',b'Lid Naam'
-b'DocType: Stock Settings',b'Use Naming Series',b'Gebruik Naming Series'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218',b'Valuation type charges can not marked as Inclusive',b'Soort waardering kosten kunnen niet zo Inclusive gemarkeerd'
-b'DocType: POS Profile',b'Update Stock',b'Voorraad bijwerken'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'in the subscription',b'in het abonnement'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100',b'Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.',b'Verschillende eenheden voor artikelen zal leiden tot een onjuiste (Totaal) Netto gewicht. Zorg ervoor dat Netto gewicht van elk artikel in dezelfde eenheid is.'
-b'DocType: Membership',b'Payment Details',b'Betalingsdetails'
-b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'BOM Rate',b'Stuklijst tarief'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225',"b'Stopped Work Order cannot be cancelled, Unstop it first to cancel'","b'Stopped Work Order kan niet geannuleerd worden, laat het eerst annuleren om te annuleren'"
-b'DocType: Asset',b'Journal Entry for Scrap',b'Dagboek voor Productieverlies'
-b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83',b'Please pull items from Delivery Note',b'Haal aub artikelen uit de Vrachtbrief'
-b'apps/erpnext/erpnext/accounts/utils.py +472',b'Journal Entries {0} are un-linked',b'Journaalposten {0} zijn un-linked'
-b'apps/erpnext/erpnext/config/crm.py +92',"b'Record of all communications of type email, phone, chat, visit, etc.'","b'Record van alle communicatie van het type e-mail, telefoon, chat, bezoek, etc.'"
-b'DocType: Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing',b'Leverancier Scorecard Scoring Standing'
-b'DocType: Manufacturer',b'Manufacturers used in Items',b'Fabrikanten gebruikt in Items'
-b'apps/erpnext/erpnext/accounts/general_ledger.py +170',b'Please mention Round Off Cost Center in Company',b'Vermeld Ronde Off kostenplaats in Company'
-b'DocType: Purchase Invoice',b'Terms',b'Voorwaarden'
-b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10',b'Select Days',b'Selecteer dagen'
-b'DocType: Academic Term',b'Term Name',b'term Naam'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332',b'Credit ({0})',b'Krediet ({0})'
-b'DocType: Buying Settings',b'Purchase Order Required',b'Inkooporder verplicht'
-,b'Item-wise Sales History',b'Artikelgebaseerde Verkoop Geschiedenis'
-b'DocType: Expense Claim',b'Total Sanctioned Amount',b'Totaal Goedgekeurd Bedrag'
-b'DocType: Land Unit',b'Land Unit',b'Landeenheid'
-,b'Purchase Analytics',b'Inkoop Analyse'
-b'DocType: Sales Invoice Item',b'Delivery Note Item',b'Vrachtbrief Artikel'
-b'DocType: Asset Maintenance Log',b'Task',b'Taak'
-b'DocType: Purchase Taxes and Charges',b'Reference Row #',b'Referentie Rij #'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76',b'Batch number is mandatory for Item {0}',b'Partij nummer is verplicht voor artikel {0}'
-b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13',b'This is a root sales person and cannot be edited.',b'Dit is een basis verkoper en kan niet worden bewerkt .'
-b'DocType: Salary Detail',"b""If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ""","b'Als geselecteerd, draagt de waarde die is opgegeven of berekend in dit onderdeel niet bij tot de winst of aftrek. De waarde ervan kan echter worden verwezen door andere componenten die kunnen worden toegevoegd of afgetrokken.'"
-b'DocType: Salary Detail',"b""If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ""","b'Als geselecteerd, draagt de waarde die is opgegeven of berekend in dit onderdeel niet bij tot de winst of aftrek. De waarde ervan kan echter worden verwezen door andere componenten die kunnen worden toegevoegd of afgetrokken.'"
-b'DocType: Asset Settings',b'Number of Days in Fiscal Year',b'Aantal dagen in fiscaal jaar'
-,b'Stock Ledger',b'Voorraad Dagboek'
-b'apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29',b'Rate: {0}',b'Prijs: {0}'
-b'DocType: Company',b'Exchange Gain / Loss Account',b'Exchange winst / verliesrekening'
-b'apps/erpnext/erpnext/config/hr.py +7',b'Employee and Attendance',b'Werknemer en Aanwezigheid'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93',b'Purpose must be one of {0}',b'Doel moet \xc3\xa9\xc3\xa9n zijn van {0}'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100',b'Fill the form and save it',b'Vul het formulier in en sla het op'
-b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26',b'Community Forum',b'Community Forum'
-b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Werkelijke hoeveelheid op voorraad'
-b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Werkelijke hoeveelheid op voorraad'
-b'DocType: Homepage',"b'URL for ""All Products""'",b'URL voor &quot;Alle producten&quot;'
-b'DocType: Leave Application',b'Leave Balance Before Application',b'Verlofsaldo voor aanvraag'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46',b'Send SMS',b'SMS versturen'
-b'DocType: Supplier Scorecard Criteria',b'Max Score',b'Max score'
-b'DocType: Cheque Print Template',b'Width of amount in word',b'Breedte van de hoeveelheid in woord'
-b'DocType: Company',b'Default Letter Head',b'Standaard Briefhoofd'
-b'DocType: Purchase Order',b'Get Items from Open Material Requests',b'Krijg items van Open Materiaal Aanvragen'
-b'DocType: Hotel Room Amenity',b'Billable',b'Factureerbaar'
-b'DocType: Lab Test Template',b'Standard Selling Rate',b'Standard Selling Rate'
-b'DocType: Account',b'Rate at which this tax is applied',b'Percentage waarmee deze belasting toegepast wordt'
-b'DocType: Cash Flow Mapper',b'Section Name',b'sectie naam'
-b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77',b'Reorder Qty',b'Bestelaantal'
-b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28',b'Current Job Openings',b'Huidige vacatures'
-b'DocType: Company',b'Stock Adjustment Account',b'Voorraad Aanpassing Rekening'
-b'apps/erpnext/erpnext/public/js/payment/pos_payment.html +17',b'Write Off',b'Afschrijven'
-b'DocType: Patient Service Unit',b'Allow Overlap',b'Overlap toestaan'
-b'DocType: Timesheet Detail',b'Operation ID',b'Operation ID'
-b'DocType: Employee',"b'System User (login) ID. If set, it will become default for all HR forms.'","b'Systeemgebruiker (login) ID. Indien ingesteld, zal het de standaard worden voor alle HR-formulieren.'"
-b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16',b'{0}: From {1}',b'{0}: Van {1}'
-b'DocType: Task',b'depends_on',b'hangt af van'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60',b'Queued for updating latest price in all Bill of Materials. It may take a few minutes.',b'In afwachting van het bijwerken van de laatste prijs in alle Materialen. Het kan enkele minuten duren.'
-b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26',"b""Name of new Account. Note: Please don't create accounts for Customers and Suppliers""",b'De naam van de nieuwe account. Let op: Gelieve niet goed voor klanten en leveranciers te cre\xc3\xabren'
-b'apps/erpnext/erpnext/config/setup.py +37',b'Country wise default Address Templates',b'Landgebaseerde standaard adressjablonen'
-b'DocType: Water Analysis',b'Appearance',b'Uiterlijk'
-b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Buying Price List Rate',b'Gem. Prijslijst kopen'
-b'DocType: Sales Order Item',b'Supplier delivers to Customer',b'Leverancier levert aan de Klant'
-b'apps/erpnext/erpnext/config/non_profit.py +23',b'Member information.',b'Informatie over leden.'
-b'apps/erpnext/erpnext/utilities/bot.py +34',b'[{0}](#Form/Item/{0}) is out of stock',b'[{0}] (# Vorm / Item / {0}) is niet op voorraad'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +58',b'Asset Maintenance',b'Asset onderhoud'
-,b'Sales Payment Summary',b'Samenvatting verkoopbetaling'
-b'DocType: Restaurant',b'Restaurant',b'Restaurant'
-b'apps/erpnext/erpnext/accounts/party.py +320',b'Due / Reference Date cannot be after {0}',b'Verval- / Referentiedatum kan niet na {0} zijn'
-b'apps/erpnext/erpnext/config/setup.py +51',b'Data Import and Export',b'Gegevens importeren en exporteren'
-b'DocType: Patient',b'Account Details',b'Account Details'
-b'DocType: Crop',b'Materials Required',b'Benodigde materialen'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76',b'No students Found',b'Geen studenten gevonden'
-b'DocType: Medical Department',b'Medical Department',b'Medische Afdeling'
-b'DocType: Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Criteria',b'Scorecard Scoringscriteria voor leveranciers'
-b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55',b'Invoice Posting Date',b'Factuur Boekingsdatum'
-b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25',b'Sell',b'Verkopen'
-b'DocType: Purchase Invoice',b'Rounded Total',b'Afgerond Totaal'
-b'DocType: Product Bundle',b'List items that form the package.',b'Lijst items die het pakket vormen.'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39',b'Not permitted. Please disable the Test Template',b'Niet toegestaan. Schakel de testsjabloon uit'
-b'apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26',b'Percentage Allocation should be equal to 100%',b'Percentage toewijzing moet gelijk zijn aan 100%'
-b'DocType: Crop Cycle',b'Linked Land Unit',b'Linked Land Unit'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584',b'Please select Posting Date before selecting Party',b'Selecteer Boekingsdatum voordat Party selecteren'
-b'DocType: Program Enrollment',b'School House',b'School House'
-b'DocType: Serial No',b'Out of AMC',b'Uit AMC'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +82',b'Number of Depreciations Booked cannot be greater than Total Number of Depreciations',b'Aantal afschrijvingen geboekt kan niet groter zijn dan het totale aantal van de afschrijvingen zijn'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47',b'Make Maintenance Visit',b'Maak Maintenance Visit'
-b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +215',b'Please contact to the user who have Sales Master Manager {0} role',b'Neem dan contact op met de gebruiker die hebben Sales Master Manager {0} rol'
-b'DocType: Company',b'Default Cash Account',b'Standaard Kasrekening'
-b'apps/erpnext/erpnext/config/accounts.py +62',b'Company (not Customer or Supplier) master.',b'Bedrijf ( geen klant of leverancier ) meester.'
-b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6',b'This is based on the attendance of this Student',b'Dit is gebaseerd op de aanwezigheid van de Student'
-b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178',b'No Students in',b'Geen studenten in'
-b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179',b'Add more items or open full form',b'Voeg meer items of geopend volledige vorm'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212',b'Delivery Notes {0} must be cancelled before cancelling this Sales Order',b'Vrachtbrief {0} moet worden geannuleerd voordat het annuleren van deze Verkooporder'
-b'apps/erpnext/erpnext/utilities/user_progress.py +259',b'Go to Users',b'Ga naar gebruikers'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85',b'Paid amount + Write Off Amount can not be greater than Grand Total',b'Betaald bedrag + Afgeschreven bedrag kan niet groter zijn dan Eindtotaal'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78',b'{0} is not a valid Batch Number for Item {1}',b'{0} is geen geldig batchnummer voor Artikel {1}'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130',b'Note: There is not enough leave balance for Leave Type {0}',b'Opmerking: Er is niet genoeg verlofsaldo voor Verlof type {0}'
-b'apps/erpnext/erpnext/regional/india/utils.py +16',b'Invalid GSTIN or Enter NA for Unregistered',b'Ongeldige GSTIN of voer NA in voor niet-geregistreerde'
-b'DocType: Training Event',b'Seminar',b'congres'
-b'DocType: Program Enrollment Fee',b'Program Enrollment Fee',b'Programma inschrijvingsgeld'
-b'DocType: Item',b'Supplier Items',b'Leverancier Artikelen'
-b'DocType: Opportunity',b'Opportunity Type',b'Type opportuniteit'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16',b'New Company',b'Nieuw Bedrijf'
-b'apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17',b'Transactions can only be deleted by the creator of the Company',b'Transacties kunnen alleen worden verwijderd door de maker van de Vennootschap'
-b'apps/erpnext/erpnext/accounts/general_ledger.py +21',b'Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.',b'Onjuist aantal Grootboekposten gevonden. U zou een verkeerde rekening kunnen hebben geselecteerd in de transactie.'
-b'DocType: Employee',b'Prefered Contact Email',b'Voorkeur Contact E-mail'
-b'DocType: Cheque Print Template',b'Cheque Width',b'Cheque Breedte'
-b'DocType: Selling Settings',b'Validate Selling Price for Item against Purchase Rate or Valuation Rate',b'Valideren verkoopprijs voor post tegen Purchase Rate of Valuation Rate'
-b'DocType: Fee Schedule',b'Fee Schedule',b'fee Schedule'
-b'DocType: Hub Settings',b'Publish Availability',b'Publiceer Beschikbaarheid'
-b'DocType: Company',b'Create Chart Of Accounts Based On',b'Maak rekeningschema op basis van'
-b'apps/erpnext/erpnext/projects/doctype/task/task.js +91',b'Cannot convert it to non-group. Child Tasks exist.',b'Kan het niet omzetten naar een niet-groep. Kindertaken bestaan.'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +112',b'Date of Birth cannot be greater than today.',b'Geboortedatum mag niet groter zijn dan vandaag.'
-,b'Stock Ageing',b'Voorraad Veroudering'
-b'apps/erpnext/erpnext/education/doctype/student/student.py +40',b'Student {0} exist against student applicant {1}',b'Student {0} bestaat tegen student aanvrager {1}'
-b'DocType: Purchase Invoice',b'Rounding Adjustment (Company Currency)',b'Afronding aanpassing (bedrijfsmunt)'
-b'apps/erpnext/erpnext/projects/doctype/task/task.js +39',b'Timesheet',b'Rooster'
-b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243',b'Batch: ',b'Partij:'
-b'DocType: Volunteer',b'Afternoon',b'Middag'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +258',"b""{0} '{1}' is disabled""","b""{0} '{1}'is uitgeschakeld"""
-b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13',b'Set as Open',b'Instellen als Open'
-b'DocType: Cheque Print Template',b'Scanned Cheque',b'gescande Cheque'
-b'DocType: Notification Control',b'Send automatic emails to Contacts on Submitting transactions.',b'Stuur automatische e-mails naar Contactpersonen op Indienen transacties.'
-b'DocType: Timesheet',b'Total Billable Amount',b'Totaal bedrag Factureerbare'
-b'DocType: Customer',b'Credit Limit and Payment Terms',b'Kredietlimiet en betalingsvoorwaarden'
-b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20',b'Item 3',b'Punt 3'
-b'apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6',b'Order Entry',b'Orderinvoer'
-b'DocType: Purchase Order',b'Customer Contact Email',b'E-mail Contactpersoon Klant'
-b'DocType: Warranty Claim',b'Item and Warranty Details',b'Item en garantie Details'
-b'DocType: Chapter',b'Chapter Members',b'Hoofdstukleden'
-b'DocType: Sales Team',b'Contribution (%)',b'Bijdrage (%)'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +102',"b""Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified""","b""Opmerking: De betaling wordt niet aangemaakt, aangezien de 'Kas- of Bankrekening' niet gespecificeerd is."""
-b'apps/erpnext/erpnext/projects/doctype/project/project.py +70',b'Project {0} already exists',b'Project {0} bestaat al'
-b'DocType: Medical Department',b'Nursing User',b'Verpleegkundige gebruiker'
-b'DocType: Plant Analysis',b'Plant Analysis Criterias',b'Plant Analysis Criteria'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239',b'Responsibilities',b'Verantwoordelijkheden'
-b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125',b'Validity period of this quotation has ended.',b'Geldigheidsduur van deze offerte is be\xc3\xabindigd.'
-b'DocType: Expense Claim Account',b'Expense Claim Account',b'Declaratie Account'
-b'DocType: Accounts Settings',b'Allow Stale Exchange Rates',b'Staale wisselkoersen toestaan'
-b'DocType: Sales Person',b'Sales Person Name',b'Verkoper Naam'
-b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54',b'Please enter atleast 1 invoice in the table',b'Vul tenminste 1 factuur in in de tabel'
-b'apps/erpnext/erpnext/utilities/user_progress.py +247',b'Add Users',b'Gebruikers toevoegen'
-b'DocType: POS Item Group',b'Item Group',b'Artikelgroep'
-b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16',b'Student Group: ',b'Studentengroep:'
-b'DocType: Item',b'Safety Stock',b'Veiligheidsvoorraad'
-b'DocType: Healthcare Settings',b'Healthcare Settings',b'Gezondheidszorginstellingen'
-b'apps/erpnext/erpnext/projects/doctype/task/task.py +54',b'Progress % for a task cannot be more than 100.',b'Voortgang% voor een taak kan niet meer dan 100 zijn.'
-b'DocType: Stock Reconciliation Item',b'Before reconciliation',b'Voordat verzoening'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12',b'To {0}',b'Naar {0}'
-b'DocType: Purchase Invoice',b'Taxes and Charges Added (Company Currency)',b'Belastingen en Toeslagen toegevoegd (Bedrijfsvaluta)'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +476',b'Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable',b'Item Tax Rij {0} moet rekening houden met het type belasting of inkomsten of uitgaven of Chargeable'
-b'DocType: Sales Order',b'Partly Billed',b'Deels Gefactureerd'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +43',b'Item {0} must be a Fixed Asset Item',b'Item {0} moet een post der vaste activa zijn'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +372',b'Make Variants',b'Varianten maken'
-b'DocType: Item',b'Default BOM',b'Standaard Stuklijst'
-b'DocType: Project',b'Total Billed Amount (via Sales Invoices)',b'Totaal gefactureerd bedrag (via verkoopfacturen)'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Debit Note Amount',b'Debietnota Bedrag'
-b'DocType: Project Update',b'Not Updated',b'Niet ge\xc3\xbcpdate'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106',"b'There are inconsistencies between the rate, no of shares and the amount calculated'","b'Er zijn inconsistenties tussen de koers, aantal aandelen en het berekende bedrag'"
-b'apps/erpnext/erpnext/setup/doctype/company/company.js +89',b'Please re-type company name to confirm',b'Gelieve re-type bedrijfsnaam te bevestigen'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +216',b'Total Outstanding Amt',b'Totale uitstaande Amt'
-b'DocType: Journal Entry',b'Printing Settings',b'Instellingen afdrukken'
-b'DocType: Employee Advance',b'Advance Account',b'Voorschot rekening'
-b'DocType: Job Offer',b'Job Offer Terms',b'Biedingsvoorwaarden'
-b'DocType: Sales Invoice',b'Include Payment (POS)',b'Inclusief Betaling (POS)'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292',b'Total Debit must be equal to Total Credit. The difference is {0}',b'Totaal Debet moet gelijk zijn aan Totaal Credit. Het verschil is {0}'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11',b'Automotive',b'Automotive'
-b'DocType: Vehicle',b'Insurance Company',b'Verzekeringsbedrijf'
-b'DocType: Asset Category Account',b'Fixed Asset Account',b'Fixed Asset Account'
-b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414',b'Variable',b'Variabele'
-b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47',b'From Delivery Note',b'Van Vrachtbrief'
-b'DocType: Chapter',b'Members',b'leden'
-b'DocType: Student',b'Student Email Address',b'Student e-mailadres'
-b'DocType: Item',b'Hub Warehouse',b'Hub Warehouse'
-b'DocType: Assessment Plan',b'From Time',b'Van Tijd'
-b'DocType: Hotel Settings',b'Hotel Settings',b'Hotelinstellingen'
-b'apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12',b'In Stock: ',b'Op voorraad:'
-b'DocType: Notification Control',b'Custom Message',b'Aangepast bericht'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33',b'Investment Banking',b'Investment Banking'
-b'DocType: Purchase Invoice',b'input',b'invoer'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79',b'Cash or Bank Account is mandatory for making payment entry',b'Kas- of Bankrekening is verplicht om een  betaling aan te maken'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Studentenadres'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Studentenadres'
-b'DocType: Purchase Invoice',b'Price List Exchange Rate',b'Prijslijst Wisselkoers'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +251',b'Account Number {0} already used in account {1}',b'Accountnummer {0} al gebruikt in account {1}'
-b'DocType: GoCardless Mandate',b'Mandate',b'Mandaat'
-b'DocType: POS Profile',b'POS Profile Name',b'POS-profielnaam'
-b'DocType: Hotel Room Reservation',b'Booked',b'geboekt'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxLib',b'CompAuxLib'
-b'DocType: Purchase Invoice Item',b'Rate',b'Tarief'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104',b'Intern',b'intern'
-b'DocType: Delivery Stop',b'Address Name',b'Adres naam'
-b'DocType: Stock Entry',b'From BOM',b'Van BOM'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639',b'Splitting {0} units of {1}',b'{0} eenheden van {1} splitsen'
-b'DocType: Assessment Code',b'Assessment Code',b'assessment Code'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73',b'Basic',b'Basis'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94',b'Stock transactions before {0} are frozen',b'Voorraadtransacties voor {0} zijn bevroren'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219',"b""Please click on 'Generate Schedule'""","b""Klik op 'Genereer Planning'"""
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122',b'Reference No is mandatory if you entered Reference Date',b'Referentienummer is verplicht als u een referentiedatum hebt ingevoerd'
-b'DocType: Bank Reconciliation Detail',b'Payment Document',b'betaling Document'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37',b'Error evaluating the criteria formula',b'Fout bij het evalueren van de criteria formule'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +115',b'Date of Joining must be greater than Date of Birth',b'Datum van indiensttreding moet groter zijn dan geboortedatum'
-b'DocType: Salary Slip',b'Salary Structure',b'Salarisstructuur'
-b'DocType: Account',b'Bank',b'Bank'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9',b'Airline',b'vliegmaatschappij'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853',b'Issue Material',b'Materiaal uitgeven'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'An error occured while creating recurring',b'Er is een fout opgetreden tijdens het maken van terugkerende'
-b'DocType: Material Request Item',b'For Warehouse',b'Voor Magazijn'
-b'DocType: Employee',b'Offer Date',b'Aanbieding datum'
-b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33',b'Quotations',b'Citaten'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +735',b'You are in offline mode. You will not be able to reload until you have network.',b'Je bent in de offline modus. Je zult niet in staat om te herladen tot je opnieuw verbonden bent met het netwerk.'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47',b'No Student Groups created.',b'Geen groepen studenten gecre\xc3\xaberd.'
-b'DocType: Purchase Invoice Item',b'Serial No',b'Serienummer'
-b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119',b'Monthly Repayment Amount cannot be greater than Loan Amount',b'Maandelijks te betalen bedrag kan niet groter zijn dan Leningen zijn'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143',b'Please enter Maintaince Details first',b'Vul eerst Onderhoudsdetails in'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56',b'Row #{0}: Expected Delivery Date cannot be before Purchase Order Date',b'Rij # {0}: Verwachte Afleverdatum kan niet v\xc3\xb3\xc3\xb3r de Aankoopdatum zijn'
-b'DocType: Purchase Invoice',b'Print Language',b'Print Taal'
-b'DocType: Salary Slip',b'Total Working Hours',b'Totaal aantal Werkuren'
-b'DocType: Sales Invoice',b'Customer PO Details',b'Klant PO-details'
-b'DocType: Subscription',b'Next Schedule Date',b'Volgende schema datum'
-b'DocType: Stock Entry',b'Including items for sub assemblies',b'Inclusief items voor sub assemblies'
-b'DocType: Opening Invoice Creation Tool Item',b'Temporary Opening Account',b'Tijdelijk account openen'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1964',b'Enter value must be positive',b'Voer waarde moet positief zijn'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446',b'All Territories',b'Alle gebieden'
-b'apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49',b'Add Multiple Tasks',b'Meerdere taken toevoegen'
-b'DocType: Purchase Invoice',b'Items',b'Artikelen'
-b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34',b'Student is already enrolled.',b'Student is reeds ingeschreven.'
-b'DocType: Fiscal Year',b'Year Name',b'Jaar Naam'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241',b'There are more holidays than working days this month.',b'Er zijn meer vakanties dan werkdagen deze maand .'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78',b'PDC/LC Ref',b'PDC / LC Ref'
-b'DocType: Product Bundle Item',b'Product Bundle Item',b'Product Bundle Item'
-b'DocType: Sales Partner',b'Sales Partner Name',b'Verkoop Partner Naam'
-b'apps/erpnext/erpnext/hooks.py +136',b'Request for Quotations',b'Verzoek om Offertes'
-b'DocType: Payment Reconciliation',b'Maximum Invoice Amount',b'Maximumfactuur Bedrag'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Montantdevise',b'Montantdevise'
-b'apps/erpnext/erpnext/healthcare/setup.py +210',b'Haematology',b'Hematologie'
-b'DocType: Normal Test Items',b'Normal Test Items',b'Normale Test Items'
-b'DocType: Student Language',b'Student Language',b'student Taal'
-b'apps/erpnext/erpnext/config/selling.py +23',b'Customers',b'Klanten'
-b'DocType: Cash Flow Mapping',b'Is Working Capital',b'Is werkkapitaal'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Order / Quot%'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Order / Quot%'
-b'apps/erpnext/erpnext/config/healthcare.py +25',b'Record Patient Vitals',b'Record Patient Vitals'
-b'DocType: Fee Schedule',b'Institution',b'Instelling'
-b'DocType: Asset',b'Partially Depreciated',b'gedeeltelijk afgeschreven'
-b'DocType: Issue',b'Opening Time',b'Opening Tijd'
-b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89',b'From and To dates required',b'Van en naar data vereist'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46',b'Securities & Commodity Exchanges',b'Securities & Commodity Exchanges'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +689',"b""Default Unit of Measure for Variant '{0}' must be same as in Template '{1}'""",b'Standaard maateenheid voor Variant &#39;{0}&#39; moet hetzelfde zijn als in zijn Template &#39;{1}&#39;'
-b'DocType: Shipping Rule',b'Calculate Based On',b'Berekenen gebaseerd op'
-b'DocType: Delivery Note Item',b'From Warehouse',b'Van Warehouse'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59',b'No employees for the mentioned criteria',b'Geen werknemers voor de genoemde criteria'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955',b'No Items with Bill of Materials to Manufacture',b'Geen Items met Bill of Materials voor fabricage'
-b'DocType: Hotel Settings',b'Default Customer',b'Standaard klant'
-b'DocType: Assessment Plan',b'Supervisor Name',b'supervisor Naam'
-b'DocType: Healthcare Settings',b'Do not confirm if appointment is created for the same day',b'Bevestig niet of afspraak voor dezelfde dag is gemaakt'
-b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Programma Inschrijvingscursus'
-b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Programma Inschrijvingscursus'
-b'DocType: Purchase Taxes and Charges',b'Valuation and Total',b'Waardering en Totaal'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11',b'Scorecards',b'scorecards'
-b'DocType: Tax Rule',b'Shipping City',b'Verzending Stad'
-b'DocType: Notification Control',b'Customize the Notification',b'Aanpassen Kennisgeving'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24',b'Cash Flow from Operations',b'De cashflow uit bedrijfsoperaties'
-b'DocType: Purchase Invoice',b'Shipping Rule',b'Verzendregel'
-b'DocType: Patient Relation',b'Spouse',b'Echtgenoot'
-b'DocType: Lab Test Groups',b'Add Test',b'Test toevoegen'
-b'DocType: Manufacturer',b'Limited to 12 characters',b'Beperkt tot 12 tekens'
-b'DocType: Journal Entry',b'Print Heading',b'Print Kop'
-b'apps/erpnext/erpnext/config/stock.py +146',b'Delivery Trip service tours to customers.',b'Levering Tripdienstreizen naar klanten.'
-b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57',b'Total cannot be zero',b'Totaal kan niet nul zijn'
-b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16',"b""'Days Since Last Order' must be greater than or equal to zero""","b""'Dagen sinds laatste opdracht' moet groter of gelijk zijn aan nul"""
-b'DocType: Plant Analysis Criteria',b'Maximum Permissible Value',b'Maximaal toelaatbare waarde'
-b'DocType: Journal Entry Account',b'Employee Advance',b'Medewerker Advance'
-b'DocType: Payroll Entry',b'Payroll Frequency',b'payroll Frequency'
-b'DocType: Lab Test Template',b'Sensitivity',b'Gevoeligheid'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941',b'Raw Material',b'grondstof'
-b'DocType: Leave Application',b'Follow via Email',b'Volg via e-mail'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55',b'Plants and Machineries',b'Installaties en Machines'
-b'DocType: Purchase Taxes and Charges',b'Tax Amount After Discount Amount',b'Belasting bedrag na korting'
-b'DocType: Daily Work Summary Settings',b'Daily Work Summary Settings',b'Dagelijks Werk Samenvatting Instellingen'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +447',b'Please enter Reqd by Date',b'Voer Reqd in op datum'
-b'DocType: Payment Entry',b'Internal Transfer',b'Interne overplaatsing'
-b'DocType: Asset Maintenance',b'Maintenance Tasks',b'Onderhoudstaken'
-b'apps/erpnext/erpnext/setup/doctype/territory/territory.py +19',b'Either target qty or target amount is mandatory',b'Ofwel doelwit aantal of streefbedrag is verplicht'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366',b'Please select Posting Date first',b'Selecteer Boekingsdatum eerste'
-b'apps/erpnext/erpnext/public/js/account_tree_grid.js +209',b'Opening Date should be before Closing Date',b'Openingsdatum moeten v\xc3\xb3\xc3\xb3r Sluitingsdatum'
-b'DocType: Leave Control Panel',b'Carry Forward',b'Carry Forward'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30',b'Cost Center with existing transactions can not be converted to ledger',b'Kostenplaats met bestaande transacties kan niet worden omgezet naar grootboek'
-b'DocType: Department',b'Days for which Holidays are blocked for this department.',b'Dagen waarvoor feestdagen zijn geblokkeerd voor deze afdeling.'
-b'DocType: GoCardless Mandate',b'ERPNext Integrations',b'ERPNext-integraties'
-b'DocType: Crop Cycle',b'Detected Disease',b'Gedetecteerde ziekte'
-,b'Produced',b'Geproduceerd'
-b'DocType: Item',b'Item Code for Suppliers',b'Item Code voor leveranciers'
-b'DocType: Issue',b'Raised By (Email)',b'Opgevoerd door (E-mail)'
-b'DocType: Training Event',b'Trainer Name',b'trainer Naam'
-b'DocType: Mode of Payment',b'General',b'Algemeen'
-b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Laatste Communicatie'
-b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Laatste Communicatie'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372',"b""Cannot deduct when category is for 'Valuation' or 'Valuation and Total'""","b""Kan niet aftrekken als categorie is voor ' Valuation ' of ' Valuation en Total '"""
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234',b'Serial Nos Required for Serialized Item {0}',b'Volgnummers zijn vereist voor Seriegebonden Artikel {0}'
-b'apps/erpnext/erpnext/config/accounts.py +144',b'Match Payments with Invoices',b'Match Betalingen met Facturen'
-b'DocType: Journal Entry',b'Bank Entry',b'Bank Invoer'
-b'DocType: Authorization Rule',b'Applicable To (Designation)',b'Van toepassing zijn op (Benaming)'
-,b'Profitability Analysis',b'winstgevendheid Analyse'
-b'DocType: Fees',b'Student Email',b'Student Email'
-b'DocType: Supplier',b'Prevent POs',b'Voorkom POs'
-b'DocType: Patient',"b'Allergies, Medical and Surgical History'","b'Allergie\xc3\xabn, Medische en Chirurgische Geschiedenis'"
-b'apps/erpnext/erpnext/templates/generators/item.html +77',b'Add to Cart',b'In winkelwagen'
-b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28',b'Group By',b'Groeperen volgens'
-b'DocType: Guardian',b'Interests',b'Interesses'
-b'apps/erpnext/erpnext/config/accounts.py +298',b'Enable / disable currencies.',b'In- / uitschakelen valuta .'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105',b'Dr {0} on Half day Leave on {1}',b'Dr {0} op halve dag Verlof op {1}'
-b'DocType: Production Plan',b'Get Material Request',b'Krijg Materiaal Request'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111',b'Postal Expenses',b'Portokosten'
-b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Amt)',b'Totaal (Amt)'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26',b'Entertainment & Leisure',b'Entertainment & Vrije Tijd'
-,b'Item Variant Details',b'Artikel Variant Details'
-b'DocType: Quality Inspection',b'Item Serial No',b'Artikel Serienummer'
-b'apps/erpnext/erpnext/utilities/activation.py +135',b'Create Employee Records',b'Maak Employee Records'
-b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Present',b'Totaal Present'
-b'apps/erpnext/erpnext/config/accounts.py +105',b'Accounting Statements',b'Boekhouding Jaarrekening'
-b'DocType: Drug Prescription',b'Hour',b'uur'
-b'DocType: Restaurant Order Entry',b'Last Sales Invoice',b'Laatste verkoopfactuur'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +788',b'Please select Qty against item {0}',b'Selecteer alstublieft Aantal tegen item {0}'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29',b'New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt',b'Nieuw Serienummer kan geen Magazijn krijgen. Magazijn moet via Voorraad Invoer of Ontvangst worden ingesteld.'
-b'DocType: Lead',b'Lead Type',b'Lead Type'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114',b'You are not authorized to approve leaves on Block Dates',b'U bent niet bevoegd om afwezigheid goed te keuren op Block Dates'
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394',b'All these items have already been invoiced',b'Al deze items zijn reeds gefactureerde'
-b'DocType: Company',b'Monthly Sales Target',b'Maandelijks verkooppunt'
-b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37',b'Can be approved by {0}',b'Kan door {0} worden goedgekeurd'
-b'DocType: Hotel Room',b'Hotel Room Type',b'Hotel kamertype'
-b'DocType: Item',b'Default Material Request Type',b'Standaard Materiaal Request Type'
-b'DocType: Supplier Scorecard',b'Evaluation Period',b'Evaluatie periode'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13',b'Unknown',b'Onbekend'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954',b'Work Order not created',b'Werkorder niet gemaakt'
-b'DocType: Shipping Rule',b'Shipping Rule Conditions',b'Verzendregel Voorwaarden'
-b'DocType: Purchase Invoice',b'Export Type',b'Exporttype'
-b'DocType: Salary Slip Loan',b'Salary Slip Loan',b'Salaris Sliplening'
-b'DocType: BOM Update Tool',b'The new BOM after replacement',b'De nieuwe Stuklijst na vervanging'
-,b'Point of Sale',b'Point of Sale'
-b'DocType: Payment Entry',b'Received Amount',b'ontvangen Bedrag'
-b'DocType: Patient',b'Widow',b'Weduwe'
-b'DocType: GST Settings',b'GSTIN Email Sent On',b'GSTIN Email Sent On'
-b'DocType: Program Enrollment',b'Pick/Drop by Guardian',b'Pick / Drop door Guardian'
-b'DocType: Crop',b'Planting UOM',b'UOM planten'
-b'DocType: Account',b'Tax',b'Belasting'
-b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45',b'Not Marked',b'ongemerkt'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1',b'Opening Invoices Summary',b'Factuuroverzicht openen'
-b'DocType: Education Settings',b'Education Manager',b'Education Manager'
-b'DocType: Crop Cycle',b'The minimum length between each plant in the field for optimum growth',b'De minimale lengte tussen elke plant in het veld voor optimale groei'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Batched item {0} kan niet worden bijgewerkt met behulp van Stock Reconciliation, maar gebruik Voorraadinvoer'"
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Batched item {0} kan niet worden bijgewerkt met behulp van Stock Reconciliation, maar gebruik Voorraadinvoer'"
-b'DocType: Quality Inspection',b'Report Date',b'Rapport datum'
-b'DocType: Student',b'Middle Name',b'Midden-naam'
-b'DocType: C-Form',b'Invoices',b'Facturen'
-b'DocType: Water Analysis',b'Type of Sample',b'Type monster'
-b'DocType: Batch',b'Source Document Name',b'Bron Document Naam'
-b'DocType: Batch',b'Source Document Name',b'Bron Document Naam'
-b'DocType: Production Plan',b'Get Raw Materials For Production',b'Krijg grondstoffen voor productie'
-b'DocType: Job Opening',b'Job Title',b'Functietitel'
-b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84',"b'{0} indicates that {1} will not provide a quotation, but all items \\\n\t\t\t\t\thave been quoted. Updating the RFQ quote status.'","b'{0} geeft aan dat {1} geen offerte zal opgeven, maar alle items \\ zijn geciteerd. De RFQ-citaatstatus bijwerken.'"
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026',b'Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.',b'Maximale voorbeelden - {0} zijn al bewaard voor Batch {1} en Item {2} in Batch {3}.'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125',b'Please Set Supplier Type in Buying Settings.',b'Geef het leverancierstype op in koopinstellingen.'
-b'DocType: Manufacturing Settings',b'Update BOM Cost Automatically',b'BOM kosten automatisch bijwerken'
-b'DocType: Lab Test',b'Test Name',b'Test Naam'
-b'apps/erpnext/erpnext/utilities/activation.py +99',b'Create Users',b'Gebruikers maken'
-b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Gram',b'Gram'
-b'DocType: Supplier Scorecard',b'Per Month',b'Per maand'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433',b'Quantity to Manufacture must be greater than 0.',b'Hoeveelheid voor fabricage moet groter dan 0 zijn.'
-b'DocType: Asset Settings',b'Calculate Prorated Depreciation Schedule Based on Fiscal Year',b'Bereken het pro rata van afschrijving op basis van het fiscale jaar'
-b'apps/erpnext/erpnext/config/maintenance.py +17',b'Visit report for maintenance call.',b'Bezoek rapport voor onderhoud gesprek.'
-b'DocType: Stock Entry',b'Update Rate and Availability',b'Update snelheid en beschikbaarheid'
-b'DocType: Stock Settings',b'Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.',b'Percentage dat u meer mag ontvangen of leveren dan de bestelde hoeveelheid. Bijvoorbeeld: Als u  100 eenheden heeft besteld en uw bandbreedte is 10% dan mag u 110 eenheden ontvangen.'
-b'DocType: POS Customer Group',b'Customer Group',b'Klantengroep'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217',b'Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs',b'Rij # {0}: bewerking {1} is niet voltooid voor {2} aantal voltooide goederen in werkorder # {3}. Werkstatus bijwerken via tijdlogboeken'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Nieuw batch-id (optioneel)'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Nieuw batch-id (optioneel)'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201',b'Expense account is mandatory for item {0}',b'Kostenrekening is verplicht voor artikel {0}'
-b'DocType: BOM',b'Website Description',b'Website Beschrijving'
-b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47',b'Net Change in Equity',b'Netto wijziging in het eigen vermogen'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +220',b'Please cancel Purchase Invoice {0} first',b'Annuleer Purchase Invoice {0} eerste'
-b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43',"b'Email Address must be unique, already exists for {0}'","b'E-mailadres moet uniek zijn, bestaat al voor {0}'"
-b'DocType: Serial No',b'AMC Expiry Date',b'AMC Vervaldatum'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880',b'Receipt',b'Ontvangst'
-,b'Sales Register',b'Verkoopregister'
-b'DocType: Daily Work Summary Group',b'Send Emails At',b'Stuur e-mails'
-b'DocType: Quotation',b'Quotation Lost Reason',b'Reden verlies van Offerte'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381',b'Transaction reference no {0} dated {1}',b'Transactiereferentie geen {0} van {1}'
-b'apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5',b'There is nothing to edit.',b'Er is niets om te bewerken .'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116',b'Summary for this month and pending activities',b'Samenvatting voor deze maand en in afwachting van activiteiten'
-b'apps/erpnext/erpnext/utilities/user_progress.py +248',"b'Add users to your organization, other than yourself.'","b'Voeg gebruikers toe aan uw organisatie, behalve uzelf.'"
-b'DocType: Customer Group',b'Customer Group Name',b'Klant Groepsnaam'
-b'apps/erpnext/erpnext/public/js/pos/pos.html +109',b'No Customers yet!',b'Nog geen klanten!'
-b'apps/erpnext/erpnext/public/js/financial_statements.js +56',b'Cash Flow Statement',b'Kasstroomoverzicht'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473',b'No material request created',b'Er is geen aanvraag voor een artikel gemaakt'
-b'apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23',b'Loan Amount cannot exceed Maximum Loan Amount of {0}',b'Geleende bedrag kan niet hoger zijn dan maximaal bedrag van de lening van {0}'
-b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22',b'License',b'Licentie'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491',b'Please remove this Invoice {0} from C-Form {1}',b'Verwijder dit Invoice {0} van C-Form {1}'
-b'DocType: Leave Control Panel',"b""Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year""",b'Selecteer Carry Forward als u ook wilt opnemen vorige boekjaar uit balans laat dit fiscale jaar'
-b'DocType: GL Entry',b'Against Voucher Type',b'Tegen Voucher Type'
-b'DocType: Physician',b'Phone (R)',b'Telefoon (R)'
-b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56',b'Time slots added',b'Tijdslots toegevoegd'
-b'DocType: Item',b'Attributes',b'Attributen'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31',b'Enable Template',b'Sjabloon inschakelen'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226',b'Please enter Write Off Account',b'Voer Afschrijvingenrekening in'
-b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71',b'Last Order Date',b'Laatste Bestel Date'
-b'DocType: Patient',b'B Negative',b'B Negatief'
-b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25',b'Maintenance Status has to be Cancelled or Completed to Submit',b'Onderhoudsstatus moet worden geannuleerd of voltooid om te verzenden'
-b'DocType: Hotel Room',b'Hotel Room',b'Hotelkamer'
-b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47',b'Account {0} does not belongs to company {1}',b'Account {0} behoort niet tot bedrijf {1}'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884',b'Serial Numbers in row {0} does not match with Delivery Note',b'Serienummers in rij {0} komt niet overeen met bezorgingsnota'
-b'DocType: Student',b'Guardian Details',b'Guardian Details'
-b'DocType: C-Form',b'C-Form',b'C-Form'
-b'apps/erpnext/erpnext/config/hr.py +18',b'Mark Attendance for multiple employees',b'Mark Attendance voor meerdere medewerkers'
-b'DocType: Agriculture Task',b'Start Day',b'Start dag'
-b'DocType: Vehicle',b'Chassis No',b'chassis Geen'
-b'DocType: Payment Request',b'Initiated',b'Ge\xc3\xafnitieerd'
-b'DocType: Production Plan Item',b'Planned Start Date',b'Geplande Startdatum'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +618',b'Please select a BOM',b'Selecteer een stuklijst'
-b'DocType: Purchase Invoice',b'Availed ITC Integrated Tax',b'Beschikbaar in ITC Integrated Tax'
-b'DocType: Serial No',b'Creation Document Type',b'Aanmaken Document type'
-b'DocType: Project Task',b'View Timesheet',b'Bekijk urenformulier'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54',b'End date must be greater than start date',b'Einddatum moet groter zijn dan startdatum'
-b'DocType: Leave Type',b'Is Encash',b'Is incasseren'
-b'DocType: Leave Allocation',b'New Leaves Allocated',b'Nieuwe Verloven Toegewezen'
-b'apps/erpnext/erpnext/controllers/trends.py +269',b'Project-wise data is not available for Quotation',b'Projectgegevens zijn niet beschikbaar voor Offertes'
-b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30',b'End on',b'Eindigt op'
-b'DocType: Project',b'Expected End Date',b'Verwachte einddatum'
-b'DocType: Budget Account',b'Budget Amount',b'budget Bedrag'
-b'DocType: Donor',b'Donor Name',b'Donornaam'
-b'DocType: Appraisal Template',b'Appraisal Template Title',b'Beoordeling Template titel'
-b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39',"b""From Date {0} for Employee {1} cannot be before employee's joining Date {2}""",b'Van Date {0} Werknemersverzekeringen {1} kan niet v\xc3\xb3\xc3\xb3r de toetreding tot Date werknemer {2}'
-b'apps/erpnext/erpnext/utilities/user_progress_utils.py +29',b'Commercial',b'commercieel'
-b'DocType: Patient',b'Alcohol Current Use',b'Alcohol Huidig Gebruik'
-b'DocType: Student Admission Program',b'Student Admission Program',b'Studenten toelating programma'
-b'DocType: Payment Entry',b'Account Paid To',b'Rekening betaald aan'
-b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24',b'Parent Item {0} must not be a Stock Item',b'Ouder Item {0} moet een Stock Item niet'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466',b'Could not submit any Salary Slip <br>\\\n\t\t\tPossible reasons: <br>\\\n\t\t\t1. Net pay is less than 0. <br>\\\n\t\t\t2. Company Email Address specified in employee master is not valid. <br>',"b'Kon geen salarisstrook indienen <br> \\ Mogelijke redenen: <br> \\ 1. Nettoloon is minder dan 0. <br> \\ 2. Het e-mailadres van het bedrijf dat in de werknemermaster is opgegeven, is niet geldig. <br>'"
-b'apps/erpnext/erpnext/config/selling.py +57',b'All Products or Services.',b'Alle producten of diensten.'
-b'DocType: Expense Claim',b'More Details',b'Meer details'
-b'DocType: Supplier Quotation',b'Supplier Address',b'Adres Leverancier'
-b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128',b'{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}',b'{0} Budget voor Account {1} tegen {2} {3} is {4}. Het zal overschrijden tegen {5}'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695',"b""Row {0}# Account must be of type 'Fixed Asset'""",b'Rij {0} # Account moet van het type zijn &#39;Vaste Activa&#39;'
-b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Out Qty',b'out Aantal'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'and unchcked Disabled in the',b'en unchcked Uitgeschakeld in de'
-b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41',b'Series is mandatory',b'Reeks is verplicht'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28',b'Financial Services',b'Financi\xc3\xable Dienstverlening'
-b'DocType: Student Sibling',b'Student ID',b'student ID'
-b'apps/erpnext/erpnext/config/projects.py +51',b'Types of activities for Time Logs',b'Soorten activiteiten voor Time Logs'
-b'DocType: Opening Invoice Creation Tool',b'Sales',b'Verkoop'
-b'DocType: Stock Entry Detail',b'Basic Amount',b'Basisbedrag'
-b'DocType: Training Event',b'Exam',b'tentamen'
-b'DocType: Complaint',b'Complaint',b'Klacht'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462',b'Warehouse required for stock Item {0}',b'Magazijn nodig voor voorraad Artikel {0}'
-b'DocType: Leave Allocation',b'Unused leaves',b'Ongebruikte afwezigheden'
-b'DocType: Patient',b'Alcohol Past Use',b'Alcohol voorbij gebruik'
-b'DocType: Fertilizer Content',b'Fertilizer Content',b'Kunstmestinhoud'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187',b'Cr',b'Cr'
-b'DocType: Project Update',b'Problematic/Stuck',b'Problematische / Stuck'
-b'DocType: Tax Rule',b'Billing State',b'Billing State'
-b'DocType: Share Transfer',b'Transfer',b'Verplaatsen'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252',b'Work Order {0} must be cancelled before cancelling this Sales Order',b'Werkorder {0} moet worden geannuleerd voordat deze klantorder wordt geannuleerd'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917',b'Fetch exploded BOM (including sub-assemblies)',b'Haal uitgeklapte Stuklijst op (inclusief onderdelen)'
-b'DocType: Authorization Rule',b'Applicable To (Employee)',b'Van toepassing zijn op (Werknemer)'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +137',b'Due Date is mandatory',b'Vervaldatum is verplicht'
-b'apps/erpnext/erpnext/controllers/item_variant.py +82',b'Increment for Attribute {0} cannot be 0',b'Toename voor Attribute {0} kan niet worden 0'
-b'apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19',b'Rooms Booked',b'Kamers geboekt'
-b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +57',b'Ends On date cannot be before Next Contact Date.',b'Eindigt op datum kan niet eerder zijn dan volgende contactdatum.'
-b'DocType: Journal Entry',b'Pay To / Recd From',b'Betaal aan / Ontv van'
-b'DocType: Naming Series',b'Setup Series',b'Instellen Reeksen'
-b'DocType: Payment Reconciliation',b'To Invoice Date',b'Om factuurdatum'
-b'DocType: Shareholder',b'Contact HTML',b'Contact HTML'
-b'apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19',b'Registration fee can not be Zero',b'Registratiekosten kunnen geen Zero zijn'
-b'DocType: Disease',b'Treatment Period',b'Behandelingsperiode'
-b'apps/erpnext/erpnext/education/api.py +338',b'Result already Submitted',b'Resultaat is al verzonden'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +169',b'Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied',b'Gereserveerd magazijn is verplicht voor artikel {0} in geleverde grondstoffen'
-,b'Inactive Customers',b'inactieve klanten'
-b'DocType: Student Admission Program',b'Maximum Age',b'Maximum leeftijd'
-b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28',b'Please wait 3 days before resending the reminder.',b'Wacht 3 dagen voordat je de herinnering opnieuw verzendt.'
-b'DocType: Landed Cost Voucher',b'LCV',b'LCV'
-b'DocType: Landed Cost Voucher',b'Purchase Receipts',b'Aankoopfacturen'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29',b'How Pricing Rule is applied?',b'Hoe wordt de Prijsregel toegepast?'
-b'DocType: Stock Entry',b'Delivery Note No',b'Vrachtbrief Nr'
-b'DocType: Cheque Print Template',b'Message to show',b'Bericht om te laten zien'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +28',b'Retail',b'Retail'
-b'DocType: Student Attendance',b'Absent',b'Afwezig'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591',b'Product Bundle',b'Product Bundle'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38',b'Unable to find score starting at {0}. You need to have standing scores covering 0 to 100',b'Kan geen score beginnen bij {0}. Je moet een score hebben van 0 tot 100'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212',b'Row {0}: Invalid reference {1}',b'Rij {0}: Invalid referentie {1}'
-b'DocType: Purchase Taxes and Charges Template',b'Purchase Taxes and Charges Template',b'Aankoop en -heffingen Template'
-b'DocType: Timesheet',b'TS-',b'TS-'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61',b'{0} {1}: Either debit or credit amount is required for {2}',b'{0} {1}: Ofwel debet of credit bedrag is vereist voor {2}'
-b'DocType: GL Entry',b'Remarks',b'Opmerkingen'
-b'DocType: Hotel Room Amenity',b'Hotel Room Amenity',b'Hotel Room Amenity'
-b'DocType: Payment Entry',b'Account Paid From',b'Account betaald uit'
-b'DocType: Purchase Order Item Supplied',b'Raw Material Item Code',b'Grondstof Artikelcode'
-b'DocType: Task',b'Parent Task',b'Oudertaak'
-b'DocType: Journal Entry',b'Write Off Based On',b'Afschrijving gebaseerd op'
-b'apps/erpnext/erpnext/utilities/activation.py +65',b'Make Lead',b'maak Lead'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112',b'Print and Stationery',b'Print en stationaire'
-b'DocType: Stock Settings',b'Show Barcode Field',b'Show streepjescodeveld'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809',b'Send Supplier Emails',b'Stuur Leverancier Emails'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96',"b'Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.'","b'Salaris al verwerkt voor de periode tussen {0} en {1}, Laat aanvraagperiode kan niet tussen deze periode.'"
-b'DocType: Chapter Member',b'Leave Reason',b'Verlaat de Rede'
-b'DocType: Guardian Interest',b'Guardian Interest',b'Guardian Interest'
-b'DocType: Volunteer',b'Availability',b'Beschikbaarheid'
-b'apps/erpnext/erpnext/config/accounts.py +319',b'Setup default values for POS Invoices',b'Stel standaardwaarden in voor POS-facturen'
-b'apps/erpnext/erpnext/config/hr.py +182',b'Training',b'Opleiding'
-b'DocType: Project',b'Time to send',b'Tijd om te verzenden'
-b'DocType: Timesheet',b'Employee Detail',b'werknemer Detail'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 Email ID'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 Email ID'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68',"b""Next Date's day and Repeat on Day of Month must be equal""",b'dag Volgende Date&#39;s en Herhalen op dag van de maand moet gelijk zijn'
-b'DocType: Lab Prescription',b'Test Code',b'Testcode'
-b'apps/erpnext/erpnext/config/website.py +11',b'Settings for website homepage',b'Instellingen voor website homepage'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40',b'RFQs are not allowed for {0} due to a scorecard standing of {1}',b'RFQ&#39;s zijn niet toegestaan voor {0} door een scorecard van {1}'
-b'DocType: Job Offer',b'Awaiting Response',b'Wachten op antwoord'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60',b'Above',b'Boven'
-b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1466',b'Total Amount {0}',b'Totaalbedrag {0}'
-b'apps/erpnext/erpnext/controllers/item_variant.py +306',b'Invalid attribute {0} {1}',b'Ongeldige eigenschap {0} {1}'
-b'DocType: Supplier',b'Mention if non-standard payable account',b'Noem als niet-standaard betaalbaar account'
-b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25',"b""Please select the assessment group other than 'All Assessment Groups'""",b'Selecteer de beoordelingsgroep anders dan &#39;Alle beoordelingsgroepen&#39;'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67',b'Row {0}: Cost center is required for an item {1}',b'Rij {0}: Kostencentrum is vereist voor een item {1}'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureDate',b'EcritureDate'
-b'DocType: Training Event Employee',b'Optional',b'facultatief'
-b'DocType: Salary Slip',b'Earning & Deduction',b'Verdienen &amp; Aftrek'
-b'DocType: Agriculture Analysis Criteria',b'Water Analysis',b'Water analyse'
-b'DocType: Chapter',b'Region',b'Regio'
-b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38',b'Optional. This setting will be used to filter in various transactions.',b'Optioneel. Deze instelling wordt gebruikt om te filteren op diverse transacties .'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110',b'Negative Valuation Rate is not allowed',b'Negatieve Waarderingstarief is niet toegestaan'
-b'DocType: Holiday List',b'Weekly Off',b'Wekelijks Vrij'
-b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7',b'Reload Linked Analysis',b'Reload Linked Analysis'
-b'DocType: Fiscal Year',"b'For e.g. 2012, 2012-13'","b'Voor bijvoorbeeld 2012, 2012-13'"
-b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96',b'Provisional Profit / Loss (Credit)',b'Voorlopige winst / verlies (Credit)'
-b'DocType: Sales Invoice',b'Return Against Sales Invoice',b'Terug Tegen Sales Invoice'
-b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32',b'Item 5',b'Punt 5'
-b'DocType: Serial No',b'Creation Time',b'Aanmaaktijd'
-b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62',b'Total Revenue',b'Totale omzet'
-b'DocType: Patient',b'Other Risk Factors',b'Andere risicofactoren'
-b'DocType: Sales Invoice',b'Product Bundle Help',b'Product Bundel Help'
-,b'Monthly Attendance Sheet',b'Maandelijkse Aanwezigheids Sheet'
-b'apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15',b'No record found',b'Geen record gevonden'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140',b'Cost of Scrapped Asset',b'Kosten van Gesloopt Asset'
-b'apps/erpnext/erpnext/controllers/stock_controller.py +236',b'{0} {1}: Cost Center is mandatory for Item {2}',b'{0} {1}: kostenplaats is verplicht voor Artikel {2}'
-b'DocType: Vehicle',b'Policy No',b'beleid Geen'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686',b'Get Items from Product Bundle',b'Krijg Items uit Product Bundle'
-b'DocType: Asset',b'Straight Line',b'Rechte lijn'
-b'DocType: Project User',b'Project User',b'project Gebruiker'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'spleet'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'spleet'
-b'DocType: GL Entry',b'Is Advance',b'Is voorschot'
-b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21',b'Attendance From Date and Attendance To Date is mandatory',b'Aanwezigheid Van Datum en Aanwezigheid Tot Datum zijn verplicht.'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +156',"b""Please enter 'Is Subcontracted' as Yes or No""","b""Vul 'Is Uitbesteed' in als Ja of Nee"""
-b'DocType: Item',b'Default Purchase Unit of Measure',b'Standaard aankoopeenheid van maatregel'
-b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Laatste Communicatie Datum'
-b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Laatste Communicatie Datum'
-b'DocType: Sales Team',b'Contact No.',b'Contact Nr'
-b'DocType: Bank Reconciliation',b'Payment Entries',b'betaling Entries'
-b'DocType: Land Unit',b'Land Unit Details',b'Gegevens over landeenheden'
-b'DocType: Land Unit',b'Latitude',b'Breedtegraad'
-b'DocType: Work Order',b'Scrap Warehouse',b'Scrap Warehouse'
-b'DocType: Work Order',b'Check if material transfer entry is not required',b'Controleer of de invoer van materiaaloverdracht niet vereist is'
-b'DocType: Work Order',b'Check if material transfer entry is not required',b'Controleer of de invoer van materiaaloverdracht niet vereist is'
-b'DocType: Program Enrollment Tool',b'Get Students From',b'Krijgen studenten uit'
-b'apps/erpnext/erpnext/config/learn.py +263',b'Publish Items on Website',b'Artikelen publiceren op de website'
-b'apps/erpnext/erpnext/utilities/activation.py +126',b'Group your students in batches',b'Groep uw leerlingen in batches'
-b'DocType: Authorization Rule',b'Authorization Rule',b'Autorisatie Rule'
-b'DocType: POS Profile',b'Offline POS Section',b'Offline POS-sectie'
-b'DocType: Sales Invoice',b'Terms and Conditions Details',b'Algemene Voorwaarden Details'
-b'apps/erpnext/erpnext/templates/generators/item.html +100',b'Specifications',b'specificaties'
-b'DocType: Sales Taxes and Charges Template',b'Sales Taxes and Charges Template',b'Sales en -heffingen Template'
-b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68',b'Total (Credit)',b'Totaal (Credit)'
-b'DocType: Repayment Schedule',b'Payment Date',b'Betaaldatum'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Nieuw aantal batches'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Nieuw aantal batches'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10',b'Apparel & Accessories',b'Kleding & Toebehoren'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91',b'Could not solve weighted score function. Make sure the formula is valid.',b'Kan de gewogen score functie niet oplossen. Zorg ervoor dat de formule geldig is.'
-b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67',b'Number of Order',b'Aantal Bestel'
-b'DocType: Item Group',b'HTML / Banner that will show on the top of product list.',b'HTML / Banner dat zal laten zien op de bovenkant van het product lijst.'
-b'DocType: Shipping Rule',b'Specify conditions to calculate shipping amount',b'Specificeer de voorwaarden om het verzendbedrag te berekenen'
-b'DocType: Program Enrollment',"b""Institute's Bus""",b'Instituut&#39;s Bus'
-b'DocType: Accounts Settings',b'Role Allowed to Set Frozen Accounts & Edit Frozen Entries',b'Rol toegestaan om Stel Frozen Accounts & bewerken Frozen Entries'
-b'DocType: Supplier Scorecard Scoring Variable',b'Path',b'Pad'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28',b'Cannot convert Cost Center to ledger as it has child nodes',b'Kan kostenplaats niet omzetten naar grootboek vanwege onderliggende nodes'
-b'DocType: Production Plan',b'Total Planned Qty',b'Totaal aantal geplande'
-b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68',b'Opening Value',b'opening Value'
-b'DocType: Salary Detail',b'Formula',b'Formule'
-b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47',b'Serial #',b'Serial #'
-b'DocType: Lab Test Template',b'Lab Test Template',b'Lab Test Template'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +181',b'Sales Account',b'Verkoopaccount'
-b'DocType: Purchase Invoice Item',b'Total Weight',b'Totale gewicht'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94',b'Commission on Sales',b'Commissie op de verkoop'
-b'DocType: Job Offer Term',b'Value / Description',b'Waarde / Beschrijving'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +630',"b'Row #{0}: Asset {1} cannot be submitted, it is already {2}'","b'Rij # {0}: Asset {1} kan niet worden ingediend, is het al {2}'"
-b'DocType: Tax Rule',b'Billing Country',b'Land'
-b'DocType: Purchase Order Item',b'Expected Delivery Date',b'Verwachte leverdatum'
-b'DocType: Restaurant Order Entry',b'Restaurant Order Entry',b'Restaurantbestelling'
-b'apps/erpnext/erpnext/accounts/general_ledger.py +134',b'Debit and Credit not equal for {0} #{1}. Difference is {2}.',b'Debet en Credit niet gelijk voor {0} # {1}. Verschil {2}.'
-b'DocType: Asset Maintenance Task',b'Assign To Name',b'Toewijzen aan naam'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98',b'Entertainment Expenses',b'Representatiekosten'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98',b'Make Material Request',b'Maak Material Request'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20',b'Open Item {0}',b'Open Item {0}'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222',b'Sales Invoice {0} must be cancelled before cancelling this Sales Order',b'Verkoopfactuur {0} moet worden geannuleerd voordat deze verkooporder kan worden geannuleerd.'
-b'DocType: Consultation',b'Age',b'Leeftijd'
-b'DocType: Sales Invoice Timesheet',b'Billing Amount',b'Factuurbedrag'
-b'DocType: Cash Flow Mapping',b'Select Maximum Of 1',b'Selecteer maximaal 1'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84',b'Invalid quantity specified for item {0}. Quantity should be greater than 0.',b'Ongeldig aantal opgegeven voor artikel {0} . Hoeveelheid moet groter zijn dan 0 .'
-b'DocType: Company',b'Default Employee Advance Account',b'Standaard Employee Advance Account'
-b'apps/erpnext/erpnext/config/hr.py +60',b'Applications for leave.',b'Aanvragen voor verlof.'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +164',b'Account with existing transaction can not be deleted',b'Rekening met bestaande transactie kan niet worden verwijderd'
-b'DocType: Vehicle',b'Last Carbon Check',b'Laatste Carbon controleren'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102',b'Legal Expenses',b'Juridische Kosten'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140',b'Please select quantity on row ',b'Selecteer alstublieft de hoeveelheid op rij'
-b'apps/erpnext/erpnext/config/accounts.py +277',b'Make Opening Sales and Purchase Invoices',b'Open verkoop- en inkoopfacturen'
-b'DocType: Purchase Invoice',b'Posting Time',b'Plaatsing Time'
-b'DocType: Timesheet',b'% Amount Billed',b'% Gefactureerd Bedrag'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118',b'Telephone Expenses',b'Telefoonkosten'
-b'DocType: Sales Partner',b'Logo',b'Logo'
-b'DocType: Naming Series',b'Check this if you want to force the user to select a series before saving. There will be no default if you check this.',b'Controleer dit als u wilt dwingen de gebruiker om een reeks voor het opslaan te selecteren. Er zal geen standaard zijn als je dit controleren.'
-b'apps/erpnext/erpnext/stock/get_item_details.py +131',b'No Item with Serial No {0}',b'Geen Artikel met Serienummer {0}'
-b'DocType: Email Digest',b'Open Notifications',b'Open Meldingen'
-b'DocType: Payment Entry',b'Difference Amount (Company Currency)',b'Verschil Bedrag (Company Munt)'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79',b'Direct Expenses',b'Directe Kosten'
-b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60',b'New Customer Revenue',b'Nieuwe klant Revenue'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119',b'Travel Expenses',b'Reiskosten'
-b'DocType: Maintenance Visit',b'Breakdown',b'Storing'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50',b'Add custom field Subscription in the doctype {0}',b'Voeg een aangepast veld toe Abonnement in het doctype {0}'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +820',b'Account: {0} with currency: {1} can not be selected',b'Account: {0} met valuta: {1} kan niet worden geselecteerd'
-b'DocType: Purchase Receipt Item',b'Sample Quantity',b'Monsterhoeveelheid'
-b'DocType: Manufacturing Settings',"b'Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.'","b'Update BOM kosten automatisch via Scheduler, op basis van de laatste waarderingssnelheid / prijslijst koers / laatste aankoophoeveelheid grondstoffen.'"
-b'DocType: Bank Reconciliation Detail',b'Cheque Date',b'Cheque Datum'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +50',b'Account {0}: Parent account {1} does not belong to company: {2}',b'Rekening {0}: Bovenliggende rekening {1} hoort niet bij bedrijf: {2}'
-b'apps/erpnext/erpnext/setup/doctype/company/company.js +106',b'Successfully deleted all transactions related to this company!',b'Succesvol verwijderd alle transacties met betrekking tot dit bedrijf!'
-b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27',b'As on Date',b'Op Date'
-b'DocType: Appraisal',b'HR',b'HR'
-b'DocType: Program Enrollment',b'Enrollment Date',b'inschrijfdatum'
-b'DocType: Healthcare Settings',b'Out Patient SMS Alerts',b'Out Patient SMS Alerts'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100',b'Probation',b'proeftijd'
-b'apps/erpnext/erpnext/config/hr.py +115',b'Salary Components',b'salaris Components'
-b'DocType: Program Enrollment Tool',b'New Academic Year',b'New Academisch Jaar'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811',b'Return / Credit Note',b'Return / Credit Note'
-b'DocType: Stock Settings',b'Auto insert Price List rate if missing',b'Auto insert Prijslijst tarief als vermist'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +117',b'Total Paid Amount',b'Totale betaalde bedrag'
-b'DocType: GST Settings',b'B2C Limit',b'B2C-limiet'
-b'DocType: Work Order Item',b'Transferred Qty',b'Verplaatst Aantal'
-b'apps/erpnext/erpnext/config/learn.py +11',b'Navigating',b'Navigeren'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188',b'Planning',b'planning'
-b'DocType: Share Balance',b'Issued',b'Uitgegeven'
-b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14',b'Student Activity',b'Studentactiviteit'
-b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80',b'Supplier Id',b'Leverancier Id'
-b'DocType: Payment Request',b'Payment Gateway Details',b'Payment Gateway Details'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276',b'Quantity should be greater than 0',b'Hoeveelheid moet groter zijn dan 0'
-b'DocType: Journal Entry',b'Cash Entry',b'Cash Entry'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17',"b""Child nodes can be only created under 'Group' type nodes""",b'Child nodes kunnen alleen worden gemaakt op grond van het type nodes &#39;Groep&#39;'
-b'DocType: Leave Application',b'Half Day Date',b'Halve dag datum'
-b'DocType: Academic Year',b'Academic Year Name',b'Academisch jaar naam'
-b'DocType: Sales Partner',b'Contact Desc',b'Contact Omschr'
-b'apps/erpnext/erpnext/config/hr.py +65',"b'Type of leaves like casual, sick etc.'","b'Type verloven zoals, buitengewoon, ziekte, etc.'"
-b'DocType: Email Digest',b'Send regular summary reports via Email.',b'Stuur regelmatige samenvattende rapporten via e-mail.'
-b'DocType: Payment Entry',b'PE-',b'PE'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282',b'Please set default account in Expense Claim Type {0}',b'Stel standaard account aan Expense conclusie Type {0}'
-b'DocType: Assessment Result',b'Student Name',b'Studenten naam'
-b'DocType: Brand',b'Item Manager',b'Item Manager'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143',b'Payroll Payable',b'payroll Payable'
-b'DocType: Buying Settings',b'Default Supplier Type',b'Standaard Leverancier Type'
-b'DocType: Plant Analysis',b'Collection Datetime',b'Verzameling Datetime'
-b'DocType: Work Order',b'Total Operating Cost',b'Totale exploitatiekosten'
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171',b'Note: Item {0} entered multiple times',b'Opmerking : Artikel {0} meerdere keren ingevoerd'
-b'apps/erpnext/erpnext/config/selling.py +41',b'All Contacts.',b'Alle contactpersonen.'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Company Abbreviation',b'Bedrijf afkorting'
-b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47',b'User {0} does not exist',b'Gebruiker {0} bestaat niet'
-b'DocType: Payment Term',b'Day(s) after invoice date',b'Dag (en) na factuurdatum'
-b'DocType: Payment Schedule',b'Payment Schedule',b'Betalingsschema'
-b'DocType: Subscription',b'SUB-',b'SUB-'
-b'DocType: Item Attribute Value',b'Abbreviation',b'Afkorting'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195',b'Payment Entry already exists',b'Betaling Entry bestaat al'
-b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36',b'Not authroized since {0} exceeds limits',b'Niet toegestaan aangezien {0} grenzen overschrijdt'
-b'apps/erpnext/erpnext/config/hr.py +110',b'Salary template master.',b'Salaris sjabloon stam .'
-b'apps/erpnext/erpnext/healthcare/setup.py +241',b'Pathology',b'Pathologie'
-b'DocType: Restaurant Order Entry',b'Restaurant Table',b'Restaurant tafel'
-b'DocType: Hotel Room',b'Hotel Manager',b'Hotel Manager'
-b'DocType: Leave Type',b'Max Days Leave Allowed',b'Max Dagen Verlof toegestaan'
-b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63',b'Set Tax Rule for shopping cart',b'Stel Tax Regel voor winkelmandje'
-b'DocType: Purchase Invoice',b'Taxes and Charges Added',b'Belastingen en Toeslagen toegevoegd'
-,b'Sales Funnel',b'Verkoop Trechter'
-b'apps/erpnext/erpnext/setup/doctype/company/company.py +49',b'Abbreviation is mandatory',b'Afkorting is verplicht'
-b'DocType: Project',b'Task Progress',b'Task Progress'
-b'apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7',b'Cart',b'Kar'
-,b'Qty to Transfer',b'Aantal te verplaatsen'
-b'apps/erpnext/erpnext/config/selling.py +13',b'Quotes to Leads or Customers.',b'Offertes naar leads of klanten.'
-b'DocType: Stock Settings',b'Role Allowed to edit frozen stock',b'Rol toegestaan om bevroren voorraden bewerken'
-,b'Territory Target Variance Item Group-Wise',b'Regio Doel Variance Artikel Groepsgewijs'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143',b'All Customer Groups',b'Alle Doelgroepen'
-b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114',b'Accumulated Monthly',b'Maandelijks geaccumuleerd'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +781',b'{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.',b'{0} is verplicht. Misschien is Valuta Koers record niet gemaakt voor {1} naar {2}.'
-b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44',b'Tax Template is mandatory.',b'Belasting Template is verplicht.'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +44',b'Account {0}: Parent account {1} does not exist',b'Rekening {0}: Bovenliggende rekening {1} bestaat niet'
-b'DocType: Purchase Invoice Item',b'Price List Rate (Company Currency)',b'Prijslijst Tarief (Bedrijfsvaluta)'
-b'DocType: Products Settings',b'Products Settings',b'producten Instellingen'
-,b'Item Price Stock',b'Artikel Prijs Voorraad'
-b'DocType: Lab Prescription',b'Test Created',b'Test gemaakt'
-b'DocType: Healthcare Settings',b'Custom Signature in Print',b'Aangepaste handtekening in afdrukken'
-b'DocType: Account',b'Temporary',b'Tijdelijk'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +107',b'Customer LPO No.',b'LPO-nummer klant'
-b'DocType: Program',b'Courses',b'cursussen'
-b'DocType: Monthly Distribution Percentage',b'Percentage Allocation',b'Percentage Toewijzing'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128',b'Secretary',b'secretaresse'
-b'DocType: Global Defaults',"b""If disable, 'In Words' field will not be visible in any transaction""","b'Als uitschakelen, &#39;In de woorden&#39; veld niet zichtbaar in elke transactie'"
-b'DocType: Serial No',b'Distinct unit of an Item',b'Aanwijsbare eenheid van een Artikel'
-b'DocType: Supplier Scorecard Criteria',b'Criteria Name',b'Criteria Naam'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295',b'Please set Company',b'Stel alsjeblieft bedrijf in'
-b'DocType: Pricing Rule',b'Buying',b'Inkoop'
-b'apps/erpnext/erpnext/config/agriculture.py +24',b'Diseases & Fertilizers',b'Ziekten &amp; Meststoffen'
-b'DocType: HR Settings',b'Employee Records to be created by',b'Werknemer Records worden gecre\xc3\xaberd door'
-b'DocType: Patient',b'AB Negative',b'AB Negatief'
-b'DocType: Sample Collection',b'SMPL-',b'SMPL-'
-b'DocType: POS Profile',b'Apply Discount On',b'Breng Korting op'
-b'DocType: Member',b'Membership Type',b'soort lidmaatschap'
-,b'Reqd By Date',b'Benodigd op datum'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140',b'Creditors',b'Crediteuren'
-b'DocType: Assessment Plan',b'Assessment Name',b'assessment Naam'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94',b'Show PDC in Print',b'PDC weergeven in Afdrukken'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97',b'Row # {0}: Serial No is mandatory',b'Rij # {0}: Serienummer is verplicht'
-b'DocType: Purchase Taxes and Charges',b'Item Wise Tax Detail',b'Artikelgebaseerde BTW Details'
-b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13',b'Job Offer',b'Vacature'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Institute Abbreviation',b'Instituut Afkorting'
-,b'Item-wise Price List Rate',b'Artikelgebaseerde Prijslijst Tarief'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082',b'Supplier Quotation',b'Leverancier Offerte'
-b'DocType: Quotation',b'In Words will be visible once you save the Quotation.',b'In Woorden zijn zichtbaar zodra u de Offerte opslaat.'
-b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Hoeveelheid ({0}) kan geen fractie in rij {1} zijn'
-b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Hoeveelheid ({0}) kan geen fractie in rij {1} zijn'
-b'DocType: Consultation',b'C-',b'C-'
-b'DocType: Attendance',b'ATT-',b'ATT-'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +492',b'Barcode {0} already used in Item {1}',b'Barcode {0} is al gebruikt in het Item {1}'
-b'apps/erpnext/erpnext/config/selling.py +86',b'Rules for adding shipping costs.',b'Regels voor het toevoegen van verzendkosten.'
-b'DocType: Hotel Room',b'Extra Bed Capacity',b'Extra bedcapaciteit'
-b'DocType: Item',b'Opening Stock',b'Opening Stock'
-b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20',b'Customer is required',b'Klant is verplicht'
-b'DocType: Lab Test',b'Result Date',b'Resultaatdatum'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77',b'PDC/LC Date',b'PDC / LC-datum'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20',b'{0} is mandatory for Return',b'{0} is verplicht voor Return'
-b'DocType: Purchase Order',b'To Receive',b'Ontvangen'
-b'apps/erpnext/erpnext/utilities/user_progress.py +252',b'user@example.com',b'user@example.com'
-b'DocType: Asset',b'Asset Owner',b'Activa-eigenaar'
-b'DocType: Employee',b'Personal Email',b'Persoonlijke e-mail'
-b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57',b'Total Variance',b'Total Variance'
-b'DocType: Accounts Settings',"b'If enabled, the system will post accounting entries for inventory automatically.'","b'Indien aangevinkt, zal het systeem voorraadboekingen automatisch plaatsen.'"
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15',b'Brokerage',b'makelaardij'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195',b'Attendance for employee {0} is already marked for this day',b'Attendance voor personeelsbeloningen {0} is al gemarkeerd voor deze dag'
-b'DocType: Work Order Operation',"b""in Minutes\nUpdated via 'Time Log'""","b""in Minuten \n Bijgewerkt via 'Time Log'"""
-b'DocType: Customer',b'From Lead',b'Van Lead'
-b'apps/erpnext/erpnext/config/manufacturing.py +13',b'Orders released for production.',b'Orders vrijgegeven voor productie.'
-b'apps/erpnext/erpnext/public/js/account_tree_grid.js +65',b'Select Fiscal Year...',b'Selecteer boekjaar ...'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567',b'POS Profile required to make POS Entry',b'POS profiel nodig om POS Entry maken'
-b'DocType: Program Enrollment Tool',b'Enroll Students',b'inschrijven Studenten'
-b'DocType: Lab Test',b'Approved Date',b'Goedgekeurde Datum'
-b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21',b'Standard Selling',b'Standaard Verkoop'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165',b'Atleast one warehouse is mandatory',b'Tenminste een magazijn is verplicht'
-b'DocType: Serial No',b'Out of Warranty',b'Uit de garantie'
-b'DocType: BOM Update Tool',b'Replace',b'Vervang'
-b'apps/erpnext/erpnext/templates/includes/product_list.js +42',b'No products found.',b'Geen producten gevonden.'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360',b'{0} against Sales Invoice {1}',b'{0} tegen verkoopfactuur {1}'
-b'DocType: Antibiotic',b'Laboratory User',b'Laboratoriumgebruiker'
-b'DocType: Sales Invoice',b'SINV-',b'SINV-'
-b'DocType: Request for Quotation Item',b'Project Name',b'Naam van het project'
-b'DocType: Customer',b'Mention if non-standard receivable account',b'Vermelden of niet-standaard te ontvangen rekening'
-b'DocType: Journal Entry Account',b'If Income or Expense',b'Indien Inkomsten (baten) of Uitgaven (lasten)'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288',b'Select interest income account in employee loan {0}',b'Selecteer rentebatenrekening in personeelslening {0}'
-b'DocType: Work Order',b'Required Items',b'Vereiste items'
-b'DocType: Stock Ledger Entry',b'Stock Value Difference',b'Voorraad Waarde Verschil'
-b'apps/erpnext/erpnext/config/learn.py +229',b'Human Resource',b'Human Resource'
-b'DocType: Payment Reconciliation Payment',b'Payment Reconciliation Payment',b'Afletteren Betaling'
-b'DocType: Disease',b'Treatment Task',b'Behandelingstaak'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38',b'Tax Assets',b'Belastingvorderingen'
-b'DocType: BOM Item',b'BOM No',b'Stuklijst nr.'
-b'DocType: Instructor',b'INS/',b'INS /'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160',b'Journal Entry {0} does not have account {1} or already matched against other voucher',b'Journal Entry {0} heeft geen rekening {1} of al vergeleken met andere voucher'
-b'DocType: Item',b'Moving Average',b'Moving Average'
-b'DocType: BOM Update Tool',b'The BOM which will be replaced',b'De Stuklijst die zal worden vervangen'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46',b'Electronic Equipments',b'elektronische apparatuur'
-b'DocType: Asset',b'Maintenance Required',b'Onderhoud vereist'
-b'DocType: Account',b'Debit',b'Debet'
-b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49',b'Leaves must be allocated in multiples of 0.5',"b'Verloven moeten in veelvouden van 0,5 worden toegewezen'"
-b'DocType: Work Order',b'Operation Cost',b'Operatie Cost'
-b'apps/erpnext/erpnext/config/hr.py +29',b'Upload attendance from a .csv file',b'Upload aanwezigheid uit een .csv-bestand'
-b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45',b'Outstanding Amt',b'Openstaande Amt'
-b'DocType: Sales Person',b'Set targets Item Group-wise for this Sales Person.',b'Set richt Item Group-wise voor deze verkoper.'
-b'DocType: Stock Settings',b'Freeze Stocks Older Than [Days]',b'Bevries Voorraden ouder dan [dagen]'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +600',b'Row #{0}: Asset is mandatory for fixed asset purchase/sale',b'Rij # {0}: Asset is verplicht voor vaste activa aankoop / verkoop'
-b'DocType: Asset Maintenance Team',b'Maintenance Team Name',b'Onderhoudsteam naam'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42',"b'If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.'","b'Als twee of meer Pricing Regels zijn gevonden op basis van de bovenstaande voorwaarden, wordt prioriteit toegepast. Prioriteit is een getal tussen 0 en 20, terwijl standaardwaarde nul (blanco). Hoger aantal betekent dat het voorrang krijgen als er meerdere prijzen Regels met dezelfde voorwaarden.'"
-b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197',"b""Customer is mandatory if 'Opportunity From' is selected as Customer""",b'Klant is verplicht als &#39;Opportunity vanaf&#39; is geselecteerd als klant'
-b'apps/erpnext/erpnext/controllers/trends.py +36',b'Fiscal Year: {0} does not exists',b'Boekjaar: {0} bestaat niet'
-b'DocType: Currency Exchange',b'To Currency',b'Naar Valuta'
-b'DocType: Leave Block List',b'Allow the following users to approve Leave Applications for block days.',b'Laat de volgende gebruikers te keuren Verlof Aanvragen voor blok dagen.'
-b'apps/erpnext/erpnext/config/hr.py +137',b'Types of Expense Claim.',b'Typen Onkostendeclaraties.'
-b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'Verkoopprijs voor item {0} is lager dan de {1}. Verkoopprijs moet ten minste {2} zijn'
-b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'Verkoopprijs voor item {0} is lager dan de {1}. Verkoopprijs moet ten minste {2} zijn'
-b'DocType: Item',b'Taxes',b'Belastingen'
-b'DocType: Purchase Invoice',b'capital goods',b'kapitaalgoederen'
-b'DocType: Purchase Invoice Item',b'Weight Per Unit',b'Gewicht per eenheid'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344',b'Paid and Not Delivered',b'Betaald en niet geleverd'
-b'DocType: Project',b'Default Cost Center',b'Standaard Kostenplaats'
-b'DocType: Bank Guarantee',b'End Date',b'Einddatum'
-b'apps/erpnext/erpnext/config/stock.py +7',b'Stock Transactions',b'Stock Transactions'
-b'DocType: Budget',b'Budget Accounts',b'budget Accounts'
-b'DocType: Employee',b'Internal Work History',b'Interne Werk Geschiedenis'
-b'DocType: Depreciation Schedule',b'Accumulated Depreciation Amount',b'Cumulatieve afschrijvingen Bedrag'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42',b'Private Equity',b'Private Equity'
-b'DocType: Supplier Scorecard Variable',b'Supplier Scorecard Variable',b'Leverancier Scorecard Variable'
-b'DocType: Employee Loan',b'Fully Disbursed',b'volledig uitbetaald'
-b'DocType: Employee Advance',b'Due Advance Amount',b'Voorschotbedrag'
-b'DocType: Maintenance Visit',b'Customer Feedback',b'Klantenfeedback'
-b'DocType: Account',b'Expense',b'Kosten'
-b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54',b'Score cannot be greater than Maximum Score',b'Score kan niet groter zijn dan de maximale score te zijn'
-b'apps/erpnext/erpnext/utilities/user_progress.py +129',b'Customers and Suppliers',b'Klanten en leveranciers'
-b'DocType: Item Attribute',b'From Range',b'Van Range'
-b'DocType: BOM',b'Set rate of sub-assembly item based on BOM',b'Set percentage van sub-assembly item op basis van BOM'
-b'DocType: Hotel Room Reservation',b'Invoiced',b'gefactureerd'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98',b'Syntax error in formula or condition: {0}',b'Syntaxisfout in formule of aandoening: {0}'
-b'DocType: Daily Work Summary Settings Company',b'Daily Work Summary Settings Company',b'Dagelijks Werk Samenvatting Instellingen Company'
-b'apps/erpnext/erpnext/stock/utils.py +125',b'Item {0} ignored since it is not a stock item',b'Artikel {0} genegeerd omdat het niet een voorraadartikel is'
-b'DocType: Appraisal',b'APRSL',b'APRSL'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23',"b'To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.'","b'Om de prijsbepalingsregel in een specifieke transactie niet toe te passen, moeten alle toepasbare prijsbepalingsregels worden uitgeschakeld.'"
-b'DocType: Payment Term',b'Day(s) after the end of the invoice month',b'Dag (en) na het einde van de factuurmaand'
-b'DocType: Assessment Group',b'Parent Assessment Group',b'Parent Assessment Group'
-b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27',b'Jobs',b'Jobs'
-,b'Sales Order Trends',b'Verkooporder Trends'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51',"b""The 'From Package No.' field must neither be empty nor it's value less than 1.""",b'Het &#39;Van pakketnummer&#39; veld mag niet leeg zijn of de waarde is kleiner dan 1.'
-b'DocType: Employee',b'Held On',b'Heeft plaatsgevonden op'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36',b'Production Item',b'Productie Item'
-,b'Employee Information',b'Werknemer Informatie'
-b'DocType: Stock Entry Detail',b'Additional Cost',b'Bijkomende kosten'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48',"b'Can not filter based on Voucher No, if grouped by Voucher'","b'Kan niet filteren op basis van vouchernummer, indien gegroepeerd per voucher'"
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918',b'Make Supplier Quotation',b'Maak Leverancier Offerte'
-b'DocType: Quality Inspection',b'Incoming',b'Inkomend'
-b'apps/erpnext/erpnext/setup/doctype/company/company.js +70',b'Default tax templates for sales and purchase are created.',b'Standaardbelastingsjablonen voor verkopen en kopen worden gemaakt.'
-b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57',b'Assessment Result record {0} already exists.',b'Beoordeling Resultaat record {0} bestaat al.'
-b'DocType: BOM',b'Materials Required (Exploded)',b'Benodigde materialen (uitgeklapt)'
-b'apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60',"b""Please set Company filter blank if Group By is 'Company'""",b'Stel alsjeblieft Bedrijfsfilter leeg als Group By is &#39;Company&#39;'
-b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66',b'Posting Date cannot be future date',b'Posting datum kan niet de toekomst datum'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102',b'Row # {0}: Serial No {1} does not match with {2} {3}',b'Rij # {0}: Serienummer {1} komt niet overeen met {2} {3}'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'for generating the recurring',b'voor het genereren van de terugkerende'
-b'DocType: Stock Entry',b'Target Warehouse Address',b'Target Warehouse Address'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86',b'Casual Leave',b'Casual Leave'
-b'DocType: Agriculture Task',b'End Day',b'Einde dag'
-b'DocType: Batch',b'Batch ID',b'Partij ID'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380',b'Note: {0}',b'Opmerking : {0}'
-,b'Delivery Note Trends',b'Vrachtbrief Trends'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112',"b""This Week's Summary""",b'Samenvatting van deze week'
-b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22',b'In Stock Qty',b'Op voorraad Aantal'
-b'DocType: Delivery Trip',b'Calculate Estimated Arrival Times',b'Bereken geschatte aankomsttijden'
-b'apps/erpnext/erpnext/accounts/general_ledger.py +113',b'Account: {0} can only be updated via Stock Transactions',b'Account: {0} kan alleen worden bijgewerkt via Voorraad Transacties'
-b'DocType: Student Group Creation Tool',b'Get Courses',b'krijg Cursussen'
-b'DocType: GL Entry',b'Party',b'Partij'
-b'DocType: Healthcare Settings',b'Patient Name',b'Patient naam'
-b'DocType: Variant Field',b'Variant Field',b'Variantveld'
-b'DocType: Sales Order',b'Delivery Date',b'Leveringsdatum'
-b'DocType: Opportunity',b'Opportunity Date',b'Datum opportuniteit'
-b'DocType: Employee',b'Health Insurance Provider',b'Zorgverzekeraar'
-b'DocType: Purchase Receipt',b'Return Against Purchase Receipt',b'Terug Tegen Aankoop Receipt'
-b'DocType: Water Analysis',b'Person Responsible',b'Verantwoordelijke persoon'
-b'DocType: Request for Quotation Item',b'Request for Quotation Item',b'Offerte Item'
-b'DocType: Purchase Order',b'To Bill',b'Bill'
-b'DocType: Material Request',b'% Ordered',b'% Besteld'
-b'DocType: Education Settings',"b'For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.'",b'Voor cursusgerichte studentengroep wordt de cursus voor elke student gevalideerd van de ingeschreven cursussen in de inschrijving van het programma.'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103',b'Piecework',b'stukwerk'
-b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70',b'Avg. Buying Rate',b'Gem. Buying Rate'
-b'DocType: Share Balance',b'From No',b'Van Nee'
-b'DocType: Task',b'Actual Time (in Hours)',b'Werkelijke tijd (in uren)'
-b'DocType: Employee',b'History In Company',b'Geschiedenis In Bedrijf'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270',b'New Message from {sender}',b'Nieuw bericht van {sender}'
-b'DocType: Customer',b'Customer Primary Address',b'Primair adres van klant'
-b'apps/erpnext/erpnext/config/learn.py +107',b'Newsletters',b'Nieuwsbrieven'
-b'DocType: Drug Prescription',b'Description/Strength',b'Beschrijving / Strength'
-b'DocType: Share Balance',b'Is Company',b'Is Bedrijf'
-b'DocType: Stock Ledger Entry',b'Stock Ledger Entry',b'Voorraad Dagboek post'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83',b'Same item has been entered multiple times',b'Hetzelfde artikel is meerdere keren ingevoerd'
-b'DocType: Department',b'Leave Block List',b'Verlof bloklijst'
-b'DocType: Purchase Invoice',b'Tax ID',b'BTW-nummer'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192',b'Item {0} is not setup for Serial Nos. Column must be blank',b'Artikel {0} is niet ingesteld voor serienummers. Kolom moet leeg zijn'
-b'DocType: Accounts Settings',b'Accounts Settings',b'Rekeningen Instellingen'
-b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11',b'Approve',b'Goedkeuren'
-b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69',"b'Malformatted address for {0}, please fix to continue.'","b'Malformatted adres voor {0}, gelieve te herstellen om verder te gaan.'"
-b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28',"b'Number of new Account, it will be included in the account name as a prefix'","b'Nummer van nieuwe account, deze zal als een prefix in de accountnaam worden opgenomen'"
-b'DocType: Maintenance Team Member',b'Team Member',b'Teamlid'
-b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151',b'No Result to submit',b'Geen resultaat om in te dienen'
-b'DocType: Customer',b'Sales Partner and Commission',b'Sales Partner en de Commissie'
-b'DocType: Employee Loan',b'Rate of Interest (%) / Year',b'Rate of Interest (%) / Jaar'
-,b'Project Quantity',b'project Hoeveelheid'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79',"b""Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'""","b'Totaal {0} voor alle items nul is, kan je zou moeten veranderen &#39;Verdeel heffingen op basis van&#39;'"
-b'DocType: Opportunity',b'To Discuss',b'Te bespreken'
-b'apps/erpnext/erpnext/stock/stock_ledger.py +377',b'{0} units of {1} needed in {2} to complete this transaction.',b'{0} eenheden van {1} die nodig zijn in {2} om deze transactie te voltooien.'
-b'DocType: Loan Type',b'Rate of Interest (%) Yearly',b'Rate of Interest (%) Jaarlijkse'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71',b'Temporary Accounts',b'Tijdelijke Accounts'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207',b'Black',b'Zwart'
-b'DocType: BOM Explosion Item',b'BOM Explosion Item',b'Stuklijst Uitklap Artikel'
-b'DocType: Shareholder',b'Contact List',b'Contactlijst'
-b'DocType: Account',b'Auditor',b'Revisor'
-b'DocType: Project',b'Frequency To Collect Progress',b'Frequentie om vorderingen te verzamelen'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132',b'{0} items produced',b'{0} items geproduceerd'
-b'apps/erpnext/erpnext/utilities/user_progress.py +58',b'Learn More',b'Kom meer te weten'
-b'DocType: Cheque Print Template',b'Distance from top edge',b'Afstand van bovenrand'
-b'apps/erpnext/erpnext/stock/get_item_details.py +367',b'Price List {0} is disabled or does not exist',b'Prijslijst {0} is uitgeschakeld of bestaat niet'
-b'DocType: Purchase Invoice',b'Return',b'Terugkeer'
-b'DocType: Pricing Rule',b'Disable',b'Uitschakelen'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180',b'Mode of payment is required to make a payment',b'Wijze van betaling is vereist om een betaling te doen'
-b'DocType: Project Task',b'Pending Review',b'In afwachting van Beoordeling'
-b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14',"b'Edit in full page for more options like assets, serial nos, batches etc.'","b'Bewerken op de volledige pagina voor meer opties zoals activa, serienummers, batches etc.'"
-b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10',b'Appointments and Consultations',b'Afspraken en overleg'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41',b'{0} - {1} is not enrolled in the Batch {2}',b'{0} - {1} is niet ingeschreven in de partij {2}'
-b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113',"b'Asset {0} cannot be scrapped, as it is already {1}'","b'Asset {0} kan niet worden gesloopt, want het is al {1}'"
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77',b'Cheques Required',b'Controles vereist'
-b'DocType: Task',b'Total Expense Claim (via Expense Claim)',b'Total Expense Claim (via Expense Claim)'
-b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177',b'Mark Absent',b'Mark Afwezig'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40',b'Failed to setup company',b'Kan bedrijf niet instellen'
-b'DocType: Asset Repair',b'Asset Repair',b'Asset reparatie'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143',b'Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}',b'Rij {0}: Munt van de BOM # {1} moet gelijk zijn aan de geselecteerde valuta zijn {2}'
-b'DocType: Journal Entry Account',b'Exchange Rate',b'Wisselkoers'
-b'DocType: Patient',b'Additional information regarding the patient',b'Aanvullende informatie over de pati\xc3\xabnt'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585',b'Sales Order {0} is not submitted',b'Verkooporder {0} is niet ingediend'
-b'DocType: Homepage',b'Tag Line',b'tag Line'
-b'DocType: Fee Component',b'Fee Component',b'fee Component'
-b'apps/erpnext/erpnext/config/hr.py +204',b'Fleet Management',b'Vloot beheer'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080',b'Add items from',b'Items uit voegen'
-b'apps/erpnext/erpnext/config/agriculture.py +7',b'Crops & Lands',b'Gewassen en land'
-b'DocType: Cheque Print Template',b'Regular',b'regelmatig'
-b'DocType: Fertilizer',b'Density (if liquid)',b'Dichtheid (indien vloeibaar)'
-b'apps/erpnext/erpnext/education/doctype/course/course.py +20',b'Total Weightage of all Assessment Criteria must be 100%',b'Totaal weightage van alle beoordelingscriteria moet 100% zijn'
-b'DocType: Purchase Order Item',b'Last Purchase Rate',b'Laatste inkooptarief'
-b'DocType: Account',b'Asset',b'aanwinst'
-b'DocType: Project Task',b'Task ID',b'Task ID'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84',b'Stock cannot exist for Item {0} since has variants',b'Voorraad kan niet bestaan voor Artikel {0} omdat het varianten heeft.'
-b'DocType: Lab Test',b'Mobile',b'mobiel'
-,b'Sales Person-wise Transaction Summary',b'Verkopergebaseerd Transactie Overzicht'
-b'DocType: Training Event',b'Contact Number',b'Contact nummer'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73',b'Warehouse {0} does not exist',b'Magazijn {0} bestaat niet'
-b'DocType: Monthly Distribution',b'Monthly Distribution Percentages',b'Maandelijkse Verdeling Percentages'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +110',b'The selected item cannot have Batch',b'Het geselecteerde item kan niet Batch hebben'
-b'DocType: Delivery Note',b'% of materials delivered against this Delivery Note',b'% van de geleverde materialen voor deze Vrachtbrief'
-b'DocType: Asset Maintenance Log',b'Has Certificate',b'Heeft certificaat'
-b'DocType: Project',b'Customer Details',b'Klant Details'
-b'DocType: Asset',b'Check if Asset requires Preventive Maintenance or Calibration',b'Controleer of Activum preventief onderhoud of kalibratie vereist'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +87',b'Company Abbreviation cannot have more than 5 characters',b'Bedrijfsbegeleiding mag niet meer dan 5 tekens bevatten'
-b'DocType: Employee',b'Reports to',b'Rapporteert aan'
-,b'Unpaid Expense Claim',b'Onbetaalde Onkostenvergoeding'
-b'DocType: Payment Entry',b'Paid Amount',b'Betaald Bedrag'
-b'apps/erpnext/erpnext/utilities/user_progress.py +158',b'Explore Sales Cycle',b'Verken de verkoopcyclus'
-b'DocType: Assessment Plan',b'Supervisor',b'opzichter'
-b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869',b'Retention Stock Entry',b'Retention Stock Entry'
-,b'Available Stock for Packing Items',b'Beschikbaar voor Verpakking Items'
-b'DocType: Item Variant',b'Item Variant',b'Artikel Variant'
-,b'Work Order Stock Report',b'Werkorder Voorraadverslag'
-b'DocType: Assessment Result Tool',b'Assessment Result Tool',b'Assessment Result Tool'
-b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24',b'As Supervisor',b'Als supervisor'
-b'DocType: BOM Scrap Item',b'BOM Scrap Item',b'BOM Scrap Item'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +895',b'Submitted orders can not be deleted',b'Ingezonden bestellingen kunnen niet worden verwijderd'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +114',"b""Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'""","b""Accountbalans reeds in Debet, 'Balans moet zijn' mag niet als 'Credit' worden ingesteld"""
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118',b'Quality Management',b'Quality Management'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +41',b'Item {0} has been disabled',b'Item {0} is uitgeschakeld'
-b'DocType: Project',b'Total Billable Amount (via Timesheets)',b'Totaal factureerbare hoeveelheid (via urenstaten)'
-b'DocType: Agriculture Task',b'Previous Business Day',b'Vorige werkdag'
-b'DocType: Employee Loan',b'Repay Fixed Amount per Period',b'Terugbetalen vast bedrag per periode'
-b'DocType: Employee',b'Health Insurance No',b'Ziektekostenverzekering Nee'
-b'apps/erpnext/erpnext/buying/utils.py +47',b'Please enter quantity for Item {0}',b'Vul het aantal in voor artikel {0}'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Credit Note Amt',b'Credit Note Amt'
-b'DocType: Employee External Work History',b'Employee External Work History',b'Werknemer Externe Werk Geschiedenis'
-b'DocType: Opening Invoice Creation Tool',b'Purchase',b'Inkopen'
-b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Balance Qty',b'Balans Aantal'
-b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20',b'Goals cannot be empty',b'Goals mag niet leeg zijn'
-b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15',b'Enrolling students',b'Studenten inschrijven'
-b'DocType: Item Group',b'Parent Item Group',b'Bovenliggende Artikelgroep'
-b'DocType: Appointment Type',b'Appointment Type',b'Afspraakstype'
-b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21',b'{0} for {1}',b'{0} voor {1}'
-b'DocType: Healthcare Settings',b'Valid number of days',b'Geldig aantal dagen'
-b'apps/erpnext/erpnext/setup/doctype/company/company.js +39',b'Cost Centers',b'Kostenplaatsen'
-b'DocType: Land Unit',b'Linked Plant Analysis',b'Linked Plant Analysis'
-b'DocType: Purchase Receipt',"b""Rate at which supplier's currency is converted to company's base currency""",b'Koers waarmee de leverancier valuta wordt omgerekend naar de basis bedrijfsvaluta'
-b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36',b'Row #{0}: Timings conflicts with row {1}',b'Rij #{0}: Tijden conflicteren met rij {1}'
-b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Zero waarderingspercentage toestaan'
-b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Zero waarderingspercentage toestaan'
-b'DocType: Training Event Employee',b'Invited',b'Uitgenodigd'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178',b'Multiple active Salary Structures found for employee {0} for the given dates',b'Meerdere actieve Salaris Structuren gevonden voor werknemer {0} de uitgekozen datum'
-b'apps/erpnext/erpnext/config/accounts.py +308',b'Setup Gateway accounts.',b'Setup Gateway accounts.'
-b'DocType: Employee',b'Employment Type',b'Dienstverband Type'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42',b'Fixed Assets',b'Vaste Activa'
-b'DocType: Payment Entry',b'Set Exchange Gain / Loss',b'Stel Exchange winst / verlies'
-,b'GST Purchase Register',b'GST Aankoopregister'
-,b'Cash Flow',b'Cashflow'
-b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25',b'Combined invoice portion must equal 100%',b'Gecombineerd factuurgedeelte moet 100% zijn'
-b'DocType: Item Group',b'Default Expense Account',b'Standaard Kostenrekening'
-b'DocType: GST Account',b'CGST Account',b'CGST-account'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53',b'Student Email ID',b'Student Email ID'
-b'DocType: Employee',b'Notice (days)',b'Kennisgeving ( dagen )'
-b'DocType: Tax Rule',b'Sales Tax Template',b'Sales Tax Template'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2510',b'Select items to save the invoice',b'Selecteer items om de factuur te slaan'
-b'DocType: Employee',b'Encashment Date',b'Betalingsdatum'
-b'DocType: Training Event',b'Internet',b'internet'
-b'DocType: Special Test Template',b'Special Test Template',b'Special Test Template'
-b'DocType: Account',b'Stock Adjustment',b'Voorraad aanpassing'
-b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34',b'Default Activity Cost exists for Activity Type - {0}',b'Default Activiteit Kosten bestaat voor Activity Type - {0}'
-b'DocType: Work Order',b'Planned Operating Cost',b'Geplande bedrijfskosten'
-b'DocType: Academic Term',b'Term Start Date',b'Term Startdatum'
-b'apps/erpnext/erpnext/config/accounts.py +471',b'List of all share transactions',b'Lijst met alle aandelentransacties'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'Opp Count'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'Opp Count'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244',b'Please find attached {0} #{1}',b'In bijlage vindt u {0} # {1}'
-b'apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52',b'Average Rate',b'Gemiddelde score'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +728',b'Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total',b'Het totale betalingsbedrag in het betalingsschema moet gelijk zijn aan het groot / afgerond totaal'
-b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34',b'Bank Statement balance as per General Ledger',b'Bankafschrift saldo per General Ledger'
-b'DocType: Job Applicant',b'Applicant Name',b'Aanvrager Naam'
-b'DocType: Authorization Rule',b'Customer / Item Name',b'Klant / Naam van het punt'
-b'DocType: Buying Settings',"b'If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt'","b'Indien ingeschakeld, worden de laatste aankoopgegevens van items niet opgehaald van de vorige bestelling of aankoopbon'"
-b'DocType: Product Bundle',"b'Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials'","b'Aggregate groep ** Items ** in een ander ** Item **. Dit is handig als u bundelen een bepaald ** Items ** in een pakket en je onderhouden voorraad van de verpakte ** Items ** en niet de totale ** Item **. Het pakket ** Item ** zal hebben &quot;Is Stock Item&quot; als &quot;Nee&quot; en &quot;Is Sales Item&quot; als &quot;Ja&quot;. Bijvoorbeeld: Als u verkoopt laptops en rugzakken los en hebben een speciale prijs als de klant beide koopt, dan is de laptop + rugzak zal een nieuw product Bundel Item zijn. Opmerking: BOM = stuklijst'"
-b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42',b'Serial No is mandatory for Item {0}',b'Serienummer is verplicht voor Artikel {0}'
-b'DocType: Item Variant Attribute',b'Attribute',b'Attribuut'
-b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43',b'Please specify from/to range',b'Gelieve te specificeren van / naar vari\xc3\xabren'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28',b'Opening {0} Invoice created',b'Opening {0} Factuur aangemaakt'
-b'DocType: Serial No',b'Under AMC',b'Onder AMC'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55',b'Item valuation rate is recalculated considering landed cost voucher amount',b'Item waardering tarief wordt herberekend overweegt landde kosten voucherbedrag'
-b'apps/erpnext/erpnext/config/selling.py +153',b'Default settings for selling transactions.',b'Standaardinstellingen voor Verkooptransacties .'
-b'DocType: Guardian',b'Guardian Of ',b'Beschermer van'
-b'DocType: Grading Scale Interval',b'Threshold',b'Drempel'
-b'DocType: BOM Update Tool',b'Current BOM',b'Huidige Stuklijst'
-b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32',b'Balance (Dr - Cr)',b'Evenwicht (Dr - Cr)'
-b'apps/erpnext/erpnext/public/js/utils.js +55',b'Add Serial No',b'Voeg Serienummer toe'
-b'DocType: Work Order Item',b'Available Qty at Source Warehouse',b'Beschikbaar Aantal bij Source Warehouse'
-b'apps/erpnext/erpnext/config/support.py +22',b'Warranty',b'Garantie'
-b'DocType: Purchase Invoice',b'Debit Note Issued',b'Debetnota'
-b'DocType: Work Order',b'Warehouses',b'Magazijnen'
-b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18',b'{0} asset cannot be transferred',b'{0} actief kan niet worden overgedragen'
-b'DocType: Hotel Room Pricing',b'Hotel Room Pricing',b'Prijzen van hotelkamers'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +80',b'This Item is a Variant of {0} (Template).',b'Dit artikel is een variant van {0} (Sjabloon).'
-b'DocType: Workstation',b'per hour',b'per uur'
-b'apps/erpnext/erpnext/config/buying.py +7',b'Purchasing',b'inkoop'
-b'DocType: Announcement',b'Announcement',b'Mededeling'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84',b'Customer LPO',b'Klant-LPO'
-b'DocType: Education Settings',"b'For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.'",b'Voor Batch-based Student Group wordt de Student Batch voor elke student gevalideerd van de Programma Inschrijving.'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50',b'Warehouse can not be deleted as stock ledger entry exists for this warehouse.',b'Magazijn kan niet worden verwijderd omdat er voorraadboekingen zijn voor dit magazijn.'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +25',b'Distribution',b'Distributie'
-b'DocType: Expense Claim Advance',b'Expense Claim Advance',b'Onkostendeclaratie doorvoeren'
-b'DocType: Lab Test',b'Report Preference',b'Rapportvoorkeur'
-b'apps/erpnext/erpnext/config/non_profit.py +43',b'Volunteer information.',b'Vrijwilliger informatie.'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133',b'Project Manager',b'Project Manager'
-,b'Quoted Item Comparison',b'Geciteerd Item Vergelijking'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34',b'Overlap in scoring between {0} and {1}',b'Overlappen in scoren tussen {0} en {1}'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114',b'Dispatch',b'Dispatch'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74',b'Max discount allowed for item: {0} is {1}%',b'Maximale korting toegestaan voor artikel: {0} is {1}%'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176',b'Net Asset value as on',b'Intrinsieke waarde Op'
-b'DocType: Crop',b'Produce',b'Produceren'
-b'DocType: Hotel Settings',b'Default Taxes and Charges',b'Standaard en -heffingen'
-b'DocType: Account',b'Receivable',b'Vordering'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308',b'Row #{0}: Not allowed to change Supplier as Purchase Order already exists',b'Rij # {0}: Niet toegestaan om van leverancier te veranderen als bestelling al bestaat'
-b'DocType: Accounts Settings',b'Role that is allowed to submit transactions that exceed credit limits set.',b'Rol welke is toegestaan om transacties in te dienen die gestelde kredietlimieten overschrijden .'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +989',b'Select Items to Manufacture',b'Selecteer Items voor fabricage'
-b'DocType: Delivery Stop',b'Delivery Stop',b'Levering Stop'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +963',"b'Master data syncing, it might take some time'","b'Master data synchronisatie, kan het enige tijd duren'"
-b'DocType: Item',b'Material Issue',b'Materiaal uitgifte'
-b'DocType: Employee Education',b'Qualification',b'Kwalificatie'
-b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42',b'View Salary Slips',b'Bekijk salarisstroken'
-b'DocType: Item Price',b'Item Price',b'Artikelprijs'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48',b'Soap & Detergent',b'Zeep & Wasmiddel'
-b'DocType: BOM',b'Show Items',b'Show items'
-b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30',b'From Time cannot be greater than To Time.',b'Van tijd kan niet groter zijn dan tot tijd.'
-b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92',b'Do you want to notify all the customers by email?',b'Wilt u alle klanten per e-mail op de hoogte stellen?'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36',b'Motion Picture & Video',b'Motion Picture & Video'
-b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5',b'Ordered',b'Besteld'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51',b'Resume',b'Hervat'
-b'DocType: Salary Detail',b'Component',b'bestanddeel'
-b'DocType: Assessment Criteria',b'Assessment Criteria Group',b'Beoordelingscriteria Group'
-b'DocType: Healthcare Settings',b'Patient Name By',b'Pati\xc3\xabntnaam By'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +72',b'Opening Accumulated Depreciation must be less than equal to {0}',b'Het openen van de cumulatieve afschrijvingen moet kleiner zijn dan gelijk aan {0}'
-b'DocType: Warehouse',b'Warehouse Name',b'Magazijn Naam'
-b'DocType: Naming Series',b'Select Transaction',b'Selecteer Transactie'
-b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30',b'Please enter Approving Role or Approving User',b'Vul de Goedkeurders Rol of Goedkeurende Gebruiker in'
-b'DocType: Journal Entry',b'Write Off Entry',b'Invoer afschrijving'
-b'DocType: BOM',b'Rate Of Materials Based On',b'Prijs van materialen op basis van'
-b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21',b'Support Analtyics',b'Support Analyse'
-b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102',b'Uncheck all',b'Verwijder het vinkje bij alle'
-b'DocType: POS Profile',b'Terms and Conditions',b'Algemene Voorwaarden'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49',b'To Date should be within the Fiscal Year. Assuming To Date = {0}',b'Tot Datum moet binnen het boekjaar vallenn. Ervan uitgaande dat Tot Datum = {0}'
-b'DocType: Employee',"b'Here you can maintain height, weight, allergies, medical concerns etc'","b'Hier kunt u onderhouden lengte, gewicht, allergie\xc3\xabn, medische zorgen, enz.'"
-b'DocType: Leave Block List',b'Applies to Company',b'Geldt voor Bedrijf'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231',b'Cannot cancel because submitted Stock Entry {0} exists',b'Kan niet annuleren omdat ingediende Voorraad Invoer {0} bestaat'
-b'DocType: Employee Loan',b'Disbursement Date',b'uitbetaling Date'
-b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80',"b""'Recipients' not specified""",b'&#39;Ontvangers&#39; niet gespecificeerd'
-b'DocType: BOM Update Tool',b'Update latest price in all BOMs',b'Update de laatste prijs in alle BOM&#39;s'
-b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23',b'Medical Record',b'Medisch dossier'
-b'DocType: Vehicle',b'Vehicle',b'Voertuig'
-b'DocType: Purchase Invoice',b'In Words',b'In Woorden'
-b'apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15',b'{0} must be submitted',b'{0} moet worden ingediend'
-b'DocType: POS Profile',b'Item Groups',b'Item Groepen'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +221',"b""Today is {0}'s birthday!""","b""Vandaag is {0} 's verjaardag!"""
-b'DocType: Sales Order Item',b'For Production',b'Voor Productie'
-b'DocType: Payment Request',b'payment_url',b'payment_url'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186',b'Please add a Temporary Opening account in Chart of Accounts',b'Voeg een tijdelijk openstaand account toe in het rekeningschema'
-b'DocType: Customer',b'Customer Primary Contact',b'Hoofdcontactpersoon klant'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154',b'Period Closing Journal',b'Periode afsluitingsjournaal'
-b'DocType: Project Task',b'View Task',b'Bekijk Task'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'Opp / Lead%'
-b'DocType: Material Request',b'MREQ-',b'MREQ-'
-b'DocType: Payment Schedule',b'Invoice Portion',b'Factuurgedeelte'
-,b'Asset Depreciations and Balances',b'Asset Afschrijvingen en Weegschalen'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370',b'Amount {0} {1} transferred from {2} to {3}',b'Bedrag {0} {1} overgebracht van {2} naar {3}'
-b'DocType: Sales Invoice',b'Get Advances Received',b'Get ontvangen voorschotten'
-b'DocType: Email Digest',b'Add/Remove Recipients',b'Toevoegen / verwijderen Ontvangers'
-b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19',"b""To set this Fiscal Year as Default, click on 'Set as Default'""","b""Om dit boekjaar in te stellen als standaard, klik op 'Als standaard instellen'"""
-b'DocType: Production Plan',b'Include Subcontracted Items',b'Inclusief uitbestede items'
-b'apps/erpnext/erpnext/projects/doctype/project/project.py +220',b'Join',b'Indiensttreding'
-b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21',b'Shortage Qty',b'Tekort Aantal'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +672',b'Cannot change Variant properties after stock transction. You will have to make a new Item to do this.',b'De Variant-eigenschappen kunnen niet worden gewijzigd na stocktransactie. U moet een nieuw item maken om dit te doen.'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +714',b'Item variant {0} exists with same attributes',b'Artikel variant {0} bestaat met dezelfde kenmerken'
-b'DocType: Employee Loan',b'Repay from Salary',b'Terugbetalen van Loon'
-b'DocType: Leave Application',b'LAP/',b'RONDE/'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360',b'Requesting payment against {0} {1} for amount {2}',b'Betalingsverzoeken tegen {0} {1} van {2} bedrag'
-b'DocType: Salary Slip',b'Salary Slip',b'Salarisstrook'
-b'DocType: Lead',b'Lost Quotation',b'verloren Offerte'
-b'apps/erpnext/erpnext/utilities/user_progress.py +221',b'Student Batches',b'Studentenbatches'
-b'DocType: Pricing Rule',b'Margin Rate or Amount',b'Margin Rate of Bedrag'
-b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48',"b""'To Date' is required""","b""'Tot Datum' is vereist"""
-b'DocType: Packing Slip',"b'Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.'","b'Genereren van pakbonnen voor pakketten te leveren. Gebruikt voor pakket nummer, inhoud van de verpakking en het gewicht te melden.'"
-b'DocType: Sales Invoice Item',b'Sales Order Item',b'Verkooporder Artikel'
-b'DocType: Salary Slip',b'Payment Days',b'Betaling Dagen'
-b'DocType: Stock Settings',b'Convert Item Description to Clean HTML',b'Itembeschrijving converteren om HTML te wissen'
-b'DocType: Patient',b'Dormant',b'Slapend'
-b'DocType: Salary Slip',b'Total Interest Amount',b'Totaal rentebedrag'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124',b'Warehouses with child nodes cannot be converted to ledger',b'Warehouses met kind nodes kunnen niet worden geconverteerd naar grootboek'
-b'DocType: BOM',b'Manage cost of operations',b'Beheer kosten van de operaties'
-b'DocType: Accounts Settings',b'Stale Days',b'Stale Days'
-b'DocType: Notification Control',"b'When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.'","b'Als de aangevinkte transacties worden ""Ingediend"", wordt een e-mail pop-up automatisch geopend om een e-mail te sturen naar de bijbehorende ""Contact"" in deze transactie, met de transactie als bijlage. De gebruiker heeft vervolgens de optie om de e-mail wel of niet te verzenden.'"
-b'apps/erpnext/erpnext/config/setup.py +14',b'Global Settings',b'Global Settings'
-b'DocType: Crop',b'Row Spacing UOM',b'Rijafstand UOM'
-b'DocType: Assessment Result Detail',b'Assessment Result Detail',b'Assessment Resultaat Detail'
-b'DocType: Employee Education',b'Employee Education',b'Werknemer Opleidingen'
-b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53',b'Duplicate item group found in the item group table',b'Duplicate artikelgroep gevonden in de artikelgroep tafel'
-b'DocType: Land Unit',b'Parent Land Unit',b'Parent Land Unit'
-b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1113',b'It is needed to fetch Item Details.',b'Het is nodig om Item Details halen.'
-b'DocType: Fertilizer',b'Fertilizer Name',b'Meststofnaam'
-b'DocType: Salary Slip',b'Net Pay',b'Nettoloon'
-b'DocType: Cash Flow Mapping Accounts',b'Account',b'Rekening'
-b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217',b'Serial No {0} has already been received',b'Serienummer {0} is reeds ontvangen'
-,b'Requested Items To Be Transferred',b'Aangevraagde Artikelen te Verplaatsen'
-b'DocType: Expense Claim',b'Vehicle Log',b'Voertuig log'
-b'DocType: Vital Signs',b'Presence of a fever (temp &gt; 38.5 \xc2\xb0C/101.3 \xc2\xb0F or sustained temp &gt; 38 \xc2\xb0C/100.4 \xc2\xb0F)',"b'Aanwezigheid van een koorts (temp&gt; 38,5 \xc2\xb0 C of bijgehouden temperatuur&gt; 38 \xc2\xb0 C / 100,4 \xc2\xb0 F)'"
-b'DocType: Customer',b'Sales Team Details',b'Verkoop Team Details'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1352',b'Delete permanently?',b'Permanent verwijderen?'
-b'DocType: Expense Claim',b'Total Claimed Amount',b'Totaal gedeclareerd bedrag'
-b'apps/erpnext/erpnext/config/crm.py +17',b'Potential opportunities for selling.',b'Potenti\xc3\xable mogelijkheden voor verkoop.'
-b'DocType: Shareholder',b'Folio no.',b'Folio nr.'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246',b'Invalid {0}',b'Ongeldige {0}'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90',b'Sick Leave',b'Ziekteverlof'
-b'DocType: Email Digest',b'Email Digest',b'E-mail Digest'
-b'DocType: Delivery Note',b'Billing Address Name',b'Factuuradres Naam'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22',b'Department Stores',b'Warenhuizen'
-,b'Item Delivery Date',b'Item Leveringsdatum'
-b'DocType: Production Plan',b'Material Requested',b'Gevraagde materiaal'
-b'DocType: Warehouse',b'PIN',b'PIN'
-b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116',"b""Error '{0}' occured. Arguments {1}.""",b'Fout &#39;{0}&#39; opgetreden. Argumenten {1}.'
-b'DocType: Bin',b'Reserved Qty for sub contract',b'Gereserveerde hoeveelheid voor subcontract'
-b'DocType: Patient Service Unit',b'Patinet Service Unit',b'Patinet service-eenheid'
-b'DocType: Sales Invoice',b'Base Change Amount (Company Currency)',b'Base Change Bedrag (Company Munt)'
-b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304',b'No accounting entries for the following warehouses',b'Geen boekingen voor de volgende magazijnen'
-b'apps/erpnext/erpnext/projects/doctype/project/project.js +95',b'Save the document first.',b'Sla het document eerst.'
-b'apps/erpnext/erpnext/shopping_cart/cart.py +74',b'Only {0} in stock for item {1}',b'Alleen {0} op voorraad voor artikel {1}'
-b'DocType: Account',b'Chargeable',b'Aan te rekenen'
-b'DocType: Company',b'Change Abbreviation',b'Afkorting veranderen'
-b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66',b'Pay {0} {1}',b'Betaal {0} {1}'
-b'DocType: Expense Claim Detail',b'Expense Date',b'Kosten Datum'
-b'DocType: Item',b'Max Discount (%)',b'Max Korting (%)'
-b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30',b'Credit Days cannot be a negative number',b'Kredietdagen mogen geen negatief getal zijn'
-b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70',b'Last Order Amount',b'Laatste Orderbedrag'
-b'DocType: Cash Flow Mapper',b'e.g Adjustments for:',b'bijv. aanpassingen voor:'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +275',"b' {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item'","b'{0} Voorbeeld behouden is gebaseerd op batch, controleer Has Batch No om monster van artikel te behouden'"
-b'DocType: Task',b'Is Milestone',b'Is Milestone'
-b'DocType: Delivery Stop',b'Email Sent To',b'Email verzonden naar'
-b'DocType: Budget',b'Warn',b'Waarschuwen'
-b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81',b'Are you sure you want to unregister?',b'Weet je zeker dat je je wilt uitschrijven?'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +797',b'All items have already been transferred for this Work Order.',b'Alle items zijn al overgedragen voor deze werkbon.'
-b'DocType: Appraisal',"b'Any other remarks, noteworthy effort that should go in the records.'","b'Eventuele andere opmerkingen, noemenswaardig voor in de boekhouding,'"
-b'DocType: Asset Maintenance',b'Manufacturing User',b'Productie Gebruiker'
-b'DocType: Purchase Invoice',b'Raw Materials Supplied',b'Grondstoffen Geleverd'
-b'DocType: C-Form',b'Series',b'Reeksen'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282',b'Currency of the price list {0} must be {1} or {2}',b'Valuta van de prijslijst {0} moet {1} of {2} zijn'
-b'DocType: Appraisal',b'Appraisal Template',b'Beoordeling Sjabloon'
-b'DocType: Soil Texture',b'Ternary Plot',b'Ternary Plot'
-b'DocType: Item Group',b'Item Classification',b'Item Classificatie'
-b'DocType: Driver',b'License Number',b'Licentienummer'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131',b'Business Development Manager',b'Business Development Manager'
-b'DocType: Maintenance Visit Purpose',b'Maintenance Visit Purpose',b'Doel van onderhouds bezoek'
-b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19',b'Invoice Patient Registration',b'Invoice Patient Registration'
-b'DocType: Crop',b'Period',b'periode'
-b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27',b'General Ledger',b'Grootboek'
-b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33',b'Employee {0} on Leave on {1}',b'Employee {0} met verlof om {1}'
-b'apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10',b'View Leads',b'Bekijk Leads'
-b'DocType: Program Enrollment Tool',b'New Program',b'nieuw programma'
-b'DocType: Item Attribute Value',b'Attribute Value',b'Eigenschap Waarde'
-,b'Itemwise Recommended Reorder Level',b'Artikelgebaseerde Aanbevolen Bestelniveau'
-b'DocType: Salary Detail',b'Salary Detail',b'salaris Detail'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070',b'Please select {0} first',b'Selecteer eerst {0}'
-b'DocType: Appointment Type',b'Physician',b'Arts'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +872',b'Batch {0} of Item {1} has expired.',b'Batch {0} van Item {1} is verlopen.'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11',b'Consultations',b'overleg'
-b'DocType: Sales Invoice',b'Commission',b'commissie'
-b'apps/erpnext/erpnext/config/manufacturing.py +27',b'Time Sheet for manufacturing.',b'Time Sheet voor de productie.'
-b'apps/erpnext/erpnext/templates/pages/cart.html +37',b'Subtotal',b'Subtotaal'
-b'apps/erpnext/erpnext/config/erpnext_integrations.py +18',b'GoCardless SEPA Mandate',b'GoCardless SEPA-mandaat'
-b'DocType: Physician',b'Charges',b'kosten'
-b'DocType: Production Plan',b'Get Items For Work Order',b'Items voor werkorder ophalen'
-b'DocType: Salary Detail',b'Default Amount',b'Standaard Bedrag'
-b'DocType: Lab Test Template',b'Descriptive',b'Beschrijvend'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95',b'Warehouse not found in the system',b'Magazijn niet gevonden in het systeem'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115',"b""This Month's Summary""",b'Samenvatting van deze maand'
-b'DocType: Quality Inspection Reading',b'Quality Inspection Reading',b'Kwaliteitscontrole Meting'
-b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25',b'`Freeze Stocks Older Than` should be smaller than %d days.',"b""'Bevries Voorraden Ouder dan' moet minder dan %d dagen zijn."""
-b'DocType: Tax Rule',b'Purchase Tax Template',b'Kopen Tax Template'
-b'apps/erpnext/erpnext/utilities/user_progress.py +48',"b""Set a sales goal you'd like to achieve for your company.""",b'Stel een verkoopdoel dat u voor uw bedrijf wilt bereiken.'
-,b'Project wise Stock Tracking',b'Projectgebaseerde Aandelenhandel'
-b'DocType: GST HSN Code',b'Regional',b'Regionaal'
-b'apps/erpnext/erpnext/config/healthcare.py +40',b'Laboratory',b'Laboratorium'
-b'DocType: Stock Entry Detail',b'Actual Qty (at source/target)',b'Werkelijke Aantal (bij de bron / doel)'
-b'DocType: Item Customer Detail',b'Ref Code',b'Ref Code'
-b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75',b'Customer Group is Required in POS Profile',b'Klantengroep is verplicht in het POS-profiel'
-b'apps/erpnext/erpnext/config/hr.py +12',b'Employee records.',b'Werknemer regel.'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +98',b'Please set Next Depreciation Date',b'Stel Volgende Afschrijvingen Date'
-b'DocType: HR Settings',b'Payroll Settings',b'Loonadministratie Instellingen'
-b'apps/erpnext/erpnext/config/accounts.py +146',b'Match non-linked Invoices and Payments.',b'Match niet-gekoppelde facturen en betalingen.'
-b'DocType: POS Settings',b'POS Settings',b'POS-instellingen'
-b'apps/erpnext/erpnext/templates/pages/cart.html +16',b'Place Order',b'Plaats bestelling'
-b'DocType: Email Digest',b'New Purchase Orders',b'Nieuwe Inkooporders'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24',b'Root cannot have a parent cost center',b'Root kan niet een bovenliggende kostenplaats hebben'
-b'apps/erpnext/erpnext/public/js/stock_analytics.js +54',b'Select Brand...',b'Selecteer merk ...'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +32',b'Non Profit (beta)',b'Non-profit (b\xc3\xa8ta)'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18',b'Training Events/Results',b'Trainingsgebeurtenissen / resultaten'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152',b'Accumulated Depreciation as on',b'Cumulatieve afschrijvingen per'
-b'DocType: Sales Invoice',b'C-Form Applicable',b'C-Form Toepasselijk'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438',b'Operation Time must be greater than 0 for Operation {0}',b'Operatie tijd moet groter zijn dan 0 voor de operatie zijn {0}'
-b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107',b'Warehouse is mandatory',b'Magazijn is verplicht'
-b'DocType: Shareholder',b'Address and Contacts',b'Adres en Contacten'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67',b'Failed to create website',b'Kan website niet maken'
-b'DocType: Soil Analysis',b'Mg/K',b'Mg / K'
-b'DocType: UOM Conversion Detail',b'UOM Conversion Detail',b'Eenheid Omrekeningsfactor Detail'
-b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924',b'Retention Stock Entry already created or Sample Quantity not provided',b'Retentie Stock Entry al gemaakt of Sample Quantity niet verstrekt'
-b'DocType: Program',b'Program Abbreviation',b'programma Afkorting'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52',b'Charges are updated in Purchase Receipt against each item',b'Kosten worden bijgewerkt in Kwitantie tegen elk item'
-b'DocType: Warranty Claim',b'Resolved By',b'Opgelost door'
-b'DocType: Bank Guarantee',b'Start Date',b'Startdatum'
-b'apps/erpnext/erpnext/config/hr.py +75',b'Allocate leaves for a period.',b'Toewijzen bladeren voor een periode .'
-b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42',b'Cheques and Deposits incorrectly cleared',b'Cheques en Deposito verkeerd ontruimd'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +46',b'Account {0}: You can not assign itself as parent account',b'Rekening {0}: U kunt niet de rekening zelf toewijzen als bovenliggende rekening'
-b'DocType: Purchase Invoice Item',b'Price List Rate',b'Prijslijst Tarief'
-b'apps/erpnext/erpnext/utilities/activation.py +72',b'Create customer quotes',b'Maak een offerte voor de klant'
-b'DocType: Item',"b'Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.'",b'Toon &quot;Op voorraad&quot; of &quot;Niet op voorraad&quot; op basis van de beschikbare voorraad in dit magazijn.'
-b'apps/erpnext/erpnext/config/manufacturing.py +38',b'Bill of Materials (BOM)',b'Stuklijsten'
-b'DocType: Item',b'Average time taken by the supplier to deliver',b'De gemiddelde tijd die door de leverancier te leveren'
-b'DocType: Sample Collection',b'Collected By',b'Verzameld door'
-b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35',b'Assessment Result',b'assessment Resultaat'
-b'DocType: Hotel Room Package',b'Hotel Room Package',b'Hotelkamerarrangement'
-b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13',b'Hours',b'Uren'
-b'DocType: Project',b'Expected Start Date',b'Verwachte startdatum'
-b'DocType: Purchase Invoice',b'04-Correction in Invoice',b'04-correctie op factuur'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963',b'Work Order already created for all items with BOM',b'Werkorder al gemaakt voor alle artikelen met Stuklijst'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +60',b'Variant Details Report',b'Variant Details Rapport'
-b'DocType: Setup Progress Action',b'Setup Progress Action',b'Setup Progress Action'
-b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36',b'Buying Price List',b'Prijslijst kopen'
-b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49',b'Remove item if charges is not applicable to that item',b'Artikel verwijderen als de kosten niet van toepassing zijn op dat artikel'
-b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21',b'Please select Maintenance Status as Completed or remove Completion Date',b'Selecteer Onderhoudsstatus als voltooid of verwijder de voltooiingsdatum'
-b'DocType: Supplier',b'Default Payment Terms Template',b'Standaard betalingsvoorwaarden sjabloon'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34',b'Transaction currency must be same as Payment Gateway currency',b'Transactie valuta moet hetzelfde zijn als Payment Gateway valuta'
-b'DocType: Payment Entry',b'Receive',b'Ontvangen'
-b'apps/erpnext/erpnext/templates/pages/rfq.html +75',b'Quotations: ',b'citaten:'
-b'DocType: Maintenance Visit',b'Fully Completed',b'Volledig afgerond'
-b'apps/erpnext/erpnext/projects/doctype/project/project_list.js +6',b'{0}% Complete',b'{0}% voltooid'
-b'DocType: Employee',b'Educational Qualification',b'Educatieve Kwalificatie'
-b'DocType: Workstation',b'Operating Costs',b'Bedrijfskosten'
-b'DocType: Budget',b'Action if Accumulated Monthly Budget Exceeded',b'Actie als gezamenlijke maandelijkse budget overschreden'
-b'DocType: Subscription',b'Submit on creation',b'Toevoegen aan de creatie'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483',b'Currency for {0} must be {1}',b'Munt voor {0} moet {1}'
-b'DocType: Asset',b'Disposal Date',b'verwijdering Date'
-b'DocType: Daily Work Summary Settings',"b'Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.'","b'Emails worden meegedeeld aan alle actieve werknemers van het bedrijf worden verzonden op het opgegeven uur, als ze geen vakantie. Samenvatting van de reacties zal worden verzonden om middernacht.'"
-b'DocType: Employee Leave Approver',b'Employee Leave Approver',b'Werknemer Verlof Fiatteur'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +510',b'Row {0}: An Reorder entry already exists for this warehouse {1}',b'Rij {0}: Er bestaat al een nabestelling voor dit magazijn {1}'
-b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99',"b'Cannot declare as lost, because Quotation has been made.'","b'Kan niet als verloren instellen, omdat offerte is gemaakt.'"
-b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16',b'Training Feedback',b'training Terugkoppeling'
-b'DocType: Supplier Scorecard Criteria',b'Supplier Scorecard Criteria',b'Leveranciers Scorecard Criteria'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149',b'Please select Start Date and End Date for Item {0}',b'Selecteer Start- en Einddatum voor Artikel {0}'
-b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55',b'Course is mandatory in row {0}',b'Natuurlijk is verplicht in de rij {0}'
-b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16',b'To date cannot be before from date',b'Tot Datum kan niet eerder zijn dan Van Datum'
-b'DocType: Supplier Quotation Item',b'Prevdoc DocType',b'Prevdoc DocType'
-b'DocType: Cash Flow Mapper',b'Section Footer',b'Sectie voettekst'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +304',b'Add / Edit Prices',b'Toevoegen / bewerken Prijzen'
-b'DocType: Batch',b'Parent Batch',b'Ouderlijk Batch'
-b'DocType: Batch',b'Parent Batch',b'Ouderlijk Batch'
-b'DocType: Cheque Print Template',b'Cheque Print Template',b'Cheque Print Template'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36',b'Chart of Cost Centers',b'Kostenplaatsenschema'
-b'DocType: Lab Test Template',b'Sample Collection',b'Sample Collection'
-,b'Requested Items To Be Ordered',b'Aangevraagde Artikelen in te kopen'
-b'apps/erpnext/erpnext/public/js/hub/hub_page.js +137',b'My Orders',b'Mijn Bestellingen'
-b'DocType: Price List',b'Price List Name',b'Prijslijst Naam'
-b'DocType: BOM',b'Manufacturing',b'Productie'
-,b'Ordered Items To Be Delivered',b'Bestelde artikelen te leveren'
-b'DocType: Account',b'Income',b'Inkomsten'
-b'DocType: Industry Type',b'Industry Type',b'Industrie Type'
-b'apps/erpnext/erpnext/templates/includes/cart.js +150',b'Something went wrong!',b'Er is iets fout gegaan!'
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105',b'Warning: Leave application contains following block dates',b'Waarschuwing: Verlof applicatie bevat volgende blok data'
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275',b'Sales Invoice {0} has already been submitted',b'Verkoopfactuur {0} is al ingediend'
-b'DocType: Supplier Scorecard Scoring Criteria',b'Score',b'partituur'
-b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25',b'Fiscal Year {0} does not exist',b'Boekjaar {0} bestaat niet'
-b'DocType: Asset Maintenance Log',b'Completion Date',b'Voltooiingsdatum'
-b'DocType: Purchase Invoice Item',b'Amount (Company Currency)',b'Bedrag (Company Munt)'
-b'DocType: Agriculture Analysis Criteria',b'Agriculture User',b'Landbouw Gebruiker'
-b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38',b'Valid till date cannot be before transaction date',b'Geldig tot datum kan niet v\xc3\xb3\xc3\xb3r de transactiedatum zijn'
-b'apps/erpnext/erpnext/stock/stock_ledger.py +381',b'{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.',b'{0} eenheden van {1} die nodig zijn in {2} op {3} {4} te {5} om deze transactie te voltooien.'
-b'DocType: Fee Schedule',b'Student Category',b'student Categorie'
-b'DocType: Announcement',b'Student',b'Student'
-b'apps/erpnext/erpnext/config/hr.py +238',b'Organization unit (department) master.',b'Organisatie -eenheid (departement) meester.'
-b'DocType: Shipping Rule',b'Shipping Rule Type',b'Verzendregel Type'
-b'apps/erpnext/erpnext/utilities/user_progress.py +239',b'Go to Rooms',b'Ga naar kamers'
-b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75',b'Please enter message before sending',b'Vul bericht in alvorens te verzenden'
-b'DocType: Purchase Invoice',b'DUPLICATE FOR SUPPLIER',b'DUPLICATE VOOR LEVERANCIER'
-b'DocType: Email Digest',b'Pending Quotations',b'In afwachting van Citaten'
-b'apps/erpnext/erpnext/config/accounts.py +318',b'Point-of-Sale Profile',b'Point-of-Sale Profile'
-b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25',b'{0} should be a value between 0 and 100',b'{0} moet een waarde tussen 0 en 100 zijn'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +94',b'Next Depreciation Date cannot be before Available-for-use Date',b'De volgende waarderingsdatum kan niet eerder zijn dan de datum van gebruik voor gebruik'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156',b'Unsecured Loans',b'Leningen zonder onderpand'
-b'DocType: Cost Center',b'Cost Center Name',b'Kostenplaats Naam'
-b'DocType: Student',b'B+',b'B +'
-b'DocType: HR Settings',b'Max working hours against Timesheet',b'Max werkuren tegen Timesheet'
-b'DocType: Maintenance Schedule Detail',b'Scheduled Date',b'Geplande Datum'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +214',b'Total Paid Amt',b'Totale betaalde Amt'
-b'DocType: SMS Center',b'Messages greater than 160 characters will be split into multiple messages',b'Bericht van meer dan 160 tekens worden opgesplitst in meerdere berichten'
-b'DocType: Purchase Receipt Item',b'Received and Accepted',b'Ontvangen en geaccepteerd'
-b'DocType: Hub Settings',b'Company and Seller Profile',b'Bedrijf en verkoperprofiel'
-,b'GST Itemised Sales Register',b'GST Itemized Sales Register'
-b'DocType: Soil Texture',b'Silt Loam',b'Silt Loam'
-,b'Serial No Service Contract Expiry',b'Serienummer Service Contract Afloop'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299',b'You cannot credit and debit same account at the same time',b'U kunt niet hetzelfde bedrag crediteren en debiteren op hetzelfde moment'
-b'DocType: Vital Signs',"b""Adults' pulse rate is anywhere between 50 and 80 beats per minute.""",b'De volwassen puls is overal tussen 50 en 80 slaats per minuut.'
-b'DocType: Naming Series',b'Help HTML',b'Help HTML'
-b'DocType: Student Group Creation Tool',b'Student Group Creation Tool',b'Student Group Creation Tool'
-b'DocType: Item',b'Variant Based On',b'Variant gebaseerd op'
-b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53',b'Total weightage assigned should be 100%. It is {0}',b'Totaal toegewezen gewicht moet 100% zijn. Het is {0}'
-b'apps/erpnext/erpnext/utilities/user_progress.py +109',b'Your Suppliers',b'Uw Leveranciers'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'Please correct the',b'Corrigeer alstublieft de'
-b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80',b'Cannot set as Lost as Sales Order is made.',"b'Kan niet als verloren instellen, omdat er al een verkooporder is gemaakt.'"
-b'DocType: Request for Quotation Item',b'Supplier Part No',b'Leverancier Part No'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382',"b""Cannot deduct when category is for 'Valuation' or 'Vaulation and Total'""",b'Kan niet aftrekken als categorie is voor &#39;Valuation&#39; of &#39;Vaulation en Total&#39;'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377',b'Received From',b'Gekregen van'
-b'DocType: Lead',b'Converted',b'Omgezet'
-b'DocType: Item',b'Has Serial No',b'Heeft Serienummer'
-b'DocType: Employee',b'Date of Issue',b'Datum van afgifte'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222',"b""As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}""","b""Conform de Aankoop Instellingen indien Aankoopbon Vereist == 'JA', dient de gebruiker eerst een Aankoopbon voor item {0} aan te maken om een Aankoop Factuur aan te kunnen maken"""
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167',b'Row #{0}: Set Supplier for item {1}',b'Rij # {0}: Stel Leverancier voor punt {1}'
-b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121',b'Row {0}: Hours value must be greater than zero.',b'Rij {0}: Aantal uren moet groter zijn dan nul.'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +195',b'Website Image {0} attached to Item {1} cannot be found',b'Website Afbeelding {0} verbonden aan Item {1} kan niet worden gevonden'
-b'DocType: Issue',b'Content Type',b'Content Type'
-b'DocType: Asset',b'Assets',b'Middelen'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17',b'Computer',b'Computer'
-b'DocType: Item',b'List this Item in multiple groups on the website.',b'Lijst deze post in meerdere groepen op de website.'
-b'DocType: Payment Term',b'Due Date Based On',b'Vervaldatum op basis van'
-b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82',b'Please set default customer group and territory in Selling Settings',b'Stel de standaard klantgroep en het gebied in de verkoopinstellingen in'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214',b'{0} {1} does not exist',b'{0} {1} bestaat niet'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323',b'Please check Multi Currency option to allow accounts with other currency',b'Kijk Valuta optie om rekeningen met andere valuta toestaan'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88',b'Item: {0} does not exist in the system',b'Item: {0} bestaat niet in het systeem'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +106',b'You are not authorized to set Frozen value',b'U bent niet bevoegd om Bevroren waarde in te stellen'
-b'DocType: Payment Reconciliation',b'Get Unreconciled Entries',b'Haal onafgeletterde transacties op'
-b'DocType: Payment Reconciliation',b'From Invoice Date',b'Na factuurdatum'
-b'DocType: Healthcare Settings',b'Laboratory Settings',b'Laboratoriuminstellingen'
-b'DocType: Patient Appointment',b'Service Unit',b'Service-eenheid'
-b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97',b'Successfully Set Supplier',b'Leverancier met succes instellen'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75',b'Leave Encashment',b'Laat Inning'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +114',b'What does it do?',b'Wat doet het?'
-b'DocType: Crop',b'Byproducts',b'bijproducten'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +84',b'To Warehouse',b'Tot Magazijn'
-b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26',b'All Student Admissions',b'Alle studentenadministratie'
-,b'Average Commission Rate',b'Gemiddelde Commissie Rate'
-b'DocType: Share Balance',b'No of Shares',b'Aantal aandelen'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +448',"b""'Has Serial No' can not be 'Yes' for non-stock item""","b""'Heeft Serienummer' kan niet 'ja' zijn voor niet- voorraad artikel"""
-b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59',b'Select Status',b'Selecteer Status'
-b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41',b'Attendance can not be marked for future dates',b'Aanwezigheid kan niet aangemerkt worden voor toekomstige data'
-b'DocType: Pricing Rule',b'Pricing Rule Help',b'Prijsbepalingsregel Help'
-b'DocType: School House',b'House Name',b'Huis naam'
-b'DocType: Fee Schedule',b'Total Amount per Student',b'Totaal Bedrag per student'
-b'DocType: Purchase Taxes and Charges',b'Account Head',b'Hoofdrekening'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153',b'Electrical',b'elektrisch'
-b'apps/erpnext/erpnext/utilities/activation.py +100',b'Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts',b'Voeg de rest van uw organisatie als uw gebruikers. U kunt ook toevoegen uitnodigen klanten naar uw portal door ze toe te voegen vanuit Contacten'
-b'DocType: Stock Entry',b'Total Value Difference (Out - In)',b'Totale waarde Verschil (Out - In)'
-b'DocType: Grant Application',b'Requested Amount',b'Gevraagde bedrag'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348',b'Row {0}: Exchange Rate is mandatory',b'Rij {0}: Wisselkoers is verplicht'
-b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27',b'User ID not set for Employee {0}',b'Gebruikers-ID niet ingesteld voor Werknemer {0}'
-b'DocType: Vehicle',b'Vehicle Value',b'Voertuig waarde'
-b'DocType: Crop Cycle',b'Detected Diseases',b'Gedetecteerde ziekten'
-b'DocType: Stock Entry',b'Default Source Warehouse',b'Standaard Bronmagazijn'
-b'DocType: Item',b'Customer Code',b'Klantcode'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +220',b'Birthday Reminder for {0}',b'Verjaardagsherinnering voor {0}'
-b'DocType: Asset Maintenance Task',b'Last Completion Date',b'Laatste voltooiingsdatum'
-b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72',b'Days Since Last Order',b'Dagen sinds laatste Order'
-b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365',b'Debit To account must be a Balance Sheet account',b'Debitering van rekening moet een balansrekening zijn'
-b'DocType: Buying Settings',b'Naming Series',b'Benoemen Series'
-b'DocType: GoCardless Settings',b'GoCardless Settings',b'GoCardless-instellingen'
-b'DocType: Leave Block List',b'Leave Block List Name',b'Laat Block List Name'
-b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14',b'Insurance Start date should be less than Insurance End date',b'Insurance Startdatum moet kleiner zijn dan de verzekering einddatum'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32',b'Stock Assets',b'Voorraad Activa'
-b'DocType: Restaurant',b'Active Menu',b'Actief menu'
-b'DocType: Target Detail',b'Target Qty',b'Doel Aantal'
-b'DocType: Shopping Cart Settings',b'Checkout Settings',b'Afrekenen Instellingen'
-b'DocType: Student Attendance',b'Present',b'Presenteer'
-b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37',b'Delivery Note {0} must not be submitted',b'Vrachtbrief {0} mag niet worden ingediend'
-b'DocType: Notification Control',b'Sales Invoice Message',b'Verkoopfactuur bericht'
-b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27',b'Closing Account {0} must be of type Liability / Equity',b'Sluiten account {0} moet van het type aansprakelijkheid / Equity zijn'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325',b'Salary Slip of employee {0} already created for time sheet {1}',b'Loonstrook van de werknemer {0} al gemaakt voor urenregistratie {1}'
-b'DocType: Vehicle Log',b'Odometer',b'Kilometerteller'
-b'DocType: Production Plan Item',b'Ordered Qty',b'Besteld Aantal'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +744',b'Item {0} is disabled',b'Punt {0} is uitgeschakeld'
-b'DocType: Stock Settings',b'Stock Frozen Upto',b'Voorraad Bevroren Tot'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930',b'BOM does not contain any stock item',b'BOM geen voorraad artikel bevatten'
-b'DocType: Chapter',b'Chapter Head',b'Hoofdstuk hoofd'
-b'DocType: Payment Term',b'Month(s) after the end of the invoice month',b'Maand (en) na het einde van de factuurmaand'
-b'apps/erpnext/erpnext/config/projects.py +24',b'Project activity / task.',b'Project activiteit / taak.'
-b'DocType: Vehicle Log',b'Refuelling Details',b'Tanken Details'
-b'apps/erpnext/erpnext/config/hr.py +104',b'Generate Salary Slips',b'Genereer Salarisstroken'
-b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25',b'Lab result datetime cannot be before testing datetime',b'Lab-resultaat datetime kan niet v\xc3\xb3\xc3\xb3r het testen van datetime zijn'
-b'DocType: POS Profile',b'Allow user to edit Discount',b'Sta de gebruiker toe om Korting te bewerken'
-b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55',b'Get customers from',b'Haal klanten uit'
-b'DocType: Purchase Invoice Item',b'Include Exploded Items',b'Exploded Items opnemen'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45',"b'Buying must be checked, if Applicable For is selected as {0}'","b'Aankopen moeten worden gecontroleerd, indien ""VAN TOEPASSING VOOR"" is geselecteerd als {0}'"
-b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40',b'Discount must be less than 100',b'Korting moet minder dan 100 zijn'
-b'DocType: Shipping Rule',b'Restrict to Countries',b'Beperken tot landen'
-b'DocType: Purchase Invoice',b'Write Off Amount (Company Currency)',b'Af te schrijven bedrag (Bedrijfsvaluta)'
-b'DocType: Sales Invoice Timesheet',b'Billing Hours',b'Billing Hours'
-b'DocType: Project',b'Total Sales Amount (via Sales Order)',b'Totaal verkoopbedrag (via klantorder)'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +548',b'Default BOM for {0} not found',b'Standaard BOM voor {0} niet gevonden'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +514',b'Row #{0}: Please set reorder quantity',b'Rij # {0}: Stel nabestelling hoeveelheid'
-b'apps/erpnext/erpnext/public/js/pos/pos.html +20',b'Tap items to add them here',b'Tik op items om ze hier toe te voegen'
-b'DocType: Fees',b'Program Enrollment',b'programma Inschrijving'
-b'DocType: Share Transfer',b'To Folio No',b'Naar Folio Nee'
-b'DocType: Landed Cost Voucher',b'Landed Cost Voucher',b'Vrachtkosten Voucher'
-b'apps/erpnext/erpnext/public/js/queries.js +39',b'Please set {0}',b'Stel {0} in'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} is inactieve student'
-b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} is inactieve student'
-b'DocType: Employee',b'Health Details',b'Gezondheid Details'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'Om een betalingsaanvraag te maken is referentie document vereist'
-b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'Om een betalingsaanvraag te maken is referentie document vereist'
-b'DocType: Soil Texture',b'Sandy Clay',b'Zanderige klei'
-b'DocType: Grant Application',b'Assessment  Manager',b'Assessment Manager'
-b'DocType: Payment Entry',b'Allocate Payment Amount',b'Toewijzen Betaling Bedrag'
-b'DocType: Employee External Work History',b'Salary',b'Salaris'
-b'DocType: Serial No',b'Delivery Document Type',b'Levering Soort document'
-b'DocType: Sales Order',b'Partly Delivered',b'Deels geleverd'
-b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48',b'Item Code &gt; Item Group &gt; Brand',b'Artikelcode&gt; Artikelgroep&gt; Merk'
-b'DocType: Item Variant Settings',b'Do not update variants on save',b'Wijzig geen varianten bij opslaan'
-b'DocType: Email Digest',b'Receivables',b'Debiteuren'
-b'DocType: Lead Source',b'Lead Source',b'Lead Bron'
-b'DocType: Customer',b'Additional information regarding the customer.',b'Aanvullende informatie over de klant.'
-b'DocType: Quality Inspection Reading',b'Reading 5',b'Meting 5'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236',"b'{0} {1} is associated with {2}, but Party Account is {3}'","b'{0} {1} is geassocieerd met {2}, maar Party Account is {3}'"
-b'apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7',b'View Lab Tests',b'Bekijk Lab Tests'
-b'DocType: Purchase Invoice',b'Y',b'Y'
-b'DocType: Maintenance Visit',b'Maintenance Date',b'Onderhoud Datum'
-b'DocType: Purchase Invoice Item',b'Rejected Serial No',b'Afgewezen Serienummer'
-b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82',b'Year start date or end date is overlapping with {0}. To avoid please set company',b'Jaar begindatum of einddatum overlapt met {0}. Om te voorkomen dat stel bedrijf'
-b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +122',b'Please mention the Lead Name in Lead {0}',b'Vermeld alstublieft de naam van de lood in lood {0}'
-b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156',b'Start date should be less than end date for Item {0}',b'Startdatum moet kleiner zijn dan einddatum voor Artikel {0}'
-b'DocType: Item',"b'Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.'","b'Voorbeeld: ABCD.##### Als reeks is ingesteld en het serienummer is niet vermeld in een transactie, dan zal een serienummer automatisch worden aangemaakt, op basis van deze reeks. Als u altijd expliciet een serienummer wilt vemelden voor dit artikel bij een transatie, laat dan dit veld leeg.'"
-b'DocType: Upload Attendance',b'Upload Attendance',b'Aanwezigheid uploaden'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +579',b'BOM and Manufacturing Quantity are required',b'BOM en Productie Hoeveelheid nodig'
-b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50',b'Ageing Range 2',b'Vergrijzing Range 2'
-b'DocType: SG Creation Tool Course',b'Max Strength',b'Max Strength'
-b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28',b'Installing presets',b'Voorinstellingen installeren'
-b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85',b'No Delivery Note selected for Customer {}',b'Geen leveringsbewijs geselecteerd voor klant {}'
-b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25',b'BOM replaced',b'Stuklijst vervangen'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052',b'Select Items based on Delivery Date',b'Selecteer items op basis van leveringsdatum'
-b'DocType: Grant Application',b'Has any past Grant Record',b'Heeft een eerdere Grant Record'
-,b'Sales Analytics',b'Verkoop analyse'
-b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127',b'Available {0}',b'Beschikbaar {0}'
-,b'Prospects Engaged But Not Converted',b'Vooruitzichten betrokken maar niet omgezet'
-,b'Prospects Engaged But Not Converted',b'Vooruitzichten betrokken maar niet omgezet'
-b'DocType: Manufacturing Settings',b'Manufacturing Settings',b'Productie Instellingen'
-b'apps/erpnext/erpnext/config/setup.py +56',b'Setting up Email',b'Het opzetten van e-mail'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57',b'Guardian1 Mobile No',b'Guardian1 Mobile No'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106',b'Please enter default currency in Company Master',b'Vul de standaard valuta in in Bedrijfsstam'
-b'DocType: Stock Entry Detail',b'Stock Entry Detail',b'Voorraadtransactie Detail'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109',b'Daily Reminders',b'Dagelijkse herinneringen'
-b'DocType: Products Settings',b'Home Page is Products',b'Startpagina is Producten'
-,b'Asset Depreciation Ledger',b'Asset Afschrijvingen Ledger'
-b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91',b'Tax Rule Conflicts with {0}',b'Belasting Regel Conflicten met {0}'
-b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25',b'New Account Name',b'Nieuwe Rekening Naam'
-b'DocType: Purchase Invoice Item',b'Raw Materials Supplied Cost',b'Grondstoffen Leveringskosten'
-b'DocType: Selling Settings',b'Settings for Selling Module',b'Instellingen voor het verkopen van Module'
-b'DocType: Hotel Room Reservation',b'Hotel Room Reservation',b'Hotelkamerreservering'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115',b'Customer Service',b'Klantenservice'
-b'DocType: BOM',b'Thumbnail',b'Miniatuur'
-b'DocType: Item Customer Detail',b'Item Customer Detail',b'Artikel Klant Details'
-b'apps/erpnext/erpnext/config/hr.py +50',b'Offer candidate a Job.',b'Aanbieding kandidaat een baan.'
-b'DocType: Notification Control',b'Prompt for Email on Submission of',b'Vragen om E-mail op Indiening van'
-b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88',b'Total allocated leaves are more than days in the period',b'Totaal toegewezen bladeren zijn meer dan dagen in de periode'
-b'DocType: Land Unit',b'Linked Soil Analysis',b'Linked Soil Analysis'
-b'DocType: Pricing Rule',b'Percentage',b'Percentage'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70',b'Item {0} must be a stock Item',b'Artikel {0} moet een voorraadartikel zijn'
-b'DocType: Manufacturing Settings',b'Default Work In Progress Warehouse',b'Standaard Work In Progress Warehouse'
-b'apps/erpnext/erpnext/config/accounts.py +288',b'Default settings for accounting transactions.',b'Standaardinstellingen voor boekhoudkundige transacties.'
-b'DocType: Maintenance Visit',b'MV',b'MV'
-b'DocType: Restaurant',b'Default Tax Template',b'Standaard belasting sjabloon'
-b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66',b'{0} Students have been enrolled',b'{0} Studenten zijn ingeschreven'
-b'DocType: Fees',b'Student Details',b'Student Details'
-b'DocType: Purchase Invoice Item',b'Stock Qty',b'Aantal voorraad'
-b'DocType: Employee Loan',b'Repayment Period in Months',b'Terugbetaling Periode in maanden'
-b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26',b'Error: Not a valid id?',b'Fout: geen geldig id?'
-b'DocType: Naming Series',b'Update Series Number',b'Serienummer bijwerken'
-b'DocType: Account',b'Equity',b'Vermogen'
-b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78',"b""{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry""","b'{0} {1}: ""winst- en verliesrekening"" type account {2} niet toegestaan in Opening Ingave'"
-b'DocType: Sales Order',b'Printing Details',b'Afdrukken Details'
-b'DocType: Task',b'Closing Date',b'Afsluitingsdatum'
-b'DocType: Sales Order Item',b'Produced Quantity',b'Geproduceerd Aantal'
-b'DocType: Timesheet',b'Work Detail',b'Werkdetails'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126',b'Engineer',b'Ingenieur'
-b'DocType: Journal Entry',b'Total Amount Currency',b'Totaal bedrag Currency'
-b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38',b'Search Sub Assemblies',b'Zoeken Sub Assemblies'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171',b'Item Code required at Row No {0}',b'Artikelcode vereist bij rijnummer {0}'
-b'DocType: GST Account',b'SGST Account',b'SGST-account'
-b'apps/erpnext/erpnext/utilities/user_progress.py +154',b'Go to Items',b'Ga naar Items'
-b'DocType: Sales Partner',b'Partner Type',b'Partner Type'
-b'DocType: Purchase Taxes and Charges',b'Actual',b'Werkelijk'
-b'DocType: Restaurant Menu',b'Restaurant Manager',b'Restaurant manager'
-b'DocType: Authorization Rule',b'Customerwise Discount',b'Klantgebaseerde Korting'
-b'apps/erpnext/erpnext/config/projects.py +46',b'Timesheet for tasks.',b'Timesheet voor taken.'
-b'DocType: Purchase Invoice',b'Against Expense Account',b'Tegen Kostenrekening'
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282',b'Installation Note {0} has already been submitted',b'Installatie Opmerking {0} is al ingediend'
-b'DocType: Bank Reconciliation',b'Get Payment Entries',b'Krijg Betaling Entries'
-b'DocType: Quotation Item',b'Against Docname',b'Tegen Docname'
-b'DocType: SMS Center',b'All Employee (Active)',b'Alle medewerkers (Actief)'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9',b'View Now',b'Bekijk nu'
-b'DocType: BOM',b'Raw Material Cost',b'Grondstofprijzen'
-b'DocType: Item Reorder',b'Re-Order Level',b'Re-order Niveau'
-b'apps/erpnext/erpnext/projects/doctype/project/project.js +54',b'Gantt Chart',b'Gantt-diagram'
-b'DocType: Crop Cycle',b'Cycle Type',b'Type cyclus'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99',b'Part-time',b'Deeltijds'
-b'DocType: Employee',b'Applicable Holiday List',b'Toepasselijk Holiday Lijst'
-b'DocType: Employee',b'Cheque',b'Cheque'
-b'DocType: Training Event',b'Employee Emails',b'Medewerkers e-mails'
-b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60',b'Series Updated',b'Reeks bijgewerkt'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +159',b'Report Type is mandatory',b'Rapport type is verplicht'
-b'DocType: Item',b'Serial Number Series',b'Serienummer Reeksen'
-b'apps/erpnext/erpnext/buying/utils.py +68',b'Warehouse is mandatory for stock Item {0} in row {1}',b'Magazijn is verplicht voor voorraadartikel {0} in rij {1}'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45',b'Retail & Wholesale',b'Retail & Groothandel'
-b'DocType: Issue',b'First Responded On',b'Eerst gereageerd op'
-b'DocType: Website Item Group',b'Cross Listing of Item in multiple groups',b'Kruis Notering van Punt in meerdere groepen'
-b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90',b'Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}',b'Boekjaar Startdatum en Boekjaar Einddatum zijn al ingesteld voor het fiscale jaar {0}'
-b'DocType: Projects Settings',b'Ignore User Time Overlap',b'Negeer User Time Overlap'
-b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113',b'Clearance Date updated',b'Ontruiming Geactualiseerd'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Batch'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Batch'
-b'DocType: Stock Settings',b'Batch Identification',b'Batchidentificatie'
-b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132',b'Successfully Reconciled',b'Succesvol Afgeletterd'
-b'DocType: Request for Quotation Supplier',b'Download PDF',b'Download PDF'
-b'DocType: Work Order',b'Planned End Date',b'Geplande Einddatum'
-b'DocType: Shareholder',b'Hidden list maintaining the list of contacts linked to Shareholder',b'Verborgen lijst met de lijst met contacten gekoppeld aan Shareholder'
-b'apps/erpnext/erpnext/config/non_profit.py +63',b'Donor Type information.',b'Donor Type informatie.'
-b'DocType: Request for Quotation',b'Supplier Detail',b'Leverancier Detail'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100',b'Error in formula or condition: {0}',b'Fout in formule of aandoening: {0}'
-b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +99',b'Invoiced Amount',b'Factuurbedrag'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47',b'Criteria weights must add up to 100%',b'Criteriumgewichten moeten maximaal 100%'
-b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7',b'Attendance',b'Aanwezigheid'
-b'apps/erpnext/erpnext/public/js/pos/pos.html +115',b'Stock Items',b'Stock items'
-b'DocType: BOM',b'Materials',b'Materialen'
-b'DocType: Leave Block List',"b'If not checked, the list will have to be added to each Department where it has to be applied.'","b'Indien niet gecontroleerd, wordt de lijst worden toegevoegd aan elk Department waar het moet worden toegepast.'"
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111',b'Creating {0}',b'{0} maken'
-b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28',b'Source and Target Warehouse cannot be same',b'Bron en Target Warehouse kan niet hetzelfde zijn'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586',b'Posting date and posting time is mandatory',b'Plaatsingsdatum en -tijd is verplicht'
-b'apps/erpnext/erpnext/config/buying.py +76',b'Tax template for buying transactions.',b'Belasting sjabloon voor inkooptransacties .'
-,b'Item Prices',b'Artikelprijzen'
-b'DocType: Purchase Order',b'In Words will be visible once you save the Purchase Order.',b'In Woorden zijn zichtbaar zodra u de Inkooporder opslaat'
-b'DocType: Period Closing Voucher',b'Period Closing Voucher',b'Periode Closing Voucher'
-b'DocType: Consultation',b'Review Details',b'Details herzien'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185',b'The shareholder does not belong to this company',b'De aandeelhouder behoort niet tot dit bedrijf'
-b'DocType: Dosage Form',b'Dosage Form',b'Doseringsformulier'
-b'apps/erpnext/erpnext/config/selling.py +67',b'Price List master.',b'Prijslijst stam.'
-b'DocType: Task',b'Review Date',b'Herzieningsdatum'
-b'DocType: Company',b'Series for Asset Depreciation Entry (Journal Entry)',b'Serie voor de afschrijving van de waardevermindering'
-b'DocType: Membership',b'Member Since',b'Lid sinds'
-b'DocType: Purchase Invoice',b'Advance Payments',b'Advance Payments'
-b'DocType: Purchase Taxes and Charges',b'On Net Total',b'Op Netto Totaal'
-b'apps/erpnext/erpnext/controllers/item_variant.py +92',b'Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}',b'Waarde voor kenmerk {0} moet binnen het bereik van {1} tot {2} in de stappen van {3} voor post {4}'
-b'DocType: Restaurant Reservation',b'Waitlisted',b'wachtlijst'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +124',b'Currency can not be changed after making entries using some other currency',b'Valuta kan niet na het maken van data met behulp van een andere valuta worden veranderd'
-b'DocType: Shipping Rule',b'Fixed',b'vast'
-b'DocType: Vehicle Service',b'Clutch Plate',b'clutch Plate'
-b'DocType: Company',b'Round Off Account',b'Afronden Account'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93',b'Administrative Expenses',b'Administratie Kosten'
-b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18',b'Consulting',b'Consulting'
-b'DocType: Customer Group',b'Parent Customer Group',b'Bovenliggende klantgroep'
-b'DocType: Journal Entry',b'Subscription',b'Abonnement'
-b'DocType: Purchase Invoice',b'Contact Email',b'Contact E-mail'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11',b'Fee Creation Pending',b'Fee Creation In afwachting'
-b'DocType: Appraisal Goal',b'Score Earned',b'Verdiende Score'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241',b'Notice Period',b'Opzegtermijn'
-b'DocType: Asset Category',b'Asset Category Name',b'Asset Categorie Naam'
-b'apps/erpnext/erpnext/setup/doctype/territory/territory.js +13',b'This is a root territory and cannot be edited.',b'Dit is een basis regio en kan niet worden bewerkt .'
-b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5',b'New Sales Person Name',b'Nieuwe Sales Person Naam'
-b'DocType: Packing Slip',b'Gross Weight UOM',b'Bruto Gewicht Eenheid'
-b'DocType: Asset Maintenance Task',b'Preventive Maintenance',b'Preventief onderhoud'
-b'DocType: Delivery Note Item',b'Against Sales Invoice',b'Tegen Sales Invoice'
-b'DocType: Purchase Invoice',b'07-Others',b'07-Anderen'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151',b'Please enter serial numbers for serialized item ',b'Voer alstublieft de serienummers in voor het serienummer'
-b'DocType: Bin',b'Reserved Qty for Production',b'Aantal voorbehouden voor productie'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureNum',b'EcritureNum'
-b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. """,b'Verlaat het vinkje als u geen batch wilt overwegen tijdens het maken van cursussen op basis van cursussen.'
-b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. """,b'Verlaat het vinkje als u geen batch wilt overwegen tijdens het maken van cursussen op basis van cursussen.'
-b'DocType: Asset',b'Frequency of Depreciation (Months)',b'Frequentie van afschrijvingen (Maanden)'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500',b'Credit Account',b'Credit Account'
-b'DocType: Landed Cost Item',b'Landed Cost Item',b'Vrachtkosten Artikel'
-b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57',b'Show zero values',b'Toon nulwaarden'
-b'DocType: BOM',b'Quantity of item obtained after manufacturing / repacking from given quantities of raw materials',b'Hoeveelheid product verkregen na productie / herverpakken van de gegeven hoeveelheden grondstoffen'
-b'DocType: Lab Test',b'Test Group',b'Testgroep'
-b'DocType: Payment Reconciliation',b'Receivable / Payable Account',b'Vorderingen / Crediteuren Account'
-b'DocType: Delivery Note Item',b'Against Sales Order Item',b'Tegen Sales Order Item'
-b'DocType: Company',b'Company Logo',b'Bedrijfslogo'
-b'apps/erpnext/erpnext/stock/doctype/item/item.py +709',b'Please specify Attribute Value for attribute {0}',b'Geef aub attribuut Waarde voor kenmerk {0}'
-b'DocType: Item',b'Default Warehouse',b'Standaard Magazijn'
-b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45',b'Budget cannot be assigned against Group Account {0}',b'Budget kan niet tegen Group rekening worden toegewezen {0}'
-b'DocType: Healthcare Settings',b'Patient Registration',b'Pati\xc3\xabntregistratie'
-b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22',b'Please enter parent cost center',b'Vul bovenliggende kostenplaats in'
-b'DocType: Delivery Note',b'Print Without Amount',b'Printen zonder Bedrag'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57',b'Depreciation Date',b'afschrijvingen Date'
-,b'Work Orders in Progress',b'Werkorders in uitvoering'
-b'DocType: Issue',b'Support Team',b'Support Team'
-b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36',b'Expiry (In Days)',b'Vervallen (in dagen)'
-b'DocType: Appraisal',b'Total Score (Out of 5)',b'Totale Score (van de 5)'
-b'DocType: Fee Structure',b'FS.',b'FS.'
-b'DocType: Student Attendance Tool',b'Batch',b'Partij'
-b'DocType: Donor',b'Donor Type',b'Donor Type'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +27',b'Balance',b'Balans'
-b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66',b'Please select the Company',b'Selecteer het bedrijf'
-b'DocType: Room',b'Seating Capacity',b'zitplaatsen'
-b'DocType: Issue',b'ISS-',b'ISS'
-b'DocType: Lab Test Groups',b'Lab Test Groups',b'Lab Testgroepen'
-b'DocType: Project',b'Total Expense Claim (via Expense Claims)',b'Total Expense Claim (via declaraties)'
-b'DocType: GST Settings',b'GST Summary',b'GST Samenvatting'
-b'apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16',b'Please enable default incoming account before creating Daily Work Summary Group',b'Schakel standaard inkomende account in voordat u Daily Work Summary Group maakt'
-b'DocType: Assessment Result',b'Total Score',b'Totale score'
-b'DocType: Journal Entry',b'Debit Note',b'Debetnota'
-b'DocType: Stock Entry',b'As per Stock UOM',b'Per Stock Verpakking'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7',b'Not Expired',b'Niet Verlopen'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49',b'ValidDate',b'Geldige datum'
-b'DocType: Student Log',b'Achievement',b'Prestatie'
-b'DocType: Batch',b'Source Document Type',b'Bron Document Type'
-b'DocType: Batch',b'Source Document Type',b'Bron Document Type'
-b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24',b'Following course schedules were created',b'Volgende cursusroosters zijn gemaakt'
-b'DocType: Journal Entry',b'Total Debit',b'Totaal Debet'
-b'DocType: Manufacturing Settings',b'Default Finished Goods Warehouse',b'Standaard Finished Goods Warehouse'
-b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108',b'Please select Patient',b'Selecteer alstublieft Pati\xc3\xabnt'
-b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76',b'Sales Person',b'Verkoper'
-b'DocType: Hotel Room Package',b'Amenities',b'voorzieningen'
-b'apps/erpnext/erpnext/config/accounts.py +233',b'Budget and Cost Center',b'Begroting en Cost Center'
-b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65',b'Multiple default mode of payment is not allowed',b'Meerdere standaard betalingswijze is niet toegestaan'
-b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',b'for the',b'voor de'
-,b'Appointment Analytics',b'Benoemingsanalyse'
-b'DocType: Vehicle Service',b'Half Yearly',b'Halfjaarlijkse'
-b'DocType: Lead',b'Blog Subscriber',b'Blog Abonnee'
-b'DocType: Guardian',b'Alternate Number',b'Alternate Number'
-b'DocType: Healthcare Settings',b'Consultations in valid days',b'Overleg in geldige dagen'
-b'DocType: Assessment Plan Criteria',b'Maximum Score',b'maximum Score'
-b'apps/erpnext/erpnext/config/setup.py +83',b'Create rules to restrict transactions based on values.',b'Regels maken om transacties op basis van waarden te beperken.'
-b'DocType: Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts'
-b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49',b' Group Roll No',b'Groepsrolnummer'
-b'DocType: Batch',b'Manufacturing Date',b'Fabricage datum'
-b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9',b'Fee Creation Failed',b'Fee Creation mislukt'
-b'DocType: Opening Invoice Creation Tool',b'Create Missing Party',b'Ontbrekende partij maken'
-b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',b'Verlaat leeg als u studentengroepen per jaar maakt'
-b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',b'Verlaat leeg als u studentengroepen per jaar maakt'
-b'DocType: HR Settings',"b'If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day'","b'Indien aangevinkt, Totaal niet. van Werkdagen zal omvatten feestdagen, en dit zal de waarde van het salaris per dag te verminderen'"
-b'DocType: Purchase Invoice',b'Total Advance',b'Totaal Voorschot'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27',b'Change Template Code',b'Sjablooncode wijzigen'
-b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23',b'The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.',b'De Term Einddatum kan niet eerder dan de Term startdatum. Corrigeer de data en probeer het opnieuw.'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'Quot Count'
-b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'Quot Count'
-,b'BOM Stock Report',b'BOM Stock Report'
-b'DocType: Stock Reconciliation Item',b'Quantity Difference',b'Aantal Verschil'
-b'DocType: Employee Advance',b'EA-',b'EA-'
-b'DocType: Opportunity Item',b'Basic Rate',b'Basis Tarief'
-b'DocType: GL Entry',b'Credit Amount',b'Credit Bedrag'
-b'DocType: Cheque Print Template',b'Signatory Position',b'ondertekenaar Position'
-b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173',b'Set as Lost',b'Instellen als Verloren'
-b'DocType: Timesheet',b'Total Billable Hours',b'Totaal factureerbare uren'
-b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4',b'Payment Receipt Note',b'Betaling Ontvangst Opmerking'
-b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6',b'This is based on transactions against this Customer. See timeline below for details',b'Dit is gebaseerd op transacties tegen deze klant. Zie tijdlijn hieronder voor meer informatie'
-b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162',b'Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2}',b'Rij {0}: Toegewezen bedrag {1} moet kleiner zijn dan of gelijk aan Payment Entry bedrag {2}'
-b'DocType: Program Enrollment Tool',b'New Academic Term',b'Nieuwe academische termijn'
-,b'Course wise Assessment Report',b'Cursusverstandig beoordelingsrapport'
-b'DocType: Purchase Invoice',b'Availed ITC State/UT Tax',b'Bezet ITC State / UT Tax'
-b'DocType: Tax Rule',b'Tax Rule',b'Belasting Regel'
-b'DocType: Selling Settings',b'Maintain Same Rate Throughout Sales Cycle',b'Handhaaf zelfde tarief gedurende verkoopcyclus'
-b'DocType: Manufacturing Settings',b'Plan time logs outside Workstation Working Hours.',b'Plan tijd logs buiten Workstation Arbeidstijdenwet.'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115',b'Dr {0} does not have a Physician Schedule. Add it in Physician master',b'Dr. {0} heeft geen Physician Schedule. Voeg het toe in Physician-master'
-b'apps/erpnext/erpnext/public/js/pos/pos.html +98',b'Customers in Queue',b'Klanten in de wachtrij'
-b'DocType: Driver',b'Issuing Date',b'Afgifte datum'
-b'DocType: Student',b'Nationality',b'Nationaliteit'
-b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109',b'Submit this Work Order for further processing.',b'Dien deze werkbon in voor verdere verwerking.'
-,b'Items To Be Requested',b'Aan te vragen artikelen'
-b'DocType: Purchase Order',b'Get Last Purchase Rate',b'Get Laatst Purchase Rate'
-b'DocType: Company',b'Company Info',b'Bedrijfsinformatie'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1385',b'Select or add new customer',b'Selecteer of voeg nieuwe klant'
-b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173',b'Cost center is required to book an expense claim',b'Kostenplaats nodig is om een declaratie te boeken'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9',b'Application of Funds (Assets)',b'Toepassing van kapitaal (Activa)'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6',b'This is based on the attendance of this Employee',b'Dit is gebaseerd op de aanwezigheid van deze werknemer'
-b'DocType: Assessment Result',b'Summary',b'Overzicht'
-b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112',b'Mark Attendance',b'Mark Attendance'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494',b'Debit Account',b'Debetrekening'
-b'DocType: Fiscal Year',b'Year Start Date',b'Jaar Startdatum'
-b'DocType: Attendance',b'Employee Name',b'Werknemer Naam'
-b'DocType: Restaurant Order Entry Item',b'Restaurant Order Entry Item',b'Restaurantbestelling Item invoeren'
-b'DocType: Purchase Invoice',b'Rounded Total (Company Currency)',b'Afgerond Totaal (Bedrijfsvaluta)'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +96',b'Cannot covert to Group because Account Type is selected.',b'Kan niet omzetten naar groep omdat accounttype is geselecteerd.'
-b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260',b'{0} {1} has been modified. Please refresh.',b'{0} {1} is gewijzigd. Vernieuw aub.'
-b'DocType: Leave Block List',b'Stop users from making Leave Applications on following days.',b'Weerhoud gebruikers van het maken van verlofaanvragen op de volgende dagen.'
-b'DocType: Asset Maintenance Team',b'Maintenance Team Members',b'Onderhoudsteamleden'
-b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63',b'Purchase Amount',b'Aankoopbedrag'
-b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261',b'Supplier Quotation {0} created',b'Leverancier Offerte {0} aangemaakt'
-b'apps/erpnext/erpnext/accounts/report/financial_statements.py +103',b'End Year cannot be before Start Year',b'Eindjaar kan niet voor Start Jaar'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234',b'Employee Benefits',b'Employee Benefits'
-b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264',b'Packed quantity must equal quantity for Item {0} in row {1}',b'Verpakt hoeveelheid moet hoeveelheid die gelijk is voor post {0} in rij {1}'
-b'DocType: Work Order',b'Manufactured Qty',b'Geproduceerd Aantal'
-b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78',"b""The shares don't exist with the {0}""",b'De shares bestaan niet met de {0}'
-b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64',b'Invoice Created',b'Invoice Created'
-b'DocType: Asset',b'Out of Order',b'Out of Order'
-b'DocType: Purchase Receipt Item',b'Accepted Quantity',b'Geaccepteerd Aantal'
-b'DocType: Projects Settings',b'Ignore Workstation Time Overlap',b'Negeer overlapping werkstationtijd'
-b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +242',b'Please set a default Holiday List for Employee {0} or Company {1}',b'Stel een standaard Holiday-lijst voor Employee {0} of Company {1}'
-b'apps/erpnext/erpnext/accounts/party.py +30',b'{0}: {1} does not exists',b'{0}: {1} bestaat niet'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76',b'Select Batch Numbers',b'Selecteer batchnummers'
-b'apps/erpnext/erpnext/config/accounts.py +12',b'Bills raised to Customers.',b'Factureren aan Klanten'
-b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Project Id',b'Project Id'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534',b'Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}',b'Rij Geen {0}: Bedrag kan niet groter zijn dan afwachting Bedrag tegen Expense conclusie {1} zijn. In afwachting van Bedrag is {2}'
-b'DocType: Patient Service Unit',b'Medical Administrator',b'Medisch beheerder'
-b'DocType: Assessment Plan',b'Schedule',b'Plan'
-b'DocType: Account',b'Parent Account',b'Bovenliggende rekening'
-b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266',b'Available',b'beschikbaar'
-b'DocType: Quality Inspection Reading',b'Reading 3',b'Meting 3'
-b'DocType: Stock Entry',b'Source Warehouse Address',b'Bron magazijnadres'
-,b'Hub',b'Naaf'
-b'DocType: GL Entry',b'Voucher Type',b'Voucher Type'
-b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1717',b'Price List not found or disabled',b'Prijslijst niet gevonden of uitgeschakeld'
-b'DocType: Student Applicant',b'Approved',b'Aangenomen'
-b'apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15',b'Price',b'prijs'
-b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267',"b""Employee relieved on {0} must be set as 'Left'""","b""Werknemer ontslagen op {0} moet worden ingesteld als 'Verlaten'"""
-b'DocType: Hub Settings',b'Last Sync On',b'Last Sync On'
-b'DocType: Guardian',b'Guardian',b'Voogd'
-b'DocType: Opening Invoice Creation Tool',b'Create missing customer or supplier.',b'Ontbrekende klant of leverancier cre\xc3\xabren.'
-b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42',b'Appraisal {0} created for Employee {1} in the given date range',b'Beoordeling {0} gemaakt voor Employee {1} in de bepaalde periode'
-b'DocType: Academic Term',b'Education',b'Onderwijs'
-b'apps/erpnext/erpnext/public/js/pos/pos.html +89',b'Del',b'del'
-b'DocType: Selling Settings',b'Campaign Naming By',b'Campagnenaam gegeven door'
-b'DocType: Employee',b'Current Address Is',b'Huidige adres is'
-b'apps/erpnext/erpnext/utilities/user_progress.py +51',b'Monthly Sales Target (',b'Maandelijks verkoopdoel ('
-b'DocType: Physician Service Unit Schedule',b'Physician Service Unit Schedule',b'Physician Service Unit Schedule'
-b'apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9',b'modified',b'gemodificeerde'
-b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43',"b""Optional. Sets company's default currency, if not specified.""","b'Optioneel. Stelt bedrijf prijslijst, indien niet opgegeven.'"
-b'DocType: Sales Invoice',b'Customer GSTIN',b'Klant GSTIN'
-b'DocType: Crop Cycle',"b""List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease """,b'Lijst met gedetecteerde ziekten op het veld. Na selectie voegt het automatisch een lijst met taken toe om de ziekte aan te pakken'
-b'DocType: Asset Repair',b'Repair Status',b'Reparatiestatus'
-b'apps/erpnext/erpnext/config/accounts.py +67',b'Accounting journal entries.',b'Journaalposten.'
-b'DocType: Delivery Note Item',b'Available Qty at From Warehouse',b'Aantal beschikbaar bij Van Warehouse'
-b'DocType: POS Profile',b'Account for Change Amount',b'Account for Change Bedrag'
-b'DocType: Purchase Invoice',b'input service',b'invoerdienst'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217',b'Row {0}: Party / Account does not match with {1} / {2} in {3} {4}',b'Rij {0}: Party / Account komt niet overeen met {1} / {2} in {3} {4}'
-b'DocType: Maintenance Team Member',b'Maintenance Team Member',b'Onderhoudsteamlid'
-b'DocType: Agriculture Analysis Criteria',b'Soil Analysis',b'Bodemanalyse'
-b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13',b'Course Code: ',b'Cursuscode:'
-b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240',b'Please enter Expense Account',b'Vul Kostenrekening in'
-b'DocType: Account',b'Stock',b'Voorraad'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095',"b'Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry'","b'Rij # {0}: Reference document moet een van Purchase Order, Purchase Invoice of Inboeken zijn'"
-b'DocType: Employee',b'Current Address',b'Huidige adres'
-b'DocType: Item',"b'If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified'","b'Als artikel is een variant van een ander item dan beschrijving, afbeelding, prijzen, belastingen etc zal worden ingesteld van de sjabloon, tenzij expliciet vermeld'"
-b'DocType: Serial No',b'Purchase / Manufacture Details',b'Inkoop / Productie Details'
-b'DocType: Assessment Group',b'Assessment Group',b'assessment Group'
-b'apps/erpnext/erpnext/config/stock.py +329',b'Batch Inventory',b'Batch Inventory'
-b'DocType: Employee',b'Contract End Date',b'Contract Einddatum'
-b'DocType: Sales Order',b'Track this Sales Order against any Project',b'Volg dit Verkooporder tegen elke Project'
-b'DocType: Sales Invoice Item',b'Discount and Margin',b'Korting en Marge'
-b'DocType: Lab Test',b'Prescription',b'Voorschrift'
-b'DocType: Project',b'Second Email',b'Tweede e-mail'
-b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111',b'Not Available',b'niet beschikbaar'
-b'DocType: Pricing Rule',b'Min Qty',b'min Aantal'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36',b'Disable Template',b'Sjabloon uitschakelen'
-b'DocType: GL Entry',b'Transaction Date',b'Transactie Datum'
-b'DocType: Production Plan Item',b'Planned Qty',b'Gepland Aantal'
-b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121',b'Total Tax',b'Total Tax'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204',b'For Quantity (Manufactured Qty) is mandatory',b'Voor Hoeveelheid (Geproduceerd Aantal) is verplicht'
-b'DocType: Stock Entry',b'Default Target Warehouse',b'Standaard Doelmagazijn'
-b'DocType: Purchase Invoice',b'Net Total (Company Currency)',b'Netto Totaal (Bedrijfsvaluta)'
-b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14',b'The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.',b'Het Jaar Einddatum kan niet eerder dan het jaar startdatum. Corrigeer de data en probeer het opnieuw.'
-b'DocType: Notification Control',b'Purchase Receipt Message',b'Ontvangstbevestiging Bericht'
-b'DocType: BOM',b'Scrap Items',b'Scrap items'
-b'DocType: Work Order',b'Actual Start Date',b'Werkelijke Startdatum'
-b'DocType: Sales Order',b'% of materials delivered against this Sales Order',b'% van de geleverde materialen voor deze verkooporder'
-b'apps/erpnext/erpnext/config/manufacturing.py +18',b'Generate Material Requests (MRP) and Work Orders.',b'Generate Material Requests (MRP) en werkorders.'
-b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62',b'Set default mode of payment',b'Stel de standaard betalingswijze in'
-b'DocType: Grant Application',b'Withdrawn',b'teruggetrokken'
-b'DocType: Hub Settings',b'Hub Settings',b'Hub Instellingen'
-b'DocType: Project',b'Gross Margin %',b'Bruto marge %'
-b'DocType: BOM',b'With Operations',b'Met Operations'
-b'apps/erpnext/erpnext/accounts/party.py +259',b'Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.',b'Boekingen zijn reeds geboekt in valuta {0} voor bedrijf {1}. Selecteer een vordering of te betalen rekening met valuta {0}.'
-b'DocType: Asset',b'Is Existing Asset',b'Is Bestaande Asset'
-b'DocType: Salary Detail',b'Statistical Component',b'Statistische Component'
-b'DocType: Salary Detail',b'Statistical Component',b'Statistische Component'
-b'DocType: Warranty Claim',b'If different than customer address',b'Indien anders dan klantadres'
-b'DocType: Purchase Invoice',b'Without Payment of Tax',b'Zonder betaling van belasting'
-b'DocType: BOM Operation',b'BOM Operation',b'Stuklijst Operatie'
-b'apps/erpnext/erpnext/config/stock.py +141',b'Fulfilment',b'Vervulling'
-b'DocType: Purchase Taxes and Charges',b'On Previous Row Amount',b'Aantal van vorige rij'
-b'DocType: Item',b'Has Expiry Date',b'Heeft vervaldatum'
-b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +282',b'Transfer Asset',b'Transfer Asset'
-b'DocType: POS Profile',b'POS Profile',b'POS Profiel'
-b'DocType: Training Event',b'Event Name',b'Evenement naam'
-b'DocType: Physician',b'Phone (Office)',b'Telefoon (kantoor)'
-b'apps/erpnext/erpnext/hooks.py +151',b'Admission',b'Toelating'
-b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29',b'Admissions for {0}',b'Opnames voor {0}'
-b'apps/erpnext/erpnext/config/accounts.py +257',"b'Seasonality for setting budgets, targets etc.'","b'Seizoensgebondenheid voor het vaststellen van budgetten, doelstellingen etc.'"
-b'DocType: Supplier Scorecard Scoring Variable',b'Variable Name',b'Variabele naam'
-b'apps/erpnext/erpnext/stock/get_item_details.py +144',"b'Item {0} is a template, please select one of its variants'","b'Item {0} is een sjabloon, selecteert u \xc3\xa9\xc3\xa9n van de varianten'"
-b'DocType: Asset',b'Asset Category',b'Asset Categorie'
-b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31',b'Net pay cannot be negative',b'Nettoloon kan niet negatief zijn'
-b'DocType: Purchase Order',b'Advance Paid',b'Voorschot Betaald'
-b'DocType: Item',b'Item Tax',b'Artikel Belasting'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883',b'Material to Supplier',b'Materiaal aan Leverancier'
-b'DocType: Soil Texture',b'Loamy Sand',b'Leemachtige zand'
-b'DocType: Production Plan',b'Material Request Planning',b'Materiaal Verzoek Planning'
-b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +638',b'Excise Invoice',b'Accijnzen Factuur'
-b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16',b'Treshold {0}% appears more than once',b'Treshold {0}% meer dan eens'
-b'DocType: Expense Claim',b'Employees Email Id',b'Medewerkers E-mail ID'
-b'DocType: Employee Attendance Tool',b'Marked Attendance',b'Gemarkeerde Attendance'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138',b'Current Liabilities',b'Kortlopende Schulden'
-b'apps/erpnext/erpnext/config/selling.py +297',b'Send mass SMS to your contacts',b'Stuur massa SMS naar uw contacten'
-b'DocType: Patient',b'A Positive',b'Een positief'
-b'DocType: Program',b'Program Name',b'Programma naam'
-b'DocType: Purchase Taxes and Charges',b'Consider Tax or Charge for',b'Overweeg belasting of heffing voor'
-b'DocType: Driver',b'Driving License Category',b'Rijbewijscategorie'
-b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158',b'No Reference',b'Geen referentie'
-b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57',b'Actual Qty is mandatory',b'Werkelijke aantal is verplicht'
-b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',"b'{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.'","b'{0} heeft momenteel een {1} Leveranciers Scorecard, en er worden voorzichtige waarborgen uitgegeven bij inkooporders.'"
-b'DocType: Asset Maintenance Team',b'Asset Maintenance Team',b'Asset Maintenance Team'
-b'DocType: Employee Loan',b'Loan Type',b'Loan Type'
-b'DocType: Scheduling Tool',b'Scheduling Tool',b'scheduling Tool'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180',b'Credit Card',b'Kredietkaart'
-b'DocType: BOM',b'Item to be manufactured or repacked',b'Artikel te vervaardigen of herverpakken'
-b'DocType: Employee Education',b'Major/Optional Subjects',b'Major / keuzevakken'
-b'DocType: Sales Invoice Item',b'Drop Ship',b'Drop Ship'
-b'DocType: Driver',b'Suspended',b'Geschorst'
-b'DocType: Training Event',b'Attendees',b'Deelnemers'
-b'DocType: Employee',"b'Here you can maintain family details like name and occupation of parent, spouse and children'","b'Hier kunt u onderhouden familie gegevens zoals naam en beroep van de ouder, echtgenoot en kinderen'"
-b'DocType: Academic Term',b'Term End Date',b'Term Einddatum'
-b'DocType: Purchase Invoice',b'Taxes and Charges Deducted (Company Currency)',b'Belastingen en Toeslagen afgetrokken (Bedrijfsvaluta)'
-b'DocType: Item Group',b'General Settings',b'Algemene Instellingen'
-b'apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23',b'From Currency and To Currency cannot be same',b'Van Valuta en naar Valuta kan niet hetzelfde zijn'
-b'DocType: Stock Entry',b'Repack',b'Herverpakken'
-b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6',b'You must Save the form before proceeding',b'U moet het formulier opslaan voordat u verder gaat'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113',b'Please select the Company first',b'Selecteer eerst het bedrijf'
-b'DocType: Item Attribute',b'Numeric Values',b'Numerieke waarden'
-b'apps/erpnext/erpnext/public/js/setup_wizard.js +56',b'Attach Logo',b'Bevestig Logo'
-b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +51',b'Stock Levels',b'Stock Levels'
-b'DocType: Customer',b'Commission Rate',b'Commissie Rate'
-b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187',b'Created {0} scorecards for {1} between: ',b'Gecre\xc3\xaberd {0} scorecards voor {1} tussen:'
-b'apps/erpnext/erpnext/stock/doctype/item/item.js +505',b'Make Variant',b'Maak Variant'
-b'apps/erpnext/erpnext/config/hr.py +87',b'Block leave applications by department.',b'Blokkeer verlofaanvragen per afdeling.'
-b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155',"b'Payment Type must be one of Receive, Pay and Internal Transfer'","b'Betaling Type moet een van te ontvangen, betalen en Internal Transfer'"
-b'apps/erpnext/erpnext/config/selling.py +184',b'Analytics',b'analytics'
-b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25',b'Cart is Empty',b'Winkelwagen is leeg'
-b'DocType: Vehicle',b'Model',b'Model'
-b'DocType: Work Order',b'Actual Operating Cost',b'Werkelijke operationele kosten'
-b'DocType: Payment Entry',b'Cheque/Reference No',b'Cheque / Reference No'
-b'DocType: Soil Texture',b'Clay Loam',b'Clay Loam'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +81',b'Root cannot be edited.',b'Root kan niet worden bewerkt .'
-b'DocType: Item',b'Units of Measure',b'Meeteenheden'
-b'DocType: Manufacturing Settings',b'Allow Production on Holidays',b'Laat Productie op vakantie'
-b'DocType: Sales Invoice',"b""Customer's Purchase Order Date""",b'Inkooporder datum van Klant'
-b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163',b'Capital Stock',b'Kapitaal Stock'
-b'DocType: Shopping Cart Settings',b'Show Public Attachments',b'Publieke bijlagen tonen'
-b'DocType: Packing Slip',b'Package Weight Details',b'Pakket gewicht details'
-b'DocType: Restaurant Reservation',b'Reservation Time',b'Reservatietijd'
-b'DocType: Payment Gateway Account',b'Payment Gateway Account',b'Payment Gateway Account'
-b'DocType: Shopping Cart Settings',b'After payment completion redirect user to selected page.',b'Na betaling voltooiing omleiden gebruiker geselecteerde pagina.'
-b'DocType: Company',b'Existing Company',b'bestaande Company'
-b'DocType: Healthcare Settings',b'Result Emailed',b'Resultaat Emailed'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +87',"b'Tax Category has been changed to ""Total"" because all the Items are non-stock items'",b'Belastingcategorie is gewijzigd in &quot;Totaal&quot; omdat alle items niet-voorraad items zijn'
-b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103',b'Please select a csv file',b'Selecteer een CSV-bestand'
-b'DocType: Student Leave Application',b'Mark as Present',b'Mark als Cadeau'
-b'DocType: Supplier Scorecard',b'Indicator Color',b'Indicator Kleur'
-b'DocType: Purchase Order',b'To Receive and Bill',b'Te ontvangen en Bill'
-b'apps/erpnext/erpnext/controllers/buying_controller.py +445',b'Row #{0}: Reqd by Date cannot be before Transaction Date',b'Rij # {0}: Gewenste datum mag niet v\xc3\xb3\xc3\xb3r Transactiedatum liggen'
-b'apps/erpnext/erpnext/templates/pages/home.html +14',b'Featured Products',b'Aanbevolen producten'
-b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136',b'Designer',b'Ontwerper'
-b'apps/erpnext/erpnext/config/selling.py +163',b'Terms and Conditions Template',b'Algemene voorwaarden Template'
-b'DocType: Serial No',b'Delivery Details',b'Levering Details'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495',b'Cost Center is required in row {0} in Taxes table for type {1}',b'Kostenplaats is vereist in regel {0} in Belastingen tabel voor type {1}'
-b'DocType: Program',b'Program Code',b'programma Code'
-b'DocType: Terms and Conditions',b'Terms and Conditions Help',b'Voorwaarden Help'
-,b'Item-wise Purchase Register',b'Artikelgebaseerde Inkoop Register'
-b'DocType: Driver',b'Expiry Date',b'Vervaldatum'
-b'DocType: Healthcare Settings',b'Employee name and designation in print',b'Werknemer naam en aanduiding in print'
-,b'accounts-browser',b'accounts-browser'
-b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368',b'Please select Category first',b'Selecteer eerst een Categorie'
-b'apps/erpnext/erpnext/config/projects.py +13',b'Project master.',b'Project stam.'
-b'apps/erpnext/erpnext/controllers/status_updater.py +212',"b'To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.'","b'Om ervoor te zorgen over-facturering of over-bestellen, &quot;Allowance&quot; actualiseren Stock Settings of het item.'"
-b'DocType: Global Defaults',b'Do not show any symbol like $ etc next to currencies.',"b'Vertoon geen symbool zoals $, enz. naast valuta.'"
-b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431',b' (Half Day)',b'(Halve Dag)'
-b'DocType: Payment Term',b'Credit Days',b'Credit Dagen'
-b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145',b'Please select Patient to get Lab Tests',b'Selecteer Pati\xc3\xabnt om Lab-tests te krijgen'
-b'apps/erpnext/erpnext/utilities/activation.py +128',b'Make Student Batch',b'Maak Student Batch'
-b'DocType: Fee Schedule',b'FRQ.',b'FRQ.'
-b'DocType: Leave Type',b'Is Carry Forward',b'Is Forward Carry'
-b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841',b'Get Items from BOM',b'Artikelen ophalen van Stuklijst'
-b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Lead Time Days',b'Lead Time Dagen'
-b'DocType: Cash Flow Mapping',b'Is Income Tax Expense',b'Is de inkomstenbelasting'
-b'apps/erpnext/erpnext/controllers/accounts_controller.py +621',b'Row #{0}: Posting Date must be same as purchase date {1} of asset {2}',b'Rij # {0}: Plaatsingsdatum moet hetzelfde zijn als aankoopdatum {1} van de activa {2}'
-b'DocType: Program Enrollment',"b""Check this if the Student is residing at the Institute's Hostel.""",b'Controleer dit als de student in het hostel van het Instituut verblijft.'
-b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125',b'Please enter Sales Orders in the above table',b'Vul verkooporders in de bovenstaande tabel'
-,b'Stock Summary',b'Stock Samenvatting'
-b'apps/erpnext/erpnext/config/assets.py +54',b'Transfer an asset from one warehouse to another',b'Transfer een troef van het ene magazijn naar het andere'
-b'DocType: Vehicle',b'Petrol',b'Benzine'
-b'apps/erpnext/erpnext/config/learn.py +217',b'Bill of Materials',b'Stuklijst'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105',b'Row {0}: Party Type and Party is required for Receivable / Payable account {1}',b'Rij {0}: Party Type en Party is vereist voor Debiteuren / Crediteuren rekening {1}'
-b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94',b'Ref Date',b'Ref Date'
-b'DocType: Employee',b'Reason for Leaving',b'Reden voor vertrek'
-b'DocType: BOM Operation',b'Operating Cost(Company Currency)',b'Bedrijfskosten (Company Munt)'
-b'DocType: Employee Loan Application',b'Rate of Interest',b'Rentevoet'
-b'DocType: Expense Claim Detail',b'Sanctioned Amount',b'Gesanctioneerde Bedrag'
-b'DocType: Item',b'Shelf Life In Days',b'Houdbaarheid in dagen'
-b'DocType: GL Entry',b'Is Opening',b'Opent'
-b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196',b'Row {0}: Debit entry can not be linked with a {1}',b'Rij {0}: debitering niet kan worden verbonden met een {1}'
-b'DocType: Journal Entry',b'Subscription Section',b'Abonnementsafdeling'
-b'apps/erpnext/erpnext/accounts/doctype/account/account.py +177',b'Account {0} does not exist',b'Rekening {0} bestaat niet'
-b'DocType: Training Event',b'Training Program',b'Oefenprogramma'
-b'DocType: Account',b'Cash',b'Contant'
-b'DocType: Employee',b'Short biography for website and other publications.',b'Korte biografie voor website en andere publicaties.'
+DocType: Employee,Salary Mode,Salaris Modus
+DocType: Patient,Divorced,Gescheiden
+DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Toestaan Item om meerdere keren in een transactie worden toegevoegd
+apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Annuleren Materiaal Bezoek {0} voor het annuleren van deze Garantie Claim
+apps/erpnext/erpnext/config/education.py +118,Assessment Reports,Beoordelingsrapporten
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Consumentenproducten
+DocType: Purchase Receipt,Subscription Detail,Abonnement Detail
+DocType: Supplier Scorecard,Notify Supplier,Meld Leverancier in
+DocType: Item,Customer Items,Klant Items
+DocType: Project,Costing and Billing,Kostenberekening en facturering
+apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Rekening {0}: Bovenliggende rekening {1} kan geen grootboek zijn
+DocType: Item,Publish Item to hub.erpnext.com,Publiceer Item om hub.erpnext.com
+apps/erpnext/erpnext/config/setup.py +88,Email Notifications,E-mail Notificaties
+apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,evaluatie
+DocType: Item,Default Unit of Measure,Standaard Eenheid
+DocType: SMS Center,All Sales Partner Contact,Alle Sales Partner Contact
+DocType: Employee,Leave Approvers,Verlof goedkeurders
+DocType: Sales Partner,Dealer,Dealer
+DocType: Work Order,WO-,WO-
+DocType: Consultation,Investigations,onderzoeken
+DocType: Restaurant Order Entry,Click Enter To Add,Klik op Enter om toe te voegen
+DocType: Employee,Rented,Verhuurd
+DocType: Purchase Order,PO-,PO
+DocType: Vehicle Service,Mileage,Mileage
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +253,Do you really want to scrap this asset?,Wilt u dit actief echt schrappen?
+DocType: Drug Prescription,Update Schedule,Update Schema
+apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Selecteer Standaard Leverancier
+apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Munt is nodig voor prijslijst {0}
+DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Zal worden berekend in de transactie.
+DocType: Purchase Order,Customer Contact,Contactpersoon Klant
+DocType: Patient Appointment,Check availability,Beschikbaarheid controleren
+DocType: Job Applicant,Job Applicant,Sollicitant
+apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Dit is gebaseerd op transacties tegen deze leverancier. Zie tijdlijn hieronder voor meer informatie
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Wettelijk
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Werkelijke soort belasting kan niet worden opgenomen in post tarief in rij {0}
+DocType: Bank Guarantee,Customer,Klant
+DocType: Purchase Receipt Item,Required By,Benodigd op
+DocType: Delivery Note,Return Against Delivery Note,Terug Tegen Delivery Note
+DocType: Purchase Order,% Billed,% Gefactureerd
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Wisselkoers moet hetzelfde zijn als zijn {0} {1} ({2})
+DocType: Sales Invoice,Customer Name,Klantnaam
+DocType: Vehicle,Natural Gas,Natuurlijk gas
+apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Bankrekening kan niet worden genoemd als {0}
+DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Hoofden (of groepen) waartegen de boekingen worden gemaakt en saldi worden gehandhaafd.
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Openstaand bedrag voor {0} mag niet kleiner zijn dan nul ({1})
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348,There are no submitted Salary Slips to process.,Er zijn geen loonslips ingediend om te verwerken.
+DocType: Manufacturing Settings,Default 10 mins,Standaard 10 min
+DocType: Leave Type,Leave Type Name,Verlof Type Naam
+apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Toon geopend
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Het is noodzakelijk om deze actie vandaag zelf te nemen voor bovengenoemde herhalende
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156,Series Updated Successfully,Reeks succesvol bijgewerkt
+apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Uitchecken
+DocType: Pricing Rule,Apply On,toepassing op
+DocType: Item Price,Multiple Item prices.,Meerdere Artikelprijzen .
+,Purchase Order Items To Be Received,Inkooporder Artikelen nog te ontvangen
+DocType: SMS Center,All Supplier Contact,Alle Leverancier Contact
+DocType: Support Settings,Support Settings,ondersteuning Instellingen
+apps/erpnext/erpnext/projects/doctype/project/project.py +75,Expected End Date can not be less than Expected Start Date,Verwachte Einddatum kan niet minder dan verwacht Startdatum zijn
+apps/erpnext/erpnext/utilities/transaction_base.py +121,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Rij # {0}: Beoordeel moet hetzelfde zijn als zijn {1}: {2} ({3} / {4})
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241,New Leave Application,Nieuwe Verlofaanvraag
+,Batch Item Expiry Status,Batch Item Vervaldatum Status
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bankcheque
+DocType: Membership,membership validaty section,lidmaatschapsvalidatie
+DocType: Mode of Payment Account,Mode of Payment Account,Modus van Betaalrekening
+DocType: Consultation,Consultation,Overleg
+DocType: Accounts Settings,Show Payment Schedule in Print,Toon betalingsschema in Print
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Verkoop en retourneren
+apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Toon Varianten
+DocType: Academic Term,Academic Term,Academisch semester
+apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiaal
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Website maken
+DocType: Opening Invoice Creation Tool Item,Quantity,Hoeveelheid
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Rekeningtabel mag niet leeg zijn.
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Leningen (Passiva)
+DocType: Employee Education,Year of Passing,Voorbije Jaar
+DocType: Item,Country of Origin,Land van herkomst
+DocType: Soil Texture,Soil Texture Criteria,Bodemtextuurcriteria
+apps/erpnext/erpnext/templates/includes/product_page.js +25,In Stock,Op Voorraad
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Primaire contactgegevens
+apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Open Issues
+DocType: Production Plan Item,Production Plan Item,Productie Plan Artikel
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Gebruiker {0} is al aan Werknemer toegewezen {1}
+DocType: Lab Test Groups,Add new line,Voeg een nieuwe regel toe
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Gezondheidszorg
+apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Vertraging in de betaling (Dagen)
+DocType: Payment Terms Template Detail,Payment Terms Template Detail,Betalingsvoorwaarden sjabloondetail
+DocType: Hotel Room Reservation,Guest Name,Gast naam
+DocType: Lab Prescription,Lab Prescription,Lab Prescription
+,Delay Days,Vertragingen dagen
+apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,dienst Expense
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899,Serial Number: {0} is already referenced in Sales Invoice: {1},Serienummer: {0} is reeds verwezen in de verkoopfactuur: {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889,Invoice,Factuur
+DocType: Purchase Invoice Item,Item Weight Details,Item Gewicht Details
+DocType: Asset Maintenance Log,Periodicity,Periodiciteit
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Boekjaar {0} is vereist
+DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,De minimale afstand tussen rijen planten voor optimale groei
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Defensie
+DocType: Salary Component,Abbr,Afk
+DocType: Appraisal Goal,Score (0-5),Score (0-5)
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,Row {0}: {1} {2} does not match with {3},Rij {0}: {1} {2} niet overeenkomt met {3}
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77,Row # {0}:,Rij # {0}:
+DocType: Timesheet,Total Costing Amount,Totaal bedrag Costing
+DocType: Delivery Note,Vehicle No,Voertuig nr.
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163,Please select Price List,Selecteer Prijslijst
+DocType: Accounts Settings,Currency Exchange Settings,Valutaveursinstellingen
+apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Betaling document is vereist om de trasaction voltooien
+DocType: Work Order Operation,Work In Progress,Onderhanden Werk
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Kies een datum
+DocType: Daily Work Summary Group,Holiday List,Holiday Lijst
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Accountant
+DocType: Hub Settings,Selling Price List,Verkoopprijslijst
+DocType: Patient,Tobacco Current Use,Tabaksgebruik
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Verkoopcijfers
+DocType: Cost Center,Stock User,Aandeel Gebruiker
+DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
+DocType: Company,Phone No,Telefoonnummer
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239,New {0}: #{1},Nieuwe {0}: # {1}
+DocType: Delivery Trip,Initial Email Notification Sent,E-mailkennisgeving verzonden
+,Sales Partners Commission,Verkoop Partners Commissie
+DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
+DocType: Purchase Invoice,Rounding Adjustment,Afrondingsaanpassing
+apps/erpnext/erpnext/setup/doctype/company/company.py +46,Abbreviation cannot have more than 5 characters,Afkorting kan niet meer dan 5 tekens lang zijn
+DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Tijdschema voor arts Schema
+DocType: Payment Request,Payment Request,Betalingsverzoek
+DocType: Asset,Value After Depreciation,Restwaarde
+DocType: Student,O+,O +
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,Verwant
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Aanwezigheid datum kan niet lager zijn dan het samenvoegen van de datum werknemer zijn
+DocType: Grading Scale,Grading Scale Name,Grading Scale Naam
+DocType: Subscription,Repeat on Day,Herhaal op dag
+apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,Dit is een basisrekening en kan niet worden bewerkt.
+DocType: Sales Invoice,Company Address,bedrijfsadres
+DocType: BOM,Operations,Bewerkingen
+apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Kan de autorisatie niet instellen op basis van korting voor {0}
+DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Bevestig .csv-bestand met twee kolommen, één voor de oude naam en één voor de nieuwe naam"
+apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} in geen enkel actief fiscale jaar.
+DocType: Packed Item,Parent Detail docname,Bovenliggende Detail docname
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Referentie: {0}, Artikelcode: {1} en klant: {2}"
+apps/erpnext/erpnext/utilities/user_progress.py +146,Kg,kg
+apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Vacature voor een baan.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114,BOM is not specified for subcontracting item {0} at row {1},Stuklijst is niet gespecificeerd voor uitbesteding van item {0} in rij {1}
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Resultaat ingediend
+DocType: Item Attribute,Increment,Aanwas
+apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Tijdspanne
+apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Warehouse...,Kies Warehouse ...
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Adverteren
+apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Hetzelfde bedrijf is meer dan één keer ingevoerd
+DocType: Patient,Married,Getrouwd
+apps/erpnext/erpnext/accounts/party.py +41,Not permitted for {0},Niet toegestaan voor {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Krijgen items uit
+DocType: Price List,Price Not UOM Dependant,Prijs niet afhankelijk van UOM
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467,Stock cannot be updated against Delivery Note {0},Voorraad kan niet worden bijgewerkt obv Vrachtbrief {0}
+apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Product {0}
+apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Geen artikelen vermeld
+DocType: Asset Repair,Error Description,Foutbeschrijving
+DocType: Payment Reconciliation,Reconcile,Afletteren
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Kruidenierswinkel
+DocType: Quality Inspection Reading,Reading 1,Meting 1
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,pensioenfondsen
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,Volgende afschrijvingen datum kan niet vóór Aankoopdatum
+DocType: Crop,Perennial,eeuwigdurend
+DocType: Consultation,Consultation Date,Raadplegingsdatum
+DocType: Accounts Settings,Use Custom Cash Flow Format,Gebruik aangepaste kasstroomindeling
+DocType: SMS Center,All Sales Person,Alle Sales Person
+DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Maandelijkse Distributie ** helpt u om de begroting / Target verdelen over maanden als u de seizoensgebondenheid in uw bedrijf.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1753,Not items found,Niet artikelen gevonden
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184,Salary Structure Missing,Salarisstructuur Missing
+DocType: Lead,Person Name,Persoon Naam
+DocType: Sales Invoice Item,Sales Invoice Item,Verkoopfactuur Artikel
+DocType: Account,Credit,Krediet
+DocType: POS Profile,Write Off Cost Center,Afschrijvingen kostenplaats
+apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",bijvoorbeeld &quot;Primary School&quot; of &quot;University&quot;
+apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Stock Reports
+DocType: Warehouse,Warehouse Detail,Magazijn Detail
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,De Term Einddatum kan niet later dan het jaar Einddatum van het studiejaar waarop de term wordt gekoppeld zijn (Academisch Jaar {}). Corrigeer de data en probeer het opnieuw.
+apps/erpnext/erpnext/stock/doctype/item/item.py +269,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Is vaste activa"" kan niet worden uitgeschakeld, als Asset record bestaat voor dit item"
+DocType: Delivery Trip,Departure Time,Vertrektijd
+DocType: Vehicle Service,Brake Oil,remolie
+DocType: Tax Rule,Tax Type,Belasting Type
+,Completed Work Orders,Voltooide werkorders
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +581,Taxable Amount,Belastbaar bedrag
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},U bent niet bevoegd om items toe te voegen of bij te werken voor {0}
+DocType: BOM,Item Image (if not slideshow),Artikel Afbeelding (indien niet diashow)
+DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Uurtarief / 60) * Werkelijk Gepresteerde Tijd
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Rij # {0}: Referentiedocumenttype moet één van de kostenrekening of het journaalboekje zijn
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975,Select BOM,Select BOM
+DocType: SMS Log,SMS Log,SMS Log
+apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Kosten van geleverde zaken
+apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Beheer vooraf bedrag gegeven aan de werknemer
+apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,De vakantie op {0} is niet tussen Van Datum en To Date
+DocType: Student Log,Student Log,student Log
+apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Sjablonen van leveranciers standings.
+DocType: Lead,Interested,Geïnteresseerd
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216,Opening,Opening
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Van {0} tot {1}
+apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234,Program: ,Programma:
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Het instellen van belastingen is mislukt
+DocType: Item,Copy From Item Group,Kopiëren van Item Group
+DocType: Delivery Trip,Delivery Notification,Bezorg notificatie
+DocType: Journal Entry,Opening Entry,Opening Entry
+apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Rekening betalen enkel
+DocType: Employee Loan,Repay Over Number of Periods,Terug te betalen gedurende een aantal perioden
+DocType: Stock Entry,Additional Costs,Bijkomende kosten
+apps/erpnext/erpnext/accounts/doctype/account/account.py +138,Account with existing transaction can not be converted to group.,Rekening met bestaande transactie kan niet worden omgezet naar een groep .
+DocType: Lead,Product Enquiry,Product Aanvraag
+DocType: Education Settings,Validate Batch for Students in Student Group,Batch valideren voor studenten in de studentengroep
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Geen verlof gevonden record voor werknemer {0} voor {1}
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Vul aub eerst bedrijf in
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365,Please select Company first,Selecteer Company eerste
+DocType: Employee Education,Under Graduate,Student zonder graad
+apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Doel op
+DocType: BOM,Total Cost,Totale kosten
+DocType: Soil Analysis,Ca/K,Ca / K
+DocType: Journal Entry Account,Employee Loan,werknemer Loan
+DocType: Fee Schedule,Send Payment Request Email,Stuur een e-mail voor betalingsverzoek
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268,Item {0} does not exist in the system or has expired,Artikel {0} bestaat niet in het systeem of is verlopen
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Vastgoed
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Rekeningafschrift
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmacie
+DocType: Purchase Invoice Item,Is Fixed Asset,Is vaste activa
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273,"Available qty is {0}, you need {1}","Beschikbare aantal is {0}, moet u {1}"
+DocType: Expense Claim Detail,Claim Amount,Claim Bedrag
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +657,Work Order has been {0},Werkorder is {0}
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Duplicate klantengroep in de cutomer groep tafel
+apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Leverancier Type / leverancier
+DocType: Naming Series,Prefix,Voorvoegsel
+apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Gebeurtenis Locatie
+DocType: Asset Settings,Asset Settings,Activuminstellingen
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Verbruiksartikelen
+DocType: Student,B-,B-
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98,Successfully unregistered.,Succesvol afgemeld.
+DocType: Assessment Result,Grade,Rang
+DocType: Restaurant Table,No of Seats,Aantal zitplaatsen
+DocType: Subscription,"To add dynamic subject, use jinja tags like
+
+<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Om dynamisch onderwerp toe te voegen, gebruik jinja tags zoals <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
+DocType: Sales Invoice Item,Delivered By Supplier,Geleverd door Leverancier
+DocType: Asset Maintenance Task,Asset Maintenance Task,Asset Maintenance Task
+DocType: SMS Center,All Contact,Alle Contact
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Annual Salary,Jaarsalaris
+DocType: Daily Work Summary,Daily Work Summary,Dagelijks Werk Samenvatting
+DocType: Period Closing Voucher,Closing Fiscal Year,Het sluiten van het fiscale jaar
+apps/erpnext/erpnext/accounts/party.py +392,{0} {1} is frozen,{0} {1} is bevroren
+apps/erpnext/erpnext/setup/doctype/company/company.py +140,Please select Existing Company for creating Chart of Accounts,Kies een bestaand bedrijf voor het maken van Rekeningschema
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Voorraadkosten
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Selecteer Target Warehouse
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Selecteer Target Warehouse
+apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Vul Preferred Contact E-mail
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxNum,CompAuxNum
+DocType: Journal Entry,Contra Entry,Contra Entry
+DocType: Journal Entry Account,Credit in Company Currency,Credit Company in Valuta
+DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
+DocType: Delivery Note,Installation Status,Installatie Status
+DocType: BOM,Quality Inspection Template,Kwaliteitscontrolesjabloon
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
+					<br>Absent: {1}",Wilt u aanwezig updaten? <br> Aanwezig: {0} \ <br> Afwezig: {1}
+apps/erpnext/erpnext/controllers/buying_controller.py +350,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Geaccepteerde + Verworpen Aantal moet gelijk zijn aan Ontvangen aantal zijn voor Artikel {0}
+DocType: Request for Quotation,RFQ-,RFQ-
+DocType: Item,Supply Raw Materials for Purchase,Supply Grondstoffen voor Aankoop
+DocType: Agriculture Analysis Criteria,Fertilizer,Kunstmest
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152,At least one mode of payment is required for POS invoice.,Ten minste één wijze van betaling is vereist voor POS factuur.
+DocType: Products Settings,Show Products as a List,Producten weergeven als een lijst
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +534,Item {0} is not active or end of life has been reached,ARtikel {0} is niet actief of heeft einde levensduur bereikt
+DocType: Student Admission Program,Minimum Age,Minimum leeftijd
+apps/erpnext/erpnext/utilities/user_progress.py +190,Example: Basic Mathematics,Voorbeeld: Basiswiskunde
+DocType: Customer,Primary Address,hoofdadres
+DocType: Production Plan,Material Request Detail,Materiaal Verzoek Detail
+DocType: Selling Settings,Default Quotation Validity Days,Standaard prijsofferte dagen
+apps/erpnext/erpnext/controllers/accounts_controller.py +800,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Om Belastingen op te nemen in het Artikeltarief in rij {0}, moeten de belastingen in rijen {1} ook worden opgenomen"
+apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Instellingen voor HR Module
+DocType: SMS Center,SMS Center,SMS Center
+DocType: Sales Invoice,Change Amount,Change Bedrag
+DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Factuurwaarde instellen voor B2C. B2CL en B2CS berekend op basis van deze factuurwaarde.
+DocType: BOM Update Tool,New BOM,Nieuwe Eenheid
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Toon alleen POS
+DocType: Driver,Driving License Categories,Rijbewijscategorieën
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Vul de Leveringsdatum in
+DocType: Depreciation Schedule,Make Depreciation Entry,Maak Afschrijvingen Entry
+DocType: Appraisal Template Goal,KRA,KRA
+DocType: Lead,Request Type,Aanvraag type
+apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17,Make Employee,maak Employee
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Uitzenden
+apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Setup-modus van POS (online / offline)
+DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Hiermee wordt het maken van tijdregistraties tegen werkorders uitgeschakeld. Bewerkingen worden niet getraceerd op werkorder
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Uitvoering
+apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Details van de uitgevoerde handelingen.
+DocType: Asset Maintenance Log,Maintenance Status,Onderhoud Status
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Lidmaatschap details
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Leverancier is vereist tegen Te Betalen account {2}
+apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Artikelen en prijzen
+apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Totaal aantal uren: {0}
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Van Datum moet binnen het boekjaar zijn. Er vanuit gaande dat Van Datum {0} is
+DocType: Drug Prescription,Interval,Interval
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253,Preference,Voorkeur
+DocType: Grant Application,Individual,Individueel
+DocType: Academic Term,Academics User,Academici Gebruiker
+DocType: Cheque Print Template,Amount In Figure,Bedrag In figuur
+DocType: Employee Loan Application,Loan Info,Loan Info
+apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plan voor onderhoud bezoeken.
+DocType: Supplier Scorecard Period,Supplier Scorecard Period,Leverancier Scorecard Periode
+DocType: Share Transfer,Share Transfer,Deel overdracht
+DocType: POS Profile,Customer Groups,Doelgroepen
+apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Jaarrekening
+DocType: Guardian,Students,leerlingen
+apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Regels voor de toepassing van prijzen en kortingen .
+DocType: Daily Work Summary,Daily Work Summary Group,Daily Work Summary Group
+DocType: Physician Schedule,Time Slots,Time Slots
+apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Prijslijst moet van toepassing zijn op Inkoop of Verkoop
+apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},De installatie mag niet vóór leveringsdatum voor post {0}
+DocType: Pricing Rule,Discount on Price List Rate (%),Korting op de prijslijst Rate (%)
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Artikel sjabloon
+apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biochemie
+DocType: Job Offer,Select Terms and Conditions,Select Voorwaarden
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Out Value,out Value
+DocType: Production Plan,Sales Orders,Verkooporders
+DocType: Purchase Taxes and Charges,Valuation,Waardering
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +394,Set as Default,Instellen als standaard
+DocType: Production Plan,PLN-,PLN-
+,Purchase Order Trends,Inkooporder Trends
+apps/erpnext/erpnext/utilities/user_progress.py +78,Go to Customers,Ga naar klanten
+DocType: Hotel Room Reservation,Late Checkin,Late check-in
+apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Het verzoek voor een offerte kan worden geopend door te klikken op de volgende link
+apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Toewijzen verloven voor het gehele jaar.
+DocType: SG Creation Tool Course,SG Creation Tool Course,SG Creation Tool Course
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275,Insufficient Stock,onvoldoende Stock
+DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Uitschakelen Capacity Planning en Time Tracking
+DocType: Email Digest,New Sales Orders,Nieuwe Verkooporders
+DocType: Bank Guarantee,Bank Account,Bankrekening
+DocType: Leave Type,Allow Negative Balance,Laat negatief saldo
+apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',U kunt projecttype &#39;extern&#39; niet verwijderen
+apps/erpnext/erpnext/public/js/utils.js +194,Select Alternate Item,Selecteer alternatief item
+DocType: Employee,Create User,Gebruiker aanmaken
+DocType: Selling Settings,Default Territory,Standaard Regio
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,televisie
+DocType: Work Order Operation,Updated via 'Time Log',Bijgewerkt via 'Time Log'
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +430,Advance amount cannot be greater than {0} {1},Advance bedrag kan niet groter zijn dan {0} {1}
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,JournalCode
+DocType: Naming Series,Series List for this Transaction,Reeks voor deze transactie
+DocType: Company,Enable Perpetual Inventory,Perpetual Inventory inschakelen
+DocType: Company,Default Payroll Payable Account,Default Payroll Payable Account
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Pas E-Group
+DocType: Sales Invoice,Is Opening Entry,Wordt Opening Entry
+DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Als het selectievakje niet is ingeschakeld, verschijnt het item niet in de verkoopfactuur, maar kan u deze gebruiken bij het maken van groepsopdrachten."
+DocType: Customer Group,Mention if non-standard receivable account applicable,Vermeld als niet-standaard te ontvangen houdend met de toepasselijke
+DocType: Course Schedule,Instructor Name,instructeur Naam
+DocType: Supplier Scorecard,Criteria Setup,Criteria Setup
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206,For Warehouse is required before Submit,Voor Magazijn is vereist voor het Indienen
+apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Ontvangen op
+DocType: Sales Partner,Reseller,Reseller
+DocType: Codification Table,Medical Code,Medisch code
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Vul Bedrijf in
+DocType: Delivery Note Item,Against Sales Invoice Item,Tegen Sales Invoice Item
+DocType: Agriculture Analysis Criteria,Linked Doctype,Gekoppeld Doctype
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44,Net Cash from Financing,De netto kasstroom uit financieringsactiviteiten
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2371,"LocalStorage is full , did not save","LocalStorage vol is, niet te redden"
+DocType: Lead,Address & Contact,Adres &amp; Contact
+DocType: Leave Allocation,Add unused leaves from previous allocations,Voeg ongebruikte bladeren van de vorige toewijzingen
+DocType: Sales Partner,Partner website,partner website
+DocType: Restaurant Order Entry,Add Item,Item toevoegen
+DocType: Lab Test,Custom Result,Aangepast resultaat
+DocType: Delivery Stop,Contact Name,Contact Naam
+DocType: Course Assessment Criteria,Course Assessment Criteria,Cursus Beoordelingscriteria
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +27,Tax Id: ,BTW-nummer:
+apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216,Student ID: ,Student-ID:
+DocType: POS Customer Group,POS Customer Group,POS Customer Group
+DocType: Land Unit,Land Unit describing various land assets,Landeenheid beschrijft verschillende terreinen
+DocType: Cheque Print Template,Line spacing for amount in words,Regelafstand voor het bedrag in woorden
+DocType: Vehicle,Additional Details,Overige gegevens
+apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Geen beschrijving gegeven
+apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Inkoopaanvraag
+DocType: Lab Test,Submitted Date,Datum indienen
+apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Dit is gebaseerd op de Time Sheets gemaakt tegen dit project
+,Open Work Orders,Open werkorders
+DocType: Payment Term,Credit Months,Kredietmaanden
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Nettoloon kan niet lager zijn dan 0
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Om te stoppen met het verzenden van herhaalde foutmeldingen van het systeem, hebben we het veld Uitgeschakeld in het abonnement gecontroleerd"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Ontslagdatum moet groter zijn dan datum van indiensttreding
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240,Leaves per Year,Verlaat per jaar
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,Rij {0}: Kijk 'Is Advance' tegen Account {1} als dit is een voorschot binnenkomst.
+apps/erpnext/erpnext/stock/utils.py +219,Warehouse {0} does not belong to company {1},Magazijn {0} behoort niet tot bedrijf {1}
+DocType: Email Digest,Profit & Loss,Verlies
+apps/erpnext/erpnext/utilities/user_progress.py +147,Litre,liter
+DocType: Task,Total Costing Amount (via Time Sheet),Totaal bedrag Costing (via Urenregistratie)
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76,Please setup Students under Student Groups,Stel de studenten onder Student Groups in
+DocType: Item Website Specification,Item Website Specification,Artikel Website Specificatie
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449,Leave Blocked,Verlof Geblokkeerd
+apps/erpnext/erpnext/stock/doctype/item/item.py +740,Item {0} has reached its end of life on {1},Artikel {0} heeft het einde van zijn levensduur bereikt op {1}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83,Bank Entries,Bank Gegevens
+DocType: Crop,Annual,jaar-
+DocType: Stock Reconciliation Item,Stock Reconciliation Item,Voorraad Afletteren Artikel
+DocType: Stock Entry,Sales Invoice No,Verkoopfactuur nr.
+DocType: Material Request Item,Min Order Qty,Minimum Aantal
+DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Student Group Creation Tool Course
+DocType: Lead,Do Not Contact,Neem geen contact op
+apps/erpnext/erpnext/utilities/user_progress.py +210,People who teach at your organisation,Mensen die lesgeven op uw organisatie
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Software Ontwikkelaar
+DocType: Item,Minimum Order Qty,Minimum bestel aantal
+DocType: Pricing Rule,Supplier Type,Leverancier Type
+DocType: Course Scheduling Tool,Course Start Date,Cursus Startdatum
+,Student Batch-Wise Attendance,Student Batch-Wise Attendance
+DocType: POS Profile,Allow user to edit Rate,Zodat de gebruiker te bewerken Rate
+DocType: Item,Publish in Hub,Publiceren in Hub
+DocType: Student Admission,Student Admission,student Toelating
+,Terretory,Regio
+apps/erpnext/erpnext/stock/doctype/item/item.py +762,Item {0} is cancelled,Artikel {0} is geannuleerd
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064,Material Request,Materiaal Aanvraag
+DocType: Bank Reconciliation,Update Clearance Date,Werk Clearance Datum bij
+,GSTR-2,GSTR-2
+DocType: Item,Purchase Details,Inkoop Details
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +408,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Item {0} niet gevonden in &#39;Raw Materials geleverd&#39; tafel in Purchase Order {1}
+DocType: Salary Slip,Total Principal Amount,Totaal hoofdbedrag
+DocType: Student Guardian,Relation,Relatie
+DocType: Student Guardian,Mother,Moeder
+DocType: Restaurant Reservation,Reservation End Time,Eindtijd van reservering
+DocType: Crop,Biennial,tweejarig
+apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Bevestigde orders van klanten.
+DocType: Purchase Receipt Item,Rejected Quantity,Afgewezen Aantal
+apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Betalingsverzoek {0} gemaakt
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Open Orders,Openstaande bestellingen
+apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Lage gevoeligheid
+DocType: Notification Control,Notification Control,Notificatie Beheer
+apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Bevestig alstublieft nadat u uw opleiding hebt voltooid
+DocType: Lead,Suggestions,Suggesties
+DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Item Group-wise budgetten op dit gebied. U kunt ook seizoensinvloeden door de Distribution.
+DocType: Payment Term,Payment Term Name,Betalingstermijn
+DocType: Healthcare Settings,Create documents for sample collection,Maak documenten voor het verzamelen van samples
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Betaling tegen {0} {1} kan niet groter zijn dan openstaande bedrag te zijn {2}
+DocType: Shareholder,Address HTML,Adres HTML
+DocType: Lead,Mobile No.,Mobiel nummer
+DocType: Maintenance Schedule,Generate Schedule,Genereer Plan
+DocType: Purchase Invoice Item,Expense Head,Kosten Hoofd
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138,Please select Charge Type first,Selecteer eerst een Charge Type
+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.. ","U kunt hier alle taken definiëren die voor dit gewas moeten worden uitgevoerd. Het dagveld wordt gebruikt om de dag te vermelden waarop de taak moet worden uitgevoerd, waarbij 1 de eerste dag is, enzovoort."
+DocType: Student Group Student,Student Group Student,Student Group Student
+apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,laatst
+DocType: Asset Maintenance Task,2 Yearly,2 Jaarlijks
+DocType: Education Settings,Education Settings,Onderwijsinstellingen
+DocType: Vehicle Service,Inspection,Inspectie
+DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
+DocType: Email Digest,New Quotations,Nieuwe Offertes
+DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Emails loonstrook van medewerkers op basis van de voorkeur e-mail geselecteerd in Employee
+DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,De eerste Verlofgoedkeurder in de lijst wordt als de standaard Verlofgoedkeurder ingesteld
+DocType: Tax Rule,Shipping County,verzending County
+apps/erpnext/erpnext/config/desktop.py +167,Learn,Leren
+DocType: Asset,Next Depreciation Date,Volgende Afschrijvingen Date
+apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Activiteitskosten per werknemer
+DocType: Accounts Settings,Settings for Accounts,Instellingen voor accounts
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673,Supplier Invoice No exists in Purchase Invoice {0},Leverancier factuur nr bestaat in Purchase Invoice {0}
+apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Beheer Sales Person Boom .
+DocType: Job Applicant,Cover Letter,Voorblad
+apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Uitstekende Cheques en Deposito&#39;s te ontruimen
+DocType: Item,Synced With Hub,Gesynchroniseerd met Hub
+DocType: Driver,Fleet Manager,Fleet Manager
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} kan niet negatief voor producten van post {2}
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Verkeerd Wachtwoord
+DocType: Item,Variant Of,Variant van
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406,Completed Qty can not be greater than 'Qty to Manufacture',Voltooid aantal mag niet groter zijn dan 'Aantal te produceren'
+DocType: Period Closing Voucher,Closing Account Head,Sluiten Account Hoofd
+DocType: Employee,External Work History,Externe Werk Geschiedenis
+apps/erpnext/erpnext/projects/doctype/task/task.py +111,Circular Reference Error,Kringverwijzing Error
+apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206,Student Report Card,Studentenrapportkaart
+DocType: Appointment Type,Is Inpatient,Is een patiënt
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1 Naam
+DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,In woorden (Export) wordt zichtbaar zodra u de vrachtbrief opslaat.
+DocType: Cheque Print Template,Distance from left edge,Afstand van linkerrand
+apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} eenheden van [{1}] (#Vorm/Item/{1}) gevonden in [{2}](#Vorm/Magazijn/{2})
+DocType: Lead,Industry,Industrie
+DocType: Employee,Job Profile,Functieprofiel
+DocType: BOM Item,Rate & Amount,Tarief en Bedrag
+apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Dit is gebaseerd op transacties tegen dit bedrijf. Zie de tijdlijn hieronder voor details
+DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Notificeer per e-mail bij automatisch aanmaken van Materiaal Aanvraag
+apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Resistant
+apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Stel de hotelkamerprijs in op {}
+DocType: Journal Entry,Multi Currency,Valuta
+DocType: Opening Invoice Creation Tool,Invoice Type,Factuur Type
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939,Delivery Note,Vrachtbrief
+DocType: Consultation,Encounter Impression,Encounter Impression
+apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Het opzetten van Belastingen
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Kosten van Verkochte Asset
+DocType: Volunteer,Morning,Ochtend
+apps/erpnext/erpnext/accounts/utils.py +345,Payment Entry has been modified after you pulled it. Please pull it again.,Betaling Bericht is gewijzigd nadat u het getrokken. Neem dan trekt het weer.
+DocType: Program Enrollment Tool,New Student Batch,Nieuwe studentenbatch
+apps/erpnext/erpnext/stock/doctype/item/item.py +479,{0} entered twice in Item Tax,{0} twee keer opgenomen in Artikel BTW
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Samenvatting voor deze week en in afwachting van activiteiten
+DocType: Student Applicant,Admitted,toegelaten
+DocType: Workstation,Rent Cost,Huurkosten
+apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Bedrag na afschrijvingen
+apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Aankomende Gebeurtenissen
+apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Variant Attributen
+apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Selecteer maand en jaar
+DocType: Employee,Company Email,Bedrijf e-mail
+DocType: GL Entry,Debit Amount in Account Currency,Debet Bedrag in account Valuta
+DocType: Supplier Scorecard,Scoring Standings,Scoring Standings
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Bestellingswaarde
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Bestellingswaarde
+apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Bank / Cash-transacties tegen de partij of voor interne overplaatsing
+DocType: Shipping Rule,Valid for Countries,Geldig voor Landen
+apps/erpnext/erpnext/stock/doctype/item/item.js +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,Dit artikel is een sjabloon en kunnen niet worden gebruikt bij transacties. Item attributen zal worden gekopieerd naar de varianten tenzij 'No Copy' is ingesteld
+DocType: Grant Application,Grant Application,Subsidieaanvraag
+apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Totaal Bestel Beschouwd
+apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Werknemer aanduiding ( bijv. CEO , directeur enz. ) ."
+DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Koers waarmee de Klant Valuta wordt omgerekend naar de basisvaluta van de klant.
+DocType: Course Scheduling Tool,Course Scheduling Tool,Course Scheduling Tool
+apps/erpnext/erpnext/controllers/accounts_controller.py +623,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Rij # {0}: Aankoop factuur kan niet worden ingediend tegen een bestaand actief {1}
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257,[Urgent] Error while creating recurring %s for %s,[Urgent] Fout bij het maken van terugkerende% s voor% s
+DocType: Land Unit,LInked Analysis,Geïntegreerde analyse
+DocType: Item Tax,Tax Rate,Belastingtarief
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73,Application period cannot be across two allocation records,De toepassingsperiode kan niet over twee toewijzingsrecords lopen
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} reeds toegewezen voor Employee {1} voor periode {2} te {3}
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,Purchase Invoice {0} is already submitted,Inkoopfactuur {0} is al ingediend
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92,Row # {0}: Batch No must be same as {1} {2},Rij # {0}: Batch Geen moet hetzelfde zijn als zijn {1} {2}
+DocType: Material Request Plan Item,Material Request Plan Item,Artikel plan voor artikelaanvraag
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Converteren naar non-Group
+DocType: Project Update,Good/Steady,Goed / Steady
+DocType: C-Form Invoice Detail,Invoice Date,Factuurdatum
+DocType: GL Entry,Debit Amount,Debet Bedrag
+apps/erpnext/erpnext/accounts/party.py +248,There can only be 1 Account per Company in {0} {1},Er kan slechts 1 account per Bedrijf in zijn {0} {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,Zie bijlage
+DocType: Purchase Order,% Received,% Ontvangen
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Maak Student Groepen
+DocType: Volunteer,Weekends,weekends
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +127,Credit Note Amount,Credit Note Bedrag
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3},{0} ({1}) kan niet groter zijn dan de geplande quanitity ({2}) in werkorder {3}
+DocType: Setup Progress Action,Action Document,Actie Document
+DocType: Chapter Member,Website URL,Website URL
+,Finished Goods,Gereed Product
+DocType: Delivery Note,Instructions,Instructies
+DocType: Quality Inspection,Inspected By,Geïnspecteerd door
+DocType: Asset Maintenance Log,Maintenance Type,Onderhoud Type
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} is niet ingeschreven in de cursus {2}
+apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225,Student Name: ,Studenten naam:
+apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serienummer {0} behoort niet tot Vrachtbrief {1}
+apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97,"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Er lijkt een probleem te zijn met de GoCardless-configuratie van de server. Maakt u zich geen zorgen, in het geval van een fout, wordt het bedrag teruggestort op uw account."
+apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
+apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Items toevoegen
+DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Artikel Kwaliteitsinspectie Parameter
+DocType: Depreciation Schedule,Schedule Date,Plan datum
+apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","De winst, aftrekposten en andere looncomponenten"
+DocType: Packed Item,Packed Item,Levering Opmerking Verpakking Item
+DocType: Job Offer Term,Job Offer Term,Biedingsperiode
+apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Standaardinstellingen voor Inkooptransacties .
+apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Activiteit Kosten bestaat voor Employee {0} tegen Activity Type - {1}
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Verplicht veld - Ontvang studenten van
+DocType: Program Enrollment,Enrolled courses,Ingeschreven cursussen
+DocType: Currency Exchange,Currency Exchange,Wisselkoersen
+DocType: Opening Invoice Creation Tool Item,Item Name,Artikelnaam
+DocType: Authorization Rule,Approving User  (above authorized value),Goedkeuren gebruiker (boven de toegestane waarde)
+DocType: Email Digest,Credit Balance,Batig saldo
+DocType: Employee,Widowed,Weduwe
+DocType: Request for Quotation,Request for Quotation,Offerte
+DocType: Healthcare Settings,Require Lab Test Approval,Vereist laboratoriumtest goedkeuring
+DocType: Salary Slip Timesheet,Working Hours,Werkuren
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68,Total Outstanding,Totaal uitstekend
+DocType: Naming Series,Change the starting / current sequence number of an existing series.,Wijzig het start-/ huidige volgnummer van een bestaande serie.
+DocType: Dosage Strength,Strength,Kracht
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1534,Create a new Customer,Maak een nieuwe klant
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Als er meerdere prijzen Regels blijven die gelden, worden gebruikers gevraagd om Prioriteit handmatig instellen om conflicten op te lossen."
+apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Maak Bestellingen
+,Purchase Register,Inkoop Register
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116,Patient not found,Patiënt niet gevonden
+DocType: Scheduling Tool,Rechedule,Rechedule
+DocType: Landed Cost Item,Applicable Charges,Toepasselijke kosten
+DocType: Workstation,Consumable Cost,Verbruiksartikel kostprijs
+DocType: Purchase Receipt,Vehicle Date,Voertuiggegegevns
+DocType: Student Log,Medical,medisch
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Reason for losing,Reden voor het verliezen
+apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Accountnummer bijwerken
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Lead Owner cannot be same as the Lead,Lead eigenaar kan niet hetzelfde zijn als de lead zijn
+apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,Toegekende bedrag kan niet hoger zijn dan niet-gecorrigeerde bedrag
+DocType: Announcement,Receiver,Ontvanger
+apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Werkstation is gesloten op de volgende data als per Holiday Lijst: {0}
+apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Kansen
+DocType: Lab Test Template,Single,Enkele
+DocType: Salary Slip,Total Loan Repayment,Totaal aflossing van de lening
+DocType: Account,Cost of Goods Sold,Kostprijs verkochte goederen
+DocType: Subscription,Yearly,Jaarlijks
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,Vul kostenplaats in
+DocType: Drug Prescription,Dosage,Dosering
+DocType: Journal Entry Account,Sales Order,Verkooporder
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Gem. Verkoopkoers
+DocType: Assessment Plan,Examiner Name,Examinator Naam
+DocType: Lab Test Template,No Result,Geen resultaat
+DocType: Purchase Invoice Item,Quantity and Rate,Hoeveelheid en Tarief
+DocType: Delivery Note,% Installed,% Geïnstalleerd
+apps/erpnext/erpnext/utilities/user_progress.py +230,Classrooms/ Laboratories etc where lectures can be scheduled.,"Klaslokalen / Laboratories etc, waar lezingen kunnen worden gepland."
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Vul aub eerst de naam van het bedrijf in
+DocType: Purchase Invoice,Supplier Name,Leverancier Naam
+apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Lees de ERPNext Manual
+DocType: Purchase Invoice,01-Sales Return,01-verkoopretour
+DocType: Account,Is Group,Is Group
+DocType: Email Digest,Pending Purchase Orders,In afwachting van Bestellingen
+DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatisch instellen serienummers op basis van FIFO
+DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Controleer Leverancier Factuurnummer Uniqueness
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Primaire adresgegevens
+DocType: Vehicle Service,Oil Change,Olie vervanging
+DocType: Asset Maintenance Log,Asset Maintenance Log,Asset-onderhoudslogboek
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','Tot Zaak nr' kan niet minder zijn dan 'Van Zaak nr'
+DocType: Chapter,Non Profit,Non-Profit
+DocType: Production Plan,Not Started,Niet gestart
+DocType: Lead,Channel Partner,Channel Partner
+DocType: Account,Old Parent,Oude Parent
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Verplicht veld - Academiejaar
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Verplicht veld - Academiejaar
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220,{0} {1} is not associated with {2} {3},{0} {1} is niet gekoppeld aan {2} {3}
+DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Pas de inleidende tekst aan die meegaat als een deel van die e-mail. Elke transactie heeft een aparte inleidende tekst.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176,Please set default payable account for the company {0},Stel alsjeblieft de standaard betaalbare rekening voor het bedrijf in {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +513,Transaction not allowed against stopped Work Order {0},Transactie niet toegestaan tegen gestopte werkorder {0}
+DocType: Setup Progress Action,Min Doc Count,Min Doc Count
+apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Algemene instellingen voor alle productieprocessen.
+DocType: Accounts Settings,Accounts Frozen Upto,Rekeningen bevroren tot
+DocType: SMS Log,Sent On,Verzonden op
+apps/erpnext/erpnext/stock/doctype/item/item.py +700,Attribute {0} selected multiple times in Attributes Table,Kenmerk {0} meerdere keren geselecteerd in Attributes Tabel
+DocType: HR Settings,Employee record is created using selected field. ,Werknemer regel wordt gemaakt met behulp van geselecteerd veld.
+DocType: Sales Order,Not Applicable,Niet van toepassing
+apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Vakantie meester .
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Factuuritem openen
+DocType: Request for Quotation Item,Required Date,Benodigd op datum
+DocType: Delivery Note,Billing Address,Factuuradres
+DocType: BOM,Costing,Costing
+DocType: Tax Rule,Billing County,Billing County
+DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Indien aangevinkt, zal de BTW-bedrag worden beschouwd als reeds in de Print Tarief / Print Bedrag"
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceRef,PieceRef
+DocType: Request for Quotation,Message for Supplier,Boodschap voor Supplier
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40,Work Order,Werkorder
+DocType: Driver,DRIVER-.#####,BESTUURDER-.#####
+DocType: Sales Invoice,Total Qty,Totaal Aantal
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
+DocType: Item,Show in Website (Variant),Show in Website (Variant)
+DocType: Employee,Health Concerns,Gezondheidszorgen
+DocType: Payroll Entry,Select Payroll Period,Selecteer Payroll Periode
+DocType: Purchase Invoice,Unpaid,Onbetaald
+apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Gereserveerd voor verkoop
+DocType: Packing Slip,From Package No.,Van Pakket No
+DocType: Item Attribute,To Range,Om Bereik
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Effecten en Deposito's
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Kan de waarderingsmethode niet wijzigen, aangezien er transacties zijn tegen sommige items die geen eigen waarderingsmethode hebben"
+DocType: Student Report Generation Tool,Attended by Parents,Bijgewoond door ouders
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Totaal bladeren toegewezen is verplicht
+DocType: Patient,AB Positive,AB Positief
+DocType: Job Opening,Description of a Job Opening,Omschrijving van een Vacature
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Pending activities for today,Afwachting van activiteiten voor vandaag
+apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Aanwezigheid record.
+DocType: Salary Structure,Salary Component for timesheet based payroll.,Salaris Component voor rooster gebaseerde payroll.
+DocType: Sales Order Item,Used for Production Plan,Gebruikt voor Productie Plan
+DocType: Employee Loan,Total Payment,Totale betaling
+DocType: Manufacturing Settings,Time Between Operations (in mins),Time Between Operations (in minuten)
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132,{0} {1} is cancelled so the action cannot be completed,{0} {1} is geannuleerd dus de actie kan niet voltooid worden
+DocType: Customer,Buyer of Goods and Services.,Koper van goederen en diensten.
+DocType: Journal Entry,Accounts Payable,Crediteuren
+DocType: Patient,Allergies,allergieën
+apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33,The selected BOMs are not for the same item,De geselecteerde stuklijsten zijn niet voor hetzelfde item
+DocType: Supplier Scorecard Standing,Notify Other,Meld andere aan
+DocType: Vital Signs,Blood Pressure (systolic),Bloeddruk (systolisch)
+DocType: Pricing Rule,Valid Upto,Geldig Tot
+DocType: Training Event,Workshop,werkplaats
+DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Waarschuwing Aankooporders
+apps/erpnext/erpnext/utilities/user_progress.py +67,List a few of your customers. They could be organizations or individuals.,Lijst een paar van uw klanten. Ze kunnen organisaties of personen .
+apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Genoeg Parts te bouwen
+DocType: POS Profile User,POS Profile User,POS-profielgebruiker
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Directe Inkomsten
+DocType: Patient Appointment,Date TIme,Datum Tijd
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,"Can not filter based on Account, if grouped by Account","Kan niet filteren op basis van Rekening, indien gegroepeerd op Rekening"
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Boekhouder
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Opzetten van bedrijf en belastingen
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Selecteer de cursus
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Selecteer de cursus
+DocType: Codification Table,Codification Table,Codificatie Tabel
+DocType: Timesheet Detail,Hrs,hrs
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349,Please select Company,Selecteer Company
+DocType: Stock Entry Detail,Difference Account,Verschillenrekening
+DocType: Purchase Invoice,Supplier GSTIN,Leverancier GSTIN
+apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Kan taak niet afsluiten als haar afhankelijke taak {0} niet is afgesloten.
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,Vul magazijn in waarvoor Materiaal Aanvragen zullen worden ingediend.
+DocType: Work Order,Additional Operating Cost,Additionele Operationele Kosten
+DocType: Lab Test Template,Lab Routine,Lab Routine
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Cosmetica
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Selecteer de voltooiingsdatum voor het uitgevoerde onderhoudslogboek
+apps/erpnext/erpnext/stock/doctype/item/item.py +552,"To merge, following properties must be same for both items","Om samen te voegen, moeten de volgende eigenschappen hetzelfde zijn voor beide artikelen"
+DocType: Shipping Rule,Net Weight,Netto Gewicht
+DocType: Employee,Emergency Phone,Noodgeval Telefoonnummer
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} bestaat niet.
+apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Kopen
+,Serial No Warranty Expiry,Serienummer Garantie Afloop
+DocType: Sales Invoice,Offline POS Name,Offline POS Naam
+apps/erpnext/erpnext/utilities/user_progress.py +180,Student Application,Studentenaanvraag
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Gelieve te definiëren cijfer voor drempel 0%
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Gelieve te definiëren cijfer voor drempel 0%
+DocType: Sales Order,To Deliver,Bezorgen
+DocType: Purchase Invoice Item,Item,Artikel
+apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Hoge gevoeligheid
+apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Type vrijwilliger informatie.
+DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Cash Flow Mapping Template
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2551,Serial no item cannot be a fraction,Serial geen item kan niet een fractie te zijn
+DocType: Journal Entry,Difference (Dr - Cr),Verschil (Db - Cr)
+DocType: Account,Profit and Loss,Winst en Verlies
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104,"Not permitted, configure Lab Test Template as required","Niet toegestaan, configureer Lab-testsjabloon zoals vereist"
+DocType: Patient,Risk Factors,Risicofactoren
+DocType: Patient,Occupational Hazards and Environmental Factors,Beroepsgevaren en milieufactoren
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239,Stock Entries already created for Work Order ,Voorraadinvoer al gemaakt voor werkorder
+DocType: Vital Signs,Respiratory rate,Ademhalingsfrequentie
+apps/erpnext/erpnext/config/stock.py +338,Managing Subcontracting,Managing Subcontracting
+DocType: Vital Signs,Body Temperature,Lichaamstemperatuur
+DocType: Project,Project will be accessible on the website to these users,Project zal toegankelijk op de website van deze gebruikers
+DocType: Detected Disease,Disease,Ziekte
+apps/erpnext/erpnext/config/projects.py +29,Define Project type.,Definieer projecttype.
+DocType: Supplier Scorecard,Weighting Function,Gewicht Functie
+DocType: Physician,OP Consulting Charge,OP Consulting Charge
+apps/erpnext/erpnext/utilities/user_progress.py +28,Setup your ,Setup uw
+DocType: Student Report Generation Tool,Show Marks,Markeringen tonen
+DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Koers waarmee Prijslijst valuta wordt omgerekend naar de basis bedrijfsvaluta
+apps/erpnext/erpnext/setup/doctype/company/company.py +70,Account {0} does not belong to company: {1},Rekening {0} behoort niet tot bedrijf: {1}
+apps/erpnext/erpnext/setup/doctype/company/company.py +52,Abbreviation already used for another company,Afkorting al gebruikt voor een ander bedrijf
+DocType: Selling Settings,Default Customer Group,Standaard Klant Groep
+DocType: Asset Repair,ARLOG-,ARLOG-
+DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Indien uitgevinkt, zal het 'Afgerond Totaal' veld niet zichtbaar zijn in een transactie"
+DocType: BOM,Operating Cost,Operationele kosten
+DocType: Crop,Produced Items,Geproduceerde items
+DocType: Sales Order Item,Gross Profit,Bruto Winst
+apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Toename kan niet worden 0
+DocType: Company,Delete Company Transactions,Verwijder Company Transactions
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Artikelcode&gt; Artikelgroep&gt; Merk
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Reference No and Reference Date is mandatory for Bank transaction,Referentienummer en Reference Data is verplicht voor Bank transactie
+DocType: Purchase Receipt,Add / Edit Taxes and Charges,Toevoegen / Bewerken Belastingen en Heffingen
+DocType: Payment Entry Reference,Supplier Invoice No,Factuurnr. Leverancier
+DocType: Territory,For reference,Ter referentie
+DocType: Healthcare Settings,Appointment Confirmation,Afspraak bevestiging
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Kan Serienummer {0} niet verwijderen, omdat het wordt gebruikt in voorraadtransacties"
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256,Closing (Cr),Sluiten (Cr)
+apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Hallo
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Item verplaatsen
+DocType: Serial No,Warranty Period (Days),Garantieperiode (dagen)
+DocType: Installation Note Item,Installation Note Item,Installatie Opmerking Item
+DocType: Production Plan Item,Pending Qty,In afwachting Aantal
+DocType: Budget,Ignore,Negeren
+apps/erpnext/erpnext/accounts/party.py +396,{0} {1} is not active,{0} {1} is niet actief
+apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Setup check afmetingen voor afdrukken
+DocType: Salary Slip,Salary Slip Timesheet,Loonstrook Timesheet
+apps/erpnext/erpnext/controllers/buying_controller.py +161,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Leverancier Magazijn verplicht voor uitbesteedde Ontvangstbewijs
+DocType: Pricing Rule,Valid From,Geldig van
+DocType: Sales Invoice,Total Commission,Totaal Commissie
+DocType: Pricing Rule,Sales Partner,Verkoop Partner
+apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Alle leveranciers scorecards.
+DocType: Buying Settings,Purchase Receipt Required,Ontvangstbevestiging Verplicht
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188,Target warehouse in row {0} must be same as Work Order,Targetmagazijn in rij {0} moet hetzelfde zijn als werkorder
+apps/erpnext/erpnext/stock/doctype/item/item.py +155,Valuation Rate is mandatory if Opening Stock entered,Valuation Rate is verplicht als Opening Stock ingevoerd
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143,No records found in the Invoice table,Geen records gevonden in de factuur tabel
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34,Please select Company and Party Type first,Selecteer Company en Party Type eerste
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Al ingesteld standaard in pos profiel {0} voor gebruiker {1}, vriendelijk uitgeschakeld standaard"
+apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Financiële / boekjaar .
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Geaccumuleerde waarden
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Sorry , serienummers kunnen niet worden samengevoegd"
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Territory is verplicht in POS Profiel
+DocType: Supplier,Prevent RFQs,Voorkom RFQs
+apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Maak verkooporder
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Salarisslip ingediend voor een periode van {0} tot {1}
+DocType: Project Task,Project Task,Project Task
+,Lead Id,Lead Id
+DocType: C-Form Invoice Detail,Grand Total,Algemeen totaal
+DocType: Assessment Plan,Course,cursus
+DocType: Timesheet,Payslip,loonstrook
+apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Item winkelwagen
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Boekjaar Startdatum mag niet groter zijn dan het Boekjaar Einddatum
+DocType: Issue,Resolution,Oplossing
+DocType: C-Form,IV,IV
+apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Geleverd: {0}
+DocType: Expense Claim,Payable Account,Verschuldigd Account
+DocType: Payment Entry,Type of Payment,Type van Betaling
+DocType: Sales Order,Billing and Delivery Status,Factuur- en leverstatus
+DocType: Job Applicant,Resume Attachment,Resume Attachment
+apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Terugkerende klanten
+DocType: Leave Control Panel,Allocate,Toewijzen
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Maak een variant
+DocType: Sales Invoice,Shipping Bill Date,Verzendingsbiljetdatum
+DocType: Production Plan,Production Plan,Productieplan
+DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Opening factuur creatie tool
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853,Sales Return,Terugkerende verkoop
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Leverancier&gt; leverancier type
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Opmerking: Totaal toegewezen bladeren {0} mag niet kleiner zijn dan die reeds zijn goedgekeurd bladeren zijn {1} voor de periode
+,Total Stock Summary,Totale voorraadoverzicht
+DocType: Announcement,Posted By,Gepost door
+DocType: Item,Delivered by Supplier (Drop Ship),Geleverd door Leverancier (Drop Ship)
+DocType: Healthcare Settings,Confirmation Message,Bevestigingsbericht
+apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Database van potentiële klanten.
+DocType: Authorization Rule,Customer or Item,Klant of Item
+apps/erpnext/erpnext/config/selling.py +28,Customer database.,Klantenbestand.
+DocType: Quotation,Quotation To,Offerte Voor
+DocType: Lead,Middle Income,Modaal Inkomen
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228,Opening (Cr),Opening ( Cr )
+apps/erpnext/erpnext/stock/doctype/item/item.py +872,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Standaard maateenheid voor post {0} kan niet direct worden gewijzigd, omdat je al enkele transactie (s) met een andere UOM hebben gemaakt. U moet een nieuwe post naar een andere Standaard UOM gebruik maken."
+apps/erpnext/erpnext/accounts/utils.py +349,Allocated amount can not be negative,Toegekende bedrag kan niet negatief zijn
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Stel het bedrijf alstublieft in
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Stel het bedrijf alstublieft in
+DocType: Share Balance,Share Balance,Share Balance
+DocType: Purchase Order Item,Billed Amt,Gefactureerd Bedr
+DocType: Training Result Employee,Training Result Employee,Training Resultaat Werknemer
+DocType: Warehouse,A logical Warehouse against which stock entries are made.,Een logisch Magazijn waartegen voorraadboekingen worden gemaakt.
+DocType: Repayment Schedule,Principal Amount,hoofdsom
+DocType: Employee Loan Application,Total Payable Interest,Totaal verschuldigde rente
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57,Total Outstanding: {0},Totaal Uitstaande: {0}
+DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Sales Invoice Timesheet
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Referentienummer en referentiedatum nodig is voor {0}
+DocType: Payroll Entry,Select Payment Account to make Bank Entry,Selecteer Betaalrekening aan Bank Entry maken
+DocType: Hotel Settings,Default Invoice Naming Series,Standaard Invoice Naming Series
+apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Maak Employee records bladeren, declaraties en salarisadministratie beheren"
+DocType: Restaurant Reservation,Restaurant Reservation,Restaurant reservering
+DocType: Land Unit,Land Unit Name,Land Eenheid Naam
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Voorstel Schrijven
+DocType: Payment Entry Deduction,Payment Entry Deduction,Betaling Entry Aftrek
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Afsluiten
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Breng klanten op de hoogte via e-mail
+apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Een andere Sales Person {0} bestaat met dezelfde werknemer id
+DocType: Employee Advance,Claimed Amount,Geclaimd bedrag
+apps/erpnext/erpnext/config/education.py +180,Masters,Stamdata
+DocType: Assessment Plan,Maximum Assessment Score,Maximum Assessment Score
+apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Update Bank transactiedata
+apps/erpnext/erpnext/config/projects.py +41,Time Tracking,tijdregistratie
+DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATE VOOR TRANSPORTOR
+apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Rij {0} # Het betaalde bedrag kan niet groter zijn dan het gevraagde voorschotbedrag
+DocType: Fiscal Year Company,Fiscal Year Company,Fiscale Jaar Company
+DocType: Packing Slip Item,DN Detail,DN Detail
+DocType: Training Event,Conference,Conferentie
+DocType: Timesheet,Billed,Gefactureerd
+DocType: Batch,Batch Description,Batch Beschrijving
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Leergroepen creëren
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Leergroepen creëren
+apps/erpnext/erpnext/accounts/utils.py +720,"Payment Gateway Account not created, please create one manually.","Payment Gateway-account aangemaakt, dan kunt u een handmatig maken."
+DocType: Supplier Scorecard,Per Year,Per jaar
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Komt niet in aanmerking voor de toelating in dit programma volgens DOB
+DocType: Sales Invoice,Sales Taxes and Charges,Verkoop Belasting en Toeslagen
+DocType: Employee,Organization Profile,organisatie Profiel
+DocType: Vital Signs,Height (In Meter),Hoogte (in meter)
+DocType: Student,Sibling Details,sibling Details
+DocType: Vehicle Service,Vehicle Service,voertuig
+apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Automatisch leidt tot de feedback verzoek op basis van de omstandigheden.
+DocType: Employee,Reason for Resignation,Reden voor ontslag
+apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Sjabloon voor functioneringsgesprekken .
+DocType: Sales Invoice,Credit Note Issued,Credit Note Uitgegeven
+DocType: Project Task,Weight,Gewicht
+DocType: Payment Reconciliation,Invoice/Journal Entry Details,Factuur / Journal Entry Details
+apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} '{1} ' niet in het boekjaar {2}
+DocType: Buying Settings,Settings for Buying Module,Instellingen voor het kopen van Module
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Asset {0} niet behoort tot bedrijf {1}
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Vul Kwitantie eerste
+DocType: Buying Settings,Supplier Naming By,Leverancier Benaming Door
+DocType: Activity Type,Default Costing Rate,Standaard Costing Rate
+DocType: Maintenance Schedule,Maintenance Schedule,Onderhoudsschema
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Dan worden prijsregels uitgefilterd op basis van Klant, Klantgroep, Regio,  Leverancier, Leverancier Type, Campagne, Verkooppartner, etc."
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29,Net Change in Inventory,Netto wijziging in Inventory
+apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Employee Lening Beheer
+DocType: Employee,Passport Number,Paspoortnummer
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Relatie met Guardian2
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Manager
+DocType: Payment Entry,Payment From / To,Betaling van / naar
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +170,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},New kredietlimiet lager is dan de huidige uitstaande bedrag voor de klant. Kredietlimiet moet minstens zijn {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Stel een account in in Magazijn {0}
+apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Gebaseerd op' en 'Groepeer per' kunnen niet hetzelfde zijn
+DocType: Sales Person,Sales Person Targets,Verkoper Doelen
+DocType: Installation Note,IN-,IN-
+DocType: Work Order Operation,In minutes,In minuten
+DocType: Issue,Resolution Date,Oplossing Datum
+DocType: Lab Test Template,Compound,samenstelling
+DocType: Student Batch Name,Batch Name,batch Naam
+DocType: Fee Validity,Max number of visit,Max. Aantal bezoeken
+,Hotel Room Occupancy,Hotel Kamer bezetting
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358,Timesheet created:,Rooster gemaakt:
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931,Please set default Cash or Bank account in Mode of Payment {0},Stel een standaard Kas- of Bankrekening in bij Betaalwijze {0}
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,Inschrijven
+DocType: GST Settings,GST Settings,GST instellingen
+DocType: Selling Settings,Customer Naming By,Klant Naming Door
+DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Zal de student zoals aanwezig in Student Maandelijkse Rapport Aanwezigheid tonen
+DocType: Depreciation Schedule,Depreciation Amount,afschrijvingen Bedrag
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Converteren naar Groep
+DocType: Delivery Trip,TOUR-.#####,TOUR-.#####
+DocType: Activity Cost,Activity Type,Activiteit Type
+DocType: Request for Quotation,For individual supplier,Voor individuele leverancier
+DocType: BOM Operation,Base Hour Rate(Company Currency),Base Uur Rate (Company Munt)
+apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Afgeleverd Bedrag
+DocType: Quotation Item,Item Balance,Item Balance
+DocType: Sales Invoice,Packing List,Paklijst
+apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Inkooporders voor leveranciers.
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Publishing
+DocType: Accounts Settings,Report Settings,Rapportinstellingen
+DocType: Activity Cost,Projects User,Projecten Gebruiker
+apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40,Consumed,Verbruikt
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0}: {1} niet gevonden in Factuur Details tabel
+DocType: Asset,Asset Owner Company,Asset Owner Company
+DocType: Company,Round Off Cost Center,Afronden kostenplaats
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Onderhoud Bezoek {0} moet worden geannuleerd voordat het annuleren van deze verkooporder
+DocType: Asset Maintenance Log,AML-,AML-
+DocType: Item,Material Transfer,Materiaal Verplaatsing
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Kan pad niet vinden voor
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221,Opening (Dr),Opening ( Dr )
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Plaatsing timestamp moet na {0} zijn
+apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Om terugkerende documenten te maken
+,GST Itemised Purchase Register,GST Itemized Purchase Register
+DocType: Course Scheduling Tool,Reschedule,Afspraak verzetten
+DocType: Employee Loan,Total Interest Payable,Totaal te betalen rente
+DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Vrachtkosten belastingen en toeslagen
+DocType: Work Order Operation,Actual Start Time,Werkelijke Starttijd
+DocType: BOM Operation,Operation Time,Operatie Tijd
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316,Finish,Afwerking
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Baseren
+DocType: Timesheet,Total Billed Hours,Totaal gefactureerd Hours
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1551,Write Off Amount,Afschrijvingsbedrag
+DocType: Leave Block List Allow,Allow User,Door gebruiker toestaan
+DocType: Journal Entry,Bill No,Factuur nr
+DocType: Company,Gain/Loss Account on Asset Disposal,Winst / verliesrekening op de verkoop van activa
+DocType: Vehicle Log,Service Details,Service Details
+DocType: Subscription,Quarterly,Kwartaal
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47,EcritureLib,EcritureLib
+DocType: Lab Test Template,Grouped,gegroepeerd
+DocType: Selling Settings,Delivery Note Required,Vrachtbrief Verplicht
+DocType: Bank Guarantee,Bank Guarantee Number,Bankgarantie Nummer
+DocType: Bank Guarantee,Bank Guarantee Number,Bankgarantie Nummer
+DocType: Assessment Criteria,Assessment Criteria,Beoordelingscriteria
+DocType: BOM Item,Basic Rate (Company Currency),Basis Tarief (Bedrijfs Valuta)
+DocType: Student Attendance,Student Attendance,student Attendance
+DocType: Sales Invoice Timesheet,Time Sheet,Urenregistratie
+DocType: Manufacturing Settings,Backflush Raw Materials Based On,Grondstoffen afgeboekt op basis van
+DocType: Sales Invoice,Port Code,Poortcode
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957,Reserve Warehouse,Magazijn reserveren
+DocType: Lead,Lead is an Organization,Lead is een organisatie
+DocType: Guardian Interest,Interest,Interesseren
+apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Voorverkoop
+DocType: Instructor Log,Other Details,Andere Details
+apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
+DocType: Lab Test,Test Template,Test sjabloon
+DocType: Restaurant Order Entry Item,Served,geserveerd
+apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Hoofdstuk informatie.
+DocType: Account,Accounts,Rekeningen
+DocType: Vehicle,Odometer Value (Last),Kilometerstand (Laatste)
+apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Templates van leveranciers scorecard criteria.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Marketing
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303,Payment Entry is already created,Betaling Entry is al gemaakt
+DocType: Request for Quotation,Get Suppliers,Krijg leveranciers
+DocType: Purchase Receipt Item Supplied,Current Stock,Huidige voorraad
+apps/erpnext/erpnext/controllers/accounts_controller.py +610,Row #{0}: Asset {1} does not linked to Item {2},Rij # {0}: Asset {1} is niet gekoppeld aan artikel {2}
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Voorbeschouwing loonstrook
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Account {0} is meerdere keren ingevoerd
+DocType: Account,Expenses Included In Valuation,Kosten inbegrepen in waardering
+apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,U kunt alleen verlengen als uw lidmaatschap binnen 30 dagen verloopt
+DocType: Land Unit,Longitude,Lengtegraad
+,Absent Student Report,Studenten afwezigheidsrapport
+DocType: Crop,Crop Spacing UOM,Gewasafstand UOM
+DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Selecteer alleen als u Cash Flow Mapper-documenten hebt ingesteld
+DocType: Email Digest,Next email will be sent on:,Volgende e-mail wordt verzonden op:
+DocType: Supplier Scorecard,Per Week,Per week
+apps/erpnext/erpnext/stock/doctype/item/item.py +666,Item has variants.,Item heeft varianten.
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Totaal student
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Artikel {0} niet gevonden
+DocType: Bin,Stock Value,Voorraad Waarde
+apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Company {0} bestaat niet
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} heeft geldigheid tot {1}
+apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54,Tree Type,Boom Type
+DocType: BOM Explosion Item,Qty Consumed Per Unit,Aantal verbruikt per eenheid
+DocType: GST Account,IGST Account,IGST-account
+DocType: Serial No,Warranty Expiry Date,Garantie Vervaldatum
+DocType: Material Request Item,Quantity and Warehouse,Hoeveelheid en magazijn
+DocType: Hub Settings,Unregister,Afmelden
+DocType: Sales Invoice,Commission Rate (%),Commissie Rate (%)
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Selecteer alsjeblieft Programma
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Selecteer alsjeblieft Programma
+DocType: Project,Estimated Cost,Geschatte kosten
+DocType: Purchase Order,Link to material requests,Koppeling naar materiaal aanvragen
+DocType: Hub Settings,Publish,Publiceren
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Ruimtevaart
+,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
+DocType: Journal Entry,Credit Card Entry,Kredietkaart invoer
+apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Bedrijf en Accounts
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,In Value,in Value
+DocType: Asset Settings,Depreciation Options,Afschrijvingsopties
+apps/erpnext/erpnext/utilities/transaction_base.py +35,Invalid Posting Time,Ongeldige boekingstijd
+DocType: Lead,Campaign Name,Campagnenaam
+DocType: Hotel Room,Capacity,Capaciteit
+DocType: Selling Settings,Close Opportunity After Days,Sluiten Opportunity Na Days
+,Reserved,gereserveerd
+DocType: Driver,License Details,Licentie details
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85,The field From Shareholder cannot be blank,Het veld Van Aandeelhouder mag niet leeg zijn
+DocType: Purchase Order,Supply Raw Materials,Supply Grondstoffen
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Vlottende Activa
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121,{0} is not a stock Item,{0} is geen voorraad artikel
+apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Deel alstublieft uw feedback aan de training door op &#39;Training Feedback&#39; te klikken en vervolgens &#39;New&#39;
+DocType: Mode of Payment Account,Default Account,Standaardrekening
+apps/erpnext/erpnext/stock/doctype/item/item.py +273,Please select Sample Retention Warehouse in Stock Settings first,Selecteer eerst Sample Retention Warehouse in Stock Settings
+DocType: Payment Entry,Received Amount (Company Currency),Ontvangen bedrag (Company Munt)
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,Lead moet worden ingesteld als de opportuniteit is gemaakt obv een lead
+apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136,Payment Cancelled. Please check your GoCardless Account for more details,Betaling geannuleerd. Controleer uw GoCardless-account voor meer informatie
+apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Selecteer wekelijkse vrije dag
+DocType: Patient,O Negative,O Negatief
+DocType: Work Order Operation,Planned End Time,Geplande Eindtijd
+,Sales Person Target Variance Item Group-Wise,Sales Person Doel Variance Post Group - Wise
+apps/erpnext/erpnext/accounts/doctype/account/account.py +93,Account with existing transaction cannot be converted to ledger,Rekening met bestaande transactie kan niet worden geconverteerd naar grootboek
+apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Type details voor lidmaatschapstype
+DocType: Delivery Note,Customer's Purchase Order No,Inkoopordernummer van Klant
+DocType: Budget,Budget Against,budget Against
+DocType: Employee,Cell Number,Mobiel nummer
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Er is geen medewerker voor de gegeven criteria. Controleer of salarisstroken nog niet zijn gemaakt.
+apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Auto Materiaal Verzoeken Vernieuwd
+apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Verloren
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,U kan geen 'Voucher' invoeren in een 'Tegen Journal Entry' kolom
+apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Gereserveerd voor productie
+DocType: Soil Texture,Sand,Zand
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energie
+DocType: Opportunity,Opportunity From,Opportuniteit Van
+apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Maandsalaris overzicht.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Rij {0}: {1} Serienummers vereist voor item {2}. U heeft {3} verstrekt.
+apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Selecteer een tafel
+DocType: BOM,Website Specifications,Website Specificaties
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} is een ongeldig e-mailadres in &#39;Ontvangers&#39;
+DocType: Special Test Items,Particulars,bijzonderheden
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Van {0} van type {1}
+DocType: Warranty Claim,CI-,CI-
+apps/erpnext/erpnext/controllers/buying_controller.py +316,Row {0}: Conversion Factor is mandatory,Rij {0}: Conversie Factor is verplicht
+DocType: Student,A+,A+
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Meerdere Prijs Regels bestaat met dezelfde criteria, dan kunt u conflicten op te lossen door het toekennen van prioriteit. Prijs Regels: {0}"
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519,Cannot deactivate or cancel BOM as it is linked with other BOMs,Kan stuklijst niet deactiveren of annuleren aangezien het is gelinkt met andere stuklijsten.
+DocType: Asset,Maintenance,Onderhoud
+DocType: Item Attribute Value,Item Attribute Value,Item Atribuutwaarde
+apps/erpnext/erpnext/projects/doctype/project/project.py +406,Please Update your Project Status,Werk uw projectstatus bij
+DocType: Item,Maximum sample quantity that can be retained,Maximum aantal monsters dat kan worden bewaard
+DocType: Project Update,How is the Project Progressing Right Now?,Hoe verloopt het project nu?
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +419,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Rij {0} # artikel {1} kan niet meer dan {2} worden overgedragen tegen bestelling {3}
+apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Verkoop campagnes
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117,Make Timesheet,maak Timesheet
+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.","Standaard belasting sjabloon die kan worden toegepast op alle verkooptransacties. Deze sjabloon kan lijst van fiscale hoofden en ook andere kosten / baten koppen als ""Verzenden"", ""Verzekering"" bevatten, ""Omgaan met"" enz 
+
+ #### Opmerking 
+
+ Het belastingtarief u definiëren hier zal het normale belastingtarief voor alle ** Items worden **. Als er ** Items ** dat verschillende tarieven hebben, moeten ze worden toegevoegd in de ** Item Tax ** tafel in de ** Item ** meester.
+
+ #### Beschrijving van Kolommen 
+
+ 1. Berekening Type: 
+ - Dit kan op ** Netto Totaal ** (dat is de som van het basisbedrag).
+ - ** Op Vorige Row Total / Bedrag ** (voor cumulatieve belastingen of heffingen). Als u deze optie selecteert, zal de belasting worden berekend als een percentage van de vorige rij (in de fiscale tabel) bedrag of totaal.
+ - ** Werkelijke ** (zoals vermeld).
+ 2. Account Head: De Account grootboek waaronder deze belasting 
+ 3 zal worden geboekt. Cost Center: Als de belasting / heffing is een inkomen (zoals de scheepvaart) of kosten die het nodig heeft tegen een kostenplaats worden geboekt.
+ 4. Beschrijving: Beschrijving van de belasting (die zullen worden afgedrukt in de facturen / offertes).
+ 5. Rate: belastingtarief.
+ 6. Bedrag: BTW bedrag.
+ 7. Totaal: Cumulatief totaal op dit punt.
+ 8. Voer Row: Als op basis van ""Vorige Row Total"" kunt u het rijnummer die zullen worden genomen als basis voor deze berekening (standaard is de vorige rij) te selecteren.
+ 9. Is dit inbegrepen in de Basic Rate ?: Indien u dit controleren, betekent dit dat deze belasting niet onder het item tafel zal worden getoond, maar zal worden opgenomen in het basistarief in uw belangrijkste punt tafel. Dit is handig wanneer u wilt geven een platte prijs (inclusief alle belastingen) prijs aan klanten."
+DocType: Employee,Bank A/C No.,Bank A / C nr.
+DocType: Bank Guarantee,Project,Project
+DocType: Quality Inspection Reading,Reading 7,Meting 7
+apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,gedeeltelijk Bestelde
+DocType: Lab Test,Lab Test,Laboratoriumtest
+DocType: Student Report Generation Tool,Student Report Generation Tool,Studentenrapport-generatietool
+DocType: Expense Claim Detail,Expense Claim Type,Kostendeclaratie Type
+DocType: Shopping Cart Settings,Default settings for Shopping Cart,Standaardinstellingen voor Winkelwagen
+apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27,Add Timeslots,Voeg tijdsloten toe
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset gesloopt via Journal Entry {0}
+DocType: Employee Loan,Interest Income Account,Rentebaten Account
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Review Uitnodiging verzonden
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Biotechnologie
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Gebouwen Onderhoudskosten
+apps/erpnext/erpnext/utilities/user_progress.py +54,Go to ,Ga naar
+apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Het opzetten van e-mailaccount
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,Vul eerst artikel in
+DocType: Asset Repair,Downtime,uitvaltijd
+DocType: Account,Liability,Verplichting
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Gesanctioneerde bedrag kan niet groter zijn dan Claim Bedrag in Row {0}.
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Academic Term: ,Academische termijn:
+DocType: Salary Detail,Do not include in total,Neem niet alles mee
+DocType: Company,Default Cost of Goods Sold Account,Standaard kosten van verkochte goederen Account
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1063,Sample quantity {0} cannot be more than received quantity {1},Voorbeeldhoeveelheid {0} kan niet meer dan ontvangen aantal {1} zijn
+apps/erpnext/erpnext/stock/get_item_details.py +369,Price List not selected,Prijslijst niet geselecteerd
+DocType: Employee,Family Background,Familie Achtergrond
+DocType: Request for Quotation Supplier,Send Email,E-mail verzenden
+apps/erpnext/erpnext/stock/doctype/item/item.py +228,Warning: Invalid Attachment {0},Waarschuwing: Invalid Attachment {0}
+DocType: Item,Max Sample Quantity,Max. Aantal monsters
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766,No Permission,Geen toestemming
+DocType: Vital Signs,Heart Rate / Pulse,Hartslag / Pulse
+DocType: Company,Default Bank Account,Standaard bankrekening
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59,"To filter based on Party, select Party Type first","Om te filteren op basis van Party, selecteer Party Typ eerst"
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},'Bijwerken voorraad' kan niet worden aangevinkt omdat items niet worden geleverd via {0}
+DocType: Vehicle,Acquisition Date,Aankoopdatum
+apps/erpnext/erpnext/utilities/user_progress.py +146,Nos,Nrs
+DocType: Item,Items with higher weightage will be shown higher,Items met een hogere weightage hoger zal worden getoond
+apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Lab-tests en vitale functies
+DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Aflettering Detail
+apps/erpnext/erpnext/controllers/accounts_controller.py +614,Row #{0}: Asset {1} must be submitted,Rij # {0}: Asset {1} moet worden ingediend
+apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Geen werknemer gevonden
+DocType: Subscription,Stopped,Gestopt
+DocType: Item,If subcontracted to a vendor,Als uitbesteed aan een leverancier
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentgroep is al bijgewerkt.
+apps/erpnext/erpnext/config/projects.py +18,Project Update.,Project update.
+DocType: SMS Center,All Customer Contact,Alle Customer Contact
+DocType: Land Unit,Tree Details,Tree Details
+DocType: Training Event,Event Status,event Status
+DocType: Volunteer,Availability Timeslot,Beschikbaarheid Timeslot
+,Support Analytics,Support Analyse
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365,"If you have any questions, please get back to us.","Mocht u nog vragen hebben, dan kunt u weer terug naar ons."
+DocType: Cash Flow Mapper,Cash Flow Mapper,Cash Flow Mapper
+DocType: Item,Website Warehouse,Website Magazijn
+DocType: Payment Reconciliation,Minimum Invoice Amount,Minimum Factuurbedrag
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: kostenplaats {2} behoort niet tot Company {3}
+apps/erpnext/erpnext/utilities/user_progress.py +92,Upload your letter head (Keep it web friendly as 900px by 100px),Upload uw briefhoofd (houd het webvriendelijk als 900px bij 100px)
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Account {2} kan geen Group zijn
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Item Row {IDX}: {doctype} {DocName} bestaat niet in bovenstaande &#39;{} doctype&#39; table
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295,Timesheet {0} is already completed or cancelled,Timesheet {0} is al voltooid of geannuleerd
+apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,geen taken
+DocType: Item Variant Settings,Copy Fields to Variant,Kopieer velden naar variant
+DocType: Asset,Opening Accumulated Depreciation,Het openen van de cumulatieve afschrijvingen
+apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Score moet lager dan of gelijk aan 5 zijn
+DocType: Program Enrollment Tool,Program Enrollment Tool,Programma Inschrijving Tool
+apps/erpnext/erpnext/config/accounts.py +335,C-Form records,C -Form records
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73,The shares already exist,De aandelen bestaan al
+apps/erpnext/erpnext/config/selling.py +316,Customer and Supplier,Klant en leverancier
+DocType: Email Digest,Email Digest Settings,E-mail Digest Instellingen
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367,Thank you for your business!,Bedankt voor uw zaken!
+apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Support vragen van klanten.
+DocType: Setup Progress Action,Action Doctype,Actie Doctype
+DocType: HR Settings,Retirement Age,Pensioenleeftijd
+DocType: Bin,Moving Average Rate,Moving Average Rate
+DocType: Production Plan,Select Items,Selecteer Artikelen
+DocType: Share Transfer,To Shareholder,Aan de aandeelhouder
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} tegen Factuur {1} gedateerd {2}
+apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Institution,Setup instelling
+DocType: Program Enrollment,Vehicle/Bus Number,Voertuig- / busnummer
+apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Course Schedule
+DocType: Request for Quotation Supplier,Quote Status,Offerte Status
+DocType: GoCardless Settings,Webhooks Secret,Webhooks geheim
+DocType: Maintenance Visit,Completion Status,Voltooiingsstatus
+DocType: Daily Work Summary Group,Select Users,Selecteer gebruikers
+DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Prijsbepaling Hotelkamer
+DocType: HR Settings,Enter retirement age in years,Voer de pensioengerechtigde leeftijd in jaren
+DocType: Crop,Target Warehouse,Doel Magazijn
+DocType: Payroll Employee Detail,Payroll Employee Detail,Loonwerknemersdetail
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select a warehouse,Selecteer een magazijn
+DocType: Cheque Print Template,Starting location from left edge,Startlocatie van linkerrand
+DocType: Item,Allow over delivery or receipt upto this percent,Laat dan levering of ontvangst upto deze procent
+DocType: Stock Entry,STE-,STEREO
+DocType: Upload Attendance,Import Attendance,Import Toeschouwers
+apps/erpnext/erpnext/public/js/pos/pos.html +124,All Item Groups,Alle Artikel Groepen
+apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Bericht automatisch samenstellen overlegging van transacties .
+DocType: Work Order,Item To Manufacture,Artikel te produceren
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteLib,CompteLib
+apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status {2}
+DocType: Water Analysis,Collection Temperature ,Verzamelingstemperatuur
+DocType: Employee,Provide Email Address registered in company,Zorg voor e-mailadres in bedrijf geregistreerd
+DocType: Shopping Cart Settings,Enable Checkout,inschakelen Afrekenen
+apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Aanschaffen om de betaling
+apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Verwachte Aantal
+DocType: Sales Invoice,Payment Due Date,Betaling Vervaldatum
+DocType: Drug Prescription,Interval UOM,Interval UOM
+DocType: Customer,"Reselect, if the chosen address is edited after save","Selecteer opnieuw, als het gekozen adres is bewerkt na opslaan"
+apps/erpnext/erpnext/stock/doctype/item/item.js +544,Item Variant {0} already exists with same attributes,Artikel Variant {0} bestaat al met dezelfde kenmerken
+DocType: Item,Hub Publishing Details,Hub publicatie details
+apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117,'Opening',&#39;Opening&#39;
+apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Open To Do
+DocType: Notification Control,Delivery Note Message,Vrachtbrief Bericht
+DocType: Lab Test Template,Result Format,Resultaatformaat
+DocType: Expense Claim,Expenses,Uitgaven
+DocType: Item Variant Attribute,Item Variant Attribute,Artikel Variant Kenmerk
+,Purchase Receipt Trends,Ontvangstbevestiging Trends
+DocType: Payroll Entry,Bimonthly,Tweemaandelijks
+DocType: Vehicle Service,Brake Pad,Brake Pad
+DocType: Fertilizer,Fertilizer Contents,Kunstmest Inhoud
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Research & Development
+apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Neerkomen op Bill
+DocType: Company,Registration Details,Registratie Details
+DocType: Timesheet,Total Billed Amount,Totaal factuurbedrag
+DocType: Item Reorder,Re-Order Qty,Re-order Aantal
+DocType: Leave Block List Date,Leave Block List Date,Laat Block List Datum
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Ruw materiaal kan niet hetzelfde zijn als hoofdartikel
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Totaal van toepassing zijnde kosten in Kwitantie Items tabel moet hetzelfde zijn als de totale belastingen en heffingen
+DocType: Sales Team,Incentives,Incentives
+DocType: SMS Log,Requested Numbers,Gevraagde Numbers
+DocType: Volunteer,Evening,Avond
+DocType: Customer,Bypass credit limit check at Sales Order,Creditlimietcontrole overslaan op klantorder
+apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Beoordeling van de prestaties.
+apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Inschakelen &quot;Gebruik voor Winkelwagen &#39;, zoals Winkelwagen is ingeschakeld en er moet minstens één Tax Rule voor Winkelwagen zijn"
+apps/erpnext/erpnext/controllers/accounts_controller.py +412,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Betaling Entry {0} is verbonden met de Orde {1}, controleer dan of het als tevoren in deze factuur moet worden getrokken."
+DocType: Sales Invoice Item,Stock Details,Voorraad Details
+apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Project Waarde
+apps/erpnext/erpnext/config/selling.py +326,Point-of-Sale,Verkooppunt
+DocType: Fee Schedule,Fee Creation Status,Fee Creation Status
+DocType: Vehicle Log,Odometer Reading,kilometerstand
+apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Accountbalans reeds in Credit, 'Balans moet zijn' mag niet als 'Debet' worden ingesteld"
+DocType: Account,Balance must be,Saldo moet worden
+DocType: Hub Settings,Publish Pricing,Publiceer Pricing
+DocType: Notification Control,Expense Claim Rejected Message,Kostendeclaratie afgewezen Bericht
+,Available Qty,Beschikbaar Aantal
+DocType: Purchase Taxes and Charges,On Previous Row Total,Aantal van volgende rij
+DocType: Purchase Invoice Item,Rejected Qty,afgewezen Aantal
+DocType: Setup Progress Action,Action Field,Actieveld
+DocType: Healthcare Settings,Manage Customer,Klant beheren
+DocType: Delivery Trip,Delivery Stops,Levering stopt
+DocType: Salary Slip,Working Days,Werkdagen
+DocType: Serial No,Incoming Rate,Inkomende Rate
+DocType: Packing Slip,Gross Weight,Bruto Gewicht
+,Final Assessment Grades,Eindbeoordeling
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Hub inschakelen
+apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,De naam van uw bedrijf waar u het systeem voor op zet.
+DocType: HR Settings,Include holidays in Total no. of Working Days,Feestdagen opnemen in totaal aantal werkdagen.
+apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Stel uw instituut op in ERPNext
+DocType: Agriculture Analysis Criteria,Plant Analysis,Plantanalyse
+DocType: Job Applicant,Hold,Houden
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +127,Alternate Item,Alternatief item
+DocType: Project Update,Progress Details,Voortgangsdetails
+DocType: Employee,Date of Joining,Datum van indiensttreding
+DocType: Naming Series,Update Series,Reeksen bijwerken
+DocType: Supplier Quotation,Is Subcontracted,Wordt uitbesteed
+DocType: Restaurant Table,Minimum Seating,Minimum aantal zitplaatsen
+DocType: Item Attribute,Item Attribute Values,Item Attribuutwaarden
+DocType: Examination Result,Examination Result,examenresultaat
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845,Purchase Receipt,Ontvangstbevestiging
+,Received Items To Be Billed,Ontvangen artikelen nog te factureren
+apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Wisselkoers stam.
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,Reference Doctype must be one of {0},Referentie Doctype moet een van {0}
+apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Filter totaal aantal nul
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341,Unable to find Time Slot in the next {0} days for Operation {1},Kan Time Slot in de volgende {0} dagen voor Operatie vinden {1}
+DocType: Work Order,Plan material for sub-assemblies,Plan materiaal voor onderdelen
+apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Sales Partners en Territory
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +601,BOM {0} must be active,Stuklijst {0} moet actief zijn
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414,No Items available for transfer,Geen items beschikbaar voor overdracht
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218,Closing (Opening + Total),Sluiten (Opening + totaal)
+DocType: Journal Entry,Depreciation Entry,afschrijvingen Entry
+apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Please select the document type first,Selecteer eerst het documenttype
+apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Annuleren Materiaal Bezoeken {0} voor het annuleren van deze Maintenance Visit
+DocType: Crop Cycle,ISO 8016 standard,ISO 8016-norm
+DocType: Pricing Rule,Rate or Discount,Tarief of korting
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serienummer {0} behoort niet tot Artikel {1}
+DocType: Purchase Receipt Item Supplied,Required Qty,Benodigde hoeveelheid
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126,Warehouses with existing transaction can not be converted to ledger.,Warehouses met bestaande transactie kan niet worden geconverteerd naar grootboek.
+DocType: Bank Reconciliation,Total Amount,Totaal bedrag
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,internet Publishing
+DocType: Prescription Duration,Number,Aantal
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,{0} factuur aanmaken
+DocType: Medical Code,Medical Code Standard,Medische Code Standaard
+DocType: Soil Texture,Clay Composition (%),Kleisamenstelling (%)
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Sla op voordat u een taak toewijst.
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74,Balance Value,Balans Waarde
+DocType: Lab Test,Lab Technician,Laboratorium technicus
+apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Sales Prijslijst
+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.","Als gecontroleerd, wordt een klant aangemaakt, aangepast aan Patiënt. Patiëntfacturen worden aangemaakt tegen deze klant. U kunt ook de bestaande klant selecteren bij het maken van een patiënt."
+DocType: Bank Reconciliation,Account Currency,Account Valuta
+DocType: Lab Test,Sample ID,Voorbeeld ID
+apps/erpnext/erpnext/accounts/general_ledger.py +167,Please mention Round Off Account in Company,Vermeld Ronde Off Account in Company
+DocType: Purchase Receipt,Range,Reeks
+DocType: Supplier,Default Payable Accounts,Standaard Crediteuren Accounts
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Werknemer {0} is niet actief of bestaat niet
+DocType: Fee Structure,Components,Components
+DocType: Item Barcode,Item Barcode,Artikel Barcode
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +329,Please enter Asset Category in Item {0},Vul Asset Categorie op post {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +661,Item Variants {0} updated,Item Varianten {0} bijgewerkt
+DocType: Quality Inspection Reading,Reading 6,Meting 6
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
+of this","gegenereerd worden. Als u vertraagd bent, moet u het veld &#39;Herhalen op dag van maand&#39; handmatig wijzigen"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961,Cannot {0} {1} {2} without any negative outstanding invoice,Kan niet {0} {1} {2} zonder negatieve openstaande factuur
+DocType: Share Transfer,From Folio No,Van Folio Nee
+DocType: Purchase Invoice Advance,Purchase Invoice Advance,Inkoopfactuur Voorschot
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Rij {0}: kan creditering niet worden gekoppeld met een {1}
+apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Definieer budget voor een boekjaar.
+DocType: Lead,LEAD-,LOOD-
+DocType: Employee,Permanent Address Is,Vast Adres is
+DocType: Work Order Operation,Operation completed for how many finished goods?,Operatie afgerond voor hoeveel eindproducten?
+DocType: Payment Terms Template,Payment Terms Template,Betalingscondities sjabloon
+apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,De Brand
+DocType: Employee,Exit Interview Details,Exit Gesprek Details
+DocType: Item,Is Purchase Item,Is inkoopartikel
+DocType: Journal Entry Account,Purchase Invoice,Inkoopfactuur
+DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail nr
+apps/erpnext/erpnext/accounts/page/pos/pos.js +789,New Sales Invoice,Nieuwe Sales Invoice
+DocType: Stock Entry,Total Outgoing Value,Totaal uitgaande waardeoverdrachten
+DocType: Physician,Appointments,afspraken
+apps/erpnext/erpnext/public/js/account_tree_grid.js +223,Opening Date and Closing Date should be within same Fiscal Year,Openingsdatum en de uiterste datum moet binnen dezelfde fiscale jaar
+DocType: Lead,Request for Information,Informatieaanvraag
+,LeaderBoard,Scorebord
+DocType: Sales Invoice Item,Rate With Margin (Company Currency),Tarief met marge (bedrijfsvaluta)
+apps/erpnext/erpnext/accounts/page/pos/pos.js +802,Sync Offline Invoices,Sync Offline Facturen
+DocType: Payment Request,Paid,Betaald
+DocType: Program Fee,Program Fee,programma Fee
+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.","Vervang een bepaalde BOM in alle andere BOM&#39;s waar het wordt gebruikt. Het zal de oude BOM link vervangen, update kosten en regenereren &quot;BOM Explosion Item&quot; tabel zoals per nieuwe BOM. Ook wordt de laatste prijs bijgewerkt in alle BOM&#39;s."
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447,The following Work Orders were created:,De volgende werkorders zijn gemaakt:
+DocType: Salary Slip,Total in words,Totaal in woorden
+DocType: Material Request Item,Lead Time Date,Lead Tijd Datum
+,Employee Advance Summary,Medewerker Advance Summary
+DocType: Asset,Available-for-use Date,Beschikbaar voor gebruik Datum
+DocType: Guardian,Guardian Name,Naam pleegouder
+DocType: Cheque Print Template,Has Print Format,Heeft Print Format
+DocType: Employee Loan,Sanctioned,Sanctioned
+apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,is verplicht. Misschien is dit Valuta record niet gemaakt voor
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139,Row #{0}: Please specify Serial No for Item {1},Rij #{0}: Voer serienummer in voor artikel {1}
+DocType: Crop Cycle,Crop Cycle,Crop Cycle
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Voor &#39;Product Bundel&#39; items, Warehouse, Serienummer en Batch Geen zal worden beschouwd van de &#39;Packing List&#39; tafel. Als Warehouse en Batch Geen zijn hetzelfde voor alle verpakking items voor welke &#39;Product Bundle&#39; punt, kunnen die waarden in de belangrijkste Item tafel worden ingevoerd, wordt waarden worden gekopieerd naar &quot;Packing List &#39;tafel."
+DocType: Student Admission,Publish on website,Publiceren op de website
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Leverancier Factuurdatum kan niet groter zijn dan Posting Date
+DocType: Purchase Invoice Item,Purchase Order Item,Inkooporder Artikel
+DocType: Agriculture Task,Agriculture Task,Landbouwtaak
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Indirecte Inkomsten
+DocType: Student Attendance Tool,Student Attendance Tool,Student Attendance Tool
+DocType: Restaurant Menu,Price List (Auto created),Prijslijst (automatisch aangemaakt)
+DocType: Cheque Print Template,Date Settings,date Settings
+apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Variantie
+,Company Name,Bedrijfsnaam
+DocType: SMS Center,Total Message(s),Totaal Bericht(en)
+DocType: Share Balance,Purchased,Gekocht
+DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Kenmerkwaarde in itemkenmerk wijzigen.
+DocType: Purchase Invoice,Additional Discount Percentage,Extra Korting Procent
+apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Bekijk een overzicht van alle hulp video&#39;s
+DocType: Agriculture Analysis Criteria,Soil Texture,Bodemstructuur
+DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Selecteer hoofdrekening van de bank waar cheque werd gedeponeerd.
+DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Zodat de gebruiker te bewerken prijslijst Rate bij transacties
+DocType: Pricing Rule,Max Qty,Max Aantal
+apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25,Print Report Card,Rapportkaart afdrukken
+apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
+						Please enter a valid Invoice","Rij {0}: Invoice {1} is ongeldig, het zou kunnen worden opgezegd / niet bestaat. \ Voer een geldige factuur"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Rij {0}: Betaling tegen Sales / Purchase Order moet altijd worden gemarkeerd als voorschot
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Chemisch
+DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Default Bank / Cash account wordt automatisch bijgewerkt in Salaris Journal Entry als deze modus wordt geselecteerd.
+DocType: BOM,Raw Material Cost(Company Currency),Grondstofkosten (Company Munt)
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Rij # {0}: De tarief kan niet groter zijn dan de tarief die wordt gebruikt in {1} {2}
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Rij # {0}: De tarief kan niet groter zijn dan de tarief die wordt gebruikt in {1} {2}
+apps/erpnext/erpnext/utilities/user_progress.py +147,Meter,Meter
+DocType: Workstation,Electricity Cost,elektriciteitskosten
+apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23,Lab testing datetime cannot be before collection datetime,Labetesten van datetime kan niet vóór verzameling datetime zijn
+DocType: HR Settings,Don't send Employee Birthday Reminders,Stuur geen Werknemer verjaardagsherinneringen
+DocType: Expense Claim,Total Advance Amount,Totaal voorschotbedrag
+DocType: Delivery Stop,Estimated Arrival,Geschatte aankomst
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Instellingen opslaan
+DocType: Delivery Stop,Notified by Email,Aangemeld per e-mail
+DocType: Item,Inspection Criteria,Inspectie Criteria
+apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Overgebrachte
+DocType: BOM Website Item,BOM Website Item,BOM Website Item
+apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Upload uw brief hoofd en logo. (Je kunt ze later bewerken).
+DocType: Timesheet Detail,Bill,Bill
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date is entered as past date,Volgende Afschrijvingen Date wordt ingevoerd als datum in het verleden
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Wit
+DocType: SMS Center,All Lead (Open),Alle Leads (Open)
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Rij {0}: Aantal niet beschikbaar voor {4} in het magazijn van {1} op het plaatsen van tijd van de invoer ({2} {3})
+apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,U kunt maximaal één optie selecteren in de lijst met selectievakjes.
+DocType: Purchase Invoice,Get Advances Paid,Get betaalde voorschotten
+DocType: Item,Automatically Create New Batch,Maak automatisch een nieuwe partij aan
+DocType: Item,Automatically Create New Batch,Maak automatisch een nieuwe partij aan
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635,Assigning {0} to {1} (row {2}),{0} toewijzen aan {1} (rij {2})
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Make ,Maken
+DocType: Student Admission,Admission Start Date,Entree Startdatum
+DocType: Journal Entry,Total Amount in Words,Totaal bedrag in woorden
+apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Nieuwe medewerker
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Er is een fout opgetreden . Een mogelijke reden zou kunnen zijn dat u het formulier niet hebt opgeslagen. Neem contact op met Support als het probleem aanhoudt .
+apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Mijn winkelwagen
+apps/erpnext/erpnext/controllers/selling_controller.py +130,Order Type must be one of {0},Order Type moet één van {0} zijn
+DocType: Lead,Next Contact Date,Volgende Contact Datum
+apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Opening Aantal
+DocType: Healthcare Settings,Appointment Reminder,Benoemingsherinnering
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478,Please enter Account for Change Amount,Vul Account for Change Bedrag
+DocType: Program Enrollment Tool Student,Student Batch Name,Student batchnaam
+DocType: Consultation,Doctor,dokter
+DocType: Holiday List,Holiday List Name,Holiday Lijst Naam
+DocType: Repayment Schedule,Balance Loan Amount,Balans Leningsbedrag
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Schedule Course
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Stock Options,Aandelenopties
+DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Schakel het ophalen van de laatste aankoopdetails in de bestelling uit
+DocType: Journal Entry Account,Expense Claim,Kostendeclaratie
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +267,Do you really want to restore this scrapped asset?,Wilt u deze schrapte activa echt herstellen?
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381,Qty for {0},Aantal voor {0}
+DocType: Leave Application,Leave Application,Verlofaanvraag
+DocType: Patient,Patient Relation,Patiëntrelatie
+apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Verlof Toewijzing Tool
+DocType: Item,Hub Category to Publish,Hubcategorie om te publiceren
+DocType: Leave Block List,Leave Block List Dates,Laat Block List Data
+DocType: Sales Invoice,Billing Address GSTIN,Factuuradres GSTIN
+DocType: Assessment Plan,Evaluate,schatten
+DocType: Workstation,Net Hour Rate,Netto uurtarief
+DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Vrachtkosten Inkoop Ontvangstbewijs
+DocType: Company,Default Terms,Default Voorwaarden
+DocType: Supplier Scorecard Period,Criteria,criteria
+DocType: Packing Slip Item,Packing Slip Item,Pakbon Artikel
+DocType: Purchase Invoice,Cash/Bank Account,Kas/Bankrekening
+apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Geef een {0}
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,Removed items with no change in quantity or value.,Verwijderde items met geen verandering in de hoeveelheid of waarde.
+DocType: Delivery Note,Delivery To,Leveren Aan
+apps/erpnext/erpnext/stock/doctype/item/item.js +415,Variant creation has been queued.,Het maken van varianten is in de wachtrij geplaatst.
+apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Werkoverzicht voor {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +696,Attribute table is mandatory,Attributentabel is verplicht
+DocType: Production Plan,Get Sales Orders,Get Verkooporders
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68,{0} can not be negative,{0} kan niet negatief zijn
+DocType: Training Event,Self-Study,Zelfstudie
+apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27,Soil compositions do not add up to 100,Bodemsamenstellingen tellen niet op tot 100
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +567,Discount,Korting
+DocType: Membership,Membership,Lidmaatschap
+DocType: Asset,Total Number of Depreciations,Totaal aantal Afschrijvingen
+DocType: Sales Invoice Item,Rate With Margin,Beoordeel met marges
+DocType: Workstation,Wages,Loon
+DocType: Asset Maintenance,Maintenance Manager Name,Naam onderhoudsmanager
+DocType: Agriculture Task,Urgent,Dringend
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Geef een geldige rij-ID voor rij {0} in tabel {1}
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Kan variabele niet vinden:
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +807,Please select a field to edit from numpad,Selecteer alstublieft een veld om van numpad te bewerken
+apps/erpnext/erpnext/stock/doctype/item/item.py +264,Cannot be a fixed asset item as Stock Ledger is created.,Kan geen vast activumartikel zijn omdat het grootboek Voorraad wordt gecreëerd.
+apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Ga naar het bureaublad om aan de slag te gaan met ERPNext
+DocType: Item,Manufacturer,Fabrikant
+DocType: Landed Cost Item,Purchase Receipt Item,Ontvangstbevestiging Artikel
+DocType: Purchase Receipt,PREC-RET-,PREC-terugwerkende
+DocType: POS Profile,Sales Invoice Payment,Sales Invoice Betaling
+DocType: Quality Inspection Template,Quality Inspection Template Name,Kwaliteit inspectiesjabloon naam
+DocType: Project,First Email,Eerste e-mail
+DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Gereserveerd Magazijn in Verkooporder / Magazijn Gereed Product
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Selling Bedrag
+DocType: Repayment Schedule,Interest Amount,Interestbedrag
+DocType: Serial No,Creation Document No,Aanmaken Document nr
+DocType: Share Transfer,Issue,Kwestie
+apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,archief
+DocType: Asset,Scrapped,gesloopt
+DocType: Purchase Invoice,Returns,opbrengst
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42,WIP Warehouse,WIP Warehouse
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serienummer {0} valt binnen onderhoudscontract tot {1}
+apps/erpnext/erpnext/config/hr.py +35,Recruitment,Werving
+DocType: Lead,Organization Name,Naam van de Organisatie
+DocType: Tax Rule,Shipping State,Scheepvaart State
+,Projected Quantity as Source,Geprojecteerd Hoeveelheid als Bron
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Het punt moet worden toegevoegd met behulp van 'Get Items uit Aankoopfacturen' knop
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858,Delivery Trip,Levering reis
+DocType: Student,A-,A-
+DocType: Share Transfer,Transfer Type,Overdrachtstype
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Verkoopkosten
+DocType: Consultation,Diagnosis,Diagnose
+apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standard kopen
+DocType: GL Entry,Against,Tegen
+DocType: Item,Default Selling Cost Center,Standaard Verkoop kostenplaats
+apps/erpnext/erpnext/public/js/pos/pos.html +85,Disc,Schijf
+DocType: Sales Partner,Implementation Partner,Implementatie Partner
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1624,ZIP Code,Postcode
+apps/erpnext/erpnext/controllers/selling_controller.py +252,Sales Order {0} is {1},Sales Order {0} is {1}
+DocType: Opportunity,Contact Info,Contact Info
+apps/erpnext/erpnext/config/stock.py +323,Making Stock Entries,Maken Stock Inzendingen
+DocType: Packing Slip,Net Weight UOM,Netto Gewicht Eenheid
+DocType: Item,Default Supplier,Standaardleverancier
+DocType: Manufacturing Settings,Over Production Allowance Percentage,Over Production Allowance Percentage
+DocType: Employee Loan,Repayment Schedule,Terugbetalingsschema
+DocType: Shipping Rule Condition,Shipping Rule Condition,Verzendregel Voorwaarde
+DocType: Holiday List,Get Weekly Off Dates,Ontvang wekelijkse Uit Data
+apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Einddatum kan niet vroeger zijn dan startdatum
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337,Invoice can't be made for zero billing hour,De factuur kan niet worden gemaakt voor uren facturering
+DocType: Sales Person,Select company name first.,Kies eerst een bedrijfsnaam.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189,Email sent to {0},E-mail verzonden naar {0}
+apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Offertes ontvangen van leveranciers.
+apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Vervang BOM en update de laatste prijs in alle BOM&#39;s
+apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},Naar {0} | {1} {2}
+DocType: Delivery Trip,Driver Name,Naam van de bestuurder
+apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Gemiddelde Leeftijd
+DocType: Education Settings,Attendance Freeze Date,Bijwonen Vries Datum
+DocType: Education Settings,Attendance Freeze Date,Bijwonen Vries Datum
+apps/erpnext/erpnext/utilities/user_progress.py +110,List a few of your suppliers. They could be organizations or individuals.,Lijst een paar van uw leveranciers . Ze kunnen organisaties of personen .
+apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Bekijk alle producten
+apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimum leeftijd (dagen)
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60,All BOMs,alle stuklijsten
+apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Hotelkamers van het type {0} zijn niet beschikbaar op {1}
+DocType: Patient,Default Currency,Standaard valuta
+DocType: Expense Claim,From Employee,Van Medewerker
+DocType: Driver,Cellphone Number,mobiel nummer
+DocType: Project,Monitor Progress,Voortgang in de gaten houden
+apps/erpnext/erpnext/controllers/accounts_controller.py +472,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Waarschuwing: Het systeem zal niet controleren overbilling sinds bedrag voor post {0} in {1} nul
+DocType: Journal Entry,Make Difference Entry,Maak Verschil Entry
+DocType: Upload Attendance,Attendance From Date,Aanwezigheid Van Datum
+DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
+DocType: Program Enrollment,Transportation,Vervoer
+apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,ongeldige attribuut
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240,{0} {1} must be submitted,{0} {1} moet worden ingediend
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},Hoeveelheid moet kleiner dan of gelijk aan {0}
+DocType: SMS Center,Total Characters,Totaal Tekens
+DocType: Employee Advance,Claimed,beweerde
+DocType: Crop,Row Spacing,Rijafstand
+apps/erpnext/erpnext/controllers/buying_controller.py +165,Please select BOM in BOM field for Item {0},Selecteer BOM in BOM veld voor post {0}
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +22,There isn't any item variant for the selected item,Er is geen artikelvariant voor het geselecteerde artikel
+DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Factuurspecificatie
+DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Afletteren Factuur
+apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38,Contribution %,Bijdrage %
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Conform de Aankoop Instellingen indien Aankoop Order Vereist == 'JA', dient de gebruiker eerst een Aankoop Order voor item {0} aan te maken om een Aankoop Factuur aan te kunnen maken"
+DocType: Company,Company registration numbers for your reference. Tax numbers etc.,"Registratienummers van de onderneming voor uw referentie. Fiscale nummers, enz."
+DocType: Sales Partner,Distributor,Distributeur
+DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Winkelwagen Verzenden Regel
+apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Stel &#39;Solliciteer Extra Korting op&#39;
+,Ordered Items To Be Billed,Bestelde artikelen te factureren
+apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Van Range moet kleiner zijn dan om het bereik
+DocType: Global Defaults,Global Defaults,Global Standaardwaarden
+apps/erpnext/erpnext/projects/doctype/project/project.py +230,Project Collaboration Invitation,Project Uitnodiging Collaboration
+DocType: Salary Slip,Deductions,Inhoudingen
+DocType: Leave Allocation,LAL/,LAL /
+DocType: Setup Progress Action,Action Name,Actie Naam
+apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Start Jaar
+apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},De eerste 2 cijfers van GSTIN moeten overeenkomen met staat nummer {0}
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77,PDC/LC,PDC / LC
+DocType: Purchase Invoice,Start date of current invoice's period,Begindatum van de huidige factuurperiode
+DocType: Salary Slip,Leave Without Pay,Onbetaald verlof
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385,Capacity Planning Error,Capacity Planning Fout
+,Trial Balance for Party,Trial Balance voor Party
+DocType: Lead,Consultant,Consultant
+apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356,Parents Teacher Meeting Attendance,Ouders Teacher Meeting presentielijst
+DocType: Salary Slip,Earnings,Verdiensten
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +443,Finished Item {0} must be entered for Manufacture type entry,Afgewerkte product {0} moet worden ingevoerd voor het type Productie binnenkomst
+apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Het openen van Accounting Balance
+,GST Sales Register,GST Sales Register
+DocType: Sales Invoice Advance,Sales Invoice Advance,Verkoopfactuur Voorschot
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Niets aan te vragen
+apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Selecteer uw domeinen
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Een andere Budget plaat &#39;{0}&#39; bestaat al tegen {1} {2} &#39;voor het fiscale jaar {3}
+DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Velden worden alleen gekopieerd op het moment van creatie.
+DocType: Setup Progress Action,Domains,Domeinen
+apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date','Werkelijke Startdatum' kan niet groter zijn dan 'Werkelijke Einddatum'
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Beheer
+DocType: Cheque Print Template,Payer Settings,Payer Instellingen
+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""","Dit zal worden toegevoegd aan de Code van het punt van de variant. Bijvoorbeeld, als je de afkorting is ""SM"", en de artikelcode is ""T-SHIRT"", de artikelcode van de variant zal worden ""T-SHIRT-SM"""
+DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Nettoloon (in woorden) zal zichtbaar zijn zodra de Salarisstrook wordt opgeslagen.
+DocType: Purchase Invoice,Is Return,Is Return
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,Caution,Voorzichtigheid
+apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17,Start day is greater than end day in task '{0}',Startdag is groter dan einddag in taak &#39;{0}&#39;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815,Return / Debit Note,Return / betaalkaart Note
+DocType: Price List Country,Price List Country,Prijslijst Land
+DocType: Item,UOMs,UOMs
+apps/erpnext/erpnext/stock/utils.py +212,{0} valid serial nos for Item {1},{0} geldig serienummers voor Artikel {1}
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Artikelcode kan niet worden gewijzigd voor Serienummer
+DocType: Purchase Invoice Item,UOM Conversion Factor,Eenheid Omrekeningsfactor
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Vul de artikelcode voor Batch Number krijgen
+DocType: Stock Settings,Default Item Group,Standaard Artikelgroep
+DocType: Employee Loan,Partially Disbursed,gedeeltelijk uitbetaald
+apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Informatie verstrekken.
+apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Leverancierbestand
+DocType: Account,Balance Sheet,Balans
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750,Cost Center For Item with Item Code ',Kostenplaats Item met Item Code '
+DocType: Fee Validity,Valid Till,Geldig tot
+DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Totale ouder lerarenbijeenkomst
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2512,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Betaling Mode is niet geconfigureerd. Controleer, of rekening is ingesteld op de wijze van betalingen of op POS Profile."
+apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Hetzelfde item kan niet meerdere keren worden ingevoerd.
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","Verdere accounts kan worden gemaakt onder groepen, maar items kunnen worden gemaakt tegen niet-Groepen"
+DocType: Lead,Lead,Lead
+DocType: Email Digest,Payables,Schulden
+DocType: Course,Course Intro,cursus Intro
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Stock Entry {0} aangemaakt
+apps/erpnext/erpnext/controllers/buying_controller.py +322,Row #{0}: Rejected Qty can not be entered in Purchase Return,Rij # {0}: Afgekeurd Aantal niet in Purchase Return kunnen worden ingevoerd
+apps/erpnext/erpnext/stock/doctype/item/item.js +182,Changing Customer Group for the selected Customer is not allowed.,Het wijzigen van de klantengroep voor de geselecteerde klant is niet toegestaan.
+,Purchase Order Items To Be Billed,Inkooporder Artikelen nog te factureren
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63,Updating estimated arrival times.,Bijwerken geschatte aankomsttijden.
+DocType: Program Enrollment Tool,Enrollment Details,Inschrijfgegevens
+DocType: Purchase Invoice Item,Net Rate,Net Rate
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152,Please select a customer,Selecteer een klant alsjeblieft
+DocType: Purchase Invoice Item,Purchase Invoice Item,Inkoopfactuur Artikel
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Voorraad boekingen en Journaalposten worden opnieuw geboekt voor de geselecteerde Ontvangstbewijzen
+DocType: Student Report Generation Tool,Assessment Terms,Beoordelingsvoorwaarden
+apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Punt 1
+DocType: Holiday,Holiday,Feestdag
+DocType: Support Settings,Close Issue After Days,Sluiten Probleem Na Days
+DocType: Leave Control Panel,Leave blank if considered for all branches,Laat leeg indien dit voor alle vestigingen is
+DocType: Bank Guarantee,Validity in Days,Geldigheid in dagen
+DocType: Bank Guarantee,Validity in Days,Geldigheid in dagen
+apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-vorm is niet van toepassing voor de factuur: {0}
+DocType: Payment Reconciliation,Unreconciled Payment Details,Niet overeenstemmende betalingsgegevens
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Ledenactiviteit
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Order Count
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Order Count
+DocType: Global Defaults,Current Fiscal Year,Huidige fiscale jaar
+DocType: Purchase Order,Group same items,Groep dezelfde items
+DocType: Purchase Invoice,Disable Rounded Total,Deactiveer Afgerond Totaal
+DocType: Employee Loan Application,Repayment Info,terugbetaling Info
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,'Invoer' kan niet leeg zijn
+DocType: Maintenance Team Member,Maintenance Role,Onderhoudsrol
+apps/erpnext/erpnext/utilities/transaction_base.py +92,Duplicate row {0} with same {1},Dubbele rij {0} met dezelfde {1}
+,Trial Balance,Proefbalans
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443,Fiscal Year {0} not found,Boekjaar {0} niet gevonden
+apps/erpnext/erpnext/config/hr.py +309,Setting up Employees,Het opzetten van Werknemers
+DocType: Sales Order,SO-,ZO-
+DocType: Hotel Room Reservation,Hotel Reservation User,Hotelreservering Gebruiker
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158,Please select prefix first,Selecteer eerst een voorvoegsel
+DocType: Student,O-,O-
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,onderzoek
+DocType: Maintenance Visit Purpose,Work Done,Afgerond Werk
+apps/erpnext/erpnext/controllers/item_variant.py +35,Please specify at least one attribute in the Attributes table,Gelieve ten minste één attribuut in de tabel attributen opgeven
+DocType: Announcement,All Students,Alle studenten
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Item {0} moet een niet-voorraad artikel zijn
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Bekijk Grootboek
+DocType: Grading Scale,Intervals,intervallen
+apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Vroegst
+apps/erpnext/erpnext/stock/doctype/item/item.py +526,"An Item Group exists with same name, please change the item name or rename the item group","Een artikel Group bestaat met dezelfde naam , moet u de naam van het item of de naam van de artikelgroep"
+DocType: Crop Cycle,Less than a year,Minder dan een jaar
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +104,Rest Of The World,Rest van de Wereld
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,De Punt {0} kan niet Batch hebben
+DocType: Crop,Yield UOM,Opbrengst UOM
+,Budget Variance Report,Budget Variantie Rapport
+DocType: Salary Slip,Gross Pay,Brutoloon
+DocType: Item,Is Item from Hub,Is item van Hub
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Activity Type is mandatory.,Rij {0}: Activiteit Type is verplicht.
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Dividenden betaald
+apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Boekhoudboek
+DocType: Stock Reconciliation,Difference Amount,Verschil Bedrag
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Dr {0} on Leave on {1},Dr {0} bij Verlof op {1}
+DocType: Purchase Invoice,Reverse Charge,Reverse Charge
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Ingehouden winsten
+DocType: Purchase Invoice,05-Change in POS,05-Verandering in POS
+DocType: Vehicle Log,Service Detail,dienst Detail
+DocType: BOM,Item Description,Artikelomschrijving
+DocType: Student Sibling,Student Sibling,student Sibling
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18,Payment Mode,Betaling Mode
+DocType: Purchase Invoice,Supplied Items,Geleverde Artikelen
+apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Stel een actief menu in voor Restaurant {0}
+DocType: Student,STUD.,Stud.
+DocType: Work Order,Qty To Manufacture,Aantal te produceren
+DocType: Email Digest,New Income,nieuwe Inkomen
+DocType: Buying Settings,Maintain same rate throughout purchase cycle,Handhaaf zelfde tarief gedurende inkoopcyclus
+DocType: Opportunity Item,Opportunity Item,Opportuniteit artikel
+,Student and Guardian Contact Details,Student and Guardian Contactgegevens
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53,Row {0}: For supplier {0} Email Address is required to send email,Rij {0}: Voor leveranciers {0} e-mailadres is vereist om e-mail te sturen
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Tijdelijke Opening
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10,View Hub,Hub bekijken
+,Employee Leave Balance,Werknemer Verlof Balans
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Saldo van rekening {0} moet altijd {1} zijn
+DocType: Patient Appointment,More Info,Meer info
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Valuation Rate vereist voor post in rij {0}
+DocType: Supplier Scorecard,Scorecard Actions,Scorecard Acties
+apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Masters in Computer Science,Voorbeeld: Masters in Computer Science
+DocType: Purchase Invoice,Rejected Warehouse,Afgewezen Magazijn
+DocType: GL Entry,Against Voucher,Tegen Voucher
+DocType: Item,Default Buying Cost Center,Standaard Inkoop kostenplaats
+apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Om het beste uit ERPNext krijgen, raden wij u aan wat tijd te nemen en te kijken deze hulp video&#39;s."
+apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,naar
+DocType: Supplier Quotation Item,Lead Time in days,Levertijd in dagen
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70,Accounts Payable Summary,Crediteuren Samenvatting
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326,Payment of salary from {0} to {1},De betaling van het salaris van {0} tot {1}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Niet bevoegd om bevroren rekening te bewerken {0}
+DocType: Journal Entry,Get Outstanding Invoices,Get openstaande facturen
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84,Sales Order {0} is not valid,Verkooporder {0} is niet geldig
+DocType: Supplier Scorecard,Warn for new Request for Quotations,Waarschuw voor nieuw verzoek om offertes
+apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Inkooporders helpen bij het plannen en opvolgen van uw aankopen
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Lab Test Prescriptions
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166,"The total Issue / Transfer quantity {0} in Material Request {1}  \
+							cannot be greater than requested quantity {2} for Item {3}",De totale Issue / Transfer hoeveelheid {0} in Materiaal Request {1} \ kan niet groter zijn dan de gevraagde hoeveelheid {2} voor post zijn {3}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Klein
+DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Het item voor het creëren van facturen openen
+DocType: Education Settings,Employee Number,Werknemer Nummer
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Zaak nr. ( s ) al in gebruik. Probeer uit Zaak nr. {0}
+DocType: Project,% Completed,% Voltooid
+,Invoiced Amount (Exculsive Tax),Factuurbedrag (excl BTW)
+apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Punt 2
+DocType: Supplier,SUPP-,SUPP-
+DocType: Training Event,Training Event,training Event
+DocType: Item,Auto re-order,Auto re-order
+apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Totaal Bereikt
+DocType: Employee,Place of Issue,Plaats van uitgifte
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Contract
+DocType: Plant Analysis,Laboratory Testing Datetime,Laboratoriumtest Datetime
+DocType: Email Digest,Add Quote,Quote voegen
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031,UOM coversion factor required for UOM: {0} in Item: {1},Eenheid Omrekeningsfactor is nodig voor eenheid: {0} in Artikel: {1}
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Indirecte Kosten
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98,Row {0}: Qty is mandatory,Rij {0}: Aantal is verplicht
+DocType: Agriculture Analysis Criteria,Agriculture,landbouw
+apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Master Data,Sync Master Data
+DocType: Asset Repair,Repair Cost,reparatiekosten
+apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,Uw producten of diensten
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Inloggen mislukt
+DocType: Special Test Items,Special Test Items,Speciale testartikelen
+DocType: Mode of Payment,Mode of Payment,Wijze van betaling
+apps/erpnext/erpnext/stock/doctype/item/item.py +202,Website Image should be a public file or website URL,Website Afbeelding moet een openbaar bestand of website URL zijn
+DocType: Student Applicant,AP,AP
+DocType: Purchase Invoice Item,BOM,BOM
+apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Dit is een basis artikelgroep en kan niet worden bewerkt .
+DocType: Journal Entry Account,Purchase Order,Inkooporder
+DocType: Vehicle,Fuel UOM,Fuel UOM
+DocType: Warehouse,Warehouse Contact Info,Magazijn Contact Info
+DocType: Payment Entry,Write Off Difference Amount,Schrijf Off Verschil Bedrag
+DocType: Volunteer,Volunteer Name,Vrijwilligers naam
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: Employee e-mail niet gevonden, dus geen e-mail verzonden"
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Verzendregel niet van toepassing voor land {0}
+DocType: Item,Foreign Trade Details,Buitenlandse Handel Details
+,Assessment Plan Status,Beoordelingsplan Status
+DocType: Email Digest,Annual Income,Jaarlijks inkomen
+DocType: Serial No,Serial No Details,Serienummer Details
+DocType: Purchase Invoice Item,Item Tax Rate,Artikel BTW-tarief
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89,Please select Physician and Date,Selecteer alsjeblieft arts en datum
+DocType: Student Group Student,Group Roll Number,Groepsrolnummer
+DocType: Student Group Student,Group Roll Number,Groepsrolnummer
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry","Voor {0}, kan alleen credit accounts worden gekoppeld tegen een andere debetboeking"
+apps/erpnext/erpnext/projects/doctype/project/project.py +84,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Totaal van alle taak gewichten moeten 1. Pas gewichten van alle Project taken dienovereenkomstig
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588,Delivery Note {0} is not submitted,Vrachtbrief {0} is niet ingediend
+apps/erpnext/erpnext/stock/get_item_details.py +148,Item {0} must be a Sub-contracted Item,Artikel {0} moet een uitbesteed artikel zijn
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Kapitaalgoederen
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Prijsbepalingsregel wordt eerst geselecteerd op basis van 'Toepassen op' veld, dat kan zijn artikel, artikelgroep of merk."
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246,Please set the Item Code first,Stel eerst de productcode in
+DocType: Item,ITEM-,ITEM-
+apps/erpnext/erpnext/controllers/selling_controller.py +123,Total allocated percentage for sales team should be 100,Totaal toegewezen percentage voor verkoopteam moet 100 zijn
+DocType: Sales Invoice Item,Edit Description,Bewerken Beschrijving
+DocType: Antibiotic,Antibiotic,Antibioticum
+,Team Updates,team updates
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912,For Supplier,voor Leverancier
+DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Instellen Account Type helpt bij het selecteren van deze account in transacties.
+DocType: Purchase Invoice,Grand Total (Company Currency),Grand Total (Company Munt)
+apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Maak Print Format
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Fee gemaakt
+apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Item met de naam {0} niet gevonden
+DocType: Supplier Scorecard Criteria,Criteria Formula,Criteria Formule
+apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Total Outgoing,Totaal Uitgaande
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Er kan maar één Verzendregel Voorwaarde met 0 of blanco waarde zijn voor ""To Value """
+DocType: Authorization Rule,Transaction,Transactie
+DocType: Patient Appointment,Duration,Looptijd
+apps/erpnext/erpnext/controllers/status_updater.py +160,"For an item {0}, quantity must be positive number",Voor een artikel {0} moet het aantal positief zijn
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Opmerking: Deze kostenplaats is een groep. Kan geen boekingen aanmaken voor groepen.
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53,Child warehouse exists for this warehouse. You can not delete this warehouse.,Child magazijn bestaat voor dit magazijn. U kunt dit magazijn niet verwijderen.
+DocType: Item,Website Item Groups,Website Artikelgroepen
+DocType: Purchase Invoice,Total (Company Currency),Totaal (Company valuta)
+DocType: Daily Work Summary Group,Reminder,Herinnering
+apps/erpnext/erpnext/stock/utils.py +207,Serial number {0} entered more than once,Serienummer {0} meer dan eens ingevoerd
+DocType: Journal Entry,Journal Entry,Journaalpost
+DocType: Expense Claim Advance,Unclaimed amount,Niet-opgeëist bedrag
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148,{0} items in progress,{0} items in progress
+DocType: Workstation,Workstation Name,Naam van werkstation
+DocType: Grading Scale Interval,Grade Code,Grade Code
+DocType: POS Item Group,POS Item Group,POS Item Group
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-mail Digest:
+apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +23,Alternative item must not be same as item code,Alternatief artikel mag niet hetzelfde zijn als artikelcode
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +617,BOM {0} does not belong to Item {1},Stuklijst {0} behoort niet tot Artikel {1}
+DocType: Sales Partner,Target Distribution,Doel Distributie
+DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Finalisatie van voorlopige beoordeling
+DocType: Salary Slip,Bank Account No.,Bankrekeningnummer
+DocType: Naming Series,This is the number of the last created transaction with this prefix,Dit is het nummer van de laatst gemaakte transactie met dit voorvoegsel
+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 variabelen kunnen worden gebruikt, evenals: {total_score} (de totale score van die periode), {period_number} (het aantal dagen dat de dag is)"
+DocType: Quality Inspection Reading,Reading 8,Meting 8
+DocType: Sales Partner,Agent,Agent
+DocType: Purchase Invoice,Taxes and Charges Calculation,Belastingen en Toeslagen berekenen
+DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Automatische afschrijving van de activa van de boekwaarde
+DocType: BOM Operation,Workstation,Werkstation
+DocType: Request for Quotation Supplier,Request for Quotation Supplier,Offerte Supplier
+DocType: Healthcare Settings,Registration Message,Registratie Bericht
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,hardware
+DocType: Prescription Dosage,Prescription Dosage,Voorschrift Dosering
+DocType: Attendance,HR Manager,HR Manager
+apps/erpnext/erpnext/accounts/party.py +175,Please select a Company,Selecteer aub een andere vennootschap
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Bijzonder Verlof
+DocType: Purchase Invoice,Supplier Invoice Date,Factuurdatum Leverancier
+DocType: Asset Settings,This value is used for pro-rata temporis calculation,Deze waarde wordt gebruikt voor pro-rata temporisberekening
+apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,U moet Winkelwagen activeren.
+DocType: Payment Entry,Writeoff,Afschrijven
+DocType: Stock Settings,Naming Series Prefix,Reeks voorvoegsel naamgeving
+DocType: Appraisal Template Goal,Appraisal Template Goal,Beoordeling Sjabloon Doel
+DocType: Salary Component,Earning,Verdienen
+DocType: Supplier Scorecard,Scoring Criteria,Scoring Criteria
+DocType: Purchase Invoice,Party Account Currency,Party account Valuta
+,BOM Browser,BOM Browser
+apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Update uw status voor dit trainingsevenement
+DocType: Item Barcode,EAN,EAN
+DocType: Purchase Taxes and Charges,Add or Deduct,Toevoegen of aftrekken
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Overlappende voorwaarden gevonden tussen :
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Tegen Journal Entry {0} is al aangepast tegen enkele andere voucher
+apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Totale orderwaarde
+apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Voeding
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57,Ageing Range 3,Vergrijzing Range 3
+DocType: Maintenance Schedule Item,No of Visits,Aantal bezoeken
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Onderhoudsplan {0} bestaat tegen {1}
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,student die zich inschrijft
+apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Valuta van de Closing rekening moet worden {0}
+apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Som van de punten voor alle doelen moeten zijn 100. Het is {0}
+DocType: Project,Start and End Dates,Begin- en einddatum
+,Delivered Items To Be Billed,Geleverde Artikelen nog te factureren
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Open BOM {0}
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Magazijn kan niet worden gewijzigd voor Serienummer
+DocType: Authorization Rule,Average Discount,Gemiddelde korting
+DocType: Project Update,Great/Quickly,Great / Snel
+DocType: Purchase Invoice Item,UOM,UOM
+DocType: Rename Tool,Utilities,Utilities
+DocType: POS Profile,Accounting,Boekhouding
+DocType: Employee,EMP/,EMP /
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +138,Please select batches for batched item ,Selecteer batches voor batched item
+DocType: Asset,Depreciation Schedules,afschrijvingen Roosters
+apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192,Following accounts might be selected in GST Settings:,Volgende accounts kunnen worden geselecteerd in GST-instellingen:
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70,Application period cannot be outside leave allocation period,Aanvraagperiode kan buiten verlof toewijzingsperiode niet
+DocType: Activity Cost,Projects,Projecten
+DocType: Payment Request,Transaction Currency,transactie Munt
+apps/erpnext/erpnext/controllers/buying_controller.py +31,From {0} | {1} {2},Van {0} | {1} {2}
+DocType: Work Order Operation,Operation Description,Operatie Beschrijving
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Kan boekjaar startdatum en einddatum niet wijzigen eenmaal het boekjaar is opgeslagen.
+DocType: Quotation,Shopping Cart,Winkelwagen
+apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Avg Daily Outgoing,Gem Daily Uitgaande
+DocType: POS Profile,Campaign,Campagne
+DocType: Supplier,Name and Type,Naam en Type
+DocType: Physician,Contacts and Address,Contacten en adres
+DocType: Purchase Invoice,Contact Person,Contactpersoon
+apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date','Verwacht Startdatum' kan niet groter zijn dan 'Verwachte Einddatum'
+DocType: Course Scheduling Tool,Course End Date,Cursus Einddatum
+DocType: Holiday List,Holidays,Feestdagen
+DocType: Sales Order Item,Planned Quantity,Gepland Aantal
+DocType: Purchase Invoice Item,Item Tax Amount,Artikel BTW-bedrag
+DocType: Water Analysis,Water Analysis Criteria,Criteria voor wateranalyse
+DocType: Item,Maintain Stock,Handhaaf Stock
+DocType: Employee,Prefered Email,Prefered Email
+DocType: Student Admission,Eligibility and Details,Geschiktheid en details
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38,Net Change in Fixed Asset,Netto wijziging in vaste activa
+DocType: Leave Control Panel,Leave blank if considered for all designations,Laat leeg indien overwogen voor alle aanduidingen
+apps/erpnext/erpnext/controllers/accounts_controller.py +806,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Charge van het type ' Actual ' in rij {0} kan niet worden opgenomen in Item Rate
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382,Max: {0},Max: {0}
+apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Van Datetime
+DocType: Email Digest,For Company,Voor Bedrijf
+apps/erpnext/erpnext/config/support.py +17,Communication log.,Communicatie log.
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195,"Request for Quotation is disabled to access from portal, for more check portal settings.","Offerte is uitgeschakeld om de toegang van portal, voor meer controle portaal instellingen."
+DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Leverancier Scorecard Scorevariabele
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Aankoop Bedrag
+DocType: Sales Invoice,Shipping Address Name,Verzenden Adres Naam
+DocType: Material Request,Terms and Conditions Content,Algemene Voorwaarden Inhoud
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Er zijn fouten opgetreden bij het maken van cursusplanning
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581,cannot be greater than 100,mag niet groter zijn dan 100
+apps/erpnext/erpnext/stock/doctype/item/item.py +752,Item {0} is not a stock Item,Artikel {0} is geen voorraadartikel
+DocType: Maintenance Visit,Unscheduled,Ongeplande
+DocType: Employee,Owned,Eigendom
+DocType: Salary Detail,Depends on Leave Without Pay,Afhankelijk van onbetaald verlof
+DocType: Pricing Rule,"Higher the number, higher the priority","Hoe hoger het getal, hoe hoger de prioriteit"
+,Purchase Invoice Trends,Inkoopfactuur Trends
+DocType: Employee,Better Prospects,Betere vooruitzichten
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +217,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Rij # {0}: De partij {1} heeft slechts {2} aantal. Selecteer alstublieft een andere partij die {3} beschikbaar heeft of verdeel de rij in meerdere rijen, om te leveren / uit te voeren vanuit meerdere batches"
+DocType: Vehicle,License Plate,Nummerplaat
+DocType: Appraisal,Goals,Doelen
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +357,Select POS Profile,Selecteer POS-profiel
+DocType: Warranty Claim,Warranty / AMC Status,Garantie / AMC Status
+,Accounts Browser,Rekeningen Verkenner
+DocType: Payment Entry Reference,Payment Entry Reference,Betaling Entry Reference
+DocType: GL Entry,GL Entry,GL Entry
+DocType: HR Settings,Employee Settings,Werknemer Instellingen
+,Batch-Wise Balance History,Batchgewijze balansgeschiedenis
+apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Print instellingen bijgewerkt in de respectievelijke gedrukte vorm
+DocType: Package Code,Package Code,Package Code
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,leerling
+DocType: Purchase Invoice,Company GSTIN,Bedrijf GSTIN
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,Negative Quantity is not allowed,Negatieve Hoeveelheid is niet toegestaan
+DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
+Used for Taxes and Charges","Belasting detail tafel haalden van post meester als een string en opgeslagen in dit gebied.
+ Gebruikt voor en -heffingen"
+DocType: Supplier Scorecard Period,SSC-,SSC-
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Werknemer kan niet rapporteren aan zichzelf.
+DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Als de rekening is bevroren, kunnen boekingen alleen door daartoe bevoegde gebruikers gedaan worden."
+DocType: Email Digest,Bank Balance,Banksaldo
+apps/erpnext/erpnext/accounts/party.py +240,Accounting Entry for {0}: {1} can only be made in currency: {2},Rekening ingave voor {0}: {1} kan alleen worden gedaan in valuta: {2}
+DocType: Job Opening,"Job profile, qualifications required etc.","Functieprofiel, benodigde kwalificaties enz."
+DocType: Journal Entry Account,Account Balance,Rekeningbalans
+apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Fiscale Regel voor transacties.
+DocType: Rename Tool,Type of document to rename.,Type document te hernoemen.
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: een klant is vereist voor Te Ontvangen rekening {2}
+DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Totaal belastingen en toeslagen (Bedrijfsvaluta)
+DocType: Weather,Weather Parameter,Weerparameter
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Toon ongesloten fiscale jaar P &amp; L saldi
+DocType: Lab Test Template,Collection Details,Collectie Details
+DocType: POS Profile,Allow Print Before Pay,Sta Print vóór betalen toe
+DocType: Land Unit,Linked Soil Texture,Gekoppelde bodemtextuur
+DocType: Shipping Rule,Shipping Account,Verzending Rekening
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Account {2} is niet actief
+apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Maak verkooporders om u te helpen uw werk en leveren op tijd
+DocType: Quality Inspection,Readings,Lezingen
+DocType: Stock Entry,Total Additional Costs,Totaal Bijkomende kosten
+DocType: Course Schedule,SH,SH
+DocType: BOM,Scrap Material Cost(Company Currency),Scrap Materiaal Kosten (Company Munt)
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Uitbesteed werk
+DocType: Asset,Asset Name,Asset Naam
+DocType: Project,Task Weight,Task Weight
+DocType: Shipping Rule Condition,To Value,Tot Waarde
+DocType: Asset Movement,Stock Manager,Stock Manager
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171,Source warehouse is mandatory for row {0},Bron magazijn is verplicht voor rij {0}
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,De betalingstermijn op rij {0} is mogelijk een duplicaat.
+apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Landbouw (bèta)
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863,Packing Slip,Pakbon
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Kantoorhuur
+apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Instellingen SMS gateway
+DocType: Disease,Common Name,Gemeenschappelijke naam
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Importeren mislukt!
+apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Nog geen adres toegevoegd.
+DocType: Workstation Working Hour,Workstation Working Hour,Werkstation Werkuur
+DocType: Vital Signs,Blood Pressure,Bloeddruk
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,analist
+DocType: Item,Inventory,Voorraad
+DocType: Item,Sales Details,Verkoop Details
+DocType: Quality Inspection,QI-,Qi-
+DocType: Opportunity,With Items,Met Items
+DocType: Asset Maintenance,Maintenance Team,Onderhoudsteam
+apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,in Aantal
+DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Valideer ingeschreven cursus voor studenten in de studentengroep
+DocType: Notification Control,Expense Claim Rejected,Kostendeclaratie afgewezen
+DocType: Item,Item Attribute,Item Attribute
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Overheid
+apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Declaratie {0} bestaat al voor de Vehicle Log
+apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,naam van het instituut
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Vul hier terug te betalen bedrag
+apps/erpnext/erpnext/config/stock.py +313,Item Variants,Item Varianten
+apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Services
+DocType: HR Settings,Email Salary Slip to Employee,E-mail loonstrook te Employee
+DocType: Cost Center,Parent Cost Center,Bovenliggende kostenplaats
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Select Possible Supplier,Stel mogelijke Leverancier
+DocType: Sales Invoice,Source,Bron
+DocType: Customer,"Select, to make the customer searchable with these fields","Selecteer, om de klant doorzoekbaar te maken met deze velden"
+apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Toon gesloten
+DocType: Leave Type,Is Leave Without Pay,Is onbetaald verlof
+apps/erpnext/erpnext/stock/doctype/item/item.py +261,Asset Category is mandatory for Fixed Asset item,Asset Categorie is verplicht voor post der vaste activa
+DocType: Fee Validity,Fee Validity,Geldigheidsgeldigheid
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,Geen records gevonden in de betaling tabel
+apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Deze {0} in strijd is met {1} voor {2} {3}
+DocType: Student Attendance Tool,Students HTML,studenten HTML
+DocType: POS Profile,Apply Discount,Solliciteer Discount
+DocType: GST HSN Code,GST HSN Code,GST HSN-code
+DocType: Employee External Work History,Total Experience,Total Experience
+apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Open Projects
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295,Packing Slip(s) cancelled,Pakbon(nen) geannuleerd
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36,Cash Flow from Investing,De cashflow uit investeringsactiviteiten
+DocType: Program Course,Program Course,programma Course
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Vracht-en verzendkosten
+DocType: Homepage,Company Tagline for website homepage,Company Tag voor website homepage
+DocType: Item Group,Item Group Name,Artikel groepsnaam
+apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Ingenomen
+DocType: Student,Date of Leaving,Datum waarop het vaartuig
+DocType: Pricing Rule,For Price List,Voor Prijslijst
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Executive Search
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Standaardwaarden instellen
+apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Maak Leads
+DocType: Maintenance Schedule,Schedules,Schema
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +472,POS Profile is required to use Point-of-Sale,POS-profiel is vereist om Point-of-Sale te gebruiken
+DocType: Purchase Invoice Item,Net Amount,Netto Bedrag
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141,{0} {1} has not been submitted so the action cannot be completed,{0} {1} is niet ingediend dus de actie kan niet voltooid worden
+DocType: Purchase Order Item Supplied,BOM Detail No,Stuklijst Detail nr.
+DocType: Landed Cost Voucher,Additional Charges,Extra kosten
+DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Extra korting Bedrag (Company valuta)
+DocType: Supplier Scorecard,Supplier Scorecard,Leverancier Scorecard
+DocType: Plant Analysis,Result Datetime,Resultaat Datetime
+apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Maak nieuwe rekening van Rekeningschema.
+,Support Hour Distribution,Support Hour Distribution
+DocType: Maintenance Visit,Maintenance Visit,Onderhoud Bezoek
+DocType: Student,Leaving Certificate Number,Leaving Certificate Number
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58,"Appointment cancelled, Please review and cancel the invoice {0}","Afspraak geannuleerd, Controleer en annuleer de factuur {0}"
+DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Verkrijgbaar Aantal Batch bij Warehouse
+apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Bijwerken Print Format
+DocType: Landed Cost Voucher,Landed Cost Help,Vrachtkosten Help
+DocType: Purchase Invoice,Select Shipping Address,Selecteer Verzendadres
+DocType: Timesheet Detail,Expected Hrs,Verwachte uren
+apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Gegevens over lidmaatschap
+DocType: Leave Block List,Block Holidays on important days.,Blokkeer vakantie op belangrijke dagen.
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220,Please input all required Result Value(s),Voer alle vereiste resultaatwaarde (n) in
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106,Accounts Receivable Summary,Debiteuren Samenvatting
+DocType: Employee Loan,Monthly Repayment Amount,Maandelijks te betalen bedrag
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Facturen openen
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,Stel User ID veld in een Werknemer record Werknemer Rol stellen
+DocType: UOM,UOM Name,Eenheid Naam
+DocType: GST HSN Code,HSN Code,HSN-code
+apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39,Contribution Amount,Bijdrage hoeveelheid
+DocType: Purchase Invoice,Shipping Address,Verzendadres
+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.,Deze tool helpt u om te werken of te repareren de hoeveelheid en de waardering van de voorraad in het systeem. Het wordt meestal gebruikt om het systeem waarden en wat in uw magazijnen werkelijk bestaat synchroniseren.
+DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,In Woorden zijn zichtbaar zodra u de vrachtbrief opslaat.
+DocType: Expense Claim,EXP,EXP
+DocType: Water Analysis,Container,houder
+apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} meerdere keren in rij {2} en {3}
+DocType: Item Alternative,Two-way,Tweezijdig
+DocType: Project,Day to Send,Dag om te verzenden
+DocType: Healthcare Settings,Manage Sample Collection,Beheer voorbeeldsamenwerking
+DocType: Production Plan,Ignore Existing Ordered Quantity,Bestaande bestelde hoeveelheid negeren
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66,Please set the series to be used.,Stel de reeks in die moet worden gebruikt.
+DocType: Patient,Tobacco Past Use,Gebruik van tabak achteraf
+DocType: Sales Invoice Item,Brand Name,Merknaam
+DocType: Purchase Receipt,Transporter Details,Transporter Details
+apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55,User {0} is already assigned to Physician {1},Gebruiker {0} is al toegewezen aan Arts {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2696,Default warehouse is required for selected item,Standaard magazijn is nodig voor geselecteerde punt
+apps/erpnext/erpnext/utilities/user_progress.py +146,Box,Doos
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038,Possible Supplier,mogelijke Leverancier
+DocType: Budget,Monthly Distribution,Maandelijkse Verdeling
+apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Ontvanger Lijst is leeg. Maak Ontvanger Lijst
+apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Gezondheidszorg (beta)
+DocType: Production Plan Sales Order,Production Plan Sales Order,Productie Plan Verkooporder
+DocType: Sales Partner,Sales Partner Target,Verkoop Partner Doel
+DocType: Loan Type,Maximum Loan Amount,Maximum Leningen
+DocType: Pricing Rule,Pricing Rule,Prijsbepalingsregel
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Dubbele rolnummer voor student {0}
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Dubbele rolnummer voor student {0}
+DocType: Budget,Action if Annual Budget Exceeded,Actie als jaarlijkse begroting overschreden
+apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Materiaal aanvragen tot Purchase Order
+DocType: Shopping Cart Settings,Payment Success URL,Betaling Succes URL
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81,Row # {0}: Returned Item {1} does not exists in {2} {3},Rij # {0}: Teruggekeerde Item {1} bestaat niet in {2} {3}
+DocType: Purchase Receipt,PREC-,PREC-
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankrekeningen
+,Bank Reconciliation Statement,Bank Aflettering Statement
+DocType: Consultation,Medical Coding,Medische codering
+DocType: Healthcare Settings,Reminder Message,Herinnering Bericht
+,Lead Name,Lead Naam
+,POS,POS
+DocType: C-Form,III,III
+apps/erpnext/erpnext/config/stock.py +318,Opening Stock Balance,Het openen Stock Balance
+apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} mag slechts eenmaal voorkomen
+apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Verlof succesvol toegewezen aan {0}
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Geen Artikelen om te verpakken
+DocType: Shipping Rule Condition,From Value,Van Waarde
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +608,Manufacturing Quantity is mandatory,Productie Aantal is verplicht
+DocType: Employee Loan,Repayment Method,terugbetaling Method
+DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Indien aangevinkt, zal de startpagina de standaard Item Group voor de website"
+DocType: Quality Inspection Reading,Reading 4,Meting 4
+apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Claims voor bedrijfsonkosten
+apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Studenten worden in het hart van het systeem, voegt al jouw leerlingen"
+apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Rij # {0}: Clearance date {1} kan niet vóór Cheque Date {2}
+DocType: Asset Maintenance Task,Certificate Required,Certificaat vereist
+DocType: Company,Default Holiday List,Standaard Vakantiedagen Lijst
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196,Row {0}: From Time and To Time of {1} is overlapping with {2},Rij {0}: Van tijd en de tijd van de {1} overlapt met {2}
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Voorraad Verplichtingen
+DocType: Purchase Invoice,Supplier Warehouse,Leverancier Magazijn
+DocType: Opportunity,Contact Mobile No,Contact Mobiele nummer
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +403,Select Company,Selecteer Bedrijf
+,Material Requests for which Supplier Quotations are not created,Materiaal Aanvragen waarvoor Leverancier Offertes niet zijn gemaakt
+DocType: Student Report Generation Tool,Print Section,Print sectie
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Gebruiker {0} heeft geen standaard POS-profiel. Schakel Standaard in rij {1} voor deze gebruiker in.
+DocType: Student Group,Set 0 for no limit,Stel 0 voor geen limiet
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,De dag (en) waarop je solliciteert verlof zijn vakantie. U hoeft niet voor verlof.
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Rij {idx}: {field} is vereist om de opening {invoice_type} facturen te maken
+DocType: Customer,Primary Address and Contact Detail,Primaire adres en contactgegevens
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,E-mail opnieuw te verzenden Betaling
+apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Nieuwe taak
+DocType: Consultation,Appointment,Afspraak
+apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Maak Offerte
+apps/erpnext/erpnext/config/education.py +230,Other Reports,andere rapporten
+apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Selecteer minimaal één domein.
+DocType: Dependent Task,Dependent Task,Afhankelijke taak
+apps/erpnext/erpnext/stock/doctype/item/item.py +444,Conversion factor for default Unit of Measure must be 1 in row {0},Conversiefactor voor Standaard meeteenheid moet 1 zijn in rij {0}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188,Leave of type {0} cannot be longer than {1},Verlof van type {0} kan niet langer zijn dan {1}
+DocType: Manufacturing Settings,Try planning operations for X days in advance.,Probeer plan operaties voor X dagen van tevoren.
+DocType: HR Settings,Stop Birthday Reminders,Stop verjaardagsherinneringen
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Stel Default Payroll Payable account in Company {0}
+DocType: SMS Center,Receiver List,Ontvanger Lijst
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1094,Search Item,Zoekitem
+DocType: Payment Schedule,Payment Amount,Betaling Bedrag
+DocType: Patient Appointment,Referring Physician,Verwijzende arts
+apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Verbruikte hoeveelheid
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100,Net Change in Cash,Netto wijziging in cash
+DocType: Assessment Plan,Grading Scale,Grading Scale
+apps/erpnext/erpnext/stock/doctype/item/item.py +438,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Eenheid {0} is meer dan eens ingevoerd in Conversie Factor Tabel
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +643,Already completed,Reeds voltooid
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Voorraad in de hand
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Importeren succesvol!
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Betalingsverzoek bestaat al {0}
+apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Kosten van Items Afgegeven
+DocType: Physician,Hospital,Ziekenhuis
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385,Quantity must not be more than {0},Hoeveelheid mag niet meer zijn dan {0}
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Vorig boekjaar is niet gesloten
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +68,Age (Days),Leeftijd (dagen)
+DocType: Quotation Item,Quotation Item,Offerte Artikel
+DocType: Customer,Customer POS Id,Klant POS-id
+DocType: Account,Account Name,Rekening Naam
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Vanaf de datum kan niet groter zijn dan tot nu toe
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serienummer {0} hoeveelheid {1} moet een geheel getal zijn
+apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Leverancier Type stam.
+DocType: Purchase Order Item,Supplier Part Number,Leverancier Onderdeelnummer
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Succespercentage kan niet 0 of 1 zijn
+DocType: Share Balance,To No,Naar Nee
+DocType: Subscription,Reference Document,Referentie document
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229,{0} {1} is cancelled or stopped,{0} {1} is geannuleerd of gestopt
+DocType: Accounts Settings,Credit Controller,Credit Controller
+DocType: Grant Application,Applicant Type,aanvrager Type
+DocType: Purchase Invoice,03-Deficiency in services,03-Deficiency in services
+DocType: Delivery Note,Vehicle Dispatch Date,Voertuig Vertrekdatum
+DocType: Healthcare Settings,Default Medical Code Standard,Standaard Medische Code Standaard
+DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Ontvangstbevestiging {0} is niet ingediend
+DocType: Company,Default Payable Account,Standaard Payable Account
+apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Instellingen voor online winkelwagentje zoals scheepvaart regels, prijslijst enz."
+apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% gefactureerd
+apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Gereserveerde Hoeveelheid
+DocType: Party Account,Party Account,Party Account
+apps/erpnext/erpnext/config/setup.py +122,Human Resources,Human Resources
+DocType: Lead,Upper Income,Bovenste Inkomen
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,afwijzen
+DocType: Journal Entry Account,Debit in Company Currency,Debet in Company Valuta
+DocType: BOM Item,BOM Item,Stuklijst Artikel
+DocType: Appraisal,For Employee,Voor Werknemer
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Maak uitbetaling Entry
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Rij {0}: Advance tegen Leverancier worden debiteren
+DocType: Company,Default Values,Standaard Waarden
+DocType: Membership,INR,INR
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frequentie} Digest
+DocType: Expense Claim,Total Amount Reimbursed,Totaal bedrag terug!
+apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Dit is gebaseerd op stammen tegen dit voertuig. Zie tijdlijn hieronder voor meer informatie
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Tegen Leverancier Factuur {0} gedateerd {1}
+DocType: Customer,Default Price List,Standaard Prijslijst
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +322,Asset Movement record {0} created,Asset bewegingsartikel {0} aangemaakt
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Je kunt niet verwijderen boekjaar {0}. Boekjaar {0} is ingesteld als standaard in Global Settings
+apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Er bestaat al een klant met dezelfde naam
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Dit zal loonstrookjes indienen en een periodedagboek aanmaken. Wil je doorgaan?
+DocType: Purchase Invoice,Total Net Weight,Totale netto gewicht
+DocType: Purchase Invoice,Eligibility For ITC,Geschiktheid voor ITC
+DocType: Journal Entry,Entry Type,Entry Type
+,Customer Credit Balance,Klant Kredietsaldo
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28,Net Change in Accounts Payable,Netto wijziging in Accounts Payable
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,EcritureLet,EcritureLet
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +209,Credit limit has been crossed for customer {0} ({1}/{2}),Kredietlimiet is overschreden voor klant {0} ({1} / {2})
+apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Klant nodig voor 'Klantgebaseerde Korting'
+apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Bijwerken bank betaaldata met journaalposten
+apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,pricing
+DocType: Quotation,Term Details,Voorwaarde Details
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Kan niet meer dan {0} studenten voor deze groep studenten inschrijven.
+apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),Totaal (zonder BTW)
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Loodtelling
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Loodtelling
+apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} moet groter zijn dan 0
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30,Stock Available,Beschikbare voorraad
+DocType: Manufacturing Settings,Capacity Planning For (Days),Capacity Planning Voor (Dagen)
+apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Inkoop
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66,None of the items have any change in quantity or value.,Geen van de items hebben een verandering in hoeveelheid of waarde.
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Verplicht veld - Programma
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Verplicht veld - Programma
+DocType: Special Test Template,Result Component,Resultaatcomponent
+apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garantie Claim
+,Lead Details,Lead Details
+DocType: Volunteer,Availability and Skills,Beschikbaarheid en vaardigheden
+DocType: Salary Slip,Loan repayment,Lening terugbetaling
+DocType: Purchase Invoice,End date of current invoice's period,Einddatum van de huidige factuurperiode
+DocType: Pricing Rule,Applicable For,Toepasselijk voor
+DocType: Lab Test,Technician Name,Technicus Naam
+DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Ontkoppelen Betaling bij annulering van de factuur
+apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Huidige kilometerstand ingevoerd moet groter zijn dan de initiële kilometerstand van het voertuig zijn {0}
+DocType: Restaurant Reservation,No Show,Geen voorstelling
+DocType: Shipping Rule Country,Shipping Rule Country,Verzenden Regel Land
+apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Verlaat en Aanwezigheid
+DocType: Maintenance Visit,Partially Completed,Gedeeltelijk afgesloten
+apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Gematigde gevoeligheid
+DocType: Leave Type,Include holidays within leaves as leaves,Inclusief vakantie binnen bladeren als bladeren
+DocType: Sales Invoice,Packed Items,Verpakt Items
+apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garantie Claim tegen Serienummer
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +211,'Total',&#39;Totaal&#39;
+DocType: Shopping Cart Settings,Enable Shopping Cart,Inschakelen Winkelwagen
+DocType: Employee,Permanent Address,Vast Adres
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
+						than Grand Total {2}",Voorschot betaald tegen {0} {1} kan niet groter zijn \ dan eindtotaal {2}
+DocType: Consultation,Medication,geneesmiddel
+DocType: Production Plan,Include Non Stock Items,Niet-voorraadartikelen opnemen
+DocType: Project Update,Challenging/Slow,Uitdagende / Slow
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Selecteer artikelcode
+DocType: Student Sibling,Studying in Same Institute,Het bestuderen in hetzelfde instituut
+DocType: Territory,Territory Manager,Regio Manager
+DocType: Packed Item,To Warehouse (Optional),Om Warehouse (optioneel)
+DocType: GST Settings,GST Accounts,GST-accounts
+DocType: Payment Entry,Paid Amount (Company Currency),Betaald bedrag (Bedrijfsvaluta)
+DocType: Purchase Invoice,Additional Discount,EXTRA KORTING
+DocType: Selling Settings,Selling Settings,Verkoop Instellingen
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Bevestig actie
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,online Veilingen
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,Please specify either Quantity or Valuation Rate or both,Specificeer ofwel Hoeveelheid of Waarderingstarief of beide
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Vervulling
+apps/erpnext/erpnext/templates/generators/item.html +82,View in Cart,Bekijk in winkelwagen
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Marketingkosten
+,Item Shortage Report,Artikel Tekort Rapport
+apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Kan geen standaardcriteria maken. Wijzig de naam van de criteria
+apps/erpnext/erpnext/stock/doctype/item/item.js +311,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Het gewicht wordt vermeld, \n Vermeld ""Gewicht UOM"" te"
+DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materiaal Aanvraag is gebruikt om deze Voorraad  Entry te maken
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Volgende Afschrijvingen Date is verplicht voor nieuwe aanwinst
+DocType: Student Group Creation Tool,Separate course based Group for every Batch,Afzonderlijke cursusgroep voor elke partij
+DocType: Student Group Creation Tool,Separate course based Group for every Batch,Afzonderlijke cursusgroep voor elke partij
+apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Enkel exemplaar van een artikel.
+DocType: Fee Category,Fee Category,fee Categorie
+DocType: Agriculture Task,Next Business Day,Volgende werkdag
+DocType: Drug Prescription,Dosage by time interval,Dosering per tijdsinterval
+DocType: Cash Flow Mapper,Section Header,Sectiekoptekst
+,Student Fee Collection,Student Fee Collection
+apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24,Appointment Duration (mins),Benoemingsduur (minuten)
+DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Maak boekhoudkundige afschrijving voor elke Stock Movement
+DocType: Leave Allocation,Total Leaves Allocated,Totaal Verlofdagen Toegewezen
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Warehouse vereist bij Row Geen {0}
+apps/erpnext/erpnext/public/js/setup_wizard.js +145,Please enter valid Financial Year Start and End Dates,Voer geldige boekjaar begin- en einddatum
+DocType: Employee,Date Of Retirement,Pensioneringsdatum
+DocType: Upload Attendance,Get Template,Get Sjabloon
+DocType: Material Request,Transferred,overgedragen
+DocType: Vehicle,Doors,deuren
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +116,ERPNext Setup Complete!,ERPNext Setup is voltooid!
+DocType: Healthcare Settings,Collect Fee for Patient Registration,Verzamelkosten voor patiëntregistratie
+apps/erpnext/erpnext/stock/doctype/item/item.py +678,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Kan attributen na beurstransactie niet wijzigen. Maak een nieuw artikel en breng aandelen over naar het nieuwe item
+DocType: Course Assessment Criteria,Weightage,Weging
+DocType: Purchase Invoice,Tax Breakup,Belastingverdeling
+DocType: Packing Slip,PS-,PS-
+DocType: Member,Non Profit Member,Non-profitlid
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: kostenplaats is nodig voor 'Winst- en verliesrekening' account {2}. Gelieve een standaard kostenplaats voor de onderneming op te zetten.
+DocType: Payment Schedule,Payment Term,Betalingstermijn
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +160,A Customer Group exists with same name please change the Customer name or rename the Customer Group,Een Klantgroep met dezelfde naam bestaat. Gelieve de naam van de Klant of de Klantgroep  wijzigen
+DocType: Land Unit,Area,Gebied
+apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Nieuw contact
+DocType: Territory,Parent Territory,Bovenliggende Regio
+DocType: Purchase Invoice,Place of Supply,Plaats van levering
+DocType: Quality Inspection Reading,Reading 2,Meting 2
+DocType: Stock Entry,Material Receipt,Materiaal ontvangst
+DocType: Homepage,Products,producten
+DocType: Announcement,Instructor,Instructeur
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +95,Select Item (optional),Selecteer item (optioneel)
+DocType: Fee Schedule Student Group,Fee Schedule Student Group,Fee Schedule Student Group
+DocType: Student,AB+,AB+
+DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Als dit item heeft varianten, dan kan het niet worden geselecteerd in verkooporders etc."
+DocType: Lead,Next Contact By,Volgende Contact Door
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325,Quantity required for Item {0} in row {1},Benodigde hoeveelheid voor item {0} in rij {1}
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45,Warehouse {0} can not be deleted as quantity exists for Item {1},Magazijn {0} kan niet worden verwijderd als er voorraad is voor artikel {1}
+DocType: Quotation,Order Type,Order Type
+,Item-wise Sales Register,Artikelgebaseerde Verkoop Register
+DocType: Asset,Gross Purchase Amount,Gross Aankoopbedrag
+apps/erpnext/erpnext/utilities/user_progress.py +39,Opening Balances,Opening Saldi
+DocType: Asset,Depreciation Method,afschrijvingsmethode
+DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Is dit inbegrepen in de Basic Rate?
+apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Totaal Doel
+DocType: Soil Texture,Sand Composition (%),Zandsamenstelling (%)
+DocType: Job Applicant,Applicant for a Job,Aanvrager van een baan
+DocType: Production Plan Material Request,Production Plan Material Request,Productie Plan Materiaal aanvragen
+DocType: Stock Reconciliation,Reconciliation JSON,Aflettering JSON
+apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Teveel kolommen. Exporteer het rapport en druk het af via een Spreadsheet programma.
+DocType: Purchase Invoice Item,Batch No,Partij nr.
+DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Kunnen meerdere verkooporders tegen een klant bestelling
+DocType: Student Group Instructor,Student Group Instructor,Student Groep Instructeur
+DocType: Student Group Instructor,Student Group Instructor,Student Groep Instructeur
+DocType: Grant Application,Assessment  Mark (Out of 10),Beoordelingstabel (van de 10)
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile No
+apps/erpnext/erpnext/setup/doctype/company/company.py +218,Main,Hoofd
+apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Variant
+DocType: Naming Series,Set prefix for numbering series on your transactions,Instellen voorvoegsel voor nummerreeksen voor uw transacties
+DocType: Employee Attendance Tool,Employees HTML,medewerkers HTML
+apps/erpnext/erpnext/stock/doctype/item/item.py +458,Default BOM ({0}) must be active for this item or its template,Default BOM ({0}) moet actief voor dit artikel of zijn template
+DocType: Employee,Leave Encashed?,Verlof verzilverd?
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,"""Opportuniteit Van"" veld is verplicht"
+DocType: Email Digest,Annual Expenses,jaarlijkse kosten
+DocType: Item,Variants,Varianten
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1149,Make Purchase Order,Maak inkooporder
+DocType: SMS Center,Send To,Verzenden naar
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,There is not enough leave balance for Leave Type {0},Er is niet genoeg verlofsaldo voor Verlof type {0}
+DocType: Payment Reconciliation Payment,Allocated amount,Toegewezen bedrag
+DocType: Sales Team,Contribution to Net Total,Bijdrage aan Netto Totaal
+DocType: Sales Invoice Item,Customer's Item Code,Artikelcode van Klant
+DocType: Stock Reconciliation,Stock Reconciliation,Voorraad Aflettering
+DocType: Territory,Territory Name,Regio Naam
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204,Work-in-Progress Warehouse is required before Submit,Werk in uitvoering Magazijn is vereist alvorens in te dienen
+apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Kandidaat voor een baan.
+DocType: Purchase Order Item,Warehouse and Reference,Magazijn en Referentie
+DocType: Supplier,Statutory info and other general information about your Supplier,Wettelijke info en andere algemene informatie over uw leverancier
+DocType: Item,Serial Nos and Batches,Serienummers en batches
+DocType: Item,Serial Nos and Batches,Serienummers en batches
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Studentengroep Sterkte
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Studentengroep Sterkte
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261,Against Journal Entry {0} does not have any unmatched {1} entry,Tegen Journal Entry {0} heeft geen ongeëvenaarde {1} binnenkomst hebben
+apps/erpnext/erpnext/config/hr.py +142,Appraisals,taxaties
+apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Trainingsevenementen
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Dubbel Serienummer ingevoerd voor Artikel {0}
+apps/erpnext/erpnext/config/selling.py +179,Track Leads by Lead Source.,Leads bijhouden op leadbron.
+DocType: Shipping Rule Condition,A condition for a Shipping Rule,Een voorwaarde voor een Verzendregel
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,Kom binnen alstublieft
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Onderhoudslogboek
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236,Please set filter based on Item or Warehouse,Stel filter op basis van artikel of Warehouse
+DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Het nettogewicht van dit pakket. (Wordt automatisch berekend als de som van de netto-gewicht van de artikelen)
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +815,Discount amount cannot be greater than 100%,Kortingsbedrag kan niet groter zijn dan 100%
+DocType: Sales Order,To Deliver and Bill,Te leveren en Bill
+DocType: Student Group,Instructors,instructeurs
+DocType: GL Entry,Credit Amount in Account Currency,Credit Bedrag in account Valuta
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +604,BOM {0} must be submitted,Stuklijst {0} moet worden ingediend
+apps/erpnext/erpnext/config/accounts.py +460,Share Management,Share Management
+DocType: Authorization Control,Authorization Control,Autorisatie controle
+apps/erpnext/erpnext/controllers/buying_controller.py +333,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Rij # {0}: Afgekeurd Warehouse is verplicht tegen verworpen Item {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Payment,Betaling
+apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Magazijn {0} is niet gekoppeld aan een account, vermeld alstublieft het account in het magazijnrecord of stel de standaard inventaris rekening in bedrijf {1}."
+apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Beheer uw bestellingen
+DocType: Work Order Operation,Actual Time and Cost,Werkelijke Tijd en kosten
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materiaal Aanvraag van maximaal {0} kan worden gemaakt voor Artikel {1} tegen Verkooporder {2}
+DocType: Crop,Crop Spacing,Uitsnede bijsnijden
+DocType: Course,Course Abbreviation,cursus Afkorting
+DocType: Student Leave Application,Student Leave Application,Student verlofaanvraag
+DocType: Item,Will also apply for variants,Geldt ook voor varianten
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +217,"Asset cannot be cancelled, as it is already {0}","Asset kan niet worden geannuleerd, want het is al {0}"
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Employee {0} op een halve dag op {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Totaal aantal werkuren mag niet groter zijn dan max werktijden {0}
+apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Op
+apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Bundel artikelen op moment van verkoop.
+DocType: Material Request Plan Item,Actual Qty,Werkelijk aantal
+DocType: Sales Invoice Item,References,Referenties
+DocType: Quality Inspection Reading,Reading 10,Meting 10
+DocType: Item,Barcodes,Barcodes
+DocType: Hub Category,Hub Node,Hub Node
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,U hebt dubbele artikelen ingevoerd. Aub aanpassen en opnieuw proberen.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,associëren
+DocType: Asset Movement,Asset Movement,Asset Movement
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +510,Work Order {0} must be submitted,Werkorder {0} moet worden ingediend
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2210,New Cart,nieuwe winkelwagen
+apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Artikel {0} is geen seriegebonden artikel
+DocType: SMS Center,Create Receiver List,Maak Ontvanger Lijst
+DocType: Vehicle,Wheels,Wheels
+DocType: Packing Slip,To Package No.,Naar pakket nr
+DocType: Patient Relation,Family,Familie
+DocType: Production Plan,Material Requests,materiaal aanvragen
+DocType: Warranty Claim,Issue Date,Uitgiftedatum
+DocType: Activity Cost,Activity Cost,Activiteit Kosten
+DocType: Sales Invoice Timesheet,Timesheet Detail,Timesheet Detail
+DocType: Purchase Receipt Item Supplied,Consumed Qty,Verbruikt aantal
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,telecommunicatie
+apps/erpnext/erpnext/accounts/party.py +263,Billing currency must be equal to either default company's currency or party account currency,Factuurvaluta moet gelijk zijn aan de valuta van het standaardbedrijf of de valuta van het partijaccount
+DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Geeft aan dat het pakket een onderdeel is van deze levering (alleen ontwerp)
+DocType: Soil Texture,Loam,Leem
+apps/erpnext/erpnext/controllers/accounts_controller.py +705,Row {0}: Due Date cannot be before posting date,Rij {0}: vervaldatum kan niet vóór de boekingsdatum zijn
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Betalen Entry
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Hoeveelheid voor artikel {0} moet kleiner zijn dan {1}
+,Sales Invoice Trends,Verkoopfactuur Trends
+DocType: Leave Application,Apply / Approve Leaves,Toepassing / Goedkeuren Leaves
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Voor
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Kan de rij enkel verwijzen bij het aanrekeningstype 'Hoeveelheid vorige rij' of 'Totaal vorige rij'
+DocType: Sales Order Item,Delivery Warehouse,Levering magazijn
+apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Boom van de financiële Cost Centers.
+DocType: Serial No,Delivery Document No,Leveringsdocument nr.
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Stel &#39;winst / verliesrekening op de verkoop van activa in Company {0}
+DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Krijg items uit Aankoopfacturen
+DocType: Serial No,Creation Date,Aanmaakdatum
+apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Artikel {0} verschijnt meerdere keren in prijslijst {1}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Selling must be checked, if Applicable For is selected as {0}","Verkoop moet zijn aangevinkt, indien ""Van toepassing voor"" is geselecteerd als {0}"
+DocType: Production Plan Material Request,Material Request Date,Materiaal Aanvraagdatum
+DocType: Purchase Order Item,Supplier Quotation Item,Leverancier Offerte Artikel
+DocType: Student,Student Mobile Number,Student Mobile Number
+DocType: Item,Has Variants,Heeft Varianten
+apps/erpnext/erpnext/controllers/accounts_controller.py +488,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Kan niet overbilleren voor item {0} in rij {1} meer dan {2}. Om overrekening toe te staan, stel in Voorraad Instellingen in"
+apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Update reactie
+apps/erpnext/erpnext/public/js/utils.js +374,You have already selected items from {0} {1},U heeft reeds geselecteerde items uit {0} {1}
+DocType: Monthly Distribution,Name of the Monthly Distribution,Naam van de verdeling per maand
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Batch ID is verplicht
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Batch ID is verplicht
+DocType: Sales Person,Parent Sales Person,Parent Sales Person
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100,The seller and the buyer cannot be the same,De verkoper en de koper kunnen niet hetzelfde zijn
+DocType: Project,Collect Progress,Verzamel vooruitgang
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Selecteer eerst het programma
+DocType: Patient Appointment,Patient Age,Patiënt leeftijd
+apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Managing Projects
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +224,Serial no {0} has been already returned,Serienummer {0} is al geretourneerd
+DocType: Supplier,Supplier of Goods or Services.,Leverancier van goederen of diensten.
+DocType: Budget,Fiscal Year,Boekjaar
+DocType: Asset Maintenance Log,Planned,Gepland
+DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,Standaard debiteurenrekening die gebruikt moet worden indien niet in Patiënt ingesteld om te reserveren.
+DocType: Vehicle Log,Fuel Price,Fuel Price
+DocType: Budget,Budget,Begroting
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65,Set Open,Stel Open
+apps/erpnext/erpnext/stock/doctype/item/item.py +258,Fixed Asset Item must be a non-stock item.,Fixed Asset punt moet een niet-voorraad artikel zijn.
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budget kan niet worden toegewezen tegen {0}, want het is geen baten of lasten rekening"
+apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Bereikt
+DocType: Student Admission,Application Form Route,Aanvraagformulier Route
+apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Regio / Klantenservice
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,Laat Type {0} kan niet worden toegewezen omdat het te verlaten zonder te betalen
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Rij {0}: Toegewezen bedrag {1} moet kleiner zijn dan of gelijk aan openstaande bedrag te factureren {2}
+DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,In Woorden zijn zichtbaar zodra u de Verkoopfactuur opslaat.
+DocType: Lead,Follow Up,Opvolgen
+DocType: Item,Is Sales Item,Is verkoopartikel
+apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Artikel groepstructuur
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Artikel {0} is niet ingesteld voor serienummers. Controleer Artikelstam
+DocType: Maintenance Visit,Maintenance Time,Onderhoud Tijd
+,Amount to Deliver,Bedrag te leveren
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335,Same item has been entered multiple times. {0},Hetzelfde item is meerdere keren ingevoerd. {0}
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,De Term Start datum kan niet eerder dan het jaar startdatum van het studiejaar waarop de term wordt gekoppeld zijn (Academisch Jaar {}). Corrigeer de data en probeer het opnieuw.
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190,There were errors.,Er zijn fouten opgetreden.
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166,Employee {0} has already applied for {1} between {2} and {3} : ,Werknemer {0} heeft al een aanvraag ingediend voor {1} tussen {2} en {3}:
+DocType: Guardian,Guardian Interests,Guardian Interesses
+DocType: Naming Series,Current Value,Huidige waarde
+apps/erpnext/erpnext/controllers/accounts_controller.py +273,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Meerdere fiscale jaar bestaan voor de datum {0}. Stel onderneming in het fiscale jaar
+DocType: Education Settings,Instructor Records to be created by,Instructor Records te creëren door
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} aangemaakt
+DocType: GST Account,GST Account,GST-account
+DocType: Delivery Note Item,Against Sales Order,Tegen klantorder
+,Serial No Status,Serienummer Status
+DocType: Payment Entry Reference,Outstanding,uitstekend
+DocType: Supplier,Warn POs,Waarschuwing POs
+,Daily Timesheet Summary,Dagelijks Timesheet Samenvatting
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
+						must be greater than or equal to {2}","Rij {0}: Instellen {1} periodiciteit, tijdsverschil tussen begin- en einddatum \
+ groter dan of gelijk aan {2}"
+apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Dit is gebaseerd op voorraad beweging. Zie {0} voor meer informatie
+DocType: Pricing Rule,Selling,Verkoop
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392,Amount {0} {1} deducted against {2},Bedrag {0} {1} in mindering gebracht tegen {2}
+DocType: Employee,Salary Information,Salaris Informatie
+DocType: Sales Person,Name and Employee ID,Naam en Werknemer ID
+apps/erpnext/erpnext/accounts/party.py +308,Due Date cannot be before Posting Date,Vervaldatum mag niet voor de boekingsdatum zijn
+DocType: Website Item Group,Website Item Group,Website Artikel Groep
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Geen salarisstrook gevonden om in te dienen voor de hierboven geselecteerde criteria OF salarisstrook al ingediend
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Invoerrechten en Belastingen
+DocType: Projects Settings,Projects Settings,Projectinstellingen
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Vul Peildatum in
+apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} betaling items kunnen niet worden gefilterd door {1}
+DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tafel voor post die in Web Site zal worden getoond
+DocType: Purchase Order Item Supplied,Supplied Qty,Meegeleverde Aantal
+DocType: Purchase Order Item,Material Request Item,Materiaal Aanvraag Artikel
+apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Boom van Artikelgroepen .
+DocType: Production Plan,Total Produced Qty,Totaal geproduceerd aantal
+DocType: Payroll Entry,Get Employee Details,Krijg medewerkersgegevens
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,Kan niet verwijzen rij getal groter dan of gelijk aan de huidige rijnummer voor dit type Charge
+DocType: Asset,Sold,uitverkocht
+,Item-wise Purchase History,Artikelgebaseerde Inkoop Geschiedenis
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Klik op 'Genereer Planning' om serienummer op te halen voor Artikel {0}
+DocType: Account,Frozen,Bevroren
+DocType: Sales Invoice Payment,Base Amount (Company Currency),Basisbedrag (Company Munt)
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928,Raw Materials,Grondstoffen
+DocType: Payment Reconciliation Payment,Reference Row,Referentie Row
+DocType: Installation Note,Installation Time,Installatie Tijd
+DocType: Sales Invoice,Accounting Details,Boekhouding Details
+apps/erpnext/erpnext/setup/doctype/company/company.js +113,Delete all the Transactions for this Company,Verwijder alle transacties voor dit bedrijf
+DocType: Patient,O Positive,O Positief
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investeringen
+DocType: Issue,Resolution Details,Oplossing Details
+apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Toekenningen
+DocType: Item Quality Inspection Parameter,Acceptance Criteria,Acceptatiecriteria
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Vul Materiaal Verzoeken in de bovenstaande tabel
+DocType: Item Attribute,Attribute Name,Attribuutnaam
+DocType: BOM,Show In Website,Toon in Website
+DocType: Shopping Cart Settings,Show Quantity in Website,Toon Hoeveelheid in Website
+DocType: Employee Loan Application,Total Payable Amount,Totaal te betalen bedrag
+DocType: Task,Expected Time (in hours),Verwachte Tijd (in uren)
+DocType: Item Reorder,Check in (group),Check-in (groeps)
+DocType: Soil Texture,Silt,Slib
+,Qty to Order,Aantal te bestellen
+DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","De rekening hoofd onder Aansprakelijkheid of Equity, waarbij winst / verlies zal worden geboekt"
+apps/erpnext/erpnext/config/projects.py +36,Gantt chart of all tasks.,Gantt-diagram van alle taken.
+DocType: Opportunity,Mins to First Response,Minuten naar First Response
+DocType: Pricing Rule,Margin Type,marge Type
+apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} uren
+DocType: Course,Default Grading Scale,Default Grading Scale
+DocType: Appraisal,For Employee Name,Voor Naam werknemer
+DocType: Holiday List,Clear Table,Wis Tabel
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119,Available slots,Beschikbare slots
+DocType: C-Form Invoice Detail,Invoice No,Factuur nr.
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363,Make Payment,Betaling maken
+DocType: Room,Room Name,Kamer naam
+DocType: Prescription Duration,Prescription Duration,Voorschrift Duur
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Verlaat niet kan worden toegepast / geannuleerd voordat {0}, als verlof balans al-carry doorgestuurd in de toekomst toewijzing verlof record is {1}"
+DocType: Activity Cost,Costing Rate,Costing Rate
+apps/erpnext/erpnext/config/selling.py +234,Customer Addresses And Contacts,Klant adressen en contacten
+,Campaign Efficiency,Campagne-efficiëntie
+DocType: Discussion,Discussion,Discussie
+DocType: Payment Entry,Transaction ID,Transactie ID
+DocType: Volunteer,Anytime,Anytime
+DocType: Patient,Surgical History,Chirurgische Geschiedenis
+DocType: Employee,Resignation Letter Date,Ontslagbrief Datum
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Prijsbepalingsregels worden verder gefilterd op basis van aantal.
+apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127,Not Set,niet ingesteld
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Stel de datum van aansluiting in voor werknemer {0}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Stel de datum van aansluiting in voor werknemer {0}
+DocType: Task,Total Billing Amount (via Time Sheet),Totaal Billing Bedrag (via Urenregistratie)
+apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Terugkerende klanten Opbrengsten
+DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
+DocType: Chapter,Chapter,Hoofdstuk
+apps/erpnext/erpnext/utilities/user_progress.py +146,Pair,paar
+DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Het standaardaccount wordt automatisch bijgewerkt in POS Invoice wanneer deze modus is geselecteerd.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970,Select BOM and Qty for Production,Selecteer BOM en Aantal voor productie
+DocType: Asset,Depreciation Schedule,afschrijving Schedule
+apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Verkooppartneradressen en contactpersonen
+DocType: Bank Reconciliation Detail,Against Account,Tegen Rekening
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Half Day Date should be between From Date and To Date,Halve dag datum moet zijn tussen Van Datum en To Date
+DocType: Maintenance Schedule Detail,Actual Date,Werkelijke Datum
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139,Please set the Default Cost Center in {0} company.,Stel het standaard kostenplaatsadres in {0} bedrijf in.
+DocType: Item,Has Batch No,Heeft Batch nr.
+apps/erpnext/erpnext/public/js/utils.js +106,Annual Billing: {0},Jaarlijkse Billing: {0}
+apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Goederen en Diensten Belasting (GST India)
+DocType: Delivery Note,Excise Page Number,Accijnzen Paginanummer
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227,"Company, From Date and To Date is mandatory","Company, Van Datum en tot op heden is verplicht"
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Krijg van raadpleging
+DocType: Asset,Purchase Date,aankoopdatum
+DocType: Volunteer,Volunteer Type,Vrijwilligers type
+DocType: Student,Personal Details,Persoonlijke Gegevens
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Stel &#39;Asset Afschrijvingen Cost Center&#39; in Company {0}
+,Maintenance Schedules,Onderhoudsschema&#39;s
+DocType: Task,Actual End Date (via Time Sheet),Werkelijke Einddatum (via Urenregistratie)
+DocType: Soil Texture,Soil Type,Grondsoort
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387,Amount {0} {1} against {2} {3},Bedrag {0} {1} tegen {2} {3}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,New Message,Nieuw bericht
+,Quotation Trends,Offerte Trends
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160,Item Group not mentioned in item master for item {0},Artikelgroep niet genoemd in Artikelstam voor Artikel {0}
+DocType: GoCardless Mandate,GoCardless Mandate,GoCardless Mandate
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368,Debit To account must be a Receivable account,Debet Om rekening moet een vordering-account
+DocType: Shipping Rule,Shipping Amount,Verzendbedrag
+DocType: Supplier Scorecard Period,Period Score,Periode Score
+apps/erpnext/erpnext/utilities/user_progress.py +66,Add Customers,Voeg klanten toe
+apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,In afwachting van Bedrag
+DocType: Lab Test Template,Special,speciaal
+DocType: Purchase Order Item Supplied,Conversion Factor,Conversiefactor
+DocType: Purchase Order,Delivered,Geleverd
+,Vehicle Expenses,Voertuig kosten
+DocType: Serial No,Invoice Details,Factuurgegevens
+DocType: Grant Application,Show on Website,Weergeven op website
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,Expected value after useful life must be greater than or equal to {0},Verwachtingswaarde na levensduur groter dan of gelijk aan {0}
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Begin maar
+DocType: Hub Category,Hub Category,Hubcategorie
+DocType: Purchase Invoice,SEZ,SEZ
+DocType: Purchase Receipt,Vehicle Number,Voertuig Aantal
+DocType: Employee Loan,Loan Amount,Leenbedrag
+DocType: Student Report Generation Tool,Add Letterhead,Voeg briefhoofd toe
+DocType: Program Enrollment,Self-Driving Vehicle,Zelfrijdend voertuig
+DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Leverancier Scorecard Standing
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443,Row {0}: Bill of Materials not found for the Item {1},Rij {0}: Bill of Materials niet gevonden voor het artikel {1}
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Totaal toegewezen bladeren {0} kan niet lager zijn dan die reeds zijn goedgekeurd bladeren {1} voor de periode
+DocType: Journal Entry,Accounts Receivable,Debiteuren
+,Supplier-Wise Sales Analytics,Leverancier-gebaseerde Verkoop Analyse
+DocType: Purchase Invoice,Availed ITC Central Tax,Gebruikmaken van ITC Central Tax
+DocType: Salary Structure,Select employees for current Salary Structure,Selecteer medewerkers voor de huidige beloningsstructuur
+DocType: Sales Invoice,Company Address Name,Bedrijfs Adres Naam
+DocType: Work Order,Use Multi-Level BOM,Gebruik Multi-Level Stuklijst
+DocType: Bank Reconciliation,Include Reconciled Entries,Omvatten Reconciled Entries
+DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Ouderlijke cursus (laat leeg, als dit niet deel uitmaakt van de ouderopleiding)"
+DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Ouderlijke cursus (laat leeg, als dit niet deel uitmaakt van de ouderopleiding)"
+DocType: Leave Control Panel,Leave blank if considered for all employee types,Laat leeg indien overwogen voor alle werknemer soorten
+DocType: Landed Cost Voucher,Distribute Charges Based On,Verdeel Toeslagen op basis van
+DocType: Projects Settings,Timesheets,timesheets
+DocType: HR Settings,HR Settings,HR-instellingen
+DocType: Salary Slip,net pay info,nettoloon info
+DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Deze waarde is bijgewerkt in de standaard verkoopprijslijst.
+DocType: Email Digest,New Expenses,nieuwe Uitgaven
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +101,PDC/LC Amount,PDC / LC Bedrag
+DocType: Shareholder,Shareholder,Aandeelhouder
+DocType: Purchase Invoice,Additional Discount Amount,Extra korting Bedrag
+DocType: Cash Flow Mapper,Position,Positie
+DocType: Patient,Patient Details,Patient Details
+DocType: Patient,B Positive,B positief
+apps/erpnext/erpnext/controllers/accounts_controller.py +596,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.",Rij # {0}: Aantal moet 1 als item is een vaste activa. Gebruik aparte rij voor meerdere aantal.
+DocType: Leave Block List Allow,Leave Block List Allow,Laat Block List Laat
+apps/erpnext/erpnext/setup/doctype/company/company.py +317,Abbr can not be blank or space,Abbr kan niet leeg of ruimte
+DocType: Patient Medical Record,Patient Medical Record,Patient Medical Record
+apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Groep om Non-groep
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Sport
+DocType: Loan Type,Loan Name,lening Naam
+apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Totaal Werkelijke
+DocType: Lab Test UOM,Test UOM,Test UOM
+DocType: Student Siblings,Student Siblings,student Broers en zussen
+apps/erpnext/erpnext/utilities/user_progress.py +146,Unit,eenheid
+apps/erpnext/erpnext/stock/get_item_details.py +138,Please specify Company,Specificeer Bedrijf
+,Customer Acquisition and Loyalty,Klantenwerving en behoud
+DocType: Asset Maintenance Task,Maintenance Task,Onderhoudstaak
+apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118,Please set B2C Limit in GST Settings.,Stel B2C-limiet in GST-instellingen in.
+DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Magazijn waar u voorraad bijhoudt van afgewezen artikelen
+DocType: Work Order,Skip Material Transfer,Materiaaloverdracht overslaan
+DocType: Work Order,Skip Material Transfer,Materiaaloverdracht overslaan
+apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Kan wisselkoers voor {0} tot {1} niet vinden voor de sleuteldatum {2}. Creëer alsjeblieft een valuta-wisselrecord
+DocType: POS Profile,Price List,Prijslijst
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} is nu het standaard Boekjaar. Ververs uw browser om de wijziging door te voeren .
+apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Declaraties
+DocType: Issue,Support,Support
+,BOM Search,BOM Zoeken
+DocType: Project,Total Consumed Material Cost  (via Stock Entry),Totale verbruikte materiaalkosten (via voorraadinvoer)
+DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publiceer &#39;In voorraad&#39; of &#39;Niet op voorraad&#39; op Hub op basis van de voorraad die beschikbaar is in dit magazijn.
+DocType: Vehicle,Fuel Type,Brandstoftype
+apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Omschrijf valuta Company
+DocType: Workstation,Wages per hour,Loon per uur
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Voorraadbalans in Batch {0} zal negatief worden {1} voor Artikel {2} in Magazijn {3}
+apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Volgende Material Aanvragen werden automatisch verhoogd op basis van re-order niveau-item
+DocType: Email Digest,Pending Sales Orders,In afwachting van klantorders
+apps/erpnext/erpnext/controllers/accounts_controller.py +312,Account {0} is invalid. Account Currency must be {1},Account {0} is ongeldig. Account Valuta moet {1} zijn
+DocType: Healthcare Settings,Remind Before,Herinner je alvast
+apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Eenheid Omrekeningsfactor is vereist in rij {0}
+DocType: Production Plan Item,material_request_item,material_request_item
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Rij # {0}: Reference document moet een van Sales Order, verkoopfactuur of Inboeken zijn"
+DocType: Salary Component,Deduction,Aftrek
+DocType: Item,Retain Sample,Bewaar monster
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Rij {0}: Van tijd en binnen Tijd is verplicht.
+DocType: Stock Reconciliation Item,Amount Difference,bedrag Verschil
+apps/erpnext/erpnext/stock/get_item_details.py +356,Item Price added for {0} in Price List {1},Item Prijs toegevoegd {0} in de prijslijst {1}
+apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Vul Employee Id van deze verkoper
+DocType: Territory,Classification of Customers by region,Indeling van de klanten per regio
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +76,In Production,In de maak
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65,Difference Amount must be zero,Verschil Bedrag moet nul zijn
+DocType: Project,Gross Margin,Bruto Marge
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61,Please enter Production Item first,Vul eerst Productie Artikel in
+apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Berekende bankafschrift balans
+DocType: Normal Test Template,Normal Test Template,Normaal Testsjabloon
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,Uitgeschakelde gebruiker
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919,Quotation,Offerte
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984,Cannot set a received RFQ to No Quote,Kan geen ontvangen RFQ zonder citaat instellen
+DocType: Quotation,QTN-,QTN-
+DocType: Salary Slip,Total Deduction,Totaal Aftrek
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18,Select an account to print in account currency,Selecteer een account om in rekeningsvaluta af te drukken
+,Production Analytics,Production Analytics
+apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Dit is gebaseerd op transacties tegen deze patiënt. Zie de tijdlijn hieronder voor details
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204,Cost Updated,Kosten Bijgewerkt
+DocType: Patient,Date of Birth,Geboortedatum
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133,Item {0} has already been returned,Artikel {0} is al geretourneerd
+DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Boekjaar** staat voor een financieel jaar. Alle boekingen en andere belangrijke transacties worden bijgehouden in **boekjaar**.
+DocType: Opportunity,Customer / Lead Address,Klant / Lead Adres
+DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Leveranciers Scorecard Setup
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Beoordeling plannaam
+DocType: Work Order Operation,Work Order Operation,Werkorder operatie
+apps/erpnext/erpnext/stock/doctype/item/item.py +233,Warning: Invalid SSL certificate on attachment {0},Waarschuwing: Ongeldig SSL certificaat op attachment {0}
+apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Leads u helpen om zaken, voeg al uw contacten en nog veel meer als uw leads"
+DocType: Work Order Operation,Actual Operation Time,Werkelijke Operatie Duur
+DocType: Authorization Rule,Applicable To (User),Van toepassing zijn op (Gebruiker)
+DocType: Purchase Taxes and Charges,Deduct,Aftrekken
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Job Description,Functiebeschrijving
+DocType: Student Applicant,Applied,Toegepast
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Re-open,Heropenen
+DocType: Sales Invoice Item,Qty as per Stock UOM,Aantal per Voorraad eenheid
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Naam
+DocType: Purchase Invoice,02-Post Sale Discount,Korting na verkoop
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Speciale tekens behalve ""-"" ""."", ""#"", en ""/"" niet toegestaan in de reeks"
+DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Blijf op de hoogte van Sales Campaigns. Blijf op de hoogte van Leads, Offertes, Sales Order etc van campagnes te meten Return on Investment."
+,SO Qty,VO Aantal
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91,The field To Shareholder cannot be blank,Het veld Naar aandeelhouder mag niet leeg zijn
+DocType: Guardian,Work Address,Werk adres
+DocType: Appraisal,Calculate Total Score,Bereken Totaalscore
+DocType: Health Insurance,Health Insurance,Ziektekostenverzekering
+DocType: Asset Repair,Manufacturing Manager,Productie Manager
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serienummer {0} is onder garantie tot {1}
+DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimaal toelaatbare waarde
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,Gebruiker {0} bestaat al
+apps/erpnext/erpnext/hooks.py +109,Shipments,Zendingen
+DocType: Payment Entry,Total Allocated Amount (Company Currency),Totaal toegewezen bedrag (Company Munt)
+DocType: Purchase Order Item,To be delivered to customer,Om de klant te leveren
+DocType: BOM,Scrap Material Cost,Scrap Materiaal Cost
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +233,Serial No {0} does not belong to any Warehouse,Serienummer {0} niet behoren tot een Warehouse
+DocType: Grant Application,Email Notification Sent,E-mailmelding verzonden
+DocType: Purchase Invoice,In Words (Company Currency),In Woorden (Bedrijfsvaluta)
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018,"Item Code, warehouse, quantity are required on row","Artikelcode, magazijn, aantal is verplicht op rij"
+DocType: Pricing Rule,Supplier,Leverancier
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Toon betalingsgegevens
+DocType: Consultation,Consultation Time,Raadplegingstijd
+DocType: C-Form,Quarter,Kwartaal
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Diverse Kosten
+DocType: Global Defaults,Default Company,Standaard Bedrijf
+apps/erpnext/erpnext/controllers/stock_controller.py +227,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Kosten- of verschillenrekening is verplicht voor artikel {0} omdat het invloed heeft op de totale voorraadwaarde
+DocType: Payment Request,PR,PR
+DocType: Cheque Print Template,Bank Name,Banknaam
+apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30,-Above,-Boven
+DocType: Employee Loan,Employee Loan Account,Werknemer Leningsrekening
+DocType: Leave Application,Total Leave Days,Totaal verlofdagen
+DocType: Email Digest,Note: Email will not be sent to disabled users,Opmerking: E-mail wordt niet verzonden naar uitgeschakelde gebruikers
+apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Aantal interacties
+apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Item Variant Settings
+apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37,Select Company...,Selecteer Bedrijf ...
+DocType: Leave Control Panel,Leave blank if considered for all departments,Laat leeg indien dit voor alle afdelingen is
+apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Vormen van dienstverband (permanent, contract, stage, etc. ) ."
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,{0} is mandatory for Item {1},{0} is verplicht voor Artikel {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"Item {0}: {1} qty produced, ","Artikel {0}: {1} aantal geproduceerd,"
+DocType: Payroll Entry,Fortnightly,van twee weken
+DocType: Currency Exchange,From Currency,Van Valuta
+DocType: Vital Signs,Weight (In Kilogram),Gewicht (in kilogram)
+DocType: Chapter,"chapters/chapter_name
+leave blank automatically set after saving chapter.",hoofdstukken / hoofdstuknaam blanco laten automatisch ingesteld na hoofdstuk opslaan.
+apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Please set GST Accounts in GST Settings,Stel GST-accounts in via GST-instellingen
+apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31,Type of Business,Soort bedrijf
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Selecteer toegewezen bedrag, Factuur Type en factuurnummer in tenminste één rij"
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Kosten van nieuwe aankoop
+apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35,All tasks for the detected diseases were imported,Alle taken voor de gedetecteerde ziekten werden geïmporteerd
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Verkooporder nodig voor Artikel {0}
+DocType: Grant Application,Grant Description,Grant Description
+DocType: Purchase Invoice Item,Rate (Company Currency),Tarief (Bedrijfsvaluta)
+DocType: Student Guardian,Others,anderen
+DocType: Payment Entry,Unallocated Amount,Niet-toegewezen bedrag
+apps/erpnext/erpnext/templates/includes/product_page.js +91,Cannot find a matching Item. Please select some other value for {0}.,Kan een bijpassende Item niet vinden. Selecteer een andere waarde voor {0}.
+DocType: POS Profile,Taxes and Charges,Belastingen en Toeslagen
+DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Een Product of een Dienst dat wordt gekocht, verkocht of in voorraad wordt gehouden."
+apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Niet meer updates
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Kan het type lading niet selecteren als 'On Vorige Row Bedrag ' of ' On Vorige Row Totaal ' voor de eerste rij
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Dit omvat alle scorecards die aan deze Setup zijn gekoppeld
+apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Onderliggend item mag geen productbundel zijn. Gelieve item `{0}` te verwijderen en op te slaan
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Bankieren
+apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Voeg Timesheets
+DocType: Vehicle Service,Service Item,dienst Item
+DocType: Bank Guarantee,Bank Guarantee,Bankgarantie
+DocType: Bank Guarantee,Bank Guarantee,Bankgarantie
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Klik op 'Genereer Planning' om planning te krijgen
+DocType: Bin,Ordered Quantity,Bestelde hoeveelheid
+apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","bijv. ""Bouwgereedschap voor bouwers """
+DocType: Grading Scale,Grading Scale Intervals,Grading afleeseenheden
+apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Jaarwinst
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Accounting Entry voor {2} kan alleen worden gemaakt in valuta: {3}
+DocType: Fee Schedule,In Process,In Process
+DocType: Authorization Rule,Itemwise Discount,Artikelgebaseerde Korting
+apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Boom van de financiële rekeningen.
+DocType: Cash Flow Mapping,Cash Flow Mapping,Cash Flow Mapping
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} tegen Verkooporder {1}
+DocType: Account,Fixed Asset,Vast Activum
+apps/erpnext/erpnext/config/stock.py +328,Serialized Inventory,Geserialiseerde Inventory
+apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,E-mailadres niet gevonden in standaardcontact
+DocType: Employee Loan,Account Info,Account informatie
+DocType: Activity Type,Default Billing Rate,Default Billing Rate
+DocType: Fees,Include Payment,Inclusief betaling
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Studentgroepen aangemaakt.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Studentgroepen aangemaakt.
+DocType: Sales Invoice,Total Billing Amount,Totaal factuurbedrag
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Het programma in de kostenstructuur en studentengroep {0} verschilt.
+DocType: Fee Schedule,Receivable Account,Vorderingen Account
+apps/erpnext/erpnext/controllers/accounts_controller.py +618,Row #{0}: Asset {1} is already {2},Rij # {0}: Asset {1} al {2}
+DocType: Quotation Item,Stock Balance,Voorraad Saldo
+apps/erpnext/erpnext/config/selling.py +321,Sales Order to Payment,Sales om de betaling
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,Directeur
+DocType: Purchase Invoice,With Payment of Tax,Met betaling van de belasting
+DocType: Expense Claim Detail,Expense Claim Detail,Kostendeclaratie Detail
+DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICATE VOOR LEVERANCIER
+DocType: Land Unit,Is Container,Is Container
+DocType: Crop Cycle,This will be day 1 of the crop cycle,Dit wordt dag 1 van de gewascyclus
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871,Please select correct account,Selecteer juiste account
+DocType: Purchase Invoice Item,Weight UOM,Gewicht Eenheid
+apps/erpnext/erpnext/config/accounts.py +466,List of available Shareholders with folio numbers,Lijst met beschikbare aandeelhouders met folionummers
+DocType: Salary Structure Employee,Salary Structure Employee,Salarisstructuur Employee
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Show Variant Attributes
+DocType: Student,Blood Group,Bloedgroep
+DocType: Course,Course Name,Cursus naam
+DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Gebruikers die verlofaanvragen een bepaalde werknemer kan goedkeuren
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Kantoor Apparatuur
+DocType: Purchase Invoice Item,Qty,Aantal
+DocType: Fiscal Year,Companies,Bedrijven
+DocType: Supplier Scorecard,Scoring Setup,Scoring instellen
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,elektronica
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326,Debit ({0}),Debet ({0})
+DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Maak Materiaal Aanvraag wanneer voorraad daalt tot onder het bestelniveau
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Full-time
+DocType: Payroll Entry,Employees,werknemers
+DocType: Employee,Contact Details,Contactgegevens
+DocType: C-Form,Received Date,Ontvangstdatum
+DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Als u een standaard template in Sales en -heffingen Template hebt gemaakt, selecteert u een en klik op de knop hieronder."
+DocType: BOM Scrap Item,Basic Amount (Company Currency),Basisbedrag (Company Munt)
+DocType: Student,Guardians,Guardians
+apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13,Payment Confirmation,Betalingsbevestiging
+DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,De prijzen zullen niet worden weergegeven als prijslijst niet is ingesteld
+DocType: Stock Entry,Total Incoming Value,Totaal Inkomende Waarde
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To is required,Debet Om vereist
+apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets helpen bijhouden van de tijd, kosten en facturering voor activiteiten gedaan door uw team"
+apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Purchase Price List
+apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Sjablonen van leveranciers scorecard variabelen.
+DocType: Job Offer Term,Offer Term,Aanbod Term
+DocType: Asset,Quality Manager,Quality Manager
+DocType: Job Applicant,Job Opening,Vacature
+DocType: Payment Reconciliation,Payment Reconciliation,Afletteren
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Selecteer de naam van de Verantwoordelijk Persoon
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,technologie
+DocType: Hub Settings,Unregister from Hub,Afmelden bij Hub
+apps/erpnext/erpnext/public/js/utils.js +108,Total Unpaid: {0},Totaal Onbetaalde: {0}
+DocType: BOM Website Operation,BOM Website Operation,BOM Website Operation
+DocType: Supplier Scorecard,Supplier Score,Leverancierscore
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +227,Total Invoiced Amt,Totale gefactureerde Amt
+DocType: Supplier,Warn RFQs,Waarschuw RFQs
+DocType: BOM,Conversion Rate,Conversion Rate
+apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,product zoeken
+DocType: Assessment Plan,To Time,Tot Tijd
+DocType: Authorization Rule,Approving Role (above authorized value),Goedkeuren Rol (boven de toegestane waarde)
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Credit Om rekening moet een betalend account zijn
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Selecteer een studententoelating die verplicht is voor de betaalde student-aanvrager
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355,BOM recursion: {0} cannot be parent or child of {2},Stuklijst recursie: {0} mag niet ouder of kind zijn van {2}
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21,Please select a Price List to publish pricing,Selecteer een prijslijst om prijzen te publiceren
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Budgetlijst
+DocType: Work Order Operation,Completed Qty,Voltooid aantal
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry","Voor {0}, kan alleen debet accounts worden gekoppeld tegen een andere creditering"
+apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Prijslijst {0} is uitgeschakeld
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Rij {0}: Voltooid Aantal kan niet meer zijn dan {1} voor de bediening {2}
+DocType: Manufacturing Settings,Allow Overtime,Laat Overwerk
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serialized Item {0} kan niet worden bijgewerkt met Stock Reconciliation, gebruik dan Voorraadinvoer"
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serialized Item {0} kan niet worden bijgewerkt met Stock Reconciliation, gebruik dan Voorraadinvoer"
+DocType: Training Event Employee,Training Event Employee,Training Event Medewerker
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1075,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximum aantal voorbeelden - {0} kan worden bewaard voor batch {1} en item {2}.
+apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7,Add Time Slots,Voeg tijdslots toe
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serienummers vereist voor post {1}. U hebt verstrekt {2}.
+DocType: Stock Reconciliation Item,Current Valuation Rate,Huidige Valuation Rate
+DocType: Training Event,Advance,Van te voren
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,om weer terug te keren.
+apps/erpnext/erpnext/config/erpnext_integrations.py +13,GoCardless payment gateway settings,GoCardless betalingsgateway-instellingen
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Exchange winst / verlies
+DocType: Opportunity,Lost Reason,Reden van verlies
+apps/erpnext/erpnext/controllers/accounts_controller.py +265,Row #{0}: Account {1} does not belong to company {2},Rij # {0}: account {1} hoort niet bij bedrijf {2}
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Kon DocType {0} niet vinden
+apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Nieuw adres
+DocType: Quality Inspection,Sample Size,Monster grootte
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Vul Ontvangst Document
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Alle items zijn reeds gefactureerde
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',Geef een geldig 'Van Zaaknummer'
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,"Verdere kostenplaatsen kan in groepen worden gemaakt, maar items kunnen worden gemaakt tegen niet-Groepen"
+apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Gebruikers en machtigingen
+DocType: Vehicle Log,VLOG.,VLOG.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Stel Employee Naming System in Human Resource&gt; HR-instellingen in
+DocType: Branch,Branch,Tak
+DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
+DocType: Delivery Trip,Fulfillment User,Vervul gebruiker
+apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Printen en Branding
+DocType: Company,Total Monthly Sales,Totale maandelijkse omzet
+DocType: Agriculture Analysis Criteria,Weather,Weer
+DocType: Bin,Actual Quantity,Werkelijke hoeveelheid
+DocType: Shipping Rule,example: Next Day Shipping,Bijvoorbeeld: Next Day Shipping
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serienummer {0} niet gevonden
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291,Subscription has been {0},Abonnement is {0}
+DocType: Fee Schedule Program,Fee Schedule Program,Fee Schedule Programma
+DocType: Fee Schedule Program,Student Batch,student Batch
+apps/erpnext/erpnext/utilities/activation.py +119,Make Student,maak Student
+DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
+apps/erpnext/erpnext/projects/doctype/project/project.py +218,You have been invited to collaborate on the project: {0},U bent uitgenodigd om mee te werken aan het project: {0}
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157,Physician not available on {0},Arts niet beschikbaar op {0}
+DocType: Leave Block List Date,Block Date,Blokeer Datum
+DocType: Crop,Crop,Gewas
+DocType: Purchase Receipt,Supplier Delivery Note,Leveranciersleveringsnota
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Nu toepassen
+apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Werkelijk Aantal {0} / Aantal Wachten {1}
+apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Werkelijk Aantal {0} / Aantal Wachten {1}
+DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
+DocType: Sales Order,Not Delivered,Niet geleverd
+,Bank Clearance Summary,Bankbewaring samenvatting
+apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Aanmaken en beheren van dagelijkse, wekelijkse en maandelijkse e-mail samenvattingen."
+DocType: Appraisal Goal,Appraisal Goal,Beoordeling Doel
+DocType: Stock Reconciliation Item,Current Amount,Huidige hoeveelheid
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,Gebouwen
+DocType: Fee Schedule,Fee Structure,fee Structuur
+DocType: Timesheet Detail,Costing Amount,Costing Bedrag
+DocType: Student Admission Program,Application Fee,Aanvraagkosten
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52,Submit Salary Slip,Indienen salarisstrook
+apps/erpnext/erpnext/controllers/selling_controller.py +137,Maxiumm discount for Item {0} is {1}%,Maximum korting voor artikel {0} is {1} %
+apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Import in bulk
+DocType: Sales Partner,Address & Contacts,Adres & Contacten
+DocType: SMS Log,Sender Name,Naam afzender
+DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Criteria voor landbouwanalyse
+DocType: POS Profile,[Select],[Selecteer]
+DocType: Vital Signs,Blood Pressure (diastolic),Bloeddruk (diastolische)
+DocType: SMS Log,Sent To,Verzenden Naar
+DocType: Agriculture Task,Holiday Management,Vakantie Management
+DocType: Payment Request,Make Sales Invoice,Maak verkoopfactuur
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,softwares
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +53,Next Contact Date cannot be in the past,Volgende Contact datum kan niet in het verleden
+DocType: Company,For Reference Only.,Alleen voor referentie.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112,Physician {0} not available on {1},Arts {0} niet beschikbaar op {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2577,Select Batch No,Selecteer batchnummer
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61,Invalid {0}: {1},Ongeldige {0}: {1}
+,GSTR-1,GSTR-1
+DocType: Purchase Invoice,PINV-RET-,PINV-terugwerkende
+DocType: Fee Validity,Reference Inv,Referentie Inv
+DocType: Sales Invoice Advance,Advance Amount,Voorschot Bedrag
+DocType: Manufacturing Settings,Capacity Planning,Capaciteit Planning
+DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Afronding aanpassing (bedrijfsmunt
+apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,'Van Datum' is vereist
+DocType: Journal Entry,Reference Number,Referentienummer
+DocType: Employee,Employment Details,Dienstverband Details
+DocType: Employee,New Workplace,Nieuwe werkplek
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Instellen als Gesloten
+apps/erpnext/erpnext/stock/get_item_details.py +127,No Item with Barcode {0},Geen Artikel met Barcode {0}
+DocType: Normal Test Items,Require Result Value,Vereiste resultaatwaarde
+DocType: Item,Show a slideshow at the top of the page,Laat een diavoorstelling zien aan de bovenkant van de pagina
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532,Boms,Boms
+apps/erpnext/erpnext/stock/doctype/item/item.py +162,Stores,Winkels
+DocType: Project Type,Projects Manager,Projecten Manager
+DocType: Serial No,Delivery Time,Levertijd
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33,Ageing Based On,Vergrijzing Based On
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61,Appointment cancelled,Benoeming geannuleerd
+DocType: Item,End of Life,End of Life
+apps/erpnext/erpnext/demo/setup/setup_data.py +331,Travel,reizen
+DocType: Student Report Generation Tool,Include All Assessment Group,Inclusief alle beoordelingsgroep
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,No active or default Salary Structure found for employee {0} for the given dates,Geen actieve of default salarisstructuur gevonden voor werknemer {0} de uitgekozen datum
+DocType: Leave Block List,Allow Users,Gebruikers toestaan
+DocType: Purchase Order,Customer Mobile No,Klant Mobile Geen
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Terugkerende
+DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Cash Flow Mapping Template-details
+DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Volg afzonderlijke baten en lasten over het product verticalen of divisies.
+DocType: Rename Tool,Rename Tool,Hernoem Tool
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Kosten bijwerken
+DocType: Item Reorder,Item Reorder,Artikel opnieuw ordenen
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Show loonstrook
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849,Transfer Material,Verplaats Materiaal
+DocType: Fees,Send Payment Request,Verzend betalingsverzoek
+DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Geef de operaties, operationele kosten en geef een unieke operatienummer aan uw activiteiten ."
+DocType: Water Analysis,Origin,Oorsprong
+apps/erpnext/erpnext/controllers/status_updater.py +204,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Dit document is dan limiet van {0} {1} voor punt {4}. Bent u het maken van een andere {3} tegen dezelfde {2}?
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1154,Please set recurring after saving,Stel terugkerende na het opslaan
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769,Select change amount account,Selecteer verandering bedrag rekening
+DocType: Purchase Invoice,Price List Currency,Prijslijst Valuta
+DocType: Naming Series,User must always select,Gebruiker moet altijd kiezen
+DocType: Stock Settings,Allow Negative Stock,Laat Negatieve voorraad
+DocType: Installation Note,Installation Note,Installatie Opmerking
+DocType: Soil Texture,Clay,Klei
+DocType: Topic,Topic,Onderwerp
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45,Cash Flow from Financing,De cashflow uit financiële activiteiten
+DocType: Budget Account,Budget Account,budget account
+DocType: Quality Inspection,Verified By,Geverifieerd door
+apps/erpnext/erpnext/setup/doctype/company/company.py +78,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.",Kan standaard valuta van het bedrijf niet veranderen want er zijn bestaande transacties. Transacties moeten worden geannuleerd om de standaard valuta te wijzigen.
+DocType: Cash Flow Mapping,Is Income Tax Liability,Is de aansprakelijkheid van de inkomstenbelasting
+DocType: Grading Scale Interval,Grade Description,Grade Beschrijving
+DocType: Stock Entry,Purchase Receipt No,Ontvangstbevestiging nummer
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Onderpand
+DocType: Sales Invoice, Shipping Bill Number,Scheepsbriefnummer
+apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,traceerbaarheid
+DocType: Asset Maintenance Log,Actions performed,Uitgevoerde acties
+DocType: Cash Flow Mapper,Section Leader,Sectieleider
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Bron van Kapitaal (Passiva)
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +433,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Hoeveelheid in rij {0} ({1}) moet hetzelfde zijn als geproduceerde hoeveelheid {2}
+DocType: Supplier Scorecard Scoring Standing,Employee,Werknemer
+DocType: Asset Repair,Failure Date,Failure Date
+DocType: Sample Collection,Collected Time,Verzamelde tijd
+DocType: Company,Sales Monthly History,Verkoop Maandelijkse Geschiedenis
+DocType: Asset Maintenance Task,Next Due Date,volgende vervaldatum
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +240,Select Batch,Selecteer batch
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} is volledig gefactureerd
+apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31,Vital Signs,Vital Signs
+DocType: Training Event,End Time,Eindtijd
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Actieve salarisstructuur {0} gevonden voor werknemer {1} de uitgekozen datum
+DocType: Payment Entry,Payment Deductions or Loss,Betaling Aftrek of verlies
+DocType: Soil Analysis,Soil Analysis Criterias,Bodemanalyse Criterias
+apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standaard contractvoorwaarden voor Verkoop of Inkoop .
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +114,Group by Voucher,Groep volgens Voucher
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233,Are you sure you want to cancel this appointment?,Weet je zeker dat je deze afspraak wilt annuleren?
+DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Prijsarrangement hotelkamer
+apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Sales Pipeline
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Stel standaard account aan Salaris Component {0}
+apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Vereist op
+DocType: Rename Tool,File to Rename,Bestand naar hernoemen
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Selecteer BOM voor post in rij {0}
+apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Rekening {0} komt niet overeen met Bedrijf {1} in Rekeningmodus: {2}
+apps/erpnext/erpnext/controllers/buying_controller.py +480,Specified BOM {0} does not exist for Item {1},Gespecificeerde Stuklijst {0} bestaat niet voor Artikel {1}
+apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301,Course: ,Cursus:
+DocType: Soil Texture,Sandy Loam,Zandige leem
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Onderhoudsschema {0} moet worden geannuleerd voordat het annuleren van deze verkooporder
+DocType: POS Profile,Applicable for Users,Toepasbaar voor gebruikers
+DocType: Notification Control,Expense Claim Approved,Kostendeclaratie Goedgekeurd
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Work Orders created,Geen werkorders aangemaakt
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Loonstrook van de werknemer {0} al gemaakt voor deze periode
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Farmaceutisch
+apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Kosten van gekochte artikelen
+DocType: Selling Settings,Sales Order Required,Verkooporder Vereist
+DocType: Purchase Invoice,Credit To,Met dank aan
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceDate,PieceDate
+apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Actieve Leads / Klanten
+DocType: Employee Education,Post Graduate,Post Doctoraal
+DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Onderhoudsschema Detail
+DocType: Supplier Scorecard,Warn for new Purchase Orders,Waarschuw voor nieuwe inkooporders
+DocType: Quality Inspection Reading,Reading 9,Meting 9
+DocType: Supplier,Is Frozen,Is Bevroren
+apps/erpnext/erpnext/stock/utils.py +224,Group node warehouse is not allowed to select for transactions,Groep knooppunt magazijn is niet toegestaan om te kiezen voor transacties
+DocType: Buying Settings,Buying Settings,Inkoop Instellingen
+DocType: Stock Entry Detail,BOM No. for a Finished Good Item,Stuklijst nr voor een Gereed Product Artikel
+DocType: Upload Attendance,Attendance To Date,Aanwezigheid graag:
+DocType: Request for Quotation Supplier,No Quote,Geen citaat
+DocType: Warranty Claim,Raised By,Opgevoed door
+DocType: Payment Gateway Account,Payment Account,Betaalrekening
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909,Please specify Company to proceed,Specificeer Bedrijf om verder te gaan
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27,Net Change in Accounts Receivable,Netto wijziging in Debiteuren
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,compenserende Off
+DocType: Job Offer,Accepted,Geaccepteerd
+DocType: Grant Application,Organization,Organisatie
+DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
+DocType: SG Creation Tool Course,Student Group Name,Student Group Name
+apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Show exploded view
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Fees creëren
+apps/erpnext/erpnext/setup/doctype/company/company.js +91,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Zorg ervoor dat u echt wilt alle transacties voor dit bedrijf te verwijderen. Uw stamgegevens zal blijven zoals het is. Deze actie kan niet ongedaan gemaakt worden.
+apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Zoekresultaten
+DocType: Room,Room Number,Kamernummer
+apps/erpnext/erpnext/utilities/transaction_base.py +107,Invalid reference {0} {1},Ongeldige referentie {0} {1}
+DocType: Shipping Rule,Shipping Rule Label,Verzendregel Label
+DocType: Journal Entry Account,Payroll Entry,Payroll Entry
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75,View Fees Records,Bekijk tarieven Records
+apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Maak belastingsjabloon
+apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Gebruikers Forum
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319,Raw Materials cannot be blank.,Grondstoffen kan niet leeg zijn.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498,"Could not update stock, invoice contains drop shipping item.","Kon niet bijwerken voorraad, factuur bevat daling van de scheepvaart punt."
+DocType: Lab Test Sample,Lab Test Sample,Lab Test Sample
+DocType: Item Variant Settings,Allow Rename Attribute Value,Toestaan Rename attribuutwaarde toestaan
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491,Quick Journal Entry,Quick Journal Entry
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,U kunt het tarief niet veranderen als een artikel Stuklijst-gerelateerd is.
+DocType: Restaurant,Invoice Series Prefix,Prefix voor factuurreeks
+DocType: Employee,Previous Work Experience,Vorige Werkervaring
+DocType: Stock Entry,For Quantity,Voor Aantal
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Vul Gepland Aantal in voor artikel {0} op rij {1}
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93,Google Maps integration is not enabled,Integratie met Google Maps is niet ingeschakeld
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} is niet ingediend
+DocType: Member,Membership Expiry Date,Vervaldatum lidmaatschap
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131,{0} must be negative in return document,{0} moet negatief zijn in teruggave document
+,Minutes to First Response for Issues,Minuten naar First Response voor problemen
+DocType: Purchase Invoice,Terms and Conditions1,Algemene Voorwaarden1
+apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,De naam van het instituut waarvoor u het opzetten van dit systeem.
+DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Boekingen bevroren tot deze datum, niemand kan / de boeking wijzigen behalve de hieronder gespecificeerde rol."
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Sla het document op voordat u het onderhoudsschema genereert
+apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Laatste prijs bijgewerkt in alle BOM&#39;s
+apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Project Status
+DocType: UOM,Check this to disallow fractions. (for Nos),Aanvinken om delingen te verbieden.
+DocType: Student Admission Program,Naming Series (for Student Applicant),Naming Series (voor Student Aanvrager)
+DocType: Delivery Note,Transporter Name,Vervoerder Naam
+DocType: Authorization Rule,Authorized Value,Authorized Value
+DocType: BOM,Show Operations,Toon Operations
+,Minutes to First Response for Opportunity,Minuten naar First Response voor Opportunity
+apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Totaal Afwezig
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +881,Item or Warehouse for row {0} does not match Material Request,Artikel of Magazijn voor rij {0} komt niet overeen met Materiaal Aanvraag
+apps/erpnext/erpnext/config/stock.py +195,Unit of Measure,Meeteenheid
+DocType: Fiscal Year,Year End Date,Jaar Einddatum
+DocType: Task Depends On,Task Depends On,Taak Hangt On
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026,Opportunity,Opportunity
+DocType: Operation,Default Workstation,Standaard Werkstation
+DocType: Notification Control,Expense Claim Approved Message,Kostendeclaratie Goedgekeurd Bericht
+DocType: Payment Entry,Deductions or Loss,Aftrek of verlies
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} is gesloten
+DocType: Email Digest,How frequently?,Hoe vaak?
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55,Total Collected: {0},Totaal verzameld: {0}
+DocType: Purchase Receipt,Get Current Stock,Get Huidige voorraad
+DocType: Purchase Invoice,ineligible,niet in aanmerking komen
+apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Boom van de Bill of Materials
+DocType: Student,Joining Date,Datum indiensttreding
+,Employees working on a holiday,Werknemers die op vakantie
+DocType: Share Balance,Current State,Huidige toestand
+apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Present
+DocType: Share Transfer,From Shareholder,Van aandeelhouder
+DocType: Project,% Complete Method,% Voltooid Methode
+apps/erpnext/erpnext/healthcare/setup.py +181,Drug,drug
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Onderhoud startdatum kan niet voor de leveringsdatum voor Serienummer {0}
+DocType: Work Order,Actual End Date,Werkelijke Einddatum
+DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Is aanpassing van financiële kosten
+DocType: BOM,Operating Cost (Company Currency),Bedrijfskosten (Company Munt)
+DocType: Purchase Invoice,PINV-,PINV-
+DocType: Authorization Rule,Applicable To (Role),Van toepassing zijn op (Rol)
+DocType: BOM Update Tool,Replace BOM,Vervang BOM
+apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Code {0} bestaat al
+DocType: Employee Advance,Purpose,Doel
+DocType: Company,Fixed Asset Depreciation Settings,Fixed Asset Afschrijvingen Instellingen
+DocType: Item,Will also apply for variants unless overrridden,Geldt ook voor varianten tenzij overrridden
+DocType: Purchase Invoice,Advances,Vooruitgang
+DocType: Work Order,Manufacture against Material Request,Fabricage tegen Material Request
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Assessment Group: ,Evaluatiegroep:
+DocType: Item Reorder,Request for,Verzoek tot
+apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Goedkeuring van Gebruiker kan niet hetzelfde zijn als gebruiker de regel is van toepassing op
+DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Basistarief (per eenheid)
+DocType: SMS Log,No of Requested SMS,Aantal gevraagde SMS
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246,Leave Without Pay does not match with approved Leave Application records,Onbetaald verlof komt niet overeen met de goedgekeurde verlofaanvraag verslagen
+DocType: Campaign,Campaign-.####,Campagne-.####
+apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Volgende stappen
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796,Please supply the specified items at the best possible rates,Gelieve de opgegeven items aan de best mogelijke prijzen
+DocType: Membership,USD,Amerikaanse Dollar
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Maak Factuur
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +102,Remaining Balance,Resterende saldo
+DocType: Selling Settings,Auto close Opportunity after 15 days,Auto dicht Opportunity na 15 dagen
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Aankooporders zijn niet toegestaan voor {0} door een scorecard van {1}.
+apps/erpnext/erpnext/stock/doctype/item/item.py +498,Barcode {0} is not a valid {1} code,Barcode {0} is geen geldige {1} code
+apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,Eindjaar
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Lead%
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Lead%
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Contract Einddatum moet groter zijn dan datum van indiensttreding zijn
+DocType: Driver,Driver,Bestuurder
+DocType: Vital Signs,Nutrition Values,Voedingswaarden
+DocType: Lab Test Template,Is billable,Is facturabel
+DocType: Delivery Note,DN-,DN
+DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Een derde partij distributeur / dealer / commissionair / affiliate / reseller die uw producten voor een commissie verkoopt.
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} tegen Inkooporder {1}
+DocType: Patient,Patient Demographics,Patient Demographics
+DocType: Task,Actual Start Date (via Time Sheet),Werkelijke Startdatum (via Urenregistratie)
+apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,"Dit is een voorbeeld website, automatisch gegenereerd door ERPNext"
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43,Ageing Range 1,Vergrijzing Range 1
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212,Total advance amount cannot be greater than total claimed amount,Het totale voorschotbedrag kan niet groter zijn dan het totaalbedrag waarvoor een claim is ingediend
+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.","Standaard belasting sjabloon die kan worden toegepast op alle inkooptransacties. Deze sjabloon kan lijst van fiscale hoofden en ook andere kosten koppen als ""Verzenden"", ""Verzekering"" bevatten, ""Omgaan met"" enz 
+
+ #### Opmerking 
+
+ De belastingdruk die u hier definieert zal het normale belastingtarief voor alle ** Items worden **. Als er ** Items ** dat verschillende tarieven hebben, moeten ze worden toegevoegd in de ** Item Tax ** tafel in de ** Item ** meester.
+
+ #### Beschrijving van Kolommen 
+
+ 1. Berekening Type: 
+ - Dit kan op ** Netto Totaal ** (dat is de som van het basisbedrag).
+ - ** Op Vorige Row Total / Bedrag ** (voor cumulatieve belastingen of heffingen). Als u deze optie selecteert, zal de belasting worden berekend als een percentage van de vorige rij (in de fiscale tabel) bedrag of totaal.
+ - ** Werkelijke ** (zoals vermeld).
+ 2. Account Head: De Account grootboek waaronder deze belasting 
+ 3 zal worden geboekt. Cost Center: Als de belasting / heffing is een inkomen (zoals de scheepvaart) of kosten die het nodig heeft tegen een kostenplaats worden geboekt.
+ 4. Beschrijving: Beschrijving van de belasting (die zullen worden afgedrukt in de facturen / offertes).
+ 5. Rate: belastingtarief.
+ 6. Bedrag: BTW bedrag.
+ 7. Totaal: Cumulatief totaal op dit punt.
+ 8. Voer Row: Als op basis van ""Vorige Row Total"" kunt u het rijnummer die zullen worden genomen als basis voor deze berekening (standaard is de vorige rij) te selecteren.
+ 9. Overweeg Tax of Charge voor: In dit gedeelte kunt u aangeven of de belasting / heffing is alleen voor de waardering (geen deel uit van het totaal) of alleen voor de totale (voegt niets toe aan het item) of voor beide.
+ 10. Toe te voegen of Trek: Of u wilt toevoegen of aftrekken van de belasting."
+DocType: Homepage,Homepage,Startpagina
+apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68,Select Physician...,Selecteer arts ...
+DocType: Grant Application,Grant Application Details ,Aanvraagdetails toekennen
+DocType: Stock Entry Detail,Original Item,Origineel item
+DocType: Purchase Receipt Item,Recd Quantity,Benodigde hoeveelheid
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Fee Records Gemaakt - {0}
+DocType: Asset Category Account,Asset Category Account,Asset Categorie Account
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,Row #{0} (Payment Table): Amount must be positive,Rij # {0} (betalingstabel): bedrag moet positief zijn
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteNum,CompteNum
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Kan niet meer produceren van Artikel {0} dan de Verkooporder hoeveelheid {1}
+apps/erpnext/erpnext/stock/doctype/item/item.js +391,Select Attribute Values,Selecteer kenmerkwaarden
+DocType: Purchase Invoice,Reason For Issuing document,Reden voor afgifte document
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Stock Entry {0} is niet ingediend
+DocType: Payment Reconciliation,Bank / Cash Account,Bank- / Kasrekening
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +47,Next Contact By cannot be same as the Lead Email Address,Volgende Contact Door het kan niet hetzelfde zijn als de Lead e-mailadres
+DocType: Tax Rule,Billing City,Stad
+DocType: Asset,Manual,handboek
+DocType: Salary Component Account,Salary Component Account,Salaris Component Account
+DocType: Global Defaults,Hide Currency Symbol,Verberg Valutasymbool
+apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Donorinformatie.
+apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","bijv. Bank, Kas, Credit Card"
+DocType: Lead Source,Source Name,Bron naam
+DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normale rustende bloeddruk bij een volwassene is ongeveer 120 mmHg systolisch en 80 mmHg diastolisch, afgekort &quot;120/80 mmHg&quot;"
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Stel de houdbaarheid van items in dagen in, om de vervaldatum in te stellen op basis van manufacturing_date plus zelfredzaamheid"
+DocType: Journal Entry,Credit Note,Creditnota
+DocType: Projects Settings,Ignore Employee Time Overlap,Negeer overlap tussen werknemerstijd
+DocType: Warranty Claim,Service Address,Service Adres
+DocType: Asset Maintenance Task,Calibration,ijking
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97,{0} is a company holiday,{0} is een bedrijfsvakantie
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Meubels en Wedstrijden
+DocType: Item,Manufacture,Fabricage
+apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Company,Setup Company
+,Lab Test Report,Lab Test Report
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Gelieve Afleveringsbon eerste
+DocType: Student Applicant,Application Date,Application Date
+DocType: Salary Detail,Amount based on formula,Bedrag op basis van de formule
+DocType: Purchase Invoice,Currency and Price List,Valuta en Prijslijst
+DocType: Opportunity,Customer / Lead Name,Klant / Lead Naam
+apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115,Clearance Date not mentioned,Ontruiming Datum niet vermeld
+apps/erpnext/erpnext/config/manufacturing.py +7,Production,productie
+DocType: Guardian,Occupation,Bezetting
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Rij {0} : Start Datum moet voor Einddatum zijn
+DocType: Crop,Planting Area,Plant gebied
+apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Totaal (Aantal)
+DocType: Installation Note Item,Installed Qty,Aantal geïnstalleerd
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Dit kan zijn door sommige ongeldige e-mailadressen in de
+apps/erpnext/erpnext/utilities/user_progress.py +31,You added ,Jij voegde toe
+DocType: Purchase Taxes and Charges,Parenttype,Parenttype
+apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,training Resultaat
+DocType: Purchase Invoice,Is Paid,Is betaald
+DocType: Salary Structure,Total Earning,Totale Winst
+DocType: Purchase Receipt,Time at which materials were received,Tijdstip waarop materialen zijn ontvangen
+DocType: Products Settings,Products per Page,Producten per pagina
+DocType: Stock Ledger Entry,Outgoing Rate,Uitgaande Rate
+apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Organisatie tak meester .
+apps/erpnext/erpnext/controllers/accounts_controller.py +313, or ,of
+DocType: Sales Order,Billing Status,Factuurstatus
+apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Issue melden?
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Utiliteitskosten
+apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Boven
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Rij # {0}: Journal Entry {1} heeft geen account {2} of al vergeleken met een ander voucher
+DocType: Supplier Scorecard Criteria,Criteria Weight,Criteria Gewicht
+DocType: Buying Settings,Default Buying Price List,Standaard Inkoop Prijslijst
+DocType: Payroll Entry,Salary Slip Based on Timesheet,Salarisstrook Op basis van Timesheet
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43,Buying Rate,Koopsnelheid
+DocType: Notification Control,Sales Order Message,Verkooporder Bericht
+apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Instellen Standaardwaarden zoals Bedrijf , Valuta , huidige boekjaar , etc."
+DocType: Payment Entry,Payment Type,Betaling Type
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +240,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Selecteer een partij voor item {0}. Kan geen enkele batch vinden die aan deze eis voldoet
+DocType: Hub Category,Parent Category,Bovenliggende categorie
+DocType: Payroll Entry,Select Employees,Selecteer Medewerkers
+DocType: Opportunity,Potential Sales Deal,Potentiële Sales Deal
+DocType: Complaint,Complaints,klachten
+DocType: Payment Entry,Cheque/Reference Date,Cheque / Reference Data
+DocType: Purchase Invoice,Total Taxes and Charges,Totaal belastingen en toeslagen
+DocType: Employee,Emergency Contact,Noodgeval Contact
+DocType: Bank Reconciliation Detail,Payment Entry,betaling Entry
+,sales-browser,sales-browser
+apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Grootboek
+DocType: Patient Medical Record,PMR-,PMR-
+DocType: Drug Prescription,Drug Code,Drug Code
+DocType: Target Detail,Target  Amount,Streefbedrag
+DocType: POS Profile,Print Format for Online,Afdrukformaat voor online
+DocType: Shopping Cart Settings,Shopping Cart Settings,Winkelwagen Instellingen
+DocType: Journal Entry,Accounting Entries,Boekingen
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Als de geselecteerde prijsbepalingsregel is gemaakt voor &#39;Tarief&#39;, overschrijft deze de prijslijst. Prijzen Regel tarief is het laatste tarief, dus geen verdere korting moet worden toegepast. Daarom wordt het bij transacties zoals klantorder, inkooporder, enz. Opgehaald in het veld &#39;Tarief&#39; in plaats van het veld &#39;Prijslijstsnelheid&#39;."
+apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Dubbele invoer. Controleer Autorisatie Regel {0}
+DocType: Journal Entry Account,Reference Due Date,Referentie vervaldag
+DocType: Purchase Order,Ref SQ,Ref SQ
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Ontvangst document moet worden ingediend
+DocType: Purchase Invoice Item,Received Qty,Ontvangen Aantal
+DocType: Stock Entry Detail,Serial No / Batch,Serienummer / Batch
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Niet betaald en niet geleverd
+DocType: Product Bundle,Parent Item,Bovenliggend Artikel
+DocType: Account,Account Type,Rekening Type
+DocType: Delivery Note,DN-RET-,DN-terugwerkende
+apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Geen tijd sheets
+DocType: GoCardless Mandate,GoCardless Customer,GoCardless klant
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,Verlaat Type {0} kan niet worden doorgestuurd dragen-
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Onderhoudsschema wordt niet gegenereerd voor alle items . Klik op ' Generate Schedule'
+,To Produce,Produceren
+apps/erpnext/erpnext/config/hr.py +93,Payroll,Loonlijst
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Voor rij {0} in {1}. Om {2} onder in punt tarief, rijen {3} moet ook opgenomen worden"
+DocType: Patient Service Unit,Parent Service Unit,Parent Service Unit
+apps/erpnext/erpnext/utilities/activation.py +101,Make User,maak Gebruiker
+DocType: Packing Slip,Identification of the package for the delivery (for print),Identificatie van het pakket voor de levering (voor afdrukken)
+DocType: Bin,Reserved Quantity,Gereserveerde Hoeveelheid
+apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Vul alstublieft een geldig e-mailadres in
+apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Vul alstublieft een geldig e-mailadres in
+DocType: Volunteer Skill,Volunteer Skill,Vrijwillige vaardigheid
+DocType: Bank Reconciliation,Include POS Transactions,POS-transacties opnemen
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +797,Please select an item in the cart,Selecteer een item in de winkelwagen
+DocType: Landed Cost Voucher,Purchase Receipt Items,Ontvangstbevestiging Artikelen
+apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Aanpassen Formulieren
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,achterstand
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Afschrijvingen bedrag gedurende de periode
+apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Gehandicapte template mag niet standaard template
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314,For row {0}: Enter planned qty,Voor rij {0}: Voer het geplande aantal in
+DocType: Shareholder,SH-,SH
+DocType: Account,Income Account,Inkomstenrekening
+DocType: Payment Request,Amount in customer's currency,Bedrag in de valuta van de klant
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825,Delivery,Levering
+DocType: Volunteer,Weekdays,Doordeweekse dagen
+DocType: Stock Reconciliation Item,Current Qty,Huidige Aantal
+DocType: Restaurant Menu,Restaurant Menu,Restaurant Menu
+apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Vorige
+DocType: Appraisal Goal,Key Responsibility Area,Key verantwoordelijkheid Area
+apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Student Batches helpen bijhouden opkomst, evaluaties en kosten voor studenten"
+DocType: Payment Entry,Total Allocated Amount,Totaal toegewezen bedrag
+apps/erpnext/erpnext/setup/doctype/company/company.py +151,Set default inventory account for perpetual inventory,Stel standaard inventaris rekening voor permanente inventaris
+DocType: Item Reorder,Material Request Type,Materiaal Aanvraag Type
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Journal Entry voor de salarissen van {0} tot {1}
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Verstuur Grant Review Email
+apps/erpnext/erpnext/accounts/page/pos/pos.js +848,"LocalStorage is full, did not save","LocalStorage vol is, niet te redden"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100,Row {0}: UOM Conversion Factor is mandatory,Rij {0}: Verpakking Conversie Factor is verplicht
+apps/erpnext/erpnext/utilities/user_progress.py +235,Room Capacity,Kamer capaciteit
+apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +28,Already record exists for the item {0},Er bestaat al record voor het item {0}
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +28,Ref,Ref
+DocType: Lab Test,LP-,LP-
+DocType: Healthcare Settings,Registration Fee,Zonder registratie
+DocType: Budget,Cost Center,Kostenplaats
+apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,Coupon #
+DocType: Notification Control,Purchase Order Message,Inkooporder Bericht
+DocType: Tax Rule,Shipping Country,Verzenden Land
+DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Hide Klant het BTW-nummer van Verkooptransacties
+DocType: Upload Attendance,Upload HTML,Upload HTML
+DocType: Employee,Relieving Date,Ontslagdatum
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Prijsbepalingsregel overschrijft de prijslijst / defininieer een kortingspercentage, gebaseerd op een aantal criteria."
+DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Magazijn kan alleen via Voorraad Invoer / Vrachtbrief / Ontvangstbewijs worden veranderd
+DocType: Employee Education,Class / Percentage,Klasse / Percentage
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Hoofd Marketing en Verkoop
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Inkomstenbelasting
+apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Houd Leads bij per de industrie type.
+apps/erpnext/erpnext/utilities/user_progress.py +101,Go to Letterheads,Ga naar Briefhoofden
+DocType: Item Supplier,Item Supplier,Artikel Leverancier
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1255,Please enter Item Code to get batch no,Vul de artikelcode  in om batchnummer op te halen
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880,Please select a value for {0} quotation_to {1},Selecteer een waarde voor {0} quotation_to {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419,No Items selected for transfer,Geen items geselecteerd voor overdracht
+apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Alle adressen.
+DocType: Company,Stock Settings,Voorraad Instellingen
+apps/erpnext/erpnext/accounts/doctype/account/account.py +183,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Samenvoegen kan alleen als volgende eigenschappen in beide registers. Is Group, Root Type, Company"
+DocType: Vehicle,Electric,elektrisch
+DocType: Task,% Progress,% Voortgang
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Winst / verlies op de verkoop van activa
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +21,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Alleen de studentaanvrager met de status &quot;Goedgekeurd&quot; wordt geselecteerd in de onderstaande tabel.
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Accountnummer voor account {0} is niet beschikbaar. <br> Stel uw rekeningschema correct in.
+DocType: Task,Depends on Tasks,Hangt af van Taken
+apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Beheer Customer Group Boom .
+DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Bijlagen kunnen worden getoond zonder de winkelwagentje in te schakelen
+DocType: Normal Test Items,Result Value,Resultaat Waarde
+DocType: Hotel Room,Hotels,hotels
+DocType: Supplier Quotation,SQTN-,SQTN-
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Nieuwe Kostenplaats Naam
+DocType: Leave Control Panel,Leave Control Panel,Verlof Configuratiescherm
+DocType: Project,Task Completion,Task Completion
+apps/erpnext/erpnext/templates/includes/product_page.js +22,Not in Stock,Niet op voorraad
+DocType: Volunteer,Volunteer Skills,Vrijwilligersvaardigheden
+DocType: Appraisal,HR User,HR Gebruiker
+DocType: Purchase Invoice,Taxes and Charges Deducted,Belastingen en Toeslagen Afgetrokken
+apps/erpnext/erpnext/hooks.py +142,Issues,Kwesties
+apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status moet één zijn van {0}
+apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Herinnering om GSTIN verzonden te updaten
+DocType: Sales Invoice,Debit To,Debitering van
+DocType: Restaurant Menu Item,Restaurant Menu Item,Restaurant Menu-item
+DocType: Delivery Note,Required only for sample item.,Alleen benodigd voor Artikelmonster.
+DocType: Stock Ledger Entry,Actual Qty After Transaction,Werkelijke Aantal Na Transactie
+,Pending SO Items For Purchase Request,In afwachting van Verkoop Artikelen voor Inkoopaanvraag
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,studentenadministratie
+apps/erpnext/erpnext/accounts/party.py +388,{0} {1} is disabled,{0} {1} is uitgeschakeld
+DocType: Supplier,Billing Currency,Valuta
+DocType: Sales Invoice,SINV-RET-,SINV-terugwerkende
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Extra Groot
+DocType: Crop,Scientific Name,Wetenschappelijke naam
+apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Totaal Leaves
+DocType: Customer,"Reselect, if the chosen contact is edited after save","Selecteer opnieuw, als het gekozen contact is bewerkt na opslaan"
+DocType: Consultation,In print,In druk
+,Profit and Loss Statement,Winst-en verliesrekening
+DocType: Bank Reconciliation Detail,Cheque Number,Cheque nummer
+,Sales Browser,Verkoop verkenner
+DocType: Journal Entry,Total Credit,Totaal Krediet
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Waarschuwing: Een andere {0} # {1} bestaat tegen voorraad binnenkomst {2}
+apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Lokaal
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Leningen en voorschotten (Activa)
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Debiteuren
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Groot
+DocType: Homepage Featured Product,Homepage Featured Product,Homepage Featured Product
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248,All Assessment Groups,Alle Assessment Groepen
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Nieuwe Warehouse Naam
+apps/erpnext/erpnext/accounts/report/financial_statements.py +259,Total {0} ({1}),Totaal {0} ({1})
+DocType: C-Form Invoice Detail,Territory,Regio
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Vermeld het benodigde aantal bezoeken
+DocType: Stock Settings,Default Valuation Method,Standaard Waarderingsmethode
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,honorarium
+apps/erpnext/erpnext/setup/doctype/company/company.js +154,Update in progress. It might take a while.,Update wordt uitgevoerd. Het kan even duren.
+DocType: Production Plan Item,Produced Qty,Geproduceerd aantal
+DocType: Vehicle Log,Fuel Qty,brandstof Aantal
+DocType: Stock Entry,Target Warehouse Name,Target Warehouse Name
+DocType: Work Order Operation,Planned Start Time,Geplande Starttijd
+DocType: Course,Assessment,Beoordeling
+DocType: Payment Entry Reference,Allocated,Toegewezen
+apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Sluiten Balans en boek Winst of verlies .
+DocType: Student Applicant,Application Status,Application Status
+DocType: Sensitivity Test Items,Sensitivity Test Items,Gevoeligheid Test Items
+DocType: Project Update,Project Update,Project update
+DocType: Fees,Fees,vergoedingen
+DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Specificeer Wisselkoers om een valuta om te zetten in een andere
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Offerte {0} is geannuleerd
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +128,Total Outstanding Amount,Totale uitstaande bedrag
+DocType: Sales Partner,Targets,Doelen
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54,Please register the SIREN number in the company information file,Registreer het SIREN-nummer in het bedrijfsinformatiedossier
+DocType: Price List,Price List Master,Prijslijst Master
+DocType: GST Account,CESS Account,CESS-account
+DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Alle Verkoop Transacties kunnen worden gelabeld tegen meerdere ** Sales Personen **, zodat u kunt instellen en controleren doelen."
+,S.O. No.,VO nr
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Maak Klant van Lead {0}
+apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Selecteer Patiënt
+DocType: Price List,Applicable for Countries,Toepasselijk voor Landen
+DocType: Supplier Scorecard Scoring Variable,Parameter Name,Parameter Naam
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Student groepsnaam is verplicht in de rij {0}
+DocType: Homepage,Products to be shown on website homepage,Producten die worden getoond op de website homepage
+apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Dit is een basis klantgroep en kan niet worden bewerkt .
+DocType: Student,AB-,AB-
+DocType: POS Profile,Ignore Pricing Rule,Negeer Prijsregel
+DocType: Employee Education,Graduate,Afstuderen
+DocType: Leave Block List,Block Days,Blokeer Dagen
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Verzendadres heeft geen land, wat nodig is voor deze verzendregel"
+DocType: Journal Entry,Excise Entry,Accijnzen Boeking
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Waarschuwing: Sales Order {0} bestaat al tegen Klant Bestelling {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.","Algemene Voorwaarden die kunnen worden toegevoegd aan de verkopen en aankopen.
+
+ Voorbeelden: 
+
+ 1. Geldigheid van het aanbod.
+ 1. Betalingscondities (In Advance, op krediet, een deel vooraf etc).
+ 1. Wat is extra (of ten laste van de Klant).
+ 1. Veiligheid / gebruik waarschuwing.
+ 1. Garantie indien van toepassing.
+ 1. Returns Policy '.
+ 1. Termen van de scheepvaart, indien van toepassing.
+ 1. Methoden voor het aanpakken geschillen, schadevergoeding, aansprakelijkheid, enz. 
+ 1. Adres en contactgegevens van uw bedrijf."
+DocType: Issue,Issue Type,Uitgiftetype
+DocType: Attendance,Leave Type,Verlof Type
+DocType: Purchase Invoice,Supplier Invoice Details,Leverancier Invoice Details
+DocType: Agriculture Task,Ignore holidays,Vakantie negeren
+apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Kosten- / Verschillenrekening ({0}) moet een 'Winst of Verlies' rekening zijn.
+DocType: Project,Copied From,Gekopieerd van
+DocType: Project,Copied From,Gekopieerd van
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340,Invoice already created for all billing hours,Factuur al gemaakt voor alle factureringsuren
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Naam fout: {0}
+DocType: Cash Flow Mapping,Is Finance Cost,Zijn financiële kosten
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Aanwezigheid voor werknemer {0} is al gemarkeerd
+DocType: Packing Slip,If more than one package of the same type (for print),Als er meer dan een pakket van hetzelfde type (voor afdrukken)
+apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Stel de standaardklant in in restaurantinstellingen
+,Salary Register,salaris Register
+DocType: Warehouse,Parent Warehouse,Parent Warehouse
+DocType: C-Form Invoice Detail,Net Total,Netto Totaal
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +549,Default BOM not found for Item {0} and Project {1},Standaard BOM niet gevonden voor Item {0} en Project {1}
+apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Definieer verschillende soorten lening
+DocType: Bin,FCFS Rate,FCFS Rate
+DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Openstaand Bedrag
+apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Tijd (in minuten)
+DocType: Project Task,Working,Werkzaam
+DocType: Stock Ledger Entry,Stock Queue (FIFO),Voorraad rij (FIFO)
+apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Financieel jaar
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} behoort niet tot Bedrijf {1}
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,Kan de criteria score functie voor {0} niet oplossen. Zorg ervoor dat de formule geldig is.
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Kosten Op
+DocType: Healthcare Settings,Out Patient Settings,Out Patient Settings
+DocType: Account,Round Off,Afronden
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +263,Quantity must be positive,De hoeveelheid moet positief zijn
+DocType: Material Request Plan Item,Requested Qty,Aangevraagde Hoeveelheid
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96,The fields From Shareholder and To Shareholder cannot be blank,De velden Van Aandeelhouder en Aandeelhouder mogen niet leeg zijn
+DocType: Tax Rule,Use for Shopping Cart,Gebruik voor de Winkelwagen
+apps/erpnext/erpnext/controllers/item_variant.py +101,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Waarde {0} voor Attribute {1} bestaat niet in de lijst van geldige Punt Attribute Values voor post {2}
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Selecteer serienummers
+DocType: BOM Item,Scrap %,Scrap%
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Kosten zullen worden proportioneel gedistribueerd op basis van punt aantal of de hoeveelheid, als per uw selectie"
+DocType: Maintenance Visit,Purposes,Doeleinden
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112,Atleast one item should be entered with negative quantity in return document,Minstens één punt moet in ruil document worden ingevoerd met een negatieve hoeveelheid
+apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operation {0} langer dan alle beschikbare werktijd in werkstation {1}, breken de operatie in meerdere operaties"
+DocType: Membership,Membership Status,Lidmaatschapsstatus
+,Requested,Aangevraagd
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Geen Opmerkingen
+DocType: Asset,In Maintenance,In onderhoud
+DocType: Purchase Invoice,Overdue,Achterstallig
+DocType: Account,Stock Received But Not Billed,Voorraad ontvangen maar nog niet gefactureerd
+apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root Account must be a group,Root account moet een groep
+DocType: Drug Prescription,Drug Prescription,Drug Prescription
+DocType: Fees,FEE.,FEE.
+DocType: Employee Loan,Repaid/Closed,Afgelost / Gesloten
+DocType: Item,Total Projected Qty,Totale geraamde Aantal
+DocType: Monthly Distribution,Distribution Name,Distributie Naam
+apps/erpnext/erpnext/stock/stock_ledger.py +477,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Waarderingspercentage niet gevonden voor het item {0}, die vereist is om boekhoudkundige vermeldingen voor {1} {2} te doen. Als het item als een nulwaarderingspercentage in de {1} wordt verwerkt, vermeld dan dat in de {1} Item tabel. Anders kunt u een inkomende voorraadtransactie voor het item maken of een waarderingspercentage vermelden in het Item-record, en probeer dan deze invoer te verzenden / annuleren"
+DocType: Course,Course Code,cursus Code
+apps/erpnext/erpnext/controllers/stock_controller.py +337,Quality Inspection required for Item {0},Kwaliteitscontrole vereist voor Artikel {0}
+DocType: POS Settings,Use POS in Offline Mode,Gebruik POS in de offline modus
+DocType: Supplier Scorecard,Supplier Variables,Leveranciersvariabelen
+DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Koers waarmee de Klant Valuta wordt omgerekend naar de basis bedrijfsvaluta
+DocType: Purchase Invoice Item,Net Rate (Company Currency),Net Rate (Company Valuta)
+DocType: Salary Detail,Condition and Formula Help,Toestand en Formula Help
+apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Beheer Grondgebied Boom.
+DocType: Patient Service Unit,Patient Service Unit,Patient Service Unit
+DocType: Journal Entry Account,Sales Invoice,Verkoopfactuur
+DocType: Journal Entry Account,Party Balance,Partij Balans
+DocType: Cash Flow Mapper,Section Subtotal,Sectie Subtotaal
+apps/erpnext/erpnext/accounts/page/pos/pos.js +498,Please select Apply Discount On,Selecteer Apply Korting op
+DocType: Stock Settings,Sample Retention Warehouse,Sample Retention Warehouse
+DocType: Company,Default Receivable Account,Standaard Vordering Account
+DocType: Physician Schedule,Physician Schedule,Arts schema
+DocType: Purchase Invoice,Deemed Export,Geachte export
+DocType: Stock Entry,Material Transfer for Manufacture,Materiaal Verplaatsing voor Productie
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Kortingspercentage kan worden toegepast tegen een prijslijst of voor alle prijslijsten.
+DocType: Subscription,Half-yearly,Halfjaarlijks
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,Accounting Entry for Stock,Boekingen voor Voorraad
+DocType: Lab Test,LabTest Approver,LabTest Approver
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61,You have already assessed for the assessment criteria {}.,U heeft al beoordeeld op de beoordelingscriteria {}.
+DocType: Vehicle Service,Engine Oil,Motorolie
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1006,Work Orders Created: {0},Werkorders aangemaakt: {0}
+DocType: Sales Invoice,Sales Team1,Verkoop Team1
+apps/erpnext/erpnext/stock/doctype/item/item.py +547,Item {0} does not exist,Artikel {0} bestaat niet
+DocType: Sales Invoice,Customer Address,Klant Adres
+DocType: Employee Loan,Loan Details,Loan Details
+DocType: Company,Default Inventory Account,Standaard Inventaris Account
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192,The folio numbers are not matching,De folionummers komen niet overeen
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Rij {0}: Voltooid Aantal moet groter zijn dan nul.
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262,Payment Request for {0},Betalingsverzoek voor {0}
+DocType: Item Barcode,Barcode Type,Streepjescodetype
+DocType: Antibiotic,Antibiotic Name,Antibiotische naam
+DocType: Purchase Invoice,Apply Additional Discount On,Breng Extra Korting op
+apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66,Select Type...,Selecteer type...
+DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Een link naar alle landeenheden waarin het gewas groeit
+DocType: Account,Root Type,Root Type
+DocType: Item,FIFO,FIFO
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136,Row # {0}: Cannot return more than {1} for Item {2},Rij # {0}: Kan niet meer dan terugkeren {1} voor post {2}
+DocType: Item Group,Show this slideshow at the top of the page,Laat deze slideshow aan de bovenkant van de pagina
+DocType: BOM,Item UOM,Artikel Eenheid
+DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Belasting Bedrag na korting Bedrag (Company valuta)
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177,Target warehouse is mandatory for row {0},Doel magazijn is verplicht voor rij {0}
+DocType: Cheque Print Template,Primary Settings,Primaire Instellingen
+DocType: Purchase Invoice,Select Supplier Address,Select Leverancier Adres
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Werknemers toevoegen
+DocType: Purchase Invoice Item,Quality Inspection,Kwaliteitscontrole
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Extra Small
+DocType: Company,Standard Template,Standard Template
+DocType: Training Event,Theory,Theorie
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806,Warning: Material Requested Qty is less than Minimum Order Qty,Waarschuwing: Materiaal Aanvraag Aantal is minder dan Minimum Bestelhoeveelheid
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Rekening {0} is bevroren
+DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Rechtspersoon / Dochteronderneming met een aparte Rekeningschema behoren tot de Organisatie.
+DocType: Payment Request,Mute Email,Mute-mail
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Voeding, Drank en Tabak"
+DocType: Account,Account Number,Rekeningnummer
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752,Can only make payment against unbilled {0},Kan alleen betaling uitvoeren voor ongefactureerde {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +102,Commission rate cannot be greater than 100,Commissietarief kan niet groter zijn dan 100
+DocType: Volunteer,Volunteer,Vrijwilliger
+DocType: Stock Entry,Subcontract,Subcontract
+apps/erpnext/erpnext/public/js/utils/party.js +166,Please enter {0} first,Voer {0} eerste
+apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,Geen antwoorden van
+DocType: Work Order Operation,Actual End Time,Werkelijke Eindtijd
+DocType: Item,Manufacturer Part Number,Onderdeelnummer fabrikant
+DocType: Work Order Operation,Estimated Time and Cost,Geschatte Tijd en Kosten
+DocType: Bin,Bin,Bak
+DocType: Crop,Crop Name,Gewasnaam
+DocType: SMS Log,No of Sent SMS,Aantal gestuurde SMS
+DocType: Antibiotic,Healthcare Administrator,Gezondheidszorg Administrator
+apps/erpnext/erpnext/utilities/user_progress.py +47,Set a Target,Stel een doel in
+DocType: Dosage Strength,Dosage Strength,Dosis Sterkte
+DocType: Account,Expense Account,Kostenrekening
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,software
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Kleur
+DocType: Assessment Plan Criteria,Assessment Plan Criteria,Assessment Plan Criteria
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +118,Expiry date is mandatory for selected item,De vervaldatum is verplicht voor het geselecteerde artikel
+DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Voorkom aankopen
+apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,vatbaar
+DocType: Patient Appointment,Scheduled,Geplande
+apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Aanvraag voor een offerte.
+apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Selecteer Item, waar &quot;Is Stock Item&quot; is &quot;Nee&quot; en &quot;Is Sales Item&quot; is &quot;Ja&quot; en er is geen enkel ander product Bundle"
+apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Selecteer klant
+DocType: Student Log,Academic,Academisch
+DocType: Patient,Personal and Social History,Persoonlijke en sociale geschiedenis
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,Gebruiker {0} gemaakt
+DocType: Fee Schedule,Fee Breakup for each student,Fee Breakup voor elke student
+apps/erpnext/erpnext/controllers/accounts_controller.py +541,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Totaal vooraf ({0}) tegen Orde {1} kan niet groter zijn dan de Grand totaal zijn ({2})
+DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Selecteer Maandelijkse Distribution om ongelijk te verdelen doelen in heel maanden.
+apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Wijzig code
+DocType: Purchase Invoice Item,Valuation Rate,Waardering Tarief
+DocType: Stock Reconciliation,SR/,SR /
+DocType: Vehicle,Diesel,Diesel
+apps/erpnext/erpnext/stock/get_item_details.py +388,Price List Currency not selected,Prijslijst Valuta nog niet geselecteerd
+DocType: Purchase Invoice,Availed ITC Cess,Beschikbaar ITC Cess
+,Student Monthly Attendance Sheet,Student Maandelijkse presentielijst
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Verzendregel alleen van toepassing op verkopen
+apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Project Start Datum
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +32,Until,Totdat
+DocType: Rename Tool,Rename Log,Hernoemen Log
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Studentgroep of cursusschema is verplicht
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Studentgroep of cursusschema is verplicht
+DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Maintain Billing en werktijden Same op Timesheet
+DocType: Maintenance Visit Purpose,Against Document No,Tegen Document nr.
+DocType: BOM,Scrap,stukje
+apps/erpnext/erpnext/utilities/user_progress.py +217,Go to Instructors,Ga naar instructeurs
+apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Beheer Verkoop Partners.
+DocType: Quality Inspection,Inspection Type,Inspectie Type
+DocType: Fee Validity,Visited yet,Nog bezocht
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134,Warehouses with existing transaction can not be converted to group.,Warehouses met bestaande transactie kan niet worden geconverteerd naar groep.
+DocType: Assessment Result Tool,Result HTML,resultaat HTML
+apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Verloopt op
+apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Studenten toevoegen
+apps/erpnext/erpnext/public/js/utils.js +412,Please select {0},Selecteer {0}
+DocType: C-Form,C-Form No,C-vorm nr.
+DocType: BOM,Exploded_items,Uitgeklapte Artikelen
+apps/erpnext/erpnext/utilities/user_progress.py +139,List your products or services that you buy or sell.,Maak een overzicht van uw producten of diensten die u koopt of verkoopt.
+DocType: Water Analysis,Storage Temperature,Bewaar temperatuur
+DocType: Employee Attendance Tool,Unmarked Attendance,Ongemerkte aanwezigheid
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,onderzoeker
+DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Programma Inschrijving Tool Student
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Startdatum moet minder zijn dan de einddatum voor taak {0}
+apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Naam of E-mail is verplicht
+DocType: Member,MEM-,MEM-
+DocType: Instructor,Instructor Log,Instructeurslogboek
+DocType: Purchase Order Item,Returned Qty,Terug Aantal
+DocType: Student,Exit,Uitgang
+apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Root Type is verplicht
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Kan presets niet installeren
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} heeft momenteel een {1} leverancierscore kaart, en RFQs aan deze leverancier moeten met voorzichtigheid worden uitgegeven."
+DocType: Chapter,Non Profit Manager,Non-profit manager
+DocType: BOM,Total Cost(Company Currency),Total Cost (Company Munt)
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +321,Serial No {0} created,Serienummer {0} aangemaakt
+DocType: Homepage,Company Description for website homepage,Omschrijving bedrijf voor website homepage
+DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Voor het gemak van de klanten, kunnen deze codes worden gebruikt in gedrukte formaten zoals facturen en de leveringsbonnen"
+apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,suplier Naam
+apps/erpnext/erpnext/accounts/report/financial_statements.py +174,Could not retrieve information for {0}.,Kan informatie niet ophalen voor {0}.
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134,Opening Entry Journal,Opening dagboek
+DocType: Sales Invoice,Time Sheet List,Urenregistratie List
+DocType: Employee,You can enter any date manually,U kunt elke datum handmatig ingeven
+DocType: Healthcare Settings,Result Printed,Resultaat afgedrukt
+DocType: Asset Category Account,Depreciation Expense Account,Afschrijvingen Account
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233,Probationary Period,Proeftijd
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Bekijk {0}
+DocType: Customer Group,Only leaf nodes are allowed in transaction,Alleen leaf nodes zijn toegestaan in transactie
+DocType: Project,Total Costing Amount (via Timesheets),Totale kostenbedrag (via urenstaten)
+DocType: Employee Advance,Expense Approver,Onkosten Goedkeurder
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Rij {0}: Advance tegen Klant moet krediet
+DocType: Project,Hourly,ieder uur
+apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-groep tot groep
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Partij is verplicht in rij {0}
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Partij is verplicht in rij {0}
+DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Ontvangstbevestiging Artikel geleverd
+apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Om Datetime
+apps/erpnext/erpnext/config/selling.py +302,Logs for maintaining sms delivery status,Logs voor het behoud van sms afleverstatus
+DocType: Accounts Settings,Make Payment via Journal Entry,Betalen via Journal Entry
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +237,Printed On,Gedrukt op
+DocType: Item,Inspection Required before Delivery,Inspectie vereist voordat Delivery
+DocType: Item,Inspection Required before Purchase,Inspectie vereist voordat Purchase
+apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Afwachting Activiteiten
+DocType: Patient Appointment,Reminded,herinnerd
+DocType: Patient,PID-,PID
+DocType: Chapter Member,Chapter Member,Hoofdstuklid
+DocType: Material Request Plan Item,Minimum Order Quantity,Minimum bestelhoeveelheid
+apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Uw organisatie
+DocType: Fee Component,Fees Category,vergoedingen Categorie
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Vul het verlichten datum .
+apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
+DocType: Supplier Scorecard,Notify Employee,Meld de medewerker in kennis
+DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Voer de naam van de campagne in als bron van onderzoek Campagne is
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Kranten Uitgeverijen
+apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Selecteer het fiscale jaar
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Verwachte leveringsdatum moet na verkoopdatum zijn
+apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Reorder Level,Bestelniveau
+DocType: Company,Chart Of Accounts Template,Rekeningschema Template
+DocType: Attendance,Attendance Date,Aanwezigheid Datum
+apps/erpnext/erpnext/stock/get_item_details.py +352,Item Price updated for {0} in Price List {1},Item Prijs bijgewerkt voor {0} in prijslijst {1}
+DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Salaris verbreken op basis Verdienen en Aftrek.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Account with child nodes cannot be converted to ledger,Rekening met onderliggende nodes kunnen niet worden omgezet naar grootboek
+DocType: Purchase Invoice Item,Accepted Warehouse,Geaccepteerd Magazijn
+DocType: Bank Reconciliation Detail,Posting Date,Plaatsingsdatum
+DocType: Item,Valuation Method,Waardering Methode
+apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Halve dag
+DocType: Sales Invoice,Sales Team,Verkoop Team
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Duplicate entry,Dubbele invoer
+DocType: Program Enrollment Tool,Get Students,krijg Studenten
+DocType: Serial No,Under Warranty,Binnen Garantie
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516,[Error],[Fout]
+DocType: Sales Order,In Words will be visible once you save the Sales Order.,In Woorden zijn zichtbaar zodra u de Verkooporder opslaat.
+,Employee Birthday,Werknemer Verjaardag
+apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Selecteer de voltooiingsdatum voor de voltooide reparatie
+DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Student Batch Attendance Tool
+apps/erpnext/erpnext/controllers/status_updater.py +213,Limit Crossed,Limit Crossed
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Geplande Tot
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Venture Capital
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Een wetenschappelijke term met deze &#39;Academisch Jaar&#39; {0} en &#39;Term Name&#39; {1} bestaat al. Wijzig deze ingangen en probeer het opnieuw.
+DocType: UOM,Must be Whole Number,Moet heel getal zijn
+DocType: Leave Control Panel,New Leaves Allocated (In Days),Nieuwe Verloven Toegewezen (in dagen)
+DocType: Purchase Invoice,Invoice Copy,Factuurkopie
+apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serienummer {0} bestaat niet
+DocType: Sales Invoice Item,Customer Warehouse (Optional),Customer Warehouse (optioneel)
+DocType: Pricing Rule,Discount Percentage,Kortingspercentage
+apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Gereserveerd voor onderaanneming
+DocType: Payment Reconciliation Invoice,Invoice Number,Factuurnummer
+DocType: Shopping Cart Settings,Orders,Bestellingen
+DocType: Employee Leave Approver,Leave Approver,Verlof goedkeurder
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +314,Please select a batch,Selecteer een batch alsjeblieft
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalLib,JournalLib
+DocType: Assessment Group,Assessment Group Name,Assessment Group Name
+DocType: Manufacturing Settings,Material Transferred for Manufacture,Overgedragen materiaal voor vervaardiging
+DocType: Landed Cost Item,Receipt Document Type,Ontvangst Document Type
+DocType: Daily Work Summary Settings,Select Companies,Selecteer Bedrijven
+DocType: Antibiotic,Healthcare,Gezondheidszorg
+DocType: Target Detail,Target Detail,Doel Detail
+apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Enkele variant
+apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,alle vacatures
+DocType: Sales Order,% of materials billed against this Sales Order,% van de materialen in rekening gebracht voor deze Verkooporder
+DocType: Program Enrollment,Mode of Transportation,Wijze van vervoer
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Periode sluitpost
+apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72,Select Department...,Selecteer afdeling ...
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Kostenplaats met bestaande transacties kan niet worden omgezet in groep
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} {2} {3},Bedrag {0} {1} {2} {3}
+DocType: Account,Depreciation,Afschrijvingskosten
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102,The number of shares and the share numbers are inconsistent,Het aantal aandelen en de aandelenaantallen zijn inconsistent
+apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Leverancier(s)
+DocType: Employee Attendance Tool,Employee Attendance Tool,Employee Attendance Tool
+DocType: Guardian Student,Guardian Student,Guardian Student
+DocType: Supplier,Credit Limit,Kredietlimiet
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +75,Avg. Selling Price List Rate,Gem. Prijslijst tarief verkopen
+DocType: Salary Component,Salary Component,salaris Component
+apps/erpnext/erpnext/accounts/utils.py +490,Payment Entries {0} are un-linked,Betaling Entries {0} zijn un-linked
+DocType: GL Entry,Voucher No,Voucher nr.
+,Lead Owner Efficiency,Leideneigenaar Efficiency
+,Lead Owner Efficiency,Leideneigenaar Efficiency
+DocType: Leave Allocation,Leave Allocation,Verlof Toewijzing
+DocType: Payment Request,Recipient Message And Payment Details,Ontvanger Bericht en betalingsgegevens
+DocType: Training Event,Trainer Email,trainer Email
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Materiaal Aanvragen {0} aangemaakt
+DocType: Restaurant Reservation,No of People,Nee van mensen
+apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Sjabloon voor contractvoorwaarden
+DocType: Purchase Invoice,Address and Contact,Adres en contactgegevens
+DocType: Cheque Print Template,Is Account Payable,Is Account Payable
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Stock kan niet worden bijgewerkt tegen Kwitantie {0}
+DocType: Support Settings,Auto close Issue after 7 days,Auto dicht Issue na 7 dagen
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Verlof kan niet eerder worden toegewezen {0}, als verlof balans al-carry doorgestuurd in de toekomst toewijzing verlof record is {1}"
+apps/erpnext/erpnext/accounts/party.py +317,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Opmerking: Vanwege / Reference Data overschrijdt toegestaan klantenkrediet dagen door {0} dag (en)
+apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,student Aanvrager
+DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINEEL VOOR RECEPIENT
+DocType: Asset Category Account,Accumulated Depreciation Account,Cumulatieve afschrijvingen Rekening
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Deze email is autogenerated
+DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Entries
+DocType: Program Enrollment,Boarding Student,Boarding Student
+DocType: Asset,Expected Value After Useful Life,Verwachte waarde Na Nuttig Life
+DocType: Item,Reorder level based on Warehouse,Bestelniveau gebaseerd op Warehouse
+DocType: Activity Cost,Billing Rate,Billing Rate
+,Qty to Deliver,Aantal te leveren
+,Stock Analytics,Voorraad Analyses
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523,Operations cannot be left blank,Operations kan niet leeg zijn
+DocType: Maintenance Visit Purpose,Against Document Detail No,Tegen Document Detail nr
+apps/erpnext/erpnext/regional/__init__.py +11,Deletion is not permitted for country {0},Verwijderen is niet toegestaan voor land {0}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110,Party Type is mandatory,Party Type is verplicht
+DocType: Quality Inspection,Outgoing,Uitgaande
+DocType: Material Request,Requested For,Aangevraagd voor
+DocType: Quotation Item,Against Doctype,Tegen Doctype
+apps/erpnext/erpnext/controllers/buying_controller.py +420,{0} {1} is cancelled or closed,{0} {1} is geannuleerd of gesloten
+DocType: Asset,Calculate Depreciation,Bereken afschrijving
+DocType: Delivery Note,Track this Delivery Note against any Project,Track this Delivery Note against any Project
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35,Net Cash from Investing,De netto kasstroom uit investeringsactiviteiten
+DocType: Work Order,Work-in-Progress Warehouse,Onderhanden Werk Magazijn
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} moet worden ingediend
+DocType: Fee Schedule Program,Total Students,Totaal studenten
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Attendance Record {0} bestaat tegen Student {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Referentie #{0} gedateerd {1}
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Afschrijvingen Uitgeschakeld als gevolg van verkoop van activa
+DocType: Member,Member,Lid
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Beheer Adressen
+DocType: Work Order Item,Work Order Item,Werkorderitem
+DocType: Pricing Rule,Item Code,Artikelcode
+DocType: Serial No,Warranty / AMC Details,Garantie / AMC Details
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Selecteer studenten handmatig voor de activiteit gebaseerde groep
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Selecteer studenten handmatig voor de activiteit gebaseerde groep
+DocType: Journal Entry,User Remark,Gebruiker Opmerking
+DocType: Lead,Market Segment,Marktsegment
+DocType: Agriculture Analysis Criteria,Agriculture Manager,Landbouwmanager
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966,Paid Amount cannot be greater than total negative outstanding amount {0},Betaalde bedrag kan niet groter zijn dan de totale negatieve openstaande bedrag {0}
+DocType: Supplier Scorecard Period,Variables,Variabelen
+DocType: Employee Internal Work History,Employee Internal Work History,Werknemer Interne Werk Geschiedenis
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249,Closing (Dr),Sluiten (Db)
+DocType: Cheque Print Template,Cheque Size,Cheque Size
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +238,Serial No {0} not in stock,Serienummer {0} niet op voorraad
+apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Belasting sjabloon voor verkooptransacties.
+DocType: Sales Invoice,Write Off Outstanding Amount,Afschrijving uitstaande bedrag
+apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Rekening {0} komt niet overeen met Bedrijf {1}
+DocType: Education Settings,Current Academic Year,Huidig Academisch Jaar
+DocType: Stock Settings,Default Stock UOM,Standaard Voorraad Eenheid
+DocType: Asset,Number of Depreciations Booked,Aantal Afschrijvingen Geboekt
+apps/erpnext/erpnext/public/js/pos/pos.html +71,Qty Total,Aantal Totaal
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Tegen Werknemer lening: {0}
+DocType: Landed Cost Item,Receipt Document,ontvangst Document
+DocType: Employee Education,School/University,School / Universiteit
+DocType: Payment Request,Reference Details,Reference Details
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Expected Value After Useful Life must be less than Gross Purchase Amount,Verwachte waarde na Praktische Het leven moet minder dan Gross Aankoopbedrag zijn
+DocType: Sales Invoice Item,Available Qty at Warehouse,Qty bij Warehouse
+apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Gefactureerd Bedrag
+DocType: Share Transfer,(including),(inclusief)
+DocType: Asset,Double Declining Balance,Double degressief
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Gesloten bestelling kan niet worden geannuleerd. Openmaken om te annuleren.
+DocType: Student Guardian,Father,Vader
+apps/erpnext/erpnext/controllers/accounts_controller.py +627,'Update Stock' cannot be checked for fixed asset sale,&#39;Bijwerken Stock&#39; kan niet worden gecontroleerd op vaste activa te koop
+DocType: Bank Reconciliation,Bank Reconciliation,Bank Aflettering
+DocType: Attendance,On Leave,Met verlof
+apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Blijf op de hoogte
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Account {2} behoort niet tot Company {3}
+apps/erpnext/erpnext/stock/doctype/item/item.js +397,Select at least one value from each of the attributes.,Selecteer ten minste één waarde uit elk van de kenmerken.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166,Material Request {0} is cancelled or stopped,Materiaal Aanvraag {0} is geannuleerd of gestopt
+apps/erpnext/erpnext/config/hr.py +314,Leave Management,Laat management
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +120,Group by Account,Groeperen volgens Rekening
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21,Please select Employee,Selecteer werknemer
+DocType: Sales Order,Fully Delivered,Volledig geleverd
+DocType: Lead,Lower Income,Lager inkomen
+DocType: Restaurant Order Entry,Current Order,Huidige bestelling
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196,Source and target warehouse cannot be same for row {0},Bron- en doelmagazijn kan niet hetzelfde zijn voor de rij {0}
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Verschil moet Account een type Asset / Liability rekening zijn, aangezien dit Stock Verzoening is een opening Entry"
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Uitbetaalde bedrag kan niet groter zijn dan Leningen zijn {0}
+apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Programs,Ga naar Programma&#39;s
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Rij {0} # Toegewezen hoeveelheid {1} kan niet groter zijn dan het niet-opgeëiste bedrag {2}
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Inkoopordernummer nodig voor Artikel {0}
+apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date','Van Datum' moet na 'Tot Datum' zijn
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Kan niet status als student te veranderen {0} is gekoppeld aan student toepassing {1}
+DocType: Asset,Fully Depreciated,volledig is afgeschreven
+DocType: Item Barcode,UPC-A,UPC-A
+,Stock Projected Qty,Verwachte voorraad hoeveelheid
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444,Customer {0} does not belong to project {1},Klant {0} behoort niet tot project {1}
+DocType: Employee Attendance Tool,Marked Attendance HTML,Marked Attendance HTML
+apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Offertes zijn voorstellen, biedingen u uw klanten hebben gestuurd"
+DocType: Sales Invoice,Customer's Purchase Order,Klant Bestelling
+DocType: Consultation,Patient,Geduldig
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Bypass credit check op klantorder
+DocType: Land Unit,Check if it is a hydroponic unit,Controleer of het een hydrocultuur is
+apps/erpnext/erpnext/config/stock.py +113,Serial No and Batch,Serienummer en Batch
+DocType: Warranty Claim,From Company,Van Bedrijf
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Som van de scores van de beoordelingscriteria moet {0} te zijn.
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Stel Aantal geboekte afschrijvingen
+DocType: Supplier Scorecard Period,Calculations,berekeningen
+apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86,Value or Qty,Waarde of Aantal
+DocType: Payment Terms Template,Payment Terms,Betaalvoorwaarden
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449,Productions Orders cannot be raised for:,Productions Bestellingen kunnen niet worden verhoogd voor:
+apps/erpnext/erpnext/utilities/user_progress.py +147,Minute,minuut
+DocType: Purchase Invoice,Purchase Taxes and Charges,Inkoop Belastingen en Toeslagen
+DocType: Chapter,Meetup Embed HTML,Meetup HTML insluiten
+apps/erpnext/erpnext/utilities/user_progress.py +121,Go to Suppliers,Ga naar leveranciers
+,Qty to Receive,Aantal te ontvangen
+DocType: Leave Block List,Leave Block List Allowed,Laat toegestaan Block List
+DocType: Grading Scale Interval,Grading Scale Interval,Grading Scale Interval
+apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Declaratie voor voertuig Inloggen {0}
+DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Korting (%) op prijslijst tarief met marges
+DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Korting (%) op prijslijst tarief met marges
+apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Alle magazijnen
+DocType: Sales Partner,Retailer,Retailer
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Credit Om rekening moet een balansrekening zijn
+apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118,All Supplier Types,Alle Leverancier Types
+DocType: Donor,Donor,schenker
+DocType: Global Defaults,Disable In Words,Uitschakelen In Woorden
+apps/erpnext/erpnext/stock/doctype/item/item.py +60,Item Code is mandatory because Item is not automatically numbered,Artikelcode is verplicht omdat Artikel niet automatisch is genummerd
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Offerte {0} niet van het type {1}
+DocType: Maintenance Schedule Item,Maintenance Schedule Item,Onderhoudsschema Item
+DocType: Sales Order,%  Delivered,% Geleverd
+apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Stel het e-mail-ID voor de student in om het betalingsverzoek te verzenden
+DocType: Patient,Medical History,Medische Geschiedenis
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Bank Kredietrekening
+DocType: Patient,Patient ID,Patient ID
+DocType: Physician Schedule,Schedule Name,Schema Naam
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +49,Make Salary Slip,Maak Salarisstrook
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840,Add All Suppliers,Voeg alle leveranciers toe
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rij # {0}: Toegewezen bedrag mag niet groter zijn dan het uitstaande bedrag.
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Bladeren BOM
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Leningen met onderpand
+DocType: Purchase Invoice,Edit Posting Date and Time,Wijzig Posting Datum en tijd
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Stel afschrijvingen gerelateerd Accounts in Vermogensbeheer categorie {0} of Company {1}
+DocType: Lab Test Groups,Normal Range,Normaal bereik
+DocType: Academic Term,Academic Year,Academisch jaar
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Available Selling,Beschikbare verkoop
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Opening Balance Equity
+DocType: Lead,CRM,CRM
+DocType: Purchase Invoice,N,N
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,resterende
+DocType: Appraisal,Appraisal,Beoordeling
+DocType: Purchase Invoice,GST Details,GST Details
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},E-mail verzonden naar leverancier {0}
+DocType: Item,Default Sales Unit of Measure,Standaard Verkoopeenheid van Maatregel
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Academic Year: ,Academiejaar:
+apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +19,Not allow to set alternative item for the item {0},Niet toestaan om alternatief item in te stellen voor het item {0}
+DocType: Opportunity,OPTY-,OPTY-
+apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Datum wordt herhaald
+apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Geautoriseerd ondertekenaar
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64,Create Fees,Fees maken
+DocType: Project,Total Purchase Cost (via Purchase Invoice),Totale aanschafkosten (via Purchase Invoice)
+DocType: Training Event,Start Time,Starttijd
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400,Select Quantity,Kies aantal
+DocType: Customs Tariff Number,Customs Tariff Number,Douanetariefnummer
+DocType: Patient Appointment,Patient Appointment,Patient Benoeming
+apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Goedkeuring Rol kan niet hetzelfde zijn als de rol van de regel is van toepassing op
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Afmelden bij dit e-mailoverzicht
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830,Get Suppliers By,Ontvang leveranciers door
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173,{0} not found for Item {1},{0} niet gevonden voor item {1}
+apps/erpnext/erpnext/utilities/user_progress.py +197,Go to Courses,Ga naar cursussen
+DocType: Accounts Settings,Show Inclusive Tax In Print,Toon Inclusive Tax In Print
+apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory","Bankrekening, van datum en tot datum zijn verplicht"
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,bericht verzonden
+apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Account with child nodes cannot be set as ledger,Rekening met de onderliggende knooppunten kan niet worden ingesteld als grootboek
+DocType: C-Form,II,II
+DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Koers waarmee Prijslijst valuta wordt omgerekend naar de basisvaluta van de klant
+DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobedrag (Company valuta)
+DocType: Physician,Physician Schedules,Arts Schedules
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215,Total advance amount cannot be greater than total sanctioned amount,Het totale voorschotbedrag kan niet hoger zijn dan het totale gesanctioneerde bedrag
+DocType: Salary Slip,Hour Rate,Uurtarief
+DocType: Stock Settings,Item Naming By,Artikel benoeming door
+apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Een ander Periode sluitpost {0} is gemaakt na {1}
+DocType: Work Order,Material Transferred for Manufacturing,Materiaal Overgedragen voor Manufacturing
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41,Account {0} does not exists,Rekening {0} bestaat niet
+DocType: Project,Project Type,Project Type
+apps/erpnext/erpnext/projects/doctype/task/task.py +153,Child Task exists for this Task. You can not delete this Task.,Child Task bestaat voor deze taak. U kunt deze taak niet verwijderen.
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,DateLet,DateLet
+apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Ofwel doelwit aantal of streefbedrag is verplicht.
+apps/erpnext/erpnext/config/projects.py +56,Cost of various activities,Kosten van verschillende activiteiten
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Instellen Events naar {0}, omdat de werknemer die aan de onderstaande Sales Personen die niet beschikt over een gebruikers-ID {1}"
+DocType: Timesheet,Billing Details,Billing Details
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,Source and target warehouse must be different,Bron en doel magazijn moet verschillen
+apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140,Payment Failed. Please check your GoCardless Account for more details,Betaling mislukt. Controleer uw GoCardless-account voor meer informatie
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Niet toegestaan om voorraadtransacties ouder dan  {0} bij te werken
+DocType: BOM,Inspection Required,Inspectie Verplicht
+DocType: Purchase Invoice Item,PR Detail,PR Detail
+DocType: Driving License Category,Class,Klasse
+DocType: Sales Order,Fully Billed,Volledig gefactureerd
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426,Work Order cannot be raised against a Item Template,Werkopdracht kan niet worden verhoogd met een itemsjabloon
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Verzendregel alleen van toepassing voor kopen
+DocType: Vital Signs,BMI,BMI
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Contanten in de hand
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Levering magazijn vereist voor voorraad artikel {0}
+DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Het bruto gewicht van het pakket. Meestal nettogewicht + verpakkingsmateriaal gewicht. (Voor afdrukken)
+DocType: Assessment Plan,Program,Programma
+DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts
+DocType: Serial No,Is Cancelled,Is Geannuleerd
+DocType: Student Group,Group Based On,Groep Gebaseerd op
+DocType: Student Group,Group Based On,Groep Gebaseerd op
+DocType: Journal Entry,Bill Date,Factuurdatum
+DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratorium SMS Alerts
+apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Service Punt, Type, de frequentie en de kosten bedragen nodig zijn"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Als er meerdere Prijsbepalings Regels zijn met de hoogste prioriteit, dan wordt de volgende interene prioriteit gehanteerd:"
+DocType: Plant Analysis Criteria,Plant Analysis Criteria,Criteria voor plantanalyse
+DocType: Cheque Print Template,Cheque Height,Cheque Hoogte
+DocType: Supplier,Supplier Details,Leverancier Details
+DocType: Setup Progress,Setup Progress,Setup Progress
+DocType: Hub Settings,Publish Items to Hub,Publiceer Artikelen toevoegen aan Hub
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Van waarde moet minder zijn dan waarde in rij {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,overboeking
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Alles aanvinken
+,Issued Items Against Work Order,Uitgegeven items tegen werkorder
+DocType: Vehicle Log,Invoice Ref,factuur Ref
+DocType: Company,Default Income Account,Standaard Inkomstenrekening
+apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Klantengroep / Klant
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Unclosed Boekjaren winst / verlies (Credit)
+DocType: Sales Invoice,Time Sheets,Time Sheets
+DocType: Lab Test Template,Change In Item,Wijzigen In Item
+DocType: Payment Gateway Account,Default Payment Request Message,Standaard bericht Payment Request
+DocType: Item Group,Check this if you want to show in website,Aanvinken om weer te geven op de website
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338,Balance ({0}),Saldo ({0})
+apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bank en betalingen
+,Welcome to ERPNext,Welkom bij ERPNext
+apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Leiden tot Offerte
+apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,E-mailherinneringen worden verzonden naar alle partijen met e-mailcontacten
+DocType: Project,Twice Daily,Tweemaal daags
+DocType: Patient,A Negative,Een negatief
+apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Niets meer te zien.
+DocType: Lead,From Customer,Van Klant
+apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Oproepen
+apps/erpnext/erpnext/utilities/user_progress.py +143,A Product,Een product
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +233,Batches,batches
+apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Maak een kostenplan
+DocType: Purchase Order Item Supplied,Stock UOM,Voorraad Eenheid
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Inkooporder {0} is niet ingediend
+DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normaal referentiebereik voor een volwassene is 16-20 ademhalingen / minuut (RCP 2012)
+DocType: Customs Tariff Number,Tariff Number,tarief Aantal
+DocType: Work Order Item,Available Qty at WIP Warehouse,Beschikbaar Aantal bij WIP Warehouse
+apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,verwachte
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +228,Serial No {0} does not belong to Warehouse {1},Serienummer {0} behoort niet tot Magazijn {1}
+apps/erpnext/erpnext/controllers/status_updater.py +177,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Opmerking : Het systeem controleert niet over- levering en overboeking voor post {0} als hoeveelheid of bedrag 0
+DocType: Notification Control,Quotation Message,Offerte Bericht
+DocType: Employee Loan,Employee Loan Application,Werknemer lening aanvraag
+DocType: Issue,Opening Date,Openingsdatum
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86,Please save the patient first,Sla de patiënt alstublieft eerst op
+apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Aanwezigheid is met succes gemarkeerd.
+DocType: Program Enrollment,Public Transport,Openbaar vervoer
+DocType: Soil Texture,Silt Composition (%),Silt-samenstelling (%)
+DocType: Journal Entry,Remark,Opmerking
+DocType: Healthcare Settings,Avoid Confirmation,Vermijd bevestiging
+DocType: Purchase Receipt Item,Rate and Amount,Tarief en Bedrag
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176,Account Type for {0} must be {1},Rekening Type voor {0} moet {1}
+DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Standaardinkomensrekeningen die gebruikt moeten worden indien niet in de arts ingesteld om te reserveren.
+apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Bladeren en vakantie
+DocType: Education Settings,Current Academic Term,Huidige academische term
+DocType: Education Settings,Current Academic Term,Huidige academische term
+DocType: Sales Order,Not Billed,Niet in rekening gebracht
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76,Both Warehouse must belong to same Company,Beide magazijnen moeten tot hetzelfde bedrijf behoren
+apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Nog geen contacten toegevoegd.
+DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Vrachtkosten Voucher Bedrag
+,Item Balance (Simple),Artikel saldo (eenvoudig)
+apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Facturen van leveranciers.
+DocType: POS Profile,Write Off Account,Afschrijvingsrekening
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +229,Debit Note Amt,Debietnota Amt
+apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Korting Bedrag
+DocType: Purchase Invoice,Return Against Purchase Invoice,Terug Tegen Purchase Invoice
+DocType: Item,Warranty Period (in days),Garantieperiode (in dagen)
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Instellen van standaardwaarden mislukt
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Relatie met Guardian1
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +787,Please select BOM against item {0},Selecteer een stuklijst met item {0}
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Facturen maken
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Cash from Operations,De netto kasstroom uit operationele activiteiten
+apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Punt 4
+DocType: Student Admission,Admission End Date,Toelating Einddatum
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Uitbesteding
+DocType: Journal Entry Account,Journal Entry Account,Dagboek rekening
+apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,student Group
+DocType: Shopping Cart Settings,Quotation Series,Offerte Series
+apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57,"An item exists with same name ({0}), please change the item group name or rename the item","Een item bestaat met dezelfde naam ( {0} ) , wijzigt u de naam van het item groep of hernoem het item"
+DocType: Soil Analysis Criteria,Soil Analysis Criteria,Bodemanalysecriteria
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2037,Please select customer,Maak een keuze van de klant
+DocType: C-Form,I,ik
+DocType: Company,Asset Depreciation Cost Center,Asset Afschrijvingen kostenplaats
+DocType: Production Plan Sales Order,Sales Order Date,Verkooporder Datum
+DocType: Sales Invoice Item,Delivered Qty,Geleverd Aantal
+DocType: Assessment Plan,Assessment Plan,assessment Plan
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Klant {0} is gemaakt.
+DocType: Stock Settings,Limit Percent,Limit Procent
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Momenteel geen voorraad beschikbaar in een magazijn
+,Payment Period Based On Invoice Date,Betaling Periode gebaseerd op factuurdatum
+DocType: Sample Collection,No. of print,Aantal afdrukken
+DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Hotelkamerreserveringsitem
+apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Ontbrekende Wisselkoersen voor {0}
+DocType: Health Insurance,Health Insurance Name,Ziekteverzekeringsnaam
+DocType: Assessment Plan,Examiner,Examinator
+DocType: Student,Siblings,broers en zussen
+DocType: Journal Entry,Stock Entry,Voorraadtransactie
+DocType: Payment Entry,Payment References,betaling Referenties
+DocType: C-Form,C-FORM-,C-vorm-
+DocType: Vehicle,Insurance Details,verzekering Details
+DocType: Account,Payable,betaalbaar
+DocType: Share Balance,Share Type,Type delen
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Vul de aflossingsperiode
+apps/erpnext/erpnext/shopping_cart/cart.py +378,Debtors ({0}),Debiteuren ({0})
+DocType: Pricing Rule,Margin,Marge
+apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Nieuwe klanten
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Brutowinst%
+DocType: Appraisal Goal,Weightage (%),Weging (%)
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +512,Change POS Profile,POS-profiel wijzigen
+DocType: Bank Reconciliation Detail,Clearance Date,Clearance Datum
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Beoordelingsverslag
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Gross Aankoopbedrag is verplicht
+apps/erpnext/erpnext/setup/doctype/company/company.js +95,Company name not same,Bedrijfsnaam niet hetzelfde
+DocType: Lead,Address Desc,Adres Omschr
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113,Party is mandatory,Party is verplicht
+DocType: Journal Entry,JV-,JV-
+apps/erpnext/erpnext/controllers/accounts_controller.py +712,Rows with duplicate due dates in other rows were found: {list},Rijen met dubbele vervaldatums in andere rijen zijn gevonden: {lijst}
+DocType: Topic,Topic Name,topic Naam
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,Atleast one of the Selling or Buying must be selected,Tenminste een van de verkopen of aankopen moeten worden gekozen
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290,Select an employee to get the employee advance.,Selecteer een medewerker om de werknemer voor te bereiden.
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Selecteer een geldige datum alstublieft
+apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Selecteer de aard van uw bedrijf.
+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.","Single voor resultaten die alleen een enkele invoer vereisen, resultaat UOM en normale waarde <br> Verbonden voor resultaten die meerdere invoervelden vereisen met overeenkomstige gebeurtenisnamen, resulteren UOM's en normale waarden <br> Beschrijvend voor tests die meerdere resultaatcomponenten en bijbehorende resultaatinvoervelden bevatten. <br> Gegroepeerd voor test templates die een groep andere test templates zijn. <br> Geen resultaat voor tests zonder resultaten. Ook is er geen Lab Test gemaakt. bv. Subtests voor Gegroepeerde resultaten."
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86,Row #{0}: Duplicate entry in References {1} {2},Rij # {0}: Duplicate entry in Referenties {1} {2}
+apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Waar de productie-activiteiten worden uitgevoerd.
+apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Als examinator
+DocType: Appointment Type,Default Duration,Standaard duur
+DocType: Asset Movement,Source Warehouse,Bron Magazijn
+DocType: Installation Note,Installation Date,Installatie Datum
+apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Deel Ledger
+apps/erpnext/erpnext/controllers/accounts_controller.py +606,Row #{0}: Asset {1} does not belong to company {2},Rij # {0}: Asset {1} hoort niet bij bedrijf {2}
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Verkoopfactuur {0} gemaakt
+DocType: Employee,Confirmation Date,Bevestigingsdatum
+DocType: C-Form,Total Invoiced Amount,Totaal Gefactureerd bedrag
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50,Min Qty can not be greater than Max Qty,Min Aantal kan niet groter zijn dan Max Aantal zijn
+DocType: Soil Texture,Silty Clay,Leemklei
+DocType: Account,Accumulated Depreciation,Cumulatieve afschrijvingen
+DocType: Supplier Scorecard Scoring Standing,Standing Name,Staande naam
+DocType: Stock Entry,Customer or Supplier Details,Klant of leverancier Details
+DocType: Employee Loan Application,Required by Date,Vereist door Date
+DocType: Lead,Lead Owner,Lead Eigenaar
+DocType: Production Plan,Sales Orders Detail,Detail verkooporders
+DocType: Bin,Requested Quantity,gevraagde hoeveelheid
+DocType: Patient,Marital Status,Burgerlijke staat
+DocType: Stock Settings,Auto Material Request,Automatisch Materiaal Request
+DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Beschikbaar Aantal Batch bij Van Warehouse
+DocType: Customer,CUST-,CUST-
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Idevise,Idevise
+DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Brutoloon - Total Aftrek - aflossing van de lening
+apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29,Current BOM and New BOM can not be same,Huidige Stuklijst en Nieuwe Stuklijst kunnen niet hetzelfde zijn
+apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47,Salary Slip ID,Loonstrook ID
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Pensioneringsdatum moet groter zijn dan datum van indiensttreding
+apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Meerdere varianten
+DocType: Sales Invoice,Against Income Account,Tegen Inkomstenrekening
+apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Geleverd
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Item {0}: Bestelde aantal {1} kan niet kleiner dan de minimale afname {2} (gedefinieerd in punt) zijn.
+DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Maandelijkse Verdeling Percentage
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49,Please login as another user.,Meld u aan als een andere gebruiker.
+DocType: Daily Work Summary Group User,Daily Work Summary Group User,Daily Work Summary Group User
+DocType: Territory,Territory Targets,Regio Doelen
+DocType: Soil Analysis,Ca/Mg,Ca / Mg
+DocType: Delivery Note,Transporter Info,Vervoerder Info
+apps/erpnext/erpnext/accounts/utils.py +497,Please set default {0} in Company {1},Stel default {0} in Company {1}
+DocType: Cheque Print Template,Starting position from top edge,Uitgangspositie van bovenrand
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33,Same supplier has been entered multiple times,Dezelfde leverancier is meerdere keren ingevoerd
+apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Bruto winst / verlies
+,Warehouse wise Item Balance Age and Value,Magazijnbeheer Artikelbalans Leeftijd en waarde
+DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Inkooporder Artikel geleverd
+apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Bedrijfsnaam kan niet bedrijf zijn
+apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Briefhoofden voor print sjablonen.
+apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Titels voor print sjablonen bijv. Proforma Factuur.
+DocType: Program Enrollment,Walking,wandelen
+DocType: Student Guardian,Student Guardian,student Guardian
+DocType: Member,Member Name,Lid Naam
+DocType: Stock Settings,Use Naming Series,Gebruik Naming Series
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Soort waardering kosten kunnen niet zo Inclusive gemarkeerd
+DocType: POS Profile,Update Stock,Voorraad bijwerken
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,in het abonnement
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Verschillende eenheden voor artikelen zal leiden tot een onjuiste (Totaal) Netto gewicht. Zorg ervoor dat Netto gewicht van elk artikel in dezelfde eenheid is.
+DocType: Membership,Payment Details,Betalingsdetails
+apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,Stuklijst tarief
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stopped Work Order kan niet geannuleerd worden, laat het eerst annuleren om te annuleren"
+DocType: Asset,Journal Entry for Scrap,Dagboek voor Productieverlies
+apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Haal aub artikelen uit de Vrachtbrief
+apps/erpnext/erpnext/accounts/utils.py +467,Journal Entries {0} are un-linked,Journaalposten {0} zijn un-linked
+apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Record van alle communicatie van het type e-mail, telefoon, chat, bezoek, etc."
+DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Leverancier Scorecard Scoring Standing
+DocType: Manufacturer,Manufacturers used in Items,Fabrikanten gebruikt in Items
+apps/erpnext/erpnext/accounts/general_ledger.py +170,Please mention Round Off Cost Center in Company,Vermeld Ronde Off kostenplaats in Company
+DocType: Purchase Invoice,Terms,Voorwaarden
+apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10,Select Days,Selecteer dagen
+DocType: Academic Term,Term Name,term Naam
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332,Credit ({0}),Krediet ({0})
+DocType: Buying Settings,Purchase Order Required,Inkooporder verplicht
+apps/erpnext/erpnext/public/js/projects/timer.js +5,Timer,timer
+,Item-wise Sales History,Artikelgebaseerde Verkoop Geschiedenis
+DocType: Expense Claim,Total Sanctioned Amount,Totaal Goedgekeurd Bedrag
+DocType: Land Unit,Land Unit,Landeenheid
+,Purchase Analytics,Inkoop Analyse
+DocType: Sales Invoice Item,Delivery Note Item,Vrachtbrief Artikel
+DocType: Asset Maintenance Log,Task,Taak
+DocType: Purchase Taxes and Charges,Reference Row #,Referentie Rij #
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Partij nummer is verplicht voor artikel {0}
+apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Dit is een basis verkoper en kan niet worden bewerkt .
+DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Als geselecteerd, draagt de waarde die is opgegeven of berekend in dit onderdeel niet bij tot de winst of aftrek. De waarde ervan kan echter worden verwezen door andere componenten die kunnen worden toegevoegd of afgetrokken."
+DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Als geselecteerd, draagt de waarde die is opgegeven of berekend in dit onderdeel niet bij tot de winst of aftrek. De waarde ervan kan echter worden verwezen door andere componenten die kunnen worden toegevoegd of afgetrokken."
+DocType: Asset Settings,Number of Days in Fiscal Year,Aantal dagen in fiscaal jaar
+,Stock Ledger,Voorraad Dagboek
+apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Prijs: {0}
+DocType: Company,Exchange Gain / Loss Account,Exchange winst / verliesrekening
+apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Werknemer en Aanwezigheid
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93,Purpose must be one of {0},Doel moet één zijn van {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Fill the form and save it,Vul het formulier in en sla het op
+apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Community Forum
+apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Werkelijke hoeveelheid op voorraad
+apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Werkelijke hoeveelheid op voorraad
+DocType: Homepage,"URL for ""All Products""",URL voor &quot;Alle producten&quot;
+DocType: Leave Application,Leave Balance Before Application,Verlofsaldo voor aanvraag
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,SMS versturen
+DocType: Supplier Scorecard Criteria,Max Score,Max score
+DocType: Cheque Print Template,Width of amount in word,Breedte van de hoeveelheid in woord
+DocType: Company,Default Letter Head,Standaard Briefhoofd
+DocType: Purchase Order,Get Items from Open Material Requests,Krijg items van Open Materiaal Aanvragen
+DocType: Hotel Room Amenity,Billable,Factureerbaar
+DocType: Lab Test Template,Standard Selling Rate,Standard Selling Rate
+DocType: Account,Rate at which this tax is applied,Percentage waarmee deze belasting toegepast wordt
+DocType: Cash Flow Mapper,Section Name,sectie naam
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77,Reorder Qty,Bestelaantal
+apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Huidige vacatures
+DocType: Company,Stock Adjustment Account,Voorraad Aanpassing Rekening
+apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Afschrijven
+DocType: Patient Service Unit,Allow Overlap,Overlap toestaan
+DocType: Timesheet Detail,Operation ID,Operation ID
+DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Systeemgebruiker (login) ID. Indien ingesteld, zal het de standaard worden voor alle HR-formulieren."
+apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Van {1}
+DocType: Task,depends_on,hangt af van
+apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,In afwachting van het bijwerken van de laatste prijs in alle Materialen. Het kan enkele minuten duren.
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,De naam van de nieuwe account. Let op: Gelieve niet goed voor klanten en leveranciers te creëren
+apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Landgebaseerde standaard adressjablonen
+DocType: Water Analysis,Appearance,Uiterlijk
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +75,Avg. Buying Price List Rate,Gem. Prijslijst kopen
+DocType: Sales Order Item,Supplier delivers to Customer,Leverancier levert aan de Klant
+apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Informatie over leden.
+apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Vorm / Item / {0}) is niet op voorraad
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Asset onderhoud
+,Sales Payment Summary,Samenvatting verkoopbetaling
+DocType: Restaurant,Restaurant,Restaurant
+apps/erpnext/erpnext/accounts/party.py +320,Due / Reference Date cannot be after {0},Verval- / Referentiedatum kan niet na {0} zijn
+apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Gegevens importeren en exporteren
+DocType: Patient,Account Details,Account Details
+DocType: Crop,Materials Required,Benodigde materialen
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Geen studenten gevonden
+DocType: Medical Department,Medical Department,Medische Afdeling
+DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Scorecard Scoringscriteria voor leveranciers
+apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Factuur Boekingsdatum
+apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Verkopen
+DocType: Purchase Invoice,Rounded Total,Afgerond Totaal
+DocType: Product Bundle,List items that form the package.,Lijst items die het pakket vormen.
+apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39,Not permitted. Please disable the Test Template,Niet toegestaan. Schakel de testsjabloon uit
+apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Percentage toewijzing moet gelijk zijn aan 100%
+DocType: Crop Cycle,Linked Land Unit,Linked Land Unit
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Selecteer Boekingsdatum voordat Party selecteren
+DocType: Program Enrollment,School House,School House
+DocType: Serial No,Out of AMC,Uit AMC
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Aantal afschrijvingen geboekt kan niet groter zijn dan het totale aantal van de afschrijvingen zijn
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Maak Maintenance Visit
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +215,Please contact to the user who have Sales Master Manager {0} role,Neem dan contact op met de gebruiker die hebben Sales Master Manager {0} rol
+DocType: Company,Default Cash Account,Standaard Kasrekening
+apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Bedrijf ( geen klant of leverancier ) meester.
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Dit is gebaseerd op de aanwezigheid van de Student
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Geen studenten in
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179,Add more items or open full form,Voeg meer items of geopend volledige vorm
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Vrachtbrief {0} moet worden geannuleerd voordat het annuleren van deze Verkooporder
+apps/erpnext/erpnext/utilities/user_progress.py +259,Go to Users,Ga naar gebruikers
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Betaald bedrag + Afgeschreven bedrag kan niet groter zijn dan Eindtotaal
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} is geen geldig batchnummer voor Artikel {1}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130,Note: There is not enough leave balance for Leave Type {0},Opmerking: Er is niet genoeg verlofsaldo voor Verlof type {0}
+apps/erpnext/erpnext/regional/india/utils.py +16,Invalid GSTIN or Enter NA for Unregistered,Ongeldige GSTIN of voer NA in voor niet-geregistreerde
+DocType: Training Event,Seminar,congres
+DocType: Program Enrollment Fee,Program Enrollment Fee,Programma inschrijvingsgeld
+DocType: Item,Supplier Items,Leverancier Artikelen
+DocType: Opportunity,Opportunity Type,Type opportuniteit
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Nieuw Bedrijf
+apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Transacties kunnen alleen worden verwijderd door de maker van de Vennootschap
+apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Onjuist aantal Grootboekposten gevonden. U zou een verkeerde rekening kunnen hebben geselecteerd in de transactie.
+DocType: Employee,Prefered Contact Email,Voorkeur Contact E-mail
+DocType: Cheque Print Template,Cheque Width,Cheque Breedte
+DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Valideren verkoopprijs voor post tegen Purchase Rate of Valuation Rate
+DocType: Fee Schedule,Fee Schedule,fee Schedule
+DocType: Hub Settings,Publish Availability,Publiceer Beschikbaarheid
+DocType: Company,Create Chart Of Accounts Based On,Maak rekeningschema op basis van
+apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Kan het niet omzetten naar een niet-groep. Kindertaken bestaan.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Geboortedatum mag niet groter zijn dan vandaag.
+,Stock Ageing,Voorraad Veroudering
+apps/erpnext/erpnext/education/doctype/student/student.py +40,Student {0} exist against student applicant {1},Student {0} bestaat tegen student aanvrager {1}
+DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Afronding aanpassing (bedrijfsmunt)
+apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Rooster
+apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243,Batch: ,Partij:
+DocType: Volunteer,Afternoon,Middag
+apps/erpnext/erpnext/controllers/accounts_controller.py +258,{0} '{1}' is disabled,{0} '{1}'is uitgeschakeld
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Instellen als Open
+DocType: Cheque Print Template,Scanned Cheque,gescande Cheque
+DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Stuur automatische e-mails naar Contactpersonen op Indienen transacties.
+DocType: Timesheet,Total Billable Amount,Totaal bedrag Factureerbare
+DocType: Customer,Credit Limit and Payment Terms,Kredietlimiet en betalingsvoorwaarden
+apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Punt 3
+apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Orderinvoer
+DocType: Purchase Order,Customer Contact Email,E-mail Contactpersoon Klant
+DocType: Warranty Claim,Item and Warranty Details,Item en garantie Details
+DocType: Chapter,Chapter Members,Hoofdstukleden
+DocType: Sales Team,Contribution (%),Bijdrage (%)
+apps/erpnext/erpnext/controllers/accounts_controller.py +102,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Opmerking: De betaling wordt niet aangemaakt, aangezien de 'Kas- of Bankrekening' niet gespecificeerd is."
+apps/erpnext/erpnext/projects/doctype/project/project.py +70,Project {0} already exists,Project {0} bestaat al
+DocType: Medical Department,Nursing User,Verpleegkundige gebruiker
+DocType: Plant Analysis,Plant Analysis Criterias,Plant Analysis Criteria
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Responsibilities,Verantwoordelijkheden
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Geldigheidsduur van deze offerte is beëindigd.
+DocType: Expense Claim Account,Expense Claim Account,Declaratie Account
+DocType: Accounts Settings,Allow Stale Exchange Rates,Staale wisselkoersen toestaan
+DocType: Sales Person,Sales Person Name,Verkoper Naam
+apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Vul tenminste 1 factuur in in de tabel
+apps/erpnext/erpnext/utilities/user_progress.py +247,Add Users,Gebruikers toevoegen
+DocType: POS Item Group,Item Group,Artikelgroep
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Student Group: ,Studentengroep:
+DocType: Item,Safety Stock,Veiligheidsvoorraad
+DocType: Healthcare Settings,Healthcare Settings,Gezondheidszorginstellingen
+apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,Voortgang% voor een taak kan niet meer dan 100 zijn.
+DocType: Stock Reconciliation Item,Before reconciliation,Voordat verzoening
+apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Naar {0}
+DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Belastingen en Toeslagen toegevoegd (Bedrijfsvaluta)
+apps/erpnext/erpnext/stock/doctype/item/item.py +476,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Item Tax Rij {0} moet rekening houden met het type belasting of inkomsten of uitgaven of Chargeable
+DocType: Sales Order,Partly Billed,Deels Gefactureerd
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} moet een post der vaste activa zijn
+apps/erpnext/erpnext/stock/doctype/item/item.js +372,Make Variants,Varianten maken
+DocType: Item,Default BOM,Standaard Stuklijst
+DocType: Project,Total Billed Amount (via Sales Invoices),Totaal gefactureerd bedrag (via verkoopfacturen)
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +127,Debit Note Amount,Debietnota Bedrag
+DocType: Project Update,Not Updated,Niet geüpdate
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106,"There are inconsistencies between the rate, no of shares and the amount calculated","Er zijn inconsistenties tussen de koers, aantal aandelen en het berekende bedrag"
+apps/erpnext/erpnext/setup/doctype/company/company.js +89,Please re-type company name to confirm,Gelieve re-type bedrijfsnaam te bevestigen
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +230,Total Outstanding Amt,Totale uitstaande Amt
+DocType: Journal Entry,Printing Settings,Instellingen afdrukken
+DocType: Employee Advance,Advance Account,Voorschot rekening
+DocType: Job Offer,Job Offer Terms,Biedingsvoorwaarden
+DocType: Sales Invoice,Include Payment (POS),Inclusief Betaling (POS)
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Totaal Debet moet gelijk zijn aan Totaal Credit. Het verschil is {0}
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Automotive
+DocType: Vehicle,Insurance Company,Verzekeringsbedrijf
+DocType: Asset Category Account,Fixed Asset Account,Fixed Asset Account
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,Variabele
+apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Van Vrachtbrief
+DocType: Chapter,Members,leden
+DocType: Student,Student Email Address,Student e-mailadres
+DocType: Item,Hub Warehouse,Hub Warehouse
+DocType: Assessment Plan,From Time,Van Tijd
+DocType: Hotel Settings,Hotel Settings,Hotelinstellingen
+apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Op voorraad:
+DocType: Notification Control,Custom Message,Aangepast bericht
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investment Banking
+DocType: Purchase Invoice,input,invoer
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Kas- of Bankrekening is verplicht om een  betaling aan te maken
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentenadres
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentenadres
+DocType: Purchase Invoice,Price List Exchange Rate,Prijslijst Wisselkoers
+apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Accountnummer {0} al gebruikt in account {1}
+DocType: GoCardless Mandate,Mandate,Mandaat
+DocType: POS Profile,POS Profile Name,POS-profielnaam
+DocType: Hotel Room Reservation,Booked,geboekt
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxLib,CompAuxLib
+DocType: Purchase Invoice Item,Rate,Tarief
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,intern
+DocType: Delivery Stop,Address Name,Adres naam
+DocType: Stock Entry,From BOM,Van BOM
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639,Splitting {0} units of {1},{0} eenheden van {1} splitsen
+DocType: Assessment Code,Assessment Code,assessment Code
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Basis
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Voorraadtransacties voor {0} zijn bevroren
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Klik op 'Genereer Planning'
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,Referentienummer is verplicht als u een referentiedatum hebt ingevoerd
+DocType: Bank Reconciliation Detail,Payment Document,betaling Document
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Fout bij het evalueren van de criteria formule
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Datum van indiensttreding moet groter zijn dan geboortedatum
+DocType: Salary Slip,Salary Structure,Salarisstructuur
+DocType: Account,Bank,Bank
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,vliegmaatschappij
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853,Issue Material,Materiaal uitgeven
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Er is een fout opgetreden tijdens het maken van terugkerende
+DocType: Material Request Item,For Warehouse,Voor Magazijn
+DocType: Employee,Offer Date,Aanbieding datum
+apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Citaten
+apps/erpnext/erpnext/accounts/page/pos/pos.js +735,You are in offline mode. You will not be able to reload until you have network.,Je bent in de offline modus. Je zult niet in staat om te herladen tot je opnieuw verbonden bent met het netwerk.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Geen groepen studenten gecreëerd.
+DocType: Purchase Invoice Item,Serial No,Serienummer
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Maandelijks te betalen bedrag kan niet groter zijn dan Leningen zijn
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Vul eerst Onderhoudsdetails in
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Rij # {0}: Verwachte Afleverdatum kan niet vóór de Aankoopdatum zijn
+DocType: Purchase Invoice,Print Language,Print Taal
+DocType: Salary Slip,Total Working Hours,Totaal aantal Werkuren
+DocType: Sales Invoice,Customer PO Details,Klant PO-details
+DocType: Subscription,Next Schedule Date,Volgende schema datum
+DocType: Stock Entry,Including items for sub assemblies,Inclusief items voor sub assemblies
+DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Tijdelijk account openen
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1964,Enter value must be positive,Voer waarde moet positief zijn
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446,All Territories,Alle gebieden
+apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49,Add Multiple Tasks,Meerdere taken toevoegen
+DocType: Purchase Invoice,Items,Artikelen
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,Student is reeds ingeschreven.
+DocType: Fiscal Year,Year Name,Jaar Naam
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241,There are more holidays than working days this month.,Er zijn meer vakanties dan werkdagen deze maand .
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +100,PDC/LC Ref,PDC / LC Ref
+DocType: Product Bundle Item,Product Bundle Item,Product Bundle Item
+DocType: Sales Partner,Sales Partner Name,Verkoop Partner Naam
+apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Verzoek om Offertes
+DocType: Payment Reconciliation,Maximum Invoice Amount,Maximumfactuur Bedrag
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Montantdevise,Montantdevise
+apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hematologie
+DocType: Normal Test Items,Normal Test Items,Normale Test Items
+DocType: Student Language,Student Language,student Taal
+apps/erpnext/erpnext/config/selling.py +23,Customers,Klanten
+DocType: Cash Flow Mapping,Is Working Capital,Is werkkapitaal
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Order / Quot%
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Order / Quot%
+apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Record Patient Vitals
+DocType: Fee Schedule,Institution,Instelling
+DocType: Asset,Partially Depreciated,gedeeltelijk afgeschreven
+DocType: Issue,Opening Time,Opening Tijd
+apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89,From and To dates required,Van en naar data vereist
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Securities & Commodity Exchanges
+apps/erpnext/erpnext/stock/doctype/item/item.py +689,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Standaard maateenheid voor Variant &#39;{0}&#39; moet hetzelfde zijn als in zijn Template &#39;{1}&#39;
+DocType: Shipping Rule,Calculate Based On,Berekenen gebaseerd op
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Stel nummeringsreeksen in voor Aanwezigheid via Setup&gt; Nummeringserie
+DocType: Delivery Note Item,From Warehouse,Van Warehouse
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Geen werknemers voor de genoemde criteria
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955,No Items with Bill of Materials to Manufacture,Geen Items met Bill of Materials voor fabricage
+DocType: Hotel Settings,Default Customer,Standaard klant
+DocType: Assessment Plan,Supervisor Name,supervisor Naam
+DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Bevestig niet of afspraak voor dezelfde dag is gemaakt
+DocType: Program Enrollment Course,Program Enrollment Course,Programma Inschrijvingscursus
+DocType: Program Enrollment Course,Program Enrollment Course,Programma Inschrijvingscursus
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +164,Make Sample Retention Stock Entry,Maak monster retentie aandeleninvoer
+DocType: Purchase Taxes and Charges,Valuation and Total,Waardering en Totaal
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,scorecards
+DocType: Tax Rule,Shipping City,Verzending Stad
+DocType: Notification Control,Customize the Notification,Aanpassen Kennisgeving
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Cash Flow from Operations,De cashflow uit bedrijfsoperaties
+DocType: Purchase Invoice,Shipping Rule,Verzendregel
+DocType: Patient Relation,Spouse,Echtgenoot
+DocType: Lab Test Groups,Add Test,Test toevoegen
+DocType: Manufacturer,Limited to 12 characters,Beperkt tot 12 tekens
+DocType: Journal Entry,Print Heading,Print Kop
+apps/erpnext/erpnext/config/stock.py +150,Delivery Trip service tours to customers.,Levering Tripdienstreizen naar klanten.
+apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Totaal kan niet nul zijn
+apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,'Dagen sinds laatste opdracht' moet groter of gelijk zijn aan nul
+DocType: Plant Analysis Criteria,Maximum Permissible Value,Maximaal toelaatbare waarde
+DocType: Journal Entry Account,Employee Advance,Medewerker Advance
+DocType: Payroll Entry,Payroll Frequency,payroll Frequency
+DocType: Lab Test Template,Sensitivity,Gevoeligheid
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941,Raw Material,grondstof
+DocType: Leave Application,Follow via Email,Volg via e-mail
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Installaties en Machines
+DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Belasting bedrag na korting
+DocType: Daily Work Summary Settings,Daily Work Summary Settings,Dagelijks Werk Samenvatting Instellingen
+apps/erpnext/erpnext/controllers/buying_controller.py +463,Please enter Reqd by Date,Voer Reqd in op datum
+DocType: Payment Entry,Internal Transfer,Interne overplaatsing
+DocType: Asset Maintenance,Maintenance Tasks,Onderhoudstaken
+apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Ofwel doelwit aantal of streefbedrag is verplicht
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Posting Date first,Selecteer Boekingsdatum eerste
+apps/erpnext/erpnext/public/js/account_tree_grid.js +209,Opening Date should be before Closing Date,Openingsdatum moeten vóór Sluitingsdatum
+DocType: Leave Control Panel,Carry Forward,Carry Forward
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Kostenplaats met bestaande transacties kan niet worden omgezet naar grootboek
+DocType: Department,Days for which Holidays are blocked for this department.,Dagen waarvoor feestdagen zijn geblokkeerd voor deze afdeling.
+DocType: GoCardless Mandate,ERPNext Integrations,ERPNext-integraties
+DocType: Crop Cycle,Detected Disease,Gedetecteerde ziekte
+,Produced,Geproduceerd
+DocType: Item,Item Code for Suppliers,Item Code voor leveranciers
+DocType: Issue,Raised By (Email),Opgevoerd door (E-mail)
+DocType: Training Event,Trainer Name,trainer Naam
+DocType: Mode of Payment,General,Algemeen
+apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Laatste Communicatie
+apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Laatste Communicatie
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Kan niet aftrekken als categorie is voor ' Valuation ' of ' Valuation en Total '
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +240,Serial Nos Required for Serialized Item {0},Volgnummers zijn vereist voor Seriegebonden Artikel {0}
+apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Match Betalingen met Facturen
+DocType: Journal Entry,Bank Entry,Bank Invoer
+DocType: Authorization Rule,Applicable To (Designation),Van toepassing zijn op (Benaming)
+,Profitability Analysis,winstgevendheid Analyse
+DocType: Fees,Student Email,Student Email
+DocType: Supplier,Prevent POs,Voorkom POs
+DocType: Patient,"Allergies, Medical and Surgical History","Allergieën, Medische en Chirurgische Geschiedenis"
+apps/erpnext/erpnext/templates/generators/item.html +77,Add to Cart,In winkelwagen
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Groeperen volgens
+DocType: Guardian,Interests,Interesses
+apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,In- / uitschakelen valuta .
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105,Dr {0} on Half day Leave on {1},Dr {0} op halve dag Verlof op {1}
+DocType: Production Plan,Get Material Request,Krijg Materiaal Request
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Portokosten
+apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Totaal (Amt)
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Entertainment & Vrije Tijd
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Stel het systeem voor instructeursbenaming in Onderwijs&gt; Onderwijsinstellingen in
+,Item Variant Details,Artikel Variant Details
+DocType: Quality Inspection,Item Serial No,Artikel Serienummer
+apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Maak Employee Records
+apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Totaal Present
+apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Boekhouding Jaarrekening
+DocType: Drug Prescription,Hour,uur
+DocType: Restaurant Order Entry,Last Sales Invoice,Laatste verkoopfactuur
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +789,Please select Qty against item {0},Selecteer alstublieft Aantal tegen item {0}
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nieuw Serienummer kan geen Magazijn krijgen. Magazijn moet via Voorraad Invoer of Ontvangst worden ingesteld.
+DocType: Lead,Lead Type,Lead Type
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114,You are not authorized to approve leaves on Block Dates,U bent niet bevoegd om afwezigheid goed te keuren op Block Dates
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394,All these items have already been invoiced,Al deze items zijn reeds gefactureerde
+DocType: Company,Monthly Sales Target,Maandelijks verkooppunt
+apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Kan door {0} worden goedgekeurd
+DocType: Hotel Room,Hotel Room Type,Hotel kamertype
+DocType: Item,Default Material Request Type,Standaard Materiaal Request Type
+DocType: Supplier Scorecard,Evaluation Period,Evaluatie periode
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Onbekend
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954,Work Order not created,Werkorder niet gemaakt
+DocType: Shipping Rule,Shipping Rule Conditions,Verzendregel Voorwaarden
+DocType: Purchase Invoice,Export Type,Exporttype
+DocType: Salary Slip Loan,Salary Slip Loan,Salaris Sliplening
+DocType: BOM Update Tool,The new BOM after replacement,De nieuwe Stuklijst na vervanging
+,Point of Sale,Point of Sale
+DocType: Payment Entry,Received Amount,ontvangen Bedrag
+DocType: Patient,Widow,Weduwe
+DocType: GST Settings,GSTIN Email Sent On,GSTIN Email Sent On
+DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop door Guardian
+DocType: Crop,Planting UOM,UOM planten
+DocType: Account,Tax,Belasting
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,ongemerkt
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Factuuroverzicht openen
+DocType: Education Settings,Education Manager,Education Manager
+DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,De minimale lengte tussen elke plant in het veld voor optimale groei
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Batched item {0} kan niet worden bijgewerkt met behulp van Stock Reconciliation, maar gebruik Voorraadinvoer"
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Batched item {0} kan niet worden bijgewerkt met behulp van Stock Reconciliation, maar gebruik Voorraadinvoer"
+DocType: Quality Inspection,Report Date,Rapport datum
+DocType: Student,Middle Name,Midden-naam
+DocType: C-Form,Invoices,Facturen
+DocType: Water Analysis,Type of Sample,Type monster
+DocType: Batch,Source Document Name,Bron Document Naam
+DocType: Batch,Source Document Name,Bron Document Naam
+DocType: Production Plan,Get Raw Materials For Production,Krijg grondstoffen voor productie
+DocType: Job Opening,Job Title,Functietitel
+apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
+					have been quoted. Updating the RFQ quote status.","{0} geeft aan dat {1} geen offerte zal opgeven, maar alle items \ zijn geciteerd. De RFQ-citaatstatus bijwerken."
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1070,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximale voorbeelden - {0} zijn al bewaard voor Batch {1} en Item {2} in Batch {3}.
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Type in Buying Settings.,Geef het leverancierstype op in koopinstellingen.
+DocType: Manufacturing Settings,Update BOM Cost Automatically,BOM kosten automatisch bijwerken
+DocType: Lab Test,Test Name,Test Naam
+apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Gebruikers maken
+apps/erpnext/erpnext/utilities/user_progress.py +147,Gram,Gram
+DocType: Supplier Scorecard,Per Month,Per maand
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433,Quantity to Manufacture must be greater than 0.,Hoeveelheid voor fabricage moet groter dan 0 zijn.
+DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Bereken het pro rata van afschrijving op basis van het fiscale jaar
+apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Bezoek rapport voor onderhoud gesprek.
+DocType: Stock Entry,Update Rate and Availability,Update snelheid en beschikbaarheid
+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.,Percentage dat u meer mag ontvangen of leveren dan de bestelde hoeveelheid. Bijvoorbeeld: Als u  100 eenheden heeft besteld en uw bandbreedte is 10% dan mag u 110 eenheden ontvangen.
+DocType: POS Customer Group,Customer Group,Klantengroep
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs,Rij # {0}: bewerking {1} is niet voltooid voor {2} aantal voltooide goederen in werkorder # {3}. Werkstatus bijwerken via tijdlogboeken
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),Nieuw batch-id (optioneel)
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),Nieuw batch-id (optioneel)
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Kostenrekening is verplicht voor artikel {0}
+DocType: BOM,Website Description,Website Beschrijving
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47,Net Change in Equity,Netto wijziging in het eigen vermogen
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +220,Please cancel Purchase Invoice {0} first,Annuleer Purchase Invoice {0} eerste
+apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-mailadres moet uniek zijn, bestaat al voor {0}"
+DocType: Serial No,AMC Expiry Date,AMC Vervaldatum
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880,Receipt,Ontvangst
+,Sales Register,Verkoopregister
+DocType: Daily Work Summary Group,Send Emails At,Stuur e-mails
+DocType: Quotation,Quotation Lost Reason,Reden verlies van Offerte
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381,Transaction reference no {0} dated {1},Transactiereferentie geen {0} van {1}
+apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Er is niets om te bewerken .
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +499,Form View,Formulierweergave
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Samenvatting voor deze maand en in afwachting van activiteiten
+apps/erpnext/erpnext/utilities/user_progress.py +248,"Add users to your organization, other than yourself.","Voeg gebruikers toe aan uw organisatie, behalve uzelf."
+DocType: Customer Group,Customer Group Name,Klant Groepsnaam
+apps/erpnext/erpnext/public/js/pos/pos.html +109,No Customers yet!,Nog geen klanten!
+apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Kasstroomoverzicht
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473,No material request created,Er is geen aanvraag voor een artikel gemaakt
+apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Geleende bedrag kan niet hoger zijn dan maximaal bedrag van de lening van {0}
+apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Licentie
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491,Please remove this Invoice {0} from C-Form {1},Verwijder dit Invoice {0} van 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,Selecteer Carry Forward als u ook wilt opnemen vorige boekjaar uit balans laat dit fiscale jaar
+DocType: GL Entry,Against Voucher Type,Tegen Voucher Type
+DocType: Physician,Phone (R),Telefoon (R)
+apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56,Time slots added,Tijdslots toegevoegd
+DocType: Item,Attributes,Attributen
+apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Sjabloon inschakelen
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,Voer Afschrijvingenrekening in
+apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Laatste Bestel Date
+DocType: Patient,B Negative,B Negatief
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Onderhoudsstatus moet worden geannuleerd of voltooid om te verzenden
+DocType: Hotel Room,Hotel Room,Hotelkamer
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Account {0} behoort niet tot bedrijf {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884,Serial Numbers in row {0} does not match with Delivery Note,Serienummers in rij {0} komt niet overeen met bezorgingsnota
+DocType: Student,Guardian Details,Guardian Details
+DocType: C-Form,C-Form,C-Form
+apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Attendance voor meerdere medewerkers
+DocType: Agriculture Task,Start Day,Start dag
+DocType: Vehicle,Chassis No,chassis Geen
+DocType: Payment Request,Initiated,Geïnitieerd
+DocType: Production Plan Item,Planned Start Date,Geplande Startdatum
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +622,Please select a BOM,Selecteer een stuklijst
+DocType: Purchase Invoice,Availed ITC Integrated Tax,Beschikbaar in ITC Integrated Tax
+DocType: Serial No,Creation Document Type,Aanmaken Document type
+DocType: Project Task,View Timesheet,Bekijk urenformulier
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Einddatum moet groter zijn dan startdatum
+DocType: Leave Type,Is Encash,Is incasseren
+DocType: Leave Allocation,New Leaves Allocated,Nieuwe Verloven Toegewezen
+apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Projectgegevens zijn niet beschikbaar voor Offertes
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Eindigt op
+DocType: Project,Expected End Date,Verwachte einddatum
+DocType: Budget Account,Budget Amount,budget Bedrag
+DocType: Donor,Donor Name,Donornaam
+DocType: Appraisal Template,Appraisal Template Title,Beoordeling Template titel
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Van Date {0} Werknemersverzekeringen {1} kan niet vóór de toetreding tot Date werknemer {2}
+apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,commercieel
+DocType: Patient,Alcohol Current Use,Alcohol Huidig Gebruik
+DocType: Student Admission Program,Student Admission Program,Studenten toelating programma
+DocType: Payment Entry,Account Paid To,Rekening betaald aan
+DocType: Item Alternative,Alternative Item Name,Alternatieve artikelnaam
+apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Ouder Item {0} moet een Stock Item niet
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466,"Could not submit any Salary Slip <br>\
+			Possible reasons: <br>\
+			1. Net pay is less than 0. <br>\
+			2. Company Email Address specified in employee master is not valid. <br>","Kon geen salarisstrook indienen <br> \ Mogelijke redenen: <br> \ 1. Nettoloon is minder dan 0. <br> \ 2. Het e-mailadres van het bedrijf dat in de werknemermaster is opgegeven, is niet geldig. <br>"
+apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Alle producten of diensten.
+DocType: Expense Claim,More Details,Meer details
+DocType: Supplier Quotation,Supplier Address,Adres Leverancier
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Budget voor Account {1} tegen {2} {3} is {4}. Het zal overschrijden tegen {5}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695,Row {0}# Account must be of type 'Fixed Asset',Rij {0} # Account moet van het type zijn &#39;Vaste Activa&#39;
+apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,out Aantal
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,en unchcked Uitgeschakeld in de
+apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41,Series is mandatory,Reeks is verplicht
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Financiële Dienstverlening
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Klant&gt; Klantengroep&gt; Gebied
+DocType: Student Sibling,Student ID,student ID
+apps/erpnext/erpnext/config/projects.py +51,Types of activities for Time Logs,Soorten activiteiten voor Time Logs
+DocType: Opening Invoice Creation Tool,Sales,Verkoop
+DocType: Stock Entry Detail,Basic Amount,Basisbedrag
+DocType: Training Event,Exam,tentamen
+DocType: Complaint,Complaint,Klacht
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462,Warehouse required for stock Item {0},Magazijn nodig voor voorraad Artikel {0}
+DocType: Leave Allocation,Unused leaves,Ongebruikte afwezigheden
+DocType: Patient,Alcohol Past Use,Alcohol voorbij gebruik
+DocType: Fertilizer Content,Fertilizer Content,Kunstmestinhoud
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187,Cr,Cr
+DocType: Project Update,Problematic/Stuck,Problematische / Stuck
+DocType: Tax Rule,Billing State,Billing State
+DocType: Share Transfer,Transfer,Verplaatsen
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Work Order {0} must be cancelled before cancelling this Sales Order,Werkorder {0} moet worden geannuleerd voordat deze klantorder wordt geannuleerd
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917,Fetch exploded BOM (including sub-assemblies),Haal uitgeklapte Stuklijst op (inclusief onderdelen)
+DocType: Authorization Rule,Applicable To (Employee),Van toepassing zijn op (Werknemer)
+apps/erpnext/erpnext/controllers/accounts_controller.py +137,Due Date is mandatory,Vervaldatum is verplicht
+apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Toename voor Attribute {0} kan niet worden 0
+apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Kamers geboekt
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +57,Ends On date cannot be before Next Contact Date.,Eindigt op datum kan niet eerder zijn dan volgende contactdatum.
+DocType: Journal Entry,Pay To / Recd From,Betaal aan / Ontv van
+DocType: Naming Series,Setup Series,Instellen Reeksen
+DocType: Payment Reconciliation,To Invoice Date,Om factuurdatum
+DocType: Shareholder,Contact HTML,Contact HTML
+apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Registratiekosten kunnen geen Zero zijn
+DocType: Disease,Treatment Period,Behandelingsperiode
+apps/erpnext/erpnext/education/api.py +338,Result already Submitted,Resultaat is al verzonden
+apps/erpnext/erpnext/controllers/buying_controller.py +170,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Gereserveerd magazijn is verplicht voor artikel {0} in geleverde grondstoffen
+,Inactive Customers,inactieve klanten
+DocType: Student Admission Program,Maximum Age,Maximum leeftijd
+apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,Wacht 3 dagen voordat je de herinnering opnieuw verzendt.
+DocType: Landed Cost Voucher,LCV,LCV
+DocType: Landed Cost Voucher,Purchase Receipts,Aankoopfacturen
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Hoe wordt de Prijsregel toegepast?
+DocType: Stock Entry,Delivery Note No,Vrachtbrief Nr
+DocType: Cheque Print Template,Message to show,Bericht om te laten zien
+apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Retail
+DocType: Student Attendance,Absent,Afwezig
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Product Bundle
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Kan geen score beginnen bij {0}. Je moet een score hebben van 0 tot 100
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Rij {0}: Invalid referentie {1}
+DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Aankoop en -heffingen Template
+DocType: Timesheet,TS-,TS-
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Ofwel debet of credit bedrag is vereist voor {2}
+DocType: GL Entry,Remarks,Opmerkingen
+DocType: Hotel Room Amenity,Hotel Room Amenity,Hotel Room Amenity
+DocType: Payment Entry,Account Paid From,Account betaald uit
+DocType: Purchase Order Item Supplied,Raw Material Item Code,Grondstof Artikelcode
+DocType: Task,Parent Task,Oudertaak
+DocType: Journal Entry,Write Off Based On,Afschrijving gebaseerd op
+apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,maak Lead
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Print en stationaire
+DocType: Stock Settings,Show Barcode Field,Show streepjescodeveld
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809,Send Supplier Emails,Stuur Leverancier Emails
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Salaris al verwerkt voor de periode tussen {0} en {1}, Laat aanvraagperiode kan niet tussen deze periode."
+DocType: Chapter Member,Leave Reason,Verlaat de Rede
+DocType: Guardian Interest,Guardian Interest,Guardian Interest
+DocType: Volunteer,Availability,Beschikbaarheid
+apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Stel standaardwaarden in voor POS-facturen
+apps/erpnext/erpnext/config/hr.py +182,Training,Opleiding
+DocType: Project,Time to send,Tijd om te verzenden
+DocType: Timesheet,Employee Detail,werknemer Detail
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,dag Volgende Date&#39;s en Herhalen op dag van de maand moet gelijk zijn
+DocType: Lab Prescription,Test Code,Testcode
+apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Instellingen voor website homepage
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ&#39;s zijn niet toegestaan voor {0} door een scorecard van {1}
+DocType: Job Offer,Awaiting Response,Wachten op antwoord
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +82,Above,Boven
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1487,Total Amount {0},Totaalbedrag {0}
+apps/erpnext/erpnext/controllers/item_variant.py +306,Invalid attribute {0} {1},Ongeldige eigenschap {0} {1}
+DocType: Supplier,Mention if non-standard payable account,Noem als niet-standaard betaalbaar account
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25,Please select the assessment group other than 'All Assessment Groups',Selecteer de beoordelingsgroep anders dan &#39;Alle beoordelingsgroepen&#39;
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Rij {0}: Kostencentrum is vereist voor een item {1}
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureDate,EcritureDate
+DocType: Training Event Employee,Optional,facultatief
+DocType: Salary Slip,Earning & Deduction,Verdienen &amp; Aftrek
+DocType: Agriculture Analysis Criteria,Water Analysis,Water analyse
+DocType: Chapter,Region,Regio
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Optioneel. Deze instelling wordt gebruikt om te filteren op diverse transacties .
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110,Negative Valuation Rate is not allowed,Negatieve Waarderingstarief is niet toegestaan
+DocType: Holiday List,Weekly Off,Wekelijks Vrij
+apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Reload Linked Analysis
+DocType: Fiscal Year,"For e.g. 2012, 2012-13","Voor bijvoorbeeld 2012, 2012-13"
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Voorlopige winst / verlies (Credit)
+DocType: Sales Invoice,Return Against Sales Invoice,Terug Tegen Sales Invoice
+apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Punt 5
+DocType: Serial No,Creation Time,Aanmaaktijd
+apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Totale omzet
+DocType: Patient,Other Risk Factors,Andere risicofactoren
+DocType: Sales Invoice,Product Bundle Help,Product Bundel Help
+,Monthly Attendance Sheet,Maandelijkse Aanwezigheids Sheet
+apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15,No record found,Geen record gevonden
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Kosten van Gesloopt Asset
+apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: kostenplaats is verplicht voor Artikel {2}
+DocType: Vehicle,Policy No,beleid Geen
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686,Get Items from Product Bundle,Krijg Items uit Product Bundle
+DocType: Asset,Straight Line,Rechte lijn
+DocType: Project User,Project User,project Gebruiker
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,Split,spleet
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,Split,spleet
+DocType: GL Entry,Is Advance,Is voorschot
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Aanwezigheid Van Datum en Aanwezigheid Tot Datum zijn verplicht.
+apps/erpnext/erpnext/controllers/buying_controller.py +157,Please enter 'Is Subcontracted' as Yes or No,Vul 'Is Uitbesteed' in als Ja of Nee
+DocType: Item,Default Purchase Unit of Measure,Standaard aankoopeenheid van maatregel
+apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Laatste Communicatie Datum
+apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Laatste Communicatie Datum
+DocType: Sales Team,Contact No.,Contact Nr
+DocType: Bank Reconciliation,Payment Entries,betaling Entries
+DocType: Land Unit,Land Unit Details,Gegevens over landeenheden
+DocType: Land Unit,Latitude,Breedtegraad
+DocType: Work Order,Scrap Warehouse,Scrap Warehouse
+DocType: Work Order,Check if material transfer entry is not required,Controleer of de invoer van materiaaloverdracht niet vereist is
+DocType: Work Order,Check if material transfer entry is not required,Controleer of de invoer van materiaaloverdracht niet vereist is
+DocType: Program Enrollment Tool,Get Students From,Krijgen studenten uit
+apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,Artikelen publiceren op de website
+apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Groep uw leerlingen in batches
+DocType: Authorization Rule,Authorization Rule,Autorisatie Rule
+DocType: POS Profile,Offline POS Section,Offline POS-sectie
+DocType: Sales Invoice,Terms and Conditions Details,Algemene Voorwaarden Details
+apps/erpnext/erpnext/templates/generators/item.html +100,Specifications,specificaties
+DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Sales en -heffingen Template
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Totaal (Credit)
+DocType: Repayment Schedule,Payment Date,Betaaldatum
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Nieuw aantal batches
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Nieuw aantal batches
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Kleding & Toebehoren
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,Kan de gewogen score functie niet oplossen. Zorg ervoor dat de formule geldig is.
+apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Aantal Bestel
+DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner dat zal laten zien op de bovenkant van het product lijst.
+DocType: Shipping Rule,Specify conditions to calculate shipping amount,Specificeer de voorwaarden om het verzendbedrag te berekenen
+DocType: Program Enrollment,Institute's Bus,Instituut&#39;s Bus
+DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Rol toegestaan om Stel Frozen Accounts & bewerken Frozen Entries
+DocType: Supplier Scorecard Scoring Variable,Path,Pad
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,Kan kostenplaats niet omzetten naar grootboek vanwege onderliggende nodes
+DocType: Production Plan,Total Planned Qty,Totaal aantal geplande
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,Opening Value,opening Value
+DocType: Salary Detail,Formula,Formule
+apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
+DocType: Lab Test Template,Lab Test Template,Lab Test Template
+apps/erpnext/erpnext/setup/doctype/company/company.py +181,Sales Account,Verkoopaccount
+DocType: Purchase Invoice Item,Total Weight,Totale gewicht
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Commissie op de verkoop
+DocType: Job Offer Term,Value / Description,Waarde / Beschrijving
+apps/erpnext/erpnext/controllers/accounts_controller.py +630,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Rij # {0}: Asset {1} kan niet worden ingediend, is het al {2}"
+DocType: Tax Rule,Billing Country,Land
+DocType: Purchase Order Item,Expected Delivery Date,Verwachte leverdatum
+DocType: Restaurant Order Entry,Restaurant Order Entry,Restaurantbestelling
+apps/erpnext/erpnext/accounts/general_ledger.py +134,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debet en Credit niet gelijk voor {0} # {1}. Verschil {2}.
+DocType: Asset Maintenance Task,Assign To Name,Toewijzen aan naam
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Representatiekosten
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98,Make Material Request,Maak Material Request
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Open Item {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Verkoopfactuur {0} moet worden geannuleerd voordat deze verkooporder kan worden geannuleerd.
+DocType: Consultation,Age,Leeftijd
+DocType: Sales Invoice Timesheet,Billing Amount,Factuurbedrag
+DocType: Cash Flow Mapping,Select Maximum Of 1,Selecteer maximaal 1
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ongeldig aantal opgegeven voor artikel {0} . Hoeveelheid moet groter zijn dan 0 .
+DocType: Company,Default Employee Advance Account,Standaard Employee Advance Account
+apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Aanvragen voor verlof.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +164,Account with existing transaction can not be deleted,Rekening met bestaande transactie kan niet worden verwijderd
+DocType: Vehicle,Last Carbon Check,Laatste Carbon controleren
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Juridische Kosten
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +145,Please select quantity on row ,Selecteer alstublieft de hoeveelheid op rij
+apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Open verkoop- en inkoopfacturen
+DocType: Purchase Invoice,Posting Time,Plaatsing Time
+DocType: Timesheet,% Amount Billed,% Gefactureerd Bedrag
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Telefoonkosten
+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.,Controleer dit als u wilt dwingen de gebruiker om een reeks voor het opslaan te selecteren. Er zal geen standaard zijn als je dit controleren.
+apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Serial No {0},Geen Artikel met Serienummer {0}
+DocType: Email Digest,Open Notifications,Open Meldingen
+DocType: Payment Entry,Difference Amount (Company Currency),Verschil Bedrag (Company Munt)
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Directe Kosten
+apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Nieuwe klant Revenue
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Reiskosten
+DocType: Maintenance Visit,Breakdown,Storing
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Voeg een aangepast veld toe Abonnement in het doctype {0}
+apps/erpnext/erpnext/controllers/accounts_controller.py +820,Account: {0} with currency: {1} can not be selected,Account: {0} met valuta: {1} kan niet worden geselecteerd
+DocType: Purchase Receipt Item,Sample Quantity,Monsterhoeveelheid
+DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Update BOM kosten automatisch via Scheduler, op basis van de laatste waarderingssnelheid / prijslijst koers / laatste aankoophoeveelheid grondstoffen."
+DocType: Bank Reconciliation Detail,Cheque Date,Cheque Datum
+apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Rekening {0}: Bovenliggende rekening {1} hoort niet bij bedrijf: {2}
+apps/erpnext/erpnext/setup/doctype/company/company.js +106,Successfully deleted all transactions related to this company!,Succesvol verwijderd alle transacties met betrekking tot dit bedrijf!
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,As on Date,Op Date
+DocType: Appraisal,HR,HR
+DocType: Program Enrollment,Enrollment Date,inschrijfdatum
+DocType: Healthcare Settings,Out Patient SMS Alerts,Out Patient SMS Alerts
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,proeftijd
+apps/erpnext/erpnext/config/hr.py +115,Salary Components,salaris Components
+DocType: Program Enrollment Tool,New Academic Year,New Academisch Jaar
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811,Return / Credit Note,Return / Credit Note
+DocType: Stock Settings,Auto insert Price List rate if missing,Auto insert Prijslijst tarief als vermist
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +126,Total Paid Amount,Totale betaalde bedrag
+DocType: GST Settings,B2C Limit,B2C-limiet
+DocType: Work Order Item,Transferred Qty,Verplaatst Aantal
+apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigeren
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,planning
+DocType: Share Balance,Issued,Uitgegeven
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Studentactiviteit
+apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Leverancier Id
+DocType: Payment Request,Payment Gateway Details,Payment Gateway Details
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276,Quantity should be greater than 0,Hoeveelheid moet groter zijn dan 0
+DocType: Journal Entry,Cash Entry,Cash Entry
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Child nodes kunnen alleen worden gemaakt op grond van het type nodes &#39;Groep&#39;
+DocType: Leave Application,Half Day Date,Halve dag datum
+DocType: Academic Year,Academic Year Name,Academisch jaar naam
+DocType: Sales Partner,Contact Desc,Contact Omschr
+apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Type verloven zoals, buitengewoon, ziekte, etc."
+DocType: Email Digest,Send regular summary reports via Email.,Stuur regelmatige samenvattende rapporten via e-mail.
+DocType: Payment Entry,PE-,PE
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282,Please set default account in Expense Claim Type {0},Stel standaard account aan Expense conclusie Type {0}
+DocType: Assessment Result,Student Name,Studenten naam
+DocType: Brand,Item Manager,Item Manager
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,payroll Payable
+DocType: Buying Settings,Default Supplier Type,Standaard Leverancier Type
+DocType: Plant Analysis,Collection Datetime,Verzameling Datetime
+DocType: Work Order,Total Operating Cost,Totale exploitatiekosten
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Opmerking : Artikel {0} meerdere keren ingevoerd
+apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Alle contactpersonen.
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Bedrijf afkorting
+apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47,User {0} does not exist,Gebruiker {0} bestaat niet
+DocType: Payment Term,Day(s) after invoice date,Dag (en) na factuurdatum
+DocType: Payment Schedule,Payment Schedule,Betalingsschema
+DocType: Subscription,SUB-,SUB-
+DocType: Item Attribute Value,Abbreviation,Afkorting
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195,Payment Entry already exists,Betaling Entry bestaat al
+apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Niet toegestaan aangezien {0} grenzen overschrijdt
+apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Salaris sjabloon stam .
+apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Pathologie
+DocType: Restaurant Order Entry,Restaurant Table,Restaurant tafel
+DocType: Hotel Room,Hotel Manager,Hotel Manager
+DocType: Leave Type,Max Days Leave Allowed,Max Dagen Verlof toegestaan
+apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Stel Tax Regel voor winkelmandje
+DocType: Purchase Invoice,Taxes and Charges Added,Belastingen en Toeslagen toegevoegd
+,Sales Funnel,Verkoop Trechter
+apps/erpnext/erpnext/setup/doctype/company/company.py +49,Abbreviation is mandatory,Afkorting is verplicht
+DocType: Project,Task Progress,Task Progress
+apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Kar
+,Qty to Transfer,Aantal te verplaatsen
+apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Offertes naar leads of klanten.
+DocType: Stock Settings,Role Allowed to edit frozen stock,Rol toegestaan om bevroren voorraden bewerken
+,Territory Target Variance Item Group-Wise,Regio Doel Variance Artikel Groepsgewijs
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Alle Doelgroepen
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,Maandelijks geaccumuleerd
+apps/erpnext/erpnext/controllers/accounts_controller.py +781,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} is verplicht. Misschien is Valuta Koers record niet gemaakt voor {1} naar {2}.
+apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44,Tax Template is mandatory.,Belasting Template is verplicht.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Rekening {0}: Bovenliggende rekening {1} bestaat niet
+DocType: Purchase Invoice Item,Price List Rate (Company Currency),Prijslijst Tarief (Bedrijfsvaluta)
+DocType: Products Settings,Products Settings,producten Instellingen
+,Item Price Stock,Artikel Prijs Voorraad
+DocType: Lab Prescription,Test Created,Test gemaakt
+DocType: Healthcare Settings,Custom Signature in Print,Aangepaste handtekening in afdrukken
+DocType: Account,Temporary,Tijdelijk
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +116,Customer LPO No.,LPO-nummer klant
+DocType: Program,Courses,cursussen
+DocType: Monthly Distribution Percentage,Percentage Allocation,Percentage Toewijzing
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,secretaresse
+DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Als uitschakelen, &#39;In de woorden&#39; veld niet zichtbaar in elke transactie"
+DocType: Serial No,Distinct unit of an Item,Aanwijsbare eenheid van een Artikel
+DocType: Supplier Scorecard Criteria,Criteria Name,Criteria Naam
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295,Please set Company,Stel alsjeblieft bedrijf in
+DocType: Pricing Rule,Buying,Inkoop
+apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Ziekten &amp; Meststoffen
+DocType: HR Settings,Employee Records to be created by,Werknemer Records worden gecreëerd door
+DocType: Patient,AB Negative,AB Negatief
+DocType: Sample Collection,SMPL-,SMPL-
+DocType: POS Profile,Apply Discount On,Breng Korting op
+DocType: Member,Membership Type,soort lidmaatschap
+,Reqd By Date,Benodigd op datum
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Crediteuren
+DocType: Assessment Plan,Assessment Name,assessment Naam
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94,Show PDC in Print,PDC weergeven in Afdrukken
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97,Row # {0}: Serial No is mandatory,Rij # {0}: Serienummer is verplicht
+DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Artikelgebaseerde BTW Details
+apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Job Offer,Vacature
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Instituut Afkorting
+,Item-wise Price List Rate,Artikelgebaseerde Prijslijst Tarief
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082,Supplier Quotation,Leverancier Offerte
+DocType: Quotation,In Words will be visible once you save the Quotation.,In Woorden zijn zichtbaar zodra u de Offerte opslaat.
+apps/erpnext/erpnext/utilities/transaction_base.py +164,Quantity ({0}) cannot be a fraction in row {1},Hoeveelheid ({0}) kan geen fractie in rij {1} zijn
+apps/erpnext/erpnext/utilities/transaction_base.py +164,Quantity ({0}) cannot be a fraction in row {1},Hoeveelheid ({0}) kan geen fractie in rij {1} zijn
+DocType: Consultation,C-,C-
+DocType: Attendance,ATT-,ATT-
+apps/erpnext/erpnext/stock/doctype/item/item.py +492,Barcode {0} already used in Item {1},Barcode {0} is al gebruikt in het Item {1}
+apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Regels voor het toevoegen van verzendkosten.
+DocType: Hotel Room,Extra Bed Capacity,Extra bedcapaciteit
+DocType: Item,Opening Stock,Opening Stock
+apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Klant is verplicht
+DocType: Lab Test,Result Date,Resultaatdatum
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +99,PDC/LC Date,PDC / LC-datum
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} is verplicht voor Return
+DocType: Purchase Order,To Receive,Ontvangen
+apps/erpnext/erpnext/utilities/user_progress.py +252,user@example.com,user@example.com
+DocType: Asset,Asset Owner,Activa-eigenaar
+DocType: Employee,Personal Email,Persoonlijke e-mail
+apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Total Variance
+DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Indien aangevinkt, zal het systeem voorraadboekingen automatisch plaatsen."
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,makelaardij
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195,Attendance for employee {0} is already marked for this day,Attendance voor personeelsbeloningen {0} is al gemarkeerd voor deze dag
+DocType: Work Order Operation,"in Minutes
+Updated via 'Time Log'","in Minuten 
+ Bijgewerkt via 'Time Log'"
+DocType: Customer,From Lead,Van Lead
+apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Orders vrijgegeven voor productie.
+apps/erpnext/erpnext/public/js/account_tree_grid.js +65,Select Fiscal Year...,Selecteer boekjaar ...
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567,POS Profile required to make POS Entry,POS profiel nodig om POS Entry maken
+DocType: Program Enrollment Tool,Enroll Students,inschrijven Studenten
+DocType: Lab Test,Approved Date,Goedgekeurde Datum
+apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standaard Verkoop
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165,Atleast one warehouse is mandatory,Tenminste een magazijn is verplicht
+DocType: Serial No,Out of Warranty,Uit de garantie
+DocType: BOM Update Tool,Replace,Vervang
+apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Geen producten gevonden.
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} tegen verkoopfactuur {1}
+DocType: Antibiotic,Laboratory User,Laboratoriumgebruiker
+DocType: Sales Invoice,SINV-,SINV-
+DocType: Request for Quotation Item,Project Name,Naam van het project
+DocType: Customer,Mention if non-standard receivable account,Vermelden of niet-standaard te ontvangen rekening
+DocType: Journal Entry Account,If Income or Expense,Indien Inkomsten (baten) of Uitgaven (lasten)
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288,Select interest income account in employee loan {0},Selecteer rentebatenrekening in personeelslening {0}
+DocType: Work Order,Required Items,Vereiste items
+DocType: Stock Ledger Entry,Stock Value Difference,Voorraad Waarde Verschil
+apps/erpnext/erpnext/config/learn.py +229,Human Resource,Human Resource
+DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Afletteren Betaling
+DocType: Disease,Treatment Task,Behandelingstaak
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Belastingvorderingen
+DocType: BOM Item,BOM No,Stuklijst nr.
+DocType: Instructor,INS/,INS /
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,Journal Entry {0} heeft geen rekening {1} of al vergeleken met andere voucher
+DocType: Item,Moving Average,Moving Average
+DocType: BOM Update Tool,The BOM which will be replaced,De Stuklijst die zal worden vervangen
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,elektronische apparatuur
+DocType: Asset,Maintenance Required,Onderhoud vereist
+DocType: Account,Debit,Debet
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Verloven moeten in veelvouden van 0,5 worden toegewezen"
+DocType: Work Order,Operation Cost,Operatie Cost
+apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Upload aanwezigheid uit een .csv-bestand
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Openstaande Amt
+DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Set richt Item Group-wise voor deze verkoper.
+DocType: Stock Settings,Freeze Stocks Older Than [Days],Bevries Voorraden ouder dan [dagen]
+apps/erpnext/erpnext/controllers/accounts_controller.py +600,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Rij # {0}: Asset is verplicht voor vaste activa aankoop / verkoop
+DocType: Asset Maintenance Team,Maintenance Team Name,Onderhoudsteam naam
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Als twee of meer Pricing Regels zijn gevonden op basis van de bovenstaande voorwaarden, wordt prioriteit toegepast. Prioriteit is een getal tussen 0 en 20, terwijl standaardwaarde nul (blanco). Hoger aantal betekent dat het voorrang krijgen als er meerdere prijzen Regels met dezelfde voorwaarden."
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,Klant is verplicht als &#39;Opportunity vanaf&#39; is geselecteerd als klant
+apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Boekjaar: {0} bestaat niet
+DocType: Currency Exchange,To Currency,Naar Valuta
+DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Laat de volgende gebruikers te keuren Verlof Aanvragen voor blok dagen.
+apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Typen Onkostendeclaraties.
+apps/erpnext/erpnext/controllers/selling_controller.py +148,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Verkoopprijs voor item {0} is lager dan de {1}. Verkoopprijs moet ten minste {2} zijn
+apps/erpnext/erpnext/controllers/selling_controller.py +148,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Verkoopprijs voor item {0} is lager dan de {1}. Verkoopprijs moet ten minste {2} zijn
+DocType: Item,Taxes,Belastingen
+DocType: Purchase Invoice,capital goods,kapitaalgoederen
+DocType: Purchase Invoice Item,Weight Per Unit,Gewicht per eenheid
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Betaald en niet geleverd
+DocType: Project,Default Cost Center,Standaard Kostenplaats
+DocType: Bank Guarantee,End Date,Einddatum
+apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Stock Transactions
+DocType: Budget,Budget Accounts,budget Accounts
+DocType: Employee,Internal Work History,Interne Werk Geschiedenis
+DocType: Depreciation Schedule,Accumulated Depreciation Amount,Cumulatieve afschrijvingen Bedrag
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
+DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Leverancier Scorecard Variable
+DocType: Employee Loan,Fully Disbursed,volledig uitbetaald
+DocType: Employee Advance,Due Advance Amount,Voorschotbedrag
+DocType: Maintenance Visit,Customer Feedback,Klantenfeedback
+DocType: Account,Expense,Kosten
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54,Score cannot be greater than Maximum Score,Score kan niet groter zijn dan de maximale score te zijn
+apps/erpnext/erpnext/utilities/user_progress.py +129,Customers and Suppliers,Klanten en leveranciers
+DocType: Item Attribute,From Range,Van Range
+DocType: BOM,Set rate of sub-assembly item based on BOM,Set percentage van sub-assembly item op basis van BOM
+DocType: Hotel Room Reservation,Invoiced,gefactureerd
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},Syntaxisfout in formule of aandoening: {0}
+DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Dagelijks Werk Samenvatting Instellingen Company
+apps/erpnext/erpnext/stock/utils.py +125,Item {0} ignored since it is not a stock item,Artikel {0} genegeerd omdat het niet een voorraadartikel is
+DocType: Appraisal,APRSL,APRSL
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Om de prijsbepalingsregel in een specifieke transactie niet toe te passen, moeten alle toepasbare prijsbepalingsregels worden uitgeschakeld."
+DocType: Payment Term,Day(s) after the end of the invoice month,Dag (en) na het einde van de factuurmaand
+DocType: Assessment Group,Parent Assessment Group,Parent Assessment Group
+apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Jobs
+,Sales Order Trends,Verkooporder Trends
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,The 'From Package No.' field must neither be empty nor it's value less than 1.,Het &#39;Van pakketnummer&#39; veld mag niet leeg zijn of de waarde is kleiner dan 1.
+DocType: Employee,Held On,Heeft plaatsgevonden op
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36,Production Item,Productie Item
+,Employee Information,Werknemer Informatie
+DocType: Stock Entry Detail,Additional Cost,Bijkomende kosten
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48,"Can not filter based on Voucher No, if grouped by Voucher","Kan niet filteren op basis van vouchernummer, indien gegroepeerd per voucher"
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918,Make Supplier Quotation,Maak Leverancier Offerte
+DocType: Quality Inspection,Incoming,Inkomend
+apps/erpnext/erpnext/setup/doctype/company/company.js +70,Default tax templates for sales and purchase are created.,Standaardbelastingsjablonen voor verkopen en kopen worden gemaakt.
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57,Assessment Result record {0} already exists.,Beoordeling Resultaat record {0} bestaat al.
+DocType: BOM,Materials Required (Exploded),Benodigde materialen (uitgeklapt)
+apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',Stel alsjeblieft Bedrijfsfilter leeg als Group By is &#39;Company&#39;
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Posting datum kan niet de toekomst datum
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102,Row # {0}: Serial No {1} does not match with {2} {3},Rij # {0}: Serienummer {1} komt niet overeen met {2} {3}
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,voor het genereren van de terugkerende
+DocType: Stock Entry,Target Warehouse Address,Target Warehouse Address
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Casual Leave
+DocType: Agriculture Task,End Day,Einde dag
+DocType: Batch,Batch ID,Partij ID
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Opmerking : {0}
+,Delivery Note Trends,Vrachtbrief Trends
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Samenvatting van deze week
+apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Op voorraad Aantal
+DocType: Delivery Trip,Calculate Estimated Arrival Times,Bereken geschatte aankomsttijden
+apps/erpnext/erpnext/accounts/general_ledger.py +113,Account: {0} can only be updated via Stock Transactions,Account: {0} kan alleen worden bijgewerkt via Voorraad Transacties
+DocType: Student Group Creation Tool,Get Courses,krijg Cursussen
+DocType: GL Entry,Party,Partij
+DocType: Healthcare Settings,Patient Name,Patient naam
+DocType: Variant Field,Variant Field,Variantveld
+DocType: Sales Order,Delivery Date,Leveringsdatum
+DocType: Opportunity,Opportunity Date,Datum opportuniteit
+DocType: Employee,Health Insurance Provider,Zorgverzekeraar
+DocType: Purchase Receipt,Return Against Purchase Receipt,Terug Tegen Aankoop Receipt
+DocType: Water Analysis,Person Responsible,Verantwoordelijke persoon
+DocType: Request for Quotation Item,Request for Quotation Item,Offerte Item
+DocType: Purchase Order,To Bill,Bill
+DocType: Material Request,% Ordered,% Besteld
+DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Voor cursusgerichte studentengroep wordt de cursus voor elke student gevalideerd van de ingeschreven cursussen in de inschrijving van het programma.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,stukwerk
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Gem. Buying Rate
+DocType: Share Balance,From No,Van Nee
+DocType: Task,Actual Time (in Hours),Werkelijke tijd (in uren)
+DocType: Employee,History In Company,Geschiedenis In Bedrijf
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,New Message from {sender},Nieuw bericht van {sender}
+DocType: Customer,Customer Primary Address,Primair adres van klant
+apps/erpnext/erpnext/config/learn.py +107,Newsletters,Nieuwsbrieven
+DocType: Drug Prescription,Description/Strength,Beschrijving / Strength
+DocType: Share Balance,Is Company,Is Bedrijf
+DocType: Stock Ledger Entry,Stock Ledger Entry,Voorraad Dagboek post
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Hetzelfde artikel is meerdere keren ingevoerd
+DocType: Department,Leave Block List,Verlof bloklijst
+DocType: Purchase Invoice,Tax ID,BTW-nummer
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Artikel {0} is niet ingesteld voor serienummers. Kolom moet leeg zijn
+DocType: Accounts Settings,Accounts Settings,Rekeningen Instellingen
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Goedkeuren
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69,"Malformatted address for {0}, please fix to continue.","Malformatted adres voor {0}, gelieve te herstellen om verder te gaan."
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix","Nummer van nieuwe account, deze zal als een prefix in de accountnaam worden opgenomen"
+DocType: Maintenance Team Member,Team Member,Teamlid
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Geen resultaat om in te dienen
+DocType: Customer,Sales Partner and Commission,Sales Partner en de Commissie
+DocType: Employee Loan,Rate of Interest (%) / Year,Rate of Interest (%) / Jaar
+,Project Quantity,project Hoeveelheid
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Totaal {0} voor alle items nul is, kan je zou moeten veranderen &#39;Verdeel heffingen op basis van&#39;"
+DocType: Opportunity,To Discuss,Te bespreken
+apps/erpnext/erpnext/stock/stock_ledger.py +377,{0} units of {1} needed in {2} to complete this transaction.,{0} eenheden van {1} die nodig zijn in {2} om deze transactie te voltooien.
+DocType: Loan Type,Rate of Interest (%) Yearly,Rate of Interest (%) Jaarlijkse
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Tijdelijke Accounts
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Zwart
+DocType: BOM Explosion Item,BOM Explosion Item,Stuklijst Uitklap Artikel
+DocType: Shareholder,Contact List,Contactlijst
+DocType: Account,Auditor,Revisor
+DocType: Project,Frequency To Collect Progress,Frequentie om vorderingen te verzamelen
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132,{0} items produced,{0} items geproduceerd
+apps/erpnext/erpnext/utilities/user_progress.py +58,Learn More,Kom meer te weten
+DocType: Cheque Print Template,Distance from top edge,Afstand van bovenrand
+apps/erpnext/erpnext/stock/get_item_details.py +367,Price List {0} is disabled or does not exist,Prijslijst {0} is uitgeschakeld of bestaat niet
+DocType: Purchase Invoice,Return,Terugkeer
+DocType: Pricing Rule,Disable,Uitschakelen
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180,Mode of payment is required to make a payment,Wijze van betaling is vereist om een betaling te doen
+DocType: Project Task,Pending Review,In afwachting van Beoordeling
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Bewerken op de volledige pagina voor meer opties zoals activa, serienummers, batches etc."
+apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Afspraken en overleg
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} is niet ingeschreven in de partij {2}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} kan niet worden gesloopt, want het is al {1}"
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +86,Cheques Required,Controles vereist
+DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense Claim)
+apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Afwezig
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Kan bedrijf niet instellen
+DocType: Asset Repair,Asset Repair,Asset reparatie
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Rij {0}: Munt van de BOM # {1} moet gelijk zijn aan de geselecteerde valuta zijn {2}
+DocType: Journal Entry Account,Exchange Rate,Wisselkoers
+DocType: Patient,Additional information regarding the patient,Aanvullende informatie over de patiënt
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585,Sales Order {0} is not submitted,Verkooporder {0} is niet ingediend
+DocType: Homepage,Tag Line,tag Line
+DocType: Fee Component,Fee Component,fee Component
+apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Vloot beheer
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080,Add items from,Items uit voegen
+apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Gewassen en land
+DocType: Cheque Print Template,Regular,regelmatig
+DocType: Fertilizer,Density (if liquid),Dichtheid (indien vloeibaar)
+apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Totaal weightage van alle beoordelingscriteria moet 100% zijn
+DocType: Purchase Order Item,Last Purchase Rate,Laatste inkooptarief
+DocType: Account,Asset,aanwinst
+DocType: Project Task,Task ID,Task ID
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Voorraad kan niet bestaan voor Artikel {0} omdat het varianten heeft.
+DocType: Lab Test,Mobile,mobiel
+,Sales Person-wise Transaction Summary,Verkopergebaseerd Transactie Overzicht
+DocType: Training Event,Contact Number,Contact nummer
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73,Warehouse {0} does not exist,Magazijn {0} bestaat niet
+DocType: Monthly Distribution,Monthly Distribution Percentages,Maandelijkse Verdeling Percentages
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +110,The selected item cannot have Batch,Het geselecteerde item kan niet Batch hebben
+DocType: Delivery Note,% of materials delivered against this Delivery Note,% van de geleverde materialen voor deze Vrachtbrief
+DocType: Asset Maintenance Log,Has Certificate,Heeft certificaat
+DocType: Project,Customer Details,Klant Details
+DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Controleer of Activum preventief onderhoud of kalibratie vereist
+apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,Bedrijfsbegeleiding mag niet meer dan 5 tekens bevatten
+DocType: Employee,Reports to,Rapporteert aan
+,Unpaid Expense Claim,Onbetaalde Onkostenvergoeding
+DocType: Payment Entry,Paid Amount,Betaald Bedrag
+apps/erpnext/erpnext/utilities/user_progress.py +158,Explore Sales Cycle,Verken de verkoopcyclus
+DocType: Assessment Plan,Supervisor,opzichter
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869,Retention Stock Entry,Retention Stock Entry
+,Available Stock for Packing Items,Beschikbaar voor Verpakking Items
+DocType: Item Variant,Item Variant,Artikel Variant
+,Work Order Stock Report,Werkorder Voorraadverslag
+DocType: Assessment Result Tool,Assessment Result Tool,Assessment Result Tool
+apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Als supervisor
+DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
+apps/erpnext/erpnext/accounts/page/pos/pos.js +895,Submitted orders can not be deleted,Ingezonden bestellingen kunnen niet worden verwijderd
+apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Accountbalans reeds in Debet, 'Balans moet zijn' mag niet als 'Credit' worden ingesteld"
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Quality Management
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Item {0} is uitgeschakeld
+DocType: Project,Total Billable Amount (via Timesheets),Totaal factureerbare hoeveelheid (via urenstaten)
+DocType: Agriculture Task,Previous Business Day,Vorige werkdag
+DocType: Employee Loan,Repay Fixed Amount per Period,Terugbetalen vast bedrag per periode
+DocType: Employee,Health Insurance No,Ziektekostenverzekering Nee
+apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Vul het aantal in voor artikel {0}
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +229,Credit Note Amt,Credit Note Amt
+DocType: Employee External Work History,Employee External Work History,Werknemer Externe Werk Geschiedenis
+DocType: Opening Invoice Creation Tool,Purchase,Inkopen
+apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Balans Aantal
+apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Goals mag niet leeg zijn
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,Enrolling students,Studenten inschrijven
+DocType: Item Group,Parent Item Group,Bovenliggende Artikelgroep
+DocType: Appointment Type,Appointment Type,Afspraakstype
+apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} voor {1}
+DocType: Healthcare Settings,Valid number of days,Geldig aantal dagen
+apps/erpnext/erpnext/setup/doctype/company/company.js +39,Cost Centers,Kostenplaatsen
+DocType: Land Unit,Linked Plant Analysis,Linked Plant Analysis
+DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Koers waarmee de leverancier valuta wordt omgerekend naar de basis bedrijfsvaluta
+apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Rij #{0}: Tijden conflicteren met rij {1}
+DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Zero waarderingspercentage toestaan
+DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Zero waarderingspercentage toestaan
+DocType: Training Event Employee,Invited,Uitgenodigd
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178,Multiple active Salary Structures found for employee {0} for the given dates,Meerdere actieve Salaris Structuren gevonden voor werknemer {0} de uitgekozen datum
+apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Setup Gateway accounts.
+DocType: Employee,Employment Type,Dienstverband Type
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Vaste Activa
+DocType: Payment Entry,Set Exchange Gain / Loss,Stel Exchange winst / verlies
+,GST Purchase Register,GST Aankoopregister
+,Cash Flow,Cashflow
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Gecombineerd factuurgedeelte moet 100% zijn
+DocType: Item Group,Default Expense Account,Standaard Kostenrekening
+DocType: GST Account,CGST Account,CGST-account
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student Email ID
+DocType: Employee,Notice (days),Kennisgeving ( dagen )
+DocType: Tax Rule,Sales Tax Template,Sales Tax Template
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2506,Select items to save the invoice,Selecteer items om de factuur te slaan
+DocType: Employee,Encashment Date,Betalingsdatum
+DocType: Training Event,Internet,internet
+DocType: Special Test Template,Special Test Template,Special Test Template
+DocType: Account,Stock Adjustment,Voorraad aanpassing
+apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Default Activiteit Kosten bestaat voor Activity Type - {0}
+DocType: Work Order,Planned Operating Cost,Geplande bedrijfskosten
+DocType: Academic Term,Term Start Date,Term Startdatum
+apps/erpnext/erpnext/config/accounts.py +471,List of all share transactions,Lijst met alle aandelentransacties
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244,Please find attached {0} #{1},In bijlage vindt u {0} # {1}
+apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Gemiddelde score
+apps/erpnext/erpnext/controllers/accounts_controller.py +728,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Het totale betalingsbedrag in het betalingsschema moet gelijk zijn aan het groot / afgerond totaal
+apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Bankafschrift saldo per General Ledger
+DocType: Job Applicant,Applicant Name,Aanvrager Naam
+DocType: Authorization Rule,Customer / Item Name,Klant / Naam van het punt
+DocType: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Indien ingeschakeld, worden de laatste aankoopgegevens van items niet opgehaald van de vorige bestelling of aankoopbon"
+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","Aggregate groep ** Items ** in een ander ** Item **. Dit is handig als u bundelen een bepaald ** Items ** in een pakket en je onderhouden voorraad van de verpakte ** Items ** en niet de totale ** Item **. Het pakket ** Item ** zal hebben &quot;Is Stock Item&quot; als &quot;Nee&quot; en &quot;Is Sales Item&quot; als &quot;Ja&quot;. Bijvoorbeeld: Als u verkoopt laptops en rugzakken los en hebben een speciale prijs als de klant beide koopt, dan is de laptop + rugzak zal een nieuw product Bundel Item zijn. Opmerking: BOM = stuklijst"
+apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serienummer is verplicht voor Artikel {0}
+DocType: Item Variant Attribute,Attribute,Attribuut
+apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Gelieve te specificeren van / naar variëren
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Opening {0} Factuur aangemaakt
+DocType: Serial No,Under AMC,Onder AMC
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Item waardering tarief wordt herberekend overweegt landde kosten voucherbedrag
+apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Standaardinstellingen voor Verkooptransacties .
+DocType: Guardian,Guardian Of ,Beschermer van
+DocType: Grading Scale Interval,Threshold,Drempel
+DocType: BOM Update Tool,Current BOM,Huidige Stuklijst
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32,Balance (Dr - Cr),Evenwicht (Dr - Cr)
+apps/erpnext/erpnext/public/js/utils.js +55,Add Serial No,Voeg Serienummer toe
+DocType: Work Order Item,Available Qty at Source Warehouse,Beschikbaar Aantal bij Source Warehouse
+apps/erpnext/erpnext/config/support.py +22,Warranty,Garantie
+DocType: Purchase Invoice,Debit Note Issued,Debetnota
+DocType: Work Order,Warehouses,Magazijnen
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} actief kan niet worden overgedragen
+DocType: Hotel Room Pricing,Hotel Room Pricing,Prijzen van hotelkamers
+apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Dit artikel is een variant van {0} (Sjabloon).
+DocType: Workstation,per hour,per uur
+apps/erpnext/erpnext/config/buying.py +7,Purchasing,inkoop
+DocType: Announcement,Announcement,Mededeling
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +106,Customer LPO,Klant-LPO
+DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Voor Batch-based Student Group wordt de Student Batch voor elke student gevalideerd van de Programma Inschrijving.
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Magazijn kan niet worden verwijderd omdat er voorraadboekingen zijn voor dit magazijn.
+apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distributie
+DocType: Expense Claim Advance,Expense Claim Advance,Onkostendeclaratie doorvoeren
+DocType: Lab Test,Report Preference,Rapportvoorkeur
+apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Vrijwilliger informatie.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Project Manager
+,Quoted Item Comparison,Geciteerd Item Vergelijking
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Overlappen in scoren tussen {0} en {1}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Dispatch
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74,Max discount allowed for item: {0} is {1}%,Maximale korting toegestaan voor artikel: {0} is {1}%
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Intrinsieke waarde Op
+DocType: Crop,Produce,Produceren
+DocType: Hotel Settings,Default Taxes and Charges,Standaard en -heffingen
+DocType: Account,Receivable,Vordering
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Rij # {0}: Niet toegestaan om van leverancier te veranderen als bestelling al bestaat
+DocType: Item Alternative,Alternative Item Code,Alternatieve artikelcode
+DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Rol welke is toegestaan om transacties in te dienen die gestelde kredietlimieten overschrijden .
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +990,Select Items to Manufacture,Selecteer Items voor fabricage
+DocType: Delivery Stop,Delivery Stop,Levering Stop
+apps/erpnext/erpnext/accounts/page/pos/pos.js +963,"Master data syncing, it might take some time","Master data synchronisatie, kan het enige tijd duren"
+DocType: Item,Material Issue,Materiaal uitgifte
+DocType: Employee Education,Qualification,Kwalificatie
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42,View Salary Slips,Bekijk salarisstroken
+DocType: Item Price,Item Price,Artikelprijs
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Zeep & Wasmiddel
+DocType: BOM,Show Items,Show items
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Van tijd kan niet groter zijn dan tot tijd.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92,Do you want to notify all the customers by email?,Wilt u alle klanten per e-mail op de hoogte stellen?
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
+apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Besteld
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Hervat
+DocType: Salary Detail,Component,bestanddeel
+DocType: Assessment Criteria,Assessment Criteria Group,Beoordelingscriteria Group
+DocType: Healthcare Settings,Patient Name By,Patiëntnaam By
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Het openen van de cumulatieve afschrijvingen moet kleiner zijn dan gelijk aan {0}
+DocType: Warehouse,Warehouse Name,Magazijn Naam
+DocType: Naming Series,Select Transaction,Selecteer Transactie
+apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Vul de Goedkeurders Rol of Goedkeurende Gebruiker in
+DocType: Journal Entry,Write Off Entry,Invoer afschrijving
+DocType: BOM,Rate Of Materials Based On,Prijs van materialen op basis van
+apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Support Analyse
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Verwijder het vinkje bij alle
+DocType: POS Profile,Terms and Conditions,Algemene Voorwaarden
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Tot Datum moet binnen het boekjaar vallenn. Ervan uitgaande dat Tot Datum = {0}
+DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Hier kunt u onderhouden lengte, gewicht, allergieën, medische zorgen, enz."
+DocType: Leave Block List,Applies to Company,Geldt voor Bedrijf
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231,Cannot cancel because submitted Stock Entry {0} exists,Kan niet annuleren omdat ingediende Voorraad Invoer {0} bestaat
+DocType: Employee Loan,Disbursement Date,uitbetaling Date
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&#39;Ontvangers&#39; niet gespecificeerd
+DocType: BOM Update Tool,Update latest price in all BOMs,Update de laatste prijs in alle BOM&#39;s
+apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23,Medical Record,Medisch dossier
+DocType: Vehicle,Vehicle,Voertuig
+DocType: Purchase Invoice,In Words,In Woorden
+apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} moet worden ingediend
+DocType: POS Profile,Item Groups,Item Groepen
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Vandaag is {0} 's verjaardag!
+DocType: Sales Order Item,For Production,Voor Productie
+DocType: Payment Request,payment_url,payment_url
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186,Please add a Temporary Opening account in Chart of Accounts,Voeg een tijdelijk openstaand account toe in het rekeningschema
+DocType: Customer,Customer Primary Contact,Hoofdcontactpersoon klant
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154,Period Closing Journal,Periode afsluitingsjournaal
+DocType: Project Task,View Task,Bekijk Task
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead%
+DocType: Material Request,MREQ-,MREQ-
+DocType: Payment Schedule,Invoice Portion,Factuurgedeelte
+,Asset Depreciations and Balances,Asset Afschrijvingen en Weegschalen
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370,Amount {0} {1} transferred from {2} to {3},Bedrag {0} {1} overgebracht van {2} naar {3}
+DocType: Sales Invoice,Get Advances Received,Get ontvangen voorschotten
+DocType: Email Digest,Add/Remove Recipients,Toevoegen / verwijderen Ontvangers
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Om dit boekjaar in te stellen als standaard, klik op 'Als standaard instellen'"
+DocType: Production Plan,Include Subcontracted Items,Inclusief uitbestede items
+apps/erpnext/erpnext/projects/doctype/project/project.py +220,Join,Indiensttreding
+apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Tekort Aantal
+apps/erpnext/erpnext/stock/doctype/item/item.py +672,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,De Variant-eigenschappen kunnen niet worden gewijzigd na stocktransactie. U moet een nieuw item maken om dit te doen.
+apps/erpnext/erpnext/stock/doctype/item/item.py +714,Item variant {0} exists with same attributes,Artikel variant {0} bestaat met dezelfde kenmerken
+DocType: Employee Loan,Repay from Salary,Terugbetalen van Loon
+DocType: Leave Application,LAP/,RONDE/
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360,Requesting payment against {0} {1} for amount {2},Betalingsverzoeken tegen {0} {1} van {2} bedrag
+DocType: Salary Slip,Salary Slip,Salarisstrook
+DocType: Lead,Lost Quotation,verloren Offerte
+apps/erpnext/erpnext/utilities/user_progress.py +221,Student Batches,Studentenbatches
+DocType: Pricing Rule,Margin Rate or Amount,Margin Rate of Bedrag
+apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,'Tot Datum' is vereist
+DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Genereren van pakbonnen voor pakketten te leveren. Gebruikt voor pakket nummer, inhoud van de verpakking en het gewicht te melden."
+DocType: Sales Invoice Item,Sales Order Item,Verkooporder Artikel
+DocType: Salary Slip,Payment Days,Betaling Dagen
+DocType: Stock Settings,Convert Item Description to Clean HTML,Itembeschrijving converteren om HTML te wissen
+DocType: Patient,Dormant,Slapend
+DocType: Salary Slip,Total Interest Amount,Totaal rentebedrag
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124,Warehouses with child nodes cannot be converted to ledger,Warehouses met kind nodes kunnen niet worden geconverteerd naar grootboek
+DocType: BOM,Manage cost of operations,Beheer kosten van de operaties
+DocType: Accounts Settings,Stale Days,Stale Days
+DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Als de aangevinkte transacties worden ""Ingediend"", wordt een e-mail pop-up automatisch geopend om een e-mail te sturen naar de bijbehorende ""Contact"" in deze transactie, met de transactie als bijlage. De gebruiker heeft vervolgens de optie om de e-mail wel of niet te verzenden."
+apps/erpnext/erpnext/config/setup.py +14,Global Settings,Global Settings
+DocType: Crop,Row Spacing UOM,Rijafstand UOM
+DocType: Assessment Result Detail,Assessment Result Detail,Assessment Resultaat Detail
+DocType: Employee Education,Employee Education,Werknemer Opleidingen
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Duplicate artikelgroep gevonden in de artikelgroep tafel
+DocType: Land Unit,Parent Land Unit,Parent Land Unit
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1113,It is needed to fetch Item Details.,Het is nodig om Item Details halen.
+DocType: Fertilizer,Fertilizer Name,Meststofnaam
+DocType: Salary Slip,Net Pay,Nettoloon
+DocType: Cash Flow Mapping Accounts,Account,Rekening
+apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serienummer {0} is reeds ontvangen
+,Requested Items To Be Transferred,Aangevraagde Artikelen te Verplaatsen
+DocType: Expense Claim,Vehicle Log,Voertuig log
+DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Aanwezigheid van een koorts (temp&gt; 38,5 ° C of bijgehouden temperatuur&gt; 38 ° C / 100,4 ° F)"
+DocType: Customer,Sales Team Details,Verkoop Team Details
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1352,Delete permanently?,Permanent verwijderen?
+DocType: Expense Claim,Total Claimed Amount,Totaal gedeclareerd bedrag
+apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potentiële mogelijkheden voor verkoop.
+DocType: Shareholder,Folio no.,Folio nr.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246,Invalid {0},Ongeldige {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Ziekteverlof
+DocType: Email Digest,Email Digest,E-mail Digest
+DocType: Delivery Note,Billing Address Name,Factuuradres Naam
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Warenhuizen
+,Item Delivery Date,Item Leveringsdatum
+DocType: Production Plan,Material Requested,Gevraagde materiaal
+DocType: Warehouse,PIN,PIN
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116,Error '{0}' occured. Arguments {1}.,Fout &#39;{0}&#39; opgetreden. Argumenten {1}.
+DocType: Bin,Reserved Qty for sub contract,Gereserveerde hoeveelheid voor subcontract
+DocType: Patient Service Unit,Patinet Service Unit,Patinet service-eenheid
+DocType: Sales Invoice,Base Change Amount (Company Currency),Base Change Bedrag (Company Munt)
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Geen boekingen voor de volgende magazijnen
+apps/erpnext/erpnext/projects/doctype/project/project.js +95,Save the document first.,Sla het document eerst.
+apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},Alleen {0} op voorraad voor artikel {1}
+DocType: Account,Chargeable,Aan te rekenen
+DocType: Company,Change Abbreviation,Afkorting veranderen
+apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66,Pay {0} {1},Betaal {0} {1}
+DocType: Expense Claim Detail,Expense Date,Kosten Datum
+DocType: Item,Max Discount (%),Max Korting (%)
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Kredietdagen mogen geen negatief getal zijn
+apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Laatste Orderbedrag
+DocType: Cash Flow Mapper,e.g Adjustments for:,bijv. aanpassingen voor:
+apps/erpnext/erpnext/stock/doctype/item/item.py +275," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Voorbeeld behouden is gebaseerd op batch, controleer Has Batch No om monster van artikel te behouden"
+DocType: Task,Is Milestone,Is Milestone
+DocType: Delivery Stop,Email Sent To,Email verzonden naar
+DocType: Budget,Warn,Waarschuwen
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Weet je zeker dat je je wilt uitschrijven?
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +812,All items have already been transferred for this Work Order.,Alle items zijn al overgedragen voor deze werkbon.
+DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Eventuele andere opmerkingen, noemenswaardig voor in de boekhouding,"
+DocType: Asset Maintenance,Manufacturing User,Productie Gebruiker
+DocType: Purchase Invoice,Raw Materials Supplied,Grondstoffen Geleverd
+DocType: C-Form,Series,Reeksen
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282,Currency of the price list {0} must be {1} or {2},Valuta van de prijslijst {0} moet {1} of {2} zijn
+DocType: Appraisal,Appraisal Template,Beoordeling Sjabloon
+DocType: Soil Texture,Ternary Plot,Ternary Plot
+DocType: Item Group,Item Classification,Item Classificatie
+DocType: Driver,License Number,Licentienummer
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Business Development Manager
+DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Doel van onderhouds bezoek
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Invoice Patient Registration
+DocType: Crop,Period,periode
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27,General Ledger,Grootboek
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Employee {0} met verlof om {1}
+apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Bekijk Leads
+DocType: Program Enrollment Tool,New Program,nieuw programma
+DocType: Item Attribute Value,Attribute Value,Eigenschap Waarde
+,Itemwise Recommended Reorder Level,Artikelgebaseerde Aanbevolen Bestelniveau
+DocType: Salary Detail,Salary Detail,salaris Detail
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070,Please select {0} first,Selecteer eerst {0}
+DocType: Appointment Type,Physician,Arts
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +891,Batch {0} of Item {1} has expired.,Batch {0} van Item {1} is verlopen.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,overleg
+DocType: Sales Invoice,Commission,commissie
+apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Time Sheet voor de productie.
+apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Subtotaal
+apps/erpnext/erpnext/config/erpnext_integrations.py +18,GoCardless SEPA Mandate,GoCardless SEPA-mandaat
+DocType: Physician,Charges,kosten
+DocType: Production Plan,Get Items For Work Order,Items voor werkorder ophalen
+DocType: Salary Detail,Default Amount,Standaard Bedrag
+DocType: Lab Test Template,Descriptive,Beschrijvend
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,Magazijn niet gevonden in het systeem
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Samenvatting van deze maand
+DocType: Quality Inspection Reading,Quality Inspection Reading,Kwaliteitscontrole Meting
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,'Bevries Voorraden Ouder dan' moet minder dan %d dagen zijn.
+DocType: Tax Rule,Purchase Tax Template,Kopen Tax Template
+apps/erpnext/erpnext/utilities/user_progress.py +48,Set a sales goal you'd like to achieve for your company.,Stel een verkoopdoel dat u voor uw bedrijf wilt bereiken.
+,Project wise Stock Tracking,Projectgebaseerde Aandelenhandel
+DocType: GST HSN Code,Regional,Regionaal
+apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratorium
+DocType: Stock Entry Detail,Actual Qty (at source/target),Werkelijke Aantal (bij de bron / doel)
+DocType: Item Customer Detail,Ref Code,Ref Code
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Klantengroep is verplicht in het POS-profiel
+apps/erpnext/erpnext/config/hr.py +12,Employee records.,Werknemer regel.
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Please set Next Depreciation Date,Stel Volgende Afschrijvingen Date
+DocType: HR Settings,Payroll Settings,Loonadministratie Instellingen
+apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Match niet-gekoppelde facturen en betalingen.
+DocType: POS Settings,POS Settings,POS-instellingen
+apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Plaats bestelling
+DocType: Email Digest,New Purchase Orders,Nieuwe Inkooporders
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Root kan niet een bovenliggende kostenplaats hebben
+apps/erpnext/erpnext/public/js/stock_analytics.js +54,Select Brand...,Selecteer merk ...
+apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Non-profit (bèta)
+apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Trainingsgebeurtenissen / resultaten
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Cumulatieve afschrijvingen per
+DocType: Sales Invoice,C-Form Applicable,C-Form Toepasselijk
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438,Operation Time must be greater than 0 for Operation {0},Operatie tijd moet groter zijn dan 0 voor de operatie zijn {0}
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107,Warehouse is mandatory,Magazijn is verplicht
+DocType: Shareholder,Address and Contacts,Adres en Contacten
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Kan website niet maken
+DocType: Soil Analysis,Mg/K,Mg / K
+DocType: UOM Conversion Detail,UOM Conversion Detail,Eenheid Omrekeningsfactor Detail
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924,Retention Stock Entry already created or Sample Quantity not provided,Retentie Stock Entry al gemaakt of Sample Quantity niet verstrekt
+DocType: Program,Program Abbreviation,programma Afkorting
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Kosten worden bijgewerkt in Kwitantie tegen elk item
+DocType: Warranty Claim,Resolved By,Opgelost door
+DocType: Bank Guarantee,Start Date,Startdatum
+apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Toewijzen bladeren voor een periode .
+apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Cheques en Deposito verkeerd ontruimd
+apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Rekening {0}: U kunt niet de rekening zelf toewijzen als bovenliggende rekening
+DocType: Purchase Invoice Item,Price List Rate,Prijslijst Tarief
+apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Maak een offerte voor de klant
+DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Toon &quot;Op voorraad&quot; of &quot;Niet op voorraad&quot; op basis van de beschikbare voorraad in dit magazijn.
+apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Stuklijsten
+DocType: Item,Average time taken by the supplier to deliver,De gemiddelde tijd die door de leverancier te leveren
+DocType: Sample Collection,Collected By,Verzameld door
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,assessment Resultaat
+DocType: Hotel Room Package,Hotel Room Package,Hotelkamerarrangement
+apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Uren
+DocType: Project,Expected Start Date,Verwachte startdatum
+DocType: Purchase Invoice,04-Correction in Invoice,04-correctie op factuur
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963,Work Order already created for all items with BOM,Werkorder al gemaakt voor alle artikelen met Stuklijst
+apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Variant Details Rapport
+DocType: Setup Progress Action,Setup Progress Action,Setup Progress Action
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Prijslijst kopen
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Artikel verwijderen als de kosten niet van toepassing zijn op dat artikel
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Selecteer Onderhoudsstatus als voltooid of verwijder de voltooiingsdatum
+DocType: Supplier,Default Payment Terms Template,Standaard betalingsvoorwaarden sjabloon
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Transactie valuta moet hetzelfde zijn als Payment Gateway valuta
+DocType: Payment Entry,Receive,Ontvangen
+apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,citaten:
+DocType: Maintenance Visit,Fully Completed,Volledig afgerond
+apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% voltooid
+DocType: Employee,Educational Qualification,Educatieve Kwalificatie
+DocType: Workstation,Operating Costs,Bedrijfskosten
+DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Actie als gezamenlijke maandelijkse budget overschreden
+DocType: Subscription,Submit on creation,Toevoegen aan de creatie
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483,Currency for {0} must be {1},Munt voor {0} moet {1}
+DocType: Asset,Disposal Date,verwijdering Date
+DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","Emails worden meegedeeld aan alle actieve werknemers van het bedrijf worden verzonden op het opgegeven uur, als ze geen vakantie. Samenvatting van de reacties zal worden verzonden om middernacht."
+DocType: Employee Leave Approver,Employee Leave Approver,Werknemer Verlof Fiatteur
+apps/erpnext/erpnext/stock/doctype/item/item.py +510,Row {0}: An Reorder entry already exists for this warehouse {1},Rij {0}: Er bestaat al een nabestelling voor dit magazijn {1}
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Kan niet als verloren instellen, omdat offerte is gemaakt."
+apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,training Terugkoppeling
+DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Leveranciers Scorecard Criteria
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Selecteer Start- en Einddatum voor Artikel {0}
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Natuurlijk is verplicht in de rij {0}
+apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Tot Datum kan niet eerder zijn dan Van Datum
+DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DocType
+DocType: Cash Flow Mapper,Section Footer,Sectie voettekst
+apps/erpnext/erpnext/stock/doctype/item/item.js +304,Add / Edit Prices,Toevoegen / bewerken Prijzen
+DocType: Batch,Parent Batch,Ouderlijk Batch
+DocType: Batch,Parent Batch,Ouderlijk Batch
+DocType: Cheque Print Template,Cheque Print Template,Cheque Print Template
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Kostenplaatsenschema
+DocType: Lab Test Template,Sample Collection,Sample Collection
+,Requested Items To Be Ordered,Aangevraagde Artikelen in te kopen
+apps/erpnext/erpnext/public/js/hub/hub_page.js +137,My Orders,Mijn Bestellingen
+DocType: Price List,Price List Name,Prijslijst Naam
+DocType: BOM,Manufacturing,Productie
+,Ordered Items To Be Delivered,Bestelde artikelen te leveren
+DocType: Account,Income,Inkomsten
+DocType: Industry Type,Industry Type,Industrie Type
+apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Er is iets fout gegaan!
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105,Warning: Leave application contains following block dates,Waarschuwing: Verlof applicatie bevat volgende blok data
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275,Sales Invoice {0} has already been submitted,Verkoopfactuur {0} is al ingediend
+DocType: Supplier Scorecard Scoring Criteria,Score,partituur
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Boekjaar {0} bestaat niet
+DocType: Asset Maintenance Log,Completion Date,Voltooiingsdatum
+DocType: Purchase Invoice Item,Amount (Company Currency),Bedrag (Company Munt)
+DocType: Agriculture Analysis Criteria,Agriculture User,Landbouw Gebruiker
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Geldig tot datum kan niet vóór de transactiedatum zijn
+apps/erpnext/erpnext/stock/stock_ledger.py +381,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} eenheden van {1} die nodig zijn in {2} op {3} {4} te {5} om deze transactie te voltooien.
+DocType: Fee Schedule,Student Category,student Categorie
+DocType: Announcement,Student,Student
+apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Organisatie -eenheid (departement) meester.
+DocType: Shipping Rule,Shipping Rule Type,Verzendregel Type
+apps/erpnext/erpnext/utilities/user_progress.py +239,Go to Rooms,Ga naar kamers
+apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Vul bericht in alvorens te verzenden
+DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICATE VOOR LEVERANCIER
+DocType: Email Digest,Pending Quotations,In afwachting van Citaten
+apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-Sale Profile
+apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25,{0} should be a value between 0 and 100,{0} moet een waarde tussen 0 en 100 zijn
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +94,Next Depreciation Date cannot be before Available-for-use Date,De volgende waarderingsdatum kan niet eerder zijn dan de datum van gebruik voor gebruik
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Leningen zonder onderpand
+DocType: Cost Center,Cost Center Name,Kostenplaats Naam
+DocType: Student,B+,B +
+DocType: HR Settings,Max working hours against Timesheet,Max werkuren tegen Timesheet
+DocType: Maintenance Schedule Detail,Scheduled Date,Geplande Datum
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +228,Total Paid Amt,Totale betaalde Amt
+DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Bericht van meer dan 160 tekens worden opgesplitst in meerdere berichten
+DocType: Purchase Receipt Item,Received and Accepted,Ontvangen en geaccepteerd
+DocType: Hub Settings,Company and Seller Profile,Bedrijf en verkoperprofiel
+,GST Itemised Sales Register,GST Itemized Sales Register
+DocType: Soil Texture,Silt Loam,Silt Loam
+,Serial No Service Contract Expiry,Serienummer Service Contract Afloop
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,U kunt niet hetzelfde bedrag crediteren en debiteren op hetzelfde moment
+DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,De volwassen puls is overal tussen 50 en 80 slaats per minuut.
+DocType: Naming Series,Help HTML,Help HTML
+DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Creation Tool
+DocType: Item,Variant Based On,Variant gebaseerd op
+apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Totaal toegewezen gewicht moet 100% zijn. Het is {0}
+apps/erpnext/erpnext/utilities/user_progress.py +109,Your Suppliers,Uw Leveranciers
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Corrigeer alstublieft de
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,"Kan niet als verloren instellen, omdat er al een verkooporder is gemaakt."
+DocType: Request for Quotation Item,Supplier Part No,Leverancier Part No
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Kan niet aftrekken als categorie is voor &#39;Valuation&#39; of &#39;Vaulation en Total&#39;
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377,Received From,Gekregen van
+DocType: Lead,Converted,Omgezet
+DocType: Item,Has Serial No,Heeft Serienummer
+DocType: Employee,Date of Issue,Datum van afgifte
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Conform de Aankoop Instellingen indien Aankoopbon Vereist == 'JA', dient de gebruiker eerst een Aankoopbon voor item {0} aan te maken om een Aankoop Factuur aan te kunnen maken"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Rij # {0}: Stel Leverancier voor punt {1}
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Rij {0}: Aantal uren moet groter zijn dan nul.
+apps/erpnext/erpnext/stock/doctype/item/item.py +195,Website Image {0} attached to Item {1} cannot be found,Website Afbeelding {0} verbonden aan Item {1} kan niet worden gevonden
+DocType: Issue,Content Type,Content Type
+DocType: Asset,Assets,Middelen
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Computer
+DocType: Item,List this Item in multiple groups on the website.,Lijst deze post in meerdere groepen op de website.
+DocType: Payment Term,Due Date Based On,Vervaldatum op basis van
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,Please set default customer group and territory in Selling Settings,Stel de standaard klantgroep en het gebied in de verkoopinstellingen in
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214,{0} {1} does not exist,{0} {1} bestaat niet
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,Kijk Valuta optie om rekeningen met andere valuta toestaan
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88,Item: {0} does not exist in the system,Item: {0} bestaat niet in het systeem
+apps/erpnext/erpnext/accounts/doctype/account/account.py +106,You are not authorized to set Frozen value,U bent niet bevoegd om Bevroren waarde in te stellen
+DocType: Payment Reconciliation,Get Unreconciled Entries,Haal onafgeletterde transacties op
+DocType: Payment Reconciliation,From Invoice Date,Na factuurdatum
+DocType: Healthcare Settings,Laboratory Settings,Laboratoriuminstellingen
+DocType: Patient Appointment,Service Unit,Service-eenheid
+apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Leverancier met succes instellen
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Laat Inning
+apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Wat doet het?
+DocType: Crop,Byproducts,bijproducten
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,Tot Magazijn
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Alle studentenadministratie
+,Average Commission Rate,Gemiddelde Commissie Rate
+DocType: Share Balance,No of Shares,Aantal aandelen
+apps/erpnext/erpnext/stock/doctype/item/item.py +448,'Has Serial No' can not be 'Yes' for non-stock item,'Heeft Serienummer' kan niet 'ja' zijn voor niet- voorraad artikel
+apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59,Select Status,Selecteer Status
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Aanwezigheid kan niet aangemerkt worden voor toekomstige data
+DocType: Pricing Rule,Pricing Rule Help,Prijsbepalingsregel Help
+DocType: School House,House Name,Huis naam
+DocType: Fee Schedule,Total Amount per Student,Totaal Bedrag per student
+DocType: Purchase Taxes and Charges,Account Head,Hoofdrekening
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,elektrisch
+apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Voeg de rest van uw organisatie als uw gebruikers. U kunt ook toevoegen uitnodigen klanten naar uw portal door ze toe te voegen vanuit Contacten
+DocType: Stock Entry,Total Value Difference (Out - In),Totale waarde Verschil (Out - In)
+DocType: Grant Application,Requested Amount,Gevraagde bedrag
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Rij {0}: Wisselkoers is verplicht
+apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},Gebruikers-ID niet ingesteld voor Werknemer {0}
+DocType: Vehicle,Vehicle Value,Voertuig waarde
+DocType: Crop Cycle,Detected Diseases,Gedetecteerde ziekten
+DocType: Stock Entry,Default Source Warehouse,Standaard Bronmagazijn
+DocType: Item,Customer Code,Klantcode
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Verjaardagsherinnering voor {0}
+DocType: Asset Maintenance Task,Last Completion Date,Laatste voltooiingsdatum
+apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Dagen sinds laatste Order
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365,Debit To account must be a Balance Sheet account,Debitering van rekening moet een balansrekening zijn
+DocType: Buying Settings,Naming Series,Benoemen Series
+DocType: GoCardless Settings,GoCardless Settings,GoCardless-instellingen
+DocType: Leave Block List,Leave Block List Name,Laat Block List Name
+apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Insurance Startdatum moet kleiner zijn dan de verzekering einddatum
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Voorraad Activa
+DocType: Restaurant,Active Menu,Actief menu
+DocType: Target Detail,Target Qty,Doel Aantal
+DocType: Shopping Cart Settings,Checkout Settings,Afrekenen Instellingen
+DocType: Student Attendance,Present,Presenteer
+apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Vrachtbrief {0} mag niet worden ingediend
+DocType: Notification Control,Sales Invoice Message,Verkoopfactuur bericht
+apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Sluiten account {0} moet van het type aansprakelijkheid / Equity zijn
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325,Salary Slip of employee {0} already created for time sheet {1},Loonstrook van de werknemer {0} al gemaakt voor urenregistratie {1}
+DocType: Vehicle Log,Odometer,Kilometerteller
+DocType: Production Plan Item,Ordered Qty,Besteld Aantal
+apps/erpnext/erpnext/stock/doctype/item/item.py +744,Item {0} is disabled,Punt {0} is uitgeschakeld
+DocType: Stock Settings,Stock Frozen Upto,Voorraad Bevroren Tot
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930,BOM does not contain any stock item,BOM geen voorraad artikel bevatten
+DocType: Chapter,Chapter Head,Hoofdstuk hoofd
+DocType: Payment Term,Month(s) after the end of the invoice month,Maand (en) na het einde van de factuurmaand
+apps/erpnext/erpnext/config/projects.py +24,Project activity / task.,Project activiteit / taak.
+DocType: Vehicle Log,Refuelling Details,Tanken Details
+apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Genereer Salarisstroken
+apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25,Lab result datetime cannot be before testing datetime,Lab-resultaat datetime kan niet vóór het testen van datetime zijn
+DocType: POS Profile,Allow user to edit Discount,Sta de gebruiker toe om Korting te bewerken
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55,Get customers from,Haal klanten uit
+DocType: Purchase Invoice Item,Include Exploded Items,Exploded Items opnemen
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45,"Buying must be checked, if Applicable For is selected as {0}","Aankopen moeten worden gecontroleerd, indien ""VAN TOEPASSING VOOR"" is geselecteerd als {0}"
+apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Korting moet minder dan 100 zijn
+DocType: Shipping Rule,Restrict to Countries,Beperken tot landen
+DocType: Purchase Invoice,Write Off Amount (Company Currency),Af te schrijven bedrag (Bedrijfsvaluta)
+DocType: Sales Invoice Timesheet,Billing Hours,Billing Hours
+DocType: Project,Total Sales Amount (via Sales Order),Totaal verkoopbedrag (via klantorder)
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +551,Default BOM for {0} not found,Standaard BOM voor {0} niet gevonden
+apps/erpnext/erpnext/stock/doctype/item/item.py +514,Row #{0}: Please set reorder quantity,Rij # {0}: Stel nabestelling hoeveelheid
+apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Tik op items om ze hier toe te voegen
+DocType: Fees,Program Enrollment,programma Inschrijving
+DocType: Share Transfer,To Folio No,Naar Folio Nee
+DocType: Landed Cost Voucher,Landed Cost Voucher,Vrachtkosten Voucher
+apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Stel {0} in
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} is inactieve student
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} is inactieve student
+DocType: Employee,Health Details,Gezondheid Details
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Om een betalingsaanvraag te maken is referentie document vereist
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Om een betalingsaanvraag te maken is referentie document vereist
+DocType: Soil Texture,Sandy Clay,Zanderige klei
+DocType: Grant Application,Assessment  Manager,Assessment Manager
+DocType: Payment Entry,Allocate Payment Amount,Toewijzen Betaling Bedrag
+DocType: Employee External Work History,Salary,Salaris
+DocType: Serial No,Delivery Document Type,Levering Soort document
+DocType: Sales Order,Partly Delivered,Deels geleverd
+DocType: Item Variant Settings,Do not update variants on save,Wijzig geen varianten bij opslaan
+DocType: Email Digest,Receivables,Debiteuren
+DocType: Lead Source,Lead Source,Lead Bron
+DocType: Customer,Additional information regarding the customer.,Aanvullende informatie over de klant.
+DocType: Quality Inspection Reading,Reading 5,Meting 5
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} is geassocieerd met {2}, maar Party Account is {3}"
+apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Bekijk Lab Tests
+DocType: Purchase Invoice,Y,Y
+DocType: Maintenance Visit,Maintenance Date,Onderhoud Datum
+DocType: Purchase Invoice Item,Rejected Serial No,Afgewezen Serienummer
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,Jaar begindatum of einddatum overlapt met {0}. Om te voorkomen dat stel bedrijf
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +122,Please mention the Lead Name in Lead {0},Vermeld alstublieft de naam van de lood in lood {0}
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Startdatum moet kleiner zijn dan einddatum voor Artikel {0}
+DocType: Item,"Example: ABCD.#####
+If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Voorbeeld: ABCD.##### Als reeks is ingesteld en het serienummer is niet vermeld in een transactie, dan zal een serienummer automatisch worden aangemaakt, op basis van deze reeks. Als u altijd expliciet een serienummer wilt vemelden voor dit artikel bij een transatie, laat dan dit veld leeg."
+DocType: Upload Attendance,Upload Attendance,Aanwezigheid uploaden
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +604,BOM and Manufacturing Quantity are required,BOM en Productie Hoeveelheid nodig
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50,Ageing Range 2,Vergrijzing Range 2
+DocType: SG Creation Tool Course,Max Strength,Max Strength
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Voorinstellingen installeren
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85,No Delivery Note selected for Customer {},Geen leveringsbewijs geselecteerd voor klant {}
+apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25,BOM replaced,Stuklijst vervangen
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1053,Select Items based on Delivery Date,Selecteer items op basis van leveringsdatum
+DocType: Grant Application,Has any past Grant Record,Heeft een eerdere Grant Record
+,Sales Analytics,Verkoop analyse
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127,Available {0},Beschikbaar {0}
+,Prospects Engaged But Not Converted,Vooruitzichten betrokken maar niet omgezet
+,Prospects Engaged But Not Converted,Vooruitzichten betrokken maar niet omgezet
+DocType: Manufacturing Settings,Manufacturing Settings,Productie Instellingen
+apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Het opzetten van e-mail
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile No
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Vul de standaard valuta in in Bedrijfsstam
+DocType: Stock Entry Detail,Stock Entry Detail,Voorraadtransactie Detail
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Dagelijkse herinneringen
+DocType: Products Settings,Home Page is Products,Startpagina is Producten
+,Asset Depreciation Ledger,Asset Afschrijvingen Ledger
+apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91,Tax Rule Conflicts with {0},Belasting Regel Conflicten met {0}
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Nieuwe Rekening Naam
+DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Grondstoffen Leveringskosten
+DocType: Selling Settings,Settings for Selling Module,Instellingen voor het verkopen van Module
+DocType: Hotel Room Reservation,Hotel Room Reservation,Hotelkamerreservering
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Klantenservice
+DocType: BOM,Thumbnail,Miniatuur
+DocType: Item Customer Detail,Item Customer Detail,Artikel Klant Details
+apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Aanbieding kandidaat een baan.
+DocType: Notification Control,Prompt for Email on Submission of,Vragen om E-mail op Indiening van
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Totaal toegewezen bladeren zijn meer dan dagen in de periode
+DocType: Land Unit,Linked Soil Analysis,Linked Soil Analysis
+DocType: Pricing Rule,Percentage,Percentage
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Artikel {0} moet een voorraadartikel zijn
+DocType: Manufacturing Settings,Default Work In Progress Warehouse,Standaard Work In Progress Warehouse
+apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Standaardinstellingen voor boekhoudkundige transacties.
+DocType: Maintenance Visit,MV,MV
+DocType: Restaurant,Default Tax Template,Standaard belasting sjabloon
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66,{0} Students have been enrolled,{0} Studenten zijn ingeschreven
+DocType: Fees,Student Details,Student Details
+DocType: Purchase Invoice Item,Stock Qty,Aantal voorraad
+DocType: Employee Loan,Repayment Period in Months,Terugbetaling Periode in maanden
+apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Fout: geen geldig id?
+DocType: Naming Series,Update Series Number,Serienummer bijwerken
+DocType: Account,Equity,Vermogen
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: ""winst- en verliesrekening"" type account {2} niet toegestaan in Opening Ingave"
+DocType: Sales Order,Printing Details,Afdrukken Details
+DocType: Task,Closing Date,Afsluitingsdatum
+DocType: Sales Order Item,Produced Quantity,Geproduceerd Aantal
+DocType: Timesheet,Work Detail,Werkdetails
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Ingenieur
+DocType: Journal Entry,Total Amount Currency,Totaal bedrag Currency
+apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Zoeken Sub Assemblies
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Artikelcode vereist bij rijnummer {0}
+DocType: GST Account,SGST Account,SGST-account
+apps/erpnext/erpnext/utilities/user_progress.py +154,Go to Items,Ga naar Items
+DocType: Sales Partner,Partner Type,Partner Type
+DocType: Purchase Taxes and Charges,Actual,Werkelijk
+DocType: Restaurant Menu,Restaurant Manager,Restaurant manager
+DocType: Authorization Rule,Customerwise Discount,Klantgebaseerde Korting
+apps/erpnext/erpnext/config/projects.py +46,Timesheet for tasks.,Timesheet voor taken.
+DocType: Purchase Invoice,Against Expense Account,Tegen Kostenrekening
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282,Installation Note {0} has already been submitted,Installatie Opmerking {0} is al ingediend
+DocType: Bank Reconciliation,Get Payment Entries,Krijg Betaling Entries
+DocType: Quotation Item,Against Docname,Tegen Docname
+DocType: SMS Center,All Employee (Active),Alle medewerkers (Actief)
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Bekijk nu
+DocType: BOM,Raw Material Cost,Grondstofprijzen
+DocType: Item Reorder,Re-Order Level,Re-order Niveau
+apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,Gantt-diagram
+DocType: Crop Cycle,Cycle Type,Type cyclus
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Deeltijds
+DocType: Employee,Applicable Holiday List,Toepasselijk Holiday Lijst
+DocType: Employee,Cheque,Cheque
+DocType: Training Event,Employee Emails,Medewerkers e-mails
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60,Series Updated,Reeks bijgewerkt
+apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Report Type is mandatory,Rapport type is verplicht
+DocType: Item,Serial Number Series,Serienummer Reeksen
+apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Magazijn is verplicht voor voorraadartikel {0} in rij {1}
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Retail & Groothandel
+DocType: Issue,First Responded On,Eerst gereageerd op
+DocType: Website Item Group,Cross Listing of Item in multiple groups,Kruis Notering van Punt in meerdere groepen
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Boekjaar Startdatum en Boekjaar Einddatum zijn al ingesteld voor het fiscale jaar {0}
+DocType: Projects Settings,Ignore User Time Overlap,Negeer User Time Overlap
+apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113,Clearance Date updated,Ontruiming Geactualiseerd
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Split Batch
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Split Batch
+DocType: Stock Settings,Batch Identification,Batchidentificatie
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,Succesvol Afgeletterd
+DocType: Request for Quotation Supplier,Download PDF,Download PDF
+DocType: Work Order,Planned End Date,Geplande Einddatum
+DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Verborgen lijst met de lijst met contacten gekoppeld aan Shareholder
+apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Donor Type informatie.
+DocType: Request for Quotation,Supplier Detail,Leverancier Detail
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Fout in formule of aandoening: {0}
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +108,Invoiced Amount,Factuurbedrag
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Criteriumgewichten moeten maximaal 100%
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Aanwezigheid
+apps/erpnext/erpnext/public/js/pos/pos.html +115,Stock Items,Stock items
+DocType: BOM,Materials,Materialen
+DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Indien niet gecontroleerd, wordt de lijst worden toegevoegd aan elk Department waar het moet worden toegepast."
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111,Creating {0},{0} maken
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Bron en Target Warehouse kan niet hetzelfde zijn
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +588,Posting date and posting time is mandatory,Plaatsingsdatum en -tijd is verplicht
+apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Belasting sjabloon voor inkooptransacties .
+,Item Prices,Artikelprijzen
+DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,In Woorden zijn zichtbaar zodra u de Inkooporder opslaat
+DocType: Period Closing Voucher,Period Closing Voucher,Periode Closing Voucher
+DocType: Consultation,Review Details,Details herzien
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185,The shareholder does not belong to this company,De aandeelhouder behoort niet tot dit bedrijf
+DocType: Dosage Form,Dosage Form,Doseringsformulier
+apps/erpnext/erpnext/config/selling.py +67,Price List master.,Prijslijst stam.
+DocType: Task,Review Date,Herzieningsdatum
+DocType: BOM,Allow Alternative Item,Toestaan alternatief item
+DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serie voor de afschrijving van de waardevermindering
+DocType: Membership,Member Since,Lid sinds
+DocType: Purchase Invoice,Advance Payments,Advance Payments
+DocType: Purchase Taxes and Charges,On Net Total,Op Netto Totaal
+apps/erpnext/erpnext/controllers/item_variant.py +92,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Waarde voor kenmerk {0} moet binnen het bereik van {1} tot {2} in de stappen van {3} voor post {4}
+DocType: Restaurant Reservation,Waitlisted,wachtlijst
+apps/erpnext/erpnext/accounts/doctype/account/account.py +124,Currency can not be changed after making entries using some other currency,Valuta kan niet na het maken van data met behulp van een andere valuta worden veranderd
+DocType: Shipping Rule,Fixed,vast
+DocType: Vehicle Service,Clutch Plate,clutch Plate
+DocType: Company,Round Off Account,Afronden Account
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Administratie Kosten
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Consulting
+DocType: Customer Group,Parent Customer Group,Bovenliggende klantgroep
+DocType: Journal Entry,Subscription,Abonnement
+DocType: Purchase Invoice,Contact Email,Contact E-mail
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Fee Creation In afwachting
+DocType: Appraisal Goal,Score Earned,Verdiende Score
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241,Notice Period,Opzegtermijn
+DocType: Asset Category,Asset Category Name,Asset Categorie Naam
+apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Dit is een basis regio en kan niet worden bewerkt .
+apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Nieuwe Sales Person Naam
+DocType: Packing Slip,Gross Weight UOM,Bruto Gewicht Eenheid
+DocType: Asset Maintenance Task,Preventive Maintenance,Preventief onderhoud
+DocType: Delivery Note Item,Against Sales Invoice,Tegen Sales Invoice
+DocType: Purchase Invoice,07-Others,07-Anderen
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +156,Please enter serial numbers for serialized item ,Voer alstublieft de serienummers in voor het serienummer
+DocType: Bin,Reserved Qty for Production,Aantal voorbehouden voor productie
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureNum,EcritureNum
+DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Verlaat het vinkje als u geen batch wilt overwegen tijdens het maken van cursussen op basis van cursussen.
+DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Verlaat het vinkje als u geen batch wilt overwegen tijdens het maken van cursussen op basis van cursussen.
+DocType: Asset,Frequency of Depreciation (Months),Frequentie van afschrijvingen (Maanden)
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500,Credit Account,Credit Account
+DocType: Landed Cost Item,Landed Cost Item,Vrachtkosten Artikel
+apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Toon nulwaarden
+DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Hoeveelheid product verkregen na productie / herverpakken van de gegeven hoeveelheden grondstoffen
+DocType: Lab Test,Test Group,Testgroep
+DocType: Payment Reconciliation,Receivable / Payable Account,Vorderingen / Crediteuren Account
+DocType: Delivery Note Item,Against Sales Order Item,Tegen Sales Order Item
+DocType: Company,Company Logo,Bedrijfslogo
+apps/erpnext/erpnext/stock/doctype/item/item.py +709,Please specify Attribute Value for attribute {0},Geef aub attribuut Waarde voor kenmerk {0}
+DocType: Item,Default Warehouse,Standaard Magazijn
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Budget kan niet tegen Group rekening worden toegewezen {0}
+DocType: Healthcare Settings,Patient Registration,Patiëntregistratie
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Vul bovenliggende kostenplaats in
+DocType: Delivery Note,Print Without Amount,Printen zonder Bedrag
+apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,afschrijvingen Date
+,Work Orders in Progress,Werkorders in uitvoering
+DocType: Issue,Support Team,Support Team
+apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Vervallen (in dagen)
+DocType: Appraisal,Total Score (Out of 5),Totale Score (van de 5)
+DocType: Fee Structure,FS.,FS.
+DocType: Student Attendance Tool,Batch,Partij
+DocType: Donor,Donor Type,Donor Type
+apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Balans
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Selecteer het bedrijf
+DocType: Room,Seating Capacity,zitplaatsen
+DocType: Issue,ISS-,ISS
+DocType: Lab Test Groups,Lab Test Groups,Lab Testgroepen
+DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via declaraties)
+DocType: GST Settings,GST Summary,GST Samenvatting
+apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,Schakel standaard inkomende account in voordat u Daily Work Summary Group maakt
+DocType: Assessment Result,Total Score,Totale score
+DocType: Journal Entry,Debit Note,Debetnota
+DocType: Stock Entry,As per Stock UOM,Per Stock Verpakking
+apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Niet Verlopen
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49,ValidDate,Geldige datum
+DocType: Student Log,Achievement,Prestatie
+DocType: Batch,Source Document Type,Bron Document Type
+DocType: Batch,Source Document Type,Bron Document Type
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Volgende cursusroosters zijn gemaakt
+DocType: Journal Entry,Total Debit,Totaal Debet
+DocType: Manufacturing Settings,Default Finished Goods Warehouse,Standaard Finished Goods Warehouse
+apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108,Please select Patient,Selecteer alstublieft Patiënt
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Verkoper
+DocType: Hotel Room Package,Amenities,voorzieningen
+apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Begroting en Cost Center
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Meerdere standaard betalingswijze is niet toegestaan
+apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,voor de
+,Appointment Analytics,Benoemingsanalyse
+DocType: Vehicle Service,Half Yearly,Halfjaarlijkse
+DocType: Lead,Blog Subscriber,Blog Abonnee
+DocType: Guardian,Alternate Number,Alternate Number
+DocType: Healthcare Settings,Consultations in valid days,Overleg in geldige dagen
+DocType: Assessment Plan Criteria,Maximum Score,maximum Score
+apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Regels maken om transacties op basis van waarden te beperken.
+DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Cash Flow Mapping Accounts
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Groepsrolnummer
+DocType: Batch,Manufacturing Date,Fabricage datum
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Fee Creation mislukt
+DocType: Opening Invoice Creation Tool,Create Missing Party,Ontbrekende partij maken
+DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Verlaat leeg als u studentengroepen per jaar maakt
+DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Verlaat leeg als u studentengroepen per jaar maakt
+DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Indien aangevinkt, Totaal niet. van Werkdagen zal omvatten feestdagen, en dit zal de waarde van het salaris per dag te verminderen"
+DocType: Purchase Invoice,Total Advance,Totaal Voorschot
+apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Sjablooncode wijzigen
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,De Term Einddatum kan niet eerder dan de Term startdatum. Corrigeer de data en probeer het opnieuw.
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Quot Count
+apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Quot Count
+,BOM Stock Report,BOM Stock Report
+DocType: Stock Reconciliation Item,Quantity Difference,Aantal Verschil
+DocType: Employee Advance,EA-,EA-
+DocType: Opportunity Item,Basic Rate,Basis Tarief
+DocType: GL Entry,Credit Amount,Credit Bedrag
+DocType: Cheque Print Template,Signatory Position,ondertekenaar Position
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173,Set as Lost,Instellen als Verloren
+DocType: Timesheet,Total Billable Hours,Totaal factureerbare uren
+apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Betaling Ontvangst Opmerking
+apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Dit is gebaseerd op transacties tegen deze klant. Zie tijdlijn hieronder voor meer informatie
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Rij {0}: Toegewezen bedrag {1} moet kleiner zijn dan of gelijk aan Payment Entry bedrag {2}
+DocType: Program Enrollment Tool,New Academic Term,Nieuwe academische termijn
+,Course wise Assessment Report,Cursusverstandig beoordelingsrapport
+DocType: Purchase Invoice,Availed ITC State/UT Tax,Bezet ITC State / UT Tax
+DocType: Tax Rule,Tax Rule,Belasting Regel
+DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Handhaaf zelfde tarief gedurende verkoopcyclus
+DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Plan tijd logs buiten Workstation Arbeidstijdenwet.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr. {0} heeft geen Physician Schedule. Voeg het toe in Physician-master
+apps/erpnext/erpnext/public/js/pos/pos.html +98,Customers in Queue,Klanten in de wachtrij
+DocType: Driver,Issuing Date,Afgifte datum
+DocType: Student,Nationality,Nationaliteit
+apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109,Submit this Work Order for further processing.,Dien deze werkbon in voor verdere verwerking.
+,Items To Be Requested,Aan te vragen artikelen
+DocType: Purchase Order,Get Last Purchase Rate,Get Laatst Purchase Rate
+DocType: Company,Company Info,Bedrijfsinformatie
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1385,Select or add new customer,Selecteer of voeg nieuwe klant
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173,Cost center is required to book an expense claim,Kostenplaats nodig is om een declaratie te boeken
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Toepassing van kapitaal (Activa)
+apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Dit is gebaseerd op de aanwezigheid van deze werknemer
+DocType: Assessment Result,Summary,Overzicht
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Mark Attendance
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494,Debit Account,Debetrekening
+DocType: Fiscal Year,Year Start Date,Jaar Startdatum
+DocType: Attendance,Employee Name,Werknemer Naam
+DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restaurantbestelling Item invoeren
+DocType: Purchase Invoice,Rounded Total (Company Currency),Afgerond Totaal (Bedrijfsvaluta)
+apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Cannot covert to Group because Account Type is selected.,Kan niet omzetten naar groep omdat accounttype is geselecteerd.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} is gewijzigd. Vernieuw aub.
+DocType: Leave Block List,Stop users from making Leave Applications on following days.,Weerhoud gebruikers van het maken van verlofaanvragen op de volgende dagen.
+DocType: Asset Maintenance Team,Maintenance Team Members,Onderhoudsteamleden
+apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Aankoopbedrag
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Leverancier Offerte {0} aangemaakt
+apps/erpnext/erpnext/accounts/report/financial_statements.py +103,End Year cannot be before Start Year,Eindjaar kan niet voor Start Jaar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Employee Benefits,Employee Benefits
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264,Packed quantity must equal quantity for Item {0} in row {1},Verpakt hoeveelheid moet hoeveelheid die gelijk is voor post {0} in rij {1}
+DocType: Work Order,Manufactured Qty,Geproduceerd Aantal
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78,The shares don't exist with the {0},De shares bestaan niet met de {0}
+apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Invoice Created
+DocType: Asset,Out of Order,Out of Order
+DocType: Purchase Receipt Item,Accepted Quantity,Geaccepteerd Aantal
+DocType: Projects Settings,Ignore Workstation Time Overlap,Negeer overlapping werkstationtijd
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Stel een standaard Holiday-lijst voor Employee {0} of Company {1}
+apps/erpnext/erpnext/accounts/party.py +30,{0}: {1} does not exists,{0}: {1} bestaat niet
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Selecteer batchnummers
+apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Factureren aan Klanten
+apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Project Id
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Rij Geen {0}: Bedrag kan niet groter zijn dan afwachting Bedrag tegen Expense conclusie {1} zijn. In afwachting van Bedrag is {2}
+DocType: Patient Service Unit,Medical Administrator,Medisch beheerder
+DocType: Assessment Plan,Schedule,Plan
+DocType: Account,Parent Account,Bovenliggende rekening
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +295,Available,beschikbaar
+DocType: Quality Inspection Reading,Reading 3,Meting 3
+DocType: Stock Entry,Source Warehouse Address,Bron magazijnadres
+,Hub,Naaf
+DocType: GL Entry,Voucher Type,Voucher Type
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1717,Price List not found or disabled,Prijslijst niet gevonden of uitgeschakeld
+DocType: Student Applicant,Approved,Aangenomen
+apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,prijs
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267,Employee relieved on {0} must be set as 'Left',Werknemer ontslagen op {0} moet worden ingesteld als 'Verlaten'
+DocType: Hub Settings,Last Sync On,Last Sync On
+DocType: Guardian,Guardian,Voogd
+DocType: Item Alternative,Item Alternative,Artikelalternatief
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Stel Naming Series in voor {0} via Setup&gt; Instellingen&gt; Serie benoemen
+DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Ontbrekende klant of leverancier creëren.
+apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Beoordeling {0} gemaakt voor Employee {1} in de bepaalde periode
+DocType: Academic Term,Education,Onderwijs
+apps/erpnext/erpnext/public/js/pos/pos.html +89,Del,del
+DocType: Selling Settings,Campaign Naming By,Campagnenaam gegeven door
+DocType: Employee,Current Address Is,Huidige adres is
+apps/erpnext/erpnext/utilities/user_progress.py +51,Monthly Sales Target (,Maandelijks verkoopdoel (
+DocType: Physician Service Unit Schedule,Physician Service Unit Schedule,Physician Service Unit Schedule
+apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,gemodificeerde
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Optioneel. Stelt bedrijf prijslijst, indien niet opgegeven."
+DocType: Sales Invoice,Customer GSTIN,Klant 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 ,Lijst met gedetecteerde ziekten op het veld. Na selectie voegt het automatisch een lijst met taken toe om de ziekte aan te pakken
+DocType: Asset Repair,Repair Status,Reparatiestatus
+apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Journaalposten.
+DocType: Delivery Note Item,Available Qty at From Warehouse,Aantal beschikbaar bij Van Warehouse
+DocType: POS Profile,Account for Change Amount,Account for Change Bedrag
+DocType: Purchase Invoice,input service,invoerdienst
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Rij {0}: Party / Account komt niet overeen met {1} / {2} in {3} {4}
+DocType: Maintenance Team Member,Maintenance Team Member,Onderhoudsteamlid
+DocType: Agriculture Analysis Criteria,Soil Analysis,Bodemanalyse
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13,Course Code: ,Cursuscode:
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Vul Kostenrekening in
+DocType: Account,Stock,Voorraad
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Rij # {0}: Reference document moet een van Purchase Order, Purchase Invoice of Inboeken zijn"
+DocType: Employee,Current Address,Huidige adres
+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","Als artikel is een variant van een ander item dan beschrijving, afbeelding, prijzen, belastingen etc zal worden ingesteld van de sjabloon, tenzij expliciet vermeld"
+DocType: Serial No,Purchase / Manufacture Details,Inkoop / Productie Details
+DocType: Assessment Group,Assessment Group,assessment Group
+apps/erpnext/erpnext/config/stock.py +333,Batch Inventory,Batch Inventory
+DocType: Employee,Contract End Date,Contract Einddatum
+DocType: Sales Order,Track this Sales Order against any Project,Volg dit Verkooporder tegen elke Project
+DocType: Sales Invoice Item,Discount and Margin,Korting en Marge
+DocType: Lab Test,Prescription,Voorschrift
+DocType: Project,Second Email,Tweede e-mail
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111,Not Available,niet beschikbaar
+DocType: Pricing Rule,Min Qty,min Aantal
+apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Sjabloon uitschakelen
+DocType: GL Entry,Transaction Date,Transactie Datum
+DocType: Production Plan Item,Planned Qty,Gepland Aantal
+apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Tax
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204,For Quantity (Manufactured Qty) is mandatory,Voor Hoeveelheid (Geproduceerd Aantal) is verplicht
+DocType: Stock Entry,Default Target Warehouse,Standaard Doelmagazijn
+DocType: Purchase Invoice,Net Total (Company Currency),Netto Totaal (Bedrijfsvaluta)
+apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Het Jaar Einddatum kan niet eerder dan het jaar startdatum. Corrigeer de data en probeer het opnieuw.
+DocType: Notification Control,Purchase Receipt Message,Ontvangstbevestiging Bericht
+DocType: BOM,Scrap Items,Scrap items
+DocType: Work Order,Actual Start Date,Werkelijke Startdatum
+DocType: Sales Order,% of materials delivered against this Sales Order,% van de geleverde materialen voor deze verkooporder
+apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Work Orders.,Generate Material Requests (MRP) en werkorders.
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Stel de standaard betalingswijze in
+DocType: Grant Application,Withdrawn,teruggetrokken
+DocType: Hub Settings,Hub Settings,Hub Instellingen
+DocType: Project,Gross Margin %,Bruto marge %
+DocType: BOM,With Operations,Met Operations
+apps/erpnext/erpnext/accounts/party.py +259,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Boekingen zijn reeds geboekt in valuta {0} voor bedrijf {1}. Selecteer een vordering of te betalen rekening met valuta {0}.
+DocType: Asset,Is Existing Asset,Is Bestaande Asset
+DocType: Salary Detail,Statistical Component,Statistische Component
+DocType: Salary Detail,Statistical Component,Statistische Component
+DocType: Warranty Claim,If different than customer address,Indien anders dan klantadres
+DocType: Purchase Invoice,Without Payment of Tax,Zonder betaling van belasting
+DocType: BOM Operation,BOM Operation,Stuklijst Operatie
+apps/erpnext/erpnext/config/stock.py +145,Fulfilment,Vervulling
+DocType: Purchase Taxes and Charges,On Previous Row Amount,Aantal van vorige rij
+DocType: Item,Has Expiry Date,Heeft vervaldatum
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +282,Transfer Asset,Transfer Asset
+DocType: POS Profile,POS Profile,POS Profiel
+DocType: Training Event,Event Name,Evenement naam
+DocType: Physician,Phone (Office),Telefoon (kantoor)
+apps/erpnext/erpnext/hooks.py +151,Admission,Toelating
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Opnames voor {0}
+apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Seizoensgebondenheid voor het vaststellen van budgetten, doelstellingen etc."
+DocType: Supplier Scorecard Scoring Variable,Variable Name,Variabele naam
+apps/erpnext/erpnext/stock/get_item_details.py +144,"Item {0} is a template, please select one of its variants","Item {0} is een sjabloon, selecteert u één van de varianten"
+DocType: Asset,Asset Category,Asset Categorie
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Nettoloon kan niet negatief zijn
+DocType: Purchase Order,Advance Paid,Voorschot Betaald
+DocType: Item,Item Tax,Artikel Belasting
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883,Material to Supplier,Materiaal aan Leverancier
+DocType: Soil Texture,Loamy Sand,Leemachtige zand
+DocType: Production Plan,Material Request Planning,Materiaal Verzoek Planning
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +663,Excise Invoice,Accijnzen Factuur
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% meer dan eens
+DocType: Expense Claim,Employees Email Id,Medewerkers E-mail ID
+DocType: Employee Attendance Tool,Marked Attendance,Gemarkeerde Attendance
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Kortlopende Schulden
+apps/erpnext/erpnext/public/js/projects/timer.js +138,Timer exceeded the given hours.,Timer heeft de gegeven uren overschreden.
+apps/erpnext/erpnext/config/selling.py +297,Send mass SMS to your contacts,Stuur massa SMS naar uw contacten
+DocType: Patient,A Positive,Een positief
+DocType: Program,Program Name,Programma naam
+DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Overweeg belasting of heffing voor
+DocType: Driver,Driving License Category,Rijbewijscategorie
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158,No Reference,Geen referentie
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Werkelijke aantal is verplicht
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} heeft momenteel een {1} Leveranciers Scorecard, en er worden voorzichtige waarborgen uitgegeven bij inkooporders."
+DocType: Asset Maintenance Team,Asset Maintenance Team,Asset Maintenance Team
+DocType: Employee Loan,Loan Type,Loan Type
+DocType: Scheduling Tool,Scheduling Tool,scheduling Tool
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Kredietkaart
+DocType: BOM,Item to be manufactured or repacked,Artikel te vervaardigen of herverpakken
+DocType: Employee Education,Major/Optional Subjects,Major / keuzevakken
+DocType: Sales Invoice Item,Drop Ship,Drop Ship
+DocType: Driver,Suspended,Geschorst
+DocType: Training Event,Attendees,Deelnemers
+DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Hier kunt u onderhouden familie gegevens zoals naam en beroep van de ouder, echtgenoot en kinderen"
+DocType: Academic Term,Term End Date,Term Einddatum
+DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Belastingen en Toeslagen afgetrokken (Bedrijfsvaluta)
+DocType: Item Group,General Settings,Algemene Instellingen
+apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Van Valuta en naar Valuta kan niet hetzelfde zijn
+DocType: Stock Entry,Repack,Herverpakken
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,U moet het formulier opslaan voordat u verder gaat
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Selecteer eerst het bedrijf
+DocType: Item Attribute,Numeric Values,Numerieke waarden
+apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Bevestig Logo
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,Stock Levels
+DocType: Customer,Commission Rate,Commissie Rate
+apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Gecreëerd {0} scorecards voor {1} tussen:
+apps/erpnext/erpnext/stock/doctype/item/item.js +527,Make Variant,Maak Variant
+apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Blokkeer verlofaanvragen per afdeling.
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155,"Payment Type must be one of Receive, Pay and Internal Transfer","Betaling Type moet een van te ontvangen, betalen en Internal Transfer"
+apps/erpnext/erpnext/config/selling.py +184,Analytics,analytics
+apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Winkelwagen is leeg
+DocType: Vehicle,Model,Model
+DocType: Work Order,Actual Operating Cost,Werkelijke operationele kosten
+DocType: Payment Entry,Cheque/Reference No,Cheque / Reference No
+DocType: Soil Texture,Clay Loam,Clay Loam
+apps/erpnext/erpnext/accounts/doctype/account/account.py +81,Root cannot be edited.,Root kan niet worden bewerkt .
+DocType: Item,Units of Measure,Meeteenheden
+DocType: Manufacturing Settings,Allow Production on Holidays,Laat Productie op vakantie
+DocType: Sales Invoice,Customer's Purchase Order Date,Inkooporder datum van Klant
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Kapitaal Stock
+DocType: Shopping Cart Settings,Show Public Attachments,Publieke bijlagen tonen
+DocType: Packing Slip,Package Weight Details,Pakket gewicht details
+DocType: Restaurant Reservation,Reservation Time,Reservatietijd
+DocType: Payment Gateway Account,Payment Gateway Account,Payment Gateway Account
+DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Na betaling voltooiing omleiden gebruiker geselecteerde pagina.
+DocType: Company,Existing Company,bestaande Company
+DocType: Healthcare Settings,Result Emailed,Resultaat Emailed
+apps/erpnext/erpnext/controllers/buying_controller.py +88,"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Belastingcategorie is gewijzigd in &quot;Totaal&quot; omdat alle items niet-voorraad items zijn
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Selecteer een CSV-bestand
+DocType: Student Leave Application,Mark as Present,Mark als Cadeau
+DocType: Supplier Scorecard,Indicator Color,Indicator Kleur
+DocType: Purchase Order,To Receive and Bill,Te ontvangen en Bill
+apps/erpnext/erpnext/controllers/buying_controller.py +461,Row #{0}: Reqd by Date cannot be before Transaction Date,Rij # {0}: Gewenste datum mag niet vóór Transactiedatum liggen
+apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Aanbevolen producten
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Ontwerper
+apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Algemene voorwaarden Template
+DocType: Serial No,Delivery Details,Levering Details
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495,Cost Center is required in row {0} in Taxes table for type {1},Kostenplaats is vereist in regel {0} in Belastingen tabel voor type {1}
+DocType: Program,Program Code,programma Code
+DocType: Terms and Conditions,Terms and Conditions Help,Voorwaarden Help
+,Item-wise Purchase Register,Artikelgebaseerde Inkoop Register
+DocType: Driver,Expiry Date,Vervaldatum
+DocType: Healthcare Settings,Employee name and designation in print,Werknemer naam en aanduiding in print
+,accounts-browser,accounts-browser
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Selecteer eerst een Categorie
+apps/erpnext/erpnext/config/projects.py +13,Project master.,Project stam.
+apps/erpnext/erpnext/controllers/status_updater.py +212,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Om ervoor te zorgen over-facturering of over-bestellen, &quot;Allowance&quot; actualiseren Stock Settings of het item."
+DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,"Vertoon geen symbool zoals $, enz. naast valuta."
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431, (Half Day),(Halve Dag)
+DocType: Payment Term,Credit Days,Credit Dagen
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,Selecteer Patiënt om Lab-tests te krijgen
+apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Maak Student Batch
+DocType: Fee Schedule,FRQ.,FRQ.
+DocType: Leave Type,Is Carry Forward,Is Forward Carry
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841,Get Items from BOM,Artikelen ophalen van Stuklijst
+apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40,Lead Time Days,Lead Time Dagen
+DocType: Cash Flow Mapping,Is Income Tax Expense,Is de inkomstenbelasting
+apps/erpnext/erpnext/controllers/accounts_controller.py +621,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Rij # {0}: Plaatsingsdatum moet hetzelfde zijn als aankoopdatum {1} van de activa {2}
+DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Controleer dit als de student in het hostel van het Instituut verblijft.
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Vul verkooporders in de bovenstaande tabel
+,Stock Summary,Stock Samenvatting
+apps/erpnext/erpnext/config/assets.py +54,Transfer an asset from one warehouse to another,Transfer een troef van het ene magazijn naar het andere
+DocType: Vehicle,Petrol,Benzine
+apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Stuklijst
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Rij {0}: Party Type en Party is vereist voor Debiteuren / Crediteuren rekening {1}
+apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref Date
+DocType: Employee,Reason for Leaving,Reden voor vertrek
+DocType: BOM Operation,Operating Cost(Company Currency),Bedrijfskosten (Company Munt)
+DocType: Employee Loan Application,Rate of Interest,Rentevoet
+DocType: Expense Claim Detail,Sanctioned Amount,Gesanctioneerde Bedrag
+DocType: Item,Shelf Life In Days,Houdbaarheid in dagen
+DocType: GL Entry,Is Opening,Opent
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Rij {0}: debitering niet kan worden verbonden met een {1}
+DocType: Journal Entry,Subscription Section,Abonnementsafdeling
+apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Rekening {0} bestaat niet
+DocType: Training Event,Training Program,Oefenprogramma
+DocType: Account,Cash,Contant
+DocType: Employee,Short biography for website and other publications.,Korte biografie voor website en andere publicaties.
