 (Half Day),(Halber Tag) #ok
 and year: ,und Jahr: #ok
""" does not exists",""" Existiert nicht"
%  Delivered,%  geliefert
% Amount Billed,% Betrag berechnet
% Billed,% berechnet
% Completed,% abgeschlossen
% Delivered,Geliefert %
% Installed,% installiert
% Milestones Achieved,% Meilensteine erreicht
% Milestones Completed,% Meilensteine fertiggestellt
% Received,% erhalten
% Tasks Completed,% Aufgaben fertiggestellt
% of materials billed against this Purchase Order.,% der für diesen Lieferatenauftrag in Rechnung gestellten Materialien.
% of materials billed against this Sales Order,% der für diesen Kundenauftrag in Rechnung gestellten Materialien
% of materials delivered against this Delivery Note,% der für diesen Lieferschein gelieferten Materialien
% of materials delivered against this Sales Order,% der für diesen Kundenauftrag gelieferten Materialien
% of materials ordered against this Material Request,% der für diese Materialanfrage bestellten Materialien
% of materials received against this Purchase Order,% der für diesen Lieferatenauftrag erhaltenen Materialien
'Actual Start Date' can not be greater than 'Actual End Date',"das ""Startdatum"" kann nicht nach dem  ""Endedatum"" liegen"
'Based On' and 'Group By' can not be same,"""basiert auf"" und ""guppiert durch"" können nicht gleich sein"
'Days Since Last Order' must be greater than or equal to zero,"""Tage seit dem letzten Auftrag"" muss größer oder gleich Null sein"
'Entries' cannot be empty,' Einträge ' darf nicht leer sein
'Expected Start Date' can not be greater than 'Expected End Date',"""erwartetes Startdatum"" nicht nach dem  ""voraussichtlichen Endedatum"" liegen"
'From Date' is required,"""Von-Datum"" ist erforderlich,"
'From Date' must be after 'To Date',"""von Datum"" muss nach 'bis Datum"" liegen"
'Has Serial No' can not be 'Yes' for non-stock item,"""hat Seriennummer"" kann nicht ""Ja"" sein bei Nicht-Lagerartikeln"
'Notification Email Addresses' not specified for recurring %s,'Benachrichtigungs-E-Mail-Adresse nicht angegeben für wiederkehrendes Ereignis %s'
'Profit and Loss' type account {0} not allowed in Opening Entry,"""Gewinn und Verlust"" Konto {0} kann nicht im Eröffnungseintrag sein"
'To Case No.' cannot be less than 'From Case No.','Bis Fall Nr.' kann nicht kleiner als 'Von Fall Nr.' sein
'To Date' is required,"""bis Datum"" ist erforderlich,"
'Update Stock' for Sales Invoice {0} must be set,'Lager aktualisieren' muss für Ausgangsrechnung {0} eingestellt werden
* Will be calculated in the transaction.,* Wird in der Transaktion berechnet.
"**Budget Distribution** helps you distribute your budget across months if you have seasonality in your business.To distribute a budget using this distribution, set this **Budget Distribution** in the **Cost Center**","**Budget Distribution** helps you distribute your budget across months if you have seasonality in your business.To distribute a budget using this distribution, set this **Budget Distribution** in the **Cost Center**"
**Currency** Master,**Währung** Stamm
**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Geschäftsjahr** steht für ein Geschäftsjahr. Alle Buchungen und anderen großen Transaktionen werden mit dem **Geschäftsjahr** verglichen.
1 Currency = [?] FractionFor e.g. 1 USD = 100 Cent,1 Währungseinheit = [?] Teileinheit. Z.b. 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. Um die kundenspezifische Artikel-Nr zu erhalten und sie auffindbar zu machen, verwenden Sie diese Option"
"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Hinzufügen / Bearbeiten </ a>"
"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group""> Hinzufügen / Bearbeiten </ a>"
"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Hinzufügen / Bearbeiten </ 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>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>"
A Customer Group exists with same name please change the Customer name or rename the Customer Group,Eine Kundengruppe mit dem gleichen Namen existiert bereits. Ändern Sie den Kundennamen oder benennen Sie die Kundengruppe um
A Customer exists with same name,Ein Kunde mit dem gleichen Namen existiert bereits!
A Lead with this email id should exist,Eine Verkaufschance mit dieser E-Mail muss existieren
A Product or Service,Ein Produkt oder Dienstleistung
"A Product or a Service that is bought, sold or kept in stock.","Produkt oder Dienstleistung, die gekauft, verkauft oder auf Lager gehalten wird."
A Supplier exists with same name,Ein Lieferant mit dem gleichen Namen existiert bereits
A condition for a Shipping Rule,Vorraussetzung für eine Lieferbedinung
A logical Warehouse against which stock entries are made.,Eine logisches Warenlager für das Bestandseinträge gemacht werden.
A symbol for this currency. For e.g. $,"Ein Symbol für diese Währung, z.B. €"
A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Ein Partner der die Produkte auf Provisionsbasis verkauft.
"A user with ""Expense Approver"" role",Ein Benutzer mit der Berechtigung Ausgaben zu genehmigen
AMC Expiry Date,AMC Verfalldatum
Abbr,Abk.
Abbreviation cannot have more than 5 characters,Abkürzung darf nicht länger als 5 Zeichen sein
Above Value,Wertgrenze wurde überschritten
Absent,Abwesend
Acceptance Criteria,Akzeptanzkriterium
Accepted,Genehmigt
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Akzeptierte + abgelehnte Menge muss für diese Position {0} gleich der erhaltenen Menge sein
Accepted Quantity,Akzeptierte Menge
Accepted Warehouse,Akzeptiertes Lager
Account,Konto
Account Balance,Kontostand
Account Created: {0},Konto für: {0} wurde erstellt
Account Details,Kontendaten
Account Head,Kostenstelleninhaber
Account Name,Kontenname
Account Type,Kontentyp
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Konto bereits im Haben, es ist nicht mehr möglich das Konto als Sollkonto festzulegen"
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Konto bereits im Soll, es ist nicht mehr möglich das Konto als Habenkonto festzulegen"
Account for the warehouse (Perpetual Inventory) will be created under this Account.,Konto für das Lager (Permanente Inventur) wird unter diesem Konto erstellt.
Account head {0} created,Kostenstelleninhaber {0} erstellt
Account must be a balance sheet account,Dieses Konto muss ein Bilanzkonto sein
Account with child nodes cannot be converted to ledger,Ein Konto mit Unterknoten kann nicht in ein Kontoblatt umgewandelt werden
Account with existing transaction can not be converted to group.,Ein Konto mit bestehenden Transaktionen kann nicht in eine Gruppe umgewandelt werden
Account with existing transaction can not be deleted,Ein Konto mit bestehenden Transaktionen kann nicht gelöscht werden
Account with existing transaction cannot be converted to ledger,Ein Konto mit bestehenden Transaktion kann nicht in ein Kontoblatt umgewandelt werden
Account {0} cannot be a Group,Konto {0} kann keine Gruppe sein
Account {0} does not belong to Company {1},Konto {0} gehört nicht zum Unternehmen {1}
Account {0} does not belong to company: {1},Konto {0} gehört nicht zum Unternehmen: {1}
Account {0} does not exist,Konto {0} existiert nicht
Account {0} does not exists,Konto {0} existiert nicht
Account {0} has been entered more than once for fiscal year {1},Konto {0} wurde mehr als einmal für das Geschäftsjahr {1} erfasst
Account {0} is frozen,
Account {0} is inactive,
Account {0} is not valid,
Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,"Konto {0} muss vom Typ ""Aktivposten"" sein, weil der Artikel {1} ein Aktivposten ist"
Account {0}: Parent account {1} can not be a ledger,Konto {0}: Eltern-Konto {1} kann kein Kontenblatt sein
Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Eltern-Konto {1} gehört nicht zur Firma {2}
Account {0}: Parent account {1} does not exist,Konto {0}: Eltern-Konto {1} existiert nicht
Account {0}: You can not assign itself as parent account,Konto {0}: Sie können dieses Konto sich selbst nicht als Eltern-Konto zuweisen
Account: {0} can only be updated via \					Stock Transactions,Konto {0} kann nur über Lagerbewegungen aktualisiert werden
Accountant,Buchhalter
Accounting,Buchhaltung
"Accounting Entries can be made against leaf nodes, called","Buchhaltungseinträge können gegen Unterelemente gemacht werden, die so genannte"
Accounting Entry for Stock,Buchhaltungseintrag für Lager
"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Bis zu diesem Zeitpunkt gesperrter Buchhaltungseintrag, niemand außer der unten genannten Rolle kann den Eintrag bearbeiten/ändern."
Accounting journal entries.,Buchhaltungsjournaleinträge
Accounts,Rechnungswesen
Accounts Browser,Kontenbrowser
Accounts Frozen Upto,Konten gesperrt bis
Accounts Manager,Rechnungswesen Verantwortlicher
Accounts Payable,Kreditoren
Accounts Receivable,Forderungen
Accounts Settings,Konteneinstellungen
Accounts User,Rechnungswesen Benutzer
Active,Aktiv
Active: Will extract emails from ,Aktiv: Werde E-Mails extrahieren von
Activity,Ereignisse
Activity Log,Ereignisprotokoll
Activity Log:,Ereignisprotokoll:
Activity Type,Ereignistyp
Actual,Tatsächlich
Actual Budget,Tatsächliches Budget
Actual Completion Date,Tatsächliches Abschlussdatum
Actual Date,Tatsächliches Datum
Actual End Date,Tatsächliches Enddatum
Actual Invoice Date,Tatsächliches Rechnungsdatum
Actual Posting Date,Tatsächliches Buchungsdatum
Actual Qty,Tatsächliche Anzahl
Actual Qty (at source/target),Tatsächliche Anzahl (am Ursprung/Ziel)
Actual Qty After Transaction,Tatsächliche Anzahl nach Transaktion
Actual Qty: Quantity available in the warehouse.,Tatsächliche Menge: Menge verfügbar im Lager.
Actual Quantity,Bestand
Actual Start Date,Tatsächliches Startdatum
Add,Hinzufügen
Add / Edit Taxes and Charges,Hinzufügen/Bearbeiten von Steuern und Abgaben
Add Child,Untergeordnetes Element hinzufügen
Add Serial No,Seriennummer hinzufügen
Add Taxes,Steuern hinzufügen
Add or Deduct,Addieren/Subtrahieren
Add rows to set annual budgets on Accounts.,Zeilen hinzufügen um Jahresbudgets in Konten festzulegen.
Add to Cart,In den Warenkorb
Add to calendar on this date,An diesem Tag zum Kalender hinzufügen
Add/Remove Recipients,Empfänger hinzufügen/entfernen
Address,Adresse
Address & Contact,Adresse & Kontakt
Address & Contacts,Adresse & Kontakte
Address Desc,Adresszusatz
Address Details,Adressdetails
Address HTML,Adresse im HTML-Format
Address Line 1,Adresszeile 1
Address Line 2,Adresszeile 2
Address Template,Adressvorlage
Address Title,Adresse Titel
Address Title is mandatory.,Adresse Titel muss angegeben werden.
Address Type,Adresstyp
Address master.,Hauptanschrift.
Administrative Expenses,Verwaltungskosten
Administrative Officer,Administrative Officer
Administrator,Administrator
Advance Amount,Vorauskasse
Advance amount,Vorausbetrag
Advances,Vorschüsse
Advertisement,Anzeige
Advertising,Werbung
Aerospace,Luft- und Raumfahrt
After Sale Installations,Installationen nach Verkauf
Against,Gegen
Against Account,Gegenkonto
Against Docname,Gegen Dokumentennamen
Against Doctype,Gegen Dokumententyp
Against Document Detail No,Gegen Dokumentendetail Nr.
Against Document No,Gegen Dokument Nr.
Against Expense Account,Gegen Aufwandskonto
Against Income Account,Gegen Einkommenskonto
Against Journal Voucher,Gegen Buchungsbeleg
Against Journal Voucher {0} does not have any unmatched {1} entry,zu Buchungsbeleg {0} gibt es keine nicht zugeordneten {1} Einträge
Against Purchase Invoice,Gegen Eingangsrechnung
Against Sales Invoice,Gegen Ausgangsrechnung
Against Sales Order,Gegen Kundenauftrag
Against Supplier Invoice {0} dated {1},Gegen Eingangsrechnung {0} vom {1}
Against Voucher,Gegen Gutschein
Against Voucher Type,Gegen Gutscheintyp
Ageing Based On,Altern basiert auf
Ageing Date is mandatory for opening entry,Alterungsdatum ist notwendig bei Starteinträgen
Ageing date is mandatory for opening entry,Alternde Datum ist obligatorisch für die Öffnung der Eintrag
Agent,Beauftragter
"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Sales BOM Item.Note: BOM = Bill of Materials","Zusammenfassen von einer Gruppe von **Artikeln** zu einem **Artikel**. Dies macht Sinn, wenn Sie bestimmte **Artikel** im Paket zusammenstellen und Sie diese Pakete am Lager vorhalten und nicht die **Einzelartikel**. Der Paket-**Artikel** wird bei ""Ist Lagerartikel"" ""Nein"" haben und bei ""ist Verkaufsartikel"" ein ""Ja"" haben. Wenn Sie Laptops und Laptoptaschen separat verkaufen und einen Sonderpreis für Kunden haben, die beides kaufen, dann wird aus Laptop + Laptoptasche eine Verkaufsstückliste."
Aging Date,Fälligkeitsdatum
Aging Date is mandatory for opening entry,Aging Datum ist obligatorisch für die Öffnung der Eintrag
Agriculture,Landwirtschaft
Airline,Fluggesellschaft
All,Alle
All Addresses.,Alle Adressen
All Contact,Alle Kontakte
All Contacts.,Alle Kontakte
All Customer Contact,Alle Kundenkontakte
All Customer Groups,Alle Kundengruppen
All Day,Ganzer Tag
All Employee (Active),Alle Mitarbeiter (Aktiv)
All Item Groups,Alle Artikelgruppen
All Lead (Open),Alle Interessenten (offen)
All Products or Services.,Alle Produkte oder Dienstleistungen.
All Sales Partner Contact,Alle Vertriebspartnerkontakte
All Sales Person,Alle Vertriebsmitarbeiter
All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Alle Verkaufsvorgänge können für mehrere ** Vertriebsmitarbeiter** markiert werden, so dass Sie Ziele festlegen und überwachen können."
All Supplier Contact,Alle Lieferantenkontakte
All Supplier Types,Alle Lieferant Typen
All Territories,Alle Staaten
"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 verwandten Bereiche wie Währung, Wechselkurse, Summenexport, Gesamtsummenexport usw. sind in Lieferschein, POS, Angebot, Ausgangsrechnung, Kundenauftrag usw. verfügbar"
"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 verwandten Bereiche wie Währung, Wechselkurs, Summenimport, Gesamtsummenimport etc sind in Eingangslieferschein, Lieferant Angebot, Eingangsrechnung, Lieferatenauftrag usw. verfügbar"
All items have already been invoiced,Alle Einzelteile sind bereits abgerechnet
All these items have already been invoiced,Alle diese Elemente sind bereits in Rechnung gestellt
Allocate,Zuordnung
Allocate leaves for a period.,Jahresurlaube für einen Zeitraum.
Allocate leaves for the year.,Jahresurlaube zuordnen.
Allocated Amount,Zugewiesener Betrag
Allocated Budget,Zugewiesenes Budget
Allocated amount,Zugewiesener Betrag
Allocated amount can not be negative,Geschätzter Betrag kann nicht negativ sein
Allocated amount can not greater than unadusted amount,Geschätzter Betrag kann nicht größer als unadusted Menge
Allow Bill of Materials,Stückliste zulassen
Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,"Stückliste erlauben sollte ""Ja"" sein, da eine oder mehrere zu diesem Artikel vorhandene Stücklisten aktiv sind"
Allow Children,Lassen Sie Kinder
Allow Dropbox Access,Dropbox-Zugang zulassen
Allow Google Drive Access,Google Drive-Zugang zulassen
Allow Negative Balance,Negativen Saldo zulassen
Allow Negative Stock,Negatives Inventar zulassen
Allow Production Order,Fertigungsauftrag zulassen
Allow User,Benutzer zulassen
Allow Users,Benutzer zulassen
Allow the following users to approve Leave Applications for block days.,"Zulassen, dass die folgenden Benutzer Urlaubsanträge für Blöcke von Tagen genehmigen können."
Allow user to edit Price List Rate in transactions,"Benutzer erlauben, die Preislistenrate in Transaktionen zu bearbeiten"
Allowance Percent,Zulassen Prozent
Allowance for over-{0} crossed for Item {1},Wertberichtigungen für Über {0} drücken für Artikel {1}
Allowance for over-{0} crossed for Item {1}.,Wertberichtigungen für Über {0} drücken für Artikel {1}.
Allowed Role to Edit Entries Before Frozen Date,"Erlaubt der Rolle, Einträge vor dem Sperrdatum zu bearbeiten"
Amended From,Geändert am
Amount,Betrag
Amount (Company Currency),Betrag (Unternehmenswährung)
Amount Paid,Zahlbetrag
Amount to Bill,Rechnungsbetrag
Amounts not reflected in bank,bei der Bank nicht berücksichtigte Beträge
Amounts not reflected in system,im System nicht berücksichtigte Beträge
An Customer exists with same name,Ein Kunde mit dem gleichen Namen existiert
"An Item Group exists with same name, please change the item name or rename the item group","Mit dem gleichen Namen eine Artikelgruppe existiert, ändern Sie bitte die Artikel -Namen oder die Artikelgruppe umbenennen"
"An item exists with same name ({0}), please change the item group name or rename the item","Ein Element mit dem gleichen Namen existiert ({0} ), ändern Sie bitte das Einzelgruppennamen oder den Artikel umzubenennen"
Analyst,Analytiker
Annual,jährlich
Another Period Closing Entry {0} has been made after {1},Eine weitere Periode Schluss Eintrag {0} wurde nach gemacht worden {1}
Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,Eine andere Gehaltsstruktur {0} ist für diesen Mitarbeiter {1} aktiv. Setzen Sie dessen Status auf inaktiv um fortzufahren.
"Any other comments, noteworthy effort that should go in the records.",Alle weiteren Kommentare sind bemerkenswert und sollten aufgezeichnet werden.
Apparel & Accessories,Kleidung & Accessoires
Applicability,Anwendbarkeit
Applicable Charges,anwendbare Gebühren
Applicable For,Anwendbar
Applicable Holiday List,Geltende Urlaubsliste
Applicable Territory,Anwendbar Territory
Applicable To (Designation),Geltend für (Bestimmung)
Applicable To (Employee),Geltend für (Mitarbeiter)
Applicable To (Role),Anwendbar auf (Rolle)
Applicable To (User),Anwendbar auf (User)
Applicant Name,Bewerbername
Applicant for a Job,Bewerber für einen Job
Applicant for a Job.,Bewerber für einen Job.
Application of Funds (Assets),Mittelverwendung (Aktiva)
Applications for leave.,Urlaubsanträge
Applies to Company,Gilt für Unternehmen
Apply / Approve Leaves,Beurlaubungen anwenden/genehmigen
Apply On,Bewerben auf
Appraisal,Bewertung
Appraisal Goal,Bewertungsziel
Appraisal Goals,Bewertungsziele
Appraisal Template,Bewertungsvorlage
Appraisal Template Goal,Bewertungsvorlage Ziel
Appraisal Template Title,Bewertungsvorlage Titel
Appraisal {0} created for Employee {1} in the given date range,Bewertung {0} für Mitarbeiter erstellt {1} in der angegebenen Datumsbereich
Apprentice,Lehrling
Approval Status,Genehmigungsstatus
Approval Status must be 'Approved' or 'Rejected',"Genehmigungsstatus muss ""genehmigt"" oder ""abgelehnt"" sein"
Approved,Genehmigt
Approver,Genehmigender
Approving Role,Genehmigende Rolle
Approving Role cannot be same as role the rule is Applicable To,Genehmigen Rolle kann nicht dieselbe sein wie die Rolle der Regel ist anwendbar auf
Approving User,Genehmigen Benutzer
Approving User cannot be same as user the rule is Applicable To,Genehmigen Benutzer kann nicht dieselbe sein wie Benutzer die Regel ist anwendbar auf
Are you sure you want to STOP ,Sind Sie sicher das Sie dies anhalten möchten?
Are you sure you want to UNSTOP ,Sind Sie sicher das Sie dies freigeben möchten?
Arrear Amount,Ausstehender Betrag
"As Production Order can be made for this item, it must be a stock item.","Da für diesen Artikel Fertigungsaufträge erlaubt sind, es muss dieser ein Lagerartikel sein."
As per Stock UOM,Wie pro Lager-ME
"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'","Da es bestehende Lagertransaktionen zu diesem Artikel gibt, können Sie die Werte von 'hat Seriennummer', 'ist Lagerartikel'  und 'Bewertungsmethode' nicht ändern"
Asset,Vermögenswert
Assistant,Assistent
Associate,Mitarbeiterin
Atleast one of the Selling or Buying must be selected,Mindestens eines aus Vertrieb oder Einkauf muss ausgewählt werden
Atleast one warehouse is mandatory,Mindestens ein Warenlager ist obligatorisch
Attach Image,Bild anhängen
Attach Letterhead,Briefkopf anhängen
Attach Logo,Logo anhängen
Attach Your Picture,fügen Sie Ihr Bild hinzu
Attendance,Teilnahme
Attendance Date,Teilnahmedatum
Attendance Details,Teilnahmedetails
Attendance From Date,Teilnahmedatum von
Attendance From Date and Attendance To Date is mandatory,Die Teilnahme von Datum bis Datum und Teilnahme ist obligatorisch
Attendance To Date,Teilnahme bis Datum
Attendance can not be marked for future dates,Die Teilnahme kann nicht für zukünftige Termine markiert werden
Attendance for employee {0} is already marked,Die Teilnahme für Mitarbeiter {0} bereits markiert ist
Attendance record.,Anwesenheitsnachweis
Auditor,Prüfer
Authorization Control,Berechtigungskontrolle
Authorization Rule,Autorisierungsregel
Auto Accounting For Stock Settings,Auto Accounting for Stock -Einstellungen
Auto Material Request,Automatische Materialanforderung
Auto-raise Material Request if quantity goes below re-order level in a warehouse,"Automatische Erstellung einer Materialanforderung, wenn die Menge in einem Warenlager unter der Grenze für Neubestellungen liegt"
Automatically compose message on submission of transactions.,Automatisch komponieren Nachricht auf Vorlage von Transaktionen.
Automatically updated via Stock Entry of type Manufacture/Repack,Automatisch über Lagerbuchung vom Typ Herstellung/Umpacken aktualisiert
Automotive,Automotive
Autoreply when a new mail is received,"Autoreply, wenn eine neue E-Mail eingegangen ist"
Available,verfügbar
Available Qty at Warehouse,Verfügbarer Lagerbestand
Available Stock for Packing Items,Verfügbarer Bestand für Verpackungsartikel
"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Verfügbar in Stückliste, Lieferschein, Eingangsrechnung, Fertigungsauftrag, Lieferatenauftrag, Eingangslieferschein, Ausgangsrechnung, Kundenauftrag, Lagerbeleg, Zeiterfassung"
Average Age,Durchschnittsalter
Average Commission Rate,Durchschnittliche Kommission bewerten
Average Discount,Durchschnittlicher Rabatt
Awesome Products,besondere Produkte
Awesome Services,besondere Dienstleistungen
BOM Detail No,Stückliste Detailnr.
BOM Explosion Item,Position der Stücklistenauflösung
BOM Item,Stücklistenartikel
BOM No,Stücklistennr.
BOM No. for a Finished Good Item,Stücklistennr. für einen fertigen Artikel
BOM Operation,Stücklistenvorgang
BOM Operations,Stücklistenvorgänge
BOM Replace Tool,Stücklisten-Ersetzungstool
BOM number is required for manufactured Item {0} in row {1},Stücklistennummer ist für hergestellten Artikel {0} erforderlich in Zeile {1}
BOM number not allowed for non-manufactured Item {0} in row {1},Stücklistennummer für nicht hergestellten Artikel {0} in Zeile {1} ist nicht zulässig
BOM recursion: {0} cannot be parent or child of {2},BOM Rekursion : {0} kann nicht Elternteil oder Kind von {2} sein
BOM replaced,Stückliste ersetzt
BOM {0} for Item {1} in row {2} is inactive or not submitted,Stückliste {0} für Artikel {1} in Zeile {2} ist inaktiv oder nicht eingereicht
BOM {0} is not active or not submitted,Stückliste {0} ist nicht aktiv oder nicht eingereicht
BOM {0} is not submitted or inactive BOM for Item {1},Stückliste {0} ist nicht eine eingereichte oder inaktive Stückliste für Artikel {1}
Backup Manager,Datensicherungsverwaltung
Backup Right Now,Jetzt eine Datensicherung durchführen
Backups will be uploaded to,Datensicherungen werden hochgeladen nach
Balance Qty,Bilanzmenge
Balance Sheet,Bilanz
Balance Value,Bilanzwert
Balance for Account {0} must always be {1},Saldo für Konto {0} muss immer {1} sein
Balance must be,Saldo muss sein
"Balances of Accounts of type ""Bank"" or ""Cash""","Guthaben von Konten vom Typ ""Bank"" oder ""Cash"""
Bank,Bank
Bank / Cash Account,Bank / Geldkonto
Bank A/C No.,Bankkonto-Nr.
Bank Account,Bankkonto
Bank Account No.,Bankkonto-Nr.
Bank Accounts,Bankkonten
Bank Clearance Summary,Zusammenfassung Bankgenehmigung
Bank Draft,Bank Entwurf
Bank Name,Name der Bank
Bank Overdraft Account,Kontokorrentkredit Konto
Bank Reconciliation,Kontenabstimmung
Bank Reconciliation Detail,Kontenabstimmungsdetail
Bank Reconciliation Statement,Kontenabstimmungsauszug
Bank Voucher,Bankbeleg
Bank/Cash Balance,Bank-/Bargeldsaldo
Banking,Bankwesen
Barcode,Barcode
Barcode {0} already used in Item {1},Barcode {0} wird bereits in Artikel {1} verwendet
Based On,Beruht auf
Basic,Grundlagen
Basic Info,Grundinfo
Basic Information,Grundinformationen
Basic Rate,Grundrate
Basic Rate (Company Currency),Grundrate (Unternehmenswährung)
Batch,Stapel
Batch (lot) of an Item.,Stapel (Partie) eines Artikels.
Batch Finished Date,Stapel endet am
Batch ID,Stapel-ID
Batch No,Stapelnr.
Batch Started Date,Stapel beginnt am
Batch Time Logs for Billing.,Stapel-Zeitprotokolle für Abrechnung.
Batch Time Logs for billing.,Stapel-Zeitprotokolle für Abrechnung.
Batch-Wise Balance History,Stapelweiser Kontostand
Batched for Billing,Für Abrechnung gebündelt
Better Prospects,Bessere zukünftige Kunden
Bill Date,Rechnungsdatum
Bill No,Rechnungsnr.
Bill of Material,Stückliste
Bill of Material to be considered for manufacturing,"Stückliste, die für die Herstellung berücksichtigt werden soll"
Bill of Materials (BOM),Stückliste (SL)
Billable,Abrechenbar
Billed,Abgerechnet
Billed Amount,Rechnungsbetrag
Billed Amt,Rechnungsbetrag
Billing,Abrechnung
Billing (Sales Invoice),Verkauf (Ausgangsrechnung)
Billing Address,Rechnungsadresse
Billing Address Name,Name der Rechnungsadresse
Billing Status,Abrechnungsstatus
Bills raised by Suppliers.,Rechnungen an Lieferanten
Bills raised to Customers.,Rechnungen an Kunden
Bin,Lagerfach
Bio,Bio
Biotechnology,Biotechnologie
Birthday,Geburtstag
Block Date,Datum sperren
Block Days,Tage sperren
Block Holidays on important days.,Urlaub an wichtigen Tagen sperren.
Block leave applications by department.,Urlaubsanträge pro Abteilung sperren.
Blog Post,Blog-Post
Blog Subscriber,Blog-Abonnent
Blood Group,Blutgruppe
Both Warehouse must belong to same Company,Beide Lager müssen zur gleichen Gesellschaft gehören
Box,Kiste
Branch,Filiale
Brand,Marke
Brand Name,Markenname
Brand master.,Marke Vorlage
Brands,Marken
Breakdown,Übersicht
Broadcasting,Rundfunk
Brokerage,Provision
Budget,Budget
Budget Allocated,Zugewiesenes Budget
Budget Detail,Budgetdetail
Budget Details,Budgetdetails
Budget Distribution,Budgetverteilung
Budget Distribution Detail,Budgetverteilung Details
Budget Distribution Details,Budgetverteilung Details
Budget Variance Report,Budget Abweichungsbericht
Budget cannot be set for Group Cost Centers,Budget kann nicht für die Konzernkostenstelleneingerichtet werden
Build Report,Bauen Bericht
Bundle items at time of sale.,Artikel zum Zeitpunkt des Verkaufs zusammenfassen.
Business Development Manager,Business Development Manager
Buyer of Goods and Services.,Käufer von Waren und Dienstleistungen.
Buying,Einkauf
Buying & Selling,Einkauf und Vertrieb
Buying Amount,Kaufbetrag
Buying Settings,Einkaufs Einstellungen
"Buying must be checked, if Applicable For is selected as {0}","Kaufen Sie muss überprüft werden, wenn Anwendbar ist als ausgewählt {0}"
C-Form,C-Formular
C-Form Applicable,C-Formular Anwendbar
C-Form Invoice Detail,C-Formular Rechnungsdetails
C-Form No,C-Formular Nr.
C-Form records,C- Form- Aufzeichnungen
CENVAT Capital Goods,CENVAT Investitionsgüter
CENVAT Edu Cess,CENVAT Edu Cess
CENVAT SHE Cess,CENVAT SHE Cess
CENVAT Service Tax,CENVAT Service Steuer
CENVAT Service Tax Cess 1,CENVAT Service Steuer Cess 1
CENVAT Service Tax Cess 2,CENVAT Service Steuer Cess 2
Calculate Based On,Berechnet auf Grundlage von
Calculate Total Score,Gesamtwertung berechnen
Calendar Events,Kalenderereignisse
Call,Anruf
Calls,Anrufe
Campaign,Kampagne
Campaign Name,Kampagnenname
Campaign Name is required,Kampagnenname ist erforderlich
Campaign Naming By,Kampagne benannt durch
Campaign-.####,Kampagne-.####
Can be approved by {0},Kann von {0} genehmigt werden
"Can not filter based on Account, if grouped by Account","Basierend auf Konto kann nicht filtern, wenn sie von Konto gruppiert"
"Can not filter based on Voucher No, if grouped by Voucher","Basierend auf Gutschein kann nicht auswählen, Nein, wenn durch Gutschein gruppiert"
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Kann sich nur auf diese Zeile beziehen, wenn die Berechnungsart 'bei vorherigem Zeilenbetrag' oder 'bei nachfolgendem Zeilenbetrag' ist"
Cancel Material Visit {0} before cancelling this Customer Issue,Abbrechen Werkstoff Besuchen Sie {0} vor Streichung dieses Kunden Ausgabe
Cancel Material Visits {0} before cancelling this Maintenance Visit,Abbrechen Werkstoff Besuche {0} vor Streichung dieses Wartungsbesuch
Cancelled,Abgebrochen
Cancelling this Stock Reconciliation will nullify its effect.,Abbruch der Lagerbewertung wird den Effekt zu nichte machen.
Cannot Cancel Opportunity as Quotation Exists,Kann nicht Abbrechen Gelegenheit als Zitat vorhanden ist
Cannot approve leave as you are not authorized to approve leaves on Block Dates,"Diese Abwesenheit kann nicht genehmigt werden, da Sie nicht über die Berechtigung zur Genehmigung von Block-Abwesenheiten verfügen."
Cannot cancel because Employee {0} is already approved for {1},"Kann nicht kündigen, weil Mitarbeiter {0} ist bereits genehmigt {1}"
Cannot cancel because submitted Stock Entry {0} exists,"Kann nicht kündigen, weil eingereichten Lizenz Eintrag {0} existiert"
Cannot carry forward {0},Kann nicht mitnehmen {0}
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Geschäftsjahr Startdatum und Geschäftsjahresende Datum, wenn die Geschäftsjahr wird gespeichert nicht ändern kann."
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Kann nicht die Standardwährung der Firma ändern, weil es bestehende Transaktionen gibt. Transaktionen müssen abgebrochen werden, um die Standardwährung zu ändern."
Cannot convert Cost Center to ledger as it has child nodes,"Kann Kostenstelle nicht zu Kontenbuch konvertieren, da es untergeordnete Knoten hat"
Cannot covert to Group because Master Type or Account Type is selected.,"Kann nicht zu Gruppe konvertiert werden, weil Hauptart oder Kontenart ausgewählt ist."
Cannot deactive or cancle BOM as it is linked with other BOMs,"Kann Stückliste nicht deaktivieren oder abbrechen, da sie mit anderen Stücklisten verknüpft ist"
"Cannot declare as lost, because Quotation has been made.","Kann nicht als Verloren deklariert werden, da dies bereits angeboten wurde."
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Abzug nicht möglich, wenn Kategorie ""Bewertung"" oder ""Bewertung und Summe"" ist"
"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Kann Seriennummer {0} in Lager nicht löschen. Zuerst aus dem Lager entfernen, dann löschen."
"Cannot directly set amount. For 'Actual' charge type, use the rate field","Kann Betrag nicht direkt setzen. Für ""tatsächliche"" Berechnungsart, verwenden Sie das Preisfeld"
"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings",Kann nicht für Artikel {0} in Zeile overbill {0} mehr als {1}. Um Überfakturierung erlauben Sie bitte Lizenzeinstellungen festgelegt
Cannot produce more Item {0} than Sales Order quantity {1},"Kann nicht mehr Artikel {0} produzieren, als Kundenaufträge {1} dafür vorliegen"
Cannot refer row number greater than or equal to current row number for this Charge type,Kann nicht Zeilennummer größer oder gleich aktuelle Zeilennummer für diesen Ladetypbeziehen
Cannot return more than {0} for Item {1},Kann nicht mehr als {0} zurück zur Artikel {1}
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Kann nicht verantwortlich Typ wie 'On Zurück Reihe Betrag ""oder"" Auf Vorherige Row Total' für die erste Zeile auswählen"
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,"Kann nicht verantwortlich Typ wie 'On Zurück Reihe Betrag ""oder"" Auf Vorherige Row Total' für die Bewertung zu wählen. Sie können nur die Option ""Total"" für die vorherige Zeile Betrag oder vorherigen Zeile Gesamt wählen"
Cannot set as Lost as Sales Order is made.,"Kann nicht als Verlust gekennzeichnet werden, da ein Kundenauftrag dazu existiert."
Cannot set authorization on basis of Discount for {0},Kann Genehmigung nicht auf der Basis des Rabattes für {0} festlegen
Capacity,Kapazität
Capacity Units,Kapazitätseinheiten
Capital Account,Kapitalkonto
Capital Equipments,Hauptstadt -Ausrüstungen
Carry Forward,Übertragen
Carry Forwarded Leaves,Übertragene Urlaubsgenehmigungen
Case No(s) already in use. Try from Case No {0},"Fall Nr. (n) bereits im Einsatz. Versuchen Sie, von Fall Nr. {0}"
Case No. cannot be 0,Fall Nr. kann nicht 0 sein
Cash,Bargeld
Cash In Hand,Bargeld in der Hand
Cash Voucher,Kassenbeleg
Cash or Bank Account is mandatory for making payment entry,Barzahlung oder Bankkonto ist für die Zahlung Eintrag
Cash/Bank Account,Kassen-/Bankkonto
Casual Leave,Lässige Leave
Cell Number,Mobiltelefonnummer
Change Abbreviation,Abkürzung ändern
Change UOM for an Item.,ME für einen Artikel ändern.
Change the starting / current sequence number of an existing series.,Startnummer/aktuelle laufende Nummer einer bestehenden Serie ändern.
Channel Partner,Vertriebspartner
Charge of type 'Actual' in row {0} cannot be included in Item Rate,Verantwortlicher für Typ ' Actual ' in Zeile {0} kann nicht in Artikel bewerten aufgenommen werden
Chargeable,Gebührenpflichtig
Charges are updated in Purchase Receipt against each item,die Gebühren im Eingangslieferschein wurden für jeden Artikel aktualisiert
Charges will be distributed proportionately based on item amount,Die Gebühren werden anteilig auf die Artikel umgelegt
Charity and Donations,Charity und Spenden
Chart Name,Diagrammname
Chart of Accounts,Kontenplan
Chart of Cost Centers,Tabelle der Kostenstellen
Check how the newsletter looks in an email by sending it to your email.,"Prüfen Sie, wie der Newsletter in einer E-Mail aussieht, indem Sie ihn an Ihre E-Mail senden."
"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Aktivieren, wenn dies eine wiederkehrende Rechnung ist, deaktivieren, damit es keine wiederkehrende Rechnung mehr ist oder ein gültiges Enddatum angeben."
"Check if recurring order, uncheck to stop recurring or put proper End Date",Aktivieren wenn es sich um eine wiederkehrende Bestellung handelt. Deaktivieren um die Wiederholungen anzuhalten oder geben Sie ein entsprechendes Ende-Datum an
"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Aktivieren, wenn Sie automatisch wiederkehrende Ausgangsrechnungen benötigen. Nach dem Absenden einer Ausgangsrechnung wird der Bereich für wiederkehrende Ausgangsrechnungen angezeigt."
Check if you want to send salary slip in mail to each employee while submitting salary slip,"Aktivieren, wenn Sie die Gehaltsabrechnung per Post an jeden Mitarbeiter senden möchten."
Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Aktivieren, wenn Sie den Benutzer zwingen möchten, vor dem Speichern eine Serie auszuwählen. Wenn Sie dies aktivieren, gibt es keine Standardeinstellung."
Check this if you want to show in website,"Aktivieren, wenn Sie den Inhalt auf der Website anzeigen möchten."
Check this to disallow fractions. (for Nos),"Aktivieren, um keine Brüche zuzulassen. (für Nr.)"
Check this to pull emails from your mailbox,"Aktivieren, um E-Mails aus Ihrem Postfach zu ziehen"
Check to activate,"Aktivieren, um zu aktivieren"
Check to make Shipping Address,"Aktivieren, um Lieferadresse anzugeben"
Check to make primary address,"Aktivieren, um primäre Adresse anzugeben"
Chemical,Chemikalie
Cheque,Scheck
Cheque Date,Scheckdatum
Cheque Number,Schecknummer
Child account exists for this account. You can not delete this account.,ein Unterkonto existiert für dieses Konto. Sie können dieses Konto nicht löschen.
City,Stadt
City/Town,Stadt/Ort
Claim Amount,Betrag einfordern
Claims for company expense.,Ansprüche auf Firmenkosten.
Class / Percentage,Klasse/Anteil
Classic,Klassisch
Classification of Customers by region,Klassifizierung der Kunden nach Region
Clear Table,Tabelle löschen
Clearance Date,Löschdatum
Clearance Date not mentioned,Räumungsdatumnicht genannt
Clearance date cannot be before check date in row {0},Räumungsdatum kann nicht vor dem Check- in Datum Zeile {0}
Click on 'Make Sales Invoice' button to create a new Sales Invoice.,"Klicken Sie auf 'Ausgangsrechnung erstellen', um eine neue Ausgangsrechnung zu erstellen."
Click on a link to get options to expand get options ,auf den Link klicken um die Optionen anzuzeigen 
Client,Kunde
Close Balance Sheet and book Profit or Loss.,Bilanz schliessen und Gewinn und Verlust buchen.
Closed,Geschlossen
Closing (Cr),Closing (Cr)
Closing (Dr),Closing (Dr)
Closing Account Head,Abschluss Kontenführer
Closing Account {0} must be of type 'Liability',"Schluss Konto {0} muss vom Typ ""Haftung"" sein"
Closing Date,Abschlussdatum
Closing Fiscal Year,Abschluss des Geschäftsjahres
Closing Qty,Schließen Menge
Closing Value,Schlusswerte
CoA Help,CoA-Hilfe
Code,Code
Cold Calling,Kaltakquise
Color,Farbe
Column Break,Spaltenumbruch
Comma separated list of email addresses,Durch Kommas getrennte Liste von E-Mail-Adressen
Comment,Kommentar
Comments,Kommentare
Commercial,Handels-
Commission,Provision
Commission Rate,Provisionssatz
Commission Rate (%),Provisionsrate (%)
Commission on Sales,Provision auf den Umsatz
Commission rate cannot be greater than 100,Provisionsrate nicht größer als 100 sein
Communication,Kommunikation
Communication HTML,Kommunikation HTML
Communication History,Kommunikationshistorie
Communication log.,Kommunikationsprotokoll
Communications,Kommunikation
Company,Firma
Company (not Customer or Supplier) master.,Firma (nicht der Kunde bzw. Lieferant) Vorlage.
Company Abbreviation,Firmen Abkürzung
Company Details,Firmendetails
Company Email,Firma E-Mail
"Company Email ID not found, hence mail not sent","Firmen E-Mail-Adresse nicht gefunden, daher wird die Mail nicht gesendet"
Company Info,Firmeninformationen
Company Name,Firmenname
Company Settings,Firmeneinstellungen
Company is missing in warehouses {0},Firma fehlt in Lagern {0}
Company is required,"Firma ist verpflichtet,"
Company registration numbers for your reference. Example: VAT Registration Numbers etc.,Firmenregistrierungsnummern für Ihre Referenz. Beispiel: Umsatzsteuer-Identifikationsnummern usw.
Company registration numbers for your reference. Tax numbers etc.,Firmenregistrierungsnummern für Ihre Referenz. Steuernummern usw.
"Company, Month and Fiscal Year is mandatory","Unternehmen, Monat und Geschäftsjahr ist obligatorisch"
Compensatory Off,Ausgleichs Off
Complete,Abschließen
Complete Setup,Setup vervollständigen
Completed,Abgeschlossen
Completed Production Orders,Abgeschlossene Fertigungsaufträge
Completed Qty,Abgeschlossene Menge
Completion Date,Abschlussdatum
Completion Status,Fertigstellungsstatus
Computer,Computer
Computers,Computer
Confirmation Date,Bestätigung Datum
Confirmed orders from Customers.,Bestätigte Aufträge von Kunden.
Consider Tax or Charge for,Steuern oder Gebühren berücksichtigen für
Considered as Opening Balance,Gilt als Anfangsbestand
Considered as an Opening Balance,Gilt als ein Anfangsbestand
Consultant,Berater
Consulting,Beratung
Consumable,Verbrauchsgut
Consumable Cost,Verbrauchskosten
Consumable cost per hour,Verbrauchskosten pro Stunde
Consumed Qty,Verbrauchte Menge
Consumer Products,Consumer Products
Contact,Kontakt
Contact Control,Kontaktsteuerung
Contact Desc,Kontakt-Beschr.
Contact Details,Kontaktinformationen
Contact Email,Kontakt E-Mail
Contact HTML,Kontakt HTML
Contact Info,Kontaktinformation
Contact Mobile No,Kontakt Mobiltelefon
Contact Name,Ansprechpartner
Contact No.,Kontakt Nr.
Contact Person,Kontaktperson
Contact Type,Kontakttyp
Contact master.,Kontakt Master.
Contacts,Impressum
Content,Inhalt
Content Type,Inhaltstyp
Contra Voucher,Gegen Gutschein
Contract,Vertrag
Contract End Date,Vertragsende
Contract End Date must be greater than Date of Joining,Vertragsende muss größer sein als Datum für Füge sein
Contribution (%),Beitrag (%)
Contribution to Net Total,Beitrag zum Gesamtnetto
Conversion Factor,Umrechnungsfaktor
Conversion Factor is required,Umrechnungsfaktor erforderlich
Conversion factor cannot be in fractions,Umrechnungsfaktor kann nicht in den Fraktionen sein
Conversion factor for default Unit of Measure must be 1 in row {0},Umrechnungsfaktor für Standard- Maßeinheit muss in Zeile 1 {0}
Conversion rate cannot be 0 or 1,Die Conversion-Rate kann nicht 0 oder 1 sein
Convert to Group,Konvertieren in Gruppe
Convert to Ledger,Convert to Ledger
Converted,Konvertiert
Copy From Item Group,Kopie von Artikelgruppe
Cosmetics,Kosmetika
Cost Center,Kostenstelle
Cost Center Details,Kostenstellendetails
Cost Center For Item with Item Code ',Kostenstelle für den Artikel mit der Artikel-Nr
Cost Center Name,Kostenstellenname
Cost Center is required for 'Profit and Loss' account {0},Kostenstelle wird für ' Gewinn-und Verlustrechnung des erforderlichen {0}
Cost Center is required in row {0} in Taxes table for type {1},Kostenstelle wird in der Zeile erforderlich {0} in Tabelle Steuern für Typ {1}
Cost Center with existing transactions can not be converted to group,Kostenstelle mit bestehenden Geschäfte nicht zu Gruppe umgewandelt werden
Cost Center with existing transactions can not be converted to ledger,Kostenstelle mit bestehenden Geschäfte nicht zu Buch umgewandelt werden
Cost Center {0} does not belong to Company {1},Kostenstellen {0} ist nicht gehören Unternehmen {1}
Cost of Goods Sold,Herstellungskosten der verkauften
Costing,Kosten
Country,Land
Country Name,Ländername
Country wise default Address Templates,landesspezifische Standardadressvorlagen
"Country, Timezone and Currency","Land, Zeitzone und Währung"
Cr,Cr
Create Bank Voucher for the total salary paid for the above selected criteria,Bankgutschein für das Gesamtgehalt nach den oben ausgewählten Kriterien erstellen
Create Customer,neuen Kunden erstellen
Create Material Requests,Materialanfragen erstellen
Create New,neuen Eintrag erstellen
Create Opportunity,Gelegenheit erstellen
Create Production Orders,Fertigungsaufträge erstellen
Create Quotation,Angebot erstellen
Create Receiver List,Empfängerliste erstellen
Create Salary Slip,Gehaltsabrechnung erstellen
Create Stock Ledger Entries when you submit a Sales Invoice,"Lagerbucheinträge erstellen, wenn Sie eine Ausgangsrechnung einreichen"
Create and Send Newsletters,Newsletter erstellen und senden
"Create and manage daily, weekly and monthly email digests.","Erstellen und Verwalten von täglichen, wöchentlichen und monatlichen E-Mail Berichten."
Create rules to restrict transactions based on values.,Erstellen Sie Regeln um Transaktionen auf Basis von Werten zu beschränken.
Created By,Erstellt von
Creates salary slip for above mentioned criteria.,Erstellt Gehaltsabrechnung für oben genannte Kriterien.
Creation Date,Erstellungsdatum
Creation Document No,Creation Dokument Nr.
Creation Document Type,Creation Dokumenttyp
Creation Time,Erstellungszeit
Credentials,Anmeldeinformationen
Credit,Guthaben
Credit Amt,Guthabenbetrag
Credit Card,Kreditkarte
Credit Card Voucher,Kreditkarten-Gutschein
Credit Controller,Kredit-Controller
Credit Days,Kredittage
Credit Limit,Kreditlimit
Credit Note,Gutschriftsanzeige
Credit To,Gutschreiben an
Cross Listing of Item in multiple groups,Kreuzweise Auflistung der Artikel in mehreren Gruppen
Currency,Währung
Currency Exchange,Geldwechsel
Currency Name,Währungsname
Currency Settings,Währungseinstellungen
Currency and Price List,Währungs- und Preisliste
Currency exchange rate master.,Wechselkurs Master.
Current Address,Aktuelle Adresse
Current Address Is,Aktuelle Adresse
Current Assets,Umlaufvermögen
Current BOM,Aktuelle SL
Current BOM and New BOM can not be same,Aktuelle Stückliste und neue Stückliste können nicht identisch sein
Current Fiscal Year,Laufendes Geschäftsjahr
Current Liabilities,Kurzfristige Verbindlichkeiten
Current Stock,Aktueller Lagerbestand
Current Stock UOM,Aktuelle Lager-ME
Current Value,Aktueller Wert
Custom,Benutzerdefiniert
Custom Autoreply Message,Benutzerdefinierte Autoreply-Nachricht
Custom Message,Benutzerdefinierte Nachricht
Customer,Kunde
Customer (Receivable) Account,Kunde (Debitoren) Konto
Customer / Item Name,Kunde/Artikelname
Customer / Lead Address,Kunden / Interessenten-Adresse
Customer / Lead Name,Kunden /Interessenten Namen
Customer > Customer Group > Territory,Kunden> Kundengruppe> Territory
Customer Account Head,Kundenkontoführer
Customer Acquisition and Loyalty,Kundengewinnung und-bindung
Customer Address,Kundenadresse
Customer Addresses And Contacts,Kundenadressen und Ansprechpartner
Customer Addresses and Contacts,Kundenadressen und Ansprechpartner
Customer Code,Kunden-Nr.
Customer Codes,Kundennummern
Customer Details,Kundendaten
Customer Feedback,Kundenrückmeldung
Customer Group,Kundengruppe
Customer Group / Customer,Kundengruppe / Kunden
Customer Group Name,Kundengruppenname
Customer Intro,Kunden Intro
Customer Issue,Kundenproblem
Customer Issue against Serial No.,Kundenproblem zu Seriennr.
Customer Name,Kundenname
Customer Naming By,Benennung der Kunden nach
Customer Service,Kundenservice
Customer database.,Kundendatenbank.
Customer is required,"Kunde ist verpflichtet,"
Customer master.,Kundenstamm.
Customer required for 'Customerwise Discount',Kunden für ' Customerwise Discount ' erforderlich
Customer {0} does not belong to project {1},Customer {0} gehört nicht zum Projekt {1}
Customer {0} does not exist,Kunden {0} existiert nicht
Customer's Item Code,Kunden-Artikel-Nr
Customer's Purchase Order Date,Kundenauftrag
Customer's Purchase Order No,Kundenauftrags-Nr
Customer's Purchase Order Number,Kundenauftragsnummer
Customer's Vendor,Kundenverkäufer
Customers Not Buying Since Long Time,"Kunden, die seit langer Zeit nichts gekauft haben"
Customerwise Discount,Kundenweiser Rabatt
Customize,Anpassen
Customize the Notification,Mitteilung anpassen
Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Einleitenden Text anpassen, der zu dieser E-Mail gehört. Jede Transaktion hat einen separaten Einleitungstext."
DN Detail,DN-Detail
Daily,Täglich
Daily Time Log Summary,Tägliche Zeitprotokollzusammenfassung
Database Folder ID,Datenbankordner-ID
Database of potential customers.,Datenbank potentieller Kunden.
Date,Datum
Date Format,Datumsformat
Date Of Retirement,Zeitpunkt der Pensionierung
Date Of Retirement must be greater than Date of Joining,Zeitpunkt der Pensionierung muss größer sein als Datum für Füge sein
Date is repeated,Ereignis wiederholen
Date of Birth,Geburtsdatum
Date of Issue,Ausstellungsdatum
Date of Joining,Beitrittsdatum
Date of Joining must be greater than Date of Birth,Beitrittsdatum muss nach dem Geburtsdatum sein
Date on which lorry started from supplier warehouse,Abfahrtdatum des LKW aus dem Lieferantenlager
Date on which lorry started from your warehouse,Abfahrtdatum des LKW aus Ihrem Lager
Dates,Termine
Days Since Last Order,Tage seit dem letzten Auftrag
Days for which Holidays are blocked for this department.,"Tage, an denen eine Urlaubssperre für diese Abteilung gilt."
Dealer,Händler
Debit,Soll
Debit Amt,Sollbetrag
Debit Note,Lastschrift
Debit To,Lastschrift für
Debit and Credit not equal for this voucher. Difference is {0}.,Debit-und Kreditkarten nicht gleich für diesen Gutschein. Der Unterschied ist {0}.
Deduct,Abziehen
Deduction,Abzug
Deduction Type,Abzugsart
Deduction1,Abzug1
Deductions,Abzüge
Default,Standard
Default Account,Standardkonto
Default Address Template cannot be deleted,Standard-Adressvorlage kann nicht gelöscht werden
Default Amount,Standard-Betrag
Default BOM,Standardstückliste
Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Standard Bank-/Geldkonto wird automatisch in Kassenbon aktualisiert, wenn dieser Modus ausgewählt ist."
Default Bank Account,Standardbankkonto
Default Buying Cost Center,Standard Buying Kostenstelle
Default Buying Price List,Standard Kaufpreisliste
Default Cash Account,Standardkassenkonto
Default Company,Standardunternehmen
Default Cost Center,Standardkostenstelle
Default Currency,Standardwährung
Default Customer Group,Standardkundengruppe
Default Expense Account,Standardaufwandskonto
Default Income Account,Standard-Gewinnkonto
Default Item Group,Standard-Artikelgruppe
Default Price List,Standardpreisliste
Default Purchase Account in which cost of the item will be debited.,"Standard-Einkaufskonto, von dem die Kosten des Artikels eingezogen werden."
Default Selling Cost Center,Standard-Vertriebs Kostenstelle
Default Settings,Standardeinstellungen
Default Source Warehouse,Standard-Ursprungswarenlager
Default Stock UOM,Standard Lager-ME
Default Supplier,Standardlieferant
Default Supplier Type,Standardlieferantentyp
Default Target Warehouse,Standard-Zielwarenlager
Default Territory,Standardregion
Default Unit of Measure,Standardmaßeinheit
"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.","Standard- Mengeneinheit kann nicht direkt geändert werden, weil Sie bereits Transaktion(en) mit einer anderen Mengeneinheit gemacht haben. Um die Standardmengeneinheit zu ändern, verwenden Sie das 'Verpackung ersetzen'-Tool im Lagermodul."
Default Valuation Method,Standard-Bewertungsmethode
Default Warehouse,Standardwarenlager
Default Warehouse is mandatory for stock Item.,Standard-Lager ist für Lager Artikel notwendig.
Default settings for accounting transactions.,Standardeinstellungen für Buchhaltungstransaktionen.
Default settings for buying transactions.,Standardeinstellungen für Einkaufstransaktionen.
Default settings for selling transactions.,Standardeinstellungen für Vertriebstransaktionen.
Default settings for stock transactions.,Standardeinstellungen für Lagertransaktionen.
Defense,Verteidigung
"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Budget für diese Kostenstelle festlegen. Zuordnen des Budgets, siehe <a href=""#!List/Company"">Unternehmensstamm</a>"
Del,löschen
Delete,Löschen
Delete {0} {1}?,Löschen {0} {1} ?
Delivered,Geliefert
Delivered Items To Be Billed,Gelieferte Artikel für Abrechnung
Delivered Qty,Gelieferte Menge
Delivered Serial No {0} cannot be deleted,Geliefert Seriennummer {0} kann nicht gelöscht werden
Delivery Date,Liefertermin
Delivery Details,Lieferdetails
Delivery Document No,Lieferbelegnummer
Delivery Document Type,Lieferbelegtyp
Delivery Note,Lieferschein
Delivery Note Item,Lieferschein Artikel
Delivery Note Items,Lieferschein Artikel
Delivery Note Message,Lieferschein Nachricht
Delivery Note No,Lieferscheinnummer
Delivery Note Required,Lieferschein erforderlich
Delivery Note Trends,Lieferscheintrends
Delivery Note {0} is not submitted,Lieferschein {0} wurde nicht eingereicht
Delivery Note {0} must not be submitted,Lieferschein {0} muss nicht eingereicht werden
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Lieferscheine {0} müssen vor Stornierung dieser Kundenaufträge storniert werden
Delivery Status,Lieferstatus
Delivery Time,Lieferzeit
Delivery To,Lieferung an
Department,Abteilung
Department Stores,Kaufhäuser
Depends on LWP,Abhängig von LWP
Depreciation,Abschreibung
Description,Beschreibung
Description HTML,Beschreibung HTML
Description of a Job Opening,Beschreibung eines Stellenangebot
Designation,Bezeichnung
Designer,Konstrukteur
Detailed Breakup of the totals,Detaillierte Aufschlüsselung der Gesamtsummen
Details,Details
Difference (Dr - Cr),Differenz ( Dr - Cr )
Difference Account,Unterschied Konto
"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Differenzkonto muss vom Typ ""Verbildlichkeit"" sein, da diese Lagerbewertung ein öffnender Eintag ist"
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.,"Unterschiedliche Verpackung für Einzelteile werden zu falschen (Gesamt-) Nettogewichtswerten führen. Stellen Sie sicher, dass die Netto-Gewichte der einzelnen Artikel in der gleichen Mengeneinheit sind."
Direct Expenses,Direkte Aufwendungen
Direct Income,Direkte Einkommens
Disable,Deaktivieren
Disable Rounded Total,Abgerundete Gesamtsumme deaktivieren
Disabled,Deaktiviert
Discount,Rabatt
Discount  %,Rabatt %
Discount %,Rabatt %
Discount (%),Rabatt (%)
Discount Amount,Discount Amount
"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Rabattfelder stehen in  Lieferatenauftrag, Eingangslieferschein und in der Eingangsrechnung zur Verfügung"
Discount Percentage,Rabatt Prozent
Discount Percentage can be applied either against a Price List or for all Price List.,Rabatt Prozent kann entweder gegen eine Preisliste oder Preisliste für alle angewendet werden.
Discount must be less than 100,Discount muss kleiner als 100 sein
Discount(%),Rabatt (%)
Dispatch,Versand
Display all the individual items delivered with the main items,Alle einzelnen Positionen zu den Hauptartikeln anzeigen
Distinct unit of an Item,Eigene Einheit eines Artikels
Distribution,Verteilung
Distribution Id,Verteilungs-ID
Distribution Name,Verteilungsnamen
Distributor,Lieferant
Divorced,Geschieden
Do Not Contact,Nicht berühren
Do not show any symbol like $ etc next to currencies.,Kein Symbol wie $ usw. neben Währungen anzeigen.
Do really want to unstop production order: ,Wollen Sie wirklich den Fertigungsauftrag fortsetzen: 
Do you really want to STOP ,Möchten Sie dies wirklich anhalten
Do you really want to STOP this Material Request?,Wollen Sie wirklich diese Materialanforderung anhalten?
Do you really want to Submit all Salary Slip for month {0} and year {1},Wollen Sie wirklich alle Gehaltsabrechnungen für den Monat {0} im Jahr {1} versenden
Do you really want to UNSTOP ,Möchten Sie dies wirklich fortsetzen
Do you really want to UNSTOP this Material Request?,Wollen Sie wirklich diese Materialanforderung fortsetzen?
Do you really want to stop production order: ,Möchten Sie den Fertigungsauftrag wirklich anhalten: 
Doc Name,Dokumentenname
Doc Type,Dokumententyp
Document Description,Dokumentenbeschreibung
Document Type,Dokumenttyp
Documents,Dokumente
Domain,Domäne
Don't send Employee Birthday Reminders,Senden Sie keine Mitarbeitergeburtstagserinnerungen
Download Materials Required,Erforderliche Materialien herunterladen
Download Reconcilation Data,Laden Versöhnung Daten
Download Template,Vorlage herunterladen
Download a report containing all raw materials with their latest inventory status,"Einen Bericht herunterladen, der alle Rohstoffe mit ihrem neuesten Bestandsstatus angibt"
"Download the Template, fill appropriate data and attach the modified file.","Herunterladen der Vorlage, füllen Sie die entsprechenden Angaben aus und hängen Sie die geänderte Datei an."
"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","Herunterladen der Vorlage, füllen Sie die entsprechenden Angaben aus und hängen Sie die geänderte Datei an. Alle Datumsangaben und Mitarbeiterkombinationen erscheinen in der ausgewählten Periode für die Anwesenheitseinträge in der Vorlage."
Dr,Dr
Draft,Entwurf
Dropbox,Dropbox
Dropbox Access Allowed,Dropbox-Zugang erlaubt
Dropbox Access Key,Dropbox-Zugangsschlüssel
Dropbox Access Secret,Dropbox-Zugangsgeheimnis
Due Date,Fälligkeitsdatum
Due Date cannot be after {0},Fälligkeitsdatum kann nicht nach {0}
Due Date cannot be before Posting Date,Fälligkeitsdatum kann nicht vor dem Buchungsdatum sein
Duplicate Entry. Please check Authorization Rule {0},Doppelter Eintrag. Bitte überprüfen Sie Autorisierungsregel {0}
Duplicate Serial No entered for Item {0},Doppelte Seriennummer für Posten {0}
Duplicate entry,Duplizieren Eintrag
Duplicate row {0} with same {1},Doppelte Zeile {0} mit dem gleichen {1}
Duties and Taxes,Zölle und Steuern
ERPNext Setup,ERPNext -Setup
Earliest,Frühest
Earnest Money,Angeld
Earning,Ertrag
Earning & Deduction,Einkommen & Abzug
Earning Type,Einkommensart
Earning1,Einkommen1
Edit,Bearbeiten
Edu. Cess on Excise,Edu. Cess Verbrauch
Edu. Cess on Service Tax,Edu. Cess auf Service Steuer
Edu. Cess on TDS,Edu. Cess auf TDS
Education,Bildung
Educational Qualification,Schulische Qualifikation
Educational Qualification Details,Einzelheiten der schulischen Qualifikation
Eg. smsgateway.com/api/send_sms.cgi,z. B. smsgateway.com/api/send_sms.cgi
Either debit or credit amount is required for {0},Entweder Debit-oder Kreditbetragist erforderlich für {0}
Either target qty or target amount is mandatory,Entweder Zielmengeoder Zielmenge ist obligatorisch
Either target qty or target amount is mandatory.,Entweder Zielmengeoder Zielmenge ist obligatorisch.
Electrical,elektrisch
Electricity Cost,Stromkosten
Electricity cost per hour,Stromkosten pro Stunde
Electronics,Elektronik
Email,E-Mail
Email Digest,Täglicher E-Mail-Bericht
Email Digest Settings,Einstellungen täglicher E-Mail-Bericht
Email Digest: ,E-Mail-Bericht: 
Email Id,E-Mail-ID
"Email Id where a job applicant will email e.g. ""jobs@example.com""","E-Mail-Adresse, an die ein Bewerber schreibt, z. B. ""jobs@example.com"""
Email Notifications,E-Mail- Benachrichtigungen
Email Sent?,Wurde die E-Mail abgesendet?
Email Settings for Outgoing and Incoming Emails.,E-Mail-Einstellungen für ausgehende und eingehende E-Mails.
"Email id must be unique, already exists for {0}",E-Mail-Adresse muss eindeutig sein; Diese existiert bereits für {0}
Email ids separated by commas.,E-Mail-Adressen durch Kommas getrennt.
"Email settings for jobs email id ""jobs@example.com""","E-Mail-Einstellungen für Bewerbungs-ID ""jobs@example.com"""
"Email settings to extract Leads from sales email id e.g. ""sales@example.com""","E-Mail-Einstellungen, mit denen Interessenten aus Verkaufs-E-Mail-Adressen wie z.B. ""vertrieb@example.com"" extrahiert werden."
Emergency Contact,Notfallkontakt
Emergency Contact Details,Notfallkontaktdaten
Emergency Phone,Notruf
Employee,Mitarbeiter
Employee Birthday,Mitarbeiter Geburtstag
Employee Details,Mitarbeiterdetails
Employee Education,Mitarbeiterschulung
Employee External Work History,Mitarbeiter externe Berufserfahrung
Employee Information,Mitarbeiterinformationen
Employee Internal Work History,Mitarbeiter interne Berufserfahrung
Employee Internal Work Historys,Mitarbeiter interne Berufserfahrungen
Employee Leave Approver,Mitarbeiter Urlaubsgenehmiger
Employee Leave Balance,Mitarbeiter Urlaubskonto
Employee Name,Mitarbeitername
Employee Number,Mitarbeiternummer
Employee Records to be created by,Mitarbeiterakte wird erstellt von
Employee Settings,Mitarbeitereinstellungen
Employee Type,Mitarbeitertyp
Employee can not be changed,Mitarbeiter kann nicht verändert werden
"Employee designation (e.g. CEO, Director etc.).","Mitarbeiterbezeichnung (z.B. Geschäftsführer, Direktor etc.)."
Employee master.,Mitarbeiterstamm .
Employee record is created using selected field. ,Mitarbeiter Datensatz erstellt anhand von ausgewählten Feld.
Employee records.,Mitarbeiterdatensätze.
Employee relieved on {0} must be set as 'Left',"freigestellter Angestellter {0} muss als ""entlassen"" eingestellt werden"
Employee {0} has already applied for {1} between {2} and {3},Angestellter {0} ist bereits für {1} zwischen angewendet {2} und {3}
Employee {0} is not active or does not exist,Angestellter {0} ist nicht aktiv oder existiert nicht
Employee {0} was on leave on {1}. Cannot mark attendance.,Angestellter {0} war in Urlaub am {1}. Kann nicht als anwesend gesetzt werden.
Employees Email Id,Mitarbeiter E-Mail-Adresse
Employment Details,Beschäftigungsdetails
Employment Type,Art der Beschäftigung
Enable / disable currencies.,Aktivieren / Deaktivieren der Währungen.
Enabled,Aktiviert
Encashment Date,Inkassodatum
End Date,Enddatum
End Date can not be less than Start Date,Ende Datum kann nicht kleiner als Startdatum sein
End date of current invoice's period,Ende der laufenden Rechnungsperiode
End date of current order's period,Enddatum der aktuellen Bestellperiode
End of Life,Lebensdauer
Energy,Energie
Engineer,Ingenieur
Enter Verification Code,Sicherheitscode eingeben
Enter campaign name if the source of lead is campaign.,"Namen der Kampagne eingeben, wenn die Interessenten-Quelle eine Kampagne ist."
Enter department to which this Contact belongs,"Abteilung eingeben, zu der dieser Kontakt gehört"
Enter designation of this Contact,Bezeichnung dieses Kontakts eingeben
"Enter email id separated by commas, invoice will be mailed automatically on particular date","Geben Sie die durch Kommas getrennte E-Mail-Adresse  ein, die Rechnung wird automatisch an einem bestimmten Rechnungsdatum abgeschickt"
"Enter email id separated by commas, order will be mailed automatically on particular date","Geben Sie die durch Kommas getrennte E-Mail-Adresse  ein, die Bestellung wird automatisch an einem bestimmten Datum abgeschickt"
Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,"Geben Sie die Posten und die geplante Menge ein, für die Sie die Fertigungsaufträge erhöhen möchten, oder laden Sie Rohstoffe für die Analyse herunter."
Enter name of campaign if source of enquiry is campaign,"Geben Sie den Namen der Kampagne ein, wenn der Ursprung der Anfrage eine Kampagne ist"
"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Geben Sie hier statische URL-Parameter ein (z. B. Absender=ERPNext, Benutzername=ERPNext, Passwort=1234 usw.)"
Enter the company name under which Account Head will be created for this Supplier,"Geben Sie den Namen der Firma ein, unter dem ein Kontenführer mit diesem Lieferanten erstellt werden soll"
Enter url parameter for message,Geben Sie den URL-Parameter für die Nachricht ein
Enter url parameter for receiver nos,Geben Sie den URL-Parameter für die Empfängernummern an
Entertainment & Leisure,Unterhaltung & Freizeit
Entertainment Expenses,Bewirtungskosten
Entries,Einträge
Entries against ,Einträge gegen
Entries are not allowed against this Fiscal Year if the year is closed.,"Einträge sind für dieses Geschäftsjahr nicht zulässig, wenn es bereits abgeschlossen ist."
Equity,Gerechtigkeit
Error: {0} > {1},Fehler: {0}> {1}
Estimated Material Cost,Geschätzte Materialkosten
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Auch wenn es mehrere Preisregeln mit der höchsten Priorität, werden dann folgende interne Prioritäten angewandt:"
Everyone can read,Jeder kann lesen
"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.","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."
Exchange Rate,Wechselkurs
Excise Duty 10,Verbrauchsteuer 10
Excise Duty 14,Verbrauchsteuer 14
Excise Duty 4,Excise Duty 4
Excise Duty 8,Verbrauchsteuer 8
Excise Duty @ 10,Verbrauchsteuer @ 10
Excise Duty @ 14,Verbrauchsteuer @ 14
Excise Duty @ 4,Verbrauchsteuer @ 4
Excise Duty @ 8,Verbrauchsteuer @ 8
Excise Duty Edu Cess 2,Verbrauchsteuer Edu Cess 2
Excise Duty SHE Cess 1,Verbrauchsteuer SHE Cess 1
Excise Page Number,Seitenzahl ausschneiden
Excise Voucher,Gutschein ausschneiden
Execution,Ausführung
Executive Search,Executive Search
Exhibition,Ausstellung
Existing Customer,Bestehender Kunde
Exit,Beenden
Exit Interview Details,Interview-Details beenden
Expected,Voraussichtlich
Expected Completion Date can not be less than Project Start Date,Erwartete Abschlussdatum kann nicht weniger als Projektstartdatumsein
Expected Date cannot be before Material Request Date,Erwartete Datum kann nicht vor -Material anfordern Date
Expected Delivery Date,Voraussichtlicher Liefertermin
Expected Delivery Date cannot be before Purchase Order Date,Voraussichtlicher Liefertermin kann nicht vor dem Lieferatenauftragsdatum sein
Expected Delivery Date cannot be before Sales Order Date,Voraussichtlicher Liefertermin kann nicht vor Kundenauftragsdatum liegen
Expected End Date,Voraussichtliches Enddatum
Expected Start Date,Voraussichtliches Startdatum
Expected balance as per bank,erwartetet Kontostand laut Bank
Expense,Ausgabe
Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Aufwand / Differenz-Konto ({0}) muss ein ""Gewinn oder Verlust""-Konto sein"
Expense Account,Aufwandskonto
Expense Account is mandatory,Aufwandskonto ist obligatorisch
Expense Approver,Ausgaben Genehmiger
Expense Claim,Spesenabrechnung
Expense Claim Approved,Spesenabrechnung zugelassen
Expense Claim Approved Message,Spesenabrechnung zugelassen Nachricht
Expense Claim Detail,Spesenabrechnungsdetail
Expense Claim Details,Spesenabrechnungsdetails
Expense Claim Rejected,Spesenabrechnung abgelehnt
Expense Claim Rejected Message,Spesenabrechnung abgelehnt Nachricht
Expense Claim Type,Spesenabrechnungstyp
Expense Claim has been approved.,Spesenabrechnung wurde genehmigt.
Expense Claim has been rejected.,Spesenabrechnung wurde abgelehnt.
Expense Claim is pending approval. Only the Expense Approver can update status.,Spesenabrechnung wird wartet auf Genehmigung. Nur der Ausgabenwilliger kann den Status aktualisieren.
Expense Date,Datum der Aufwendung
Expense Details,Details der Aufwendung
Expense Head,Kopf der Aufwendungen
Expense account is mandatory for item {0},Aufwandskonto ist für item {0}
Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Ausgaben- oder Differenz-Konto ist Pflicht für Artikel {0}, da es Auswirkungen gesamten Lagerwert hat"
Expenses,Kosten
Expenses Booked,Gebuchte Aufwendungen
Expenses Included In Valuation,In der Bewertung enthaltene Aufwendungen
Expenses booked for the digest period,Gebuchte Aufwendungen für den Berichtszeitraum
Expired,verfallen
Expiry,Verfall
Expiry Date,Verfalldatum
Exports,Exporte
External,Extern
Extract Emails,E-Mails extrahieren
FCFS Rate,FCFS-Rate
Failed: ,Failed:
Family Background,Familiärer Hintergrund
Fax,Fax
Features Setup,Funktionssetup
Feed,Feed
Feed Type,Art des Feeds
Feedback,Feedback
Female,Weiblich
Fetch exploded BOM (including sub-assemblies),Abruch der Stücklisteneinträge (einschließlich der Unterelemente)
"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Feld ist in Lieferschein, Angebot, Ausgangsrechnung, Kundenauftrag verfügbar"
Files Folder ID,Dateien-Ordner-ID
Fill the form and save it,Füllen Sie das Formular aus und speichern Sie sie
Filter based on customer,Filtern nach Kunden
Filter based on item,Filtern nach Artikeln
Financial / accounting year.,Finanz / Rechnungsjahres.
Financial Analytics,Finanzielle Analyse
Financial Chart of Accounts. Imported from file.,FInanzübersicht der Konten. Importiert aus einer Datei
Financial Services,Finanzdienstleistungen
Financial Year End Date,Geschäftsjahr Enddatum
Financial Year Start Date,Geschäftsjahr Startdatum
Finished Goods,Fertigwaren
First Name,Vorname
First Responded On,Erstmalig reagiert am
Fiscal Year,Geschäftsjahr
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Geschäftsjahr Startdatum und Geschäftsjahresende Datum sind bereits im Geschäftsjahr gesetzt {0}
Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Geschäftsjahr Startdatum und Geschäftsjahresende Datum kann nicht mehr als ein Jahr betragen.
Fiscal Year Start Date should not be greater than Fiscal Year End Date,Geschäftsjahr Startdatum sollte nicht größer als Geschäftsjahresende Date
Fiscal Year {0} not found.,Geschäftsjahr {0} nicht gefunden
Fixed Asset,Fixed Asset
Fixed Assets,Anlagevermögen
Fold,eingeklappt
Follow via Email,Per E-Mail nachverfolgen
"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.","Die folgende Tabelle zeigt die Werte, wenn Artikel von Zulieferern stammen. Diese Werte werden aus dem Stamm der ""Materialliste"" für Artikel von Zulieferern abgerufen."
Food,Lebensmittel
"Food, Beverage & Tobacco","Lebensmittel, Getränke und 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.","Für 'Sales BOM Stücke, Lagerhaus, Seriennummer und Chargen Nein wird von der ""Packliste"" Tabelle berücksichtigt werden. Wenn Lager-und Stapel Nein sind für alle Verpackungsteile aus irgendeinem 'Sales BOM' Punkt können die Werte in der Haupt Artikel-Tabelle eingetragen werden, werden die Werte zu ""Packliste"" Tabelle kopiert werden."
For Company,Für Unternehmen
For Employee,Für Mitarbeiter
For Employee Name,Für Mitarbeiter Name
For Price List,Für Preisliste
For Production,Für Produktion
For Reference Only.,Nur zu Referenzzwecken.
For Sales Invoice,Für Ausgangsrechnungen
For Server Side Print Formats,Für Druckformate auf Serverseite
For Supplier,für Lieferanten
For Warehouse,Für Warenlager
For Warehouse is required before Submit,"Für Warehouse erforderlich ist, bevor abschicken"
"For e.g. 2012, 2012-13",Für z.B. 2012 2012-13
For reference,Zu Referenzzwecken
For reference only.,Nur zu Referenzzwecken.
"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Um es den Kunden zu erleichtern, können diese Codes in Druckformaten wie Rechnungen und Lieferscheinen verwendet werden"
Fraction,Teilmenge
Fraction Units,Bruchteile von Einheiten
Freeze Stock Entries,Lagerbestandseinträge einfrieren
Freeze Stocks Older Than [Days],Frieren Stocks Älter als [ Tage ]
Freight and Forwarding Charges,Fracht-und Versandkosten
Friday,Freitag
From,Von
From Bill of Materials,Von Stückliste
From Company,Von Unternehmen
From Currency,Von Währung
From Currency and To Currency cannot be same,Von-Währung und Bis-Währung dürfen nicht gleich sein
From Customer,Von Kunden
From Customer Issue,Von Kunden Ausgabe
From Date,Von Datum
From Date cannot be greater than To Date,Von-Datum darf nicht größer als bisher sein
From Date must be before To Date,Von-Datum muss vor dem Bis-Datum liegen
From Date should be within the Fiscal Year. Assuming From Date = {0},"Von-Datum sollte im Geschäftsjahr sein. Unter der Annahme, Von-Datum = {0}"
From Delivery Note,von Lieferschein
From Employee,Von Mitarbeiter
From Lead,von Interessent
From Maintenance Schedule,Vom Wartungsplan
From Material Request,Von Materialanforderung
From Opportunity,von der Chance
From Package No.,Von Paket-Nr.
From Purchase Order,von Lieferatenauftrag
From Purchase Receipt,von Eingangslieferschein
From Quotation,von Zitat
From Sales Order,Aus Kundenauftrag
From Supplier Quotation,von Lieferantenangebot
From Time,Von Zeit
From Value,Von Wert
From and To dates required,Von-und Bis Daten erforderlich
From value must be less than to value in row {0},Vom Wert von weniger als um den Wert in der Zeile sein muss {0}
Frozen,Eingefroren
Frozen Accounts Modifier,Eingefrorenen Konten Modifier
Fulfilled,Erledigt
Full Name,Vollständiger Name
Full-time,Vollzeit-
Fully Billed,Voll Angekündigt
Fully Completed,Vollständig abgeschlossen
Fully Delivered,Komplett geliefert
Furniture and Fixture,Möbel -und Maschinen
Further accounts can be made under Groups but entries can be made against Ledger,"Weitere Konten können unter Gruppen gemacht werden, aber gegen Ledger Einträge können vorgenommen werden"
"Further accounts can be made under Groups, but entries can be made against Ledger","Weitere Konten können unter Gruppen gemacht werden, aber gegen Ledger Einträge können vorgenommen werden"
Further nodes can be only created under 'Group' type nodes,"Weitere Knoten kann nur unter Typ -Knoten ""Gruppe"" erstellt werden"
GL Entry,HB-Eintrag
Gantt Chart,Gantt-Diagramm
Gantt chart of all tasks.,Gantt-Diagramm aller Aufgaben.
Gender,Geschlecht
General,Allgemein
General Ledger,Hauptbuch
General Settings,Grundeinstellungen
Generate Description HTML,Beschreibungs-HTML generieren
Generate Material Requests (MRP) and Production Orders.,Materialanforderungen (MRP) und Fertigungsaufträge generieren.
Generate Salary Slips,Gehaltsabrechnungen generieren
Generate Schedule,Zeitplan generieren
"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Packzettel für zu liefernde Pakete generieren. Wird verwendet, um Paketnummer, Packungsinhalt und das Gewicht zu dokumentieren."
Generates HTML to include selected image in the description,"Generiert HTML, die das ausgewählte Bild in der Beschreibung enthält"
Get Advances Paid,Vorkasse aufrufen
Get Advances Received,Erhaltene Anzahlungen aufrufen
Get Current Stock,Aktuellen Lagerbestand aufrufen
Get Items,Artikel aufrufen
Get Items From Purchase Receipts,Artikel vom Eingangslieferschein übernehmen
Get Items From Sales Orders,Artikel aus Kundenaufträgen abrufen
Get Items from BOM,Artikel aus der Stückliste holen
Get Last Purchase Rate,Letzten Anschaffungskurs abrufen
Get Outstanding Invoices,Ausstehende Rechnungen abrufen
Get Relevant Entries,Holen Relevante Einträge
Get Sales Orders,Kundenaufträge abrufen
Get Specification Details,Spezifikationsdetails abrufen
Get Stock and Rate,Lagerbestand und Rate abrufen
Get Template,Vorlage abrufen
Get Terms and Conditions,Allgemeine Geschäftsbedingungen abrufen
Get Unreconciled Entries,Holen Nicht abgestimmte Einträge
Get Weekly Off Dates,Wöchentliche Abwesenheitstermine abrufen
"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.","Bewertungsrate und verfügbaren Lagerbestand an Ursprungs-/Zielwarenlager zum genannten Buchungsdatum/Uhrzeit abrufen. Bei Serienartikel, drücken Sie diese Taste nach der Eingabe der Seriennummern."
Global Defaults,Globale Standardwerte
Global POS Setting {0} already created for company {1},"Globale POS Einstellung {0} bereits für Unternehmen geschaffen, {1}"
Global Settings,Globale Einstellungen
"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""","Gehen Sie auf die entsprechende Gruppe (in der Regel Anwendungszweck > Umlaufvermögen > Bankkonten und erstellen einen neuen Belegeintrag (durch Klicken auf Untereintrag hinzufügen) vom Typ ""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.","Gehen Sie auf die entsprechende Gruppe (in der Regel Quelle der Dahrlehen > kurzfristige Verbindlichkeiten > Steuern und Abgaben und legen einen neuen Buchungsbeleg (durch Klicken auf Unterelement einfügen) des Typs ""Steuer"" an und geben den Steuersatz mit an."
Goal,Ziel
Goals,Ziele
Goods received from Suppliers.,Von Lieferanten erhaltene Ware.
Google Drive,Google Drive
Google Drive Access Allowed,Google Drive-Zugang erlaubt
Government,Regierung
Graduate,Hochschulabsolvent
Grand Total,Gesamtbetrag
Grand Total (Company Currency),Gesamtbetrag (Unternehmenswährung)
"Grid ""","Grid """
Grocery,Lebensmittelgeschäft
Gross Margin %,Bruttoergebnis %
Gross Margin Value,Bruttoergebniswert
Gross Pay,Bruttolohn
Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Bruttolohn +  ausstehender Betrag +   Inkassobetrag - Gesamtabzug
Gross Profit,Rohgewinn
Gross Profit (%),Rohgewinn (%)
Gross Weight,Bruttogewicht
Gross Weight UOM,Bruttogewicht ME
Group,Gruppe
Group by Account,Gruppe von Konto
Group by Voucher,Gruppe von Gutschein
Group or Ledger,Gruppen oder Sachbuch
Groups,Gruppen
Guest,Gast
HR Manager,HR-Manager
HR Settings,HR-Einstellungen
HR User,HR-Mitarbeiter
HTML / Banner that will show on the top of product list.,"HTML/Banner, das oben auf der der Produktliste angezeigt wird."
Half Day,Halbtags
Half Yearly,Halbjährlich
Half-yearly,Halbjährlich
Happy Birthday!,Happy Birthday!
Hardware,Hardware
Has Batch No,Hat Stapelnr.
Has Child Node,Weitere Elemente vorhanden
Has Serial No,Seriennummer vorhanden
Head of Marketing and Sales,Leiter Marketing und Vertrieb
Header,Kopfzeile
Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Vorgesetzte (oder Gruppen), für die Buchungseinträge vorgenommen und Salden geführt werden."
Health Care,Health Care
Health Concerns,Gesundheitliche Bedenken
Health Details,Gesundheitsdetails
Held On,Abgehalten am
Help HTML,HTML-Hilfe
"Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Hilfe: Um eine Verknüpfung zu einem anderen Datensatz im System herzustellen, verwenden Sie ""#Formular/Anmerkung/[Anmerkungsname]"" als Link-URL. (verwenden Sie nicht ""http://"")"
"Here you can maintain family details like name and occupation of parent, spouse and children","Hier können Sie Familiendetails wie Namen und Beruf der Eltern, Ehepartner und Kinder angeben"
"Here you can maintain height, weight, allergies, medical concerns etc","Hier können Sie Größe, Gewicht, Allergien, medizinische Bedenken usw. eingeben"
Hide Currency Symbol,Währungssymbol ausblenden
High,Hoch
History In Company,Historie im Unternehmen
Hold,Anhalten
Holiday,Urlaub
Holiday List,Urlaubsliste
Holiday List Name,Urlaubslistenname
Holiday master.,Vorlage Feiertage
Holidays,Feiertage
Home,Startseite
Host,Host
"Host, Email and Password required if emails are to be pulled","Host-, E-Mail und Passwort erforderlich, wenn E-Mails gezogen werden sollen"
Hour,Stunde
Hour Rate,Stundensatz
Hour Rate Labour,Stundensatz Arbeitslohn
Hours,Stunden
How Pricing Rule is applied?,Wie Pricing-Regel angewendet wird?
How frequently?,Wie häufig?
"How should this currency be formatted? If not set, will use system defaults","Wie soll diese Währung formatiert werden? Wenn nicht festgelegt, werden die Systemstands verwendet"
Human Resources,Personalwesen
Identification of the package for the delivery (for print),Bezeichnung des Pakets für die Lieferung (für den Druck)
If Income or Expense,Wenn Ertrag oder Aufwand
If Monthly Budget Exceeded,Wenn Monatsbudget überschritten
"If Supplier Part Number exists for given Item, it gets stored here","Falls für eine bestimmte Position eine Lieferantenteilenummer vorhanden ist, wird sie hier gespeichert"
If Yearly Budget Exceeded,Wenn Jahresbudget überschritten
"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.","Wenn aktiviert, wird die Stückliste für Unterbaugruppen-Artikel beim Abrufen von Rohstoffen berücksichtigt. Andernfalls werden alle Unterbaugruppen-Artikel als Rohmaterial behandelt."
"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Wenn aktiviert, beinhaltet die Gesamtanzahl der Arbeitstage auch Feiertage und dies reduziert den Wert des Gehalts pro Tag."
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Wenn aktiviert, wird der Steuerbetrag als bereits in der Druckrate oder im Druckbetrag enthalten betrachtet."
If different than customer address,Wenn anders als Kundenadresse
"If disable, 'Rounded Total' field will not be visible in any transaction","Wenn deaktiviert, wird das Feld 'Gerundeter Gesamtbetrag' in keiner Transaktion angezeigt"
"If enabled, the system will post accounting entries for inventory automatically.","Wenn aktiviert, veröffentlicht das System Bestandsbuchungseinträge automatisch."
If more than one package of the same type (for print),Wenn mehr als ein Paket von der gleichen Art (für den Druck)
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Wenn mehrere Preisregeln weiterhin herrschen, werden die Benutzer aufgefordert, Priorität manuell einstellen, um Konflikt zu lösen."
"If no change in either Quantity or Valuation Rate, leave the cell blank.","Wenn es keine Änderung entweder bei Mengen- oder Bewertungspreis gibt, lassen Sie das Eingabefeld leer."
"If not checked, the list will have to be added to each Department where it has to be applied.","Wenn deaktiviert, muss die Liste zu jeder Abteilung hinzugefügt werden, für die sie gilt."
"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.","Wenn Preisregel für 'Preis' ausgewählt wird, wird der Wert aus der Preisliste überschrieben. Der Preis der Preisregel ist der Endpreis, so dass keine weiteren Rabatt angewendet werden sollten. Daher wird in Transaktionen wie z.B. Kundenauftrag, Lieferatenauftrag usw., es nicht im Feld 'Preis' eingetragen werden, sondern im Feld 'Preisliste'."
"If specified, send the newsletter using this email address","Wenn angegeben, senden Sie den Newsletter mit dieser E-Mail-Adresse"
"If the account is frozen, entries are allowed to restricted users.","Wenn das Konto eingefroren ist, werden Einträge für eingeschränkte Benutzer erlaubt."
"If this Account represents a Customer, Supplier or Employee, set it here.","Wenn dieses Konto zu einem Kunden, Lieferanten oder Mitarbeiter gehört, legen Sie dies hier fest."
"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.","Wenn zwei oder mehrere Preisregeln werden auf der Grundlage der obigen Bedingungen festgestellt wird Priorität angewandt. Priorität ist eine Zahl zwischen 0 und 20, während Standardwert ist null (leer). Höhere Zahl bedeutet es Vorrang, wenn es mehrere Preisregeln mit gleichen Bedingungen."
If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,"Wenn Sie Qualitätskontrollen druchführen. Aktiviert bei Artikel """"Qualitätssicherung notwendig"""" und """"Qualitätssicherung Nein"""" in Eingangslieferschein"
If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,"Wenn Sie ein Verkaufsteam und Verkaufspartner (Vertriebskanalpartner) haben, können sie markiert werden und ihren Beitrag zur Umsatztätigkeit behalten"
"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Wenn Sie eine Standardvorlage im Stamm für Verkaufssteuern und Abgaben erstellt haben, wählen Sie eine aus und klicken Sie unten auf die Schaltfläche."
"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Wenn Sie eine Standardvorlage im Stamm für Steuern und Abgaben erstellt haben, wählen Sie eine aus und klicken Sie unten auf die Schaltfläche."
"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","Wenn Sie lange Druckformate haben, kann diese Funktion verwendet werden, um die Seite auf mehrere Seiten mit allen Kopf- und Fußzeilen aufzuteilen"
If you involve in manufacturing activity. Enables Item 'Is Manufactured',Wenn Sie in die produzierenden Aktivitäten einzubeziehen. Ermöglicht Item ' hergestellt '
Ignore,Ignorieren
Ignore Pricing Rule,Ignorieren Preisregel
Ignored: ,Ignoriert:
Image,Bild
Image View,Bildansicht
Implementation Partner,Implementierungspartner
Import Attendance,Importteilnahme
Import Failed!,Import fehlgeschlagen !
Import Log,Importprotokoll
Import Successful!,Importieren Sie erfolgreich!
Imports,Importe
In Hours,In Stunden
In Process,In Bearbeitung
In Qty,Menge
In Stock,an Lager
In Value,Wert bei
In Words,In Worten
In Words (Company Currency),In Worten (Unternehmenswährung)
In Words (Export) will be visible once you save the Delivery Note.,"In Worten (Export) wird sichtbar, sobald Sie den Lieferschein speichern."
In Words will be visible once you save the Delivery Note.,"In Worten wird sichtbar, sobald Sie den Lieferschein speichern."
In Words will be visible once you save the Purchase Invoice.,"In Worten wird sichtbar, sobald Sie die Eingangsrechnung speichern."
In Words will be visible once you save the Purchase Order.,"In Worten wird sichtbar, sobald Sie den Lieferatenauftrag speichern."
In Words will be visible once you save the Purchase Receipt.,"In Worten wird sichtbar, sobald Sie den Eingangslieferschein speichern."
In Words will be visible once you save the Quotation.,"In Worten wird sichtbar, sobald Sie den Kostenvoranschlag speichern."
In Words will be visible once you save the Sales Invoice.,"In Worten wird sichtbar, sobald Sie die Ausgangsrechnung speichern."
In Words will be visible once you save the Sales Order.,"In Worten wird sichtbar, sobald Sie den Kundenauftrag speichern."
Incentives,Anreize
Include Reconciled Entries,Fügen versöhnt Einträge
Include holidays in Total no. of Working Days,Urlaub in die Gesamtzahl der Arbeitstage einschließen
Income,Einkommen
Income / Expense,Einnahmen/Ausgaben
Income Account,Gewinnkonto
Income Booked,Gebuchter Gewinn
Income Tax,Einkommensteuer
Income Year to Date,Jahresertrag bis dato
Income booked for the digest period,Gebuchter Gewinn für den Berichtszeitraum
Incoming,Eingehend
Incoming Rate,Eingehende Rate
Incoming quality inspection.,Eingehende Qualitätsprüfung.
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Falsche Anzahl von Hauptbuch-Einträge gefunden. Sie könnten ein falsches Konto in der Transaktion ausgewählt haben.
Incorrect or Inactive BOM {0} for Item {1} at row {2}, fehlerhafte oder inaktive Stückliste {0} für Artikel {1} in Zeile {2}
Indicates that the package is a part of this delivery (Only Draft),"Zeigt an, dass das Paket ist ein Teil dieser Lieferung (nur Entwurf)"
Indirect Expenses,Indirekte Aufwendungen
Indirect Income,Indirekte Erträge
Individual,Einzelperson
Industry,Industrie
Industry Type,Industrietyp
Inspected By,Geprüft von
Inspection Criteria,Prüfkriterien
Inspection Required,Prüfung ist Pflicht
Inspection Type,Art der Prüfung
Installation Date,Datum der Installation
Installation Note,Installationshinweis
Installation Note Item,Bestandteil Installationshinweis
Installation Note {0} has already been submitted,Installation Hinweis {0} wurde bereits eingereicht
Installation Status,Installationsstatus
Installation Time,Installationszeit
Installation date cannot be before delivery date for Item {0},Installationsdatum kann nicht vor dem Liefertermin für Artikel {0}
Installation record for a Serial No.,Installationsdatensatz für eine Seriennummer
Installed Qty,Installierte Anzahl
Instructions,Anweisungen
Interested,Interessiert
Intern,internieren
Internal,Intern
Internet Publishing,Internet Publishing
Introduction,Einführung
Invalid Barcode,Ungültige Barcode
Invalid Barcode or Serial No,Ungültige Barcode oder Seriennummer
Invalid Mail Server. Please rectify and try again.,Ungültiger E-Mail-Server. Bitte Angaben korrigieren und erneut versuchen.
Invalid Master Name,Ungültige Master-Name
Invalid User Name or Support Password. Please rectify and try again.,Ungültiger Benutzername oder Passwort. Bitte Angaben korrigieren und erneut versuchen.
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Zum Artikel angegebenen ungültig Menge {0}. Menge sollte grßer als 0 sein.
Inventory,Lagerbestand
Inventory & Support,Inventar & Support
Investment Banking,Investment Banking
Investments,Investments
Invoice Date,Rechnungsdatum
Invoice Details,Rechnungsdetails
Invoice No,Rechnungs-Nr.
Invoice Number,Rechnungsnummer
Invoice Type,Rechnungstyp
Invoice/Journal Voucher Details,Rechnungs- / Buchungsbeleg-Details
Invoiced Amount (Exculsive Tax),berechneter Betrag (ohne MwSt.)
Is Active,Ist aktiv
Is Advance,Ist Voraus
Is Cancelled,Ist storniert
Is Carry Forward,Ist Übertrag
Is Default,Ist Standard
Is Encash,Ist Inkasso
Is Fixed Asset Item,Ist Posten des Anlagevermögens
Is LWP,Ist LWP
Is Opening,Ist Öffnung
Is Opening Entry,Ist Öffnungseintrag
Is POS,Ist POS
Is Primary Contact,Ist primärer Kontakt
Is Purchase Item,Ist Einkaufsartikel
Is Recurring,ist wiederkehrend
Is Sales Item,Ist Verkaufsartikel
Is Service Item,Ist Leistungsposition
Is Stock Item,Ist Bestandsartikel
Is Sub Contracted Item,Ist Zulieferer-Artikel
Is Subcontracted,Ist Untervergabe
Is this Tax included in Basic Rate?,Ist diese Steuer in der Basisrate enthalten?
Issue,Ausstellung
Issue Date,Ausstellungsdatum
Issue Details,Vorgangsdetails
Issued Items Against Production Order,Gegen Fertigungsauftrag ausgegebene Artikel
It can also be used to create opening stock entries and to fix stock value.,"Es kann auch verwendet werden, um die Öffnung der Vorratszugänge zu schaffen und Bestandswert zu beheben."
Item,Artikel
Item #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Artikel #{0}: Bestellmenge kann nicht kleiner sein als die Mindestbestellmenge (festgelegt im Artikelstamm)
Item Advanced,Erweiterter Artikel
Item Barcode,Artikelstrichcode
Item Batch Nos,Artikel-Chargennummern
Item Classification,Artikelklassifizierung
Item Code,Artikel-Nr
Item Code > Item Group > Brand,Artikel-Nr > Artikelgruppe > Marke
Item Code and Warehouse should already exist.,Artikel-Nummer und Lager sollten bereits vorhanden sein.
Item Code cannot be changed for Serial No.,Item Code kann nicht für Seriennummer geändert werden
Item Code is mandatory because Item is not automatically numbered,"Artikel-Code ist zwingend erforderlich, da Einzelteil wird nicht automatisch nummeriert"
Item Code required at Row No {0},Item Code in Zeile Keine erforderlich {0}
Item Customer Detail,Kundendetail Artikel
Item Description,Artikelbeschreibung
Item Desription,Artikelbeschreibung
Item Details,Artikeldetails
Item Group,Artikelgruppe
Item Group Name,Name der Artikelgruppe
Item Group Tree,Artikelgruppenstruktur
Item Group not mentioned in item master for item {0},Im Artikelstamm für Artikel nicht erwähnt Artikelgruppe {0}
Item Groups in Details,Artikelgruppen in Details
Item Image (if not slideshow),Artikelbild (wenn keine Diashow)
Item Name,Artikelname
Item Naming By,Artikelbenennung nach
Item Price,Artikelpreis
Item Prices,Artikelpreise
Item Quality Inspection Parameter,Parameter der Artikel-Qualitätsprüfung
Item Reorder,Artikel Wiederbestellung
Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,Artikel Zeile {0}: Eingangslieferschein {1} existiert nicht in den o.g. Eingangslieferscheinen
Item Serial No,Artikel-Seriennummer
Item Serial Nos,Artikel-Seriennummern
Item Shortage Report,Artikel Mangel Bericht
Item Supplier,Artikellieferant
Item Supplier Details,Details Artikellieferant
Item Tax,Artikelsteuer
Item Tax Amount,Artikel-Steuerbetrag
Item Tax Rate,Artikel-Steuersatz
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Artikel Tax Row {0} muss wegen Art oder Steuerertrag oder-aufwand oder Kostenpflichtige haben
Item Tax1,Artikelsteuer1
Item To Manufacture,Artikel Bis-Herstellung
Item UOM,Artikel-ME
Item Website Specification,Artikel-Webseitenspezifikation
Item Website Specifications,Artikel-Webseitenspezifikationen
Item Wise Tax Detail,Artikel Wise UST Details
Item Wise Tax Detail ,Artikel Wise UST Details
Item is required,Artikel erforderlich
Item is updated,Artikel wird aktualisiert
Item master.,Artikelstamm.
"Item must be a purchase item, as it is present in one or many Active BOMs","Artikel muss ein Zukaufsartikel sein, da es in einer oder mehreren aktiven Stücklisten vorhanden ist"
Item must be added using 'Get Items from Purchase Receipts' button,"Artikel müssen mit dem Button ""Artikel von Eingangslieferschein übernehmen"" hinzugefühgt werden"
Item or Warehouse for row {0} does not match Material Request,Artikel- oder Lagerreihe{0} ist Materialanforderung nicht überein
Item table can not be blank,Artikel- Tabelle kann nicht leer sein
Item to be manufactured or repacked,Hergestellter oder umgepackter Artikel
Item valuation rate is recalculated considering landed cost voucher amount,Artikelpreis wird anhand von Frachtkosten neu berechnet
Item valuation updated,Artikel- Bewertung aktualisiert
Item will be saved by this name in the data base.,Einzelteil wird mit diesem Namen in der Datenbank gespeichert.
Item {0} appears multiple times in Price List {1},Artikel {0} erscheint mehrfach in Preisliste {1}
Item {0} does not exist,Artikel {0} existiert nicht
Item {0} does not exist in the system or has expired,Artikel {0} ist nicht im System vorhanden oder abgelaufen
Item {0} does not exist in {1} {2},Artikel {0} existiert nicht in {1} {2}
Item {0} has already been returned,Artikel {0} wurde bereits zurück
Item {0} has been entered multiple times against same operation,Artikel {0} wurde mehrmals gegen dieselbe Operation eingegeben
Item {0} has been entered multiple times with same description or date,Artikel {0} wurde mehrmals mit der gleichen Beschreibung oder Datum eingegeben
Item {0} has been entered multiple times with same description or date or warehouse,Artikel {0} wurde mehrmals mit der gleichen Beschreibung oder Datum oder Lager eingetragen
Item {0} has been entered twice,Artikel {0} wurde zweimal eingegeben
Item {0} has reached its end of life on {1},Artikel {0} hat das Ende ihrer Lebensdauer erreicht auf {1}
Item {0} ignored since it is not a stock item,"Artikel {0} ignoriert, da es sich nicht um Lagerware"
Item {0} is cancelled,Artikel {0} wird abgebrochen
Item {0} is not Purchase Item,Artikel {0} ist nicht Kaufsache
Item {0} is not a serialized Item,Artikel {0} ist keine serialisierten Artikel
Item {0} is not a stock Item,Artikel {0} ist kein Lagerartikel
Item {0} is not active or end of life has been reached,Artikel {0} ist nicht aktiv oder Ende des Lebens ist erreicht
Item {0} is not setup for Serial Nos. Check Item master,Artikel {0} ist kein Setup für den Seriennummern prüfen Artikelstamm
Item {0} is not setup for Serial Nos. Column must be blank,Artikel {0} ist kein Setup für den Seriennummern Spalte muss leer sein
Item {0} must be Sales Item,Artikel {0} muss sein Verkaufsartikel
Item {0} must be Sales or Service Item in {1},Artikel {0} muss Vertriebs-oder Service Artikel in {1}
Item {0} must be Service Item,Artikel {0} muss sein Service- Artikel
Item {0} must be a Purchase Item,Artikel {0} muss ein Kaufsache sein
Item {0} must be a Sales Item,Artikel {0} muss ein Verkaufsartikel sein
Item {0} must be a Service Item.,Artikel {0} muss ein Service- Element sein.
Item {0} must be a Sub-contracted Item,Artikel {0} muss ein Subunternehmer vergebene Titel
Item {0} must be a stock Item,Artikel {0} muss ein Lager Artikel sein
Item {0} must be manufactured or sub-contracted,Artikel {0} hergestellt werden muss oder Unteraufträge vergeben
Item {0} not found,Artikel {0} nicht gefunden
Item {0} with Serial No {1} is already installed,Artikel {0} mit Seriennummer {1} ist bereits installiert
Item {0} with same description entered twice,Artikel {0} mit derselben Beschreibung zweimal eingegeben
"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Details zu Artikel, Garantie, AMC (Jahreswartungsvertrag) werden automatisch angezeigt, wenn die Seriennummer ausgewählt wird."
Item-wise Price List Rate,Artikel weise Preis List
Item-wise Purchase History,Artikelweiser Einkaufsverlauf
Item-wise Purchase Register,Artikelweises Einkaufsregister
Item-wise Sales History,Artikelweiser Vertriebsverlauf
Item-wise Sales Register,Artikelweises Vertriebsregister
"Item: {0} managed batch-wise, can not be reconciled using \					Stock Reconciliation, instead use Stock Entry",Artikel: {0} wird stapelweise verarbeitet; kann nicht mit Lagerabgleich abgestimmt werden. Nutze nun Lagerbestand.
Item: {0} not found in the system,Item: {0} nicht im System gefunden
Items,Artikel
Items To Be Requested,Artikel angefordert werden
Items required,Artikel erforderlich
"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Angeforderte Artikel, die im gesamten Warenlager bezüglich der geforderten Menge und Mindestbestellmenge ""Nicht vorrätig"" sind."
Items which do not exist in Item master can also be entered on customer's request,"Artikel, die nicht im Artikelstamm vorhanden sind, können auf Wunsch des Kunden auch eingetragen werden"
Itemwise Discount,Artikelweiser Rabatt
Itemwise Recommended Reorder Level,Artikelweise empfohlene Neubestellungsebene
Job Applicant,Bewerber
Job Opening,Offene Stelle
Job Profile,Stellenbeschreibung
Job Title,Stellenbezeichnung
"Job profile, qualifications required etc.","Stellenbeschreibung, erforderliche Qualifikationen usw."
Jobs Email Settings,Stellen-E-Mail-Einstellungen
Journal Entries,Journaleinträge
Journal Entry,Journaleintrag
Journal Voucher,Buchungsbeleg
Journal Voucher Detail,Buchungsbeleg Detail
Journal Voucher Detail No,Buchungsbeleg Detailnr.
Journal Voucher {0} does not have account {1} or already matched,Buchungsbeleg {0} hat kein Konto {1} oder oder wurde bereits zugeordnet
Journal Vouchers {0} are un-linked,{0} Buchungsbelege sind nicht verknüpft
"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Verfolgung von Vertriebskampangen, Interessenten, Angebote, Kundenauftrag, usw. zur Beurteilung des Erfolges von Kampangen."
Keep a track of communication related to this enquiry which will help for future reference.,Kommunikation bezüglich dieser Anfrage für zukünftige Zwecke aufbewahren.
Keep it web friendly 900px (w) by 100px (h),halten Sie es Webfreundlich - 900px (breit) bei 100px (hoch)
Key Performance Area,Wichtigster Leistungsbereich
Key Responsibility Area,Wichtigster Verantwortungsbereich
Kg,kg
LR Date,LR-Datum
LR No,LR-Nr.
Label,Etikett
Landed Cost Help,Einstandpreis Hilfe
Landed Cost Item,Einstandspreis Artikel
Landed Cost Purchase Receipt,Einstandspreis Eingangslieferschein
Landed Cost Taxes and Charges,Einstandspreis Steuern und Abgaben
Landed Cost Voucher,Einstandspreis Gutschein
Landed Cost Voucher Amount,Einstandspreis Gutscheinbetrag
Language,Sprache
Last Name,Familienname
Last Purchase Rate,Letzter Anschaffungskurs
Latest,neueste
Lead,Interessent
Lead Details,Interessent-Details
Lead Id,Interessent Id
Lead Name,Interessent Name
Lead Owner,Interessent Eigentümer
Lead Source,Interessent Ursprung
Lead Status,Interessent Status
Lead Time Date,Durchlaufzeit Datum
Lead Time Days,Durchlaufzeit Tage
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.,"""Durchlaufzeit Tage"" beschreibt die Anzahl der Tage, bis wann mit dem Eintreffen des Artikels im Lager zu rechnen ist. Diese Tage werden aus der Materialanforderung abgefragt, wenn Sie diesen Artikel auswählen."
Lead Type,Lead-Typ
Lead must be set if Opportunity is made from Lead,"Interessent muss eingestellt werden, wenn Chancen aus Interessenten erstellt werden"
Leave Allocation,Urlaubszuordnung
Leave Allocation Tool,Urlaubszuordnungs-Tool
Leave Application,Abwesenheitsantrag
Leave Approver,Urlaubsgenehmiger
Leave Approvers,Urlaubsgenehmiger
Leave Balance Before Application,Urlaubskonto vor Anwendung
Leave Block List,Urlaubssperrenliste
Leave Block List Allow,Urlaubssperrenliste zulassen
Leave Block List Allowed,Urlaubssperrenliste zugelassen
Leave Block List Date,Urlaubssperrenliste Datum
Leave Block List Dates,Urlaubssperrenliste Termine
Leave Block List Name,Urlaubssperrenliste Name
Leave Blocked,Urlaub gesperrt
Leave Control Panel,Urlaubskontrolloberfläche
Leave Encashed?,Urlaub eingelöst?
Leave Encashment Amount,Urlaubseinlösung Betrag
Leave Type,Urlaubstyp
Leave Type Name,Urlaubstyp Name
Leave Without Pay,Unbezahlter Urlaub
Leave application has been approved.,Urlaubsantrag wurde genehmigt.
Leave application has been rejected.,Urlaubsantrag wurde abgelehnt.
Leave approver must be one of {0},Urlaube und Abwesenheiten müssen von {0} genehmigt werden.
Leave blank if considered for all branches,"Freilassen, wenn es für alle Branchen gelten soll"
Leave blank if considered for all departments,"Freilassen, wenn es für alle Abteilungen gelten soll"
Leave blank if considered for all designations,"Freilassen, wenn es für alle Bezeichnungen gelten soll"
Leave blank if considered for all employee types,"Freilassen, wenn es für alle Mitarbeitertypen gelten soll"
"Leave can be approved by users with Role, ""Leave Approver""","Urlaub kann von Benutzern mit der Rolle ""Urlaubsgenehmiger"" genehmigt werden"
Leave of type {0} cannot be longer than {1},Abwesenheit vom Typ {0} kann nicht länger sein als {1}
Leaves Allocated Successfully for {0},Erfolgreich zugewiesene Abwesenheiten für {0}
Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Abwesenheiten für Typ {0} sind bereits für das Geschäftsjahr {0} dem Arbeitnehmer {1} zugeteilt
Leaves must be allocated in multiples of 0.5,"Abwesenheiten müssen ein Vielfaches von 0,5 sein"
Ledger,Sachkonto
Ledgers,Sachkonten
Left,Links
Legal,Juristisch
Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Juristische Einheit/Niederlassung mit einem separaten Kontenplan, der zum Unternehmen gehört."
Legal Expenses,Anwaltskosten
Letter Head,Briefkopf
Letter Heads for print templates.,Briefköpfe für Druckvorlagen.
Level,Ebene
Lft,li
Liability,Haftung
List a few of your customers. They could be organizations or individuals.,Geben Sie ein paar Ihrer Kunden an. Dies können Firmen oder Einzelpersonen sein.
List a few of your suppliers. They could be organizations or individuals.,Geben Sie ein paar von Ihren Lieferanten an. Diese können Firmen oder Einzelpersonen sein.
List items that form the package.,"Listenelemente, die das Paket bilden."
List of users who can edit a particular Note,"Liste der Benutzer, die eine besondere Notiz bearbeiten können"
List this Item in multiple groups on the website.,Diesen Artikel in mehreren Gruppen auf der Website auflisten.
"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.","Geben Sie ein paar Ihrer Produkte oder Dienstleistungen an, die Sie kaufen oder verkaufen."
"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.","Geben Sie Ihre Steuerangaben (z.B. Mehrwertsteuer, Verbrauchssteuern, etc.; Diese sollten eindeutige Namen haben) und die jeweiligen Standardsätze an."
Loading...,Wird geladen ...
Loans (Liabilities),Kredite (Passiva)
Loans and Advances (Assets),Forderungen (Aktiva)
Local,lokal
"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Protokoll der von Benutzern durchgeführten Aktivitäten bei Aufgaben, die zum Protokollieren von Zeit und zur Rechnungslegung verwendet werden."
Login,Anmelden
Login with your new User ID,Loggen Sie sich mit Ihrer neuen Benutzer-ID ein
Logo,Logo
Logo and Letter Heads,Logo und Briefköpfe
Lost,verloren
Lost Reason,Verlustgrund
Low,Niedrig
Lower Income,Niedrigeres Einkommen
MTN Details,MTN-Details
Main,Haupt
Main Reports,Hauptberichte
Maintain Same Rate Throughout Sales Cycle,Gleiche Rate im gesamten Verkaufszyklus beibehalten
Maintain same rate throughout purchase cycle,Gleiche Rate im gesamten Kaufzyklus beibehalten
Maintenance,Wartung
Maintenance Date,Wartungsdatum
Maintenance Details,Wartungsdetails
Maintenance Manager,Verantwortlicher für die Wartung
Maintenance Schedule,Wartungsplan
Maintenance Schedule Detail,Wartungsplandetail
Maintenance Schedule Item,Wartungsplanposition
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Wartungsplan wird nicht für alle Elemente erzeugt. Bitte klicken Sie auf ""Zeitplan generieren"""
Maintenance Schedule {0} exists against {0},Wartungsplan {0} gegen {0} existiert
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Wartungsplan {0} muss vor Stornierung dieses Kundenauftrages storniert werden
Maintenance Schedules,Wartungspläne
Maintenance Status,Wartungsstatus
Maintenance Time,Wartungszeit
Maintenance Type,Wartungstyp
Maintenance User,Mitarbeiter für die Wartung
Maintenance Visit,Wartungsbesuch
Maintenance Visit Purpose,Wartungsbesuch Zweck
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Wartungsbesuch {0} muss vor Stornierung dieses Kundenauftrages storniert werden
Maintenance start date can not be before delivery date for Serial No {0},Wartung Startdatum kann nicht vor dem Liefertermin für Seriennummer {0} sein
Major/Optional Subjects,Wichtiger/optionaler Betreff
Make ,Ausführen 
Make Accounting Entry For Every Stock Movement,Machen Accounting Eintrag für jede Lagerbewegung
Make Bank Voucher,Bankbeleg erstellen
Make Credit Note,Gutschrift erstellen
Make Debit Note,Lastschrift erstellen
Make Delivery,Lieferung erstellen
Make Difference Entry,Differenzeintrag erstellen
Make Excise Invoice,Machen Verbrauch Rechnung
Make Installation Note,Installationshinweis erstellen
Make Invoice,Rechnung erstellen
Make Maint. Schedule,Wartungsfenster erstellen
Make Maint. Visit,Wartungsbesuch erstellen
Make Maintenance Visit,Wartungsbesuch erstellen
Make Packing Slip,Packzettel erstellen
Make Payment,Zahlung durchführen
Make Payment Entry,Zahlung hinzufügen
Make Purchase Invoice,Einkaufsrechnung erstellen
Make Purchase Order,Bestellung erstellen
Make Purchase Receipt,Kaufbeleg erstellen
Make Salary Slip,Gehaltsabrechnung erstellen
Make Salary Structure,Gehaltsübersicht erstellen
Make Sales Invoice,Verkaufsrechnung erstellen
Make Sales Order,Verkaufsauftrag erstellen
Make Supplier Quotation,Lieferantenanfrage erstellen
Make Time Log Batch,Zeitprotokollstapel erstellen
Make new POS Setting,POS-Einstellung hinzufügen
Male,Männlich
Manage Customer Group Tree.,Verwalten von Kundengruppen
Manage Sales Partners.,Verwalten von Vertriebspartnern
Manage Sales Person Tree.,Verwalten von Vertriebsmitarbeitern
Manage Territory Tree.,Verwalten von Vertriebsgebieten
Manage cost of operations,Betriebskosten verwalten
Management,Management
Manager,Manager
"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Notwendige Angabe, wenn Bestandsartikel ""Ja"" ist. Ebenfalls das Standardwarenlager, in dem die Menge über den Kundenauftrag reserviert wurde."
Manufacture against Sales Order,Herstellung laut Kundenauftrag
Manufacture/Repack,Herstellung/Neuverpackung
Manufactured Item,Fertigungsartikel
Manufactured Qty,Hergestellte Menge
Manufactured quantity will be updated in this warehouse,Hergestellte Menge wird in diesem Lager aktualisiert
Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Hergestellte Menge {0} kann nicht größer sein als die geplante Menge {1} in Fertigungsauftrag {2}
Manufacturer,Hersteller
Manufacturer Part Number,Hersteller-Teilenummer
Manufacturing,Produktionsplanung
Manufacturing Manager,Fertigung Verantwortlicher
Manufacturing Quantity,Fertigungsmenge
Manufacturing Quantity is mandatory,Eingabe einer Fertigungsmenge ist obligatorisch!
Manufacturing User,Fertigung Mitarbeiter
Margin,Marge
Marital Status,Familienstand
Market Segment,Marktsegment
Marketing,Marketing
Marketing Expenses,Marketingkosten
Married,verheiratet
Mass Mailing,Massenmailversand
Master Name,Stammname
Master Name is mandatory if account type is Warehouse,"Meister -Name ist obligatorisch, wenn Kontotyp Warehouse"
Master Type,Stammtyp
Masters,Stämme
Match non-linked Invoices and Payments.,Zuordnung nicht verknüpfter Rechnungen und Zahlungen.
Material Issue,Materialentnahme
Material Manager,Lager Verantwortlicher
Material Master Manager,Lager Hauptverantwortlicher
Material Receipt,Materialannahme
Material Request,Materialanforderung
Material Request Detail No,Detailnr. der Materialanforderung
Material Request For Warehouse,Materialanforderung für Warenlager
Material Request Item,Materialanforderungsposition
Material Request Items,Materialanforderungspositionen
Material Request No,Materialanforderungsnr.
Material Request Type,Materialanforderungstyp
Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materialanforderung von maximal {0} kann für Artikel {1} aus Kundenauftrag {2} gemacht werden
Material Request used to make this Stock Entry,Verwendete Materialanforderung für diesen Lagereintrag
Material Request {0} is cancelled or stopped,Materialanforderung {0} wird abgebrochen oder gestoppt
Material Requests for which Supplier Quotations are not created,Materialanfragen für die Lieferantenbestellungen werden nicht erstellt
Material Requests {0} created,Material Requests {0} erstellt
Material Requirement,Materialanforderung
Material Transfer,Materialtransfer
Material User,Lager Mitarbeiter
Materials,Materialien
Materials Required (Exploded),Benötigte Materialien (erweitert)
Max 5 characters,Max 5 Zeichen
Max Days Leave Allowed,Maximal zulässige Urlaubstage
Max Discount (%),Maximaler Rabatt (%)
Max Qty,Max Menge
Max discount allowed for item: {0} is {1}%,Max Rabatt erlaubt zum Artikel: {0} {1}%
Maximum Amount,Höchstbetrag
Maximum allowed credit is {0} days after posting date,Die maximal zulässige Kredit ist {0} Tage nach Buchungsdatum
Maximum {0} rows allowed,Maximum {0} Zeilen erlaubt
Maxiumm discount for Item {0} is {1}%,Maxiumm Rabatt für Artikel {0} {1}%
Medical,Medizin-
Medium,Mittel
"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company","Merging ist nur möglich, wenn folgenden Objekte sind in beiden Datensätzen."
Message,Nachricht
Message Parameter,Nachrichtenparameter
Message Sent,Nachricht gesendet
Message updated,Nachricht aktualisiert
Messages,Nachrichten
Messages greater than 160 characters will be split into multiple messages,Nachrichten mit mehr als 160 Zeichen werden in mehrere Nachrichten aufgeteilt
Middle Income,Mittleres Einkommen
Milestone,Ecktermin
Milestone Date,Ecktermin Datum
Milestones,Ecktermine
Milestones will be added as Events in the Calendar,Ecktermine werden als Ereignisse in den Kalender aufgenommen
Min Order Qty,Mindestbestellmenge
Min Qty,Mindestmenge
Min Qty can not be greater than Max Qty,Mindestmenge nicht größer als Max Menge sein
Minimum Amount,Mindestbetrag
Minimum Order Qty,Mindestbestellmenge
Minute,Minute
Misc Details,Sonstige Einzelheiten
Miscellaneous Expenses,Sonstige Aufwendungen
Miscelleneous,Sonstiges
Mobile No,Mobilfunknummer
Mobile No.,Mobilfunknr.
Mode of Payment,Zahlungsweise
Modern,Modern
Monday,Montag
Month,Monat
Monthly,Monatlich
Monthly Attendance Sheet,Monatliche Anwesenheitsliste
Monthly Earning & Deduction,Monatliches Einkommen & Abzug
Monthly Salary Register,Monatsgehalt Register
Monthly salary statement.,Monatliche Gehaltsabrechnung
More Details,Weitere Details
More Info,Mehr Informationen
Motion Picture & Video,Motion Picture & Video
Moving Average,Gleitender Mittelwert
Moving Average Rate,Gleitende Mittelwertsrate
Mr,Herr
Ms,Frau
Multiple Item prices.,Mehrere Artikelpreise.
"Multiple Price Rule exists with same criteria, please resolve \			conflict by assigning priority. Price Rules: {0}","mehrere Preisregeln exisitieren mit den gleich Kriterien, bitte beheben durch Angabe der Priorität- Preisregel: {0}"
Music,Musik
Must be Whole Number,Muss eine Ganzzahl sein
Name,Name
Name and Description,Name und Beschreibung
Name and Employee ID,Name und Personalnummer
"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Name des neuen Kontos. Hinweis: Bitte erstellen Sie keine Konten für Kunden und Lieferanten zu schaffen, diese werden automatisch vom Kunden- und Lieferantenstamm angelegt"
Name of person or organization that this address belongs to.,"Name der Person oder des Unternehmens, zu dem diese Adresse gehört."
Name of the Budget Distribution,Name der Budgetverteilung
Naming Series,Benennungsreihenfolge
Negative Quantity is not allowed,Negative Menge ist nicht erlaubt
Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negative Auf Error ( {6}) für Artikel {0} in {1} Warehouse auf {2} {3} {4} in {5}
Negative Valuation Rate is not allowed,Negative Bewertungsbetrag ist nicht erlaubt
Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Negative Bilanz in Batch {0} für {1} Artikel bei Warehouse {2} auf {3} {4}
Net Pay,Nettolohn
Net Pay (in words) will be visible once you save the Salary Slip.,"Nettolohn (in Worten) wird angezeigt, sobald Sie die Gehaltsabrechnung speichern."
Net Profit / Loss,Nettogewinn /-verlust
Net Total,Nettosumme
Net Total (Company Currency),Nettosumme (Unternehmenswährung)
Net Weight,Nettogewicht
Net Weight UOM,Nettogewicht-ME
Net Weight of each Item,Nettogewicht der einzelnen Artikel
Net pay cannot be negative,Nettolohn kann nicht negativ sein
Never,Nie
New ,Neue 
New Account,Neues Konto
New Account Name,New Account Name
New BOM,Neue Stückliste
New Communications,Neue Nachrichten
New Company,Neue Gesellschaft
New Cost Center,Neue Kostenstelle
New Cost Center Name,Neue Kostenstellennamen
New Delivery Notes,Neue Lieferscheine
New Enquiries,Neue Anfragen
New Leads,Neue Interessenten
New Leave Application,Neuer Urlaubsantrag
New Leaves Allocated,Neue Urlaubszuordnung
New Leaves Allocated (In Days),Neue Urlaubszuordnung (in Tagen)
New Material Requests,Neue Materialanfragen
New Projects,Neue Projekte
New Purchase Orders,Neue Lieferatenaufträge
New Purchase Receipts,Neue Eingangslieferscheine
New Quotations,Neue Angebote
New Sales Orders,Neue Kundenaufträge
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Neue Seriennummer kann kann kein Lager haben. Lagerangaben müssen durch Lagerzugang oder Eingangslieferschein erstellt werden
New Stock Entries,Neue Lagerbestandseinträge
New Stock UOM,Neue Lagerbestands-ME
New Stock UOM is required,Neue Lager-ME erforderlich
New Stock UOM must be different from current stock UOM,Neue Lager-ME muss sich von aktuellen Lager-ME unterscheiden
New Supplier Quotations,Neue Lieferantenangebote
New Support Tickets,Neue Support-Tickets
New UOM must NOT be of type Whole Number,Neue Mengeneinheit darf NICHT vom Typ ganze Zahl sein
New Workplace,Neuer Arbeitsplatz
New {0}: #{1},Neu: {0} - #{1}
Newsletter,Newsletter
Newsletter Content,Newsletter-Inhalt
Newsletter Status,Newsletter-Status
Newsletter has already been sent,Newsletter wurde bereits gesendet
"Newsletters to contacts, leads.","Newsletter an Kontakte, Interessenten"
Newspaper Publishers,Zeitungsverleger
Next,weiter
Next Contact By,nächster Kontakt durch
Next Contact Date,nächstes Kontaktdatum
Next Date,nächster Termin
Next Recurring {0} will be created on {1},nächste Wiederholung von {0} wird erstellt am {1}
Next email will be sent on:,Nächste E-Mail wird gesendet am:
No,Nein
No Customer Accounts found.,Keine Kundenkonten gefunden.
No Customer or Supplier Accounts found,Keine Kunden-oder Lieferantenkontengefunden
No Item with Barcode {0},Kein Artikel mit Barcode {0}
No Item with Serial No {0},Kein Artikel mit Seriennummer {0}
No Items to pack,Keine Artikel zu packen
No Permission,Keine Berechtigung
No Production Orders created,Keine Fertigungsaufträge erstellt
No Remarks,ohne Anmerkungen
No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,Keine Lieferantenkontengefunden. Lieferant Konten werden basierend auf dem Wert 'Master Type' in Kontodatensatz identifiziert.
No accounting entries for the following warehouses,Keine Buchungen für die folgenden Hallen
No addresses created,Keine Adressen erstellt
No contacts created,Keine Kontakte erstellt
No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Kein Standardadressvorlage gefunden. Bitte erstellen Sie eine Neue unter Setup > Druck und Branding -> Adressvorlage.
No default BOM exists for Item {0},für Artikel {0} existiert keine Standardstückliste
No description given,Keine Beschreibung angegeben
No employee found,Kein Mitarbeiter gefunden
No employee found!,Kein Mitarbeiter gefunden!
No of Requested SMS,Anzahl angeforderter SMS
No of Sent SMS,Anzahl abgesendeter SMS
No of Visits,Anzahl der Besuche
No permission,Keine Berechtigung
No record found,Kein Eintrag gefunden
No records found in the Invoice table,Keine Einträge in der Rechnungstabelle gefunden
No records found in the Payment table,Keine Datensätze in der Tabelle gefunden Zahlung
No salary slip found for month: ,Keine Gehaltsabrechnung gefunden für den Monat:
Non Profit,Non-Profit
Nos,Stk
Not Active,nicht aktiv
Not Applicable,nicht anwendbar
Not Available,nicht verfügbar
Not Billed,nicht abgerechnet
Not Delivered,nicht geliefert
Not In Stock,nicht an Lager
Not Sent,nicht versendet
Not Set,nicht festgelegt
Not allowed to update stock transactions older than {0},"Nicht erlaubt, um zu aktualisieren, Aktiengeschäfte, die älter als {0}"
Not authorized to edit frozen Account {0},Keine Berechtigung für gefrorene Konto bearbeiten {0}
Not authroized since {0} exceeds limits,Nicht authroized seit {0} überschreitet Grenzen
Not permitted,Nicht zulässig
Note,Anmerkung
Note User,Anmerkungsbenutzer
Note is a free page where users can share documents / notes,"""Anmerkung"" ist eine kostenlose Seite, wo Benutzer Dokumente/Anmerkungen freigeben können"
"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.",Hinweis: Backups und Dateien werden nicht von Dropbox gelöscht; Sie müssen sie manuell löschen.
"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.",Hinweis: Backups und Dateien werden nicht von Google Drive gelöscht; Sie müssen sie manuell löschen.
Note: Due Date exceeds the allowed credit days by {0} day(s),Hinweis: Due Date übersteigt die zulässigen Kredit Tage von {0} Tag (e)
Note: Email will not be sent to disabled users,Hinweis: E-Mail wird nicht an behinderte Nutzer gesendet
Note: Item {0} entered multiple times,Hinweis: Artikel {0} mehrfach eingegeben
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Hinweis: Zahlung Eintrag nicht da ""Cash oder Bankkonto ' wurde nicht angegeben erstellt werden"
Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Hinweis: Das System wird nicht über Lieferung und Überbuchung überprüfen zu Artikel {0} als Menge oder die Menge ist 0
Note: There is not enough leave balance for Leave Type {0},Hinweis: Es ist nicht genügend Urlaubsbilanz für Leave Typ {0}
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Hinweis: Diese Kostenstelle ist eine Gruppe. Kann nicht gegen eine Gruppe buchen.
Note: {0},Hinweis: {0}
Notes,Notizen
Notes:,Notizen:
Nothing to request,"Nichts zu verlangen,"
Notice (days),Kenntnis (Tage)
Notification Control,Benachrichtungseinstellungen
Notification Email Address,Benachrichtigungs E-Mail Adresse
Notify by Email on creation of automatic Material Request,Bei Erstellung einer automatischen Materialanforderung per E-Mail benachrichtigen
Number Format,Zahlenformat
Offer Date,Angebot Datum
Office,Büro
Office Equipments,Büro Ausstattung
Office Maintenance Expenses,Office-Wartungskosten
Office Rent,Büromiete
Old Parent,Alte übergeordnete Position
On Net Total,Auf Nettosumme
On Previous Row Amount,Auf vorherigen Zeilenbetrag
On Previous Row Total,Auf vorherige Zeilensumme
Online Auctions,Online-Auktionen
Only Leave Applications with status 'Approved' can be submitted,"Nur Lassen Anwendungen mit dem Status ""Genehmigt"" eingereicht werden können"
"Only Serial Nos with status ""Available"" can be delivered.","Nur Seriennummernmit dem Status ""Verfügbar"" geliefert werden."
Only leaf nodes are allowed in transaction,In der Transaktion sind nur Unterelemente erlaubt
Only the selected Leave Approver can submit this Leave Application,Nur der ausgewählte Datum Genehmiger können diese Urlaubsantrag einreichen
Open,Offen
Open Production Orders,Offene Fertigungsaufträge
Open Tickets,Tickets eröffnen
Opening (Cr),Eröffnung (Cr)
Opening (Dr),Opening ( Dr)
Opening Date,Öffnungsdatum
Opening Entry,Öffnungseintrag
Opening Qty,Öffnungs Menge
Opening Time,Öffnungszeit
Opening Value,Öffnungs Wert
Opening for a Job.,Stellenausschreibung
Operating Cost,Betriebskosten
Operation Description,Vorgangsbeschreibung
Operation No,Vorgangsnr.
Operation Time (mins),Betriebszeit (Min.)
Operation {0} is repeated in Operations Table,Bedienung {0} ist in Operations Tabelle wiederholt
Operation {0} not present in Operations Table,Bedienung {0} nicht in Operations Tabelle vorhanden
Operations,Vorgänge
Opportunity,Gelegenheit
Opportunity Date,Datum der Gelegenheit
Opportunity From,Gelegenheit von
Opportunity Item,Gelegenheitsartikel
Opportunity Items,Gelegenheitsartikel
Opportunity Lost,Gelegenheit verpasst
Opportunity Type,Gelegenheitstyp
Optional. This setting will be used to filter in various transactions.,"Optional. Diese Einstellung wird verwendet, um in verschiedenen Transaktionen zu filtern."
Order Type,Bestelltyp
Order Type must be one of {0},Auftragstyp muss einer der {0}
Ordered,Bestellt
Ordered Items To Be Billed,"Abzurechnende, bestellte Artikel"
Ordered Items To Be Delivered,"Zu liefernde, bestellte Artikel"
Ordered Qty,bestellte Menge
"Ordered Qty: Quantity ordered for purchase, but not received.","Bestellte Menge: Bestellmenge für den Kauf, aber nicht erhalten."
Ordered Quantity,Bestellte Menge
Orders released for production.,Für die Produktion freigegebene Bestellungen.
Organization Name,Firmenname
Organization Profile,Firmenprofil
Organization branch master.,Firmen-Niederlassungen Vorlage.
Organization unit (department) master.,Firmeneinheit (Abteilung) Vorlage.
Other,sonstige
Other Details,weitere Details
Others,andere
Out Qty,out Menge
Out Value,out Wert
Out of AMC,Außerhalb AMC
Out of Warranty,Außerhalb der Garantie
Outgoing,Postausgang
Outstanding Amount,Ausstehender Betrag
Outstanding for {0} cannot be less than zero ({1}),Herausragende für {0} kann nicht kleiner als Null sein ({1})
Overdue,überfällig
Overdue: ,überfällig:
Overhead,Gemeinkosten
Overheads,Gemeinkosten
Overlapping conditions found between:,überlagernde Bedingungen gefunden zwischen:
Overview,Überblick
Owned,Im Besitz
Owner,Eigentümer
P L A - Cess Portion,PLA - Cess Portion
PL or BS,PL oder BS
PO Date,Bestelldatum
PO No,Lieferantenauftag Nr
POP3 Mail Server,POP3-Mail-Server
POP3 Mail Settings,POP3-Mail-Einstellungen
POP3 mail server (e.g. pop.gmail.com),POP3-Mail-Server (z. B. pop.gmail.com)
POP3 server e.g. (pop.gmail.com),POP3-Server (z. B. pop.gmail.com)
POS,POS
POS Setting,POS-Einstellung
POS Setting required to make POS Entry,"POS -Einstellung erforderlich, um POS- Eintrag machen"
POS Setting {0} already created for user: {1} and company {2},POS -Einstellung {0} bereits Benutzer angelegt : {1} und {2} Unternehmen
POS View,POS-Ansicht
PR Detail,PR-Detail
Package Item Details,Artikeldetails zum Paket
Package Items,Artikel im Paket
Package Weight Details,Details Paketgewicht
Packed Item,Verpackter Artikel
Packed quantity must equal quantity for Item {0} in row {1},Lunch Menge muss Menge für Artikel gleich {0} in Zeile {1}
Packing Details,Verpackungsdetails
Packing List,Lieferschein
Packing Slip,Packzettel
Packing Slip Item,Packzettel Artikel
Packing Slip Items,Packzettel Artikel
Packing Slip(s) cancelled,Lieferschein (e) abgesagt
Page Break,Seitenumbruch
Page Name,Seitenname
Paid,bezahlt
Paid Amount,Gezahlter Betrag
Paid amount + Write Off Amount can not be greater than Grand Total,Bezahlte Betrag + Write Off Betrag kann nicht größer als Gesamtsumme sein
Pair,Paar
Parameter,Parameter
Parent Account,Übergeordnetes Konto
Parent Cost Center,Übergeordnete Kostenstelle
Parent Customer Group,Übergeordnete Kundengruppe
Parent Detail docname,Übergeordnetes Detail Dokumentenname
Parent Item,Übergeordnete Position
Parent Item Group,Übergeordnete Artikelgruppe
Parent Item {0} must be not Stock Item and must be a Sales Item,Eltern Artikel {0} muss nicht Stock Artikel sein und ein Verkaufsartikel sein
Parent Party Type,Eltern -Party -Typ
Parent Sales Person,Übergeordneter Verkäufer
Parent Territory,Übergeordnete Region
Parent Website Route,Eltern- Webseite Routen
Parenttype,Übergeordnete Position
Part-time,Teilzeit-
Partially Completed,Teilweise abgeschlossen
Partly Billed,Teilweise abgerechnet
Partly Delivered,Teilweise geliefert
Partner Target Detail,Partner Zieldetail
Partner Type,Partnertyp
Partner's Website,Webseite des Partners
Party,Gruppe
Party Account,Gruppenzugang
Party Type,Gruppen-Typ
Party Type Name,Gruppen-Typ Name
Passive,Passiv
Passport Number,Passnummer
Password,Passwort
Pay To / Recd From,Zahlen an/Zurücktreten von
Payable,zahlbar
Payables,Verbindlichkeiten
Payables Group,Verbindlichkeiten Gruppe
Payment Days,Zahltage
Payment Due Date,Zahlungstermin
Payment Pending,Zahlung ausstehend
Payment Period Based On Invoice Date,Zahlungszeitraum basiert auf Rechnungsdatum
Payment Reconciliation,Zahlungsabstimmung
Payment Reconciliation Invoice,Zahlung Versöhnung Rechnung
Payment Reconciliation Invoices,Zahlung Versöhnung Rechnungen
Payment Reconciliation Payment,Payment Zahlungs Versöhnung
Payment Reconciliation Payments,Zahlung Versöhnung Zahlungen
Payment Type,Zahlungsart
Payment cannot be made for empty cart,Die Zahlung kann nicht für leere Korb gemacht werden
Payment of salary for the month {0} and year {1},Die Zahlung der Gehälter für den Monat {0} und {1} Jahre
Payments,Zahlungen
Payments Made,Getätigte Zahlungen
Payments Received,Erhaltene Zahlungen
Payments made during the digest period,Während des Berichtszeitraums vorgenommene Zahlungen
Payments received during the digest period,Während des Berichtszeitraums erhaltene Zahlungen
Payroll Settings,Payroll -Einstellungen
Pending,Ausstehend
Pending Amount,Bis Betrag
Pending Items {0} updated,Ausstehende Elemente {0} aktualisiert
Pending Review,Wartet auf Bewertung
Pending SO Items For Purchase Request,SO-Artikel stehen für Einkaufsanforderung aus
Pension Funds,Pensionsfonds
Percentage Allocation,Prozentuale Aufteilung
Percentage Allocation should be equal to 100%,Prozentuale Aufteilung sollte gleich 100%
Percentage variation in quantity to be allowed while receiving or delivering this item.,"Prozentuale Abweichung in der Menge, die beim Empfang oder bei der Lieferung dieses Artikels zulässig ist."
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.,"Zusätzlich zur bestellten Menge zulässiger Prozentsatz, der empfangen oder geliefert werden kann. Zum Beispiel: Wenn Sie 100 Einheiten bestellt haben und Ihre Spanne beträgt 10 %, dann können Sie 110 Einheiten empfangen."
Performance appraisal.,Mitarbeiterbeurteilung
Period,Zeit
Period Closing Entry,Zeitraum Abschluss Eintrag
Period Closing Voucher,Zeitraum Abschluss Gutschein
Period From and Period To dates mandatory for recurring %s,Zeitraum von und Zeitraum bis sind notwendig bei wiederkehrendem Eintrag %s
Periodicity,Periodizität
Permanent Address,Dauerhafte Adresse
Permanent Address Is,Permanent -Adresse ist
Permission,Berechtigung
Personal,Persönlich
Personal Details,Persönliche Daten
Personal Email,Persönliche E-Mail
Pharmaceutical,pharmazeutisch
Pharmaceuticals,Pharmaceuticals
Phone,Telefon
Phone No,Telefonnummer
Piecework,Akkordarbeit
Pincode,Pincode
Place of Issue,Ausstellungsort
Plan for maintenance visits.,Wartungsbesuche planen
Planned Qty,Geplante Menge
"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Geplante Menge: Menge, für die Fertigungsaufträge ausgelöst wurden, aber noch hergestellt wurden."
Planned Quantity,Geplante Menge
Planning,Planung
Plant,Fabrik
Plant and Machinery,Anlagen und Maschinen
Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,"Geben Sie das Kürzel oder den Kurznamen richtig ein, weil dieser als Suffix allen Kontenführern hinzugefügt wird."
Please Update SMS Settings,Bitte aktualisiere SMS-Einstellungen
Please add expense voucher details,Bitte fügen Sie Kosten Gutschein Details
Please add to Modes of Payment from Setup.,Bitte um Zahlungsmodalitäten legen aus einrichten.
Please check 'Is Advance' against Account {0} if this is an advance entry.,"Bitte prüfen Sie 'Ist Vorkasse' zu Konto {0}, wenn dies ein Vorkassen-Eintrag ist."
Please click on 'Generate Schedule',"Bitte klicken Sie auf ""Zeitplan generieren"""
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Bitte klicken Sie auf ""Zeitplan generieren"" die Seriennummer für Artikel {0} hinzuzufügen"
Please click on 'Generate Schedule' to get schedule,"Bitte klicken Sie auf ""Zeitplan generieren"" um den Zeitplan zu bekommen"
Please create Customer from Lead {0},Bitte erstellen Sie einen Kunden aus dem Interessent {0}
Please create Salary Structure for employee {0},Legen Sie bitte Gehaltsstruktur für Mitarbeiter {0}
Please create new account from Chart of Accounts.,Bitte neues Konto erstellen von Kontenübersicht.
Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Bitte keine Konten (Buchungsbelege) für Kunden und Lieferanten erstellen. Diese werden direkt von den Kunden-/Lieferanten-Stammdaten aus erstellt.
Please enter 'Expected Delivery Date',"Bitte geben Sie den ""voraussichtlichen Liefertermin"" ein"
Please enter 'Is Subcontracted' as Yes or No,"Bitte geben Sie Untervergabe"""" als Ja oder Nein ein"""
Please enter 'Repeat on Day of Month' field value,"Bitte geben Sie ""Wiederholung am Tag des Monats"" als Feldwert ein"
Please enter Account Receivable/Payable group in company master,Bitte geben Sie Debitoren / Kreditorengruppein der Firma Master
Please enter Approving Role or Approving User,Bitte geben Sie die Genehmigung von Rolle oder Genehmigung Benutzer
Please enter BOM for Item {0} at row {1},Bitte geben Sie Stückliste für Artikel {0} in Zeile {1}
Please enter Company,Bitte geben Sie Firmen
Please enter Cost Center,Bitte geben Sie Kostenstelle
Please enter Delivery Note No or Sales Invoice No to proceed,"Geben Sie die Lieferschein- oder die Ausgangsrechnungs-Nr ein, um fortzufahren"
Please enter Employee Id of this sales parson,Bitte geben Sie die Mitarbeiter-ID dieses Verkaufs Pfarrer
Please enter Expense Account,Geben Sie das Aufwandskonto ein
Please enter Item Code to get batch no,Bitte geben Sie Artikel-Code zu Charge nicht bekommen
Please enter Item Code.,Bitte geben Sie die Artikel-Nummer ein.
Please enter Item first,Bitte geben Sie zuerst Artikel
Please enter Maintaince Details first,Bitte geben Sie Maintaince Einzelheiten ersten
Please enter Master Name once the account is created.,Bitte geben Sie den Hauptmamen ein sobald das Konto angelegt wurde.
Please enter Planned Qty for Item {0} at row {1},Bitte geben Sie Geplante Menge für Artikel {0} in Zeile {1}
Please enter Production Item first,Bitte geben Sie zuerst Herstellungs Artikel
Please enter Purchase Receipt No to proceed,"Geben Sie 'Eingangslieferschein-Nr.' ein, um fortzufahren"
Please enter Purchase Receipt first,erfassen Sie zuerst den Eingangslieferschein
Please enter Purchase Receipts,Erfassen Sie die Eingangslieferscheine
Please enter Reference date,Bitte geben Sie Stichtag
Please enter Taxes and Charges,Erfassen Sie die Steuern und Abgaben
Please enter Warehouse for which Material Request will be raised,Bitte geben Sie für die Warehouse -Material anfordern wird angehoben
Please enter Write Off Account,Bitte geben Sie Write Off Konto
Please enter atleast 1 invoice in the table,Bitte geben Sie atleast 1 Rechnung in der Tabelle
Please enter company first,Bitte geben Sie Unternehmen zunächst
Please enter company name first,Bitte geben erste Firmennamen
Please enter default Unit of Measure,Bitte geben Sie Standard Maßeinheit
Please enter default currency in Company Master,Bitte geben Sie die Standardwährung in Firmen Meister
Please enter email address,Bitte geben Sie eine E-Mail-Adresse an
Please enter item details,Bitte geben Sie Artikel-Details an
Please enter message before sending,Bitte geben Sie eine Nachricht vor dem Versenden ein
Please enter parent account group for warehouse {0},Bitte geben Sie die Stammkontengruppe für das Lager {0} an
Please enter parent cost center,Bitte geben Sie Mutterkostenstelle
Please enter quantity for Item {0},Bitte geben Sie Menge für Artikel {0}
Please enter relieving date.,Bitte geben Sie Linderung Datum.
Please enter sales order in the above table,Bitte geben Sie den Kundenauftrag in der obigen Tabelle an
Please enter valid Company Email,Bitte geben Sie eine gültige E-Mail- Gesellschaft
Please enter valid Email Id,Bitte geben Sie eine gültige E-Mail -ID
Please enter valid Personal Email,Bitte geben Sie eine gültige E-Mail- Personal
Please enter valid mobile nos,Bitte geben Sie eine gültige Mobil nos
Please find attached {0} #{1},Bitte nehmen Sie den Anhang {0} #{1} zur Kenntnis
Please install dropbox python module,Installieren Sie das Dropbox Python-Modul
Please mention no of visits required,Bitte erwähnen Sie keine Besuche erforderlich
Please pull items from Delivery Note,Bitte nehmen Sie die Artikel aus dem Lieferschein
Please save the Newsletter before sending,Bitte speichern Sie den Newsletter vor dem Senden
Please save the document before generating maintenance schedule,Bitte speichern Sie das Dokument vor dem Speichern des Wartungsplans
Please see attachment,siehe Anhang
Please select Bank Account,Wählen Sie ein Bankkonto aus
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Klicken Sie auf 'Übertragen', wenn Sie auch die Bilanz des vorangegangenen Geschäftsjahrs in dieses Geschäftsjahr einbeziehen möchten."
Please select Category first,Bitte wählen Sie zuerst Kategorie
Please select Charge Type first,Bitte wählen Sie zunächst Ladungstyp
Please select Fiscal Year,Bitte wählen Geschäftsjahr
Please select Group or Ledger value,Bitte wählen Sie Gruppen-oder Buchwert
Please select Incharge Person's name,Bitte wählen Sie Incharge Person Name
Please select Invoice Type and Invoice Number in atleast one row,Bitte wählen Sie Rechnungstyp und Rechnungsnummer in einer Zeile atleast
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Bitte wählen Sie den Artikel, bei dem ""Ist Lageratikel"" ""Nein"" ist und ""Ist Verkaufsartikel ""Ja"" ist und es keine andere Vertriebsstückliste gibt"
Please select Price List,Wählen Sie eine Preisliste aus
Please select Start Date and End Date for Item {0},Bitte wählen Sie Start -und Enddatum für den Posten {0}
Please select Time Logs.,Wählen Sie Zeitprotokolle aus.
Please select a csv file,Wählen Sie eine CSV-Datei aus.
Please select a valid csv file with data,Bitte wählen Sie eine gültige CSV-Datei mit Daten
Please select a value for {0} quotation_to {1},Bitte wählen Sie einen Wert für {0} {1} quotation_to
"Please select an ""Image"" first","Bitte wählen Sie einen ""Bild"" erste"
Please select charge type first,Bitte wählen Sie zunächst Ladungstyp
Please select company first,Bitte wählen Unternehmen zunächst
Please select company first.,Bitte wählen zuerst die Firma aus.
Please select item code,Bitte wählen Sie Artikel Code
Please select month and year,Wählen Sie Monat und Jahr aus
Please select prefix first,Bitte wählen Sie zunächst Präfix
Please select the document type first,Wählen Sie zuerst den Dokumententyp aus
Please select weekly off day,Bitte wählen Sie Wochen schlechten Tag
Please select {0},Bitte wählen Sie {0}
Please select {0} first,Bitte wählen Sie {0} zuerst
Please select {0} first.,Bitte wählen Sie {0} zuerst.
Please set Dropbox access keys in your site config,Bitte setzen Dropbox Zugriffstasten auf Ihrer Website Config
Please set Google Drive access keys in {0},Bitte setzen Google Drive Zugriffstasten in {0}
Please set default Cash or Bank account in Mode of Payment {0},Bitte setzen Standard Bargeld oder Bank- Konto in Zahlungsmodus {0}
Please set default value {0} in Company {0},Bitte setzen Standardwert {0} in Gesellschaft {0}
Please set {0},Bitte setzen Sie {0}
Please setup Employee Naming System in Human Resource > HR Settings,Richten Sie das Mitarbeiterbenennungssystem unter Personalwesen > HR-Einstellungen ein
Please setup numbering series for Attendance via Setup > Numbering Series,Bitte Setup Nummerierungsserie für Besucher über Setup> Nummerierung Serie
Please setup your POS Preferences,Bitte richten Sie zunächst die POS-Einstellungen ein
Please setup your chart of accounts before you start Accounting Entries,"Bitte richten Sie zunächst Ihre Kontenbuchhaltung ein, bevor Sie Einträge vornehmen"
Please specify,Geben Sie Folgendes an
Please specify Company,Geben Sie das Unternehmen an
Please specify Company to proceed,"Geben Sie das Unternehmen an, um fortzufahren"
Please specify Default Currency in Company Master and Global Defaults,Bitte geben Sie Standardwährung in Unternehmen und Global Master- Defaults
Please specify a,Legen Sie Folgendes fest
Please specify a valid 'From Case No.',Geben Sie eine gültige 'Von Fall Nr.' an
Please specify a valid Row ID for {0} in row {1},Bitte geben Sie eine gültige Zeilen-ID für {0} in Zeile {1}
Please specify either Quantity or Valuation Rate or both,Bitte geben Sie entweder Menge oder Bewertungs bewerten oder beide
Please submit to update Leave Balance.,"Bitte reichen Sie zu verlassen, Bilanz zu aktualisieren."
Plot,Grundstück
Plot By,Grundstück von
Point of Sale,Verkaufsstelle
Point-of-Sale Setting,Verkaufsstellen-Einstellung
Post Graduate,Graduiert
Postal,Post
Postal Expenses,Post Aufwendungen
Posting Date,Buchungsdatum
Posting Time,Buchungszeit
Posting date and posting time is mandatory,Buchungsdatum und Buchungszeit ist obligatorisch
Posting timestamp must be after {0},Buchungszeitmarkemuss nach {0}
Potential Sales Deal,Mögliches Umsatzgeschäft
Potential opportunities for selling.,Mögliche Gelegenheiten für den Vertrieb.
Preferred Billing Address,Bevorzugte Rechnungsadresse
Preferred Shipping Address,Bevorzugte Lieferadresse
Prefix,Präfix
Present,Gegenwart
Prevdoc DocType,Dokumententyp Prevdoc
Prevdoc Doctype,Dokumententyp Prevdoc
Preview,Vorschau
Previous,zurück
Previous Work Experience,Vorherige Berufserfahrung
Price,Preis
Price / Discount,Preis / Rabatt
Price List,Preisliste
Price List Currency,Preislistenwährung
Price List Currency not selected,Preisliste Währung nicht ausgewählt
Price List Exchange Rate,Preisliste Wechselkurs
Price List Master,Preislistenstamm
Price List Name,Preislistenname
Price List Rate,Preislistenrate
Price List Rate (Company Currency),Preislisten-Preis (Unternehmenswährung)
Price List master.,Preisliste Master.
Price List must be applicable for Buying or Selling,Preisliste muss für Einkauf oder Vertrieb gültig sein
Price List not selected,Preisliste nicht ausgewählt
Price List {0} is disabled,Preisliste {0} ist deaktiviert
Price or Discount,Preis -oder Rabatt-
Pricing Rule,Preisregel
Pricing Rule Help,Pricing Rule Hilfe
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Pricing-Regel wird zunächst basierend auf 'Anwenden auf' Feld, die Artikel, Artikelgruppe oder Marke sein kann, ausgewählt."
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Pricing-Regel gemacht wird, überschreiben Preisliste / Rabattsatz definieren, nach bestimmten Kriterien."
Pricing Rules are further filtered based on quantity.,Preisregeln sind weiter auf Quantität gefiltert.
Print Format Style,Druckformatstil
Print Heading,Überschrift drucken
Print Without Amount,Drucken ohne Betrag
Print and Stationary,Print-und Schreibwaren
Printing and Branding,Druck-und Branding-
Priority,Priorität
Private,Privat
Private Equity,Private Equity
Privilege Leave,Privilege Leave
Probation,Bewährung
Process Payroll,Gehaltsabrechnung bearbeiten
Produced,produziert
Produced Quantity,Produzierte Menge
Product Enquiry,Produktanfrage
Production,Produktion
Production Order,Fertigungsauftrag
Production Order status is {0},Status des Fertigungsauftrags lautet {0}
Production Order {0} must be cancelled before cancelling this Sales Order,Fertigungsauftrag {0} muss vor Stornierung dieses Kundenauftages storniert werden
Production Order {0} must be submitted,Fertigungsauftrag {0} muss eingereicht werden
Production Orders,Fertigungsaufträge
Production Orders in Progress,Fertigungsaufträge in Arbeit
Production Plan Item,Produktionsplan Artikel
Production Plan Items,Produktionsplan Artikel
Production Plan Sales Order,Produktionsplan Kundenauftrag
Production Plan Sales Orders,Produktionsplan Kundentaufträge
Production Planning Tool,Produktionsplanungstool
Products,Produkte
"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Die Produkte werden bei der Standardsuche nach Gewicht-Alter sortiert. Je höher das Gewicht-Alter, desto weiter oben wird das Produkt in der Liste angezeigt."
Professional Tax,Professionelle Steuer
Profit and Loss,Gewinn-und Verlust
Profit and Loss Statement,Gewinn-und Verlustrechnung
Project,Projekt
Project Costing,Projektkalkulation
Project Details,Projektdetails
Project Manager,Projektleiter
Project Milestone,Meilenstein
Project Milestones,Meilensteine
Project Name,Projektname
Project Start Date,Projektstartdatum
Project Type,Projekttyp
Project Value,Projektwert
Project activity / task.,Projektaktivität/Aufgabe
Project master.,Projektstamm
Project will get saved and will be searchable with project name given,Projekt wird gespeichert und kann unter dem Projektnamen durchsucht werden
Project wise Stock Tracking,Projektweise Lagerbestandsverfolgung
Project-wise data is not available for Quotation,Daten des Projekts sind für das Angebot nicht verfügbar
Projected,projektiert
Projected Qty,Projektspezifische Menge
Projects,Projekte
Projects & System,Projekte & System
Projects Manager,Projekte Verantwortlicher
Projects User,Projekte Mitarbeiter
Prompt for Email on Submission of,Eingabeaufforderung per E-Mail bei Einreichung von
Proposal Writing,Proposal Writing
Provide email id registered in company,Geben Sie die im Unternehmen registrierte E-Mail an
Provisional Profit / Loss (Credit),Vorläufige Gewinn / Verlust (Kredit)
Public,Öffentlich
Published on website at: {0},Veröffentlicht auf der Website unter: {0}
Publishing,Herausgabe
Pull sales orders (pending to deliver) based on the above criteria,Aufträge (deren Lieferung aussteht) entsprechend der oben genannten Kriterien ziehen
Purchase,Einkauf
Purchase / Manufacture Details,Kauf / Herstellung Einzelheiten
Purchase Analytics,Einkaufsanalyse
Purchase Common,Einkauf Allgemein
Purchase Details,Kaufinformationen
Purchase Discounts,Einkaufsrabatte
Purchase Invoice,Eingangsrechnung
Purchase Invoice Advance,Eingangsrechnung Vorkasse
Purchase Invoice Advances,Eingangsrechnung Vorkasse
Purchase Invoice Item,Eingangsrechnung Artikel
Purchase Invoice Trends,Eingangsrechnung Trends
Purchase Invoice {0} is already submitted,Eingangsrechnung {0} ist bereits eingereicht
Purchase Item,Einkaufsartikel
Purchase Manager,Einkaf Verantwortlicher
Purchase Master Manager,Einkauf Hauptverantwortlicher
Purchase Order,Lieferatenauftrag
Purchase Order Item,Lieferatenauftrag Artikel
Purchase Order Item No,Lieferatenauftrag Artikel-Nr.
Purchase Order Item Supplied,Lieferatenauftrag Artikel geliefert
Purchase Order Items,Lieferatenauftrag Artikel
Purchase Order Items Supplied,Lieferatenauftrag Artikel geliefert
Purchase Order Items To Be Billed,Abzurechnende Lieferatenauftrags-Artikel
Purchase Order Items To Be Received,Eingehende Lieferatenauftrags-Artikel
Purchase Order Message,Lieferatenauftrag Nachricht
Purchase Order Required,Lieferatenauftrag erforderlich
Purchase Order Trends,Lieferatenauftrag Trends
Purchase Order number required for Item {0},Lieferatenauftragsnummer ist für den Artikel {0} erforderlich
Purchase Order {0} is 'Stopped',Lieferatenauftrag {0} wurde 'angehalten'
Purchase Order {0} is not submitted,Lieferatenauftrag {0} wurde nicht eingereicht
Purchase Orders given to Suppliers.,An Lieferanten weitergegebene Lieferatenaufträge.
Purchase Receipt,Eingangslieferschein
Purchase Receipt Item,Eingangslieferschein Artikel
Purchase Receipt Item Supplied,Eingangslieferschein Artikel geliefert
Purchase Receipt Item Supplieds,Eingangslieferschein Artikel geliefert
Purchase Receipt Items,Eingangslieferschein Artikel
Purchase Receipt Message,Eingangslieferschein Nachricht
Purchase Receipt No,Eingangslieferschein Nr.
Purchase Receipt Required,Eingangslieferschein notwendig
Purchase Receipt Trends,Eingangslieferschein Trends
Purchase Receipt must be submitted,Eingangslieferscheine müssen eingereicht werden
Purchase Receipt number required for Item {0},Eingangslieferschein-Nr ist für Artikel {0} erforderlich
Purchase Receipt {0} is not submitted,Eingangslieferschein {0} wurde nicht eingereicht
Purchase Receipts,Eingangslieferscheine
Purchase Register,Einkaufsregister
Purchase Return,Warenrücksendung
Purchase Returned,Zurückgegebene Ware
Purchase Taxes and Charges,Einkauf Steuern und Abgaben
Purchase Taxes and Charges Master,Einkaufssteuern und Abgabenstamm
Purchase User,Einkauf Mitarbeiter
Purchse Order number required for Item {0},Lieferantenbestellnummer ist für Artikel {0} erforderlich
Purpose,Zweck
Purpose must be one of {0},Zweck muss einer von diesen sein: {0}
QA Inspection,QA-Inspektion
Qty,Menge
Qty Consumed Per Unit,Verbrauchte Menge pro Einheit
Qty To Manufacture,Herzustellende Menge
Qty as per Stock UOM,Menge nach Lager-ME
Qty to Deliver,Menge zu liefern
Qty to Order,Menge zu bestellen
Qty to Receive,Menge zu erhalten
Qty to Transfer,Menge zu versenden
Qualification,Qualifikation
Quality,Qualität
Quality Inspection,Qualitätsprüfung
Quality Inspection Parameters,Qualitätsprüfungsparameter
Quality Inspection Reading,Qualitätsprüfung Ablesen
Quality Inspection Readings,Qualitätsprüfung Ablesungen
Quality Inspection required for Item {0},Qualitätsprüfung für den Posten erforderlich {0}
Quality Management,Qualitätsmanagement
Quality Manager,Qualitätsbeauftragter
Quantity,Menge
Quantity Requested for Purchase,Erforderliche Bestellmenge
Quantity and Rate,Menge und Preis
Quantity and Warehouse,Menge und Lager
Quantity cannot be a fraction in row {0},Menge kann nicht ein Bruchteil in Zeile {0}
Quantity for Item {0} must be less than {1},Menge Artikel für {0} muss kleiner sein als {1}
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Menge in Zeile {0} ( {1}) muss die gleiche sein wie hergestellte Menge {2}
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Menge eines Artikels nach der Herstellung / Menge durch Umpacken von bestimmten Mengen an Rohstoffen
Quantity required for Item {0} in row {1},Menge Artikel für erforderlich {0} in Zeile {1}
Quarter,Quartal
Quarterly,Quartalsweise
Quick Help,Schnellinfo
Quotation,Angebot
Quotation Item,Angebotsposition
Quotation Items,Angebotspositionen
Quotation Lost Reason,Angebot verloren - Grund
Quotation Message,Angebotsnachricht
Quotation To,Angebot für
Quotation Trends,Angebot Trends
Quotation {0} is cancelled,Angebot {0} wird abgebrochen
Quotation {0} not of type {1},Angebot {0} nicht vom Typ {1}
Quotations received from Suppliers.,Angebote von Lieferanten
Quotes to Leads or Customers.,Angebote an Interessenten oder Kunden.
Raise Material Request when stock reaches re-order level,"Materialanfrage erstellen, wenn der Lagerbestand unter einen Wert sinkt"
Raised By,Gemeldet von
Raised By (Email),Gemeldet von (E-Mail)
Random,Zufällig
Range,Bandbreite
Rate,Rate
Rate ,Rate
Rate (%),Satz ( %)
Rate (Company Currency),Satz (Firmen Währung)
Rate Of Materials Based On,Rate der zu Grunde liegenden Materialien
Rate and Amount,Kurs und Menge
Rate at which Customer Currency is converted to customer's base currency,"Kurs, zu dem die Kundenwährung in die Basiswährung des Kunden umgerechnet wird"
Rate at which Price list currency is converted to company's base currency,"Kurs, zu dem die Preislistenwährung in die Basiswährung des Unternehmens umgerechnet wird"
Rate at which Price list currency is converted to customer's base currency,"Kurs, zu dem die Preislistenwährung in die Basiswährung des Kunden umgerechnet wird"
Rate at which customer's currency is converted to company's base currency,"Kurs, zu dem die Kundenwährung in die Basiswährung des Kunden umgerechnet wird"
Rate at which supplier's currency is converted to company's base currency,"Kurs, zu dem die Lieferantenwährung in die Basiswährung des Unternehmens umgerechnet wird"
Rate at which this tax is applied,"Kurs, zu dem dieser Steuersatz angewendet wird"
Raw Material,Rohstoff
Raw Material Item Code,Artikel-Nr Rohstoffe
Raw Materials Supplied,Gelieferte Rohstoffe
Raw Materials Supplied Cost,Kosten gelieferter Rohstoffe
Raw material cannot be same as main Item,Raw Material nicht wie Haupt Titel
Re-Order Level,Nachbestellungsebene
Re-Order Qty,Nachbestellungsmenge
Re-order,Nachbestellung
Re-order Level,Nachbestellungsebene
Re-order Qty,Nachbestellungsmenge
Read,Lesen
Reading 1,Ablesung 1
Reading 10,Ablesung 10
Reading 2,Ablesung 2
Reading 3,Ablesung 3
Reading 4,Ablesung 4
Reading 5,Ablesung 5
Reading 6,Ablesung 6
Reading 7,Ablesung 7
Reading 8,Ablesung 8
Reading 9,Ablesung 9
Real Estate,Immobilien
Reason,Grund
Reason for Leaving,Grund für das Verlassen
Reason for Resignation,Grund für Rücktritt
Reason for losing,Grund für den Verlust
Recd Quantity,Zurückgegebene Menge
Receivable,Forderung
Receivable / Payable account will be identified based on the field Master Type,Debitoren-/Kreditorenkonto wird auf der Grundlage des Feld-Stammtyps identifiziert
Receivables,Forderungen
Receivables / Payables,Forderungen / Verbindlichkeiten
Receivables Group,Forderungen-Gruppe
Received,Erhalten
Received Date,Empfangsdatum
Received Items To Be Billed,"Empfangene Artikel, die in Rechnung gestellt werden"
Received Qty,Empfangene Menge
Received and Accepted,Erhalten und akzeptiert
Receiver List,Empfängerliste
Receiver List is empty. Please create Receiver List,Empfängerliste ist leer. Bitte erstellen Sie Empfängerliste
Receiver Parameter,Empfängerparameter
Recipients,Empfänger
Reconcile,versöhnen
Reconciliation Data,Tilgungsdatum
Reconciliation HTML,Tilgung HTML
Reconciliation JSON,Tilgung JSON
Record item movement.,Verschiebung Datenposition
Recurring Id,Wiederkehrende ID
Recurring Invoice,Wiederkehrende Rechnung
Recurring Order,sich Wiederholende Bestellung
Recurring Type,Wiederkehrender Typ
Reduce Deduction for Leave Without Pay (LWP),Abzug für unbezahlten Urlaub (LWP) senken
Reduce Earning for Leave Without Pay (LWP),Verdienst für unbezahlten Urlaub (LWP) senken
Ref,Ref.
Ref Code,Ref-Code
Ref SQ,Ref-SQ
Reference,Referenz
Reference #{0} dated {1},Referenz # {0} vom {1}
Reference Date,Referenzdatum
Reference Name,Referenzname
Reference No & Reference Date is required for {0},Referenz Nr & Stichtag ist erforderlich für {0}
Reference No is mandatory if you entered Reference Date,"Referenznummer ist obligatorisch, wenn Sie Stichtag eingegeben"
Reference Number,Referenznummer
Reference Row #,Referenz Row #
Refresh,aktualisieren
Registration Details,Details zur Anmeldung
Registration Info,Anmeldungsinfo
Rejected,Abgelehnt
Rejected Quantity,Abgelehnte Menge
Rejected Serial No,Abgelehnte Seriennummer
Rejected Warehouse,Abgelehntes Warenlager
Rejected Warehouse is mandatory against regected item,Abgelehnt Warehouse ist obligatorisch gegen regected Artikel
Relation,Beziehung
Relieving Date,Ablösedatum
Relieving Date must be greater than Date of Joining,Entlastung Datum muss größer sein als Datum für Füge sein
Remark,Bemerkung
Remarks,Bemerkungen
Remove item if charges is not applicable to that item,"Artikel entfernen, wenn keine Gebühren angerechtet werden können"
Rename,umbenennen
Rename Log,Protokoll umbenennen
Rename Tool,Tool umbenennen
Rent Cost,Mieten Kosten
Rent per hour,Miete pro Stunde
Rented,Gemietet
Repeat on Day of Month,Wiederholen am Tag des Monats
Replace,Ersetzen
Replace Item / BOM in all BOMs,Artikel/Stückliste in allen Stücklisten ersetzen
"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM","Eine bestimmte Stückliste in allen anderen Stücklisten austauschen, in denen sie eingesetzt. Ersetzt den alten Stücklisten-Link, aktualisiert Kosten und erstellt die Tabelle ""Stücklistenerweiterung Artikel"" nach der neuen Stückliste"
Replied,Beantwortet
Report Date,Berichtsdatum
Report Type,Berichtstyp
Report Type is mandatory,Berichtstyp ist verpflichtend
Reports to,Berichte an
Reqd By Date,Reqd nach Datum
Reqd by Date,Reqd nach Datum
Request Type,Anfragetyp
Request for Information,Informationsanfrage
Request for purchase.,Einkaufsanfrage
Requested,Angeforderte
Requested For,Für Anfrage
Requested Items To Be Ordered,"Angeforderte Artikel, die bestellt werden sollen"
Requested Items To Be Transferred,"Angeforderte Artikel, die übertragen werden sollen"
Requested Qty,Angeforderte Menge
"Requested Qty: Quantity requested for purchase, but not ordered.","Angeforderte Menge : Menge durch einen Verkauf benötigt, aber nicht bestellt."
Requests for items.,Artikelanfragen
Required By,Erforderlich nach
Required Date,Erforderliches Datum
Required Qty,Erforderliche Anzahl
Required only for sample item.,Nur erforderlich für Probenartikel.
Required raw materials issued to the supplier for producing a sub - contracted item.,"Erforderliche Rohstoffe, die an den Zulieferer zur Herstellung eines beauftragten Artikels ausgeliefert wurden."
Research,Forschung
Research & Development,Forschung & Entwicklung
Researcher,Forscher
Reseller,Wiederverkäufer
Reserved,reserviert
Reserved Qty,reservierte Menge
"Reserved Qty: Quantity ordered for sale, but not delivered.","Reservierte Menge: Für den Verkauf bestellte Menge, aber noch nicht geliefert."
Reserved Quantity,Reservierte Menge
Reserved Warehouse,Reserviertes Warenlager
Reserved Warehouse in Sales Order / Finished Goods Warehouse,Reservierte Ware im Lager aus Kundenaufträgen / Fertigwarenlager
Reserved Warehouse is missing in Sales Order,Reservierendes Lager fehlt in Kundenauftrag
Reserved Warehouse required for stock Item {0} in row {1},Reserviert Lagerhaus Lager Artikel erforderlich {0} in Zeile {1}
Reserved warehouse required for stock item {0},Reserviert Lager für Lagerware erforderlich {0}
Reserves and Surplus,Rücklagen und Überschüsse
Reset Filters,Filter zurücksetzen
Resignation Letter Date,Kündigungsschreiben Datum
Resolution,Auflösung
Resolution Date,Auflösung Datum
Resolution Details,Auflösungsdetails
Resolved By,Gelöst von
Rest Of The World,Rest der Welt
Retail,Einzelhandel
Retail & Wholesale,Retail & Wholesale
Retailer,Einzelhändler
Review Date,Bewertung
Rgt,re
Role Allowed to edit frozen stock,Rolle darf eingefrorenen Bestand bearbeiten
Role that is allowed to submit transactions that exceed credit limits set.,"Rolle darf Transaktionen einreichen, die das gesetzte Kreditlimit überschreiten."
Root Type,root- Typ
Root Type is mandatory,Root- Typ ist obligatorisch
Root account can not be deleted,Haupt-Konto kann nicht gelöscht werden
Root cannot be edited.,Haupt-Konto kann nicht bearbeitet werden.
Root cannot have a parent cost center,Stamm darf keine übergeordnete Kostenstelle haben
Rounded Off,abgerundet
Rounded Total,Abgerundete Gesamtsumme
Rounded Total (Company Currency),Abgerundete Gesamtsumme (Unternehmenswährung)
Row # ,Zeile #
Row # {0}: ,Zeile # {0}:
Row #{0}: Please specify Serial No for Item {1},Row # {0}: Bitte Seriennummer für Artikel {1}
Row {0}: Account does not match with \						Purchase Invoice Credit To account,Zeile {0}: Konto stimmt nicht mit Eingangsrechnungswert überein
Row {0}: Account does not match with \						Sales Invoice Debit To account,Zeile {0}: Konto stimmt nicht mit Ausgangsrechnungsbetrag überein
Row {0}: Conversion Factor is mandatory,Row {0}: Umrechnungsfaktor ist obligatorisch
Row {0}: Credit entry can not be linked with a Purchase Invoice,Row {0} : Kredit Eintrag kann nicht mit einer Eingangsrechnung verknüpft werden
Row {0}: Debit entry can not be linked with a Sales Invoice,Zeile {0}: Debit-Eintrag kann nicht mit einer Ausgangsrechnung verknüpft werden
Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Row {0}: Zahlungsbetrag muss kleiner als oder gleich zu ausstehenden Betrag in Rechnung stellen können. Bitte beachten Sie folgenden Hinweis.
Row {0}: Qty is mandatory,Row {0}: Menge ist obligatorisch
"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.					Available Qty: {4}, Transfer Qty: {5}",
"Row {0}: To set {1} periodicity, difference between from and to date \						must be greater than or equal to {2}",Zeile {0}: Um {1} als wiederholend zu setzen muss der Unterschied zwischen von und bis Datum größer oder gleich {2} sein
Row {0}:Start Date must be before End Date,Row {0}: Startdatum muss vor dem Enddatum liegen
Rules for adding shipping costs.,Regeln für das Hinzufügen von Versandkosten.
Rules for applying pricing and discount.,Regeln für die Anwendung von Preis und Rabatt.
Rules to calculate shipping amount for a sale,Regeln zum Berechnen des Versandbetrags für einen Verkauf
S.O. No.,Lieferantenbestellung Nein.
SHE Cess on Excise,SHE Cess Verbrauch
SHE Cess on Service Tax,SHE Cess auf Service Steuer
SHE Cess on TDS,SHE Cess auf TDS
SMS Center,SMS-Center
SMS Gateway URL,SMS-Gateway-URL
SMS Log,SMS-Protokoll
SMS Parameter,SMS-Parameter
SMS Sender Name,SMS-Absendername
SMS Settings,SMS-Einstellungen
SO Date,SO-Datum
SO Pending Qty,SO Ausstehende Menge
SO Qty,SO Menge
Salary,Gehalt
Salary Information,Gehaltsinformationen
Salary Manager,Gehaltsmanager
Salary Mode,Gehaltsmodus
Salary Slip,Gehaltsabrechnung
Salary Slip Deduction,Gehaltsabrechnung Abzug
Salary Slip Earning,Gehaltsabrechnung Verdienst
Salary Slip of employee {0} already created for this month,Gehaltsabrechnung für Mitarbeiter {0} wurde bereits für diesen Monat erstellt
Salary Structure,Gehaltsstruktur
Salary Structure Deduction,Gehaltsstruktur Abzug
Salary Structure Earning,Gehaltsstruktur Verdienst
Salary Structure Earnings,Gehaltsstruktur Verdienst
Salary breakup based on Earning and Deduction.,Gehaltsaufteilung nach Verdienst und Abzug.
Salary components.,Gehaltskomponenten
Salary template master.,Gehalt Stammdaten.
Sales,Vertrieb
Sales Analytics,Vertriebsanalyse
Sales BOM,Verkaufsstückliste
Sales BOM Help,Verkaufsstückliste Hilfe
Sales BOM Item,Verkaufsstücklistenartikel
Sales BOM Items,Verkaufsstücklistenpositionen
Sales Browser,Verkauf Browser
Sales Details,Verkaufsdetails
Sales Discounts,Verkaufsrabatte
Sales Email Settings,Vertrieb E-Mail-Einstellungen
Sales Expenses,Vertriebskosten
Sales Extras,Verkauf Extras
Sales Funnel,Vertriebskanal
Sales Invoice,Ausgangsrechnung
Sales Invoice Advance,Ausgangsrechnung erweitert
Sales Invoice Item,Ausgangsrechnung Artikel
Sales Invoice Items,Ausgangsrechnung Artikel
Sales Invoice Message,Ausgangsrechnung Nachricht
Sales Invoice No,Ausgangsrechnungs-Nr.
Sales Invoice Trends,Ausgangsrechnung Trends
Sales Invoice {0} has already been submitted,Ausgangsrechnung {0} wurde bereits eingereicht
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Ausgangsrechnung {0} muss vor Streichung dieses Kundenauftrag storniert werden
Sales Item,Verkaufsartikel
Sales Manager,Vertriebsleiter
Sales Master Manager,Hauptvertriebsleiter
Sales Order,Kundenauftrag
Sales Order Date,Kundenauftrag Datum
Sales Order Item,Kundenauftrag Artikel
Sales Order Items,Kundenauftrag Artikel
Sales Order Message,Kundenauftrag Nachricht
Sales Order No,Kundenauftrag-Nr.
Sales Order Required,Kundenauftrag erforderlich
Sales Order Trends,Kundenauftrag Trends
Sales Order required for Item {0},Kundenauftrag für den Artikel {0} erforderlich
Sales Order {0} is not submitted,Kundenauftrag {0} wurde nicht eingereicht
Sales Order {0} is not valid,Kundenauftrag {0} ist nicht gültig
Sales Order {0} is stopped,Kundenauftrag {0} ist angehalten
Sales Partner,Vertriebspartner
Sales Partner Name,Vertriebspartner Name
Sales Partner Target,Vertriebspartner Ziel
Sales Partners Commission,Vertriebspartner-Kommission
Sales Person,Verkäufer
Sales Person Name,Vertriebsmitarbeiter Name
Sales Person Target Variance Item Group-Wise,Verkäufer Zielabweichung zu Artikel (gruppiert)
Sales Person Targets,Ziele für Vertriebsmitarbeiter
Sales Person-wise Transaction Summary,Vertriebsmitarbeiterweise Zusammenfassung der Transaktion
Sales Register,Vertriebsregister
Sales Return,Absatzertrag
Sales Returned,Verkaufszurück
Sales Taxes and Charges,Umsatzsteuern und Abgaben
Sales Taxes and Charges Master,Umsatzsteuern und Abgabenstamm
Sales Team,Verkaufsteam
Sales Team Details,Verkaufsteamdetails
Sales Team1,Verkaufsteam1
Sales User,Verkauf Mitarbeiter
Sales and Purchase,Vertrieb und Einkauf
Sales campaigns.,Vertriebskampagnen.
Salutation,Anrede
Sample Size,Stichprobenumfang
Sanctioned Amount,Sanktionierter Betrag
Saturday,Samstag
Schedule,Zeitplan
Schedule Date,Zeitplan Datum
Schedule Details,Zeitplandetails
Scheduled,Geplant
Scheduled Date,Geplantes Datum
Scheduled to send to {0},Geplant zum Versand an {0}
Scheduled to send to {0} recipients,Geplant zum Versand an {0} Empfänger
Scheduler Failed Events,Fehlgeschlagene Termine im Zeitplan
School/University,Schule/Universität
Score (0-5),Punktzahl (0-5)
Score Earned,Erreichte Punktzahl
Score must be less than or equal to 5,Punktzahl muß gleich 5 oder weniger sein
Scrap %,Ausschuss %
Seasonality for setting budgets.,Saisonalität für die Budgeterstellung.
Secretary,Sekretärin
Secured Loans,Secured Loans
Securities & Commodity Exchanges,Securities & Warenbörsen
Securities and Deposits,Wertpapiere und Einlagen
"See ""Rate Of Materials Based On"" in Costing Section",Siehe „Rate der zu Grunde liegenden Materialien“ im Abschnitt Kalkulation
"Select ""Yes"" for sub - contracting items",Wählen Sie „Ja“ für  Zulieferer-Artikel
"Select ""Yes"" if this item is used for some internal purpose in your company.","Wählen Sie „Ja“, wenn diese Position zu internen Zwecke in Ihrem Unternehmen verwendet wird."
"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Wählen Sie „Ja“, wenn diese Position Arbeit wie Schulung, Entwurf, Beratung usw. beinhaltet."
"Select ""Yes"" if you are maintaining stock of this item in your Inventory.","Wählen Sie „Ja“, wenn Sie den Bestand dieses Artikels in Ihrem Inventar verwalten."
"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.","Wählen Sie „Ja“, wenn Sie Rohstoffe an Ihren Lieferanten zur Herstellung dieses Artikels liefern."
Select Brand...,Marke auswählen...
Select Budget Distribution to unevenly distribute targets across months.,"Wählen Sie Budgetverteilung aus, um Ziele ungleichmäßig über Monate hinweg zu verteilen."
"Select Budget Distribution, if you want to track based on seasonality.","Wählen Sie Budgetverteilung, wenn Sie nach Saisonalität verfolgen möchten."
Select Company...,Firma auswählen...
Select DocType,Dokumenttyp auswählen
Select Fiscal Year...,Wählen Sie das Geschäftsjahr ...
Select Items,Artikel auswählen
Select Project...,Wählen Sie Projekt ...
Select Sales Orders,Kundenaufträge auswählen
Select Sales Orders from which you want to create Production Orders.,"Kundenaufträge auswählen, aus denen Sie Fertigungsaufträge erstellen möchten."
Select Time Logs and Submit to create a new Sales Invoice.,"Wählen Sie Zeitprotokolle und ""Absenden"" aus, um eine neue Ausgangsrechnung zu erstellen."
Select Transaction,Transaktion auswählen
Select Warehouse...,Lager auswählen...
Select Your Language,Wählen Sie Ihre Sprache
Select account head of the bank where cheque was deposited.,"Wählen Sie den Kontenführer der Bank, bei der der Scheck eingereicht wurde."
Select company name first.,Wählen Sie zuerst den Firmennamen aus.
Select template from which you want to get the Goals,"Wählen Sie eine Vorlage aus, von der Sie die Ziele abrufen möchten"
Select the Employee for whom you are creating the Appraisal.,"Wählen Sie den Mitarbeiter aus, für den Sie die Bewertung erstellen."
Select the period when the invoice will be generated automatically,"Wählen Sie den Zeitraum aus, zu dem die Rechnung automatisch erstellt werden soll."
Select the relevant company name if you have multiple companies,"Wählen Sie den entsprechenden Firmennamen aus, wenn mehrere Unternehmen vorhanden sind"
Select the relevant company name if you have multiple companies.,"Wählen Sie den entsprechenden Firmennamen aus, wenn mehrere Unternehmen vorhanden sind."
Select type of transaction,Transaktionstyp auswählen
Select who you want to send this newsletter to,"Wählen Sie aus, an wen dieser Newsletter gesendet werden soll"
Select your home country and check the timezone and currency.,Wählen Sie Ihr Land und überprüfen Sie die Zeitzone und Währung.
"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Wenn Sie „Ja“ auswählen, wird dieser Artikel in Lieferatenaufträgen und Eingangslieferscheinen angezeigt."
"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Wenn Sie „Ja“ auswählen, wird dieser Artikel in Kundenauftrag und Lieferschein angezeigt"
"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.","Wenn Sie „Ja“ auswählen, können Sie eine Materialliste erstellen, die Rohstoff- und Betriebskosten anzeigt, die bei der Herstellung dieses Artikels anfallen."
"Selecting ""Yes"" will allow you to make a Production Order for this item.","Wenn Sie „Ja“ auswählen, können Sie einen Fertigungsauftrag für diesen Artikel erstellen."
"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Wenn Sie „Ja“ auswählen, wird jeder Einheit dieses Artikels eine eindeutige Identität zugeteilt, die im Seriennummernstamm angezeigt werden kann."
Selling,Vertrieb
Selling Settings,Vertriebseinstellungen
"Selling must be checked, if Applicable For is selected as {0}","Vertrieb muss aktiviert werden, wenn ""Anwendbar auf"" ausgewählt ist bei {0}"
Send,Absenden
Send Autoreply,Autoreply absenden
Send Email,E-Mail absenden
Send From,Absenden von
Send Notifications To,Benachrichtigungen senden an
Send Now,Jetzt senden
Send SMS,SMS senden
Send To,Senden an
Send To Type,Senden an Typ
Send automatic emails to Contacts on Submitting transactions.,Beim Einreichen von Transaktionen automatische E-Mails an Kontakte senden.
Send mass SMS to your contacts,Massen-SMS an Ihre Kontakte senden
Send regular summary reports via Email.,Regelmäßig zusammenfassende Berichte per E-Mail senden.
Send to this list,An diese Liste senden
Sender Name,Absendername
Sent,verschickt
Sent On,Gesendet am
Separate production order will be created for each finished good item.,Separater Fertigungsauftrag wird für jeden fertigen Warenartikel erstellt.
Serial No,Seriennummer
Serial No / Batch,Seriennummer / Charge
Serial No Details,Details Seriennummer
Serial No Service Contract Expiry,Seriennummer am Ende des Wartungsvertrags
Serial No Status,Seriennr. Status
Serial No Warranty Expiry,Seriennr. Garantieverfall
Serial No is mandatory for Item {0},Seriennummer ist für Artikel {0} obligatorisch.
Serial No {0} created,Seriennummer {0} erstellt
Serial No {0} does not belong to Delivery Note {1},Seriennummer {0} gehört nicht zu Lieferschein {1}
Serial No {0} does not belong to Item {1},Seriennummer {0} gehört nicht zu Artikel {1}
Serial No {0} does not belong to Warehouse {1},Seriennummer {0} gehört nicht zu Lager {1}
Serial No {0} does not exist,Seriennummer {0} existiert nicht
Serial No {0} has already been received,Seriennummer {0} bereits erhalten
Serial No {0} is under maintenance contract upto {1},Seriennummer {0} ist unter Wartungsvertrag bis {1}
Serial No {0} is under warranty upto {1},Seriennummer {0} ist unter Garantie bis {1}
Serial No {0} not found,Seriennummer {0} wurde nicht gefunden
Serial No {0} not in stock,Seriennummer {0} ist nicht auf Lager
Serial No {0} quantity {1} cannot be a fraction,Seriennummer {0} mit Menge {1} kann nicht eine Teilmenge sein
Serial No {0} status must be 'Available' to Deliver,"Seriennummer {0} muss den Status ""verfügbar"" haben um ihn ausliefern zu können"
Serial Nos Required for Serialized Item {0},Seriennummern sind erforderlich für den Artikel mit Seriennummer {0}
Serial Number Series,Seriennummern Reihe
Serial number {0} entered more than once,Seriennummer {0} wurde bereits mehrfach erfasst
Serialized Item {0} cannot be updated \					using Stock Reconciliation,Artikel mit Seriennummer {0} kann nicht aktualisiert werden durch Lagerneubewertung
Series,Serie
Series List for this Transaction,Serienliste für diese Transaktion
Series Updated,Aktualisiert Serie
Series Updated Successfully,Serie erfolgreich aktualisiert
Series is mandatory,Serie ist obligatorisch
Series {0} already used in {1},Serie {0} bereits verwendet {1}
Service,Service
Service Address,Serviceadresse
Service Tax,Service Steuer
Services,Services
Set,Set
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Vorschlagswerte wie Unternehmen, Währung, aktuelles Geschäftsjahr usw. festlegen"
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Artikelgruppenweise Budgets in dieser Region erstellen. Durch Einrichten der Verteilung können Sie auch Saisonalität mit einbeziehen.
Set Status as Available,Set Status als Verfügbar
Set as Default,Als Standard setzen
Set as Lost,Als Verlust setzen
Set prefix for numbering series on your transactions,Präfix für die Seriennummerierung Ihrer Transaktionen festlegen
Set targets Item Group-wise for this Sales Person.,Ziele artikelgruppenweise für diesen Vertriebsmitarbeiter festlegen.
Setting Account Type helps in selecting this Account in transactions.,Das Festlegen des Kontotyps hilft bei der Auswahl dieses Kontos in Transaktionen.
Setting this Address Template as default as there is no other default,"Die Einstellung dieses Adressvorlage als Standard, da es keine anderen Standard"
Setting up...,Einrichten ...
Settings,Einstellungen
Settings for Accounts,Einstellungen für Konten
Settings for Buying Module,Einstellungen für Einkaufsmodul
Settings for HR Module,Einstellungen für das HR -Modul
Settings for Selling Module,Einstellungen für das Vertriebsmodul
"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""","Einstellungen, um Bewerber aus einem Postfach, z.B. ""jobs@example.com"", zu extrahieren."
Setup,Setup
Setup Already Complete!!,Bereits Komplett -Setup !
Setup Complete,Setup Complete
Setup SMS gateway settings,Setup-SMS-Gateway-Einstellungen
Setup Series,Setup-Reihenfolge
Setup Wizard,Setup-Assistenten
Setup incoming server for jobs email id. (e.g. jobs@example.com),Posteingangsserver für Jobs E-Mail-Adresse einrichten. (z.B. jobs@example.com)
Setup incoming server for sales email id. (e.g. sales@example.com),Posteingangsserver für den Vertrieb E-Mail-Adresse einrichten. (z.B. sales@example.com)
Setup incoming server for support email id. (e.g. support@example.com),Posteingangsserver für die Support E-Mail-Adresse einrichten. (z.B. support@example.com)
Share,Freigeben
Share With,Freigeben für
Shareholders Funds,Aktionäre Fonds
Shipments to customers.,Lieferungen an Kunden.
Shipping,Versand
Shipping Account,Versandkonto
Shipping Address,Versandadresse
Shipping Amount,Versandbetrag
Shipping Rule,Versandregel
Shipping Rule Condition,Versandbedingung
Shipping Rule Conditions,Versandbedingungen
Shipping Rule Label,Versandbedingungsetikett
Shop,Shop
Shopping Cart,Warenkorb
Short biography for website and other publications.,Kurzbiographie für die Website und andere Publikationen.
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Details zu ""Auf Lager"" oder ""Nicht auf Lager"" entsprechend des in diesem Warenlager verfügbaren Bestands anzeigen."
"Show / Hide features like Serial Nos, POS etc.","Funktionen wie Seriennummern, POS, etc. anzeigen / ausblenden"
Show In Website,Auf der Webseite anzeigen
Show a slideshow at the top of the page,Diaschau oben auf der Seite anzeigen
Show in Website,Auf der Webseite anzeigen
Show this slideshow at the top of the page,Diese Diaschau oben auf der Seite anzeigen
Show zero values,Nullwerte anzeigen
Shown in Website,Angezeigt auf Website
Sick Leave,krankheitsbedingte Abwesenheit
Signature,Unterschrift
Signature to be appended at the end of every email,"Signatur, die am Ende jeder E-Mail angehängt werden soll"
Single,Einzeln
Single unit of an Item.,Einzeleinheit eines Artikels.
Sit tight while your system is being setup. This may take a few moments.,"Bitte warten Sie, während Ihr System eingerichtet wird. Dies kann einige Zeit dauern."
Slideshow,Diaschau
Soap & Detergent,Soap & Reinigungsmittel
Software,Software
Software Developer,Software-Entwickler
"Sorry, Serial Nos cannot be merged","Sorry, Seriennummernkönnen nicht zusammengeführt werden,"
"Sorry, companies cannot be merged","Sorry, Unternehmen können nicht zusammengeführt werden"
Source,Quelle
Source File,Source File
Source Warehouse,Quellenwarenlager
Source and target warehouse cannot be same for row {0},Quell- und Ziel-Lager kann nicht gleich sein für die Zeile {0}
Source of Funds (Liabilities),Mittelherkunft ( Passiva)
Source warehouse is mandatory for row {0},Quelle Lager ist für Zeile {0}
Spartan,Spartanisch
"Special Characters except ""-"" and ""/"" not allowed in naming series","Sonderzeichen außer ""-"" und ""/"" nicht in der Benennung Serie erlaubt"
Specification Details,Spezifikationsdetails
Specifications,Technische Daten
Specify Exchange Rate to convert one currency into another,Geben Sie den Wechselkurs zum Umrechnen einer Währung in eine andere an
"Specify a list of Territories, for which, this Price List is valid","Geben Sie eine Liste der Regionen an, für die diese Preisliste gilt"
"Specify a list of Territories, for which, this Shipping Rule is valid","Geben Sie eine Liste der Regionen an, für die diese Versandregel gilt"
"Specify a list of Territories, for which, this Taxes Master is valid","Geben Sie eine Liste der Regionen an, für die dieser Steuerstamm gilt"
Specify conditions to calculate shipping amount,Geben Sie die Bedingungen zur Berechnung der Versandkosten an
"Specify the operations, operating cost and give a unique Operation no to your operations.","Geben Sie die Vorgänge, Betriebskosten an und geben einen einzigartige Betriebs-Nr für Ihren Betrieb an."
Split Delivery Note into packages.,Lieferschein in Pakete aufteilen.
Sports,Sport
Sr,Serie
Standard,Standard
Standard Buying,Standard- Einkaufsführer
Standard Reports,Standardberichte
Standard Selling,Standard-Vertrieb
"Standard Terms and Conditions that can be added to Sales and Purchases.Examples:1. Validity of the offer.1. Payment Terms (In Advance, On Credit, part advance etc).1. What is extra (or payable by the Customer).1. Safety / usage warning.1. Warranty if any.1. Returns Policy.1. Terms of shipping, if applicable.1. Ways of addressing disputes, indemnity, liability, etc.1. Address and Contact of your Company.","Standard Terms and Conditions that can be added to Sales and Purchases.Examples:1. Validity of the offer.1. Payment Terms (In Advance, On Credit, part advance etc).1. What is extra (or payable by the Customer).1. Safety / usage warning.1. Warranty if any.1. Returns Policy.1. Terms of shipping, if applicable.1. Ways of addressing disputes, indemnity, liability, etc.1. Address and Contact of your Company."
Standard contract terms for Sales or Purchase.,Standard Vertragsbedingungen für den Verkauf oder Kauf.
"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.#### NoteThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.#### Description of Columns1. Calculation Type:     - This can be on **Net Total** (that is the sum of basic amount).    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.    - **Actual** (as mentioned).2. Account Head: The Account ledger under which this tax will be booked3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.4. Description: Description of the tax (that will be printed in invoices / quotes).5. Rate: Tax rate.6. Amount: Tax amount.7. Total: Cumulative total to this point.8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.10. Add or Deduct: Whether you want to add or deduct the tax.","Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.#### NoteThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.#### Description of Columns1. Calculation Type:     - This can be on **Net Total** (that is the sum of basic amount).    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.    - **Actual** (as mentioned).2. Account Head: The Account ledger under which this tax will be booked3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.4. Description: Description of the tax (that will be printed in invoices / quotes).5. Rate: Tax rate.6. Amount: Tax amount.7. Total: Cumulative total to this point.8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.10. Add or Deduct: Whether you want to add or deduct the tax."
"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.#### NoteThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.#### Description of Columns1. Calculation Type:     - This can be on **Net Total** (that is the sum of basic amount).    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.    - **Actual** (as mentioned).2. Account Head: The Account ledger under which this tax will be booked3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.4. Description: Description of the tax (that will be printed in invoices / quotes).5. Rate: Tax rate.6. Amount: Tax amount.7. Total: Cumulative total to this point.8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.#### NoteThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.#### Description of Columns1. Calculation Type:     - This can be on **Net Total** (that is the sum of basic amount).    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.    - **Actual** (as mentioned).2. Account Head: The Account ledger under which this tax will be booked3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.4. Description: Description of the tax (that will be printed in invoices / quotes).5. Rate: Tax rate.6. Amount: Tax amount.7. Total: Cumulative total to this point.8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers."
Start,Start
Start Date,Startdatum
Start date of current invoice's period,Startdatum der laufenden Rechnungsperiode
Start date of current order's period,Startdatum der aktuellen Bestellperiode
Start date should be less than end date for Item {0},Startdatum sollte weniger als Enddatum für Artikel {0}
State,Land
Statement of Account,Kontoauszug
Static Parameters,Statische Parameter
Status,Status
Status must be one of {0},Der Status muss man von {0}
Status of {0} {1} is now {2},Status {0} {1} ist jetzt {2}
Status updated to {0},Status aktualisiert {0}
Statutory info and other general information about your Supplier,Gesetzliche und andere allgemeine Informationen über Ihren Lieferanten
Stay Updated,Bleiben Sie auf dem neuesten Stand
Stock,Lagerbestand
Stock Adjustment,Auf Einstellung
Stock Adjustment Account,Bestandskorrektur-Konto
Stock Ageing,Bestandsalterung
Stock Analytics,Bestandsanalyse
Stock Assets,Auf Assets
Stock Balance,Bestandsbilanz
Stock Entries already created for Production Order ,Lagerzugänge sind für Fertigungsauftrag bereits angelegt worden
Stock Entry,Lagerzugang
Stock Entry Detail,Bestandseintragsdetail
Stock Expenses,Auf Kosten
Stock Frozen Upto,Bestand eingefroren bis
Stock Item,Lagerartikel
Stock Ledger,Lagerbuch
Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts, Lagerbuch-Einträge und Hauptbuch-Einträge werden durch den Eingangslieferschein erstellt
Stock Ledger Entry,Lagerbuch-Eintrag
Stock Ledger entries balances updated,Lagerbuch-Einträge wurden aktualisiert
Stock Level,Bestandsebene
Stock Liabilities,Auf Verbindlichkeiten
Stock Projected Qty,Auf Projizierte Menge
Stock Queue (FIFO),Bestands-Warteschlange (FIFO)
Stock Received But Not Billed,"Empfangener, aber nicht abgerechneter Bestand"
Stock Reconcilation Data,Auf Versöhnung Daten
Stock Reconcilation Template,Auf Versöhnung Vorlage
Stock Reconciliation,Bestandsabgleich
"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.","Lagerbewertung kann verwendet werden um das Lager auf einem bestimmten Zeitpunkt zu aktualisieren, in der Regel ist das nach der Inventur."
Stock Settings,Bestandseinstellungen
Stock UOM,Bestands-ME
Stock UOM Replace Utility,Dienstprogramm zum Ersetzen der Bestands-ME
Stock UOM updatd for Item {0},"Auf ME fortgeschrieben, für den Posten {0}"
Stock Uom,Bestands-ME
Stock Value,Bestandswert
Stock Value Difference,Wertdifferenz Bestand
Stock balances updated,Auf Salden aktualisiert
Stock cannot be updated against Delivery Note {0},Lager kann nicht mit Lieferschein {0} aktualisiert werden
Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',Auf Einträge vorhanden sind gegen Lager {0} kann nicht neu zuweisen oder ändern 'Master -Name'
Stock transactions before {0} are frozen,Aktiengeschäfte vor {0} werden eingefroren
Stock: ,Bestand:
Stop,Anhalten
Stop Birthday Reminders,Stop- Geburtstagserinnerungen
Stop users from making Leave Applications on following days.,"Benutzer davon abhalten, Urlaubsanträge für folgende Tage zu machen."
Stopped,Angehalten
Stopped order cannot be cancelled. Unstop to cancel.,"angehaltener Auftrag kann nicht abgebrochen werden. Erst diesen Fortsetzen, um dann abzubrechen zu können."
Stores,Shops
Stub,Stummel
Sub Assemblies,Unterbaugruppen
"Sub-currency. For e.g. ""Cent""","Unterwährung. Zum Beispiel ""Cent"""
Subcontract,Zulieferer
Subcontracted,Weiterbeauftragt
Subject,Betreff
Submit Salary Slip,Gehaltsabrechnung absenden
Submit all salary slips for the above selected criteria,Alle Gehaltsabrechnungen für die oben gewählten Kriterien absenden
Submit this Production Order for further processing.,Speichern Sie diesen Fertigungsauftrag für die weitere Verarbeitung ab.
Submitted,Abgesendet/Eingereicht
Subsidiary,Tochtergesellschaft
Successful: ,Erfolgreich:
Successfully Reconciled,Erfolgreich versöhnt
Suggestions,Vorschläge
Sunday,Sonntag
Supplier,Lieferant
Supplier (Payable) Account,Lieferantenkonto (zahlbar)
Supplier (vendor) name as entered in supplier master,Lieferantenname (Verkäufer) wie im Lieferantenstamm eingetragen
Supplier > Supplier Type,Lieferant> Lieferantentyp
Supplier Account Head,Lieferant Kontenführer
Supplier Address,Lieferantenadresse
Supplier Addresses and Contacts,Lieferant Adressen und Kontakte
Supplier Details,Lieferantendetails
Supplier Intro,Lieferant Intro
Supplier Invoice Date,Lieferantenrechnungsdatum
Supplier Invoice No,Lieferantenrechnungsnr.
Supplier Name,Lieferantenname
Supplier Naming By,Benennung des Lieferanten nach
Supplier Part Number,Artikelnummer Lieferant
Supplier Quotation,Lieferantenangebot
Supplier Quotation Item,Angebotsposition Lieferant
Supplier Reference,Referenznummer des Lieferanten
Supplier Type,Lieferantentyp
Supplier Type / Supplier,Lieferant Typ / Lieferant
Supplier Type master.,Lieferant Typ Master.
Supplier Warehouse,Lieferantenlager
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Lieferantenlager notwendig für Eingangslieferschein aus Unteraufträgen
Supplier database.,Lieferantendatenbank
Supplier master.,Lieferantenvorlage.
Supplier of Goods or Services.,Lieferant von Waren oder Dienstleistungen.
Supplier warehouse where you have issued raw materials for sub - contracting,"Lieferantenlager, wo Sie Rohstoffe für Zulieferer ausgegeben haben."
Supplier-Wise Sales Analytics,HerstellerverkaufsWise Analytics
Support,Support
Support Analtyics,Support-Analyse
Support Analytics,Support-Analyse
Support Email,Support per E-Mail
Support Email Settings,Support E-Mail-Einstellungen
Support Manager,Support Verantwortlicher
Support Password,Support-Passwort
Support Team,Support-Team
Support Ticket,Support-Ticket
Support queries from customers.,Support-Anfragen von Kunden.
Symbol,Symbol
Sync Support Mails,Sync Unterstützungs E-Mails
Sync with Dropbox,Mit Dropbox synchronisieren
Sync with Google Drive,Mit Google Drive synchronisieren
System,System
System Balance,System Bilanz
System Manager,System Verantwortlicher
System Settings,Systemeinstellungen
"System User (login) ID. If set, it will become default for all HR forms.","Systembenutzer-ID (Anmeldung) Wenn gesetzt, wird sie standardmäßig für alle HR-Formulare verwendet."
System for managing Backups,System zur Verwaltung von Backups
TDS (Advertisement),TDS (Anzeige)
TDS (Commission),TDS (Kommission)
TDS (Contractor),TDS (Auftragnehmer)
TDS (Interest),TDS (Zinsen)
TDS (Rent),TDS (Mieten)
TDS (Salary),TDS (Salary)
Table for Item that will be shown in Web Site,"Tabelle für Artikel, die auf der Webseite angezeigt werden"
Target  Amount,Zielbetrag
Target Detail,Zieldetail
Target Details,Zieldetails
Target Details1,Zieldetails1
Target Distribution,Zielverteilung
Target On,Ziel Auf
Target Qty,Zielmenge
Target Warehouse,Zielwarenlager
Target warehouse in row {0} must be same as Production Order,Ziel-Lager in Zeile {0} muss dem Fertigungsauftrag entsprechen
Target warehouse is mandatory for row {0},Ziel-Lager ist für Zeile {0}
Task,Aufgabe
Task Details,Aufgabendetails
Tasks,Aufgaben
Tax,Steuer
Tax Amount After Discount Amount,Steuerbetrag nach Rabatt Betrag
Tax Assets,Steueransprüche
Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Steuerkategorie kann nicht ""Verbindlichkeit"" oder ""Verbindlichkeit und Summe"", da alle Artikel keine Lagerartikel sind"
Tax Rate,Steuersatz
Tax and other salary deductions.,Steuer und sonstige Gehaltsabzüge
Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges,Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges
Tax template for buying transactions.,Steuer-Vorlage für Einkaufs-Transaktionen.
Tax template for selling transactions.,Steuer-Vorlage für Vertriebs-Transaktionen.
Taxes,Steuer
Taxes and Charges,Steuern und Abgaben
Taxes and Charges Added,Steuern und Abgaben hinzugefügt
Taxes and Charges Added (Company Currency),Steuern und Abgaben hinzugefügt (Unternehmenswährung)
Taxes and Charges Calculation,Berechnung der Steuern und Abgaben
Taxes and Charges Deducted,Steuern und Abgaben abgezogen
Taxes and Charges Deducted (Company Currency),Steuern und Abgaben abgezogen (Unternehmenswährung)
Taxes and Charges Total,Steuern und Abgaben Gesamt1
Taxes and Charges Total (Company Currency),Steuern und Abgaben Gesamt (Unternehmenswährung)
Technology,Technologie
Telecommunications,Telekommunikation
Telephone Expenses,Telefonkosten
Television,Fernsehen
Template,Vorlage
Template for performance appraisals.,Vorlage für Leistungsbeurteilungen.
Template of terms or contract.,Vorlage für Geschäftsbedingungen oder Vertrag.
Temporary Accounts (Assets),Temporäre Accounts ( Assets)
Temporary Accounts (Liabilities),Temporäre Konten ( Passiva)
Temporary Assets,Temporäre Assets
Temporary Liabilities,Temporäre Verbindlichkeiten
Term Details,Details Geschäftsbedingungen
Terms,Bedingungen
Terms and Conditions,Allgemeine Geschäftsbedingungen
Terms and Conditions Content,Allgemeine Geschäftsbedingungen Inhalt
Terms and Conditions Details,Allgemeine Geschäftsbedingungen Details
Terms and Conditions Template,Allgemeine Geschäftsbedingungen Vorlage
Terms and Conditions1,Allgemeine Geschäftsbedingungen1
Terretory,Terretory
Territory,Region
Territory / Customer,Territory / Kunden
Territory Manager,Gebietsleiter
Territory Name,Name der Region
Territory Target Variance Item Group-Wise,Territory ZielabweichungsartikelgruppeWise -
Territory Targets,Ziele der Region
Test,Test
Test Email Id,E-Mail-Adresse testen
Test the Newsletter,Newsletter testen
The BOM which will be replaced,"Die Stückliste, die ersetzt wird"
The First User: You,Der erste Benutzer: Sie selbst!
"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""","Der Artikel, der das Paket darstellt. Bei diesem Artikel muss ""Ist Lagerartikel"" als ""Nein"" und ""Ist Verkaufsartikel"" als ""Ja"" gekennzeichnet sein"
The Organization,Die Firma
"The account head under Liability, in which Profit/Loss will be booked","Das Hauptkonto unter Verbindlichkeit, in das Gewinn/Verlust verbucht werden"
The date on which next invoice will be generated. It is generated on submit.,"Das Datum, an dem die nächste Rechnung erstellt wird. Sie wird beim Einreichen erzeugt."
The date on which recurring invoice will be stop,"Das Datum, an dem die wiederkehrende Rechnung angehalten wird"
The date on which recurring order will be stop,Das Datum an dem die sich Wiederholende Bestellung endet
"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ","Der Tag des Monats, an dem auto Rechnung zB 05, 28 usw. generiert werden"
"The day of the month on which auto order will be generated e.g. 05, 28 etc ","Der Tag im Monat, an dem die Bestellung erzeugt wird (z.B: 05, 27, etc)"
The day(s) on which you are applying for leave are holiday. You need not apply for leave.,"Tag(e), auf die Sie Urlaub beantragen, sind Feiertage. Hierfür müssen Sie keinen Urlaub beantragen."
The first Leave Approver in the list will be set as the default Leave Approver,Der erste Urlaubsgenehmiger auf der Liste wird als standardmäßiger Urlaubsgenehmiger festgesetzt
The first user will become the System Manager (you can change that later).,Der erste Benutzer wird der System-Manager (Sie können das später noch ändern).
The gross weight of the package. Usually net weight + packaging material weight. (for print),Das Bruttogewicht des Pakets. Normalerweise Nettogewicht + Gewicht des Verpackungsmaterials (Für den Ausdruck)
The name of your company for which you are setting up this system.,"Der Name der Firma, für die Sie die Einrichtung dieses Systems."
The net weight of this package. (calculated automatically as sum of net weight of items),Das Nettogewicht dieses Pakets. (automatisch als Summe der einzelnen Nettogewichte berechnet)
The new BOM after replacement,Die neue Stückliste nach dem Austausch
The rate at which Bill Currency is converted into company's base currency,"Der Kurs, mit dem die Rechnungswährung in die Basiswährung des Unternehmens umgerechnet wird"
The unique id for tracking all recurring invoices. It is generated on submit.,Die eindeutige ID für die Nachverfolgung aller wiederkehrenden Rechnungen. Wird beim Speichern generiert.
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Dann Preisregeln werden auf Basis von Kunden gefiltert, Kundengruppe, Territory, Lieferant, Lieferant Typ, Kampagne, Vertriebspartner usw."
There are more holidays than working days this month.,Es gibt mehr Feiertage als Arbeitstage in diesem Monat.
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Es kann nur eine Versandregel mit dem Wert 0 oder Leerwert für ""zu Wert"" geben"
There is not enough leave balance for Leave Type {0},Es ist nicht genügend Urlaubsbilanz für Leave Typ {0}
There is nothing to edit.,Es gibt nichts zu bearbeiten.
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.,"Es ist ein Fehler aufgetreten. Ein möglicher Grund könnte sein, dass Sie das Formular nicht gespeichert haben. Bitte kontaktieren Sie support@erpnext.com wenn das Problem weiterhin besteht."
There were errors.,Es sind Fehler aufgetreten.
This Currency is disabled. Enable to use in transactions,"Diese Währung ist deaktiviert. Aktivieren, um Transaktionen in"
This Leave Application is pending approval. Only the Leave Apporver can update status.,Dieser Urlaubsantrag wartet auf Genehmigung. Nur Urlaubsbewilliger können den Status aktualisieren.
This Time Log Batch has been billed.,Dieser Zeitprotokollstapel wurde abgerechnet.
This Time Log Batch has been cancelled.,Dieser Zeitprotokollstapel wurde abgebrochen.
This Time Log conflicts with {0},This Time Log Konflikt mit {0}
This format is used if country specific format is not found,"Dieses Format wird verwendet, wenn länderspezifischen Format wird nicht gefunden"
This is a root account and cannot be edited.,Dies ist ein Root-Account und können nicht bearbeitet werden.
This is a root customer group and cannot be edited.,Dies ist eine Stamm Kundengruppe und kann nicht editiert werden.
This is a root item group and cannot be edited.,Dies ist ein Stammelement-Gruppe und kann nicht editiert.
This is a root sales person and cannot be edited.,Dies ist ein Stamm-Verkäufer und kann daher nicht editiert werden.
This is a root territory and cannot be edited.,Dies ist ein Stammgebiet und diese können nicht bearbeitet werden.
This is an example website auto-generated from ERPNext,"Dies ist eine Beispiel-Website, von ERPNext automatisch generiert"
This is the number of the last created transaction with this prefix,Dies ist die Nummer der letzten erstellten Transaktion mit diesem Präfix
This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"Dieses Tool hilft Ihnen, die Menge und die Bewertung von Bestand im System zu aktualisieren oder zu ändern. Sie wird in der Regel verwendet, um die Systemwerte und den aktuellen Bestand Ihrer Warenlager zu synchronisieren."
This will be used for setting rule in HR module,Dies wird für die Festlegung der Regel im HR-Modul verwendet
Thread HTML,Thread HTML
Thursday,Donnerstag
Time Log,Zeitprotokoll
Time Log Batch,Zeitprotokollstapel
Time Log Batch Detail,Zeitprotokollstapel-Detail
Time Log Batch Details,Zeitprotokollstapel-Details
Time Log Batch {0} must be 'Submitted',"Zeitprotokollstapel {0} muss ""eingereicht"" werden"
Time Log Status must be Submitted.,Status des Zeitprotokolls muss 'Eingereicht/Abgesendet' sein
Time Log for tasks.,Zeitprotokoll für Aufgaben.
Time Log is not billable,Zeitprotokoll ist nicht abrechenbar
Time Log {0} must be 'Submitted',"Zeiotprotokoll {0} muss ""eingereicht"" werden"
Time Zone,Zeitzone
Time Zones,Zeitzonen
Time and Budget,Zeit und Budget
Time at which items were delivered from warehouse,"Zeitpunkt, zu dem Artikel aus dem Lager geliefert wurden"
Time at which materials were received,"Zeitpunkt, zu dem Materialien empfangen wurden"
Title,Titel
Titles for print templates e.g. Proforma Invoice.,Titel für Druckvorlagen z.B. Proforma-Rechnung.
To,bis
To Currency,In Währung
To Date,Bis dato
To Date should be same as From Date for Half Day leave,Bis Datum sollten gleiche wie von Datum für Halbtagesurlaubsein
To Date should be within the Fiscal Year. Assuming To Date = {0},"Bis Datum sollte im Geschäftsjahr sein. Unter der Annahme, bis Datum = {0}"
To Discuss,Zur Diskussion
To Do List,Aufgabenliste
To Package No.,Bis Paket Nr.
To Produce,Um Produzieren
To Time,Bis Uhrzeit
To Value,Bis Wert
To Warehouse,An Warenlager
"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Um Unterelemente hinzuzufügen, klicken Sie im Baum auf das Element, unter dem Sie weitere Elemente hinzufügen möchten."
"To assign this issue, use the ""Assign"" button in the sidebar.","Um dieses Problem zu zuzuweisen, verwenden Sie die Schaltfläche ""Zuweisen"" auf der Seitenleiste."
To create a Bank Account,Um ein Bankkonto zu erstellen
To create a Tax Account,Um ein Steuerkonto erstellen
"To create an Account Head under a different company, select the company and save customer.","Um einen Kontenführer unter einem anderen Unternehmen zu erstellen, wählen Sie das Unternehmen aus und speichern Sie den Kunden."
To date cannot be before from date,Bis heute kann nicht vor von aktuell sein
To enable <b>Point of Sale</b> features,Um Funktionen der <b>Verkaufsstelle</b> zu aktivieren
To enable <b>Point of Sale</b> view,Um <b> Point of Sale </ b> Ansicht aktivieren
To get Item Group in details table,So rufen sie eine Artikelgruppe in die Detailtabelle ab
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",Um Steuern im Artikelpreis in Zeile {0} einzubeziehen müssen Steuern in den Zeilen {1} ebenfalls einbezogen sein
"To merge, following properties must be same for both items","Um mischen können, müssen folgende Eigenschaften für beide Produkte sein"
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Um Pricing Regel in einer bestimmten Transaktion nicht zu, sollten alle geltenden Preisregeln deaktiviert zu sein."
"To set this Fiscal Year as Default, click on 'Set as Default'","Um dieses Geschäftsjahr als Standard festzulegen, klicken Sie auf ""als Standard festlegen"""
To track any installation or commissioning related work after sales,So verfolgen Sie eine Installation oder eine mit Kommissionierung verbundene Arbeit nach dem Verkauf
"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","Um Markennamen in der folgenden Dokumente zu verfolgen: Lieferschein, Chance, Materialanforderung, Artikel, Lieferatenauftrag, Einkaufsgutschein, Käufer Beleg, Angebot, Ausgangsrechnung, Verkaufsstückliste, Kundenauftrag, Seriennummer"
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.,"So verfolgen Sie Artikel in Einkaufs-und Verkaufsdokumenten auf der Grundlage ihrer Seriennummern. Diese Funktion kann auch verwendet werden, um die Garantieangaben des Produkts zu verfolgen."
To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,So verfolgen Sie Artikel in Einkaufs-und Verkaufsdokumenten mit Stapelnummern<b>Bevorzugte Branche: Chemikalien usw.</b>
To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,So verfolgen Sie Artikel über den Barcode. Durch das Scannen des Artikel-Barcodes können Sie ihn in den Lieferschein und die Ausgangsrechnung aufnehmen.
Too many columns. Export the report and print it using a spreadsheet application.,Zu viele Spalten. Exportieren Sie den Bericht und drucken Sie es mit einem Tabellenkalkulationsprogramm.
Tools,Extras
Total,Gesamt
Total ({0}),Gesamt ({0})
Total Advance,Gesamtvoraus
Total Amount,Gesamtbetrag
Total Amount To Pay,Fälliger Gesamtbetrag
Total Amount in Words,Gesamtbetrag in Worten
Total Billing This Year: ,Insgesamt Billing ieses Jahr:
Total Characters,Insgesamt Charaktere
Total Claimed Amount,Summe des geforderten Betrags
Total Commission,Gesamtbetrag Kommission
Total Cost,Gesamtkosten
Total Credit,Gesamtkredit
Total Debit,Gesamtschuld
Total Debit must be equal to Total Credit. The difference is {0},
Total Deduction,Gesamtabzug
Total Earning,Gesamteinnahmen
Total Experience,Intensive Erfahrung
Total Hours,Gesamtstunden
Total Hours (Expected),Gesamtstunden (erwartet)
Total Invoiced Amount,Gesamtrechnungsbetrag
Total Leave Days,Urlaubstage insgesamt
Total Leaves Allocated,Insgesamt zugewiesene Urlaubstage
Total Message(s),Insgesamt Nachricht (en)
Total Operating Cost,Gesamtbetriebskosten
Total Points,Gesamtpunkte
Total Raw Material Cost,Gesamtkosten für Rohstoffe
Total Sanctioned Amount,Gesamtsumme genehmigter Betrag
Total Score (Out of 5),Gesamtwertung (von 5)
Total Tax (Company Currency),Gesamtsteuerlast (Unternehmenswährung)
Total Taxes and Charges,Steuern und Ausgaben insgesamt
Total Taxes and Charges (Company Currency),Steuern und Ausgaben insgesamt (Unternehmenswährung)
Total allocated percentage for sales team should be 100,Insgesamt zugeordnet Prozentsatz für Vertriebsteam sollte 100 sein
Total amount of invoices received from suppliers during the digest period,Gesamtbetrag der vom Lieferanten während des Berichtszeitraums eingereichten Rechnungen
Total amount of invoices sent to the customer during the digest period,"Gesamtbetrag der Rechnungen, die während des Berichtszeitraums an den Kunden gesendet wurden"
Total cannot be zero,Insgesamt darf nicht Null sein
Total in words,Gesamt in Worten
Total points for all goals should be 100. It is {0},Gesamtpunkte für alle Ziele sollten 100 sein. Es ist {0}
Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Gesamtbewertungs für hergestellte oder umgepackt Artikel (s) kann nicht kleiner als die Gesamt Bewertung der Rohstoffe sein
Total weightage assigned should be 100%. It is {0},Insgesamt Gewichtung zugeordnet sollte 100 % sein. Es ist {0}
Totals,Summen
Track Leads by Industry Type.,Verfolge Interessenten nach Branchentyp.
Track separate Income and Expense for product verticals or divisions.,Einnahmen und Ausgaben für Produktbereiche oder Abteilungen separat verfolgen.
Track this Delivery Note against any Project,Diesen Lieferschein in jedem Projekt nachverfolgen
Track this Sales Order against any Project,Diesen Kundenauftrag in jedem Projekt nachverfolgen
Transaction,Transaktion
Transaction Date,Transaktionsdatum
Transaction not allowed against stopped Production Order {0},Transaktion nicht gegen angehaltenen Fertigungsauftrag {0} erlaubt
Transfer,Übertragung
Transfer Material,Transfermaterial
Transfer Raw Materials,Übertragen Rohstoffe
Transferred Qty,Die übertragenen Menge
Transportation,Transport
Transporter Info,Informationen zum Transportunternehmer
Transporter Name,Name des Transportunternehmers
Transporter lorry number,LKW-Nr. des Transportunternehmers
Travel,Reise
Travel Expenses,Reisekosten
Tree Type,Baum- Typ
Tree of Item Groups.,Baum der Artikelgruppen.
Tree of finanial Cost Centers.,Baum der Finanz-Kostenstellen.
Tree of finanial accounts.,Baum der Finanz-Konten.
Trial Balance,Allgemeine Kontenbilanz
Tuesday,Dienstag
Type,Typ
Type of document to rename.,Art des Dokuments umbenennen.
"Type of leaves like casual, sick etc.","Grund für Beurlaubung, wie Urlaub, krank usw."
Types of Expense Claim.,Spesenabrechnungstypen
Types of activities for Time Sheets,Art der Aktivität für Tätigkeitsnachweis
"Types of employment (permanent, contract, intern etc.).","Art der Beschäftigung (dauerhaft, Vertrag, Praktikanten etc.)."
UOM Conversion Detail,ME-Umrechnung Detail
UOM Conversion Details,ME-Umrechnung Details
UOM Conversion Factor,ME-Umrechnungsfaktor
UOM Conversion factor is required in row {0},ME-Umrechnungsfaktor ist erforderlich in der Zeile {0}
UOM Name,ME-Name
UOM coversion factor required for UOM: {0} in Item: {1},ME-Umrechnungsfaktor ist erforderlich für ME: {0} bei Artikel: {1}
Under AMC,Unter AMC
Under Graduate,Schulabgänger
Under Warranty,Unter Garantie
Unit,Einheit
Unit of Measure,Mengeneimheit
Unit of Measure {0} has been entered more than once in Conversion Factor Table,Mengeneinheit {0} wurde mehr als einmal in die Umrechnungsfaktor-Tabelle eingetragen
"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Mengeneinheit für diesen Artikel (z.B. Kg, Stück, Pack, Paar)."
Units/Hour,Einheiten/Stunde
Units/Shifts,Einheiten/Schichten
Unpaid,Unbezahlt
Unreconciled Payment Details,Nicht abgestimmte Zahlungsdetails
Unscheduled,Außerplanmäßig
Unsecured Loans,Unbesicherte Kredite
Unstop,aufmachen
Unstop Material Request,Materialanforderung fortsetzen
Unstop Purchase Order,Lieferatenauftrag fortsetzen
Unsubscribed,Abgemeldet
Update,Aktualisierung
Update Clearance Date,Tilgungsdatum aktualisieren
Update Cost,Aktualisierung der Kosten
Update Finished Goods,Fertigteile aktualisieren
Update Series,Serie aktualisieren
Update Series Number,Seriennummer aktualisieren
Update Stock,Lagerbestand aktualisieren
Update additional costs to calculate landed cost of items,Aktualisieren Sie Zusatzkosten um die Einstandskosten des Artikels zu kalkulieren
Update bank payment dates with journals.,Aktualisieren Sie die Zahlungstermine anhand der Journale.
Update clearance date of Journal Entries marked as 'Bank Vouchers',"Update- Clearance Datum der Journaleinträge als ""Bank Gutscheine 'gekennzeichnet"
Updated,Aktualisiert
Updated Birthday Reminders,Aktualisiert Geburtstagserinnerungen
Upload Attendance,Teilnahme hochladen
Upload Backups to Dropbox,Backups in Dropbox hochladen
Upload Backups to Google Drive,Backups auf Google Drive hochladen
Upload HTML,Upload-HTML
Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,"Laden Sie eine CSV-Datei mit zwei Spalten hoch: In der einen der alte, in der anderen der neue Name. Maximal 500 Zeilen."
Upload attendance from a .csv file,Anwesenheiten aus einer CSV-Datei hochladen
Upload stock balance via csv.,Bestandsbilanz über CSV hochladen
Upload your letter head and logo - you can edit them later.,Laden Sie Ihren Briefkopf und Ihr Logo hoch - Sie können diese auch später noch bearbeiten.
Upper Income,Oberes Einkommen
Urgent,Dringend
Use Multi-Level BOM,Mehrstufige Stückliste verwenden
Use SSL,SSL verwenden
Used for Production Plan,Wird für Produktionsplan
User,Benutzer
User ID,Benutzerkennung
User ID not set for Employee {0},Benutzer-ID nicht für Mitarbeiter eingestellt {0}
User Name,Benutzername
User Name or Support Password missing. Please enter and try again.,Benutzername oder Passwort fehlt. Bitte geben Sie diese ein und versuchen Sie es erneut.
User Remark,Benutzerbemerkung
User Remark will be added to Auto Remark,Benutzerbemerkung wird der automatischen Bemerkung hinzugefügt
User Remarks is mandatory,Benutzer Bemerkungen ist obligatorisch
User Specific,Benutzerspezifisch
User must always select,Benutzer muss immer auswählen
User {0} is already assigned to Employee {1},Benutzer {0} ist bereits an Mitarbeiter zugewiesen {1}
User {0} is disabled,Benutzer {0} ist deaktiviert
Username,Benutzername
Users who can approve a specific employee's leave applications,"Benutzer, die die Urlaubsanträge eines bestimmten Mitarbeiters genehmigen können"
Users with this role are allowed to create / modify accounting entry before frozen date,Benutzer mit dieser Rolle sind erlaubt zu erstellen / Verbuchung vor gefrorenen Datum ändern
Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Benutzer mit dieser Rolle erlaubt sind auf eingefrorenen Konten setzen und / Buchungen gegen eingefrorene Konten ändern
Utilities,Dienstprogramme
Utility Expenses,Utility- Aufwendungen
Valid For Territories,Gültig für Regionen
Valid From,Gültig ab
Valid Upto,Gültig bis
Valid for Territories,Gültig für Regionen
Validate,Prüfen
Valuation,Bewertung
Valuation Method,Bewertungsmethode
Valuation Rate,Bewertungsrate
Valuation Rate required for Item {0},Artikel für erforderlich Bewertungs Bewerten {0}
Valuation and Total,Bewertung und Gesamt
Value,Wert
Value or Qty,Wert oder Menge
Vehicle Dispatch Date,Fahrzeugversanddatum
Vehicle No,Fahrzeug Nr.
Venture Capital,Risikokapital
Verified By,Geprüft durch
View Details,Details anschauen
View Ledger,Ansicht Ledger
View Now,Jetzt ansehen
Visit report for maintenance call.,Besuchsbericht für Wartungsabruf.
Voucher #,Gutschein #
Voucher Detail No,Gutscheindetail Nr.
Voucher Detail Number,Gutschein Detail Anzahl
Voucher ID,Gutschein-ID
Voucher No,Gutscheinnr.
Voucher Type,Gutscheintyp
Voucher Type and Date,Art und Datum des Gutscheins
Walk In,Laufkundschaft
Warehouse,Warenlager
Warehouse Contact Info,Kontaktinformation Warenlager
Warehouse Detail,Detail Warenlager
Warehouse Name,Warenlagername
Warehouse and Reference,Warenlager und Referenz
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Lager kann nicht gelöscht werden, da es Lagerbuch-Einträge für dieses Lager gibt."
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Lager kann nur über Lagerzugang / Lieferschein / Eingangslieferschein geändert werden
Warehouse cannot be changed for Serial No.,Warehouse kann nicht für Seriennummer geändert werden
Warehouse is mandatory for stock Item {0} in row {1},Warehouse ist für Lager Artikel {0} in Zeile {1}
Warehouse is missing in Purchase Order,Angabe des Lagers fehlt in dem Lieferatenauftrag
Warehouse not found in the system,Lager im System nicht gefunden
Warehouse required for stock Item {0},Angabe des Lagers ist für den Lagerartikel {0} erforderlich
Warehouse where you are maintaining stock of rejected items,"Lager, in dem Sie Bestand abgelehnter Artikel führen"
Warehouse {0} can not be deleted as quantity exists for Item {1},"Lager {0} kann nicht gelöscht werden, da noch ein Bestand für Artikel {1} existiert"
Warehouse {0} does not belong to company {1},Lager {0} gehört nicht zu Unternehmen {1}
Warehouse {0} does not exist,Lager {0} existiert nicht
Warehouse {0}: Company is mandatory,Warehouse {0}: Unternehmen ist obligatorisch
Warehouse {0}: Parent account {1} does not bolong to the company {2},Lager {0}: Ursprungskonto {1} gehört nicht zu Unternehmen {2}
Warehouse-Wise Stock Balance,Warenlagerweise Bestandsbilanz
Warehouse-wise Item Reorder,Warenlagerweise Artikelaufzeichnung
Warehouses,Warenlager
Warehouses.,Warenlager.
Warn,Warnen
Warning: Leave application contains following block dates,Achtung: Die Urlaubsanwendung enthält die folgenden gesperrten Daten
Warning: Material Requested Qty is less than Minimum Order Qty,Achtung : Material Gewünschte Menge weniger als Mindestbestellmengeist
Warning: Sales Order {0} already exists against same Purchase Order number,Warnung: Kundenauftrag {0} existiert bereits für die gleiche Lieferatenauftragsnummer
Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Achtung: Das System wird nicht zu überprüfen, da überhöhte Betrag für Artikel {0} in {1} Null"
Warranty / AMC Details,Garantie / AMC-Details
Warranty / AMC Status,Garantie / AMC-Status
Warranty Expiry Date,Garantieablaufdatum
Warranty Period (Days),Gewährleistungsfrist
Warranty Period (in days),Garantiezeitraum (in Tagen)
We buy this Item,Wir kaufen diesen Artikel
We sell this Item,Wir verkaufen diesen Artikel
Website,Website
Website Description,Website-Beschreibung
Website Item Group,Webseite-Artikelgruppe
Website Item Groups,Webseite-Artikelgruppen
Website Manager,Website-Administrator
Website Settings,Website-Einstellungen
Website Warehouse,Website-Lager
Wednesday,Mittwoch
Weekly,Wöchentlich
Weekly Off,Wöchentlich frei
Weight UOM,Gewicht ME
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Gewichtsangabe wird angegeben,\nBitte geben Sie das Gewicht pro Mengeneinheit (Gewicht ME) ebenfalls an"
Weightage,Gewichtung
Weightage (%),Gewichtung (%)
Welcome,Willkommen
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!,"Willkommen auf ERPNext. In den nächsten Minuten werden wir Ihnen helfen, Ihr ERPNext Konto einzurichten. Versuchen Sie soviel wie möglich auszufüllen, auch wenn es etwas länger dauert. Es wird Ihnen eine später Menge Zeit sparen. Viel Erfolg!"
Welcome to ERPNext. Please select your language to begin the Setup Wizard.,"Willkommen bei ERPNext. Bitte wählen Sie Ihre Sprache, um den Setup-Assistenten zu starten."
What does it do?,Unternehmenszweck?
"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.","Wenn eine der geprüften Transaktionen den Status ""Abgesendet/Eingereicht"" hat, wird automatisch eine Popup-E-Mail geöffnet, damit die Transaktion als Anhang per E-Mail an den zugeordneten ""Kontakt"" dieser Transaktion gesendet werden kann.  Der Benutzer kann diese E-Mail absenden oder nicht."
"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Wenn eingereicht wird, erstellt das System Differenz-Einträge anhand der Bestände und Wertw an diesem Tag."
Where items are stored.,Wo Artikel gelagert werden.
Where manufacturing operations are carried out.,Wo Herstellungsvorgänge durchgeführt werden.
Widowed,Verwaist
Will be calculated automatically when you enter the details,"Wird automatisch berechnet, wenn Sie die Daten eingeben"
Will be updated after Sales Invoice is Submitted.,"Wird aktualisiert, nachdem die Ausgangsrechnung eingereicht wird."
Will be updated when batched.,"Wird aktualisiert, wenn Stapel erstellt werden."
Will be updated when billed.,"Wird aktualisiert, wenn in Rechnung gestellt."
Wire Transfer,Überweisung
With Operations,Mit Vorgängen
Work Details,Arbeitsdetails
Work Done,Erledigte Arbeit
Work In Progress,Laufende Arbeiten
Work-in-Progress Warehouse,Warenlager laufende Arbeit
Work-in-Progress Warehouse is required before Submit,"Arbeit - in -Progress Warehouse erforderlich ist, bevor abschicken"
Working,Arbeit
Working Days,Arbeitstage
Workstation,Arbeitsstation
Workstation Name,Name der Arbeitsstation
Write Off Account,"Abschreibung, Konto"
Write Off Amount,"Abschreibung, Betrag"
Write Off Amount <=,"Abschreibung, Betrag <="
Write Off Based On,Abschreiben basiert auf
Write Off Cost Center,"Abschreibung, Kostenstelle"
Write Off Outstanding Amount,"Abschreiben, ausstehender Betrag"
Write Off Voucher,"Abschreiben, Gutschein"
Wrong Template: Unable to find head row.,Falsche Vorlage: Kopfzeile nicht gefunden
Year,Jahr
Year Closed,Jahr geschlossen
Year End Date,Geschäftsjahr Ende
Year Name,Name des Jahrs
Year Start Date,Geschäftsjahr Beginn
Year of Passing,Jahr des Übergangs
Yearly,Jährlich
Yes,Ja
You are not authorized to add or update entries before {0},Sie haben keine Berechtigung Einträge vor {0} hinzuzufügen oder zu aktualisieren
You are not authorized to set Frozen value,Sie haben keine Berechtigung eingefrorene Werte zu setzen
You are the Expense Approver for this record. Please Update the 'Status' and Save,Sie sind der Ausgabenbewilliger für diesen Datensatz. Bitte aktualisieren Sie den 'Status' und dann speichern Sie diesen ab
You are the Leave Approver for this record. Please Update the 'Status' and Save,Sie sind der Abwesenheitsbewilliger für diesen Datensatz. Bitte aktualisieren Sie den 'Status' und dann speichern Sie diesen ab
You can enter any date manually,Sie können jedes Datum manuell eingeben
You can enter the minimum quantity of this item to be ordered.,"Sie können die Mindestmenge des Artikels eingeben, der bestellt werden soll."
You can not change rate if BOM mentioned agianst any item,Sie können den Tarif nicht ändern solange die Stückliste Artikel enthält
You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Sie können nicht sowohl die Lieferschein-Nr. als auch die Ausgangsrechnungs-Nr. angeben. Bitte geben Sie nur eine von Beiden an.
You can not enter current voucher in 'Against Journal Voucher' column,"Sie können den aktuellen Beleg nicht in ""zu Buchungsbeleg-Spalte erfassen"
You can set Default Bank Account in Company master,Sie können Standard- Bank-Konto in Firmen Master eingestellt
You can start by selecting backup frequency and granting access for sync,Sie können durch Auswahl Backup- Frequenz und den Zugang für die Gewährung Sync starten
You can submit this Stock Reconciliation.,Sie können diese Vektor Versöhnung vorzulegen.
You can update either Quantity or Valuation Rate or both.,Sie können entweder Menge oder Bewertungs bewerten oder beides aktualisieren.
You cannot credit and debit same account at the same time,Sie können keine Kredit-und Debit gleiche Konto in der gleichen Zeit
You have entered duplicate items. Please rectify and try again.,Sie haben doppelte Elemente eingetragen. Bitte korrigieren und versuchen Sie es erneut .
You may need to update: {0},Sie müssen möglicherweise folgendes aktualisieren: {0}
You must Save the form before proceeding,Sie müssen das Formular speichern um fortzufahren 
Your Customer's TAX registration numbers (if applicable) or any general information,Steuernummern Ihres Kunden (falls zutreffend) oder allgemeine Informationen
Your Customers,Ihre Kunden
Your Login Id,Ihre Login-ID
Your Products or Services,Ihre Produkte oder Dienstleistungen
Your Suppliers,Ihre Lieferanten
Your email address,Ihre E-Mail -Adresse
Your financial year begins on,Ihr Geschäftsjahr beginnt am
Your financial year ends on,Ihr Geschäftsjahr endet am
Your sales person who will contact the customer in future,"Ihr Vertriebsmitarbeiter, der den Kunden in Zukunft kontaktiert"
Your sales person will get a reminder on this date to contact the customer,"Ihr Vertriebsmitarbeiter erhält an diesem Datum eine Erinnerung, den Kunden zu kontaktieren"
Your setup is complete. Refreshing...,die Einrichtung ist abgeschlossen. Aktualisiere...
Your support email id - must be a valid email - this is where your emails will come!,Ihre Support-E-Mail-ID - muss eine gültige E-Mail sein. An diese Adresse erhalten Sie Ihre E-Mails!
[Error],[Error]
[Select],[Select ]
`Freeze Stocks Older Than` should be smaller than %d days.,`Frost Stocks Älter als ` sollte kleiner als% d Tage.
and,und
are not allowed.,sind nicht erlaubt.
assigned by,zugewiesen von
cannot be greater than 100,darf nicht größer als 100 sein
"e.g. ""Build tools for builders""","z.B. ""Build -Tools für Bauherren """
"e.g. ""MC""","z.B. ""MC"""
"e.g. ""My Company LLC""","z.B. ""My Company LLC"""
e.g. 5,z.B. 5
"e.g. Bank, Cash, Credit Card","z.B. Bank, Bargeld, Kreditkarte"
"e.g. Kg, Unit, Nos, m","z.B. Kg, Einheit, Nr, m"
e.g. VAT,z.B. Mehrwertsteuer
eg. Cheque Number,z. B. Schecknummer
example: Next Day Shipping,Beispiel: Versand am nächsten Tag
fold,
hidden,versteckt
hours,
lft,li
old_parent,vorheriges Element
rgt,Rt
subject,Betreff
to,bis
website page link,Website-Link
{0} '{1}' not in Fiscal Year {2},{0} ' {1}' nicht im Geschäftsjahr {2}
{0} Credit limit {1} crossed,{0} Kreidlinie überschritte {1}
{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} Seriennummern für Artikel erforderlich {0}. Nur {0} ist.
{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} Budget für Konto {1} gegen Kostenstelle {2} wird von {3} überschreiten
{0} can not be negative,{0} kann nicht negativ sein
{0} created,{0} erstellt
{0} days from {1}, {0} Tage von {1} ab
{0} does not belong to Company {1},{0} ist nicht auf Unternehmen gehören {1}
{0} entered twice in Item Tax,{0} trat zweimal in Artikel Tax
{0} is an invalid email address in 'Notification \					Email Address',{0} ist eine ungültige E-Mail-Adresse in 'Mitteilung E-Mail-Adresse'
{0} is mandatory,{0} ist obligatorisch
{0} is mandatory for Item {1},{0} Artikel ist obligatorisch für {1}
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} ist obligatorisch. Vielleicht Devisenwechsel Datensatz nicht für {1} bis {2} erstellt.
{0} is not a stock Item,{0} ist kein Lagerartikel
{0} is not a valid Batch Number for Item {1},{0} ist keine gültige Chargennummer für Artikel {1}
{0} is not a valid Leave Approver. Removing row #{1}.,{0} ist kein gültiges Datum Genehmiger. Entfernen Folge # {1}.
{0} is not a valid email id,{0} ist keine gültige E-Mail -ID
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,"{0} ist jetzt der Standardgeschäftsjahr. Bitte aktualisieren Sie Ihren Browser, damit die Änderungen wirksam werden."
{0} is required,{0} ist erforderlich
{0} must be a Purchased or Sub-Contracted Item in row {1},{0} muss ein Gekaufte oder Subunternehmer vergebene Artikel in Zeile {1}
{0} must be reduced by {1} or you should increase overflow tolerance,"{0} muss {1} reduziert werden, oder sollten Sie Überlauftoleranz zu erhöhen"
{0} must have role 'Leave Approver',"{0} muss die Rolle ""Abwesenheitsgenehmiger"" haben"
{0} valid serial nos for Item {1},{0} gültige Seriennummernfür Artikel {1}
{0} {1} against Bill {2} dated {3},{0} {1} gegen Bill {2} {3} vom
{0} {1} against Invoice {2},{0} {1} gegen Rechnung {2}
{0} {1} has already been submitted,{0} {1} wurde bereits eingereich
{0} {1} has been modified. Please refresh.,{0} {1} wurde geändert. Bitte aktualisieren.
{0} {1} is not submitted,{0} {1} nicht vorgelegt
{0} {1} must be submitted,{0} {1} muss vorgelegt werden
{0} {1} not in any Fiscal Year,{0} {1} nicht in jedem Geschäftsjahr
{0} {1} status is 'Stopped',"{0} {1} hat den Status ""angehalten"""
{0} {1} status is Stopped,{0} {1} hat den Status angehalten
{0} {1} status is Unstopped,{0} {1} hat den Status fortgesetzt
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Kostenstelle ist obligatorisch für Artikel {2}
{0}: {1} not found in Invoice Details table,{0}: {1} nicht in der Rechnungs Details-Tabelle gefunden
