 (Half Day),(Halve dag)
 and year: ,en jaar:
""" does not exists",""" Bestaat niet"
%  Delivered,Geleverd%
% Amount Billed,Gefactureerd% Bedrag
% Billed,% Gefactureerd
% Completed,% Voltooid
% Delivered,% Geleverd
% Installed,% Geïnstalleerd
% Received,% Ontvangen
% of materials billed against this Purchase Order.,% Van de materialen in rekening gebracht tegen deze Purchase Order.
% of materials billed against this Sales Order,% Van de materialen in rekening gebracht tegen deze verkooporder
% of materials delivered against this Delivery Note,% Van de geleverde materialen tegen deze Delivery Note
% of materials delivered against this Sales Order,% Van de geleverde materialen tegen deze verkooporder
% of materials ordered against this Material Request,% Van de bestelde materialen tegen dit materiaal aanvragen
% of materials received against this Purchase Order,% Van de materialen ontvangen tegen deze Kooporder
'Actual Start Date' can not be greater than 'Actual End Date',' Werkelijke Startdatum ' kan niet groter zijn dan ' Werkelijke Einddatum ' zijn
'Based On' and 'Group By' can not be same,' Based On ' en ' Group By ' kan niet hetzelfde zijn
'Days Since Last Order' must be greater than or equal to zero,' Dagen sinds Last Order ' moet groter zijn dan of gelijk zijn aan nul
'Entries' cannot be empty,' Inzendingen ' kan niet leeg zijn
'Expected Start Date' can not be greater than 'Expected End Date',' Verwacht Startdatum ' kan niet groter zijn dan ' Verwachte einddatum ' zijn
'From Date' is required,' Van datum ' vereist
'From Date' must be after 'To Date','From Date' moet na ' To Date'
'Has Serial No' can not be 'Yes' for non-stock item,' Heeft Serial No ' kan niet ' ja' voor niet- voorraad artikel
'Notification Email Addresses' not specified for recurring invoice,' Notification E-mailadressen ' niet gespecificeerd voor terugkerende factuur
'Profit and Loss' type account {0} not allowed in Opening Entry,' Winst-en verliesrekening ' accounttype {0} niet toegestaan ​​in Opening Entry
'To Case No.' cannot be less than 'From Case No.',&#39;Om Case No&#39; kan niet minder zijn dan &#39;Van Case No&#39;
'To Date' is required,' To Date' is vereist
'Update Stock' for Sales Invoice {0} must be set,'Bijwerken Stock ' voor verkoopfactuur {0} moet worden ingesteld
* Will be calculated in the transaction.,* Zal worden berekend in de transactie.
1 Currency = [?] FractionFor e.g. 1 USD = 100 Cent,1 Valuta = [?] Fractie  Voor bijv. 1 USD = 100 Cent
1. To maintain the customer wise item code and to make them searchable based on their code use this option,1. Om de klant wijzen artikelcode te behouden en om ze doorzoekbaar te maken op basis van hun code te gebruiken van deze optie
"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> toevoegen / bewerken < / a>"
"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group""> toevoegen / bewerken < / a>"
"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> toevoegen / bewerken < / a>"
"<h4>Default Template</h4><p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p><pre><code>{{ address_line1 }}&lt;br&gt;{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}{{ city }}&lt;br&gt;{% if state %}{{ state }}&lt;br&gt;{% endif -%}{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}{{ country }}&lt;br&gt;{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}</code></pre>","<h4> Standaardsjabloon </ h4>  <p> Gebruikt <a href=""http://jinja.pocoo.org/docs/templates/""> Jinja Templating </ a> en alle velden van Address ( inclusief aangepaste velden indien aanwezig) zal beschikbaar zijn </ p>  <pre> <code> {{address_line1}} <br>  {% if address_line2%} {{address_line2}} {<br> % endif -%}  {{city}} <br>  {% if staat%} {{staat}} {% endif <br> -%}  {% if pincode%} PIN: {{pincode}} {% endif <br> -%}  {{land}} <br>  {% if telefoon%} Telefoon: {{telefoon}} {<br> % endif -%}  {% if fax%} Fax: {{fax}} {% endif <br> -%}  {% if email_id%} E-mail: {{email_id}} <br> ; {% endif -%}  </ code> </ pre>"
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 te wijzigen
A Customer exists with same name,Een Klant bestaat met dezelfde naam
A Lead with this email id should exist,Een Lead met deze e-mail-ID moet bestaan
A Product or Service,Een product of dienst
A Supplier exists with same name,Een leverancier bestaat met dezelfde naam
A symbol for this currency. For e.g. $,Een symbool voor deze valuta. Voor bijvoorbeeld $
AMC Expiry Date,AMC Vervaldatum
Abbr,Afk
Abbreviation cannot have more than 5 characters,Afkorting kan niet meer dan 5 tekens lang zijn
Above Value,Boven Waarde
Absent,Afwezig
Acceptance Criteria,Acceptatiecriteria
Accepted,Aanvaard
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Geaccepteerde + Verworpen Aantal moet gelijk zijn aan Ontvangen aantal zijn voor post {0}
Accepted Quantity,Geaccepteerd Aantal
Accepted Warehouse,Geaccepteerd Magazijn
Account,Rekening
Account Balance,Rekeningbalans
Account Created: {0},Account Gemaakt : {0}
Account Details,Account Details
Account Head,Account Hoofding
Account Name,Rekeningnaam
Account Type,Rekening Type
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Saldo reeds in Credit, is het niet toegestaan om 'evenwicht moet worden' als 'Debet'"
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Saldo reeds in Debit, is het niet toegestaan om 'evenwicht moet worden' als 'Credit'"
Account for the warehouse (Perpetual Inventory) will be created under this Account.,Rekening voor het magazijn ( Perpetual Inventory ) wordt aangemaakt onder deze account .
Account head {0} created,Account hoofding {0} aangemaakt
Account must be a balance sheet account,Rekening moet een balansrekening zijn
Account with child nodes cannot be converted to ledger,Rekening met kind nodes kunnen niet worden geconverteerd naar ledger
Account with existing transaction can not be converted to group.,Rekening met bestaande transactie kan niet worden omgezet in groep .
Account with existing transaction can not be deleted,Rekening met bestaande transactie kan niet worden verwijderd
Account with existing transaction cannot be converted to ledger,Rekening met bestaande transactie kan niet worden geconverteerd naar grootboek
Account {0} cannot be a Group,Rekening {0} kan geen groep zijn
Account {0} does not belong to Company {1},Rekening {0} behoort niet tot Bedrijf {1}
Account {0} does not belong to company: {1},Rekening {0} behoort niet tot bedrijf: {1}
Account {0} does not exist,Account {0} bestaat niet
Account {0} has been entered more than once for fiscal year {1},Rekening {0} is meer dan een keer ingevoerd voor het fiscale jaar {1}
Account {0} is frozen,Rekening {0} is bevroren
Account {0} is inactive,Rekening {0} is niet actief
Account {0} is not valid,Rekening {0} is niet geldig
Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Rekening {0} moet van het type 'vaste activa' zijn  omdat Artikel {1} een actiefpost is
Account {0}: Parent account {1} can not be a ledger,Rekening {0}: Bovenliggende rekening {1} kan geen grootboek zijn
Account {0}: Parent account {1} does not belong to company: {2},Rekening {0}: Bovenliggende rekening {1} hoort niet bij bedrijf: {2}
Account {0}: Parent account {1} does not exist,Rekening {0}: Bovenliggende rekening {1} bestaat niet
Account {0}: You can not assign itself as parent account,Rekening {0}: U kunt niet zelf zichzelf toewijzen als bovenliggende rekening
Account: {0} can only be updated via \					Stock Transactions,Rekening: {0} kan alleen worden bijgewerkt via \ Voorraad Transacties
Accountant,Accountant
Accounting,Boekhouding
"Accounting Entries can be made against leaf nodes, called","Boekingen kunnen worden gemaakt tegen leaf nodes , genaamd"
"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Boekhoudkundige afschrijving bevroren tot deze datum, kan niemand / te wijzigen toegang behalve rol hieronder aangegeven."
Accounting journal entries.,Accounting journaalposten.
Accounts,Rekeningen
Accounts Browser,Rekeningen Browser
Accounts Frozen Upto,Rekeningen bevroren Tot
Accounts Payable,Accounts Payable
Accounts Receivable,Debiteuren
Accounts Settings,Accounts Settings
Active,Actief
Active: Will extract emails from ,Actief: Zal ​​e-mails uittreksel uit
Activity,Activiteit
Activity Log,Activiteitenlogboek
Activity Log:,Activiteitenlogboek:
Activity Type,Activiteit Type
Actual,Werkelijk
Actual Budget,Werkelijk Budget
Actual Completion Date,Werkelijke Voltooiingsdatum
Actual Date,Werkelijke Datum
Actual End Date,Werkelijke Einddatum
Actual Invoice Date,Werkelijke Factuurdatum
Actual Posting Date,Werkelijke Boekingsdatum
Actual Qty,Werkelijke Aantal
Actual Qty (at source/target),Werkelijke Aantal (bij de bron / doel)
Actual Qty After Transaction,Werkelijke Aantal Na Transactie
Actual Qty: Quantity available in the warehouse.,Werkelijke Aantal: Aantal beschikbaar in het magazijn.
Actual Quantity,Werkelijke hoeveelheid
Actual Start Date,Werkelijke Startdatum
Add,Toevoegen
Add / Edit Taxes and Charges,Toevoegen / Bewerken Belastingen en Heffingen
Add Child,Onderliggende toevoegen
Add Serial No,Voeg Serienummer
Add Taxes,Belastingen toevoegen
Add Taxes and Charges,Belastingen en heffingen toe te voegen
Add or Deduct,Toevoegen of aftrekken
Add rows to set annual budgets on Accounts.,Rijen toevoegen aan jaarlijkse begrotingen op Accounts in te stellen.
Add to Cart,In winkelwagen
Add to calendar on this date,Toevoegen aan agenda op deze datum
Add/Remove Recipients,Toevoegen / verwijderen Ontvangers
Address,Adres
Address & Contact,Adres &amp; Contact
Address & Contacts,Adres &amp; Contact
Address Desc,Adres Desc
Address Details,Adresgegevens
Address HTML,Adres HTML
Address Line 1,Adres Lijn 1
Address Line 2,Adres Lijn 2
Address Template,Adres Template
Address Title,Adres Titel
Address Title is mandatory.,Adres titel is verplicht.
Address Type,Adrestype
Address master.,Adres meester .
Administrative Expenses,administratieve Lasten
Administrative Officer,Administrative Officer
Advance Amount,Advance Bedrag
Advance amount,Advance hoeveelheid
Advances,Vooruitgang
Advertisement,Advertentie
Advertising,advertentie-
Aerospace,ruimte
After Sale Installations,Na Verkoop Installaties
Against,Tegen
Against Account,Tegen account
Against Bill {0} dated {1},Tegen Bill {0} gedateerd {1}
Against Docname,Tegen Docname
Against Doctype,Tegen Doctype
Against Document Detail No,Tegen Document Detail Geen
Against Document No,Tegen document nr.
Against Expense Account,Tegen Expense Account
Against Income Account,Tegen Inkomen account
Against Journal Voucher,Tegen Journal Voucher
Against Journal Voucher {0} does not have any unmatched {1} entry,Tegen Journal Voucher {0} heeft geen ongeëvenaarde {1} toegang hebben
Against Purchase Invoice,Tegen Aankoop Factuur
Against Sales Invoice,Tegen Sales Invoice
Against Sales Order,Tegen klantorder
Against Voucher,Tegen Voucher
Against Voucher Type,Tegen Voucher Type
Ageing Based On,Vergrijzing Based On
Ageing Date is mandatory for opening entry,Vergrijzing Date is verplicht voor het openen van binnenkomst
Ageing date is mandatory for opening entry,Vergrijzing datum is verplicht voor het openen van binnenkomst
Agent,Agent
Aging Date,Aging Datum
Aging Date is mandatory for opening entry,Veroudering Date is verplicht voor het openen van binnenkomst
Agriculture,landbouw
Airline,vliegmaatschappij
All Addresses.,Alle adressen.
All Contact,Alle Contact
All Contacts.,Alle contactpersonen.
All Customer Contact,Alle Customer Contact
All Customer Groups,Alle Doelgroepen
All Day,All Day
All Employee (Active),Alle medewerkers (Actief)
All Item Groups,Alle Item Groepen
All Lead (Open),Alle Lood (Open)
All Products or Services.,Alle producten of diensten.
All Sales Partner Contact,Alle Sales Partner Contact
All Sales Person,Alle Sales Person
All Supplier Contact,Alle Leverancier Contact
All Supplier Types,Alle Leverancier Types
All Territories,Alle gebieden
"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Alle export gerelateerde gebieden zoals valuta , wisselkoers , export totaal, export eindtotaal enz. zijn beschikbaar in Delivery Note , POS , Offerte , verkoopfactuur , Sales Order etc."
"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Alle import gerelateerde gebieden zoals valuta , wisselkoers , import totaal, import eindtotaal enz. zijn beschikbaar in aankoopbewijs Leverancier offerte, factuur , bestelbon enz."
All items have already been invoiced,Alle items zijn reeds gefactureerde
All these items have already been invoiced,Al deze items zijn reeds gefactureerde
Allocate,Toewijzen
Allocate leaves for a period.,Toewijzen bladeren voor een periode .
Allocate leaves for the year.,Wijs bladeren voor het jaar.
Allocated Amount,Toegewezen bedrag
Allocated Budget,Toegekende budget
Allocated amount,Toegewezen bedrag
Allocated amount can not be negative,Toegekende bedrag kan niet negatief zijn
Allocated amount can not greater than unadusted amount,Toegekende bedrag kan niet hoger zijn dan unadusted bedrag
Allow Bill of Materials,Laat Bill of Materials
Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,Laat Bill of Materials moet 'ja ' . Omdat een of veel actieve stuklijsten voor dit artikel aanwezig
Allow Children,Kinderen laten
Allow Dropbox Access,Laat Dropbox Access
Allow Google Drive Access,Laat Google Drive Access
Allow Negative Balance,Laat negatief saldo
Allow Negative Stock,Laat Negatieve voorraad
Allow Production Order,Laat Productieorder
Allow User,Door gebruiker toestaan
Allow Users,Gebruikers toestaan
Allow the following users to approve Leave Applications for block days.,Laat de volgende gebruikers te keuren Verlof Aanvragen voor blok dagen.
Allow user to edit Price List Rate in transactions,Zodat de gebruiker te bewerken prijslijst Rate bij transacties
Allowance Percent,Toelage Procent
Allowance for over-{0} crossed for Item {1},Korting voor over-{0} gekruist voor post {1}
Allowance for over-{0} crossed for Item {1}.,Korting voor over-{0} gekruist voor post {1}.
Allowed Role to Edit Entries Before Frozen Date,Toegestaan ​​Rol te bewerken items voor Frozen Datum
Amended From,Gewijzigd Van
Amount,Bedrag
Amount (Company Currency),Bedrag (Company Munt)
Amount Paid,Betaald bedrag
Amount to Bill,Neerkomen op Bill
An Customer exists with same name,Een klant bestaat met dezelfde naam
"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"
"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"
Analyst,analist
Annual,jaar-
Another Period Closing Entry {0} has been made after {1},Een ander Periode sluitpost {0} is gemaakt na {1}
Another Salary Structure {0} is active for employee {0}. Please make its status 'Inactive' to proceed.,Een andere salarisstructuur {0} is actief voor werknemer {0} . Maak dan de status ' Inactief ' om verder te gaan .
"Any other comments, noteworthy effort that should go in the records.","Eventuele andere opmerkingen, opmerkelijke inspanning die moet gaan in de administratie."
Apparel & Accessories,Kleding & Toebehoren
Applicability,toepasselijkheid
Applicable For,Toepasselijk voor
Applicable Holiday List,Toepasselijk Holiday Lijst
Applicable Territory,Toepasselijk Territory
Applicable To (Designation),Van toepassing zijn op (Benaming)
Applicable To (Employee),Van toepassing zijn op (Werknemer)
Applicable To (Role),Van toepassing zijn op (Rol)
Applicable To (User),Van toepassing zijn op (Gebruiker)
Applicant Name,Aanvrager Naam
Applicant for a Job.,Kandidaat voor een baan.
Application of Funds (Assets),Toepassing van fondsen ( activa )
Applications for leave.,Aanvragen voor verlof.
Applies to Company,Geldt voor Bedrijf
Apply On,toepassing op
Appraisal,Taxatie
Appraisal Goal,Beoordeling Doel
Appraisal Goals,Beoordeling Doelen
Appraisal Template,Beoordeling Sjabloon
Appraisal Template Goal,Beoordeling Sjabloon Doel
Appraisal Template Title,Beoordeling Template titel
Appraisal {0} created for Employee {1} in the given date range,Beoordeling {0} gemaakt voor Employee {1} in de bepaalde periode
Apprentice,leerling
Approval Status,Goedkeuringsstatus
Approval Status must be 'Approved' or 'Rejected',Goedkeuring Status moet worden ' goedgekeurd ' of ' Afgewezen '
Approved,Aangenomen
Approver,Goedkeurder
Approving Role,Goedkeuren Rol
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
Approving User,Goedkeuren Gebruiker
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
Are you sure you want to STOP ,
Are you sure you want to UNSTOP ,
Arrear Amount,Achterstallig bedrag
"As Production Order can be made for this item, it must be a stock item.","Zoals productieorder kan worden gemaakt voor dit punt, moet het een voorraad item."
As per Stock UOM,Per Stock Verpakking
"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Is Stock Item' and 'Valuation Method'","Want er zijn bestaande voorraad transacties voor dit artikel , kunt u de waarden van ' Has Serial No ' niet veranderen , ' Is Stock Item ' en ' Valuation Method '"
Asset,aanwinst
Assistant,assistent
Associate,associëren
Atleast one of the Selling or Buying must be selected,Tenminste een van de verkopen of aankopen moeten worden gekozen
Atleast one warehouse is mandatory,Tenminste een magazijn is verplicht
Attach Image,Bevestig Afbeelding
Attach Letterhead,Bevestig briefhoofd
Attach Logo,Bevestig Logo
Attach Your Picture,Bevestig Uw Beeld
Attendance,Opkomst
Attendance Date,Aanwezigheid Datum
Attendance Details,Aanwezigheid Details
Attendance From Date,Aanwezigheid Van Datum
Attendance From Date and Attendance To Date is mandatory,Aanwezigheid Van Datum en tot op heden opkomst is verplicht
Attendance To Date,Aanwezigheid graag:
Attendance can not be marked for future dates,Toeschouwers kunnen niet worden gemarkeerd voor toekomstige data
Attendance for employee {0} is already marked,Opkomst voor werknemer {0} is al gemarkeerd
Attendance record.,Aanwezigheid record.
Authorization Control,Autorisatie controle
Authorization Rule,Autorisatie Rule
Auto Accounting For Stock Settings,Auto Accounting Voor Stock Instellingen
Auto Material Request,Automatisch Materiaal Request
Auto-raise Material Request if quantity goes below re-order level in a warehouse,Auto-raise Materiaal aanvragen als kwantiteit gaat onder re-orde niveau in een magazijn
Automatically compose message on submission of transactions.,Bericht automatisch samenstellen overlegging van transacties .
Automatically extract Job Applicants from a mail box ,
Automatically extract Leads from a mail box e.g.,Leads automatisch extraheren uit een brievenbus bijv.
Automatically updated via Stock Entry of type Manufacture/Repack,Automatisch geüpdate via Stock positie van het type Vervaardiging / Verpak
Automotive,Automotive
Autoreply when a new mail is received,Autoreply wanneer er een nieuwe e-mail wordt ontvangen
Available,beschikbaar
Available Qty at Warehouse,Qty bij Warehouse
Available Stock for Packing Items,Beschikbaar voor Verpakking Items
"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Verkrijgbaar in BOM , Delivery Note, aankoopfactuur, Productie Order , Bestelling , Kwitantie , verkoopfactuur , Sales Order , Voorraad Entry , Rooster"
Average Age,Gemiddelde Leeftijd
Average Commission Rate,Gemiddelde Commissie Rate
Average Discount,Gemiddelde korting
Awesome Products,Awesome producten
Awesome Services,Awesome Services
BOM Detail No,BOM Detail Geen
BOM Explosion Item,BOM Explosie Item
BOM Item,BOM Item
BOM No,BOM Geen
BOM No. for a Finished Good Item,BOM Nee voor een afgewerkte goed item
BOM Operation,BOM Operatie
BOM Operations,BOM Operations
BOM Replace Tool,BOM Replace Tool
BOM number is required for manufactured Item {0} in row {1},BOM nummer is vereist voor gefabriceerde Item {0} in rij {1}
BOM number not allowed for non-manufactured Item {0} in row {1},BOM nummer niet toegestaan ​​voor niet - gefabriceerde Item {0} in rij {1}
BOM recursion: {0} cannot be parent or child of {2},BOM recursie : {0} mag niet ouder of kind zijn van {2}
BOM replaced,BOM vervangen
BOM {0} for Item {1} in row {2} is inactive or not submitted,BOM {0} voor post {1} in rij {2} is niet actief of niet ingediend
BOM {0} is not active or not submitted,BOM {0} is niet actief of niet ingediend
BOM {0} is not submitted or inactive BOM for Item {1},BOM {0} is niet voorgelegd of inactief BOM voor post {1}
Backup Manager,Backup Manager
Backup Right Now,Back-up Right Now
Backups will be uploaded to,Back-ups worden geüpload naar
Balance Qty,Balance Aantal
Balance Sheet,balans
Balance Value,Balance Waarde
Balance for Account {0} must always be {1},Saldo van account {0} moet altijd {1}
Balance must be,Evenwicht moet worden
"Balances of Accounts of type ""Bank"" or ""Cash""","Saldi van de rekeningen van het type "" Bank "" of "" Cash """
Bank,Bank
Bank / Cash Account,Bank / Cash Account
Bank A/C No.,Bank A / C Nee
Bank Account,Bankrekening
Bank Account No.,Bank Account Nr
Bank Accounts,bankrekeningen
Bank Clearance Summary,Bank Ontruiming Samenvatting
Bank Draft,Bank Draft
Bank Name,Naam van de bank
Bank Overdraft Account,Bank Overdraft Account
Bank Reconciliation,Bank Verzoening
Bank Reconciliation Detail,Bank Verzoening Detail
Bank Reconciliation Statement,Bank Verzoening Statement
Bank Voucher,Bank Voucher
Bank/Cash Balance,Bank / Geldsaldo
Banking,bank
Barcode,Barcode
Barcode {0} already used in Item {1},Barcode {0} al gebruikt in post {1}
Based On,Gebaseerd op
Basic,basisch
Basic Info,Basic Info
Basic Information,Basisinformatie
Basic Rate,Basic Rate
Basic Rate (Company Currency),Basic Rate (Company Munt)
Batch,Partij
Batch (lot) of an Item.,Batch (lot) van een item.
Batch Finished Date,Batch Afgewerkt Datum
Batch ID,Batch ID
Batch No,Batch nr.
Batch Started Date,Batch Gestart Datum
Batch Time Logs for billing.,Batch Time Logs voor de facturering.
Batch-Wise Balance History,Batch-Wise Balance Geschiedenis
Batched for Billing,Gebundeld voor facturering
Better Prospects,Betere vooruitzichten
Bill Date,Bill Datum
Bill No,Bill Geen
Bill No {0} already booked in Purchase Invoice {1},Bill Geen {0} al geboekt in inkoopfactuur {1}
Bill of Material,Bill of Material
Bill of Material to be considered for manufacturing,Bill of Material te worden beschouwd voor de productie van
Bill of Materials (BOM),Bill of Materials (BOM)
Billable,Factureerbare
Billed,Gefactureerd
Billed Amount,gefactureerde bedrag
Billed Amt,Billed Amt
Billing,Billing
Billing Address,Factuuradres
Billing Address Name,Factuuradres Naam
Billing Status,Billing Status
Bills raised by Suppliers.,Rekeningen die door leveranciers.
Bills raised to Customers.,Bills verhoogd tot klanten.
Bin,Bak
Bio,Bio
Biotechnology,biotechnologie
Birthday,verjaardag
Block Date,Blokkeren Datum
Block Days,Blokkeren Dagen
Block leave applications by department.,Blok verlaten toepassingen per afdeling.
Blog Post,Blog Post
Blog Subscriber,Blog Abonnee
Blood Group,Bloedgroep
Both Warehouse must belong to same Company,Beide Warehouse moeten behoren tot dezelfde Company
Box,doos
Branch,Tak
Brand,Merk
Brand Name,Merknaam
Brand master.,Brand meester.
Brands,Merken
Breakdown,Storing
Broadcasting,omroep
Brokerage,makelarij
Budget,Begroting
Budget Allocated,Budget
Budget Detail,Budget Detail
Budget Details,Budget Details
Budget Distribution,Budget Distributie
Budget Distribution Detail,Budget Distributie Detail
Budget Distribution Details,Budget Distributie Details
Budget Variance Report,Budget Variantie Report
Budget cannot be set for Group Cost Centers,Begroting kan niet worden ingesteld voor groep kostenplaatsen
Build Report,Build Report
Bundle items at time of sale.,Bundel artikelen op moment van verkoop.
Business Development Manager,Business Development Manager
Buying,Het kopen
Buying & Selling,Kopen en verkopen
Buying Amount,Kopen Bedrag
Buying Settings,Kopen Instellingen
"Buying must be checked, if Applicable For is selected as {0}","Kopen moet worden gecontroleerd, indien van toepassing voor is geselecteerd als {0}"
C-Form,C-Form
C-Form Applicable,C-Form Toepasselijk
C-Form Invoice Detail,C-Form Factuurspecificatie
C-Form No,C-vorm niet
C-Form records,C -Form platen
CENVAT Capital Goods,CENVAT Kapitaalgoederen
CENVAT Edu Cess,CENVAT Edu Cess
CENVAT SHE Cess,CENVAT SHE Cess
CENVAT Service Tax,CENVAT Dienst Belastingen
CENVAT Service Tax Cess 1,CENVAT Dienst Belastingen Cess 1
CENVAT Service Tax Cess 2,CENVAT Dienst Belastingen Cess 2
Calculate Based On,Bereken Based On
Calculate Total Score,Bereken Totaal Score
Calendar Events,Kalender Evenementen
Call,Noemen
Calls,oproepen
Campaign,Campagne
Campaign Name,Campagnenaam
Campaign Name is required,Campagne Naam is vereist
Campaign Naming By,Campagne Naming Door
Campaign-.####,Campagne - . # # # #
Can be approved by {0},Kan door {0} worden goedgekeurd
"Can not filter based on Account, if grouped by Account",Kan niet filteren op basis van account als gegroepeerd per account
"Can not filter based on Voucher No, if grouped by Voucher","Kan niet filteren op basis van Voucher Nee, als gegroepeerd per Voucher"
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Kan verwijzen rij alleen als het type lading is 'On Vorige Row Bedrag ' of ' Vorige Row Total'
Cancel Material Visit {0} before cancelling this Customer Issue,Annuleren Materiaal Bezoek {0} voor het annuleren van deze klant Issue
Cancel Material Visits {0} before cancelling this Maintenance Visit,Annuleren Materiaal Bezoeken {0} voor het annuleren van deze Maintenance Visit
Cancelled,Geannuleerd
Cancelling this Stock Reconciliation will nullify its effect.,Annuleren van dit Stock Verzoening zal het effect teniet doen .
Cannot Cancel Opportunity as Quotation Exists,Kan niet annuleren Opportunity als Offerte Bestaat
Cannot approve leave as you are not authorized to approve leaves on Block Dates,Kan verlof niet goedkeuren als u niet bevoegd bent om bladeren op Block Data goedkeuren
Cannot cancel because Employee {0} is already approved for {1},Kan niet annuleren omdat Employee {0} is reeds goedgekeurd voor {1}
Cannot cancel because submitted Stock Entry {0} exists,Kan niet annuleren omdat ingediend Stock Entry {0} bestaat
Cannot carry forward {0},Kan niet dragen {0}
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Kan boekjaar Startdatum en Boekjaareinde Datum zodra het boekjaar wordt opgeslagen niet wijzigen.
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Kan bedrijf standaard valuta niet veranderen , want er zijn bestaande transacties . Transacties moeten worden geannuleerd om de standaard valuta te wijzigen ."
Cannot convert Cost Center to ledger as it has child nodes,Kan kostenplaats niet omzetten naar grootboek omdat het kind knooppunten
Cannot covert to Group because Master Type or Account Type is selected.,Kan niet verkapte naar Groep omdat Master Type of Type account is geselecteerd.
Cannot deactive or cancle BOM as it is linked with other BOMs,Kan niet deactive of cancle BOM omdat het verbonden is met andere stuklijsten
"Cannot declare as lost, because Quotation has been made.","Kan niet verklaren als verloren , omdat Offerte is gemaakt."
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Kan niet aftrekken als categorie is voor ' Valuation ' of ' Valuation en Total '
"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Kan Serienummer {0} niet verwijderen in voorraad . Verwijder eerst uit voorraad , dan verwijderen."
"Cannot directly set amount. For 'Actual' charge type, use the rate field","Kan niet direct is opgenomen. Voor ' Actual ""type lading , gebruikt u het veld tarief"
"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings","Kan niet overbill voor post {0} in rij {0} meer dan {1}. Om overbilling staan, stel dan in Stock Instellingen"
Cannot produce more Item {0} than Sales Order quantity {1},Kan niet meer produceren Item {0} dan Sales Bestelhoeveelheid {1}
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
Cannot return more than {0} for Item {1},Kan niet meer dan terug {0} voor post {1}
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
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for valuation. You can select only 'Total' option for previous row amount or previous row total,Kan het type lading niet selecteren als 'On Vorige Row Bedrag ' of ' On Vorige Row Totaal ' voor waardering . U kunt alleen ' Totaal ' optie voor de vorige rij bedrag of vorige rijtotaal selecteren
Cannot set as Lost as Sales Order is made.,Kan niet ingesteld als Lost als Sales Order wordt gemaakt .
Cannot set authorization on basis of Discount for {0},Kan de vergunning niet ingesteld op basis van Korting voor {0}
Capacity,Hoedanigheid
Capacity Units,Capaciteit Units
Capital Account,vermogensoverdrachtenrekening
Capital Equipments,kapitaal Uitrustingen
Carry Forward,Carry Forward
Carry Forwarded Leaves,Carry Doorgestuurd Bladeren
Case No(s) already in use. Try from Case No {0},Zaak nr. ( s ) al in gebruik. Probeer uit Zaak nr. {0}
Case No. cannot be 0,Zaak nr. mag geen 0
Cash,Geld
Cash In Hand,Cash In Hand
Cash Voucher,Cash Voucher
Cash or Bank Account is mandatory for making payment entry,Cash of bankrekening is verplicht voor de betaling toegang
Cash/Bank Account,Cash / bankrekening
Casual Leave,Casual Leave
Cell Number,Mobiele nummer
Change UOM for an Item.,Wijzig Verpakking voor een item.
Change the starting / current sequence number of an existing series.,Wijzig de start-/ huidige volgnummer van een bestaande serie.
Channel Partner,Channel Partner
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
Chargeable,Oplaadbare
Charity and Donations,Liefdadigheid en Donaties
Chart Name,grafiek
Chart of Accounts,Rekeningschema
Chart of Cost Centers,Grafiek van Kostenplaatsen
Check how the newsletter looks in an email by sending it to your email.,Controleer hoe de nieuwsbrief eruit ziet in een e-mail door te sturen naar uw e-mail.
"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Controleer of terugkerende factuur, schakelt u om te stoppen met terugkerende of zet de juiste Einddatum"
"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Controleer of u de automatische terugkerende facturen. Na het indienen van elke verkoop factuur, zal terugkerende sectie zichtbaar zijn."
Check if you want to send salary slip in mail to each employee while submitting salary slip,"Controleer of u wilt loonstrook sturen mail naar elke werknemer, terwijl het indienen van loonstrook"
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.
Check this if you want to show in website,Selecteer dit als u wilt weergeven in de website
Check this to disallow fractions. (for Nos),Controleer dit te verbieden fracties. (Voor Nos)
Check this to pull emails from your mailbox,Vink dit aan om e-mails uit je mailbox
Check to activate,Controleer activeren
Check to make Shipping Address,Controleer Verzendadres maken
Check to make primary address,Controleer primaire adres maken
Chemical,chemisch
Cheque,Cheque
Cheque Date,Cheque Datum
Cheque Number,Cheque nummer
Child account exists for this account. You can not delete this account.,Kind account bestaat voor dit account . U kunt deze niet verwijderen .
City,City
City/Town,Stad / Plaats
Claim Amount,Claim Bedrag
Claims for company expense.,Claims voor rekening bedrijf.
Class / Percentage,Klasse / Percentage
Classic,Klassiek
Clear Table,Clear Tabel
Clearance Date,Clearance Datum
Clearance Date not mentioned,Ontruiming Datum niet vermeld
Clearance date cannot be before check date in row {0},Klaring mag niet voor check datum in rij {0}
Click on 'Make Sales Invoice' button to create a new Sales Invoice.,Klik op &#39;Sales Invoice&#39; knop om een ​​nieuwe verkoopfactuur maken.
Click on a link to get options to expand get options ,
Client,Klant
Close Balance Sheet and book Profit or Loss.,Sluiten Balans en boek Winst of verlies .
Closed,Gesloten
Closing (Cr),Sluiten (Cr)
Closing (Dr),Sluiten (Dr)
Closing Account Head,Sluiten Account Hoofd
Closing Account {0} must be of type 'Liability',Closing account {0} moet van het type ' Aansprakelijkheid ' zijn
Closing Date,Afsluitingsdatum
Closing Fiscal Year,Het sluiten van het fiscale jaar
Closing Qty,closing Aantal
Closing Value,eindwaarde
CoA Help,CoA Help
Code,Code
Cold Calling,Cold Calling
Color,Kleur
Column Break,Column Break
Comma separated list of email addresses,Komma&#39;s gescheiden lijst van e-mailadressen
Comment,Commentaar
Comments,Reacties
Commercial,commercieel
Commission,commissie
Commission Rate,Commissie Rate
Commission Rate (%),Commissie Rate (%)
Commission on Sales,Commissie op de verkoop
Commission rate cannot be greater than 100,Tarief Commissie kan niet groter zijn dan 100
Communication,Verbinding
Communication HTML,Communicatie HTML
Communication History,Communicatie Geschiedenis
Communication log.,Communicatie log.
Communications,communicatie
Company,Vennootschap
Company (not Customer or Supplier) master.,Company ( geen klant of leverancier ) meester.
Company Abbreviation,bedrijf Afkorting
Company Details,Bedrijfsgegevens
Company Email,bedrijf E-mail
"Company Email ID not found, hence mail not sent","Bedrijf E -ID niet gevonden , dus mail niet verzonden"
Company Info,Bedrijfsgegevens
Company Name,Bedrijfsnaam
Company Settings,Bedrijfsinstellingen
Company is missing in warehouses {0},Bedrijf ontbreekt in magazijnen {0}
Company is required,Vennootschap is verplicht
Company registration numbers for your reference. Example: VAT Registration Numbers etc.,"Registratienummers van de onderneming voor uw referentie. Voorbeeld: BTW-nummers, enz."
Company registration numbers for your reference. Tax numbers etc.,"Registratienummers van de onderneming voor uw referentie. Fiscale nummers, enz."
"Company, Month and Fiscal Year is mandatory","Bedrijf , maand en het fiscale jaar is verplicht"
Compensatory Off,compenserende Off
Complete,Compleet
Complete Setup,compleet Setup
Completed,Voltooid
Completed Production Orders,Voltooide productieorders
Completed Qty,Voltooide Aantal
Completion Date,Voltooiingsdatum
Completion Status,Afronding Status
Computer,computer
Computers,Computers
Confirmation Date,bevestiging Datum
Confirmed orders from Customers.,Bevestigde orders van klanten.
Consider Tax or Charge for,Overweeg belasting of heffing voor
Considered as Opening Balance,Beschouwd als Opening Balance
Considered as an Opening Balance,Beschouwd als een openingsbalans
Consultant,Consultant
Consulting,raadgevend
Consumable,verbruiksartikelen
Consumable Cost,verbruiksartikelen Cost
Consumable cost per hour,Verbruiksartikelen kosten per uur
Consumed Qty,Consumed Aantal
Consumer Products,Consumer Products
Contact,Contact
Contact Control,Contact Controle
Contact Desc,Contact Desc
Contact Details,Contactgegevens
Contact Email,Contact E-mail
Contact HTML,Contact HTML
Contact Info,Contact Info
Contact Mobile No,Contact Mobiel Nog geen
Contact Name,Contact Naam
Contact No.,Contact No
Contact Person,Contactpersoon
Contact Type,Contact Type
Contact master.,Contact meester .
Contacts,contacten
Content,Inhoud
Content Type,Content Type
Contra Voucher,Contra Voucher
Contract,contract
Contract End Date,Contract Einddatum
Contract End Date must be greater than Date of Joining,Contract Einddatum moet groter zijn dan Datum van Deelnemen zijn
Contribution (%),Bijdrage (%)
Contribution to Net Total,Bijdrage aan de netto Total
Conversion Factor,Conversie Factor
Conversion Factor is required,Omrekeningsfactor worden vastgesteld
Conversion factor cannot be in fractions,Omrekeningsfactor kan niet in fracties
Conversion factor for default Unit of Measure must be 1 in row {0},Conversiefactor voor Standaard meeteenheid moet 1 zijn in rij {0}
Conversion rate cannot be 0 or 1,Succespercentage kan niet 0 of 1
Convert into Recurring Invoice,Om te zetten in terugkerende factuur
Convert to Group,Converteren naar Groep
Convert to Ledger,Converteren naar Ledger
Converted,Omgezet
Copy From Item Group,Kopiëren van Item Group
Cosmetics,schoonheidsmiddelen
Cost Center,Kostenplaats
Cost Center Details,Kosten Center Details
Cost Center Name,Kosten Center Naam
Cost Center is required for 'Profit and Loss' account {0},Kostenplaats is vereist voor ' winst-en verliesrekening ' rekening {0}
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}
Cost Center with existing transactions can not be converted to group,Cost Center met bestaande transacties kunnen niet worden omgezet in groep
Cost Center with existing transactions can not be converted to ledger,Cost Center met bestaande transacties kunnen niet worden omgezet naar grootboek
Cost Center {0} does not belong to Company {1},Kostenplaats {0} behoort niet tot Company {1}
Cost of Goods Sold,Kostprijs van verkochte goederen
Costing,Costing
Country,Land
Country Name,Naam van het land
Country wise default Address Templates,Land verstandig default Adres Templates
"Country, Timezone and Currency","Country , Tijdzone en Valuta"
Create Bank Voucher for the total salary paid for the above selected criteria,Maak Bank Voucher voor het totale loon voor de bovenstaande geselecteerde criteria
Create Customer,Maak de klant
Create Material Requests,Maak Materiaal Aanvragen
Create New,Create New
Create Opportunity,Maak Opportunity
Create Production Orders,Maak productieorders
Create Quotation,Maak Offerte
Create Receiver List,Maak Receiver Lijst
Create Salary Slip,Maak loonstrook
Create Stock Ledger Entries when you submit a Sales Invoice,Maak Stock Grootboekposten wanneer u een verkoopfactuur indienen
"Create and manage daily, weekly and monthly email digests.","Aanmaken en beheren van dagelijkse, wekelijkse en maandelijkse e-mail verteert ."
Create rules to restrict transactions based on values.,Regels maken om transacties op basis van waarden te beperken.
Created By,Gemaakt door
Creates salary slip for above mentioned criteria.,Maakt salarisstrook voor de bovengenoemde criteria.
Creation Date,aanmaakdatum
Creation Document No,Creatie Document No
Creation Document Type,Type het maken van documenten
Creation Time,Aanmaaktijd
Credentials,Geloofsbrieven
Credit,Krediet
Credit Amt,Credit Amt
Credit Card,creditkaart
Credit Card Voucher,Credit Card Voucher
Credit Controller,Credit Controller
Credit Days,Credit Dagen
Credit Limit,Kredietlimiet
Credit Note,Creditnota
Credit To,Met dank aan
Currency,Valuta
Currency Exchange,Wisselkantoor
Currency Name,De Naam van
Currency Settings,Valuta-instellingen
Currency and Price List,Valuta en Prijslijst
Currency exchange rate master.,Wisselkoers meester.
Current Address,Huidige adres
Current Address Is,Huidige adres wordt
Current Assets,Vlottende activa
Current BOM,Actueel BOM
Current BOM and New BOM can not be same,Huidige BOM en New BOM kan niet hetzelfde zijn
Current Fiscal Year,Huidige fiscale jaar
Current Liabilities,Kortlopende verplichtingen
Current Stock,Huidige voorraad
Current Stock UOM,Huidige voorraad Verpakking
Current Value,Huidige waarde
Custom,Gewoonte
Custom Autoreply Message,Aangepaste Autoreply Bericht
Custom Message,Aangepast bericht
Customer,Klant
Customer (Receivable) Account,Klant (Debiteuren) Account
Customer / Item Name,Klant / Naam van het punt
Customer / Lead Address,Klant / Lead Adres
Customer / Lead Name,Klant / Lead Naam
Customer > Customer Group > Territory,Klant> Customer Group> Territory
Customer Account Head,Customer Account Head
Customer Acquisition and Loyalty,Klantenwerving en Loyalty
Customer Address,Klant Adres
Customer Addresses And Contacts,Klant adressen en contacten
Customer Addresses and Contacts,Klant Adressen en Contacten
Customer Code,Klantcode
Customer Codes,Klant Codes
Customer Details,Klant Details
Customer Feedback,Klantenfeedback
Customer Group,Klantengroep
Customer Group / Customer,Customer Group / Klantenservice
Customer Group Name,Klant Groepsnaam
Customer Intro,Klant Intro
Customer Issue,Probleem voor de klant
Customer Issue against Serial No.,Klant Kwestie tegen Serienummer
Customer Name,Klantnaam
Customer Naming By,Klant Naming Door
Customer Service,Klantenservice
Customer database.,Klantenbestand.
Customer is required,Opdrachtgever is verplicht
Customer master.,Klantstam .
Customer required for 'Customerwise Discount',Klant nodig voor ' Customerwise Korting'
Customer {0} does not belong to project {1},Customer {0} niet behoort tot het project {1}
Customer {0} does not exist,Customer {0} bestaat niet
Customer's Item Code,Klant Artikelcode
Customer's Purchase Order Date,Klant Purchase Order Date
Customer's Purchase Order No,Klant Purchase Order No
Customer's Purchase Order Number,Klant Inkoopordernummer
Customer's Vendor,Klant Vendor
Customers Not Buying Since Long Time,Klanten Niet kopen Sinds Long Time
Customerwise Discount,Customerwise Korting
Customize,Pas
Customize the Notification,Pas de Kennisgeving
Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Pas de inleidende tekst die gaat als een deel van die e-mail. Elke transactie heeft een aparte inleidende tekst.
DN Detail,DN Detail
Daily,Dagelijks
Daily Time Log Summary,Daily Time Log Samenvatting
Database Folder ID,Database Folder ID
Database of potential customers.,Database van potentiële klanten.
Date,Datum
Date Format,Datumnotatie
Date Of Retirement,Datum van pensionering
Date Of Retirement must be greater than Date of Joining,Datum van pensionering moet groter zijn dan Datum van Deelnemen zijn
Date is repeated,Datum wordt herhaald
Date of Birth,Geboortedatum
Date of Issue,Datum van afgifte
Date of Joining,Datum van toetreding tot
Date of Joining must be greater than Date of Birth,Datum van toetreding moet groter zijn dan Geboortedatum zijn
Date on which lorry started from supplier warehouse,Datum waarop vrachtwagen gestart vanuit leverancier magazijn
Date on which lorry started from your warehouse,Datum waarop vrachtwagen gestart vanuit uw magazijn
Dates,Data
Days Since Last Order,Dagen sinds vorige Bestel
Days for which Holidays are blocked for this department.,Dagen waarvoor feestdagen zijn geblokkeerd voor deze afdeling.
Dealer,Handelaar
Debit,Debet
Debit Amt,Debet Amt
Debit Note,Debetnota
Debit To,Debitering van
Debit and Credit not equal for this voucher. Difference is {0}.,Debet en Credit niet gelijk voor deze bon . Verschil is {0} .
Deduct,Aftrekken
Deduction,Aftrek
Deduction Type,Aftrek Type
Deduction1,Deduction1
Deductions,Inhoudingen
Default,Verzuim
Default Account,Standaard Account
Default Address Template cannot be deleted,Default Address Template kan niet worden verwijderd
Default Amount,Standaard Bedrag
Default BOM,Standaard BOM
Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Standaard Bank / Cash account wordt automatisch bijgewerkt in POS Factuur bij deze modus is geselecteerd.
Default Bank Account,Standaard bankrekening
Default Buying Cost Center,Standaard Buying kostenplaats
Default Buying Price List,Standaard Buying Prijslijst
Default Cash Account,Standaard Cash Account
Default Company,Standaard Bedrijf
Default Currency,Standaard valuta
Default Customer Group,Standaard Klant Groep
Default Expense Account,Standaard Expense Account
Default Income Account,Standaard Inkomen account
Default Item Group,Standaard Onderdeel Groep
Default Price List,Standaard Prijslijst
Default Purchase Account in which cost of the item will be debited.,Standaard Aankoop account waarin kosten van het actief zal worden gedebiteerd.
Default Selling Cost Center,Standaard Selling kostenplaats
Default Settings,Standaardinstellingen
Default Source Warehouse,Standaard Bron Warehouse
Default Stock UOM,Default Stock Verpakking
Default Supplier,Standaardleverancier
Default Supplier Type,Standaard Leverancier Type
Default Target Warehouse,Standaard Target Warehouse
Default Territory,Standaard Territory
Default Unit of Measure,Standaard Maateenheid
"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.","Standaard meeteenheid kan niet direct worden veranderd , omdat je al enkele transactie (s ) heeft gemaakt met een andere Verpakking . Om standaard Verpakking wijzigen, gebruikt ' Verpakking Vervang Utility ' hulpmiddel onder Stock module ."
Default Valuation Method,Standaard Valuation Method
Default Warehouse,Standaard Warehouse
Default Warehouse is mandatory for stock Item.,Standaard Warehouse is verplicht voor voorraad Punt .
Default settings for accounting transactions.,Standaardinstellingen voor boekhoudkundige verrichtingen .
Default settings for buying transactions.,Standaardinstellingen voor het kopen van transacties .
Default settings for selling transactions.,Standaardinstellingen voor verkooptransacties .
Default settings for stock transactions.,Standaardinstellingen voor effectentransacties .
Defense,defensie
"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Definieer budget voor deze kostenplaats. Om de begroting actie in te stellen, zie <a href=""#!List/Company"">Company Master</a>"
Del,Verw.
Delete,Verwijder
Delete {0} {1}?,Verwijder {0} {1} ?
Delivered,Geleverd
Delivered Items To Be Billed,Geleverd Items te factureren
Delivered Qty,Geleverd Aantal
Delivered Serial No {0} cannot be deleted,Geleverd Serienummer {0} kan niet worden verwijderd
Delivery Date,Leveringsdatum
Delivery Details,Levering Details
Delivery Document No,Levering document nr.
Delivery Document Type,Levering Soort document
Delivery Note,Vrachtbrief
Delivery Note Item,Levering Note Item
Delivery Note Items,Levering Opmerking Items
Delivery Note Message,Levering Opmerking Bericht
Delivery Note No,Levering aantekening
Delivery Note Required,Levering Opmerking Verplicht
Delivery Note Trends,Delivery Note Trends
Delivery Note {0} is not submitted,Delivery Note {0} is niet ingediend
Delivery Note {0} must not be submitted,Delivery Note {0} mag niet worden ingediend
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Pakbonnen {0} moet worden geannuleerd voordat het annuleren van deze verkooporder
Delivery Status,Delivery Status
Delivery Time,Levertijd
Delivery To,Levering To
Department,Afdeling
Department Stores,Warenhuizen
Depends on LWP,Afhankelijk van LWP
Depreciation,waardevermindering
Description,Beschrijving
Description HTML,Beschrijving HTML
Designation,Benaming
Designer,ontwerper
Detailed Breakup of the totals,Gedetailleerde Breakup van de totalen
Details,Details
Difference (Dr - Cr),Verschil ( Dr - Cr )
Difference Account,verschil Account
"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Moet verschil account een ' Aansprakelijkheid ' account type te zijn , aangezien dit Stock Verzoening is een Opening Entry"
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 Verpakking voor items zal leiden tot een onjuiste (Totaal ) Netto gewicht waarde . Zorg ervoor dat Netto gewicht van elk item is in dezelfde Verpakking .
Direct Expenses,directe kosten
Direct Income,direct Inkomen
Disable,onbruikbaar maken
Disable Rounded Total,Uitschakelen Afgeronde Totaal
Disabled,Invalide
Discount  %,Korting%
Discount %,Korting%
Discount (%),Korting (%)
Discount Amount,korting Bedrag
"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Korting Velden zal beschikbaar zijn in Bestelbon, bewijs van aankoop Aankoop Factuur"
Discount Percentage,kortingspercentage
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 prijslijst.
Discount must be less than 100,Korting moet minder dan 100 zijn
Discount(%),Korting (%)
Dispatch,verzending
Display all the individual items delivered with the main items,Toon alle afzonderlijke onderdelen geleverd met de belangrijkste onderwerpen
Distribute transport overhead across items.,Verdeel het vervoer overhead van verschillende items.
Distribution,Distributie
Distribution Id,Distributie Id
Distribution Name,Distributie Naam
Distributor,Verdeler
Divorced,Gescheiden
Do Not Contact,Neem geen contact op
Do not show any symbol like $ etc next to currencies.,"Vertonen geen symbool zoals $, enz. naast valuta."
Do really want to unstop production order: ,
Do you really want to STOP ,
Do you really want to STOP this Material Request?,Wil je echt wilt dit materiaal afbreken ?
Do you really want to Submit all Salary Slip for month {0} and year {1},Wil je echt alle salarisstrook voor de maand indienen {0} en {1} jaar
Do you really want to UNSTOP ,
Do you really want to UNSTOP this Material Request?,Wil je echt wilt dit materiaal aanvragen opendraaien ?
Do you really want to stop production order: ,
Doc Name,Doc Naam
Doc Type,Doc Type
Document Description,Document Beschrijving
Document Type,Soort document
Documents,Documenten
Domain,Domein
Don't send Employee Birthday Reminders,Stuur geen Werknemer verjaardagsherinneringen
Download Materials Required,Download Benodigde materialen
Download Reconcilation Data,Download Verzoening gegevens
Download Template,Download Template
Download a report containing all raw materials with their latest inventory status,Download een verslag met alle grondstoffen met hun nieuwste inventaris status
"Download the Template, fill appropriate data and attach the modified file.","Download de Template , vul de juiste gegevens en bevestig het gewijzigde bestand ."
"Download the Template, fill appropriate data and attach the modified file.All dates and employee combination in the selected period will come in the template, with existing attendance records","Download de Template, vul de juiste gegevens en bevestig het gewijzigde bestand. Alle data en werknemer combinatie in de gekozen periode zal komen in de template, met bestaande presentielijsten"
Draft,Ontwerp
Dropbox,Dropbox
Dropbox Access Allowed,Dropbox Toegang toegestaan
Dropbox Access Key,Dropbox Access Key
Dropbox Access Secret,Dropbox Toegang Secret
Due Date,Vervaldag
Due Date cannot be after {0},Due Date mag niet na {0}
Due Date cannot be before Posting Date,Einddatum kan niet voor de Boekingsdatum
Duplicate Entry. Please check Authorization Rule {0},Dubbele vermelding . Controleer Authorization Regel {0}
Duplicate Serial No entered for Item {0},Duplicate Serial Geen ingevoerd voor post {0}
Duplicate entry,dubbele vermelding
Duplicate row {0} with same {1},Duplicate rij {0} met dezelfde {1}
Duties and Taxes,Accijnzen en invoerrechten
ERPNext Setup,ERPNext Setup
Earliest,vroegste
Earnest Money,Earnest Money
Earning,Verdienen
Earning & Deduction,Verdienen &amp; Aftrek
Earning Type,Verdienen Type
Earning1,Earning1
Edit,Redigeren
Edu. Cess on Excise,Edu. Cess op Excise
Edu. Cess on Service Tax,Edu. Ces op Dienst Belastingen
Edu. Cess on TDS,Edu. Cess op TDS
Education,onderwijs
Educational Qualification,Educatieve Kwalificatie
Educational Qualification Details,Educatieve Kwalificatie Details
Eg. smsgateway.com/api/send_sms.cgi,Bijv. smsgateway.com / api / send_sms.cgi
Either debit or credit amount is required for {0},Ofwel debet of credit bedrag is nodig voor {0}
Either target qty or target amount is mandatory,Ofwel doelwit aantal of streefbedrag is verplicht
Either target qty or target amount is mandatory.,Ofwel doelwit aantal of streefbedrag is verplicht.
Electrical,elektrisch
Electricity Cost,elektriciteitskosten
Electricity cost per hour,Kosten elektriciteit per uur
Electronics,elektronica
Email,E-mail
Email Digest,E-mail Digest
Email Digest Settings,E-mail Digest Instellingen
Email Digest: ,
Email Id,E-mail Identiteitskaart
"Email Id where a job applicant will email e.g. ""jobs@example.com""",E-mail Identiteitskaart waar een sollicitant zal bijvoorbeeld &quot;jobs@example.com&quot; e-mail
Email Notifications,e-mailberichten
Email Sent?,E-mail verzonden?
"Email id must be unique, already exists for {0}","E-id moet uniek zijn , al bestaat voor {0}"
Email ids separated by commas.,E-mail ids gescheiden door komma&#39;s.
"Email settings to extract Leads from sales email id e.g. ""sales@example.com""",E-mail instellingen voor Leads uit de verkoop e-id bijvoorbeeld &quot;sales@example.com&quot; extract
Emergency Contact,Emergency Contact
Emergency Contact Details,Emergency Contactgegevens
Emergency Phone,Emergency Phone
Employee,Werknemer
Employee Birthday,Werknemer Verjaardag
Employee Details,Medewerker Details
Employee Education,Medewerker Onderwijs
Employee External Work History,Medewerker Buitendienst Medewerker Geschiedenis
Employee Information,Employee Information
Employee Internal Work History,Medewerker Interne Werk Geschiedenis
Employee Internal Work Historys,Medewerker Interne Werk historys
Employee Leave Approver,Werknemer Verlof Fiatteur
Employee Leave Balance,Werknemer Verlof Balance
Employee Name,Naam werknemer
Employee Number,Medewerker Aantal
Employee Records to be created by,Werknemer Records worden gecreëerd door
Employee Settings,werknemer Instellingen
Employee Type,Type werknemer
"Employee designation (e.g. CEO, Director etc.).","Werknemer aanduiding ( bijv. CEO , directeur enz. ) ."
Employee master.,Werknemer meester .
Employee record is created using selected field. ,Werknemer record wordt gemaakt met behulp van geselecteerde veld.
Employee records.,Employee records.
Employee relieved on {0} must be set as 'Left',Werknemer opgelucht over {0} moet worden ingesteld als 'Links '
Employee {0} has already applied for {1} between {2} and {3},Werknemer {0} heeft reeds toegepast voor {1} tussen {2} en {3}
Employee {0} is not active or does not exist,Werknemer {0} is niet actief of niet bestaat
Employee {0} was on leave on {1}. Cannot mark attendance.,Werknemer {0} was met verlof om {1} . Kan opkomst niet markeren .
Employees Email Id,Medewerkers E-mail Identiteitskaart
Employment Details,Werkgelegenheid Details
Employment Type,Type baan
Enable / disable currencies.,Enable / disable valuta .
Enabled,Ingeschakeld
Encashment Date,Inning Datum
End Date,Einddatum
End Date can not be less than Start Date,Einddatum kan niet lager zijn dan startdatum
End date of current invoice's period,Einddatum van de periode huidige factuur&#39;s
End of Life,End of Life
Energy,energie
Engineer,ingenieur
Enter Verification Code,Voer Verification Code
Enter campaign name if the source of lead is campaign.,Voer naam voor de campagne als de bron van lood is campagne.
Enter department to which this Contact belongs,Voer dienst waaraan deze persoon behoort
Enter designation of this Contact,Voer aanwijzing van deze persoon
"Enter email id separated by commas, invoice will be mailed automatically on particular date","Vul e-id, gescheiden door komma&#39;s, zal factuur automatisch worden gemaild op bepaalde datum"
Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Voer de onderdelen in en geplande aantal waarvoor u wilt productieorders verhogen of grondstoffen voor analyse te downloaden.
Enter name of campaign if source of enquiry is campaign,Voer de naam van de campagne als bron van onderzoek is campagne
"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Voer statische url parameters here (Eg. afzender = ERPNext, username = ERPNext, wachtwoord = 1234 enz.)"
Enter the company name under which Account Head will be created for this Supplier,Voer de bedrijfsnaam waaronder Account hoofd zal worden aangemaakt voor dit bedrijf
Enter url parameter for message,Voer URL-parameter voor bericht
Enter url parameter for receiver nos,Voer URL-parameter voor de ontvanger nos
Entertainment & Leisure,Uitgaan & Vrije Tijd
Entertainment Expenses,representatiekosten
Entries,Inzendingen
Entries against ,
Entries are not allowed against this Fiscal Year if the year is closed.,Inzendingen zijn niet toegestaan ​​tegen deze fiscale jaar als het jaar gesloten is.
Equity,billijkheid
Error: {0} > {1},Fout : {0} > {1}
Estimated Material Cost,Geschatte Materiaal Kosten
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Zelfs als er meerdere Prijzen Regels met de hoogste prioriteit, worden vervolgens volgende interne prioriteiten aangebracht:"
Everyone can read,Iedereen kan lezen
"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 serie is ingesteld en volgnummer wordt niet bij transacties vermeld, zal dan automatisch het serienummer worden gemaakt op basis van deze serie. Als u wilt altijd expliciet te vermelden serienummers voor dit item. dit veld leeg laten."
Exchange Rate,Wisselkoers
Excise Duty 10,Accijns 10
Excise Duty 14,Excise Duty 14
Excise Duty 4,Excise Duty 4
Excise Duty 8,Accijns 8
Excise Duty @ 10,Accijns @ 10
Excise Duty @ 14,Accijns @ 14
Excise Duty @ 4,Accijns @ 4
Excise Duty @ 8,Accijns @ 8
Excise Duty Edu Cess 2,Accijns Edu Cess 2
Excise Duty SHE Cess 1,Accijns SHE Cess 1
Excise Page Number,Accijnzen Paginanummer
Excise Voucher,Accijnzen Voucher
Execution,uitvoering
Executive Search,Executive Search
Exemption Limit,Vrijstelling Limit
Exhibition,Tentoonstelling
Existing Customer,Bestaande klant
Exit,Uitgang
Exit Interview Details,Exit Interview Details
Expected,Verwachte
Expected Completion Date can not be less than Project Start Date,Verwachte oplevering datum kan niet lager zijn dan startdatum van het project zijn
Expected Date cannot be before Material Request Date,Verwachte datum kan niet voor de Material Aanvraagdatum
Expected Delivery Date,Verwachte leverdatum
Expected Delivery Date cannot be before Purchase Order Date,Verwachte leverdatum kan niet voor de Purchase Order Datum
Expected Delivery Date cannot be before Sales Order Date,Verwachte leverdatum kan voordat Sales Order Date niet
Expected End Date,Verwachte einddatum
Expected Start Date,Verwachte startdatum
Expense,kosten
Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Expense / Verschil rekening ({0}) moet een ""Winst of verlies 'rekening worden"
Expense Account,Expense Account
Expense Account is mandatory,Expense Account is verplicht
Expense Claim,Expense Claim
Expense Claim Approved,Expense Claim Goedgekeurd
Expense Claim Approved Message,Expense Claim Goedgekeurd Bericht
Expense Claim Detail,Expense Claim Detail
Expense Claim Details,Expense Claim Details
Expense Claim Rejected,Expense claim afgewezen
Expense Claim Rejected Message,Expense claim afgewezen Bericht
Expense Claim Type,Expense Claim Type
Expense Claim has been approved.,Declaratie is goedgekeurd .
Expense Claim has been rejected.,Declaratie is afgewezen .
Expense Claim is pending approval. Only the Expense Approver can update status.,Declaratie is in afwachting van goedkeuring . Alleen de Expense Approver kan status bijwerken .
Expense Date,Expense Datum
Expense Details,Expense Details
Expense Head,Expense Hoofd
Expense account is mandatory for item {0},Kostenrekening is verplicht voor punt {0}
Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Kosten of Difference account is verplicht voor post {0} als het invloed totale voorraadwaarde
Expenses,uitgaven
Expenses Booked,Kosten geboekt
Expenses Included In Valuation,Kosten inbegrepen In Valuation
Expenses booked for the digest period,Kosten geboekt voor de digest periode
Expiry Date,Vervaldatum
Exports,Export
External,Extern
Extract Emails,Extract Emails
FCFS Rate,FCFS Rate
Failed: ,Mislukt:
Family Background,Familie Achtergrond
Fax,Fax
Features Setup,Features instelscherm
Feed,Voeden
Feed Type,Feed Type
Feedback,Terugkoppeling
Female,Vrouwelijk
Fetch exploded BOM (including sub-assemblies),Fetch ontplofte BOM ( inclusief onderdelen )
"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Veld verkrijgbaar in Delivery Note, Offerte, Sales Invoice, Sales Order"
Files Folder ID,Bestanden Folder ID
Fill the form and save it,Vul het formulier in en sla het
Filter based on customer,Filteren op basis van klant
Filter based on item,Filteren op basis van artikel
Financial / accounting year.,Financiële / boekjaar .
Financial Analytics,Financiële Analytics
Financial Services,Financial Services
Financial Year End Date,Boekjaar Einddatum
Financial Year Start Date,Boekjaar Startdatum
Finished Goods,afgewerkte producten
First Name,Voornaam
First Responded On,Eerste reageerden op
Fiscal Year,Boekjaar
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Boekjaar Startdatum en Boekjaareinde Datum zijn al ingesteld in het fiscale jaar {0}
Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Boekjaar Startdatum en Boekjaareinde datum kan niet meer dan een jaar uit elkaar zijn.
Fiscal Year Start Date should not be greater than Fiscal Year End Date,Boekjaar Startdatum mag niet groter zijn dan het fiscale jaar einddatum
Fixed Asset,vaste Activa
Fixed Assets,vaste activa
Follow via Email,Volg via e-mail
"Following table will show values if items are sub - contracted. These values will be fetched from the master of ""Bill of Materials"" of sub - contracted items.",Na tafel zal waarden als items zijn sub - gecontracteerde. Deze waarden zullen worden opgehaald van de meester van de &quot;Bill of Materials&quot; van sub - gecontracteerde items.
Food,voedsel
"Food, Beverage & Tobacco","Voedsel , drank en tabak"
"For 'Sales BOM' 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 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Voor 'Sales BOM' items, Warehouse, volgnummer en Batch No zullen worden gezien van de 'Packing List' tafel. Als Warehouse en Batch No zijn gelijk voor alle inpakken van objecten voor een 'Sales BOM' post, kunnen deze waarden in de belangrijkste Item tabel worden ingevoerd, zullen de waarden worden gekopieerd naar 'Packing List' tafel."
For Company,Voor Bedrijf
For Employee,Uitvoeringsinstituut Werknemersverzekeringen
For Employee Name,Voor Naam werknemer
For Price List,Prijslijst
For Production,Voor productie
For Reference Only.,Alleen ter referentie.
For Sales Invoice,Voor verkoopfactuur
For Server Side Print Formats,Voor Server Side Print Formats
For Supplier,voor Leverancier
For Warehouse,Voor Warehouse
For Warehouse is required before Submit,Voor Warehouse is vereist voordat Indienen
"For e.g. 2012, 2012-13","Voor bijvoorbeeld 2012, 2012-13"
For reference,Ter referentie
For reference only.,Alleen ter referentie.
"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"
Fraction,Fractie
Fraction Units,Fractie Units
Freeze Stock Entries,Freeze Stock Entries
Freeze Stocks Older Than [Days],Freeze Voorraden Ouder dan [ dagen ]
Freight and Forwarding Charges,Vracht-en verzendingskosten
Friday,Vrijdag
From,Van
From Bill of Materials,Van Bill of Materials
From Company,Van Company
From Currency,Van Valuta
From Currency and To Currency cannot be same,Van Munt en naar Valuta kan niet hetzelfde zijn
From Customer,Van Klant
From Customer Issue,Van Customer Issue
From Date,Van Datum
From Date cannot be greater than To Date,Vanaf de datum kan niet groter zijn dan tot nu toe
From Date must be before To Date,Van datum moet voor-to-date
From Date should be within the Fiscal Year. Assuming From Date = {0},Van datum moet binnen het boekjaar. Ervan uitgaande dat Van Date = {0}
From Delivery Note,Van Delivery Note
From Employee,Van Medewerker
From Lead,Van Lood
From Maintenance Schedule,Van onderhoudsschema
From Material Request,Van Materiaal Request
From Opportunity,van Opportunity
From Package No.,Van Pakket No
From Purchase Order,Van Purchase Order
From Purchase Receipt,Van Kwitantie
From Quotation,van Offerte
From Sales Order,Van verkooporder
From Supplier Quotation,Van Leverancier Offerte
From Time,Van Tijd
From Value,Van Waarde
From and To dates required,Van en naar de data vereist
From value must be less than to value in row {0},Van waarde moet in rij minder dan waarde {0}
Frozen,Bevroren
Frozen Accounts Modifier,Bevroren rekeningen Modifikatie
Fulfilled,Vervulde
Full Name,Volledige naam
Full-time,Full -time
Fully Billed,Volledig gefactureerde
Fully Completed,Volledig ingevulde
Fully Delivered,Volledig geleverd
Furniture and Fixture,Meubilair en Inrichting
Further accounts can be made under Groups but entries can be made against Ledger,"Verder rekeningen kunnen onder Groepen worden gemaakt, maar data kan worden gemaakt tegen Ledger"
"Further accounts can be made under Groups, but entries can be made against Ledger","Nadere accounts kunnen worden gemaakt onder groepen, maar items kunnen worden gemaakt tegen Ledger"
Further nodes can be only created under 'Group' type nodes,Verder nodes kunnen alleen worden gemaakt op grond van het type nodes 'Groep'
GL Entry,GL Entry
Gantt Chart,Gantt-diagram
Gantt chart of all tasks.,Gantt-grafiek van alle taken.
Gender,Geslacht
General,Algemeen
General Ledger,Grootboek
Generate Description HTML,Genereer Beschrijving HTML
Generate Material Requests (MRP) and Production Orders.,Genereer Materiaal Requests (MRP) en productieorders.
Generate Salary Slips,Genereer Salaris Slips
Generate Schedule,Genereer Plan
Generates HTML to include selected image in the description,Genereert HTML aan geselecteerde beeld te nemen in de beschrijving
Get Advances Paid,Get betaalde voorschotten
Get Advances Received,Get ontvangen voorschotten
Get Current Stock,Get Huidige voorraad
Get Items,Get Items
Get Items From Sales Orders,Krijg Items Van klantorders
Get Items from BOM,Items ophalen van BOM
Get Last Purchase Rate,Get Laatst Purchase Rate
Get Outstanding Invoices,Get openstaande facturen
Get Relevant Entries,Krijgen relevante gegevens
Get Sales Orders,Get Verkooporders
Get Specification Details,Get Specificatie Details
Get Stock and Rate,Get voorraad en Rate
Get Template,Get Sjabloon
Get Terms and Conditions,Get Algemene Voorwaarden
Get Unreconciled Entries,Krijgen Unreconciled Entries
Get Weekly Off Dates,Ontvang wekelijkse Uit Data
"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Get waardering tarief en beschikbare voorraad bij de bron / doel pakhuis op de genoemde plaatsen van datum-tijd. Als geserialiseerde item, drukt u op deze toets na het invoeren van seriële nos."
Global Defaults,Global Standaardwaarden
Global POS Setting {0} already created for company {1},Global POS -instelling {0} al gemaakt voor bedrijf {1}
Global Settings,Global Settings
"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account Ledger (by clicking on Add Child) of type ""Bank""","Ga naar de desbetreffende groep ( meestal Toepassing van Fondsen> vlottende activa > bankrekeningen en maak een nieuw account Ledger ( door te klikken op Toevoegen Kind ) van het type "" Bank """
"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account Ledger (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.","Ga naar de desbetreffende groep ( meestal bron van fondsen > kortlopende schulden > Belastingen en accijnzen en maak een nieuwe account Ledger ( door te klikken op Toevoegen Kind ) van het type "" Tax"" en niet vergeten het belastingtarief."
Goal,Doel
Goals,Doelen
Goods received from Suppliers.,Goederen ontvangen van leveranciers.
Google Drive,Google Drive
Google Drive Access Allowed,Google Drive Access toegestaan
Government,overheid
Graduate,Afstuderen
Grand Total,Algemeen totaal
Grand Total (Company Currency),Grand Total (Company Munt)
"Grid ""","Grid """
Grocery,kruidenierswinkel
Gross Margin %,Winstmarge%
Gross Margin Value,Winstmarge Value
Gross Pay,Brutoloon
Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Brutoloon + achteraf Bedrag + inning Bedrag - Totaal Aftrek
Gross Profit,Brutowinst
Gross Profit (%),Brutowinst (%)
Gross Weight,Brutogewicht
Gross Weight UOM,Brutogewicht Verpakking
Group,Groep
Group by Account,Groep door Account
Group by Voucher,Groep door Voucher
Group or Ledger,Groep of Ledger
Groups,Groepen
HR Manager,HR Manager
HR Settings,HR-instellingen
HTML / Banner that will show on the top of product list.,HTML / Banner dat zal laten zien op de bovenkant van het product lijst.
Half Day,Halve dag
Half Yearly,Halfjaarlijkse
Half-yearly,Halfjaarlijks
Happy Birthday!,Happy Birthday!
Hardware,hardware
Has Batch No,Heeft Batch nr.
Has Child Node,Heeft het kind Node
Has Serial No,Heeft Serienummer
Head of Marketing and Sales,Hoofd Marketing en Sales
Header,Hoofd
Health Care,Gezondheidszorg
Health Concerns,Gezondheid Zorgen
Health Details,Gezondheid Details
Held On,Held Op
Help HTML,Help HTML
"Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Help: Om te linken naar een andere record in het systeem, gebruikt &quot;# Vorm / NB / [Note Name] &#39;, zoals de Link URL. (Gebruik geen &quot;http://&quot;)"
"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"
"Here you can maintain height, weight, allergies, medical concerns etc","Hier kunt u onderhouden lengte, gewicht, allergieën, medische zorgen, enz."
Hide Currency Symbol,Verberg Valutasymbool
High,Hoog
History In Company,Geschiedenis In Bedrijf
Hold,Houden
Holiday,Feestdag
Holiday List,Holiday Lijst
Holiday List Name,Holiday Lijst Naam
Holiday master.,Vakantie meester .
Holidays,Vakantie
Home,Thuis
Host,Gastheer
"Host, Email and Password required if emails are to be pulled","Host, e-mail en wachtwoord nodig als e-mails moeten worden getrokken"
Hour,uur
Hour Rate,Uurtarief
Hour Rate Labour,Uurtarief Arbeid
Hours,Uur
How Pricing Rule is applied?,Hoe Pricing regel wordt toegepast?
How frequently?,Hoe vaak?
"How should this currency be formatted? If not set, will use system defaults","Hoe moet deze valuta worden geformatteerd? Indien niet ingesteld, zal gebruik maken van het systeem standaard"
Human Resources,Human Resources
Identification of the package for the delivery (for print),Identificatie van het pakket voor de levering (voor afdrukken)
If Income or Expense,Indien baten of lasten
If Monthly Budget Exceeded,Als Maandelijks Budget overschreden
"If Sale BOM is defined, the actual BOM of the Pack is displayed as table. Available in Delivery Note and Sales Order","Als Verkoop BOM is gedefinieerd , de werkelijke BOM van de Pack wordt weergegeven als tabel . Verkrijgbaar in Delivery Note en Sales Order"
"If Supplier Part Number exists for given Item, it gets stored here","Indien Leverancier Onderdeelnummer bestaat voor bepaalde Item, het wordt hier opgeslagen"
If Yearly Budget Exceeded,Als jaarlijks budget overschreden
"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Indien aangevinkt, zal BOM voor sub-assemblage zaken geacht voor het krijgen van grondstoffen. Anders zullen alle subeenheid items worden behandeld als een grondstof."
"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"
"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"
If different than customer address,Indien anders dan adres van de klant
"If disable, 'Rounded Total' field will not be visible in any transaction","Indien storing, &#39;Afgerond Total&#39; veld niet zichtbaar zijn in een transactie"
"If enabled, the system will post accounting entries for inventory automatically.","Indien ingeschakeld, zal het systeem de boekingen automatisch plaatsen voor de inventaris."
If more than one package of the same type (for print),Als er meer dan een pakket van hetzelfde type (voor afdrukken)
"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."
"If no change in either Quantity or Valuation Rate, leave the cell blank.","Als er geen wijziging optreedt Hoeveelheid of Valuation Rate , verlaat de cel leeg ."
If not applicable please enter: NA,Indien niet van toepassing gelieve: Nvt
"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."
"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, 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.","Indien geselecteerd Prijzen Regel is gemaakt voor 'Prijs', zal het prijslijst overschrijven. Pricing Rule prijs is de uiteindelijke prijs, dus geen verdere korting worden toegepast. Vandaar dat in transacties zoals Sales Order, Bestelling etc, het zal worden opgehaald in 'Rate' veld, in plaats van 'prijslijst Rate' veld."
"If specified, send the newsletter using this email address","Als de opgegeven, stuurt u de nieuwsbrief via dit e-mailadres"
"If the account is frozen, entries are allowed to restricted users.","Als de account wordt gepauzeerd, blijven inzendingen mogen gebruikers met beperkte rechten ."
"If this Account represents a Customer, Supplier or Employee, set it here.","Als dit account is een klant, leverancier of werknemer, hier instellen."
"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 Prijzen Regels zijn gevonden die aan de bovenstaande voorwaarden, wordt prioriteit toegepast. Prioriteit is een getal tussen 0 en 20, terwijl standaardwaarde nul (blanco). Hoger nummer betekent dat het voorrang als er meerdere Prijzen Regels met dezelfde voorwaarden."
If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Als u volgen Kwaliteitscontrole . Stelt Item QA Vereiste en QA Geen in Kwitantie
If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Als je Sales Team en Verkoop Partners (Channel Partners) ze kunnen worden gelabeld en onderhouden van hun bijdrage in de commerciële activiteit
"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Als u hebt gemaakt van een standaard template in Aankoop en-heffingen Meester, selecteert u een en klikt u op de knop."
"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Als u hebt gemaakt van een standaard template in Sales en-heffingen Meester, selecteert u een en klikt u op de knop."
"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Als je al lang af te drukken formaten, kan deze functie gebruikt worden om splitsing van de pagina die moet worden afgedrukt op meerdere pagina&#39;s met alle kop-en voetteksten op elke pagina"
If you involve in manufacturing activity. Enables Item 'Is Manufactured',Als u te betrekken in de productie -activiteit . Stelt Item ' is vervaardigd '
Ignore,Negeren
Ignore Pricing Rule,Negeer Pricing Rule
Ignored: ,Genegeerd:
Image,Beeld
Image View,Afbeelding View
Implementation Partner,Implementatie Partner
Import Attendance,Import Toeschouwers
Import Failed!,Import mislukt!
Import Log,Importeren Inloggen
Import Successful!,Importeer Succesvol!
Imports,Invoer
In Hours,In Hours
In Process,In Process
In Qty,in Aantal
In Value,in Waarde
In Words,In Woorden
In Words (Company Currency),In Woorden (Company Munt)
In Words (Export) will be visible once you save the Delivery Note.,In Words (Export) wordt zichtbaar zodra u bespaart de pakbon.
In Words will be visible once you save the Delivery Note.,In Woorden zijn zichtbaar zodra u bespaart de pakbon.
In Words will be visible once you save the Purchase Invoice.,In Woorden zijn zichtbaar zodra u bespaart de aankoopfactuur.
In Words will be visible once you save the Purchase Order.,In Woorden zijn zichtbaar zodra u bespaart de Bestelbon.
In Words will be visible once you save the Purchase Receipt.,In Woorden zijn zichtbaar zodra u de aankoopbon te bewaren.
In Words will be visible once you save the Quotation.,In Woorden zijn zichtbaar zodra het opslaan van de offerte.
In Words will be visible once you save the Sales Invoice.,In Woorden zijn zichtbaar zodra u bespaart de verkoopfactuur.
In Words will be visible once you save the Sales Order.,In Woorden zijn zichtbaar zodra u bespaart de Verkooporder.
Incentives,Incentives
Include Reconciled Entries,Omvatten Reconciled Entries
Include holidays in Total no. of Working Days,Onder meer vakanties in Total nee. van Werkdagen
Income,inkomen
Income / Expense,Inkomsten / Uitgaven
Income Account,Inkomen account
Income Booked,Inkomen Geboekt
Income Tax,inkomstenbelasting
Income Year to Date,Inkomsten Jaar tot datum
Income booked for the digest period,Inkomsten geboekt voor de digest periode
Incoming,Inkomend
Incoming Rate,Inkomende Rate
Incoming quality inspection.,Inkomende kwaliteitscontrole.
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Onjuist aantal Grootboekposten gevonden. Je zou een verkeerde account hebt geselecteerd in de transactie.
Incorrect or Inactive BOM {0} for Item {1} at row {2},Onjuiste of Inactieve BOM {0} voor post {1} bij rij {2}
Indicates that the package is a part of this delivery (Only Draft),Geeft aan dat het pakket is een onderdeel van deze levering (alleen ontwerp)
Indirect Expenses,indirecte kosten
Indirect Income,indirecte Inkomen
Individual,Individueel
Industry,Industrie
Industry Type,Industry Type
Inspected By,Geïnspecteerd door
Inspection Criteria,Inspectie Criteria
Inspection Required,Inspectie Verplicht
Inspection Type,Inspectie Type
Installation Date,Installatie Datum
Installation Note,Installatie Opmerking
Installation Note Item,Installatie Opmerking Item
Installation Note {0} has already been submitted,Installatie Let op {0} al is ingediend
Installation Status,Installatie Status
Installation Time,Installatie Tijd
Installation date cannot be before delivery date for Item {0},De installatie mag niet vóór leveringsdatum voor post {0}
Installation record for a Serial No.,Installatie record voor een Serienummer
Installed Qty,Aantal geïnstalleerd
Instructions,Instructies
Integrate incoming support emails to Support Ticket,Integreer inkomende support e-mails naar ticket support
Interested,Geïnteresseerd
Intern,intern
Internal,Intern
Internet Publishing,internet Publishing
Introduction,Introductie
Invalid Barcode,Ongeldige Barcode
Invalid Barcode or Serial No,Ongeldige streepjescode of Serienummer
Invalid Mail Server. Please rectify and try again.,Ongeldige Mail Server . Aub verwijderen en probeer het opnieuw .
Invalid Master Name,Ongeldige Master Naam
Invalid User Name or Support Password. Please rectify and try again.,Ongeldige gebruikersnaam of wachtwoord Ondersteuning . Aub verwijderen en probeer het opnieuw .
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ongeldig aantal opgegeven voor product {0} . Hoeveelheid moet groter zijn dan 0 .
Inventory,Inventaris
Inventory & Support,Inventarisatie & Support
Investment Banking,Investment Banking
Investments,investeringen
Invoice Date,Factuurdatum
Invoice Details,Factuurgegevens
Invoice No,Factuur nr.
Invoice Number,Factuurnummer
Invoice Period From,Factuur Periode Van
Invoice Period From and Invoice Period To dates mandatory for recurring invoice,Factuur Periode Van en Factuur periode data verplicht voor terugkerende factuur
Invoice Period To,Factuur periode
Invoice Type,Factuur Type
Invoice/Journal Voucher Details,Factuur / Journal Voucher Details
Invoiced Amount (Exculsive Tax),Factuurbedrag ( Exculsive BTW )
Is Active,Is actief
Is Advance,Is Advance
Is Cancelled,Is Geannuleerd
Is Carry Forward,Is Forward Carry
Is Default,Is Standaard
Is Encash,Is incasseren
Is Fixed Asset Item,Is post der vaste activa
Is LWP,Is LWP
Is Opening,Is openen
Is Opening Entry,Wordt Opening Entry
Is POS,Is POS
Is Primary Contact,Is Primaire contactpersoon
Is Purchase Item,Is Aankoop Item
Is Sales Item,Is Sales Item
Is Service Item,Is Service Item
Is Stock Item,Is Stock Item
Is Sub Contracted Item,Is Sub Gecontracteerde Item
Is Subcontracted,Wordt uitbesteed
Is this Tax included in Basic Rate?,Is dit inbegrepen in de Basic Rate?
Issue,Uitgifte
Issue Date,Uitgiftedatum
Issue Details,Probleem Details
Issued Items Against Production Order,Uitgegeven Artikelen Tegen productieorder
It can also be used to create opening stock entries and to fix stock value.,Het kan ook worden gebruikt voor het openen van de voorraad te maken en om de balans de waarde vast te stellen .
Item,item
Item Advanced,Item Geavanceerde
Item Barcode,Item Barcode
Item Batch Nos,Item Batch Nos
Item Code,Artikelcode
Item Code > Item Group > Brand,Item Code> Artikel Group> Merk
Item Code and Warehouse should already exist.,Item Code en Warehouse moet al bestaan ​​.
Item Code cannot be changed for Serial No.,Item Code kan niet worden gewijzigd voor Serienummer
Item Code is mandatory because Item is not automatically numbered,Item Code is verplicht omdat Item is niet automatisch genummerd
Item Code required at Row No {0},Item Code vereist bij Rij Geen {0}
Item Customer Detail,Item Klant Detail
Item Description,Item Beschrijving
Item Desription,Item desription
Item Details,Item Details
Item Group,Item Group
Item Group Name,Item Groepsnaam
Item Group Tree,Punt Groepsstructuur
Item Group not mentioned in item master for item {0},Post Groep niet in punt meester genoemd voor punt {0}
Item Groups in Details,Artikelgroepen in Details
Item Image (if not slideshow),Item Afbeelding (indien niet diashow)
Item Name,Naam van het punt
Item Naming By,Punt benoemen Door
Item Price,Item Prijs
Item Prices,Item Prijzen
Item Quality Inspection Parameter,Item Kwaliteitscontrole Parameter
Item Reorder,Item opnieuw ordenen
Item Serial No,Item Volgnr
Item Serial Nos,Item serienummers
Item Shortage Report,Punt Tekort Report
Item Supplier,Item Leverancier
Item Supplier Details,Item Product Detail
Item Tax,Item Belasting
Item Tax Amount,Item BTW-bedrag
Item Tax Rate,Item Belastingtarief
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
Item Tax1,Item belastingen1
Item To Manufacture,Item te produceren
Item UOM,Item Verpakking
Item Website Specification,Item Website Specificatie
Item Website Specifications,Item Website Specificaties
Item Wise Tax Detail,Item Wise Tax Detail
Item Wise Tax Detail ,Item Wise Tax Detail
Item is required,Punt is vereist
Item is updated,Het punt wordt bijgewerkt
Item master.,Punt meester .
"Item must be a purchase item, as it is present in one or many Active BOMs","Het punt moet een aankoop item, als het aanwezig is in een of vele Actieve stuklijsten is"
Item or Warehouse for row {0} does not match Material Request,Punt of Warehouse voor rij {0} komt niet overeen Materiaal Request
Item table can not be blank,Item tabel kan niet leeg zijn
Item to be manufactured or repacked,Item te vervaardigen of herverpakt
Item valuation updated,Punt waardering bijgewerkt
Item will be saved by this name in the data base.,Het punt zal worden opgeslagen met deze naam in de databank.
Item {0} appears multiple times in Price List {1},Punt {0} verschijnt meerdere keren in prijslijst {1}
Item {0} does not exist,Punt {0} bestaat niet
Item {0} does not exist in the system or has expired,Punt {0} bestaat niet in het systeem of is verlopen
Item {0} does not exist in {1} {2},Punt {0} bestaat niet in {1} {2}
Item {0} has already been returned,Punt {0} is al teruggekeerd
Item {0} has been entered multiple times against same operation,Punt {0} is meerdere malen opgenomen tegen dezelfde operatie
Item {0} has been entered multiple times with same description or date,Punt {0} is meerdere keren opgenomen met dezelfde beschrijving of datum
Item {0} has been entered multiple times with same description or date or warehouse,Punt {0} is meerdere keren opgenomen met dezelfde beschrijving of datum of magazijn
Item {0} has been entered twice,Punt {0} is tweemaal ingevoerd
Item {0} has reached its end of life on {1},Punt {0} heeft het einde van zijn levensduur bereikt op {1}
Item {0} ignored since it is not a stock item,Punt {0} genegeerd omdat het niet een voorraad artikel
Item {0} is cancelled,Punt {0} wordt geannuleerd
Item {0} is not Purchase Item,Punt {0} is geen aankoop Item
Item {0} is not a serialized Item,Punt {0} is geen series Item
Item {0} is not a stock Item,Punt {0} is geen voorraad artikel
Item {0} is not active or end of life has been reached,Punt {0} is niet actief of einde van de levensduur bereikt is
Item {0} is not setup for Serial Nos. Check Item master,Punt {0} is niet ingesteld voor serienummers controleren Item meester
Item {0} is not setup for Serial Nos. Column must be blank,Punt {0} is niet ingesteld voor Serial Nos kolom moet leeg zijn
Item {0} must be Sales Item,Punt {0} moet Sales Item zijn
Item {0} must be Sales or Service Item in {1},Punt {0} moet Sales of SERVICE in {1}
Item {0} must be Service Item,Punt {0} moet Serviceartikelbeheer zijn
Item {0} must be a Purchase Item,Punt {0} moet een aankoop Item zijn
Item {0} must be a Sales Item,Punt {0} moet een Sales Item zijn
Item {0} must be a Service Item.,Punt {0} moet een service item.
Item {0} must be a Sub-contracted Item,Punt {0} moet een Uitbestede Item zijn
Item {0} must be a stock Item,Punt {0} moet een voorraad artikel zijn
Item {0} must be manufactured or sub-contracted,Punt {0} moet worden vervaardigd of uitbesteed
Item {0} not found,Punt {0} niet gevonden
Item {0} with Serial No {1} is already installed,Punt {0} met Serial No {1} is al geïnstalleerd
Item {0} with same description entered twice,Punt {0} met dezelfde beschrijving tweemaal ingevoerd
"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Item, Garantie, zal AMC (jaarlijks onderhoudscontract) gegevens automatisch worden opgehaald wanneer Serienummer is geselecteerd."
Item-wise Price List Rate,Item- wise Prijslijst Rate
Item-wise Purchase History,Post-wise Aankoop Geschiedenis
Item-wise Purchase Register,Post-wise Aankoop Register
Item-wise Sales History,Post-wise Sales Geschiedenis
Item-wise Sales Register,Post-wise sales Registreren
"Item: {0} managed batch-wise, can not be reconciled using \					Stock Reconciliation, instead use Stock Entry","Item: {0} beheerd batchgewijs, niet kan worden verzoend met behulp van \ Stock Verzoening, in plaats daarvan gebruik Stock Entry"
Item: {0} not found in the system,Item: {0} niet gevonden in het systeem
Items,Artikelen
Items To Be Requested,Items worden aangevraagd
Items required,items nodig
"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty",Items worden aangevraagd die &quot;Niet op voorraad&quot; rekening houdend met alle magazijnen op basis van verwachte aantal en minimale bestelling qty
Items which do not exist in Item master can also be entered on customer's request,Items die niet bestaan ​​in punt master kan ook worden ingevoerd op verzoek van de klant
Itemwise Discount,Itemwise Korting
Itemwise Recommended Reorder Level,Itemwise Aanbevolen Reorder Niveau
Job Applicant,Sollicitant
Job Opening,Vacature
Job Profile,Functieprofiel
Job Title,Functie
"Job profile, qualifications required etc.","Functieprofiel , kwalificaties enz."
Jobs Email Settings,Vacatures E-mailinstellingen
Journal Entries,Journaalposten
Journal Entry,Journal Entry
Journal Voucher,Journal Voucher
Journal Voucher Detail,Journal Voucher Detail
Journal Voucher Detail No,Journal Voucher Detail Geen
Journal Voucher {0} does not have account {1} or already matched,Journal Voucher {0} heeft geen rekening {1} of al geëvenaard
Journal Vouchers {0} are un-linked,Dagboek Vouchers {0} zijn niet- verbonden
Keep a track of communication related to this enquiry which will help for future reference.,Houd een spoor van communicatie met betrekking tot dit onderzoek dat zal helpen voor toekomstig gebruik.
Keep it web friendly 900px (w) by 100px (h),Houd het web vriendelijk 900px ( w ) door 100px ( h )
Key Performance Area,Key Performance Area
Key Responsibility Area,Belangrijke verantwoordelijkheid Area
Kg,kg
LR Date,LR Datum
LR No,LR Geen
Label,Label
Landed Cost Item,Landed Cost Item
Landed Cost Items,Landed Cost Items
Landed Cost Purchase Receipt,Landed Cost Inkoop Ontvangstbewijs
Landed Cost Purchase Receipts,Landed Cost aankoopbonnen
Landed Cost Wizard,Landed Cost Wizard
Landed Cost updated successfully,Landed Cost succesvol bijgewerkt
Language,Taal
Last Name,Achternaam
Last Purchase Rate,Laatste Purchase Rate
Latest,laatst
Lead,Leiden
Lead Details,Lood Details
Lead Id,lead Id
Lead Name,Lead Naam
Lead Owner,Lood Owner
Lead Source,Lood Bron
Lead Status,Lead Status
Lead Time Date,Lead Tijd Datum
Lead Time Days,Lead Time Dagen
Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,Levertijd dagen is het aantal dagen waarmee dit artikel wordt verwacht in uw magazijn. Deze dag wordt opgehaald in Laden en aanvragen als u dit item.
Lead Type,Lood Type
Lead must be set if Opportunity is made from Lead,Lood moet worden ingesteld als Opportunity is gemaakt van lood
Leave Allocation,Laat Toewijzing
Leave Allocation Tool,Laat Toewijzing Tool
Leave Application,Verlofaanvraag
Leave Approver,Laat Fiatteur
Leave Approvers,Verlaat Goedkeurders
Leave Balance Before Application,Laat Balance Voor het aanbrengen
Leave Block List,Laat Block List
Leave Block List Allow,Laat Block List Laat
Leave Block List Allowed,Laat toegestaan ​​Block List
Leave Block List Date,Laat Block List Datum
Leave Block List Dates,Laat Block List Data
Leave Block List Name,Laat Block List Name
Leave Blocked,Laat Geblokkeerde
Leave Control Panel,Laat het Configuratiescherm
Leave Encashed?,Laat verzilverd?
Leave Encashment Amount,Laat inning Bedrag
Leave Type,Laat Type
Leave Type Name,Laat Type Naam
Leave Without Pay,Verlof zonder wedde
Leave application has been approved.,Verlof aanvraag is goedgekeurd .
Leave application has been rejected.,Verlofaanvraag is afgewezen .
Leave approver must be one of {0},Verlaat approver moet een van zijn {0}
Leave blank if considered for all branches,Laat leeg indien dit voor alle vestigingen
Leave blank if considered for all departments,Laat leeg indien dit voor alle afdelingen
Leave blank if considered for all designations,Laat leeg indien overwogen voor alle aanduidingen
Leave blank if considered for all employee types,Laat leeg indien overwogen voor alle werknemer soorten
"Leave can be approved by users with Role, ""Leave Approver""",Laat kan worden goedgekeurd door gebruikers met Role: &quot;Laat Fiatteur&quot;
Leave of type {0} cannot be longer than {1},Verlof van type {0} kan niet langer zijn dan {1}
Leaves Allocated Successfully for {0},Bladeren succesvol Toegewezen voor {0}
Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Bladeren voor type {0} reeds voor Employee {1} voor het fiscale jaar {0}
Leaves must be allocated in multiples of 0.5,"Bladeren moeten in veelvouden van 0,5 worden toegewezen"
Ledger,Grootboek
Ledgers,grootboeken
Left,Links
Legal,wettelijk
Legal Expenses,Juridische uitgaven
Letter Head,Brief Hoofd
Letter Heads for print templates.,Letter Heads voor print templates .
Level,Niveau
Lft,Lft
Liability,aansprakelijkheid
List a few of your customers. They could be organizations or individuals.,Lijst een paar van uw klanten. Ze kunnen organisaties of personen .
List a few of your suppliers. They could be organizations or individuals.,Lijst een paar van uw leveranciers . Ze kunnen organisaties of personen .
List items that form the package.,Lijst items die het pakket vormen.
List this Item in multiple groups on the website.,Lijst deze post in meerdere groepen op de website.
"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.",Een lijst van uw producten of diensten die u koopt of verkoopt .
"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Een lijst van uw fiscale koppen ( zoals btw , accijnzen , ze moeten unieke namen hebben ) en hun standaard tarieven."
Loading...,Loading ...
Loans (Liabilities),Leningen (passiva )
Loans and Advances (Assets),Leningen en voorschotten ( Assets )
Local,lokaal
Login,login
Login with your new User ID,Log in met je nieuwe gebruikersnaam
Logo,Logo
Logo and Letter Heads,Logo en Letter Heads
Lost,verloren
Lost Reason,Verloren Reden
Low,Laag
Lower Income,Lager inkomen
MTN Details,MTN Details
Main,hoofd-
Main Reports,Belangrijkste Rapporten
Maintain Same Rate Throughout Sales Cycle,Onderhouden Zelfde Rate Gedurende Salescyclus
Maintain same rate throughout purchase cycle,Handhaaf dezelfde snelheid gedurende aankoop cyclus
Maintenance,Onderhoud
Maintenance Date,Onderhoud Datum
Maintenance Details,Onderhoud Details
Maintenance Schedule,Onderhoudsschema
Maintenance Schedule Detail,Onderhoudsschema Detail
Maintenance Schedule Item,Onderhoudsschema Item
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'
Maintenance Schedule {0} exists against {0},Onderhoudsschema {0} bestaat tegen {0}
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Onderhoudsschema {0} moet worden geannuleerd voordat het annuleren van deze verkooporder
Maintenance Schedules,Onderhoudsschema&#39;s
Maintenance Status,Onderhoud Status
Maintenance Time,Onderhoud Tijd
Maintenance Type,Onderhoud Type
Maintenance Visit,Onderhoud Bezoek
Maintenance Visit Purpose,Onderhoud Bezoek Doel
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Onderhoud Bezoek {0} moet worden geannuleerd voordat het annuleren van deze verkooporder
Maintenance start date can not be before delivery date for Serial No {0},Onderhoud startdatum kan niet voor de leveringsdatum voor Serienummer {0}
Major/Optional Subjects,Major / keuzevakken
Make ,
Make Accounting Entry For Every Stock Movement,Maak boekhoudkundige afschrijving voor elke Stock Movement
Make Bank Voucher,Maak Bank Voucher
Make Credit Note,Maak Credit Note
Make Debit Note,Maak debetnota
Make Delivery,Maak Levering
Make Difference Entry,Maak Verschil Entry
Make Excise Invoice,Maak Accijnzen Factuur
Make Installation Note,Maak installatie Opmerking
Make Invoice,Maak Factuur
Make Maint. Schedule,Maken Maint . dienstregeling
Make Maint. Visit,Maken Maint . bezoek
Make Maintenance Visit,Maak Maintenance Visit
Make Packing Slip,Maak pakbon
Make Payment,Betalen
Make Payment Entry,Betalen Entry
Make Purchase Invoice,Maak inkoopfactuur
Make Purchase Order,Maak Bestelling
Make Purchase Receipt,Maak Kwitantie
Make Salary Slip,Maak loonstrook
Make Salary Structure,Maak salarisstructuur
Make Sales Invoice,Maak verkoopfactuur
Make Sales Order,Maak klantorder
Make Supplier Quotation,Maak Leverancier Offerte
Make Time Log Batch,Maak tijd Inloggen Batch
Male,Mannelijk
Manage Customer Group Tree.,Beheer Customer Group Boom .
Manage Sales Partners.,Beheer Sales Partners.
Manage Sales Person Tree.,Beheer Sales Person Boom .
Manage Territory Tree.,Beheer Grondgebied Boom.
Manage cost of operations,Beheer kosten van de operaties
Management,beheer
Manager,Manager
"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.",Verplicht als Stock Item is &quot;ja&quot;. Ook de standaard opslagplaats waar de gereserveerde hoeveelheid is ingesteld van Sales Order.
Manufacture against Sales Order,Vervaardiging tegen Verkooporder
Manufacture/Repack,Fabricage / Verpak
Manufactured Qty,Gefabriceerd Aantal
Manufactured quantity will be updated in this warehouse,Gefabriceerd hoeveelheid zal worden bijgewerkt in dit magazijn
Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Geproduceerde hoeveelheid {0} mag niet groter zijn dan gepland quanitity {1} in productieorder {2}
Manufacturer,Fabrikant
Manufacturer Part Number,Partnummer fabrikant
Manufacturing,Productie
Manufacturing Quantity,Productie Aantal
Manufacturing Quantity is mandatory,Manufacturing Kwantiteit is verplicht
Margin,Marge
Marital Status,Burgerlijke staat
Market Segment,Marktsegment
Marketing,afzet
Marketing Expenses,marketingkosten
Married,Getrouwd
Mass Mailing,Mass Mailing
Master Name,Master Naam
Master Name is mandatory if account type is Warehouse,Master Naam is verplicht als account type Warehouse
Master Type,Meester Soort
Masters,Masters
Match non-linked Invoices and Payments.,Match niet-gekoppelde facturen en betalingen.
Material Issue,Materiaal Probleem
Material Receipt,Materiaal Ontvangst
Material Request,Materiaal aanvragen
Material Request Detail No,Materiaal Aanvraag Detail Geen
Material Request For Warehouse,Materiaal Request For Warehouse
Material Request Item,Materiaal aanvragen Item
Material Request Items,Materiaal aanvragen Items
Material Request No,Materiaal aanvragen Geen
Material Request Type,Materiaal Soort aanvraag
Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materiaal aanvragen van maximaal {0} kan worden gemaakt voor post {1} tegen Sales Order {2}
Material Request used to make this Stock Entry,Materiaal Request gebruikt om dit Stock Entry maken
Material Request {0} is cancelled or stopped,Materiaal aanvragen {0} wordt geannuleerd of gestopt
Material Requests for which Supplier Quotations are not created,Materiaal Verzoeken waarvoor Leverancier Offertes worden niet gemaakt
Material Requests {0} created,Materiaal Verzoeken {0} aangemaakt
Material Requirement,Material Requirement
Material Transfer,Materiaaloverdracht
Materials,Materieel
Materials Required (Exploded),Benodigde materialen (Exploded)
Max 5 characters,Max. 5 tekens
Max Days Leave Allowed,Max Dagen Laat toegestaan
Max Discount (%),Max Korting (%)
Max Qty,Max Aantal
Max discount allowed for item: {0} is {1}%,Maximale korting toegestaan voor artikel: {0} is {1}%
Maximum Amount,Maximum Bedrag
Maximum allowed credit is {0} days after posting date,Maximaal toegestane krediet is {0} dagen na de boekingsdatum
Maximum {0} rows allowed,Maximum {0} rijen toegestaan
Maxiumm discount for Item {0} is {1}%,Maxiumm korting voor post {0} is {1} %
Medical,medisch
Medium,Medium
"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company",Samenvoegen is alleen mogelijk als volgende eigenschappen zijn hetzelfde in beide dossiers .
Message,Bericht
Message Parameter,Bericht Parameter
Message Sent,bericht verzonden
Message updated,bericht geactualiseerd
Messages,Berichten
Messages greater than 160 characters will be split into multiple messages,Bericht van meer dan 160 tekens worden opgesplitst in meerdere mesage
Middle Income,Midden Inkomen
Milestone,Mijlpaal
Milestone Date,Mijlpaal Datum
Milestones,Mijlpalen
Milestones will be added as Events in the Calendar,Mijlpalen worden toegevoegd als evenementen in deze kalender
Min Order Qty,Minimum Aantal
Min Qty,min Aantal
Min Qty can not be greater than Max Qty,Min Aantal kan niet groter zijn dan Max Aantal zijn
Minimum Amount,Minimumbedrag
Minimum Order Qty,Minimum Aantal
Minute,minuut
Misc Details,Misc Details
Miscellaneous Expenses,diverse kosten
Miscelleneous,Miscelleneous
Mobile No,Mobiel Nog geen
Mobile No.,Mobile No
Mode of Payment,Wijze van betaling
Modern,Modern
Monday,Maandag
Month,Maand
Monthly,Maandelijks
Monthly Attendance Sheet,Maandelijkse Toeschouwers Sheet
Monthly Earning & Deduction,Maandelijkse Verdienen &amp; Aftrek
Monthly Salary Register,Maandsalaris Register
Monthly salary statement.,Maandsalaris verklaring.
More Details,Meer details
More Info,Meer info
Motion Picture & Video,Motion Picture & Video
Moving Average,Moving Average
Moving Average Rate,Moving Average Rate
Mr,De heer
Ms,Mevrouw
Multiple Item prices.,Meerdere Artikelprijzen .
"Multiple Price Rule exists with same criteria, please resolve \			conflict by assigning priority. Price Rules: {0}","Prijs Regel Meerdere bestaat met dezelfde criteria, dan kunt u oplossen door \ conflict door het toekennen van prioriteit. Prijs Regels: {0}"
Music,muziek
Must be Whole Number,Moet heel getal zijn
Name,Naam
Name and Description,Naam en beschrijving
Name and Employee ID,Naam en Employee ID
"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Naam van de nieuwe account . Let op : Gelieve niet goed voor klanten en leveranciers te maken, worden ze automatisch gemaakt op basis van cliënt en leverancier, meester"
Name of person or organization that this address belongs to.,Naam van de persoon of organisatie die dit adres behoort.
Name of the Budget Distribution,Naam van de begroting Distribution
Naming Series,Benoemen Series
Negative Quantity is not allowed,Negatieve Hoeveelheid is niet toegestaan
Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negatieve Stock Error ( {6} ) voor post {0} in Pakhuis {1} op {2} {3} in {4} {5}
Negative Valuation Rate is not allowed,Negatieve waardering Rate is niet toegestaan
Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Negatief saldo in Lot {0} voor post {1} bij Warehouse {2} op {3} {4}
Net Pay,Nettoloon
Net Pay (in words) will be visible once you save the Salary Slip.,Netto loon (in woorden) zal zichtbaar zodra het opslaan van de loonstrook.
Net Profit / Loss,Netto winst / verlies
Net Total,Net Total
Net Total (Company Currency),Netto Totaal (Bedrijf Munt)
Net Weight,Netto Gewicht
Net Weight UOM,Netto Gewicht Verpakking
Net Weight of each Item,Netto gewicht van elk item
Net pay cannot be negative,Nettoloon kan niet negatief zijn
Never,Nooit
New ,
New Account,nieuw account
New Account Name,Nieuw account Naam
New BOM,Nieuwe BOM
New Communications,Nieuwe Communications
New Company,nieuw bedrijf
New Cost Center,Nieuwe kostenplaats
New Cost Center Name,Nieuwe kostenplaats Naam
New Delivery Notes,Nieuwe Delivery Notes
New Enquiries,Nieuwe Inlichtingen
New Leads,Nieuwe leads
New Leave Application,Nieuwe verlofaanvraag
New Leaves Allocated,Nieuwe bladeren Toegewezen
New Leaves Allocated (In Days),Nieuwe Bladeren Toegewezen (in dagen)
New Material Requests,Nieuw Materiaal Verzoeken
New Projects,Nieuwe projecten
New Purchase Orders,Nieuwe bestellingen
New Purchase Receipts,Nieuwe aankoopbonnen
New Quotations,Nieuwe Citaten
New Sales Orders,Nieuwe Verkooporders
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nieuwe Serienummer kunt niet Warehouse. Warehouse moet door Stock Entry of Kwitantie worden ingesteld
New Stock Entries,Nieuwe toevoegingen aan de voorraden
New Stock UOM,Nieuwe Voorraad Verpakking
New Stock UOM is required,Nieuw Stock UOM nodig
New Stock UOM must be different from current stock UOM,Nieuw Stock Verpakking moet verschillen van huidige voorraad Verpakking zijn
New Supplier Quotations,Nieuwe leverancier Offertes
New Support Tickets,Nieuwe Support Tickets
New UOM must NOT be of type Whole Number,Nieuw Verpakking mag NIET van het type Geheel getal zijn
New Workplace,Nieuwe werkplek
Newsletter,Nieuwsbrief
Newsletter Content,Nieuwsbrief Inhoud
Newsletter Status,Nieuwsbrief Status
Newsletter has already been sent,Newsletter reeds verzonden
"Newsletters to contacts, leads.","Nieuwsbrieven naar contacten, leidt."
Newspaper Publishers,Newspaper Publishers
Next,volgende
Next Contact By,Volgende Contact Door
Next Contact Date,Volgende Contact Datum
Next Date,Volgende datum
Next email will be sent on:,Volgende e-mail wordt verzonden op:
No,Geen
No Customer Accounts found.,Geen Customer Accounts gevonden .
No Customer or Supplier Accounts found,Geen klant of leverancier Accounts gevonden
No Expense Approvers. Please assign 'Expense Approver' Role to atleast one user,Geen kosten Goedkeurders . Gelieve toewijzen ' Expense Approver ' Rol om tenminste een gebruiker
No Item with Barcode {0},Geen Item met Barcode {0}
No Item with Serial No {0},Geen Item met Serienummer {0}
No Items to pack,Geen items om te pakken
No Leave Approvers. Please assign 'Leave Approver' Role to atleast one user,Geen Leave Goedkeurders . Gelieve ' Leave Approver ' Rol toewijzen aan tenminste een gebruiker
No Permission,Geen toestemming
No Production Orders created,Geen productieorders aangemaakt
No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,Geen Leverancier Accounts gevonden . Leverancier Accounts worden geïdentificeerd op basis van 'Master Type' waarde in rekening te nemen.
No accounting entries for the following warehouses,Geen boekingen voor de volgende magazijnen
No addresses created,Geen adressen aangemaakt
No contacts created,Geen contacten gemaakt
No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Geen standaard-adres Template gevonden. Maak een nieuwe van Setup> Afdrukken en Branding> Address Template.
No default BOM exists for Item {0},Geen standaard BOM bestaat voor post {0}
No description given,Geen beschrijving gegeven
No employee found,Geen enkele werknemer gevonden
No employee found!,Geen enkele werknemer gevonden !
No of Requested SMS,Geen van de gevraagde SMS
No of Sent SMS,Geen van Sent SMS
No of Visits,Geen van bezoeken
No permission,geen toestemming
No record found,Geen record gevonden
No records found in the Invoice table,Geen records gevonden in de factuur tabel
No records found in the Payment table,Geen records gevonden in de betaling tabel
No salary slip found for month: ,Geen loonstrook gevonden voor de maand:
Non Profit,non Profit
Nos,nos
Not Active,Niet actief
Not Applicable,Niet van toepassing
Not Available,niet beschikbaar
Not Billed,Niet in rekening gebracht
Not Delivered,Niet geleverd
Not Set,niet instellen
Not allowed to update stock transactions older than {0},Niet toegestaan om transacties in effecten ouder dan updaten {0}
Not authorized to edit frozen Account {0},Niet bevoegd om bevroren account bewerken {0}
Not authroized since {0} exceeds limits,Niet authroized sinds {0} overschrijdt grenzen
Not permitted,niet toegestaan
Note,Nota
Note User,Opmerking Gebruiker
"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Opmerking: Back-ups en bestanden worden niet verwijderd van Dropbox, moet u ze handmatig verwijdert."
"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Opmerking: Back-ups en bestanden worden niet verwijderd uit Google Drive, moet u ze handmatig verwijdert."
Note: Due Date exceeds the allowed credit days by {0} day(s),Opmerking : Due Date overschrijdt de toegestane krediet dagen door {0} dag (en )
Note: Email will not be sent to disabled users,Opmerking: E-mail wordt niet verzonden naar gebruikers met een handicap
Note: Item {0} entered multiple times,Opmerking : Item {0} ingevoerd meerdere keren
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Let op : De betaling krijgt u geen toegang gemaakt sinds ' Cash of bankrekening ' is niet opgegeven
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
Note: There is not enough leave balance for Leave Type {0},Opmerking : Er is niet genoeg verlofsaldo voor Verlof type {0}
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Opmerking: Deze kostenplaats is een groep . Kan boekingen van groepen niet te maken.
Note: {0},Opmerking : {0}
Notes,Opmerkingen
Notes:,Opmerkingen:
Nothing to request,Niets aan te vragen
Notice (days),Notice ( dagen )
Notification Control,Kennisgeving Controle
Notification Email Address,Melding e-mail adres
Notify by Email on creation of automatic Material Request,Informeer per e-mail op de creatie van automatische Materiaal Request
Number Format,Getalnotatie
Offer Date,aanbieding Datum
Office,Kantoor
Office Equipments,Office Uitrustingen
Office Maintenance Expenses,Office onderhoudskosten
Office Rent,Office Rent
Old Parent,Oude Parent
On Net Total,On Net Totaal
On Previous Row Amount,Op de vorige toer Bedrag
On Previous Row Total,Op de vorige toer Totaal
Online Auctions,online Veilingen
Only Leave Applications with status 'Approved' can be submitted,Alleen Laat Toepassingen met de status ' Goedgekeurd ' kunnen worden ingediend
"Only Serial Nos with status ""Available"" can be delivered.","Alleen serienummers met de status ""Beschikbaar"" kan worden geleverd."
Only leaf nodes are allowed in transaction,Alleen leaf nodes zijn toegestaan ​​in transactie
Only the selected Leave Approver can submit this Leave Application,Alleen de geselecteerde Leave Approver kan deze verlofaanvraag indienen
Open,Open
Open Production Orders,Open productieorders
Open Tickets,Open Kaarten
Opening (Cr),Opening ( Cr )
Opening (Dr),Opening ( Dr )
Opening Date,Opening Datum
Opening Entry,Opening Entry
Opening Qty,Opening Aantal
Opening Time,Opening Time
Opening Value,Opening Waarde
Opening for a Job.,Opening voor een baan.
Operating Cost,Operationele kosten
Operation Description,Operatie Beschrijving
Operation No,Operation No
Operation Time (mins),Operatie Tijd (min.)
Operation {0} is repeated in Operations Table,Operatie {0} wordt herhaald in Operations Tabel
Operation {0} not present in Operations Table,Operatie {0} niet in Operations Tabel
Operations,Operations
Opportunity,Kans
Opportunity Date,Opportunity Datum
Opportunity From,Opportunity Van
Opportunity Item,Opportunity Item
Opportunity Items,Opportunity Items
Opportunity Lost,Opportunity Verloren
Opportunity Type,Type functie
Optional. This setting will be used to filter in various transactions.,Optioneel. Deze instelling wordt gebruikt om te filteren op diverse transacties .
Order Type,Bestel Type
Order Type must be one of {0},Bestel Type moet een van zijn {0}
Ordered,bestelde
Ordered Items To Be Billed,Bestelde artikelen te factureren
Ordered Items To Be Delivered,Besteld te leveren zaken
Ordered Qty,bestelde Aantal
"Ordered Qty: Quantity ordered for purchase, but not received.","Bestelde Aantal : Aantal besteld voor aankoop , maar niet ontvangen ."
Ordered Quantity,Bestelde hoeveelheid
Orders released for production.,Bestellingen vrijgegeven voor productie.
Organization Name,Naam van de Organisatie
Organization Profile,organisatie Profiel
Organization branch master.,Organisatie tak meester .
Organization unit (department) master.,Organisatie -eenheid (departement) meester.
Other,Ander
Other Details,Andere Details
Others,anderen
Out Qty,out Aantal
Out Value,out Waarde
Out of AMC,Uit AMC
Out of Warranty,Out of Warranty
Outgoing,Uitgaande
Outstanding Amount,Openstaande bedrag
Outstanding for {0} cannot be less than zero ({1}),Uitstekend voor {0} mag niet kleiner zijn dan nul ( {1} )
Overhead,Boven het hoofd
Overheads,overheadkosten
Overlapping conditions found between:,Overlappende voorwaarden gevonden tussen :
Overview,Overzicht
Owned,Owned
Owner,eigenaar
P L A - Cess Portion,PLA - Cess Portie
PL or BS,PL of BS
PO Date,PO Datum
PO No,PO Geen
POP3 Mail Server,POP3-e-mailserver
POP3 Mail Settings,POP3-mailinstellingen
POP3 mail server (e.g. pop.gmail.com),POP3-mailserver (bv pop.gmail.com)
POP3 server e.g. (pop.gmail.com),POP3-server bijvoorbeeld (pop.gmail.com)
POS Setting,POS-instelling
POS Setting required to make POS Entry,POS -instelling verplicht om POS Entry maken
POS Setting {0} already created for user: {1} and company {2},POS -instelling {0} al gemaakt voor de gebruiker : {1} en {2} bedrijf
POS View,POS View
PR Detail,PR Detail
Package Item Details,Pakket Item Details
Package Items,Pakket Artikelen
Package Weight Details,Pakket gewicht details
Packed Item,Levering Opmerking Verpakking Item
Packed quantity must equal quantity for Item {0} in row {1},Verpakt hoeveelheid moet hoeveelheid die gelijk is voor post {0} in rij {1}
Packing Details,Details van de verpakking
Packing List,Paklijst
Packing Slip,Pakbon
Packing Slip Item,Pakbon Item
Packing Slip Items,Pakbon Items
Packing Slip(s) cancelled,Pakbon ( s ) geannuleerd
Page Break,Pagina-einde
Page Name,Page Name
Paid Amount,Betaalde Bedrag
Paid amount + Write Off Amount can not be greater than Grand Total,Betaalde bedrag + Schrijf Uit Het bedrag kan niet groter zijn dan eindtotaal worden
Pair,paar
Parameter,Parameter
Parent Account,Parent Account
Parent Cost Center,Parent kostenplaats
Parent Customer Group,Bovenliggende klant Group
Parent Detail docname,Parent Detail docname
Parent Item,Parent Item
Parent Item Group,Parent Item Group
Parent Item {0} must be not Stock Item and must be a Sales Item,Parent Item {0} mag niet Stock Item zijn en moet een Sales Item zijn
Parent Party Type,Bovenliggende partij Type
Parent Sales Person,Parent Sales Person
Parent Territory,Parent Territory
Parent Website Page,Ouder Website Pagina
Parent Website Route,Ouder Website Route
Parenttype,Parenttype
Part-time,Deeltijds
Partially Completed,Gedeeltelijk afgesloten
Partly Billed,Deels Gefactureerd
Partly Delivered,Deels geleverd
Partner Target Detail,Partner Target Detail
Partner Type,Partner Type
Partner's Website,Website partner
Party,Partij
Party Account,Party Account
Party Type,partij Type
Party Type Name,Partij Type Naam
Passive,Passief
Passport Number,Nummer van het paspoort
Password,Wachtwoord
Pay To / Recd From,Pay To / RECD Van
Payable,betaalbaar
Payables,Schulden
Payables Group,Schulden Groep
Payment Days,Betaling Dagen
Payment Due Date,Betaling Due Date
Payment Period Based On Invoice Date,Betaling Periode Based On Factuurdatum
Payment Reconciliation,Betaling Verzoening
Payment Reconciliation Invoice,Betaling Verzoening Factuur
Payment Reconciliation Invoices,Betaling Verzoening Facturen
Payment Reconciliation Payment,Betaling Betaling Verzoening
Payment Reconciliation Payments,Betaling Verzoening Betalingen
Payment Type,betaling Type
Payment cannot be made for empty cart,Betaling kan niet worden gemaakt van lege kar
Payment of salary for the month {0} and year {1},Betaling van salaris voor de maand {0} en {1} jaar
Payments,Betalingen
Payments Made,Betalingen Made
Payments Received,Betalingen ontvangen
Payments made during the digest period,Betalingen in de loop van de digest periode
Payments received during the digest period,Betalingen ontvangen tijdens de digest periode
Payroll Settings,payroll -instellingen
Pending,In afwachting van
Pending Amount,In afwachting van Bedrag
Pending Items {0} updated,Wachtende items {0} bijgewerkt
Pending Review,In afwachting Beoordeling
Pending SO Items For Purchase Request,In afwachting van SO Artikelen te Purchase Request
Pension Funds,pensioenfondsen
Percent Complete,Percentage voltooid
Percentage Allocation,Percentage Toewijzing
Percentage Allocation should be equal to 100%,Percentage toewijzing moet gelijk zijn aan 100 % te zijn
Percentage variation in quantity to be allowed while receiving or delivering this item.,Percentage variërende hoeveelheid te mogen tijdens het ontvangen of versturen van dit item.
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 mag ontvangen of te leveren meer tegen de bestelde hoeveelheid. Bijvoorbeeld: Als u heeft besteld 100 eenheden. en uw Allowance is 10% dan mag je 110 eenheden ontvangen.
Performance appraisal.,Beoordeling van de prestaties.
Period,periode
Period Closing Voucher,Periode Closing Voucher
Periodicity,Periodiciteit
Permanent Address,Permanente Adres
Permanent Address Is,Vast adres
Permission,Toestemming
Personal,Persoonlijk
Personal Details,Persoonlijke Gegevens
Personal Email,Persoonlijke e-mail
Pharmaceutical,farmaceutisch
Pharmaceuticals,Pharmaceuticals
Phone,Telefoon
Phone No,Telefoon nr.
Piecework,stukwerk
Pincode,Pincode
Place of Issue,Plaats van uitgave
Plan for maintenance visits.,Plan voor onderhoud bezoeken.
Planned Qty,Geplande Aantal
"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Geplande Aantal : Aantal , waarvoor , productieorder is verhoogd , maar is in afwachting van te worden vervaardigd."
Planned Quantity,Geplande Aantal
Planning,planning
Plant,Plant
Plant and Machinery,Plant and Machinery
Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Gelieve goed op Enter Afkorting of korte naam als het zal worden toegevoegd als suffix aan alle Account Heads.
Please Update SMS Settings,Werk SMS-instellingen
Please add expense voucher details,Gelieve te voegen koste voucher informatie
Please add to Modes of Payment from Setup.,Gelieve te voegen aan vormen van betaling van Setup.
Please check 'Is Advance' against Account {0} if this is an advance entry.,Kijk ' Is Advance ' tegen account {0} als dit is een voorschot binnenkomst .
Please click on 'Generate Schedule',Klik op ' Generate Schedule'
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Klik op ' Generate Schedule' te halen Serial No toegevoegd voor post {0}
Please click on 'Generate Schedule' to get schedule,Klik op ' Generate Schedule' schema te krijgen
Please create Customer from Lead {0},Maak Klant van Lead {0}
Please create Salary Structure for employee {0},Maak salarisstructuur voor werknemer {0}
Please create new account from Chart of Accounts.,Maak nieuwe account van Chart of Accounts .
Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Gelieve niet Account ( Grootboeken ) te creëren voor klanten en leveranciers . Ze worden rechtstreeks vanuit de klant / leverancier- meesters.
Please enter 'Expected Delivery Date',Vul ' Verwachte leverdatum '
Please enter 'Is Subcontracted' as Yes or No,Vul ' Is Uitbesteed ' als Ja of Nee
Please enter 'Repeat on Day of Month' field value,Vul de 'Repeat op de Dag van de Maand ' veldwaarde
Please enter Account Receivable/Payable group in company master,Vul Debiteuren / Crediteuren groep in gezelschap meester
Please enter Approving Role or Approving User,Vul Goedkeuren Rol of Goedkeuren Gebruiker
Please enter BOM for Item {0} at row {1},Vul BOM voor post {0} op rij {1}
Please enter Company,Vul Company
Please enter Cost Center,Vul kostenplaats
Please enter Delivery Note No or Sales Invoice No to proceed,Vul Delivery Note Geen of verkoopfactuur Nee om door te gaan
Please enter Employee Id of this sales parson,Vul Werknemer Id van deze verkoop dominee
Please enter Expense Account,Vul Expense Account
Please enter Item Code to get batch no,Vul de artikelcode voor batch niet krijgen
Please enter Item Code.,Vul Item Code .
Please enter Item first,Gelieve eerst in Item
Please enter Maintaince Details first,Vul Maintaince Details eerste
Please enter Master Name once the account is created.,Vul Master Naam zodra het account is aangemaakt .
Please enter Planned Qty for Item {0} at row {1},Vul Geplande Aantal voor post {0} op rij {1}
Please enter Production Item first,Vul Productie Item eerste
Please enter Purchase Receipt No to proceed,Vul Kwitantie Nee om door te gaan
Please enter Reference date,Vul Peildatum
Please enter Warehouse for which Material Request will be raised,Vul Warehouse waarvoor Materiaal Request zal worden verhoogd
Please enter Write Off Account,Vul Schrijf Off account
Please enter atleast 1 invoice in the table,Vul tenminste 1 factuur in de tabel
Please enter company first,Gelieve eerst in bedrijf
Please enter company name first,Vul de naam van het bedrijf voor het eerst
Please enter default Unit of Measure,Vul Standaard meeteenheid
Please enter default currency in Company Master,Vul de standaard valuta in Bedrijf Master
Please enter email address,Vul het e-mailadres
Please enter item details,Vul objectgegevens
Please enter message before sending,Gelieve bericht voordat u
Please enter parent account group for warehouse account,Vul ouderaccount groep voor magazijn rekening
Please enter parent cost center,Vul ouder kostenplaats
Please enter quantity for Item {0},Graag het aantal voor post {0}
Please enter relieving date.,Vul het verlichten datum .
Please enter sales order in the above table,Vul de verkooporder in de bovenstaande tabel
Please enter valid Company Email,Voer geldige Company Email
Please enter valid Email Id,Voer een geldig e Id
Please enter valid Personal Email,Voer geldige Personal Email
Please enter valid mobile nos,Voer geldige mobiele nos
Please find attached Sales Invoice #{0},Gelieve in bijlage verkoopfactuur # {0}
Please install dropbox python module,Installeer dropbox python module
Please mention no of visits required,Vermeld geen bezoeken nodig
Please pull items from Delivery Note,Gelieve te trekken items uit Delivery Note
Please save the Newsletter before sending,Wij verzoeken u de nieuwsbrief voor het verzenden
Please save the document before generating maintenance schedule,Bewaar het document voordat het genereren van onderhoudsschema
Please see attachment,Zie bijlage
Please select Bank Account,Selecteer Bankrekening
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
Please select Category first,Selecteer Categorie eerst
Please select Charge Type first,Selecteer Charge Type eerste
Please select Fiscal Year,Selecteer boekjaar
Please select Group or Ledger value,Selecteer Groep of Ledger waarde
Please select Incharge Person's name,Selecteer de naam Incharge Person's
Please select Invoice Type and Invoice Number in atleast one row,Selecteer Factuur Type en factuurnummer in tenminste een rij
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Selecteer aub Punt waar "" Is Stock Item "" is ""Nee"" en "" Is Sales Item"" ""ja"" en er is geen andere Sales BOM"
Please select Price List,Selecteer Prijs Lijst
Please select Start Date and End Date for Item {0},Selecteer Start en Einddatum voor post {0}
Please select Time Logs.,Selecteer Time Logs.
Please select a csv file,Selecteer een CSV-bestand
Please select a valid csv file with data,Selecteer een geldige CSV-bestand met gegevens
Please select a value for {0} quotation_to {1},Selecteer een waarde voor {0} quotation_to {1}
"Please select an ""Image"" first","Selecteer aub een "" beeld"" eerste"
Please select charge type first,Selecteer het type lading eerst
Please select company first,Selecteer eerst bedrijf
Please select company first.,Selecteer eerst bedrijf.
Please select item code,Selecteer aub artikelcode
Please select month and year,Selecteer maand en jaar
Please select prefix first,Selecteer prefix eerste
Please select the document type first,Selecteer het documenttype eerste
Please select weekly off day,Selecteer wekelijkse rotdag
Please select {0},Selecteer dan {0}
Please select {0} first,Selecteer {0} eerste
Please select {0} first.,Selecteer {0} eerste.
Please set Dropbox access keys in your site config,Stel Dropbox toegang sleutels in uw site config
Please set Google Drive access keys in {0},Stel Google Drive toegang sleutels in {0}
Please set default Cash or Bank account in Mode of Payment {0},Stel standaard Cash of bankrekening in wijze van betaling {0}
Please set default value {0} in Company {0},Stel standaard waarde {0} in Bedrijf {0}
Please set {0},Stel {0}
Please setup Employee Naming System in Human Resource > HR Settings,Gelieve setup Employee Naming System in Human Resource&gt; HR-instellingen
Please setup numbering series for Attendance via Setup > Numbering Series,Gelieve setup nummerreeks voor het bijwonen via Setup > Nummering Series
Please setup your chart of accounts before you start Accounting Entries,Behagen opstelling uw rekeningschema voordat u start boekingen
Please specify,Gelieve te specificeren
Please specify Company,Specificeer Company
Please specify Company to proceed,Specificeer Company om verder te gaan
Please specify Default Currency in Company Master and Global Defaults,Gelieve te specificeren Standaard valuta in Bedrijf Master en Global Defaults
Please specify a,Geef een
Please specify a valid 'From Case No.',Geef een geldige &#39;Van Case No&#39;
Please specify a valid Row ID for {0} in row {1},Geef een geldig rij -ID voor {0} in rij {1}
Please specify either Quantity or Valuation Rate or both,Specificeer ofwel Hoeveelheid of Valuation Rate of beide
Please submit to update Leave Balance.,Gelieve te werken verlofsaldo .
Plot,plot
Plot By,plot Door
Point of Sale,Point of Sale
Point-of-Sale Setting,Point-of-Sale-instelling
Post Graduate,Post Graduate
Postal,Post-
Postal Expenses,portokosten
Posting Date,Plaatsingsdatum
Posting Time,Posting Time
Posting date and posting time is mandatory,Boekingsdatum en detachering is verplicht
Posting timestamp must be after {0},Posting timestamp moet na {0}
Potential opportunities for selling.,Potentiële mogelijkheden voor de verkoop.
Preferred Billing Address,Voorkeur Factuuradres
Preferred Shipping Address,Voorkeur verzendadres
Prefix,Voorvoegsel
Present,Presenteer
Prevdoc DocType,Prevdoc DocType
Prevdoc Doctype,Prevdoc Doctype
Preview,Voorbeeld
Previous,vorig
Previous Work Experience,Vorige Werkervaring
Price,prijs
Price / Discount,Prijs / Korting
Price List,Prijslijst
Price List Currency,Prijslijst Valuta
Price List Currency not selected,Prijslijst Munt nog niet geselecteerd
Price List Exchange Rate,Prijslijst Wisselkoers
Price List Name,Prijslijst Naam
Price List Rate,Prijslijst Prijs
Price List Rate (Company Currency),Prijslijst Rate (Company Munt)
Price List master.,Prijslijst meester .
Price List must be applicable for Buying or Selling,Prijslijst moet van toepassing voor de aankoop of verkoop zijn
Price List not selected,Prijslijst niet geselecteerd
Price List {0} is disabled,Prijslijst {0} is uitgeschakeld
Price or Discount,Prijs of korting
Pricing Rule,Pricing Rule
Pricing Rule Help,Pricing Rule Help
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Pricing Rule wordt eerst geselecteerd op basis van 'Toepassen op' veld, dat kan zijn item, artikel Group of merk."
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Prijsstelling Regel is gemaakt om te overschrijven prijslijst / define kortingspercentage, gebaseerd op een aantal criteria."
Pricing Rules are further filtered based on quantity.,Pricing regels worden verder gefilterd op basis van kwantiteit.
Print Format Style,Print Format Style
Print Heading,Print rubriek
Print Without Amount,Printen zonder Bedrag
Print and Stationary,Print en stationaire
Printing and Branding,Printen en Branding
Priority,Prioriteit
Private Equity,private Equity
Privilege Leave,Privilege Leave
Probation,proeftijd
Process Payroll,Proces Payroll
Produced,geproduceerd
Produced Quantity,Geproduceerd Aantal
Product Enquiry,Product Aanvraag
Production,productie
Production Order,Productieorder
Production Order status is {0},Productie Order status is {0}
Production Order {0} must be cancelled before cancelling this Sales Order,Productie Order {0} moet worden geannuleerd voordat het annuleren van deze verkooporder
Production Order {0} must be submitted,Productie Order {0} moet worden ingediend
Production Orders,Productieorders
Production Orders in Progress,Productieorders in Progress
Production Plan Item,Productie Plan Item
Production Plan Items,Productie Plan Items
Production Plan Sales Order,Productie Plan Verkooporder
Production Plan Sales Orders,Productie Plan Verkooporders
Production Planning Tool,Productie Planning Tool
Products,producten
"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Producten worden gesorteerd op gewicht-leeftijd in verzuim zoekopdrachten. Meer van het gewicht-leeftijd, zal een hogere het product in de lijst."
Professional Tax,Professionele Tax
Profit and Loss,Winst-en verliesrekening
Profit and Loss Statement,Winst-en verliesrekening
Project,Project
Project Costing,Project Costing
Project Details,Details van het project
Project Manager,project Manager
Project Milestone,Project Milestone
Project Milestones,Project Milestones
Project Name,Naam van het project
Project Start Date,Project Start Datum
Project Type,Project Type
Project Value,Project Value
Project activity / task.,Project activiteit / taak.
Project master.,Project meester.
Project will get saved and will be searchable with project name given,Project zal gered worden en zal doorzoekbaar met de gegeven naam van het project
Project wise Stock Tracking,Project verstandig Stock Tracking
Project-wise data is not available for Quotation,Project - wise gegevens is niet beschikbaar voor Offerte
Projected,verwachte
Projected Qty,Verwachte Aantal
Projects,Projecten
Projects & System,Projecten & Systeem
Prompt for Email on Submission of,Vragen om E-mail op Indiening van
Proposal Writing,voorstel Schrijven
Provide email id registered in company,Zorg voor e-id geregistreerd in bedrijf
Provisional Profit / Loss (Credit),Voorlopige winst / verlies (Credit)
Public,Publiek
Published on website at: {0},Gepubliceerd op de website op: {0}
Publishing,Publishing
Pull sales orders (pending to deliver) based on the above criteria,Trek verkooporders (in afwachting van te leveren) op basis van de bovengenoemde criteria
Purchase,Kopen
Purchase / Manufacture Details,Aankoop / Productie Details
Purchase Analytics,Aankoop Analytics
Purchase Common,Aankoop Gemeenschappelijke
Purchase Details,Aankoopinformatie
Purchase Discounts,Inkoopkortingen
Purchase Invoice,Aankoop Factuur
Purchase Invoice Advance,Aankoop Factuur Advance
Purchase Invoice Advances,Aankoop Factuur Vooruitgang
Purchase Invoice Item,Aankoop Factuur Item
Purchase Invoice Trends,Aankoop Factuur Trends
Purchase Invoice {0} is already submitted,Purchase Invoice {0} is al ingediend
Purchase Order,Purchase Order
Purchase Order Item,Aankoop Bestelling
Purchase Order Item No,Purchase Order Item No
Purchase Order Item Supplied,Aankoop Bestelling ingevoerd
Purchase Order Items,Purchase Order Items
Purchase Order Items Supplied,Purchase Order Items ingevoerd
Purchase Order Items To Be Billed,Purchase Order Items te factureren
Purchase Order Items To Be Received,Purchase Order Items te ontvangen
Purchase Order Message,Purchase Order Bericht
Purchase Order Required,Vereiste Purchase Order
Purchase Order Trends,Purchase Order Trends
Purchase Order number required for Item {0},Purchase Order nummer nodig voor post {0}
Purchase Order {0} is 'Stopped',"Purchase Order {0} ""Te betalen"""
Purchase Order {0} is not submitted,Bestelling {0} is niet ingediend
Purchase Orders given to Suppliers.,Inkooporders aan leveranciers.
Purchase Receipt,Aankoopbewijs
Purchase Receipt Item,Aankoopbewijs Item
Purchase Receipt Item Supplied,Aankoopbewijs Item ingevoerd
Purchase Receipt Item Supplieds,Aankoopbewijs Item Supplieds
Purchase Receipt Items,Aankoopbewijs Items
Purchase Receipt Message,Aankoopbewijs Bericht
Purchase Receipt No,Aankoopbewijs Geen
Purchase Receipt Required,Aankoopbewijs Verplicht
Purchase Receipt Trends,Aankoopbewijs Trends
Purchase Receipt number required for Item {0},Aankoopbewijs nummer nodig voor post {0}
Purchase Receipt {0} is not submitted,Aankoopbewijs {0} is niet ingediend
Purchase Register,Aankoop Registreer
Purchase Return,Aankoop Return
Purchase Returned,Aankoop Returned
Purchase Taxes and Charges,Aankoop en-heffingen
Purchase Taxes and Charges Master,Aankoop en-heffingen Master
Purchse Order number required for Item {0},Purchse Bestelnummer vereist voor post {0}
Purpose,Doel
Purpose must be one of {0},Doel moet een van zijn {0}
QA Inspection,QA Inspectie
Qty,Aantal
Qty Consumed Per Unit,Aantal verbruikt per eenheid
Qty To Manufacture,Aantal te produceren
Qty as per Stock UOM,Aantal per Voorraad Verpakking
Qty to Deliver,Aantal te leveren
Qty to Order,Aantal te bestellen
Qty to Receive,Aantal te ontvangen
Qty to Transfer,Aantal Transfer
Qualification,Kwalificatie
Quality,Kwaliteit
Quality Inspection,Kwaliteitscontrole
Quality Inspection Parameters,Quality Inspection Parameters
Quality Inspection Reading,Kwaliteitscontrole Reading
Quality Inspection Readings,Kwaliteitscontrole Lezingen
Quality Inspection required for Item {0},Kwaliteitscontrole vereist voor post {0}
Quality Management,Quality Management
Quantity,Hoeveelheid
Quantity Requested for Purchase,Aantal op aankoop
Quantity and Rate,Hoeveelheid en Prijs
Quantity and Warehouse,Hoeveelheid en Warehouse
Quantity cannot be a fraction in row {0},Hoeveelheid kan een fractie in rij niet {0}
Quantity for Item {0} must be less than {1},Hoeveelheid voor post {0} moet kleiner zijn dan {1}
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Hoeveelheid in rij {0} ( {1} ) moet hetzelfde zijn als geproduceerde hoeveelheid {2}
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Hoeveelheid product verkregen na de productie / ompakken van de gegeven hoeveelheden grondstoffen
Quantity required for Item {0} in row {1},Benodigde hoeveelheid voor post {0} in rij {1}
Quarter,Kwartaal
Quarterly,Driemaandelijks
Quick Help,Quick Help
Quotation,Citaat
Quotation Item,Offerte Item
Quotation Items,Offerte Items
Quotation Lost Reason,Offerte Verloren Reden
Quotation Message,Offerte Bericht
Quotation To,Offerte Voor
Quotation Trends,offerte Trends
Quotation {0} is cancelled,Offerte {0} wordt geannuleerd
Quotation {0} not of type {1},Offerte {0} niet van het type {1}
Quotations received from Suppliers.,Offertes ontvangen van leveranciers.
Quotes to Leads or Customers.,Quotes om leads of klanten.
Raise Material Request when stock reaches re-order level,Raise Materiaal aanvragen bij voorraad strekt re-order niveau
Raised By,Opgevoed door
Raised By (Email),Verhoogde Door (E-mail)
Random,Toeval
Range,Reeks
Rate,Tarief
Rate ,Tarief
Rate (%),Tarief (%)
Rate (Company Currency),Rate (Company Munt)
Rate Of Materials Based On,Prijs van materialen op basis
Rate and Amount,Beoordeel en Bedrag
Rate at which Customer Currency is converted to customer's base currency,Snelheid waarmee Klant Valuta wordt omgezet naar de basis van de klant munt
Rate at which Price list currency is converted to company's base currency,Snelheid waarmee Prijslijst valuta wordt omgerekend naar de basis bedrijf munt
Rate at which Price list currency is converted to customer's base currency,Snelheid waarmee Prijslijst valuta wordt omgerekend naar de basis van de klant munt
Rate at which customer's currency is converted to company's base currency,Snelheid waarmee de klant valuta wordt omgerekend naar de basis bedrijf munt
Rate at which supplier's currency is converted to company's base currency,Snelheid waarmee de leverancier valuta wordt omgerekend naar de basis bedrijf munt
Rate at which this tax is applied,Snelheid waarmee deze belasting ingaat
Raw Material,grondstof
Raw Material Item Code,Grondstof Artikelcode
Raw Materials Supplied,Grondstoffen Geleverd
Raw Materials Supplied Cost,Grondstoffen ingevoerd Kosten
Raw material cannot be same as main Item,Grondstof kan niet hetzelfde zijn als belangrijkste punt zijn
Re-Order Level,Re-Order Level
Re-Order Qty,Re-Order Aantal
Re-order,Re-order
Re-order Level,Re-order Level
Re-order Qty,Re-order Aantal
Read,Lezen
Reading 1,Reading 1
Reading 10,Lezen 10
Reading 2,2 lezen
Reading 3,Reading 3
Reading 4,Reading 4
Reading 5,Reading 5
Reading 6,Lezen 6
Reading 7,Het lezen van 7
Reading 8,Het lezen van 8
Reading 9,Lezen 9
Real Estate,Real Estate
Reason,Reden
Reason for Leaving,Reden voor vertrek
Reason for Resignation,Reden voor ontslag
Reason for losing,Reden voor het verliezen
Recd Quantity,RECD Aantal
Receivable,Vorderingen
Receivable / Payable account will be identified based on the field Master Type,Zal vorderen / betalen rekening worden geïdentificeerd op basis van het veld Master Type
Receivables,Vorderingen
Receivables / Payables,Debiteuren / Crediteuren
Receivables Group,Vorderingen Groep
Received Date,Ontvangen Datum
Received Items To Be Billed,Ontvangen items te factureren
Received Qty,Ontvangen Aantal
Received and Accepted,Ontvangen en geaccepteerd
Receiver List,Ontvanger Lijst
Receiver List is empty. Please create Receiver List,Ontvanger is leeg. Maak Receiver Lijst
Receiver Parameter,Receiver Parameter
Recipients,Ontvangers
Reconcile,verzoenen
Reconciliation Data,Reconciliatiegegevens
Reconciliation HTML,Verzoening HTML
Reconciliation JSON,Verzoening JSON
Record item movement.,Opnemen punt beweging.
Recurring Id,Terugkerende Id
Recurring Invoice,Terugkerende Factuur
Recurring Type,Terugkerende Type
Reduce Deduction for Leave Without Pay (LWP),Verminderen Aftrek voor onbetaald verlof (LWP)
Reduce Earning for Leave Without Pay (LWP),Verminderen Verdienen voor onbetaald verlof (LWP)
Ref,Ref
Ref Code,Ref Code
Ref SQ,Ref SQ
Reference,Verwijzing
Reference #{0} dated {1},Referentie # {0} gedateerd {1}
Reference Date,Referentie Datum
Reference Name,Referentie Naam
Reference No & Reference Date is required for {0},Referentienummer en referentie Datum nodig is voor {0}
Reference No is mandatory if you entered Reference Date,Referentienummer is verplicht als je Peildatum ingevoerd
Reference Number,Referentienummer
Reference Row #,Referentie Row #
Refresh,Verversen
Registration Details,Registratie Details
Registration Info,Registratie Info
Rejected,Verworpen
Rejected Quantity,Rejected Aantal
Rejected Serial No,Afgewezen Serienummer
Rejected Warehouse,Afgewezen Warehouse
Rejected Warehouse is mandatory against regected item,Verworpen Warehouse is verplicht tegen regected post
Relation,Relatie
Relieving Date,Het verlichten van Datum
Relieving Date must be greater than Date of Joining,Het verlichten Datum moet groter zijn dan Datum van Deelnemen zijn
Remark,Opmerking
Remarks,Opmerkingen
Remarks Custom,Opmerkingen Custom
Rename,andere naam geven
Rename Log,Hernoemen Inloggen
Rename Tool,Wijzig de naam van Tool
Rent Cost,Kosten huur
Rent per hour,Huur per uur
Rented,Verhuurd
Repeat on Day of Month,Herhaal dit aan Dag van de maand
Replace,Vervang
Replace Item / BOM in all BOMs,Vervang Item / BOM in alle stuklijsten
Replied,Beantwoord
Report Date,Verslag Datum
Report Type,Meld Type
Report Type is mandatory,Soort rapport is verplicht
Reports to,Rapporteert aan
Reqd By Date,Reqd op datum
Reqd by Date,Reqd op Datum
Request Type,Soort aanvraag
Request for Information,Aanvraag voor informatie
Request for purchase.,Verzoek om aankoop.
Requested,gevraagd
Requested For,gevraagd voor
Requested Items To Be Ordered,Gevraagde items te bestellen
Requested Items To Be Transferred,Gevraagde items te dragen
Requested Qty,verzocht Aantal
"Requested Qty: Quantity requested for purchase, but not ordered.","Aangevraagd Aantal : Aantal op aankoop, maar niet besteld."
Requests for items.,Verzoeken om punten.
Required By,Vereiste Door
Required Date,Vereiste Datum
Required Qty,Vereist aantal
Required only for sample item.,Alleen vereist voor monster item.
Required raw materials issued to the supplier for producing a sub - contracted item.,Benodigde grondstoffen uitgegeven aan de leverancier voor het produceren van een sub - gecontracteerde item.
Research,onderzoek
Research & Development,Research & Development
Researcher,onderzoeker
Reseller,Reseller
Reserved,gereserveerd
Reserved Qty,Gereserveerd Aantal
"Reserved Qty: Quantity ordered for sale, but not delivered.","Gereserveerd Aantal : Aantal besteld te koop , maar niet geleverd ."
Reserved Quantity,Gereserveerde Aantal
Reserved Warehouse,Gereserveerde Warehouse
Reserved Warehouse in Sales Order / Finished Goods Warehouse,Gereserveerde Warehouse in Sales Order / Finished Goods Warehouse
Reserved Warehouse is missing in Sales Order,Gereserveerde Warehouse ontbreekt in verkooporder
Reserved Warehouse required for stock Item {0} in row {1},Gereserveerd Warehouse nodig voor voorraad Item {0} in rij {1}
Reserved warehouse required for stock item {0},Gereserveerd magazijn nodig voor voorraad artikel {0}
Reserves and Surplus,Reserves en Surplus
Reset Filters,Reset Filters
Resignation Letter Date,Ontslagbrief Datum
Resolution,Resolutie
Resolution Date,Resolutie Datum
Resolution Details,Resolutie Details
Resolved By,Opgelost door
Rest Of The World,Rest van de Wereld
Retail,Kleinhandel
Retail & Wholesale,Retail & Wholesale
Retailer,Kleinhandelaar
Review Date,Herzieningsdatum
Rgt,Rgt
Role Allowed to edit frozen stock,Rol toegestaan ​​op bevroren voorraad bewerken
Role that is allowed to submit transactions that exceed credit limits set.,"Rol die is toegestaan ​​om transacties die kredietlimieten, te overschrijden indienen."
Root Type,Root Type
Root Type is mandatory,Root Type is verplicht
Root account can not be deleted,Root-account kan niet worden verwijderd
Root cannot be edited.,Root kan niet worden bewerkt .
Root cannot have a parent cost center,Root kan niet een ouder kostenplaats
Rounded Off,afgerond
Rounded Total,Afgeronde Totaal
Rounded Total (Company Currency),Afgeronde Totaal (Bedrijf Munt)
Row # ,Rij #
Row # {0}: ,
Row #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Rij # {0}: Bestelde hoeveelheid kan niet minder dan minimum afname item (gedefinieerd in punt master).
Row #{0}: Please specify Serial No for Item {1},Rij # {0}: Geef volgnummer voor post {1}
Row {0}: Account does not match with \						Purchase Invoice Credit To account,Rij {0}: Account komt niet overeen met \ Aankoop Factuur Credit Om rekening te houden
Row {0}: Account does not match with \						Sales Invoice Debit To account,Rij {0}: Account komt niet overeen met \ verkoopfactuur Debit Om rekening te houden
Row {0}: Conversion Factor is mandatory,Rij {0}: Conversie Factor is verplicht
Row {0}: Credit entry can not be linked with a Purchase Invoice,Rij {0} : Credit invoer kan niet worden gekoppeld aan een inkoopfactuur
Row {0}: Debit entry can not be linked with a Sales Invoice,Rij {0} : debitering kan niet worden gekoppeld aan een verkoopfactuur
Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Rij {0}: Betaling bedrag moet kleiner dan of gelijk aan openstaande bedrag factureren zijn. Raadpleeg onderstaande opmerking.
Row {0}: Qty is mandatory,Rij {0}: Aantal is verplicht
"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.					Available Qty: {4}, Transfer Qty: {5}","Rij {0}: Aantal niet voorraad in magazijn {1} op {2} {3}. Beschikbaar Aantal: {4}, Transfer Aantal: {5}"
"Row {0}: To set {1} periodicity, difference between from and to date \						must be greater than or equal to {2}","Rij {0}: Voor het instellen van {1} periodiciteit, verschil tussen uit en tot op heden \ moet groter zijn dan of gelijk aan {2}"
Row {0}:Start Date must be before End Date,Rij {0} : Start Datum moet zijn voordat Einddatum
Rules for adding shipping costs.,Regels voor het toevoegen van verzendkosten.
Rules for applying pricing and discount.,Regels voor de toepassing van prijzen en kortingen .
Rules to calculate shipping amount for a sale,Regels voor de scheepvaart bedrag te berekenen voor een verkoop
S.O. No.,S.O. Nee.
SHE Cess on Excise,SHE Cess op Excise
SHE Cess on Service Tax,SHE Cess op Dienst Belastingen
SHE Cess on TDS,SHE Cess op TDS
SMS Center,SMS Center
SMS Gateway URL,SMS Gateway URL
SMS Log,SMS Log
SMS Parameter,SMS Parameter
SMS Sender Name,SMS Sender Name
SMS Settings,SMS-instellingen
SO Date,SO Datum
SO Pending Qty,SO afwachting Aantal
SO Qty,SO Aantal
Salary,Salaris
Salary Information,Salaris Informatie
Salary Manager,Salaris Manager
Salary Mode,Salaris Mode
Salary Slip,Loonstrook
Salary Slip Deduction,Loonstrook Aftrek
Salary Slip Earning,Loonstrook verdienen
Salary Slip of employee {0} already created for this month,Loonstrook van de werknemer {0} al gemaakt voor deze maand
Salary Structure,Salarisstructuur
Salary Structure Deduction,Salaris Structuur Aftrek
Salary Structure Earning,Salaris Structuur verdienen
Salary Structure Earnings,Salaris Structuur winst
Salary breakup based on Earning and Deduction.,Salaris verbreken op basis Verdienen en Aftrek.
Salary components.,Salaris componenten.
Salary template master.,Salaris sjabloon meester .
Sales,Sales
Sales Analytics,Sales Analytics
Sales BOM,Verkoop BOM
Sales BOM Help,Verkoop BOM Help
Sales BOM Item,Verkoop BOM Item
Sales BOM Items,Verkoop BOM Items
Sales Browser,Sales Browser
Sales Details,Verkoop Details
Sales Discounts,Sales kortingen
Sales Email Settings,Sales E-mailinstellingen
Sales Expenses,verkoopkosten
Sales Extras,Sales Extra&#39;s
Sales Funnel,Sales Funnel
Sales Invoice,Sales Invoice
Sales Invoice Advance,Sales Invoice Advance
Sales Invoice Item,Sales Invoice Item
Sales Invoice Items,Verkoopfactuur Items
Sales Invoice Message,Sales Invoice Message
Sales Invoice No,Verkoop Factuur nr.
Sales Invoice Trends,Verkoopfactuur Trends
Sales Invoice {0} has already been submitted,Verkoopfactuur {0} al is ingediend
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Verkoopfactuur {0} moet worden geannuleerd voordat het annuleren van deze verkooporder
Sales Order,Verkooporder
Sales Order Date,Verkooporder Datum
Sales Order Item,Sales Order Item
Sales Order Items,Sales Order Items
Sales Order Message,Verkooporder Bericht
Sales Order No,Sales Order No
Sales Order Required,Verkooporder Vereiste
Sales Order Trends,Sales Order Trends
Sales Order required for Item {0},Klantorder nodig is voor post {0}
Sales Order {0} is not submitted,Sales Order {0} is niet ingediend
Sales Order {0} is not valid,Sales Order {0} is niet geldig
Sales Order {0} is stopped,Sales Order {0} is gestopt
Sales Partner,Sales Partner
Sales Partner Name,Sales Partner Naam
Sales Partner Target,Sales Partner Target
Sales Partners Commission,Sales Partners Commissie
Sales Person,Sales Person
Sales Person Name,Sales Person Name
Sales Person Target Variance Item Group-Wise,Sales Person Doel Variance Post Group - Wise
Sales Person Targets,Sales Person Doelen
Sales Person-wise Transaction Summary,Sales Person-wise Overzicht opdrachten
Sales Register,Sales Registreer
Sales Return,Verkoop Terug
Sales Returned,Sales Terugkerende
Sales Taxes and Charges,Verkoop en-heffingen
Sales Taxes and Charges Master,Verkoop en-heffingen Master
Sales Team,Sales Team
Sales Team Details,Sales Team Details
Sales Team1,Verkoop Team1
Sales and Purchase,Verkoop en Inkoop
Sales campaigns.,Verkoopacties .
Salutation,Aanhef
Sample Size,Steekproefomvang
Sanctioned Amount,Gesanctioneerde Bedrag
Saturday,Zaterdag
Schedule,Plan
Schedule Date,tijdschema
Schedule Details,Schema Details
Scheduled,Geplande
Scheduled Date,Geplande Datum
Scheduled to send to {0},Gepland om te sturen naar {0}
Scheduled to send to {0} recipients,Gepland om te sturen naar {0} ontvangers
Scheduler Failed Events,Scheduler mislukt Evenementen
School/University,School / Universiteit
Score (0-5),Score (0-5)
Score Earned,Score Verdiende
Score must be less than or equal to 5,Score moet lager dan of gelijk aan 5 zijn
Scrap %,Scrap%
Seasonality for setting budgets.,Seizoensinvloeden voor het instellen van budgetten.
Secretary,secretaresse
Secured Loans,Beveiligde Leningen
Securities & Commodity Exchanges,Securities & Commodity Exchanges
Securities and Deposits,Effecten en deposito's
"See ""Rate Of Materials Based On"" in Costing Section",Zie &quot;Rate Of Materials Based On&quot; in Costing Sectie
"Select ""Yes"" for sub - contracting items",Selecteer &quot;Ja&quot; voor sub - aanbestedende artikelen
"Select ""Yes"" if this item is used for some internal purpose in your company.",Selecteer &quot;Ja&quot; als dit voorwerp wordt gebruikt voor een aantal intern gebruik in uw bedrijf.
"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Selecteer &quot;Ja&quot; als dit voorwerp vertegenwoordigt wat werk zoals training, ontwerpen, overleg, enz."
"Select ""Yes"" if you are maintaining stock of this item in your Inventory.",Selecteer &quot;Ja&quot; als u het handhaven voorraad van dit artikel in je inventaris.
"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.",Selecteer &quot;Ja&quot; als u de levering van grondstoffen aan uw leverancier om dit item te produceren.
Select Brand...,Selecteer Merk ...
Select Budget Distribution to unevenly distribute targets across months.,Selecteer Budget Uitkering aan ongelijk verdelen doelen uit maanden.
"Select Budget Distribution, if you want to track based on seasonality.","Selecteer Budget Distributie, als je wilt volgen op basis van seizoensinvloeden."
Select Company...,Selecteer Company ...
Select DocType,Selecteer DocType
Select Fiscal Year...,Selecteer boekjaar ...
Select Items,Selecteer Items
Select Project...,Selecteer Project ...
Select Purchase Receipts,Selecteer Aankoopfacturen
Select Sales Orders,Selecteer Verkooporders
Select Sales Orders from which you want to create Production Orders.,Selecteer Verkooporders van waaruit u wilt productieorders creëren.
Select Time Logs and Submit to create a new Sales Invoice.,Selecteer Time Logs en indienen om een ​​nieuwe verkoopfactuur maken.
Select Transaction,Selecteer Transactie
Select Warehouse...,Selecteer Warehouse ...
Select Your Language,Selecteer uw taal
Select account head of the bank where cheque was deposited.,Selecteer met het hoofd van de bank waar cheque werd afgezet.
Select company name first.,Kies eerst een bedrijfsnaam.
Select template from which you want to get the Goals,Selecteer template van waaruit u de Doelen te krijgen
Select the Employee for whom you are creating the Appraisal.,Selecteer de werknemer voor wie u het maken van de Beoordeling.
Select the period when the invoice will be generated automatically,Selecteer de periode waarin de factuur wordt automatisch gegenereerd
Select the relevant company name if you have multiple companies,Selecteer de gewenste bedrijfsnaam als u meerdere bedrijven
Select the relevant company name if you have multiple companies.,Selecteer de gewenste bedrijfsnaam als u meerdere bedrijven.
Select who you want to send this newsletter to,Selecteer de personen die u wilt deze nieuwsbrief te sturen naar
Select your home country and check the timezone and currency.,Selecteer uw land en controleer de tijdzone en valuta .
"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","&quot;Ja&quot; zal dit artikel om te verschijnen in Purchase Order, aankoopbon."
"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","&quot;Ja&quot; zal dit artikel te achterhalen in Sales Order, pakbon"
"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.",&quot;Ja&quot; zal u toelaten om Bill of Material tonen grondstof-en operationele kosten om dit item te produceren maken.
"Selecting ""Yes"" will allow you to make a Production Order for this item.",&quot;Ja&quot; zal u toelaten om een ​​productieorder voor dit item te maken.
"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.",&quot;Ja&quot; geeft een unieke identiteit voor elke entiteit van dit artikel die kunnen worden bekeken in de Serial No meester.
Selling,Selling
Selling Settings,Selling Instellingen
"Selling must be checked, if Applicable For is selected as {0}","Selling moet worden gecontroleerd, indien van toepassing voor is geselecteerd als {0}"
Send,Sturen
Send Autoreply,Stuur Autoreply
Send Email,E-mail verzenden
Send From,Stuur Van
Send Notifications To,Meldingen verzenden naar
Send Now,Nu verzenden
Send SMS,SMS versturen
Send To,Verzenden naar
Send To Type,Verzenden naar type
Send mass SMS to your contacts,Stuur massa SMS naar uw contacten
Send to this list,Stuur deze lijst
Sender Name,Naam afzender
Sent On,Verzonden op
Separate production order will be created for each finished good item.,Gescheiden productie order wordt aangemaakt voor elk eindproduct goed punt.
Serial No,Serienummer
Serial No / Batch,Serienummer / Batch
Serial No Details,Serial geen gegevens
Serial No Service Contract Expiry,Serial No Service Contract Expiry
Serial No Status,Serienummer Status
Serial No Warranty Expiry,Serial Geen garantie Expiry
Serial No is mandatory for Item {0},Serienummer is verplicht voor post {0}
Serial No {0} created,Serienummer {0} aangemaakt
Serial No {0} does not belong to Delivery Note {1},Serienummer {0} behoort niet tot Delivery Note {1}
Serial No {0} does not belong to Item {1},Serienummer {0} behoort niet tot Item {1}
Serial No {0} does not belong to Warehouse {1},Serienummer {0} behoort niet tot Warehouse {1}
Serial No {0} does not exist,Serienummer {0} bestaat niet
Serial No {0} has already been received,Serienummer {0} is reeds ontvangen
Serial No {0} is under maintenance contract upto {1},Serienummer {0} is onder onderhoudscontract tot {1}
Serial No {0} is under warranty upto {1},Serienummer {0} is onder garantie tot {1}
Serial No {0} not in stock,Serienummer {0} niet op voorraad
Serial No {0} quantity {1} cannot be a fraction,Serienummer {0} hoeveelheid {1} kan een fractie niet
Serial No {0} status must be 'Available' to Deliver,Serienummer {0} statuut moet 'Beschikbaar' te bezorgen
Serial Nos Required for Serialized Item {0},Volgnummers Vereiste voor Serialized Item {0}
Serial Number Series,Serienummer Series
Serial number {0} entered more than once,Serienummer {0} ingevoerd meer dan eens
Serialized Item {0} cannot be updated \					using Stock Reconciliation,Geserialiseerde Item {0} niet kan worden bijgewerkt \ met behulp van Stock Verzoening
Series,serie
Series List for this Transaction,Series Lijst voor deze transactie
Series Updated,serie update
Series Updated Successfully,Serie succesvol bijgewerkt
Series is mandatory,Serie is verplicht
Series {0} already used in {1},Serie {0} al gebruikt in {1}
Service,service
Service Address,Service Adres
Service Tax,Dienst Belastingen
Services,Diensten
Set,reeks
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Standaardwaarden zoals onderneming , Valuta , huidige boekjaar , etc."
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.
Set Status as Available,Stel Status als Beschikbaar
Set as Default,Instellen als standaard
Set as Lost,Instellen als Lost
Set prefix for numbering series on your transactions,Stel prefix voor het nummeren van serie over uw transacties
Set targets Item Group-wise for this Sales Person.,Set richt Item Group-wise voor deze verkoper.
Setting Account Type helps in selecting this Account in transactions.,Instellen Account Type helpt bij het selecteren van deze account in transacties.
Setting this Address Template as default as there is no other default,Dit adres Template instellen als standaard als er geen andere standaard
Setting up...,Het opzetten ...
Settings,Instellingen
Settings for HR Module,Instellingen voor HR Module
"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""",Instellingen om sollicitanten halen uit een mailbox bijv. &quot;jobs@example.com&quot;
Setup,Setup
Setup Already Complete!!,Setup al voltooid !
Setup Complete,Installatie voltooid
Setup SMS gateway settings,Setup SMS gateway instellingen
Setup Series,Setup-serie
Setup Wizard,Setup Wizard
Setup incoming server for jobs email id. (e.g. jobs@example.com),Setup inkomende server voor banen e-id . ( b.v. jobs@example.com )
Setup incoming server for sales email id. (e.g. sales@example.com),Setup inkomende server voor de verkoop e-id . ( b.v. sales@example.com )
Setup incoming server for support email id. (e.g. support@example.com),Setup inkomende server voor ondersteuning e-id . ( b.v. support@example.com )
Share,Aandeel
Share With,Delen
Shareholders Funds,eigen middelen
Shipments to customers.,Verzendingen naar klanten.
Shipping,Scheepvaart
Shipping Account,Verzending account
Shipping Address,Verzendadres
Shipping Amount,Verzending Bedrag
Shipping Rule,Verzending Rule
Shipping Rule Condition,Verzending Regel Conditie
Shipping Rule Conditions,Verzending Regel Voorwaarden
Shipping Rule Label,Verzending Regel Label
Shop,Winkelen
Shopping Cart,Winkelwagen
Short biography for website and other publications.,Korte biografie voor website en andere publicaties.
"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.
"Show / Hide features like Serial Nos, POS etc.","Toon / verberg functies, zoals serienummers , POS etc."
Show In Website,Toon in Website
Show a slideshow at the top of the page,Laat een diavoorstelling aan de bovenkant van de pagina
Show in Website,Toon in Website
Show rows with zero values,Toon rijen met nulwaarden
Show this slideshow at the top of the page,Laat deze slideshow aan de bovenkant van de pagina
Sick Leave,Sick Leave
Signature,Handtekening
Signature to be appended at the end of every email,Handtekening moet worden toegevoegd aan het einde van elke e-mail
Single,Single
Single unit of an Item.,Enkele eenheid van een item.
Sit tight while your system is being setup. This may take a few moments.,Hou je vast terwijl uw systeem wordt setup. Dit kan even duren .
Slideshow,Diashow
Soap & Detergent,Soap & Wasmiddel
Software,software
Software Developer,software Developer
"Sorry, Serial Nos cannot be merged","Sorry , kan de serienummers niet worden samengevoegd"
"Sorry, companies cannot be merged","Sorry , bedrijven kunnen niet worden samengevoegd"
Source,Bron
Source File,Bronbestand
Source Warehouse,Bron Warehouse
Source and target warehouse cannot be same for row {0},Bron en doel magazijn kan niet hetzelfde zijn voor de rij {0}
Source of Funds (Liabilities),Bron van fondsen (passiva)
Source warehouse is mandatory for row {0},Bron magazijn is verplicht voor rij {0}
Spartan,Spartaans
"Special Characters except ""-"" and ""/"" not allowed in naming series","Speciale tekens behalve "" - "" en "" / "" niet toegestaan ​​in het benoemen serie"
Specification Details,Specificatie Details
Specifications,specificaties
"Specify a list of Territories, for which, this Price List is valid","Geef een lijst van gebieden, waarvoor deze prijslijst is geldig"
"Specify a list of Territories, for which, this Shipping Rule is valid","Geef een lijst van gebieden, waarvoor dit Verzending regel is geldig"
"Specify a list of Territories, for which, this Taxes Master is valid","Geef een lijst van gebieden, waarvoor dit Belastingen Master is geldig"
"Specify the operations, operating cost and give a unique Operation no to your operations.","Geef de operaties , operationele kosten en geven een unieke operatie niet aan uw activiteiten ."
Split Delivery Note into packages.,Split pakbon in pakketten.
Sports,sport-
Sr,Sr
Standard,Standaard
Standard Buying,Standard kopen
Standard Reports,standaard rapporten
Standard Selling,Standaard Selling
Standard contract terms for Sales or Purchase.,Standaard contractvoorwaarden voor Sales en Inkoop .
Start,begin
Start Date,Startdatum
Start date of current invoice's period,Begindatum van de periode huidige factuur&#39;s
Start date should be less than end date for Item {0},Startdatum moet kleiner zijn dan einddatum voor post zijn {0}
State,Staat
Statement of Account,Rekeningafschrift
Static Parameters,Statische Parameters
Status,Staat
Status must be one of {0},Status moet een van zijn {0}
Status of {0} {1} is now {2},Status van {0} {1} is nu {2}
Status updated to {0},Status bijgewerkt naar {0}
Statutory info and other general information about your Supplier,Wettelijke info en andere algemene informatie over uw leverancier
Stay Updated,Blijf op de hoogte
Stock,Voorraad
Stock Adjustment,Stock aanpassing
Stock Adjustment Account,Stock Aanpassing Account
Stock Ageing,Stock Vergrijzing
Stock Analytics,Stock Analytics
Stock Assets,Stock activa
Stock Balance,Stock Balance
Stock Entries already created for Production Order ,
Stock Entry,Stock Entry
Stock Entry Detail,Stock Entry Detail
Stock Expenses,Stock Lasten
Stock Frozen Upto,Stock Bevroren Tot
Stock Ledger,Stock Ledger
Stock Ledger Entry,Stock Ledger Entry
Stock Ledger entries balances updated,Stock dagboekposten saldi bijgewerkt
Stock Level,Stock Level
Stock Liabilities,Stock Verplichtingen
Stock Projected Qty,Verwachte voorraad Aantal
Stock Queue (FIFO),Stock Queue (FIFO)
Stock Received But Not Billed,Stock Ontvangen maar niet gefactureerde
Stock Reconcilation Data,Stock Verzoening gegevens
Stock Reconcilation Template,Stock Verzoening Template
Stock Reconciliation,Stock Verzoening
"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.","Stock Verzoening kan worden gebruikt om de voorraad bij te werken op een bepaalde datum , meestal als per fysieke inventaris ."
Stock Settings,Stock Instellingen
Stock UOM,Stock Verpakking
Stock UOM Replace Utility,Stock Verpakking Vervang Utility
Stock UOM updatd for Item {0},Stock Verpakking updatd voor post {0}
Stock Uom,Stock Verpakking
Stock Value,Stock Waarde
Stock Value Difference,Stock Waarde Verschil
Stock balances updated,Stock saldi bijgewerkt
Stock cannot be updated against Delivery Note {0},Voorraad kan niet worden bijgewerkt tegen Delivery Note {0}
Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',Stock inzendingen bestaan ​​tegen magazijn {0} kan niet opnieuw toewijzen of wijzigen 'Master Naam'
Stock transactions before {0} are frozen,Aandelentransacties voor {0} zijn bevroren
Stop,Stop
Stop Birthday Reminders,Stop verjaardagsherinneringen
Stop Material Request,Stop Materiaal Request
Stop users from making Leave Applications on following days.,Stop gebruikers van het maken van verlofaanvragen op de volgende dagen.
Stop!,Stop!
Stopped,Gestopt
Stopped order cannot be cancelled. Unstop to cancel.,Gestopt bestelling kan niet worden geannuleerd . Opendraaien om te annuleren .
Stores,winkel
Stub,stomp
Sub Assemblies,sub Assemblies
"Sub-currency. For e.g. ""Cent""",Sub-valuta. Voor bijvoorbeeld &quot;Cent&quot;
Subcontract,Subcontract
Subject,Onderwerp
Submit Salary Slip,Indienen loonstrook
Submit all salary slips for the above selected criteria,Gelieve alle loonstroken voor de bovenstaande geselecteerde criteria
Submit this Production Order for further processing.,Submit deze productieorder voor verdere verwerking .
Submitted,Ingezonden
Subsidiary,Dochteronderneming
Successful: ,Succesvol:
Successfully Reconciled,Succes Reconciled
Suggestions,Tips
Sunday,Zondag
Supplier,Leverancier
Supplier (Payable) Account,Leverancier (te betalen) Account
Supplier (vendor) name as entered in supplier master,Leverancier (vendor) naam als die in leverancier meester
Supplier > Supplier Type,Leveranciers> Leverancier Type
Supplier Account Head,Leverancier Account Head
Supplier Address,Leverancier Adres
Supplier Addresses and Contacts,Leverancier Adressen en Contacten
Supplier Details,Product Detail
Supplier Intro,Leverancier Intro
Supplier Invoice Date,Leverancier Factuurdatum
Supplier Invoice No,Leverancier Factuur nr.
Supplier Name,Leverancier Naam
Supplier Naming By,Leverancier Naming Door
Supplier Part Number,Leverancier Onderdeelnummer
Supplier Quotation,Leverancier Offerte
Supplier Quotation Item,Leverancier Offerte Item
Supplier Reference,Leverancier Referentie
Supplier Type,Leverancier Type
Supplier Type / Supplier,Leverancier Type / leverancier
Supplier Type master.,Leverancier Type meester .
Supplier Warehouse,Leverancier Warehouse
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Leverancier Warehouse verplicht voor onderaannemers Kwitantie
Supplier database.,Leverancier database.
Supplier master.,Leverancier meester .
Supplier warehouse where you have issued raw materials for sub - contracting,Leverancier magazijn waar u grondstoffen afgegeven voor sub - aanbestedende
Supplier-Wise Sales Analytics,Leveranciers Wise Sales Analytics
Support,Ondersteunen
Support Analtyics,ondersteuning Analtyics
Support Analytics,Ondersteuning Analytics
Support Email,Ondersteuning E-mail
Support Email Settings,Ondersteuning E-mailinstellingen
Support Password,Ondersteuning Wachtwoord
Support Ticket,Hulpaanvraag
Support queries from customers.,Ondersteuning vragen van klanten.
Symbol,Symbool
Sync Support Mails,Sync Ondersteuning Mails
Sync with Dropbox,Synchroniseren met Dropbox
Sync with Google Drive,Synchroniseren met Google Drive
System,Systeem
System Settings,Systeeminstellingen
"System User (login) ID. If set, it will become default for all HR forms.","Systeem (login) ID. Indien ingesteld, zal het standaard voor alle HR-formulieren."
TDS (Advertisement),TDS (Advertentie)
TDS (Commission),TDS (Commissie)
TDS (Contractor),TDS (Aannemer)
TDS (Interest),TDS (Interest)
TDS (Rent),TDS (huur)
TDS (Salary),TDS (Salaris)
Target  Amount,Streefbedrag
Target Detail,Doel Detail
Target Details,Target Details
Target Details1,Target Details1
Target Distribution,Target Distributie
Target On,Target On
Target Qty,Target Aantal
Target Warehouse,Target Warehouse
Target warehouse in row {0} must be same as Production Order,Doel magazijn in rij {0} moet hetzelfde zijn als productieorder
Target warehouse is mandatory for row {0},Doel magazijn is verplicht voor rij {0}
Task,Taak
Task Details,Taak Details
Tasks,taken
Tax,Belasting
Tax Amount After Discount Amount,Tax bedrag na korting Bedrag
Tax Assets,belastingvorderingen
Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Fiscale categorie kan ' Valuation ' of ' Valuation en Total ' als alle items zijn niet-voorraadartikelen niet
Tax Rate,Belastingtarief
Tax and other salary deductions.,Belastingen en andere inhoudingen op het loon.
Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges,Tax detail tafel haalde van post meester als een string en opgeslagen in dit gebied. Gebruikt voor belastingen en-heffingen
Tax template for buying transactions.,Belasting sjabloon voor het kopen van transacties .
Tax template for selling transactions.,Belasting sjabloon voor de verkoop transacties.
Taxable,Belastbaar
Taxes,Belastingen
Taxes and Charges,Belastingen en heffingen
Taxes and Charges Added,Belastingen en heffingen toegevoegd
Taxes and Charges Added (Company Currency),Belastingen en heffingen toegevoegd (Company Munt)
Taxes and Charges Calculation,Belastingen en kosten berekenen
Taxes and Charges Deducted,Belastingen en heffingen Afgetrokken
Taxes and Charges Deducted (Company Currency),Belastingen en kosten afgetrokken (Company Munt)
Taxes and Charges Total,Belastingen en kosten Totaal
Taxes and Charges Total (Company Currency),Belastingen en bijkomende kosten Totaal (Bedrijf Munt)
Technology,technologie
Telecommunications,telecommunicatie
Telephone Expenses,telefoonkosten
Television,televisie
Template,Sjabloon
Template for performance appraisals.,Sjabloon voor functioneringsgesprekken .
Template of terms or contract.,Sjabloon van termen of contract.
Temporary Accounts (Assets),Tijdelijke Accounts ( Activa )
Temporary Accounts (Liabilities),Tijdelijke rekeningen ( passiva )
Temporary Assets,tijdelijke activa
Temporary Liabilities,tijdelijke Verplichtingen
Term Details,Term Details
Terms,Voorwaarden
Terms and Conditions,Algemene Voorwaarden
Terms and Conditions Content,Voorwaarden Inhoud
Terms and Conditions Details,Algemene Voorwaarden Details
Terms and Conditions Template,Algemene voorwaarden Template
Terms and Conditions1,Algemene Conditions1
Terretory,terretory
Territory,Grondgebied
Territory / Customer,Grondgebied / Klantenservice
Territory Manager,Territory Manager
Territory Name,Grondgebied Naam
Territory Target Variance Item Group-Wise,Grondgebied Doel Variance Post Group - Wise
Territory Targets,Grondgebied Doelen
Test,Test
Test Email Id,Test E-mail Identiteitskaart
Test the Newsletter,Test de nieuwsbrief
The BOM which will be replaced,De BOM die zal worden vervangen
The First User: You,De eerste gebruiker : U
"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""",Het item dat het pakket vertegenwoordigt. Dit artikel moet hebben &quot;Is Stock Item&quot; als &quot;No&quot; en &quot;Is Sales Item&quot; als &quot;Yes&quot;
The Organization,de Organisatie
"The account head under Liability, in which Profit/Loss will be booked","De rekening hoofd onder Aansprakelijkheid , waarin Winst / verlies zal worden geboekt"
The date on which next invoice will be generated. It is generated on submit.,De datum waarop de volgende factuur wordt gegenereerd. Het wordt geproduceerd op te dienen.
The date on which recurring invoice will be stop,De datum waarop terugkerende factuur stoppen
"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ","De dag van de maand waarop de automatische factuur wordt gegenereerd bv 05, 28 etc"
The day(s) on which you are applying for leave are holiday. You need not apply for leave.,De dag (en ) waarop je solliciteert verlof zijn vakantie . Je hoeft niet voor verlof .
The first Leave Approver in the list will be set as the default Leave Approver,De eerste Plaats Approver in de lijst wordt als de standaard Leave Fiatteur worden ingesteld
The first user will become the System Manager (you can change that later).,De eerste gebruiker zal de System Manager te worden (u kunt dat later wijzigen ) .
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)
The name of your company for which you are setting up this system.,De naam van uw bedrijf waar u het opzetten van dit systeem .
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 items)
The new BOM after replacement,De nieuwe BOM na vervanging
The rate at which Bill Currency is converted into company's base currency,De snelheid waarmee Bill valuta worden omgezet in basis bedrijf munt
The unique id for tracking all recurring invoices. It is generated on submit.,De unieke id voor het bijhouden van alle terugkerende facturen. Het wordt geproduceerd op te dienen.
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Dan prijsregels worden uitgefilterd op basis van Klant, Customer Group, Territory, Leverancier, Leverancier Type, Campagne, Sales Partner etc."
There are more holidays than working days this month.,Er zijn meer vakanties dan werkdagen deze maand .
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Er kan maar een Verzenden Regel Voorwaarde met 0 of blanco waarde voor ""To Value """
There is not enough leave balance for Leave Type {0},Er is niet genoeg verlofsaldo voor Verlof type {0}
There is nothing to edit.,Er is niets om te bewerken .
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 je niet hebt opgeslagen het formulier . Neem dan contact support@erpnext.com als het probleem aanhoudt .
There were errors.,Er waren fouten .
This Currency is disabled. Enable to use in transactions,Deze valuta is uitgeschakeld . In staat om te gebruiken in transacties
This Leave Application is pending approval. Only the Leave Apporver can update status.,Deze verlofaanvraag is in afwachting van goedkeuring . Alleen de Leave Apporver kan status bijwerken .
This Time Log Batch has been billed.,This Time Log Batch is gefactureerd.
This Time Log Batch has been cancelled.,This Time Log Batch is geannuleerd.
This Time Log conflicts with {0},This Time Log in strijd is met {0}
This format is used if country specific format is not found,Dit formaat wordt gebruikt als landspecifieke indeling niet wordt gevonden
This is a root account and cannot be edited.,Dit is een root account en kan niet worden bewerkt .
This is a root customer group and cannot be edited.,Dit is een wortel klantgroep en kan niet worden bewerkt .
This is a root item group and cannot be edited.,Dit is een hoofditem groep en kan niet worden bewerkt .
This is a root sales person and cannot be edited.,Dit is een wortel verkoper en kan niet worden bewerkt .
This is a root territory and cannot be edited.,Dit is een wortel grondgebied en kan niet worden bewerkt .
This is an example website auto-generated from ERPNext,Dit is een voorbeeld website automatisch gegenereerd ERPNext
This is the number of the last created transaction with this prefix,Dit is het nummer van de laatst gemaakte transactie met dit voorvoegsel
This will be used for setting rule in HR module,Deze wordt gebruikt voor instelling regel HR module
Thread HTML,Thread HTML
Thursday,Donderdag
Time Log,Tijd Inloggen
Time Log Batch,Time Log Batch
Time Log Batch Detail,Time Log Batch Detail
Time Log Batch Details,Time Log Batch Details
Time Log Batch {0} must be 'Submitted',Tijd Inloggen Batch {0} moet worden ' Ingezonden '
Time Log Status must be Submitted.,Tijd Inloggen Status moet worden ingediend.
Time Log for tasks.,Tijd Inloggen voor taken.
Time Log is not billable,Time Log is niet factureerbare
Time Log {0} must be 'Submitted',Tijd Inloggen {0} moet worden ' Ingezonden '
Time Zone,Time Zone
Time Zones,Tijdzones
Time and Budget,Tijd en Budget
Time at which items were delivered from warehouse,Tijd waarop items werden geleverd uit magazijn
Time at which materials were received,Tijdstip waarop materialen ontvangen
Title,Titel
Titles for print templates e.g. Proforma Invoice.,Titels voor print templates bijv. Proforma Factuur .
To,Naar
To Currency,Naar Valuta
To Date,To-date houden
To Date should be same as From Date for Half Day leave,Om datum moet dezelfde zijn als Van Datum voor halve dag verlof zijn
To Date should be within the Fiscal Year. Assuming To Date = {0},To Date dient binnen het boekjaar. Ervan uitgaande To Date = {0}
To Discuss,Om Bespreek
To Do List,To Do List
To Package No.,Op Nee Pakket
To Produce,Produce
To Time,Naar Time
To Value,Om Value
To Warehouse,Om Warehouse
"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Om onderliggende nodes te voegen , te verkennen boom en klik op het knooppunt waar u wilt meer knooppunten toe te voegen ."
"To assign this issue, use the ""Assign"" button in the sidebar.","Om dit probleem op te wijzen, gebruikt u de &quot;Assign&quot;-knop in de zijbalk."
To create a Bank Account,Om een bankrekening te creëren
To create a Tax Account,Om een Tax Account maken
"To create an Account Head under a different company, select the company and save customer.","Om een ​​account te creëren hoofd onder een andere onderneming, selecteert u het bedrijf en op te slaan klant."
To date cannot be before from date,Tot op heden kan niet eerder worden vanaf datum
To enable <b>Point of Sale</b> features,Om <b>Point of Sale</b> functies in te schakelen
To enable <b>Point of Sale</b> view,Om <b> Point of Sale < / b > view staat
To get Item Group in details table,Om Item Group te krijgen in details tabel
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Om voorheffing omvatten in rij {0} in Item tarief , de belastingen in rijen {1} moet ook opgenomen worden"
"To merge, following properties must be same for both items","Te fuseren , moeten volgende eigenschappen hetzelfde zijn voor beide posten"
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Om Prijzen regel niet van toepassing in een bepaalde transactie, moeten alle toepasselijke prijszettingsregels worden uitgeschakeld."
"To set this Fiscal Year as Default, click on 'Set as Default'","Om dit fiscale jaar ingesteld als standaard , klik op ' Als standaard instellen '"
To track any installation or commissioning related work after sales,Om een ​​installatie of inbedrijfstelling gerelateerde werk na verkoop bij te houden
"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No","Om merknaam volgen op de volgende documenten Delivery Note, Opportunity , Materiaal Request , punt , Bestelling , Aankoopbon , Koper Ontvangst , Offerte , verkoopfactuur , Sales BOM , Sales Order , Serienummer"
To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Om object in verkoop-en inkoopdocumenten op basis van hun seriële nos. Dit wordt ook gebruikt om informatie over de garantie van het product volgen.
To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,"Als u items in verkoop-en inkoopdocumenten volgen met batch nos <br> <b>Voorkeur Industrie: Chemische stoffen, enz.</b>"
To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Om items met behulp van barcode te volgen. Je zult in staat zijn om items in leveringsbon en Sales Invoice voer door het scannen van barcodes van item.
Too many columns. Export the report and print it using a spreadsheet application.,Te veel kolommen. Het rapport exporteren en afdrukken met behulp van een spreadsheetprogramma.
Tools,Gereedschap
Total,Totaal
Total ({0}),Totaal ({0})
Total Advance,Totaal Advance
Total Amount,Totaal bedrag
Total Amount To Pay,Totaal te betalen bedrag
Total Amount in Words,Totaal bedrag in woorden
Total Billing This Year: ,Totaal Facturering Dit Jaar:
Total Characters,Totaal Characters
Total Claimed Amount,Totaal gedeclareerde bedrag
Total Commission,Totaal Commissie
Total Cost,Totale kosten
Total Credit,Totaal Krediet
Total Debit,Totaal Debet
Total Debit must be equal to Total Credit. The difference is {0},Totaal Debet moet gelijk zijn aan de totale krediet.
Total Deduction,Totaal Aftrek
Total Earning,Totaal Verdienen
Total Experience,Total Experience
Total Hours,Total Hours
Total Hours (Expected),Totaal aantal uren (Verwachte)
Total Invoiced Amount,Totaal Gefactureerd bedrag
Total Leave Days,Totaal verlofdagen
Total Leaves Allocated,Totaal Bladeren Toegewezen
Total Message(s),Totaal Message ( s )
Total Operating Cost,Totale exploitatiekosten
Total Points,Totaal aantal punten
Total Raw Material Cost,Totaal grondstofprijzen
Total Sanctioned Amount,Totaal Sanctioned Bedrag
Total Score (Out of 5),Totaal Score (van de 5)
Total Tax (Company Currency),Total Tax (Company Munt)
Total Taxes and Charges,Totaal belastingen en heffingen
Total Taxes and Charges (Company Currency),Total en-heffingen (Company Munt)
Total allocated percentage for sales team should be 100,Totaal toegewezen percentage voor sales team moet 100
Total amount of invoices received from suppliers during the digest period,Totaal bedrag van de facturen van leveranciers ontvangen tijdens de digest periode
Total amount of invoices sent to the customer during the digest period,Totaalbedrag van de verzonden facturen aan de klant tijdens de digest periode
Total cannot be zero,Totaal kan niet nul zijn
Total in words,Totaal in woorden
Total points for all goals should be 100. It is {0},Totaal aantal punten voor alle doelen moet 100 . Het is {0}
Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Totale waardering voor de gefabriceerde of omgepakt item (s) kan niet lager zijn dan de totale waarde van de grondstoffen worden
Total weightage assigned should be 100%. It is {0},Totaal weightage toegewezen moet 100 % zijn. Het is {0}
Totals,Totalen
Track Leads by Industry Type.,Track Leads door de industrie type .
Track this Delivery Note against any Project,Volg dit pakbon tegen elke Project
Track this Sales Order against any Project,Volg dit Verkooporder tegen elke Project
Transaction,Transactie
Transaction Date,Transactie Datum
Transaction not allowed against stopped Production Order {0},Transactie niet toegestaan ​​tegen gestopt productieorder {0}
Transfer,Overdracht
Transfer Material,Transfer Materiaal
Transfer Raw Materials,Transfer Grondstoffen
Transferred Qty,overgedragen hoeveelheid
Transportation,vervoer
Transporter Info,Transporter Info
Transporter Name,Vervoerder Naam
Transporter lorry number,Transporter vrachtwagen nummer
Travel,reizen
Travel Expenses,reiskosten
Tree Type,boom Type
Tree of Item Groups.,Boom van Punt groepen .
Tree of finanial Cost Centers.,Boom van finanial kostenplaatsen .
Tree of finanial accounts.,Boom van finanial accounts.
Trial Balance,Trial Balance
Tuesday,Dinsdag
Type,Type
Type of document to rename.,Type document te hernoemen.
"Type of leaves like casual, sick etc.","Aard van de bladeren, zoals casual, zieken enz."
Types of Expense Claim.,Bij declaratie.
Types of activities for Time Sheets,Soorten activiteiten voor Time Sheets
"Types of employment (permanent, contract, intern etc.).","Vormen van werkgelegenheid ( permanent, contract , intern etc. ) ."
UOM Conversion Detail,Verpakking Conversie Detail
UOM Conversion Details,Verpakking Conversie Details
UOM Conversion Factor,Verpakking Conversie Factor
UOM Conversion factor is required in row {0},Verpakking omrekeningsfactor worden vastgesteld in rij {0}
UOM Name,Verpakking Naam
UOM coversion factor required for UOM: {0} in Item: {1},Verpakking conversie factor die nodig is voor Verpakking: {0} in Item: {1}
Under AMC,Onder AMC
Under Graduate,Onder Graduate
Under Warranty,Onder de garantie
Unit,eenheid
Unit of Measure,Meeteenheid
Unit of Measure {0} has been entered more than once in Conversion Factor Table,Maateenheid {0} is ingevoerd meer dan eens in Conversion Factor Tabel
"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Meeteenheid van dit artikel (bijvoorbeeld kg, eenheid, Nee, Pair)."
Units/Hour,Eenheden / uur
Units/Shifts,Eenheden / Verschuivingen
Unpaid,Onbetaald
Unreconciled Payment Details,Onverzoend Betalingsgegevens
Unscheduled,Ongeplande
Unsecured Loans,ongedekte leningen
Unstop,opendraaien
Unstop Material Request,Unstop Materiaal Request
Unstop Purchase Order,Unstop Bestelling
Unsubscribed,Uitgeschreven
Update,Bijwerken
Update Clearance Date,Werk Clearance Datum
Update Cost,Kosten bijwerken
Update Finished Goods,Afgewerkt update Goederen
Update Landed Cost,Update Landed Cost
Update Series,Update Series
Update Series Number,Update Serie Nummer
Update Stock,Werk Stock
Update bank payment dates with journals.,Update bank betaaldata met tijdschriften.
Update clearance date of Journal Entries marked as 'Bank Vouchers',Goedkeuring datum actualisering van Journaalposten gemarkeerd als ' Bank Vouchers '
Updated,Bijgewerkt
Updated Birthday Reminders,Bijgewerkt verjaardagsherinneringen
Upload Attendance,Upload Toeschouwers
Upload Backups to Dropbox,Upload Backups naar Dropbox
Upload Backups to Google Drive,Upload Backups naar Google Drive
Upload HTML,Upload HTML
Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,Upload een csv-bestand met twee kolommen:. De oude naam en de nieuwe naam. Max. 500 rijen.
Upload attendance from a .csv file,Upload aanwezigheid van een. Csv-bestand
Upload stock balance via csv.,Upload voorraadsaldo via csv.
Upload your letter head and logo - you can edit them later.,Upload uw brief hoofd en logo - u kunt ze later bewerken .
Upper Income,Bovenste Inkomen
Urgent,Dringend
Use Multi-Level BOM,Gebruik Multi-Level BOM
Use SSL,Gebruik SSL
Used for Production Plan,Gebruikt voor Productie Plan
User,Gebruiker
User ID,Gebruikers-ID
User ID not set for Employee {0},Gebruikers-ID niet ingesteld voor Employee {0}
User Name,Gebruikersnaam
User Name or Support Password missing. Please enter and try again.,Gebruikersnaam of wachtwoord ondersteuning ontbreekt. Vul en probeer het opnieuw .
User Remark,Gebruiker Opmerking
User Remark will be added to Auto Remark,Gebruiker Opmerking zal worden toegevoegd aan Auto Opmerking
User Remarks is mandatory,Gebruiker Opmerkingen is verplicht
User Specific,gebruiker Specifieke
User must always select,Gebruiker moet altijd kiezen
User {0} is already assigned to Employee {1},Gebruiker {0} is al Employee toegewezen {1}
User {0} is disabled,Gebruiker {0} is uitgeschakeld
Username,Gebruikersnaam
Users with this role are allowed to create / modify accounting entry before frozen date,Gebruikers met deze rol mogen maken / boekhoudkundige afschrijving vóór bevroren datum wijzigen
Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Gebruikers met deze rol mogen bevroren accounts en maak / boekingen tegen bevroren rekeningen wijzigen
Utilities,Utilities
Utility Expenses,Utility kosten
Valid For Territories,Geldig voor Territories
Valid From,geldig van
Valid Upto,Geldig Tot
Valid for Territories,Geldig voor Territories
Validate,Bevestigen
Valuation,Taxatie
Valuation Method,Waardering Methode
Valuation Rate,Waardering Prijs
Valuation Rate required for Item {0},Taxatie Rate vereist voor post {0}
Valuation and Total,Taxatie en Total
Value,Waarde
Value or Qty,Waarde of Aantal
Vehicle Dispatch Date,Vehicle Dispatch Datum
Vehicle No,Voertuig Geen
Venture Capital,Venture Capital
Verified By,Verified By
View Ledger,Bekijk Ledger
View Now,Bekijk nu
Visit report for maintenance call.,Bezoek rapport voor onderhoud gesprek.
Voucher #,voucher #
Voucher Detail No,Voucher Detail Geen
Voucher Detail Number,Voucher Detail Nummer
Voucher ID,Voucher ID
Voucher No,Blad nr.
Voucher Type,Voucher Type
Voucher Type and Date,Voucher Type en Date
Walk In,Walk In
Warehouse,magazijn
Warehouse Contact Info,Warehouse Contact Info
Warehouse Detail,Magazijn Detail
Warehouse Name,Warehouse Naam
Warehouse and Reference,Magazijn en Reference
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Magazijn kan niet worden verwijderd als voorraad grootboek toegang bestaat voor dit magazijn .
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Magazijn kan alleen via Stock Entry / Delivery Note / Kwitantie worden veranderd
Warehouse cannot be changed for Serial No.,Magazijn kan niet worden gewijzigd voor Serienummer
Warehouse is mandatory for stock Item {0} in row {1},Warehouse is verplicht voor voorraad Item {0} in rij {1}
Warehouse is missing in Purchase Order,Warehouse ontbreekt in Purchase Order
Warehouse not found in the system,Magazijn niet gevonden in het systeem
Warehouse required for stock Item {0},Magazijn nodig voor voorraad Item {0}
Warehouse where you are maintaining stock of rejected items,Warehouse waar u het handhaven voorraad van afgewezen artikelen
Warehouse {0} can not be deleted as quantity exists for Item {1},Magazijn {0} kan niet worden verwijderd als hoeveelheid bestaat voor post {1}
Warehouse {0} does not belong to company {1},Magazijn {0} behoort niet tot bedrijf {1}
Warehouse {0} does not exist,Magazijn {0} bestaat niet
Warehouse {0}: Company is mandatory,Magazijn {0}: Bedrijf is verplicht
Warehouse {0}: Parent account {1} does not bolong to the company {2},Magazijn {0}: Parent rekening {1} niet bolong aan het bedrijf {2}
Warehouse-Wise Stock Balance,Warehouse-Wise Stock Balance
Warehouse-wise Item Reorder,Warehouse-wise Item opnieuw ordenen
Warehouses,Magazijnen
Warehouses.,Magazijnen.
Warn,Waarschuwen
Warning: Leave application contains following block dates,Waarschuwing: Verlof applicatie bevat volgende blok data
Warning: Material Requested Qty is less than Minimum Order Qty,Waarschuwing : Materiaal gevraagde Aantal minder dan Minimum afname
Warning: Sales Order {0} already exists against same Purchase Order number,Waarschuwing : Sales Order {0} bestaat tegen hetzelfde Purchase Order nummer
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
Warranty / AMC Details,Garantie / AMC Details
Warranty / AMC Status,Garantie / AMC Status
Warranty Expiry Date,Garantie Vervaldatum
Warranty Period (Days),Garantieperiode (dagen)
Warranty Period (in days),Garantieperiode (in dagen)
We buy this Item,We kopen dit item
We sell this Item,Wij verkopen dit item
Website,Website
Website Description,Website Beschrijving
Website Item Group,Website Item Group
Website Item Groups,Website Artikelgroepen
Website Settings,Website-instellingen
Website Warehouse,Website Warehouse
Wednesday,Woensdag
Weekly,Wekelijks
Weekly Off,Wekelijkse Uit
Weight UOM,Gewicht Verpakking
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Gewicht wordt vermeld , \ nGelieve noemen "" Gewicht Verpakking "" te"
Weightage,Weightage
Weightage (%),Weightage (%)
Welcome,welkom
Welcome to ERPNext. Over the next few minutes we will help you setup your ERPNext account. Try and fill in as much information as you have even if it takes a bit longer. It will save you a lot of time later. Good Luck!,"Welkom bij ERPNext . In de komende paar minuten zullen we u helpen opzetten van je ERPNext account. Probeer en vul zo veel mogelijk informatie je hebt , zelfs als het duurt een beetje langer . Het zal u een hoop tijd later besparen . Good Luck !"
Welcome to ERPNext. Please select your language to begin the Setup Wizard.,Welkom bij ERPNext . Selecteer uw taal om de installatiewizard te starten.
What does it do?,Wat doet het?
"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 een van de gecontroleerde transacties &quot;Submitted&quot;, een e-mail pop-up automatisch geopend om een ​​e-mail te sturen naar de bijbehorende &quot;Contact&quot; in deze transactie, de transactie als bijlage. De gebruiker kan al dan niet verzenden email."
"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Wanneer ingediend , maakt het systeem verschil inzendingen voor de gegeven voorraad en de waardering die op deze datum."
Where items are stored.,Waar items worden opgeslagen.
Where manufacturing operations are carried out.,Wanneer de productie operaties worden uitgevoerd.
Widowed,Weduwe
Will be calculated automatically when you enter the details,Wordt automatisch berekend wanneer u de details
Will be updated after Sales Invoice is Submitted.,Zal worden bijgewerkt na verkoopfactuur wordt ingediend.
Will be updated when batched.,Zal worden bijgewerkt wanneer gedoseerd.
Will be updated when billed.,Zal worden bijgewerkt wanneer gefactureerd.
Wire Transfer,overboeking
With Operations,Met Operations
With Period Closing Entry,Met Periode sluitpost
Work Details,Work Details
Work Done,Werk
Work In Progress,Work In Progress
Work-in-Progress Warehouse,Work-in-Progress Warehouse
Work-in-Progress Warehouse is required before Submit,Work -in- Progress Warehouse wordt vóór vereist Verzenden
Working,Werkzaam
Working Days,Werkdagen
Workstation,Workstation
Workstation Name,Naam van werkstation
Write Off Account,Schrijf Uit account
Write Off Amount,Schrijf Uit Bedrag
Write Off Amount <=,Schrijf Uit Bedrag &lt;=
Write Off Based On,Schrijf Uit Based On
Write Off Cost Center,Schrijf Uit kostenplaats
Write Off Outstanding Amount,Schrijf uitstaande bedrag
Write Off Voucher,Schrijf Uit Voucher
Wrong Template: Unable to find head row.,Verkeerde Template: Kan hoofd rij vinden.
Year,Jaar
Year Closed,Jaar Gesloten
Year End Date,Eind van het jaar Datum
Year Name,Jaar Naam
Year Start Date,Jaar Startdatum
Year of Passing,Jaar van de Passing
Yearly,Jaar-
Yes,Ja
You are not authorized to add or update entries before {0},U bent niet bevoegd om items toe te voegen of bij te werken voordat {0}
You are not authorized to set Frozen value,U bent niet bevoegd om Frozen waarde in te stellen
You are the Expense Approver for this record. Please Update the 'Status' and Save,U bent de Expense Approver voor dit record . Werk van de 'Status' en opslaan
You are the Leave Approver for this record. Please Update the 'Status' and Save,U bent de Leave Approver voor dit record . Werk van de 'Status' en opslaan
You can enter any date manually,U kunt elke datum handmatig
You can enter the minimum quantity of this item to be ordered.,U kunt de minimale hoeveelheid van dit product te bestellen.
You can not change rate if BOM mentioned agianst any item,U kunt geen koers veranderen als BOM agianst een item genoemd
You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Je kunt niet Geen Voer beide Delivery Note en verkoopfactuur Nee Geef iemand.
You can not enter current voucher in 'Against Journal Voucher' column,Je kan niet in de huidige voucher in ' Against Journal Voucher ' kolom
You can set Default Bank Account in Company master,U kunt Default Bank Account ingesteld in Bedrijf meester
You can start by selecting backup frequency and granting access for sync,U kunt beginnen met back- frequentie te selecteren en het verlenen van toegang voor synchronisatie
You can submit this Stock Reconciliation.,U kunt indienen dit Stock Verzoening .
You can update either Quantity or Valuation Rate or both.,U kunt Hoeveelheid of Valuation Rate of beide te werken.
You cannot credit and debit same account at the same time,Je kunt niet crediteren en debiteren dezelfde account op hetzelfde moment
You have entered duplicate items. Please rectify and try again.,U heeft dubbele items ingevoerd. Aub verwijderen en probeer het opnieuw .
You may need to update: {0},U kan nodig zijn om te werken: {0}
You must Save the form before proceeding,U moet het formulier opslaan voordat u verder gaat
Your Customer's TAX registration numbers (if applicable) or any general information,Uw klant fiscale nummers (indien van toepassing) of een algemene informatie
Your Customers,uw klanten
Your Login Id,Uw login-ID
Your Products or Services,Uw producten of diensten
Your Suppliers,uw Leveranciers
Your email address,Uw e-mailadres
Your financial year begins on,Uw financiële jaar begint op
Your financial year ends on,Uw financiële jaar eindigt op
Your sales person who will contact the customer in future,Uw verkoop persoon die de klant in de toekomst contact op te nemen
Your sales person will get a reminder on this date to contact the customer,Uw verkoop persoon krijgt een herinnering op deze datum aan de klant contact op te nemen
Your setup is complete. Refreshing...,Uw installatie is voltooid . Verfrissend ...
Your support email id - must be a valid email - this is where your emails will come!,Uw steun e-id - moet een geldig e zijn - dit is waar je e-mails zal komen!
[Error],[Error]
[Select],[Selecteer ]
`Freeze Stocks Older Than` should be smaller than %d days.,`Freeze Voorraden Ouder dan` moet kleiner zijn dan %d dagen.
and,en
are not allowed.,zijn niet toegestaan ​​.
assigned by,toegewezen door
cannot be greater than 100,mag niet groter zijn dan 100
"e.g. ""Build tools for builders""","bijv. ""Bouw gereedschap voor bouwers """
"e.g. ""MC""","bijv. "" MC """
"e.g. ""My Company LLC""","bijv. "" My Company LLC """
e.g. 5,bijv. 5
"e.g. Bank, Cash, Credit Card","bijvoorbeeld Bank, Cash, Credit Card"
"e.g. Kg, Unit, Nos, m","bv Kg, eenheid, Nos, m"
e.g. VAT,bijv. BTW
eg. Cheque Number,bijvoorbeeld. Cheque nummer
example: Next Day Shipping,Bijvoorbeeld: Next Day Shipping
lft,lft
old_parent,old_parent
rgt,RGT
subject,onderwerp
to,naar
website page link,website Paginalink
{0} '{1}' not in Fiscal Year {2},{0} ' {1} ' niet in het fiscale jaar {2}
{0} Credit limit {0} crossed,{0} kredietlimiet {0} gekruist
{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} serienummers nodig voor post {0} . Slechts {0} ontvangen .
{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} budget voor Account {1} tegen kostenplaats {2} zal overschrijden door {3}
{0} can not be negative,{0} kan niet negatief zijn
{0} created,{0} aangemaakt
{0} does not belong to Company {1},{0} is niet van Company {1}
{0} entered twice in Item Tax,{0} twee keer opgenomen in post Tax
{0} is an invalid email address in 'Notification Email Address',{0} is een ongeldig e-mailadres in ' Notification E-mailadres '
{0} is mandatory,{0} is verplicht
{0} is mandatory for Item {1},{0} is verplicht voor post {1}
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} is verplicht. Misschien Valutawissel record is niet gemaakt voor {1} naar {2}.
{0} is not a stock Item,{0} is geen voorraad artikel
{0} is not a valid Batch Number for Item {1},{0} is geen geldig batchnummer voor post {1}
{0} is not a valid Leave Approver. Removing row #{1}.,{0} is geen geldig Leave Approver. Het verwijderen van rij # {1}.
{0} is not a valid email id,{0} is geen geldig e-id
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} is nu de standaard boekjaar . Vernieuw uw browser om de wijziging door te voeren .
{0} is required,{0} is verplicht
{0} must be a Purchased or Sub-Contracted Item in row {1},{0} moet een gekochte of uitbesteed Item in rij {1}
{0} must be reduced by {1} or you should increase overflow tolerance,{0} moet worden verminderd door {1} of moet je overflow tolerantie verhogen
{0} must have role 'Leave Approver',{0} moet rol ' Leave Approver ' hebben
{0} valid serial nos for Item {1},{0} geldig serienummer nos voor post {1}
{0} {1} against Bill {2} dated {3},{0} {1} tegen Bill {2} gedateerd {3}
{0} {1} against Invoice {2},{0} {1} tegen Factuur {2}
{0} {1} has already been submitted,{0} {1} al is ingediend
{0} {1} has been modified. Please refresh.,{0} {1} is gewijzigd . Vernieuw .
{0} {1} is not submitted,{0} {1} wordt niet ingediend
{0} {1} must be submitted,{0} {1} moet worden ingediend
{0} {1} not in any Fiscal Year,{0} {1} niet in een boekjaar
{0} {1} status is 'Stopped',{0} {1} status ' Gestopt '
{0} {1} status is Stopped,{0} {1} status Gestopt
{0} {1} status is Unstopped,{0} {1} status ontsloten
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: kostenplaats is verplicht voor Item {2}
{0}: {1} not found in Invoice Details table,{0}: {1} niet gevonden in Factuur Details tabel
