diff --git a/erpnext/translations/de.csv b/erpnext/translations/de.csv
index e520112..e28304e 100644
--- a/erpnext/translations/de.csv
+++ b/erpnext/translations/de.csv
@@ -1,5837 +1,5772 @@
-DocType: Employee,Salary Mode,Gehaltsmodus
-DocType: Patient,Divorced,Geschieden
-DocType: Buying Settings,Allow Item to be added multiple times in a transaction,"Zulassen, dass ein Artikel mehrfach in einer Transaktion hinzugefügt werden kann"
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Materialkontrolle {0} stornieren vor Abbruch dieses Garantieantrags
-apps/erpnext/erpnext/config/education.py +118,Assessment Reports,Bewertungsberichte
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Verbrauchsgüter
-DocType: Purchase Receipt,Subscription Detail,Abonnement Detail
-DocType: Supplier Scorecard,Notify Supplier,Lieferanten benachrichtigen
-DocType: Item,Customer Items,Kunden-Artikel
-DocType: Project,Costing and Billing,Kalkulation und Abrechnung
-apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Konto {0}: Übergeordnetes Konto {1} kann kein Kontenblatt sein
-DocType: Item,Publish Item to hub.erpnext.com,Artikel über hub.erpnext.com veröffentlichen
-apps/erpnext/erpnext/config/setup.py +88,Email Notifications,E-Mail-Benachrichtigungen
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,Beurteilung
-DocType: Item,Default Unit of Measure,Standardmaßeinheit
-DocType: SMS Center,All Sales Partner Contact,Alle Vertriebspartnerkontakte
-DocType: Employee,Leave Approvers,Urlaubsgenehmiger
-DocType: Sales Partner,Dealer,Händler
-DocType: Consultation,Investigations,Untersuchungen
-DocType: Restaurant Order Entry,Click Enter To Add,Klicken Sie zum Hinzufügen auf Hinzufügen.
-DocType: Employee,Rented,Gemietet
-DocType: Purchase Order,PO-,PO-
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +225,"Stopped Production Order cannot be cancelled, Unstop it first to cancel",Angehaltener Fertigungsauftrag kann nicht storniert werden. Bitte zuerst den Fertigungsauftrag fortsetzen um ihn dann zu stornieren
-DocType: Vehicle Service,Mileage,Kilometerstand
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +253,Do you really want to scrap this asset?,Möchten Sie diesen Gegenstand wirklich entsorgen?
-DocType: Drug Prescription,Update Schedule,Aktualisierungsplan
-apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Standard -Lieferant auswählen
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Währung für Preisliste {0} erforderlich
-DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Wird in der Transaktion berechnet.
-DocType: Purchase Order,Customer Contact,Kundenkontakt
-DocType: Patient Appointment,Check availability,Verfügbarkeit prüfen
-DocType: Job Applicant,Job Applicant,Bewerber
-apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Dies basiert auf Transaktionen gegen diesen Lieferanten. Siehe Zeitleiste unten für Details
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Rechtswesen
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Tatsächliche Steuerart kann nicht im Artikelpreis in Zeile {0} beinhaltet sein
-DocType: Bank Guarantee,Customer,Kunde
-DocType: Purchase Receipt Item,Required By,Benötigt von
-DocType: Delivery Note,Return Against Delivery Note,Zurück zum Lieferschein
-DocType: Purchase Order,% Billed,% verrechnet
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Wechselkurs muss derselbe wie {0} {1} ({2}) sein
-DocType: Sales Invoice,Customer Name,Kundenname
-DocType: Vehicle,Natural Gas,Erdgas
-apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Bankname {0} ungültig
-DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Typen (oder Gruppen), zu denen Buchungseinträge vorgenommen und Salden geführt werden."
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Ausstände für {0} können nicht kleiner als Null sein ({1})
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Es gibt keine eingereichten Salary Slips zu verarbeiten.
-DocType: Manufacturing Settings,Default 10 mins,Standard 10 Minuten
-DocType: Leave Type,Leave Type Name,Bezeichnung der Abwesenheit
-apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,zeigen open
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,"Es ist notwendig, diese Handlung heute selbst für die oben erwähnten wiederkehrenden zu nehmen"
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +24,Diagnosis and Complaints cannot be left blank,Diagnose und Beschwerden können nicht leer gelassen werden
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Nummernkreise erfolgreich geändert
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Auschecken
-DocType: Pricing Rule,Apply On,Anwenden auf
-DocType: Item Price,Multiple Item prices.,Mehrere verschiedene Artikelpreise
-,Purchase Order Items To Be Received,Eingehende Lieferantenauftrags-Artikel
-DocType: SMS Center,All Supplier Contact,Alle Lieferantenkontakte
-DocType: Support Settings,Support Settings,Support-Einstellungen
-apps/erpnext/erpnext/projects/doctype/project/project.py +74,Expected End Date can not be less than Expected Start Date,Voraussichtliches Enddatum kann nicht vor dem voraussichtlichen Startdatum liegen
-apps/erpnext/erpnext/utilities/transaction_base.py +117,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Zeile #{0}: Preis muss derselbe wie {1}: {2} ({3} / {4}) sein
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241,New Leave Application,Neuer Urlaubsantrag
-,Batch Item Expiry Status,Stapelobjekt Ablauf-Status
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bankwechsel
-DocType: Membership,membership validaty section,Mitgliedschaft validity Abschnitt
-DocType: Mode of Payment Account,Mode of Payment Account,Art des Zahlungskontos
-DocType: Consultation,Consultation,Beratung
-DocType: Accounts Settings,Show Payment Schedule in Print,Zeige Zahlungstermin in Drucken
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Verkauf und Retouren
-apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Varianten anzeigen
-DocType: Academic Term,Academic Term,Semester
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Stoff
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Website erstellen
-DocType: Opening Invoice Creation Tool Item,Quantity,Menge
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Kontenliste darf nicht leer sein.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Darlehen/Kredite (Verbindlichkeiten)
-DocType: Employee Education,Year of Passing,Abschlussjahr
-DocType: Item,Country of Origin,Herkunftsland
-DocType: Soil Texture,Soil Texture Criteria,Bodentextur Kriterien
-apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Auf Lager
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Primäre Kontaktdaten
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,offene Probleme
-DocType: Production Order,Production Plan Item,Artikel auf dem Produktionsplan
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Benutzer {0} ist bereits Mitarbeiter {1} zugewiesen
-DocType: Lab Test Groups,Add new line,Neue Zeile hinzufügen
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Gesundheitswesen
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Zahlungsverzug (Tage)
-DocType: Payment Terms Template Detail,Payment Terms Template Detail,Details zur Zahlungsbedingungsvorlage
-DocType: Hotel Room Reservation,Guest Name,Gastname
-DocType: Lab Prescription,Lab Prescription,Labor Rezept
-,Delay Days,Verzögerungstage
-apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Dienstzeitaufwand
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899,Serial Number: {0} is already referenced in Sales Invoice: {1},Seriennummer: {0} wird bereits in der Verkaufsrechnung referenziert: {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880,Invoice,Rechnung
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145,Make Retention Stock Entry,Machen Sie den Vorratsbestandseintrag
-DocType: Purchase Invoice Item,Item Weight Details,Artikel Gewicht Details
-DocType: Asset Maintenance Log,Periodicity,Häufigkeit
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Fiscal Year {0} ist erforderlich
-DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Der Mindestabstand zwischen den Pflanzenreihen für optimales Wachstum
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Verteidigung
-DocType: Salary Component,Abbr,Kürzel
-DocType: Appraisal Goal,Score (0-5),Punktzahl (0-5)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,Row {0}: {1} {2} does not match with {3},Zeile {0}: {1} {2} stimmt nicht mit {3} überein
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77,Row # {0}:,Zeile # {0}:
-DocType: Timesheet,Total Costing Amount,Gesamtkalkulation Betrag
-DocType: Delivery Note,Vehicle No,Fahrzeug-Nr.
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +162,Please select Price List,Bitte eine Preisliste auswählen
-DocType: Accounts Settings,Currency Exchange Settings,Währungsaustausch Einstellungen
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,"Row # {0}: Zahlungsbeleg ist erforderlich, um die trasaction abzuschließen"
-DocType: Production Order Operation,Work In Progress,Laufende Arbeit/-en
-apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Bitte wählen Sie Datum
-DocType: Daily Work Summary Group,Holiday List,Urlaubsübersicht
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Buchhalter
-DocType: Hub Settings,Selling Price List,Verkaufspreisliste
-DocType: Patient,Tobacco Current Use,Tabakstrom Verwendung
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Verkaufsrate
-DocType: Cost Center,Stock User,Lager-Benutzer
-DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
-DocType: Company,Phone No,Telefonnummer
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239,New {0}: #{1},Neu {0}: #{1}
-DocType: Delivery Trip,Initial Email Notification Sent,Erste E-Mail-Benachrichtigung gesendet
-,Sales Partners Commission,Vertriebspartner-Provision
-DocType: Soil Texture,Sandy Clay Loam,Sandiger Ton Lehm
-DocType: Purchase Invoice,Rounding Adjustment,Rundungseinstellung
-apps/erpnext/erpnext/setup/doctype/company/company.py +46,Abbreviation cannot have more than 5 characters,Abkürzung darf nicht länger als 5 Zeichen sein
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundengruppe&gt; Gebiet
-DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Arzt Zeitplan Zeitplan
-DocType: Payment Request,Payment Request,Zahlungsaufforderung
-DocType: Asset,Value After Depreciation,Wert nach Abschreibung
-DocType: Student,O+,O +
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,Zugehörig
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Die Teilnahme Datum kann nicht kleiner sein als Verbindungsdatum des Mitarbeiters
-DocType: Grading Scale,Grading Scale Name,Notenskala Namen
-DocType: Subscription,Repeat on Day,Wiederholen am Tag
-apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,Dies ist ein Root-Konto und kann nicht bearbeitet werden.
-DocType: Sales Invoice,Company Address,Firmenanschrift
-DocType: BOM,Operations,Arbeitsvorbereitung
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Genehmigung kann nicht auf der Basis des Rabattes für {0} festgelegt werden
-DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name",".csv-Datei mit zwei Zeilen, eine für den alten und eine für den neuen Namen, anhängen"
-apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} nicht in einem aktiven Geschäftsjahr.
-DocType: Packed Item,Parent Detail docname,Übergeordnetes Detail Dokumentenname
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Referenz: {0}, Item Code: {1} und Kunde: {2}"
-apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,kg
-apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Stellenausschreibung
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114,BOM is not specified for subcontracting item {0} at row {1},Die Stückliste ist für die Lohnbearbeitungseinheit {0} in der Zeile {1} nicht angegeben.
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Ergebnis übermittelt
-DocType: Item Attribute,Increment,Schrittweite
-apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Zeitspanne
-apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Lager auswählen ...
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Werbung
-apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Gleiche Firma wurde mehr als einmal eingegeben
-DocType: Patient,Married,Verheiratet
-apps/erpnext/erpnext/accounts/party.py +42,Not permitted for {0},Nicht zulässig für {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Holen Sie Elemente aus
-DocType: Price List,Price Not UOM Dependant,Preis nicht UOM abhängig
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467,Stock cannot be updated against Delivery Note {0},Lager kann nicht mit Lieferschein {0} aktualisiert werden
-apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produkt {0}
-apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Keine Artikel aufgeführt
-DocType: Asset Repair,Error Description,Fehlerbeschreibung
-DocType: Payment Reconciliation,Reconcile,Abgleichen
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Lebensmittelgeschäft
-DocType: Quality Inspection Reading,Reading 1,Ablesewert 1
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Pensionsfonds
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,Nächstes Abschreibedatum kann nicht vor dem Kaufdatum sein
-DocType: Crop,Perennial,Staude
-DocType: Consultation,Consultation Date,Konsultationsdatum
-DocType: Accounts Settings,Use Custom Cash Flow Format,Verwenden Sie das benutzerdefinierte Cashflow-Format
-DocType: SMS Center,All Sales Person,Alle Vertriebsmitarbeiter
-DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Monatliche Ausschüttung ** hilft Ihnen, das Budget / Ziel über Monate zu verteilen, wenn Sie Saisonalität in Ihrem Unternehmen haben."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1752,Not items found,Nicht Artikel gefunden
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Gehaltsstruktur Fehlende
-DocType: Lead,Person Name,Name der Person
-DocType: Sales Invoice Item,Sales Invoice Item,Ausgangsrechnungs-Artikel
-DocType: Account,Credit,Haben
-DocType: POS Profile,Write Off Cost Center,Kostenstelle für Abschreibungen
-apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""","z.B. ""Grundschule"" oder ""Universität"""
-apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Lagerberichte
-DocType: Warehouse,Warehouse Detail,Lagerdetail
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Der Begriff Enddatum kann nicht später sein als das Jahr Enddatum des Akademischen Jahres an dem der Begriff verknüpft ist (Akademisches Jahr {}). Bitte korrigieren Sie die Daten und versuchen Sie es erneut.
-apps/erpnext/erpnext/stock/doctype/item/item.py +268,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Ist Anlagevermögen"" kann nicht deaktiviert werden, da Anlagebuchung gegen den Artikel vorhanden"
-DocType: Delivery Trip,Departure Time,Abfahrtszeit
-DocType: Vehicle Service,Brake Oil,Bremsöl
-DocType: Tax Rule,Tax Type,Steuerart
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +581,Taxable Amount,Steuerpflichtiger Betrag
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Sie haben keine Berechtigung Buchungen vor {0} hinzuzufügen oder zu aktualisieren
-DocType: BOM,Item Image (if not slideshow),Artikelbild (wenn keine Diashow)
-DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Stundensatz / 60) * tatsächliche Betriebszeit
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Row # {0}: Referenzdokumenttyp muss einer der Kostenansprüche oder des Journaleintrags sein
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +966,Select BOM,Wählen Sie BOM
-DocType: SMS Log,SMS Log,SMS-Protokoll
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Aufwendungen für gelieferte Artikel
-apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Verwalten Sie den Vorschussbetrag an den Mitarbeiter
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Der Urlaub am {0} ist nicht zwischen dem Von-Datum und dem Bis-Datum
-DocType: Student Log,Student Log,Studenten Log
-apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Vorlagen der Lieferantenwertung.
-DocType: Lead,Interested,Interessiert
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216,Opening,Eröffnung
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Von {0} bis {1}
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Fehler beim Einrichten der Steuern
-DocType: Item,Copy From Item Group,Von Artikelgruppe kopieren
-DocType: Delivery Trip,Delivery Notification,Versandbenachrichtigung
-DocType: Journal Entry,Opening Entry,Eröffnungsbuchung
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Reines Zahlungskonto
-DocType: Employee Loan,Repay Over Number of Periods,Repay über Anzahl der Perioden
-DocType: Stock Entry,Additional Costs,Zusätzliche Kosten
-apps/erpnext/erpnext/accounts/doctype/account/account.py +138,Account with existing transaction can not be converted to group.,Ein Konto mit bestehenden Transaktionen kann nicht in eine Gruppe umgewandelt werden
-DocType: Lead,Product Enquiry,Produktanfrage
-DocType: Education Settings,Validate Batch for Students in Student Group,Validiere Charge für Studierende in der Studentengruppe
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Kein Urlaubssatz für Mitarbeiter gefunden {0} von {1}
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Bitte zuerst die Firma angeben
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365,Please select Company first,Bitte zuerst Firma auswählen
-DocType: Employee Education,Under Graduate,Schulabgänger
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Ziel auf
-DocType: BOM,Total Cost,Gesamtkosten
-DocType: Soil Analysis,Ca/K,Ca / K
-DocType: Journal Entry Account,Employee Loan,MItarbeiterdarlehen
-DocType: Fee Schedule,Send Payment Request Email,Sende Zahlungsauftrag E-Mail
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +269,Item {0} does not exist in the system or has expired,Artikel {0} ist nicht im System vorhanden oder abgelaufen
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Immobilien
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Kontoauszug
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Pharmaprodukte
-DocType: Purchase Invoice Item,Is Fixed Asset,Ist Anlagevermögen
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +260,"Available qty is {0}, you need {1}","Verfügbare Menge ist {0}, müssen Sie {1}"
-DocType: Expense Claim Detail,Claim Amount,Betrag einfordern
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Doppelte Kundengruppe in der cutomer Gruppentabelle gefunden
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Lieferantentyp / Lieferant
-DocType: Naming Series,Prefix,Präfix
-apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Veranstaltungsort
-DocType: Asset Settings,Asset Settings,Anlageneinstellungen
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Verbrauchsgut
-DocType: Student,B-,B-
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98,Successfully unregistered.,Erfolgreich nicht registriert.
-DocType: Assessment Result,Grade,Klasse
-DocType: Restaurant Table,No of Seats,Anzahl der Sitze
-DocType: Subscription,"To add dynamic subject, use jinja tags like
-
-<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Um dynamisches Thema hinzuzufügen, benutze Jinja-Tags wie <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
-DocType: Sales Invoice Item,Delivered By Supplier,Geliefert von Lieferant
-DocType: Asset Maintenance Task,Asset Maintenance Task,Asset-Wartungsaufgabe
-DocType: SMS Center,All Contact,Alle Kontakte
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954,Production Order already created for all items with BOM,Fertigungsauftrag bereits für alle Positionen mit BOM erstellt
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Annual Salary,Jahresgehalt
-DocType: Daily Work Summary,Daily Work Summary,tägliche Arbeitszusammenfassung
-DocType: Period Closing Voucher,Closing Fiscal Year,Abschluss des Geschäftsjahres
-apps/erpnext/erpnext/accounts/party.py +393,{0} {1} is frozen,{0} {1} ist gesperrt
-apps/erpnext/erpnext/setup/doctype/company/company.py +140,Please select Existing Company for creating Chart of Accounts,Bitte wählen Sie Bestehende Unternehmen für die Erstellung von Konten
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Lagerkosten
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Wählen Sie Target Warehouse
-apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Bitte geben Sie Bevorzugte Kontakt per E-Mail
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxNum,CompAuxNum
-DocType: Journal Entry,Contra Entry,Gegenbuchung
-DocType: Journal Entry Account,Credit in Company Currency,(Gut)Haben in Unternehmenswährung
-DocType: Lab Test UOM,Lab Test UOM,Labortest UOM
-DocType: Delivery Note,Installation Status,Installationsstatus
-DocType: BOM,Quality Inspection Template,Qualitätsinspektionsvorlage
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
-					<br>Absent: {1}",Wollen Sie die Teilnahme zu aktualisieren? <br> Present: {0} \ <br> Abwesend: {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +344,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
-DocType: Request for Quotation,RFQ-,RFQ-
-DocType: Item,Supply Raw Materials for Purchase,Rohmaterial für Einkauf bereitstellen
-DocType: Agriculture Analysis Criteria,Fertilizer,Dünger
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152,At least one mode of payment is required for POS invoice.,Mindestens eine Art der Bezahlung ist für POS-Rechnung erforderlich.
-DocType: Products Settings,Show Products as a List,Produkte anzeigen als Liste
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +519,Item {0} is not active or end of life has been reached,Artikel {0} ist nicht aktiv oder hat das Ende der Lebensdauer erreicht
-DocType: Student Admission Program,Minimum Age,Mindestalter
-apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Beispiel: Basismathematik
-DocType: Customer,Primary Address,Hauptadresse
-DocType: Production Plan,Material Request Detail,Materialanforderungsdetail
-DocType: Selling Settings,Default Quotation Validity Days,Standard-Angebotsgültigkeitstage
-apps/erpnext/erpnext/controllers/accounts_controller.py +793,"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"
-apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Einstellungen für das Personal-Modul
-DocType: SMS Center,SMS Center,SMS-Center
-DocType: Sales Invoice,Change Amount,Anzahl ändern
-DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Rechnungswert für B2C festlegen B2CL und B2CS basierend auf diesem Rechnungswert berechnet.
-DocType: BOM Update Tool,New BOM,Neue Stückliste
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Zeige nur POS
-DocType: Driver,Driving License Categories,Führerscheinkategorien
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Bitte geben Sie das Lieferdatum ein
-DocType: Depreciation Schedule,Make Depreciation Entry,Neuen Abschreibungseintrag erstellen
-DocType: Appraisal Template Goal,KRA,KRA
-DocType: Lead,Request Type,Anfragetyp
-apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17,Make Employee,Mitarbeiter anlegen
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Rundfunk
-apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Einrichtungsmodus des POS (Online / Offline)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Ausführung
-apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Details der durchgeführten Arbeitsgänge
-DocType: Asset Maintenance Log,Maintenance Status,Wartungsstatus
-apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Mitgliedschaftsdetails
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Für das Kreditorenkonto ist ein Lieferant erforderlich {2}
-apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Artikel und Preise
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Stundenzahl: {0}
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},"Von-Datum sollte im Geschäftsjahr liegen. Unter der Annahme, Von-Datum = {0}"
-DocType: Drug Prescription,Interval,Intervall
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +252,Preference,Präferenz
-DocType: Grant Application,Individual,Einzelperson
-DocType: Academic Term,Academics User,Benutzer: Lehre
-DocType: Cheque Print Template,Amount In Figure,Betrag als Zahl
-DocType: Employee Loan Application,Loan Info,Darlehensinformation
-apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plan für Wartungsbesuche
-DocType: Supplier Scorecard Period,Supplier Scorecard Period,Supplier Scorecard Zeitraum
-DocType: Share Transfer,Share Transfer,Weitergabe übertragen
-DocType: POS Profile,Customer Groups,Kundengruppen
-apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Jahresabschluss
-DocType: Guardian,Students,Studenten
-apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Regeln für die Anwendung von Preisen und Rabatten
-DocType: Daily Work Summary,Daily Work Summary Group,Tägliche Arbeitszusammenfassungsgruppe
-DocType: Physician Schedule,Time Slots,Zeitfenster
-apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Preisliste muss für Einkauf oder Vertrieb gültig sein
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Installationsdatum kann nicht vor dem Liefertermin für Artikel {0} liegen
-DocType: Pricing Rule,Discount on Price List Rate (%),Rabatt auf die Preisliste (%)
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Artikelvorlage
-apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biochemie
-DocType: Job Offer,Select Terms and Conditions,Bitte Geschäftsbedingungen auswählen
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Out Value,Out Wert
-DocType: Production Plan,Sales Orders,Kundenaufträge
-DocType: Purchase Taxes and Charges,Valuation,Bewertung
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +386,Set as Default,Als Standard festlegen
-DocType: Production Plan,PLN-,PLN-
-,Purchase Order Trends,Entwicklung Lieferantenaufträge
-apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Gehen Sie zu Kunden
-DocType: Hotel Room Reservation,Late Checkin,Später Check-In
-apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Die Angebotsanfrage kann durch einen Klick auf den folgenden Link abgerufen werden
-apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Urlaube für ein Jahr zuordnen
-DocType: SG Creation Tool Course,SG Creation Tool Course,SG Creation Tool-Kurs
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +262,Insufficient Stock,Nicht genug Lagermenge.
-DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Kapazitätsplanung und Zeiterfassung deaktivieren
-DocType: Email Digest,New Sales Orders,Neue Kundenaufträge
-DocType: Bank Guarantee,Bank Account,Bankkonto
-DocType: Leave Type,Allow Negative Balance,Negativen Saldo zulassen
-apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Sie können den Projekttyp &#39;Extern&#39; nicht löschen
-DocType: Employee,Create User,Benutzer erstellen
-DocType: Selling Settings,Default Territory,Standardregion
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Fernsehen
-DocType: Production Order Operation,Updated via 'Time Log',"Aktualisiert über ""Zeitprotokoll"""
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +430,Advance amount cannot be greater than {0} {1},Anzahlung kann nicht größer sein als {0} {1}
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,Journalcode
-DocType: Naming Series,Series List for this Transaction,Nummernkreise zu diesem Vorgang
-DocType: Company,Enable Perpetual Inventory,Permanente Inventur aktivieren
-DocType: Company,Default Payroll Payable Account,Standardabrechnungskreditorenkonto
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,E-Mail-Gruppe aktualisieren
-DocType: Sales Invoice,Is Opening Entry,Ist Eröffnungsbuchung
-DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Wenn nicht markiert, wird das Element nicht in der Verkaufsrechnung angezeigt, sondern kann bei der Gruppentesterstellung verwendet werden."
-DocType: Customer Group,Mention if non-standard receivable account applicable,"Vermerken, wenn kein Standard-Forderungskonto verwendbar ist"
-DocType: Course Schedule,Instructor Name,Ausbilder-Name
-DocType: Supplier Scorecard,Criteria Setup,Kriterieneinstellung
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +206,For Warehouse is required before Submit,"""Für Lager"" wird vor dem Übertragen benötigt"
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Eingegangen am
-DocType: Sales Partner,Reseller,Wiederverkäufer
-DocType: Codification Table,Medical Code,Medizinischer Code
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Bitte Firmenname angeben
-DocType: Delivery Note Item,Against Sales Invoice Item,Zu Ausgangsrechnungs-Position
-DocType: Agriculture Analysis Criteria,Linked Doctype,Verknüpfter Doctype
-,Production Orders in Progress,Fertigungsaufträge in Arbeit
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44,Net Cash from Financing,Nettocashflow aus Finanzierung
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2359,"LocalStorage is full , did not save","LocalStorage ist voll, nicht gespeichert"
-DocType: Lead,Address & Contact,Adresse & Kontakt
-DocType: Leave Allocation,Add unused leaves from previous allocations,Ungenutzten Urlaub von vorherigen Zuteilungen hinzufügen
-DocType: Sales Partner,Partner website,Partner-Website
-DocType: Restaurant Order Entry,Add Item,Artikel hinzufügen
-DocType: Lab Test,Custom Result,Benutzerdefiniertes Ergebnis
-DocType: Delivery Stop,Contact Name,Ansprechpartner
-DocType: Course Assessment Criteria,Course Assessment Criteria,Kursbeurteilungskriterien
-DocType: POS Customer Group,POS Customer Group,POS Kundengruppe
-DocType: Land Unit,Land Unit describing various land assets,Land Unit beschreibt verschiedene Land Vermögenswerte
-DocType: Cheque Print Template,Line spacing for amount in words,Zeilenabstand für Betrag in Worten
-DocType: Vehicle,Additional Details,Weitere Details
-apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Keine Beschreibung angegeben
-apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Lieferantenanfrage
-DocType: Lab Test,Submitted Date,Eingeschriebenes Datum
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Dies wird auf der Grundlage der Zeitblätter gegen dieses Projekt erstellt
-DocType: Payment Term,Credit Months,Kreditmonate
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +408,Net Pay cannot be less than 0,Net Pay kann nicht kleiner als 0
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Um das Senden von sich wiederholenden Fehlerbenachrichtigungen aus dem System zu beenden, haben wir das Feld Deaktiviert im Abonnement aktiviert."
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Freitstellungsdatum muss nach dem Eintrittsdatum liegen
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Leaves per Year,Abwesenheiten pro Jahr
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Zeile {0}: Wenn es sich um eine Vorkasse-Buchung handelt, bitte ""Ist Vorkasse"" zu Konto {1} anklicken, ."
-apps/erpnext/erpnext/stock/utils.py +219,Warehouse {0} does not belong to company {1},Lager {0} gehört nicht zu Firma {1}
-DocType: Email Digest,Profit & Loss,Profiteinbuße
-apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Liter
-DocType: Task,Total Costing Amount (via Time Sheet),Gesamtkostenbetrag (über Arbeitszeitblatt)
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Bitte richten Sie Schüler unter Schülergruppen ein
-DocType: Item Website Specification,Item Website Specification,Artikel-Webseitenspezifikation
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449,Leave Blocked,Urlaub gesperrt
-apps/erpnext/erpnext/stock/doctype/item/item.py +739,Item {0} has reached its end of life on {1},Artikel {0} hat das Ende seiner Lebensdauer erreicht zum Datum {1}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83,Bank Entries,Bank-Einträge
-DocType: Crop,Annual,Jährlich
-DocType: Stock Reconciliation Item,Stock Reconciliation Item,Bestandsabgleich-Artikel
-DocType: Stock Entry,Sales Invoice No,Ausgangsrechnungs-Nr.
-DocType: Material Request Item,Min Order Qty,Mindestbestellmenge
-DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Student Group Creation Tool-Kurs
-DocType: Lead,Do Not Contact,Nicht Kontakt aufnehmen
-apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,"Menschen, die in Ihrer Organisation lehren"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Software-Entwickler
-DocType: Item,Minimum Order Qty,Mindestbestellmenge
-DocType: Pricing Rule,Supplier Type,Lieferantentyp
-DocType: Course Scheduling Tool,Course Start Date,Kursbeginn
-,Student Batch-Wise Attendance,Student Batch-Wise Teilnahme
-DocType: POS Profile,Allow user to edit Rate,Benutzer darf Höhe bearbeiten
-DocType: Item,Publish in Hub,Im Hub veröffentlichen
-DocType: Student Admission,Student Admission,Studenten Eintritt
-,Terretory,Region
-apps/erpnext/erpnext/stock/doctype/item/item.py +761,Item {0} is cancelled,Artikel {0} wird storniert
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1055,Material Request,Materialanfrage
-DocType: Bank Reconciliation,Update Clearance Date,Abwicklungsdatum aktualisieren
-,GSTR-2,GSTR-2
-DocType: Item,Purchase Details,Einkaufsdetails
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +394,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},"Artikel {0} in Tabelle ""Rohmaterialien geliefert"" des Lieferantenauftrags {1} nicht gefunden"
-DocType: Salary Slip,Total Principal Amount,Gesamtbetrag
-DocType: Student Guardian,Relation,Beziehung
-DocType: Student Guardian,Mother,Mutter
-DocType: Restaurant Reservation,Reservation End Time,Reservierungsendzeit
-DocType: Crop,Biennial,Biennale
-apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Bestätigte Aufträge von Kunden
-DocType: Purchase Receipt Item,Rejected Quantity,Ausschuss-Menge
-apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Zahlungsauftrag {0} erstellt
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Offene Bestellungen
-apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Geringe Empfindlichkeit
-DocType: Notification Control,Notification Control,Benachrichtungseinstellungen
-apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,"Bitte bestätigen Sie, sobald Sie Ihre Ausbildung abgeschlossen haben"
-DocType: Lead,Suggestions,Vorschläge
-DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Artikelgruppenbezogene Budgets für diese Region erstellen. Durch Setzen der Auslieferungseinstellungen können auch saisonale Aspekte mit einbezogen werden.
-DocType: Payment Term,Payment Term Name,Name der Zahlungsbedingung
-DocType: Healthcare Settings,Create documents for sample collection,Erstellen Sie Dokumente für die Probenahme
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Zahlung zu {0} {1} kann nicht größer als ausstehender Betrag {2} sein
-DocType: Shareholder,Address HTML,Adresse im HTML-Format
-DocType: Lead,Mobile No.,Mobilfunknr.
-DocType: Maintenance Schedule,Generate Schedule,Zeitplan generieren
-DocType: Purchase Invoice Item,Expense Head,Ausgabenbezeichnung
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138,Please select Charge Type first,Bitte zuerst Chargentyp auswählen
-DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Sie können hier alle Aufgaben definieren, die für diese Kultur durchgeführt werden sollen. Das Tagesfeld wird verwendet, um den Tag zu nennen, an dem die Aufgabe ausgeführt werden muss, wobei 1 der 1. Tag usw. ist."
-DocType: Student Group Student,Student Group Student,Student Group Student
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Neueste(r/s)
-DocType: Asset Maintenance Task,2 Yearly,Alle 2 Jahre
-DocType: Education Settings,Education Settings,Bildungseinstellungen
-DocType: Vehicle Service,Inspection,Kontrolle
-DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
-DocType: Email Digest,New Quotations,Neue Angebote
-DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,E-Mails Gehaltsabrechnung an Mitarbeiter auf Basis von bevorzugten E-Mail in Mitarbeiter ausgewählt
-DocType: Employee,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
-DocType: Tax Rule,Shipping County,Versand-Landesbezirk/-Gemeinde/-Kreis
-apps/erpnext/erpnext/config/desktop.py +167,Learn,Lernen
-DocType: Asset,Next Depreciation Date,Nächstes Abschreibungsdatum
-apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Aktivitätskosten je Mitarbeiter
-DocType: Accounts Settings,Settings for Accounts,Konteneinstellungen
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673,Supplier Invoice No exists in Purchase Invoice {0},Lieferantenrechnung existiert in Kauf Rechnung {0}
-apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Baumstruktur der Vertriebsmitarbeiter verwalten
-DocType: Job Applicant,Cover Letter,Motivationsschreiben
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Ausstehende Schecks und Anzahlungen zum verbuchen
-DocType: Item,Synced With Hub,Synchronisiert mit Hub
-DocType: Driver,Fleet Manager,Flottenmanager
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} kann für Artikel nicht negativ sein {2}
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Falsches Passwort
-DocType: Item,Variant Of,Variante von
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +406,Completed Qty can not be greater than 'Qty to Manufacture',"Gefertigte Menge kann nicht größer sein als ""Menge für Herstellung"""
-DocType: Period Closing Voucher,Closing Account Head,Bezeichnung des Abschlusskontos
-DocType: Employee,External Work History,Externe Arbeits-Historie
-DocType: Physician,Time per Appointment,Zeit pro Termin
-apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Zirkelschluss-Fehler
-DocType: Appointment Type,Is Inpatient,Ist stationär
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1 Namen
-DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"""In Worten (Export)"" wird sichtbar, sobald Sie den Lieferschein speichern."
-DocType: Cheque Print Template,Distance from left edge,Entfernung vom linken Rand
-apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} Einheiten [{1}] (# Form / Item / {1}) im Lager [{2}] (# Form / Lager / {2})
-DocType: Lead,Industry,Industrie
-DocType: Employee,Job Profile,Stellenbeschreibung
-DocType: BOM Item,Rate & Amount,Rate &amp; Betrag
-apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Dies beruht auf Transaktionen gegen diese Gesellschaft. Siehe Zeitleiste unten für Details
-DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Bei Erstellung einer automatischen Materialanfrage per E-Mail benachrichtigen
-apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Beständig
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Bitte setzen Sie den Zimmerpreis auf {}
-DocType: Journal Entry,Multi Currency,Unterschiedliche Währungen
-DocType: Opening Invoice Creation Tool,Invoice Type,Rechnungstyp
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939,Delivery Note,Lieferschein
-DocType: Consultation,Encounter Impression,Begegnung Eindruck
-apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Steuern einrichten
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Herstellungskosten des verkauften Vermögens
-DocType: Volunteer,Morning,Morgen
-apps/erpnext/erpnext/accounts/utils.py +350,Payment Entry has been modified after you pulled it. Please pull it again.,"Zahlungsbuchung wurde geändert, nachdem sie abgerufen wurde. Bitte erneut abrufen."
-DocType: Program Enrollment Tool,New Student Batch,Neue Studentencharge
-apps/erpnext/erpnext/stock/doctype/item/item.py +478,{0} entered twice in Item Tax,{0} in Artikelsteuer doppelt eingegeben
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Zusammenfassung für diese Woche und anstehende Aktivitäten
-DocType: Student Applicant,Admitted,Zugelassen
-DocType: Workstation,Rent Cost,Mietkosten
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Betrag nach Abschreibungen
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Die nächsten Kalender Ereignisse
-apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Variantenattribute
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Bitte Monat und Jahr auswählen
-DocType: Employee,Company Email,Email-Adresse der Firma
-DocType: GL Entry,Debit Amount in Account Currency,Soll-Betrag in Kontowährung
-DocType: Supplier Scorecard,Scoring Standings,Punkte zählen
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Bestellwert
-apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Bank / Geldgeschäfte gegen Partei oder für die interne Übertragung
-DocType: Shipping Rule,Valid for Countries,Gültig für folgende Länder
-apps/erpnext/erpnext/stock/doctype/item/item.js +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Dieser Artikel ist eine Vorlage und kann nicht in Transaktionen verwendet werden. Artikelattribute werden in die Varianten kopiert, es sein denn es wurde ""nicht kopieren"" ausgewählt"
-DocType: Grant Application,Grant Application,Antrag bewilligen
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Geschätzte Summe der Bestellungen
-apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Mitarbeiterbezeichnung (z. B. Geschäftsführer, Direktor etc.)"
-DocType: Sales Invoice,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"
-DocType: Course Scheduling Tool,Course Scheduling Tool,Kursplanung Werkzeug
-apps/erpnext/erpnext/controllers/accounts_controller.py +622,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Kauf Rechnung kann nicht gegen einen bereits bestehenden Asset vorgenommen werden {1}
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257,[Urgent] Error while creating recurring %s for %s,[Dringend] Fehler beim Erstellen von wiederkehrenden% s für% s
-DocType: Land Unit,LInked Analysis,Verknüpfte Analyse
-DocType: Item Tax,Tax Rate,Steuersatz
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,Application period cannot be across two allocation records,Der Bewerbungszeitraum kann nicht über zwei Zuordnungssätze liegen
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} bereits an Mitarbeiter {1} zugeteilt für den Zeitraum {2} bis {3}
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,Purchase Invoice {0} is already submitted,Eingangsrechnung {0} wurde bereits übertragen
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Zeile # {0}: Chargennummer muss dieselbe sein wie {1} {2}
-DocType: Material Request Plan Item,Material Request Plan Item,Materialanforderung Planelement
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,In nicht-Gruppe umwandeln
-DocType: C-Form Invoice Detail,Invoice Date,Rechnungsdatum
-DocType: GL Entry,Debit Amount,Soll-Betrag
-apps/erpnext/erpnext/accounts/party.py +249,There can only be 1 Account per Company in {0} {1},Es kann nur EIN Konto pro Unternehmen in {0} {1} geben
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +425,Please see attachment,Bitte Anhang beachten
-DocType: Purchase Order,% Received,% erhalten
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Studentengruppen erstellen
-DocType: Volunteer,Weekends,Wochenenden
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +113,Credit Note Amount,Gutschriftbetrag
-DocType: Setup Progress Action,Action Document,Aktions-Dokument
-DocType: Chapter Member,Website URL,Webseiten-URL
-,Finished Goods,Fertigerzeugnisse
-DocType: Delivery Note,Instructions,Anweisungen
-DocType: Quality Inspection,Inspected By,kontrolliert durch
-DocType: Asset Maintenance Log,Maintenance Type,Wartungstyp
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} ist nicht im Kurs {2} eingeschrieben
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Seriennummer {0} gehört nicht zu Lieferschein {1}
-apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
-apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Mehrere Artikel hinzufügen
-DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Parameter der Artikel-Qualitätsprüfung
-DocType: Depreciation Schedule,Schedule Date,Geplantes Datum
-apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Gehalt, Abzüge und andere Gehaltskomponenten"
-DocType: Packed Item,Packed Item,Verpackter Artikel
-DocType: Job Offer Term,Job Offer Term,Jobangebot
-apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Standardeinstellungen für Einkaufstransaktionen
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Aktivitätskosten bestehen für Arbeitnehmer {0} zur Aktivitätsart {1}
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Pflichtfeld - Holen Sie sich Studenten aus
-DocType: Program Enrollment,Enrolled courses,Eingeschriebene Kurse
-DocType: Currency Exchange,Currency Exchange,Währungs-Umrechnung
-DocType: Opening Invoice Creation Tool Item,Item Name,Artikelname
-DocType: Authorization Rule,Approving User  (above authorized value),Genehmigender Benutzer (über dem autorisierten Wert)
-DocType: Email Digest,Credit Balance,Verfügbarer Kredit
-DocType: Employee,Widowed,Verwitwet
-DocType: Request for Quotation,Request for Quotation,Angebotsanfrage
-DocType: Healthcare Settings,Require Lab Test Approval,Erforderliche Labortests genehmigen
-DocType: Salary Slip Timesheet,Working Hours,Arbeitszeit
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +54,Total Outstanding,Absolut aussergewöhnlich
-DocType: Naming Series,Change the starting / current sequence number of an existing series.,Anfangs- / Ist-Wert eines Nummernkreises ändern.
-DocType: Dosage Strength,Strength,Stärke
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1533,Create a new Customer,Erstellen Sie einen neuen Kunden
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Wenn mehrere Preisregeln weiterhin gleichrangig gelten, werden die Benutzer aufgefordert, Vorrangregelungen manuell zu erstellen, um den Konflikt zu lösen."
-apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Bestellungen erstellen
-,Purchase Register,Übersicht über Einkäufe
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +119,Patient not found,Patient nicht gefunden
-DocType: Scheduling Tool,Rechedule,neu Terminieren
-DocType: Landed Cost Item,Applicable Charges,Anfallende Gebühren
-DocType: Workstation,Consumable Cost,Verbrauchskosten
-DocType: Purchase Receipt,Vehicle Date,Fahrzeug-Datum
-DocType: Student Log,Medical,Medizinisch
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Reason for losing,Grund für das Verlieren
-apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Kontonummer aktualisieren
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Lead-Besitzer können nicht gleich dem Lead sein
-apps/erpnext/erpnext/accounts/utils.py +356,Allocated amount can not greater than unadjusted amount,Zugeteilter Betrag kann nicht größer sein als nicht angepasster Betrag
-DocType: Announcement,Receiver,Empfänger
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Arbeitsplatz ist an folgenden Tagen gemäß der Urlaubsliste geschlossen: {0}
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Chancen
-DocType: Lab Test Template,Single,Ledig
-DocType: Salary Slip,Total Loan Repayment,Insgesamt Loan Rückzahlung
-DocType: Account,Cost of Goods Sold,Selbstkosten
-DocType: Subscription,Yearly,Jährlich
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,Bitte die Kostenstelle eingeben
-DocType: Drug Prescription,Dosage,Dosierung
-DocType: Journal Entry Account,Sales Order,Kundenauftrag
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Durchschnittlicher Verkaufspreis
-DocType: Assessment Plan,Examiner Name,Prüfer-Name
-DocType: Lab Test Template,No Result,Kein Ergebnis
-DocType: Purchase Invoice Item,Quantity and Rate,Menge und Preis
-DocType: Delivery Note,% Installed,% installiert
-apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,"Die Klassenräume / Laboratorien usw., wo Vorträge können geplant werden."
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Bitte zuerst den Firmennamen angeben
-DocType: Purchase Invoice,Supplier Name,Lieferantenname
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Lesen Sie das ERPNext-Handbuch
-DocType: Purchase Invoice,01-Sales Return,01-Verkaufsrückgabe
-DocType: Account,Is Group,Ist Gruppe
-DocType: Email Digest,Pending Purchase Orders,Bis Bestellungen
-DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatisch Seriennummern auf Basis FIFO einstellen
-DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,"Aktivieren, damit dieselbe Lieferantenrechnungsnummer nur einmal vorkommen kann"
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Primäre Adressendetails
-DocType: Vehicle Service,Oil Change,Ölwechsel
-DocType: Asset Maintenance Log,Asset Maintenance Log,Anlagenwartungsprotokoll
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',"""Bis Fall Nr."" kann nicht kleiner als ""Von Fall Nr."" sein"
-DocType: Chapter,Non Profit,Gemeinnützig
-DocType: Production Order,Not Started,Nicht begonnen
-DocType: Lead,Channel Partner,Vertriebspartner
-DocType: Account,Old Parent,Alte übergeordnetes Element
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Pflichtfeld - Akademisches Jahr
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +215,{0} {1} is not associated with {2} {3},{0} {1} ist nicht mit {2} {3} verknüpft
-DocType: Notification Control,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 eigenen Einleitungstext."
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +174,Please set default payable account for the company {0},Bitte setzen Sie das Zahlungsverzugskonto für die Firma {0}
-DocType: Setup Progress Action,Min Doc Count,Min
-apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Allgemeine Einstellungen für alle Fertigungsprozesse
-DocType: Accounts Settings,Accounts Frozen Upto,Konten gesperrt bis
-DocType: SMS Log,Sent On,Gesendet am
-apps/erpnext/erpnext/stock/doctype/item/item.py +699,Attribute {0} selected multiple times in Attributes Table,Attribut {0} mehrfach in Attributetabelle ausgewäht
-DocType: HR Settings,Employee record is created using selected field. ,Mitarbeiter-Datensatz wird erstellt anhand des ausgewählten Feldes.
-DocType: Sales Order,Not Applicable,Nicht anwenden
-apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Stammdaten zum Urlaub
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Rechnungsposition öffnen
-DocType: Request for Quotation Item,Required Date,Angefragtes Datum
-DocType: Delivery Note,Billing Address,Rechnungsadresse
-DocType: BOM,Costing,Kalkulation
-DocType: Tax Rule,Billing County,Rechnung: Landesbezirk - Gemeinde - Kreis
-DocType: Purchase Taxes and Charges,"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 den Druckkosten enthalten erachtet."
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceRef,StückRef
-DocType: Request for Quotation,Message for Supplier,Nachricht für Lieferanten
-DocType: Driver,DRIVER-.#####,TREIBER-.#####
-DocType: Sales Invoice,Total Qty,Gesamtmenge
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 E-Mail-ID
-DocType: Item,Show in Website (Variant),Auf der Website anzeigen (Variante)
-DocType: Employee,Health Concerns,Gesundheitsfragen
-DocType: Payroll Entry,Select Payroll Period,Wählen Sie Abrechnungsperiode
-DocType: Purchase Invoice,Unpaid,Unbezahlt
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Reserviert für Verkauf
-DocType: Packing Slip,From Package No.,Von Paket Nr.
-DocType: Item Attribute,To Range,Bis-Bereich
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Wertpapiere und Einlagen
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Kann die Bewertungsmethode nicht ändern, da es Transaktionen gegen einige Posten gibt, für die es keine eigene Bewertungsmethode gibt"
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Die Gesamtmenge des zugeteilten Urlaubs ist zwingend erforderlich
-DocType: Patient,AB Positive,AB +
-DocType: Job Opening,Description of a Job Opening,Stellenbeschreibung
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Pending activities for today,Ausstehende Aktivitäten für heute
-apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Anwesenheitsnachweis
-DocType: Salary Structure,Salary Component for timesheet based payroll.,Gehaltskomponente für Zeiterfassung basierte Abrechnung.
-DocType: Sales Order Item,Used for Production Plan,Wird für den Produktionsplan verwendet
-DocType: Employee Loan,Total Payment,Gesamtzahlung
-DocType: Manufacturing Settings,Time Between Operations (in mins),Zeit zwischen den Arbeitsgängen (in Minuten)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132,{0} {1} is cancelled so the action cannot be completed,"{0} {1} wurde abgebrochen, deshalb kann die Aktion nicht abgeschlossen werden"
-DocType: Customer,Buyer of Goods and Services.,Käufer von Waren und Dienstleistungen.
-DocType: Journal Entry,Accounts Payable,Verbindlichkeiten
-DocType: Patient,Allergies,Allergien
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33,The selected BOMs are not for the same item,Die ausgewählten Stücklisten sind nicht für den gleichen Artikel
-DocType: Supplier Scorecard Standing,Notify Other,Andere benachrichtigen
-DocType: Vital Signs,Blood Pressure (systolic),Blutdruck (systolisch)
-DocType: Pricing Rule,Valid Upto,Gültig bis
-DocType: Training Event,Workshop,Werkstatt
-DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Warnung Bestellungen
-apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Bitte ein paar Kunden angeben. Dies können Firmen oder Einzelpersonen sein.
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Genug Teile zu bauen
-DocType: POS Profile User,POS Profile User,POS-Profilbenutzer
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Direkte Erträge
-DocType: Patient Appointment,Date TIme,Terminzeit
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,"Can not filter based on Account, if grouped by Account","Wenn nach Konto gruppiert wurde, kann nicht auf Grundlage des Kontos gefiltert werden."
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Administrativer Benutzer
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Gründung von Unternehmen und Steuern
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Bitte wählen Sie Kurs
-DocType: Codification Table,Codification Table,Kodifizierungstabelle
-DocType: Timesheet Detail,Hrs,Std
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349,Please select Company,Bitte Firma auswählen
-DocType: Stock Entry Detail,Difference Account,Differenzkonto
-DocType: Purchase Invoice,Supplier GSTIN,Lieferant GSTIN
-apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,"Aufgabe kann nicht geschlossen werden, da die von ihr abhängige Aufgabe {0} nicht geschlossen ist."
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,"Bitte das Lager eingeben, für das eine Materialanfrage erhoben wird"
-DocType: Production Order,Additional Operating Cost,Zusätzliche Betriebskosten
-DocType: Lab Test Template,Lab Routine,Laborroutine
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kosmetika
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Bitte wählen Sie Fertigstellungsdatum für das abgeschlossene Anlagenpflegeprotokoll
-apps/erpnext/erpnext/stock/doctype/item/item.py +551,"To merge, following properties must be same for both items","Um zwei Produkte zusammenzuführen, müssen folgende Eigenschaften für beide Produkte gleich sein"
-DocType: Shipping Rule,Net Weight,Nettogewicht
-DocType: Employee,Emergency Phone,Notruf
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} ist nicht vorhanden.
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Kaufen
-,Serial No Warranty Expiry,Ablaufdatum der Garantie zu Seriennummer
-DocType: Sales Invoice,Offline POS Name,Offline-Verkaufsstellen-Name
-apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Studentische Bewerbung
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Bitte definieren Sie Grade for Threshold 0%
-DocType: Sales Order,To Deliver,Auszuliefern
-DocType: Purchase Invoice Item,Item,Artikel
-apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Hohe Empfindlichkeit
-apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Informationen zum Freiwilligentyp.
-DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Cashflow-Mapping-Vorlage
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2539,Serial no item cannot be a fraction,Serien-Nr Element kann nicht ein Bruchteil sein
-DocType: Journal Entry,Difference (Dr - Cr),Differenz (Soll - Haben)
-DocType: Account,Profit and Loss,Gewinn und Verlust
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104,"Not permitted, configure Lab Test Template as required","Nicht zulässig, konfigurieren Sie Lab Test Vorlage wie erforderlich"
-DocType: Patient,Risk Factors,Risikofaktoren
-DocType: Patient,Occupational Hazards and Environmental Factors,Berufsrisiken und Umweltfaktoren
-DocType: Vital Signs,Respiratory rate,Atemfrequenz
-apps/erpnext/erpnext/config/stock.py +334,Managing Subcontracting,Unteraufträge vergeben
-DocType: Vital Signs,Body Temperature,Körpertemperatur
-DocType: Project,Project will be accessible on the website to these users,Projekt wird auf der Website für diese Benutzer zugänglich sein
-DocType: Detected Disease,Disease,Krankheit
-apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Projekttyp definieren
-DocType: Supplier Scorecard,Weighting Function,Gewichtungsfunktion
-DocType: Physician,OP Consulting Charge,OP Beratungsgebühr
-apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Richten Sie Ihre
-DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Kurs, zu dem die Währung der Preisliste in die Basiswährung des Unternehmens umgerechnet wird"
-apps/erpnext/erpnext/setup/doctype/company/company.py +70,Account {0} does not belong to company: {1},Konto {0} gehört nicht zu Firma: {1}
-apps/erpnext/erpnext/setup/doctype/company/company.py +52,Abbreviation already used for another company,Abkürzung bereits für ein anderes Unternehmen verwendet
-DocType: Selling Settings,Default Customer Group,Standardkundengruppe
-DocType: Asset Repair,ARLOG-,ARLOG-
-DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Wenn deaktiviert, wird das Feld ""Gerundeter Gesamtbetrag"" in keiner Transaktion angezeigt"
-DocType: BOM,Operating Cost,Betriebskosten
-DocType: Crop,Produced Items,Produzierte Artikel
-DocType: Sales Order Item,Gross Profit,Rohgewinn
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Schrittweite kann nicht 0 sein
-DocType: Company,Delete Company Transactions,Löschen der Transaktionen dieser Firma
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Reference No and Reference Date is mandatory for Bank transaction,Referenznummer und Referenzdatum ist obligatorisch für Bankengeschäft
-DocType: Purchase Receipt,Add / Edit Taxes and Charges,Hinzufügen/Bearbeiten von Steuern und Abgaben
-DocType: Payment Entry Reference,Supplier Invoice No,Lieferantenrechnungsnr.
-DocType: Territory,For reference,Zu Referenzzwecken
-DocType: Healthcare Settings,Appointment Confirmation,Terminbestätigung
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Die Seriennummer {0} kann nicht gelöscht werden, da sie in Lagertransaktionen verwendet wird"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256,Closing (Cr),Schlußstand (Haben)
-apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Hallo
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Element verschieben
-DocType: Serial No,Warranty Period (Days),Garantiefrist (Tage)
-DocType: Installation Note Item,Installation Note Item,Bestandteil des Installationshinweises
-DocType: Production Plan Item,Pending Qty,Ausstehende Menge
-DocType: Budget,Ignore,Ignorieren
-apps/erpnext/erpnext/accounts/party.py +397,{0} {1} is not active,{0} {1} ist nicht aktiv
-apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Setup-Kontrollmaße für den Druck
-DocType: Salary Slip,Salary Slip Timesheet,Gehaltszettel Timesheet
-apps/erpnext/erpnext/controllers/buying_controller.py +160,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Lieferantenlager notwendig für Kaufbeleg aus Unteraufträgen
-DocType: Pricing Rule,Valid From,Gültig ab
-DocType: Sales Invoice,Total Commission,Gesamtprovision
-DocType: Pricing Rule,Sales Partner,Vertriebspartner
-apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Alle Lieferanten-Scorecards.
-DocType: Buying Settings,Purchase Receipt Required,Kaufbeleg notwendig
-apps/erpnext/erpnext/stock/doctype/item/item.py +154,Valuation Rate is mandatory if Opening Stock entered,"Bewertungskurs ist obligatorisch, wenn Öffnung Stock eingegeben"
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143,No records found in the Invoice table,Keine Datensätze in der Rechnungstabelle gefunden
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34,Please select Company and Party Type first,Bitte zuerst Firma und Gruppentyp auswählen
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Im Standardprofil {0} für den Benutzer {1} ist der Standard bereits festgelegt, standardmäßig deaktiviert"
-apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Finanz-/Rechnungsjahr
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Kumulierte Werte
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Verzeihung! Seriennummern können nicht zusammengeführt werden,"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Territory ist im POS-Profil erforderlich
-DocType: Supplier,Prevent RFQs,Vermeidung von Ausschreibungen
-apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Kundenauftrag erstellen
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Gehaltszettel für Zeitraum von {0} bis {1} eingereicht
-DocType: Project Task,Project Task,Projektvorgang
-,Lead Id,Lead-ID
-DocType: C-Form Invoice Detail,Grand Total,Gesamtbetrag
-DocType: Assessment Plan,Course,Kurs
-DocType: Timesheet,Payslip,payslip
-apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Artikel Warenkorb
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Das Startdatum des Geschäftsjahres sollte nicht nach dem Enddatum des Gschäftsjahres liegen
-DocType: Issue,Resolution,Entscheidung
-DocType: C-Form,IV,IV
-apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Geliefert: {0}
-DocType: Expense Claim,Payable Account,Verbindlichkeiten-Konto
-DocType: Payment Entry,Type of Payment,Zahlungsart
-DocType: Sales Order,Billing and Delivery Status,Abrechnungs- und Lieferstatus
-DocType: Job Applicant,Resume Attachment,Resume-Anlage
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Bestandskunden
-DocType: Leave Control Panel,Allocate,Zuweisen
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Erstellen Sie eine Variante
-DocType: Sales Invoice,Shipping Bill Date,Lieferschein-Datum
-DocType: Production Order,Production Plan,Produktionsplan
-DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Öffnen des Rechnungserstellungswerkzeugs
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853,Sales Return,Rücklieferung
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Hinweis: Die aufteilbaren Gesamt Blätter {0} sollte nicht kleiner sein als bereits genehmigt Blätter {1} für den Zeitraum
-,Total Stock Summary,Gesamt Stock Zusammenfassung
-DocType: Announcement,Posted By,Geschrieben von
-DocType: Item,Delivered by Supplier (Drop Ship),durch Lieferanten geliefert (Streckengeschäft)
-DocType: Healthcare Settings,Confirmation Message,Bestätigungsmeldung
-apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Datenbank potentieller Kunden.
-DocType: Authorization Rule,Customer or Item,Kunde oder Artikel
-apps/erpnext/erpnext/config/selling.py +28,Customer database.,Kundendatenbank
-DocType: Quotation,Quotation To,Angebot für
-DocType: Lead,Middle Income,Mittleres Einkommen
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228,Opening (Cr),Anfangssstand (Haben)
-apps/erpnext/erpnext/stock/doctype/item/item.py +871,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Die Standard-Maßeinheit für Artikel {0} kann nicht direkt geändert werden, weil Sie bereits einige Transaktionen mit einer anderen Maßeinheit durchgeführt haben. Sie müssen einen neuen Artikel erstellen, um eine andere Standard-Maßeinheit verwenden zukönnen."
-apps/erpnext/erpnext/accounts/utils.py +354,Allocated amount can not be negative,Zugewiesene Menge kann nicht negativ sein
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Bitte setzen Sie das Unternehmen
-DocType: Share Balance,Share Balance,Anteilsbestand
-DocType: Purchase Order Item,Billed Amt,Rechnungsbetrag
-DocType: Training Result Employee,Training Result Employee,Trainingsergebnis Mitarbeiter
-DocType: Warehouse,A logical Warehouse against which stock entries are made.,Ein logisches Lager zu dem Lagerbuchungen gemacht werden.
-DocType: Repayment Schedule,Principal Amount,Nennbetrag
-DocType: Employee Loan Application,Total Payable Interest,Insgesamt fällige Zinsen
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Gesamtsumme: {0}
-DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Ausgangsrechnung-Zeiterfassung
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Referenznr. & Referenz-Tag sind erforderlich für {0}
-DocType: Payroll Entry,Select Payment Account to make Bank Entry,Wählen Sie ein Zahlungskonto für die Buchung
-DocType: Hotel Settings,Default Invoice Naming Series,Standard-Rechnungsbenennungsserie
-apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Erstellen Sie Mitarbeiterdaten Blätter, Spesenabrechnung und Gehaltsabrechnung zu verwalten"
-DocType: Restaurant Reservation,Restaurant Reservation,Restaurant Reservierung
-DocType: Land Unit,Land Unit Name,Name der Landeinheit
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Verfassen von Angeboten
-DocType: Payment Entry Deduction,Payment Entry Deduction,Zahlungsabzug
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Aufwickeln
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Benachrichtigen Sie Kunden per E-Mail
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Ein weiterer Vertriebsmitarbeiter {0} existiert bereits mit der gleichen Mitarbeiter ID
-DocType: Employee Advance,Claimed Amount,Anspruchsbetrag
-apps/erpnext/erpnext/config/education.py +176,Masters,Stämme
-DocType: Assessment Plan,Maximum Assessment Score,Maximale Beurteilung Score
-apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Kontenabgleich
-apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Zeiterfassung
-DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLIKAT FÜR TRANSPORTER
-apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Zeile {0} # Bezahlter Betrag darf nicht größer sein als der angeforderte Vorschussbetrag
-DocType: Fiscal Year Company,Fiscal Year Company,Geschäftsjahr Firma
-DocType: Packing Slip Item,DN Detail,DN-Detail
-DocType: Training Event,Conference,Konferenz
-DocType: Timesheet,Billed,Abgerechnet
-DocType: Batch,Batch Description,Chargenbeschreibung
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Erstelle Studentengruppen
-apps/erpnext/erpnext/accounts/utils.py +727,"Payment Gateway Account not created, please create one manually.","Payment Gateway-Konto nicht erstellt haben, erstellen Sie bitte ein manuell."
-DocType: Supplier Scorecard,Per Year,Pro Jahr
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Nicht für die Aufnahme in dieses Programm nach DOB geeignet
-DocType: Sales Invoice,Sales Taxes and Charges,Umsatzsteuern und Gebühren auf den Verkauf
-DocType: Employee,Organization Profile,Firmenprofil
-DocType: Vital Signs,Height (In Meter),Höhe (In Meter)
-DocType: Student,Sibling Details,Geschwister-Details
-DocType: Vehicle Service,Vehicle Service,Fahrzeug-Service
-apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Automatisch löst die Anfrage Feedback basierend auf Bedingungen.
-DocType: Employee,Reason for Resignation,Kündigungsgrund
-apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Vorlage für Mitarbeiterbeurteilungen
-DocType: Sales Invoice,Credit Note Issued,Gutschrift ausgelöst
-DocType: Project Task,Weight,Gewicht
-DocType: Payment Reconciliation,Invoice/Journal Entry Details,Einzelheiten zu Rechnungs-/Journalbuchungen
-apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} '{1}' nicht im Geschäftsjahr {2}
-DocType: Buying Settings,Settings for Buying Module,Einstellungen Einkauf
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Anlagewert-{0} gehört nicht zur Firma {1}
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Bitte zuerst Kaufbeleg eingeben
-DocType: Buying Settings,Supplier Naming By,Bezeichnung des Lieferanten nach
-DocType: Activity Type,Default Costing Rate,Standardkosten
-DocType: Maintenance Schedule,Maintenance Schedule,Wartungsplan
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Dann werden Preisregeln bezogen auf Kunde, Kundengruppe, Region, Lieferant, Lieferantentyp, Kampagne, Vertriebspartner usw. ausgefiltert"
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29,Net Change in Inventory,Nettoveränderung des Bestands
-apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Verwaltung der Mitarbeiterdarlehen
-DocType: Employee,Passport Number,Passnummer
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Beziehung mit Guardian2
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Leiter
-DocType: Payment Entry,Payment From / To,Zahlung von / an
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +177,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Neue Kreditlimit ist weniger als die aktuellen ausstehenden Betrag für den Kunden. Kreditlimit hat atleast sein {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Bitte Konto in Lager {0} setzen
-apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""basierend auf"" und ""guppiert nach"" können nicht gleich sein"
-DocType: Sales Person,Sales Person Targets,Ziele für Vertriebsmitarbeiter
-DocType: Installation Note,IN-,IM-
-DocType: Production Order Operation,In minutes,In Minuten
-DocType: Issue,Resolution Date,Datum der Entscheidung
-DocType: Lab Test Template,Compound,Verbindung
-DocType: Student Batch Name,Batch Name,Chargenname
-DocType: Fee Validity,Max number of visit,Maximaler Besuch
-,Hotel Room Occupancy,Hotelzimmerbelegung
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +358,Timesheet created:,Timesheet erstellt:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931,Please set default Cash or Bank account in Mode of Payment {0},"Bitte Standardeinstellungen für Kassen- oder Bankkonto in ""Zahlungsart"" {0} setzen"
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,Einschreiben
-DocType: GST Settings,GST Settings,GST-Einstellungen
-DocType: Selling Settings,Customer Naming By,Benennung der Kunden nach
-DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,"Zeigen die Schüler, wie sie in Studenten monatlichen Anwesenheitsbericht"
-DocType: Depreciation Schedule,Depreciation Amount,Abschreibungsbetrag
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,In Gruppe umwandeln
-DocType: Delivery Trip,TOUR-.#####,TOUR-.#####
-DocType: Activity Cost,Activity Type,Aktivitätsart
-DocType: Request for Quotation,For individual supplier,Für einzelne Anbieter
-DocType: BOM Operation,Base Hour Rate(Company Currency),Basis Stundensatz (Gesellschaft Währung)
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Gelieferte Menge
-DocType: Quotation Item,Item Balance,die Balance der Gegenstände
-DocType: Sales Invoice,Packing List,Packliste
-apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,An Lieferanten erteilte Lieferantenaufträge
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Veröffentlichung
-DocType: Accounts Settings,Report Settings,Berichteinstellungen
-DocType: Activity Cost,Projects User,Nutzer Projekt
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Verbraucht
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0}: {1} nicht in der Rechnungs-Details-Tabelle gefunden
-DocType: Asset,Asset Owner Company,Eigentümergesellschaft
-DocType: Company,Round Off Cost Center,Abschluss-Kostenstelle
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Wartungsbesuch {0} muss vor Stornierung dieses Kundenauftrages abgebrochen werden
-DocType: Asset Maintenance Log,AML-,AML-
-DocType: Item,Material Transfer,Materialübertrag
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Konnte keinen Weg finden
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221,Opening (Dr),Anfangsstand (Soll)
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Buchungszeitstempel muss nach {0} liegen
-apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Um wiederkehrende Dokumente zu machen
-,GST Itemised Purchase Register,GST Itemized Purchase Register
-DocType: Course Scheduling Tool,Reschedule,Neu planen
-DocType: Employee Loan,Total Interest Payable,Gesamtsumme der Zinszahlungen
-DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Einstandspreis Steuern und Gebühren
-DocType: Production Order Operation,Actual Start Time,Tatsächliche Startzeit
-DocType: BOM Operation,Operation Time,Zeit für einen Arbeitsgang
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +316,Finish,Fertig
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Basis
-DocType: Timesheet,Total Billed Hours,Insgesamt Angekündigt Stunden
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1526,Write Off Amount,Abschreibungs-Betrag
-DocType: Leave Block List Allow,Allow User,Benutzer zulassen
-DocType: Journal Entry,Bill No,Rechnungsnr.
-DocType: Company,Gain/Loss Account on Asset Disposal,Gewinn / Verlustrechnung auf die Veräußerung von Vermögenswerten
-DocType: Vehicle Log,Service Details,Service Details
-DocType: Subscription,Quarterly,Quartalsweise
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47,EcritureLib,EcritureLib
-DocType: Lab Test Template,Grouped,Gruppiert
-DocType: Selling Settings,Delivery Note Required,Lieferschein erforderlich
-DocType: Bank Guarantee,Bank Guarantee Number,Bankgarantie Nummer
-DocType: Assessment Criteria,Assessment Criteria,Beurteilungskriterien
-DocType: BOM Item,Basic Rate (Company Currency),Grundpreis (Firmenwährung)
-DocType: Student Attendance,Student Attendance,Schülerzahl
-DocType: Sales Invoice Timesheet,Time Sheet,Zeitblatt
-DocType: Manufacturing Settings,Backflush Raw Materials Based On,Rückmeldung Rohmaterialien auf Basis von
-DocType: Sales Invoice,Port Code,Portcode
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Reserve Warehouse,Lager reservieren
-DocType: Lead,Lead is an Organization,Lead ist eine Organisation
-DocType: Guardian Interest,Interest,Zinsen
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Vorverkauf
-DocType: Instructor Log,Other Details,Sonstige Einzelheiten
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
-DocType: Lab Test,Test Template,Testvorlage
-DocType: Restaurant Order Entry Item,Served,Serviert
-apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Kapitelinformationen.
-DocType: Account,Accounts,Rechnungswesen
-DocType: Vehicle,Odometer Value (Last),(letzter) Tachostand
-apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Vorlagen der Lieferanten-Scorecard-Kriterien.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Marketing
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Payment Eintrag bereits erstellt
-DocType: Request for Quotation,Get Suppliers,Holen Sie sich Lieferanten
-DocType: Purchase Receipt Item Supplied,Current Stock,Aktueller Lagerbestand
-apps/erpnext/erpnext/controllers/accounts_controller.py +609,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Vermögens {1} nicht auf Artikel verknüpft {2}
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Vorschau Gehaltsabrechnung
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Konto {0} wurde mehrmals eingegeben
-DocType: Account,Expenses Included In Valuation,In der Bewertung enthaltene Aufwendungen
-apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,"Sie können nur verlängern, wenn Ihre Mitgliedschaft innerhalb von 30 Tagen abläuft"
-DocType: Land Unit,Longitude,Längengrad
-,Absent Student Report,Bericht: Abwesende Studenten
-DocType: Crop,Crop Spacing UOM,Crop-Abstand UOM
-DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Wählen Sie nur aus, wenn Sie Cash Flow Mapper-Dokumente eingerichtet haben"
-DocType: Email Digest,Next email will be sent on:,Nächste E-Mail wird gesendet am:
-DocType: Supplier Scorecard,Per Week,Pro Woche
-apps/erpnext/erpnext/stock/doctype/item/item.py +665,Item has variants.,Artikel hat Varianten.
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Gesamtstudent
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Artikel {0} nicht gefunden
-DocType: Bin,Stock Value,Lagerwert
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,Gebühren-Aufzeichnungen werden im Hintergrund erstellt. Im Falle eines Fehlers wird die Fehlermeldung im Zeitplan aktualisiert.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Gesellschaft {0} existiert nicht
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} hat die Gültigkeitsdauer bis {1}
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Struktur-Typ
-DocType: BOM Explosion Item,Qty Consumed Per Unit,Verbrauchte Menge pro Einheit
-DocType: GST Account,IGST Account,IGST Konto
-DocType: Serial No,Warranty Expiry Date,Ablaufsdatum der Garantie
-DocType: Material Request Item,Quantity and Warehouse,Menge und Lager
-DocType: Hub Settings,Unregister,Registrierung aufheben
-DocType: Sales Invoice,Commission Rate (%),Provisionssatz (%)
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Bitte wählen Sie Programm
-DocType: Project,Estimated Cost,Geschätzte Kosten
-DocType: Purchase Order,Link to material requests,mit Materialanforderungen verknüpfen
-DocType: Hub Settings,Publish,Veröffentlichen
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Luft- und Raumfahrt
-,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
-DocType: Journal Entry,Credit Card Entry,Kreditkarten-Buchung
-apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Firma und Konten
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,In Value,Wert bei
-DocType: Asset Settings,Depreciation Options,Abschreibungsoptionen
-apps/erpnext/erpnext/utilities/transaction_base.py +35,Invalid Posting Time,Ungültige Buchungszeit
-DocType: Lead,Campaign Name,Kampagnenname
-DocType: Hotel Room,Capacity,Kapazität
-DocType: Selling Settings,Close Opportunity After Days,Gelegenheit schliessen nach
-,Reserved,Reserviert
-DocType: Driver,License Details,Lizenzdetails
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85,The field From Shareholder cannot be blank,Das Feld Von Aktionär darf nicht leer sein
-DocType: Purchase Order,Supply Raw Materials,Rohmaterial bereitstellen
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Umlaufvermögen
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +108,{0} is not a stock Item,{0} ist kein Lagerartikel
-apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Bitte teilen Sie Ihr Feedback mit dem Training ab, indem Sie auf &#39;Training Feedback&#39; und dann &#39;New&#39; klicken."
-DocType: Mode of Payment Account,Default Account,Standardkonto
-apps/erpnext/erpnext/stock/doctype/item/item.py +272,Please select Sample Retention Warehouse in Stock Settings first,Bitte wählen Sie in den Lagereinstellungen zuerst das Muster-Aufbewahrungslager aus
-DocType: Payment Entry,Received Amount (Company Currency),Erhaltene Menge (Gesellschaft Währung)
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,"Lead muss eingestellt werden, wenn eine Opportunity aus dem Lead entsteht"
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Bitte die wöchentlichen Auszeittage auswählen
-DocType: Patient,O Negative,0 -
-DocType: Production Order Operation,Planned End Time,Geplante Endzeit
-,Sales Person Target Variance Item Group-Wise,Artikelgruppenbezogene Zielabweichung des Vertriebsmitarbeiters
-apps/erpnext/erpnext/accounts/doctype/account/account.py +93,Account with existing transaction cannot be converted to ledger,Ein Konto mit bestehenden Transaktionen kann nicht in ein Kontoblatt umgewandelt werden
-apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Details zum Membership-Typ
-DocType: Delivery Note,Customer's Purchase Order No,Kundenauftragsnr.
-DocType: Budget,Budget Against,Budget gegen
-DocType: Employee,Cell Number,Mobiltelefonnummer
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,"Es gibt keinen Angestellten für die gegebenen Kriterien. Überprüfen Sie, ob Gehaltsabrechnungen nicht bereits erstellt wurden."
-apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Automatische Materialanfragen generiert
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Verloren
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,"Momentan können keine Belege in die Spalte ""Zu Buchungssatz"" eingegeben werden"
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,für die Herstellung Reserviert
-DocType: Soil Texture,Sand,Sand
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energie
-DocType: Opportunity,Opportunity From,Chance von
-apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Monatliche Gehaltsabrechnung
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Zeile {0}: {1} Für den Eintrag {2} benötigte Seriennummern. Du hast {3} zur Verfügung gestellt.
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Bitte wählen Sie eine Tabelle
-DocType: BOM,Website Specifications,Webseiten-Spezifikationen
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',"{0} ist eine ungültige E-Mail-Adresse in ""Empfänger"""
-DocType: Special Test Items,Particulars,Einzelheiten
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Von {0} vom Typ {1}
-DocType: Warranty Claim,CI-,CI-
-apps/erpnext/erpnext/controllers/buying_controller.py +310,Row {0}: Conversion Factor is mandatory,Row {0}: Umrechnungsfaktor ist zwingend erfoderlich
-DocType: Student,A+,A+
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Es sind mehrere Preisregeln mit gleichen Kriterien vorhanden, lösen Sie Konflikte, indem Sie Prioritäten zuweisen. Preis Regeln: {0}"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +514,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Stückliste kann nicht deaktiviert oder storniert werden, weil sie mit anderen Stücklisten verknüpft ist"
-DocType: Asset,Maintenance,Wartung
-DocType: Item Attribute Value,Item Attribute Value,Attributwert des Artikels
-DocType: Item,Maximum sample quantity that can be retained,"Maximale Probenmenge, die beibehalten werden kann"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +405,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Zeile {0} # Artikel {1} kann nicht mehr als {2} gegen Bestellung {3} übertragen werden.
-apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Vertriebskampagnen
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,Machen Sie Timesheet
-DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
-
-#### Note
-
-The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
-
-#### Description of Columns
-
-1. Calculation Type: 
-    - This can be on **Net Total** (that is the sum of basic amount).
-    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
-    - **Actual** (as mentioned).
-2. Account Head: The Account ledger under which this tax will be booked
-3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
-4. Description: Description of the tax (that will be printed in invoices / quotes).
-5. Rate: Tax rate.
-6. Amount: Tax amount.
-7. Total: Cumulative total to this point.
-8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
-9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standard-Steuer-Vorlage, die für alle Kauftransaktionen angewandt werden kann. Diese Vorlage kann eine Liste der Steuern und auch anderer Kosten wie ""Versand"", ""Versicherung"", ""Handhabung"" usw. enthalten. 
-
- #### Hinweis 
-
-Der Steuersatz, den sie hier definieren, wird der Standardsteuersatz für alle Artikel. Wenn es Artikel mit davon abweichenden Steuersätzen gibt, müssen diese in der Tabelle ""Artikelsteuer"" im Artikelstamm hinzugefügt werden.
-
- #### Beschreibung der Spalten 
-
-1. Berechnungsart: 
-- Dies kann sein ""Auf Nettosumme"" (das ist die Summe der Grundbeträge).
-- ""Auf vorherige Zeilensumme/-Betrag"" (für kumulative Steuern oder Abgaben). Wenn diese Option ausgewählt wird, wird die Steuer als Prozentsatz der vorherigen Zeilesumme/des vorherigen Zeilenbetrags (in der Steuertabelle) angewendet.
-- ""Unmittelbar"" (wie bereits erwähnt).
-2. Kontobezeichnung: Das Konto, auf das diese Steuer gebucht wird.
-3. Kostenstelle: Ist die Steuer/Gebühr ein Ertrag (wie Versand) oder ein Aufwand, muss sie gegen eine Kostenstelle gebucht werden.
-4. Beschreibung: Beschreibung der Steuer (wird auf Rechnungen und Angeboten abgedruckt).
-5. Satz: Steuersatz.
-6. Betrag: Steuerbetrag.
-7. Gesamt: Kumulierte Summe bis zu diesem Punkt.
-8. Zeile eingeben: Wenn ""Basierend auf Vorherige Zeile"" eingestellt wurde, kann hier die Zeilennummer ausgewählt werden, die als Basis für diese Berechnung (voreingestellt ist die vorherige Zeile) herangezogen wird.
-9. Ist diese Steuer im Basispreis enthalten?: Wenn dieser Punkt aktiviert ist, wird diese Steuer nicht unter dem Artikelstamm angezeigt, aber in den Grundpreis der Tabelle der Hauptartikel mit eingerechnet. Das ist nützlich, wenn ein Pauschalpreis  (inklusive aller Steuern)  an den Kunden gegeben werden soll."
-DocType: Employee,Bank A/C No.,Bankkonto-Nr.
-DocType: Bank Guarantee,Project,Projekt
-DocType: Quality Inspection Reading,Reading 7,Ablesewert 7
-apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,teilweise geordnete
-DocType: Lab Test,Lab Test,Labortest
-DocType: Expense Claim Detail,Expense Claim Type,Art der Aufwandsabrechnung
-DocType: Shopping Cart Settings,Default settings for Shopping Cart,Standardeinstellungen für den Warenkorb
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Zeitfenster hinzufügen
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Gegenstand entsorgt über Journaleintrag {0}
-DocType: Employee Loan,Interest Income Account,Zinserträge Konto
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Einladung überprüfen gesendet
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Biotechnologie
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Büro-Wartungskosten
-apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Gehe zu
-apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Einrichten E-Mail-Konto
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,Bitte zuerst den Artikel angeben
-DocType: Asset Repair,Downtime,Ausfallzeit
-DocType: Account,Liability,Verbindlichkeit
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +218,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Genehmigter Betrag kann nicht größer als geforderter Betrag in Zeile {0} sein.
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Academic Term: ,Akademischer Ausdruck:
-DocType: Salary Detail,Do not include in total,Nicht in Summe
-DocType: Company,Default Cost of Goods Sold Account,Standard-Herstellkosten
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1005,Sample quantity {0} cannot be more than received quantity {1},Die Beispielmenge {0} darf nicht mehr als die empfangene Menge {1} sein
-apps/erpnext/erpnext/stock/get_item_details.py +369,Price List not selected,Preisliste nicht ausgewählt
-DocType: Employee,Family Background,Familiärer Hintergrund
-DocType: Request for Quotation Supplier,Send Email,E-Mail absenden
-apps/erpnext/erpnext/stock/doctype/item/item.py +227,Warning: Invalid Attachment {0},Warnung: Ungültige Anlage {0}
-DocType: Item,Max Sample Quantity,Max. Probenmenge
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766,No Permission,Keine Berechtigung
-DocType: Vital Signs,Heart Rate / Pulse,Herzfrequenz / Puls
-DocType: Company,Default Bank Account,Standardbankkonto
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59,"To filter based on Party, select Party Type first","Um auf der Grundlage von Gruppen zu filtern, bitte zuerst den Gruppentyp wählen"
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"""Lager aktualisieren"" kann nicht ausgewählt werden, da Artikel nicht über {0} geliefert wurden"
-DocType: Vehicle,Acquisition Date,Kaufdatum
-apps/erpnext/erpnext/utilities/user_progress.py +143,Nos,Stk
-DocType: Item,Items with higher weightage will be shown higher,Artikel mit höherem Gewicht werden weiter oben angezeigt
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Labortests und Lebenszeichen
-DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Ausführlicher Kontenabgleich
-apps/erpnext/erpnext/controllers/accounts_controller.py +613,Row #{0}: Asset {1} must be submitted,Row # {0}: Vermögens {1} muss eingereicht werden
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Kein Mitarbeiter gefunden
-DocType: Subscription,Stopped,Angehalten
-DocType: Item,If subcontracted to a vendor,Wenn an einen Zulieferer untervergeben
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentengruppe ist bereits aktualisiert.
-DocType: SMS Center,All Customer Contact,Alle Kundenkontakte
-DocType: Land Unit,Tree Details,Baum-Details
-DocType: Training Event,Event Status,Event Status
-DocType: Volunteer,Availability Timeslot,Verfügbarkeitszeitfenster
-,Support Analytics,Support-Analyse
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Wenn Sie Fragen haben, wenden Sie sich bitte an uns."
-DocType: Cash Flow Mapper,Cash Flow Mapper,Cashflow Mapper
-DocType: Item,Website Warehouse,Webseiten-Lager
-DocType: Payment Reconciliation,Minimum Invoice Amount,Mindestabrechnung
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Kostenstelle {2} gehört nicht zur Firma {3}
-apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Laden Sie Ihren Briefkopf hoch (Halten Sie ihn webfreundlich mit 900x100px)
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Konto {2} darf keine Gruppe sein
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Artikel Row {idx}: {} {Doctype docname} existiert nicht in der oben &#39;{Doctype}&#39; Tisch
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295,Timesheet {0} is already completed or cancelled,Timesheet {0} ist bereits abgeschlossen oder abgebrochen
-apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,keine Vorgänge
-DocType: Item Variant Settings,Copy Fields to Variant,Kopiere Felder auf Varianten
-DocType: Asset,Opening Accumulated Depreciation,Öffnungs Kumulierte Abschreibungen
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Punktzahl muß kleiner oder gleich 5 sein
-DocType: Program Enrollment Tool,Program Enrollment Tool,Programm-Enrollment-Tool
-apps/erpnext/erpnext/config/accounts.py +335,C-Form records,Kontakt-Formular Datensätze
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73,The shares already exist,Die Aktien sind bereits vorhanden
-apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Kunde und Lieferant
-DocType: Email Digest,Email Digest Settings,Einstellungen zum täglichen E-Mail-Bericht
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Vielen Dank für Ihr Unternehmen!
-apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Support-Anfragen von Kunden
-DocType: Setup Progress Action,Action Doctype,Aktions-Doctype
-,Production Order Stock Report,Fertigungsauftrag Stock Report
-DocType: HR Settings,Retirement Age,Rentenalter
-DocType: Bin,Moving Average Rate,Wert für den Gleitenden Durchschnitt
-DocType: Production Plan,Select Items,Artikel auswählen
-DocType: Share Transfer,To Shareholder,An den Aktionär
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} zu Rechnung {1} vom {2}
-apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Einrichtung Einrichtung
-DocType: Program Enrollment,Vehicle/Bus Number,Fahrzeug / Bus Nummer
-apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Kurstermine
-DocType: Request for Quotation Supplier,Quote Status,Zitat Status
-DocType: Maintenance Visit,Completion Status,Fertigstellungsstatus
-DocType: Daily Work Summary Group,Select Users,Wählen Sie Benutzer aus
-DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Hotelzimmer-Preisartikel
-DocType: HR Settings,Enter retirement age in years,Geben Sie das Rentenalter in Jahren
-DocType: Crop,Target Warehouse,Eingangslager
-DocType: Payroll Employee Detail,Payroll Employee Detail,Personalabrechnung Mitarbeiter Detail
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Bitte wählen Sie ein Lager aus
-DocType: Cheque Print Template,Starting location from left edge,Startposition vom linken Rand
-DocType: Item,Allow over delivery or receipt upto this percent,Überlieferung bis zu diesem Prozentsatz zulassen
-DocType: Stock Entry,STE-,STE-
-DocType: Upload Attendance,Import Attendance,Import von Anwesenheiten
-apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Alle Artikelgruppen
-apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Automatisch beim Übertragen von Transaktionen Mitteilungen verfassen
-DocType: Production Order,Item To Manufacture,Zu fertigender Artikel
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteLib,CompteLib
-apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} Status ist {2}
-DocType: Water Analysis,Collection Temperature ,Sammlungs-Temperatur
-DocType: Employee,Provide Email Address registered in company,Geben Sie E-Mail-Adresse in Unternehmen registriert
-DocType: Shopping Cart Settings,Enable Checkout,Aktivieren Kasse
-apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Vom Lieferantenauftrag zur Zahlung
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Geplante Menge
-DocType: Sales Invoice,Payment Due Date,Zahlungsstichtag
-DocType: Drug Prescription,Interval UOM,Intervall UOM
-DocType: Customer,"Reselect, if the chosen address is edited after save","Wählen Sie erneut, wenn die gewählte Adresse nach dem Speichern bearbeitet wird"
-apps/erpnext/erpnext/stock/doctype/item/item.js +492,Item Variant {0} already exists with same attributes,Artikelvariante {0} mit denselben Attributen existiert bereits
-DocType: Item,Hub Publishing Details,Hub-Veröffentlichungsdetails
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +114,'Opening',"""Eröffnung"""
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,offene Aufgaben
-DocType: Notification Control,Delivery Note Message,Lieferschein-Nachricht
-DocType: Lab Test Template,Result Format,Ergebnisformat
-DocType: Expense Claim,Expenses,Ausgaben
-DocType: Item Variant Attribute,Item Variant Attribute,Artikelvariantenattribut
-,Purchase Receipt Trends,Trendanalyse Kaufbelege
-DocType: Payroll Entry,Bimonthly,Zweimonatlich
-DocType: Vehicle Service,Brake Pad,Bremsklotz
-DocType: Fertilizer,Fertilizer Contents,Dünger Inhalt
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Forschung & Entwicklung
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Rechnungsbetrag
-DocType: Company,Registration Details,Details zur Registrierung
-DocType: Timesheet,Total Billed Amount,Gesamtrechnungsbetrag
-DocType: Item Reorder,Re-Order Qty,Nachbestellmenge
-DocType: Leave Block List Date,Leave Block List Date,Urlaubssperrenliste Datum
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +93,BOM #{0}: Raw material cannot be same as main Item,Stückliste # {0}: Rohstoff kann nicht gleich dem Artikel sein.
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Gesamt Die Gebühren in Kauf Eingangspositionen Tabelle muss als Gesamt Steuern und Abgaben gleich sein
-DocType: Sales Team,Incentives,Anreize
-DocType: SMS Log,Requested Numbers,Angeforderte Nummern
-DocType: Volunteer,Evening,Abend
-DocType: Customer,Bypass credit limit check at Sales Order,Kreditlimitprüfung im Kundenauftrag umgehen
-apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Mitarbeiterbeurteilung
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +99,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Aktivieren &quot;Verwendung für Einkaufswagen&quot;, wie Einkaufswagen aktiviert ist und es sollte mindestens eine Steuerregel für Einkaufswagen sein"
-apps/erpnext/erpnext/controllers/accounts_controller.py +411,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Zahlung {0} ist mit der Bestellung {1} verknüpft, überprüfen Sie bitte, ob es als Anteil in dieser Rechnung gezogen werden sollte."
-DocType: Sales Invoice Item,Stock Details,Lagerdetails
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Projektwert
-apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Verkaufsstelle
-DocType: Fee Schedule,Fee Creation Status,Status Gebührenermittlung
-DocType: Vehicle Log,Odometer Reading,Tachostand
-apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Konto bereits im Haben, es ist nicht mehr möglich das Konto als Sollkonto festzulegen"
-DocType: Account,Balance must be,Saldo muss sein
-DocType: Hub Settings,Publish Pricing,Preise veröffentlichen
-DocType: Notification Control,Expense Claim Rejected Message,Benachrichtigung über abgelehnte Aufwandsabrechnung
-,Available Qty,Verfügbare Menge
-DocType: Purchase Taxes and Charges,On Previous Row Total,Auf vorherige Zeilensumme
-DocType: Purchase Invoice Item,Rejected Qty,Abgelehnt Menge
-DocType: Setup Progress Action,Action Field,Aktions-Feld
-DocType: Healthcare Settings,Manage Customer,Kunden verwalten
-DocType: Delivery Trip,Delivery Stops,Lieferstopps
-DocType: Salary Slip,Working Days,Arbeitstage
-DocType: Serial No,Incoming Rate,Eingangsbewertung
-DocType: Packing Slip,Gross Weight,Bruttogewicht
-,Final Assessment Grades,Endgültige Bewertungsmaßstäbe
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Hub aktivieren
-apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,"Name der Firma, für die dieses System eingerichtet wird."
-DocType: HR Settings,Include holidays in Total no. of Working Days,Urlaub in die Gesamtzahl der Arbeitstage mit einbeziehen
-apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Richten Sie Ihr Institut in ERPNext ein
-DocType: Agriculture Analysis Criteria,Plant Analysis,Anlagenanalyse
-DocType: Job Applicant,Hold,Anhalten
-DocType: Employee,Date of Joining,Eintrittsdatum
-DocType: Naming Series,Update Series,Nummernkreise aktualisieren
-DocType: Supplier Quotation,Is Subcontracted,Ist Untervergabe
-DocType: Restaurant Table,Minimum Seating,Mindestbestuhlung
-DocType: Item Attribute,Item Attribute Values,Artikel-Attributwerte
-DocType: Examination Result,Examination Result,Prüfungsergebnis
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845,Purchase Receipt,Kaufbeleg
-,Received Items To Be Billed,"Von Lieferanten gelieferte Artikel, die noch abgerechnet werden müssen"
-apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Stammdaten zur Währungsumrechnung
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +204,Reference Doctype must be one of {0},Referenz Doctype muss man von {0}
-apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Gesamtmenge filtern
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +341,Unable to find Time Slot in the next {0} days for Operation {1},In den nächsten {0} Tagen kann für den Arbeitsgang {1} kein Zeitfenster gefunden werden
-DocType: Production Order,Plan material for sub-assemblies,Materialplanung für Unterbaugruppen
-apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Vertriebspartner und Territorium
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +595,BOM {0} must be active,Stückliste {0} muss aktiv sein
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +409,No Items available for transfer,Keine Artikel zur Übertragung verfügbar
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218,Closing (Opening + Total),Schließen (Eröffnung + Gesamt)
-DocType: Journal Entry,Depreciation Entry,Abschreibungs Eintrag
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Please select the document type first,Bitte zuerst den Dokumententyp auswählen
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Materialkontrolle {0} stornieren vor Abbruch dieses Wartungsbesuchs
-DocType: Crop Cycle,ISO 8016 standard,ISO 8016 Standard
-DocType: Pricing Rule,Rate or Discount,Rate oder Rabatt
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Seriennummer {0} gehört nicht zu Artikel {1}
-DocType: Purchase Receipt Item Supplied,Required Qty,Erforderliche Anzahl
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Lagerhäuser mit bestehenden Transaktion kann nicht in Ledger umgewandelt werden.
-DocType: Bank Reconciliation,Total Amount,Gesamtsumme
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Veröffentlichung im Internet
-DocType: Prescription Duration,Number,Nummer
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,{0} Rechnung erstellen
-DocType: Medical Code,Medical Code Standard,Medizinischer Code Standard
-DocType: Soil Texture,Clay Composition (%),Tonzusammensetzung (%)
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Bitte vor dem Zuweisen der Aufgabe speichern.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74,Balance Value,Bilanzwert
-DocType: Lab Test,Lab Technician,Labortechniker
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Verkaufspreisliste
-DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
-Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Wenn aktiviert, wird ein Kunde erstellt, der Patient zugeordnet ist. Patientenrechnungen werden gegen diesen Kunden angelegt. Sie können den vorhandenen Kunden auch beim Erstellen von Patient auswählen."
-DocType: Bank Reconciliation,Account Currency,Kontenwährung
-DocType: Lab Test,Sample ID,Muster-ID
-apps/erpnext/erpnext/accounts/general_ledger.py +165,Please mention Round Off Account in Company,Bitte Abschlusskonto in Firma vermerken
-DocType: Purchase Receipt,Range,Bandbreite
-DocType: Supplier,Default Payable Accounts,Standard-Verbindlichkeitenkonten
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Mitarbeiter {0} ist nicht aktiv oder existiert nicht
-DocType: Fee Structure,Components,Komponenten
-DocType: Item Barcode,Item Barcode,Artikelbarcode
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +329,Please enter Asset Category in Item {0},Bitte geben Sie Anlagekategorie in Artikel {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +660,Item Variants {0} updated,Artikelvarianten {0} aktualisiert
-DocType: Quality Inspection Reading,Reading 6,Ablesewert 6
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
-of this","erzeugt werden Wenn Sie verspätet sind, müssen Sie das Feld &quot;Wiederholen am Tag des Monats&quot; manuell ändern"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Kann nicht {0} {1} {2} ohne negative ausstehende Rechnung
-DocType: Share Transfer,From Folio No,Aus Folio Nr
-DocType: Purchase Invoice Advance,Purchase Invoice Advance,Vorkasse zur Eingangsrechnung
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Zeile {0}: Habenbuchung kann nicht mit ein(em) {1} verknüpft werden
-apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Budget für ein Geschäftsjahr angeben.
-DocType: Lead,LEAD-,LEAD-
-DocType: Employee,Permanent Address Is,Feste Adresse ist
-DocType: Production Order Operation,Operation completed for how many finished goods?,Für wie viele fertige Erzeugnisse wurde der Arbeitsgang abgeschlossen?
-DocType: Payment Terms Template,Payment Terms Template,Vorlage Zahlungsbedingungen
-apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Die Marke
-DocType: Employee,Exit Interview Details,Details zum Austrittsgespräch
-DocType: Item,Is Purchase Item,Ist Einkaufsartikel
-DocType: Journal Entry Account,Purchase Invoice,Eingangsrechnung
-DocType: Stock Ledger Entry,Voucher Detail No,Belegdetail-Nr.
-apps/erpnext/erpnext/accounts/page/pos/pos.js +789,New Sales Invoice,Neue Ausgangsrechnung
-DocType: Stock Entry,Total Outgoing Value,Gesamtwert Auslieferungen
-DocType: Physician,Appointments,Termine
-apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Eröffnungsdatum und Abschlussdatum sollten im gleichen Geschäftsjahr sein
-DocType: Lead,Request for Information,Informationsanfrage
-,LeaderBoard,Bestenliste
-DocType: Sales Invoice Item,Rate With Margin (Company Currency),Rate mit Margin (Unternehmenswährung)
-apps/erpnext/erpnext/accounts/page/pos/pos.js +802,Sync Offline Invoices,Sync Offline-Rechnungen
-DocType: Payment Request,Paid,Bezahlt
-DocType: Program Fee,Program Fee,Programmgebühr
-DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
-It also updates latest price in all the BOMs.","Ersetzen Sie eine bestimmte Stückliste in allen anderen Stücklisten, wo sie verwendet wird. Es wird die alte BOM-Link ersetzen, die Kosten aktualisieren und die &quot;BOM Explosion Item&quot; -Tabelle nach neuer Stückliste regenerieren. Es aktualisiert auch den aktuellen Preis in allen Stücklisten."
-DocType: Salary Slip,Total in words,Summe in Worten
-DocType: Material Request Item,Lead Time Date,Lieferzeit und -datum
-DocType: Asset,Available-for-use Date,Verfügbarkeitsdatum
-DocType: Guardian,Guardian Name,Wächter-Name
-DocType: Cheque Print Template,Has Print Format,Hat ein Druckformat
-DocType: Employee Loan,Sanctioned,sanktionierte
-apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,ist zwingend erforderlich. Vielleicht wurde kein Datensatz für den Geldwechsel erstellt für
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +126,Row #{0}: Please specify Serial No for Item {1},Zeile #{0}: Bitte Seriennummer für Artikel {1} angeben
-DocType: Crop Cycle,Crop Cycle,Erntezyklus
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Für Artikel aus ""Produkt-Bundles"" werden Lager, Seriennummer und Chargennummer aus der Tabelle ""Packliste"" berücksichtigt. Wenn Lager und Chargennummer für alle Packstücke in jedem Artikel eines Produkt-Bundles gleich sind, können diese Werte in die Tabelle ""Hauptpositionen"" eingetragen werden, Die Werte werden in die Tabelle ""Packliste"" kopiert."
-DocType: Student Admission,Publish on website,Veröffentlichen Sie auf der Website
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Lieferant Rechnungsdatum kann nicht größer sein als Datum der Veröffentlichung
-DocType: Purchase Invoice Item,Purchase Order Item,Lieferantenauftrags-Artikel
-DocType: Agriculture Task,Agriculture Task,Landwirtschaftsaufgabe
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Indirekte Erträge
-DocType: Student Attendance Tool,Student Attendance Tool,Schülerteilnahme Werkzeug
-DocType: Restaurant Menu,Price List (Auto created),Preisliste (automatisch erstellt)
-DocType: Cheque Print Template,Date Settings,Datums-Einstellungen
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Abweichung
-,Company Name,Firmenname
-DocType: SMS Center,Total Message(s),Summe Nachricht(en)
-DocType: Share Balance,Purchased,Gekauft
-DocType: Purchase Invoice,Additional Discount Percentage,Zusätzlicher prozentualer Rabatt
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Sehen Sie eine Liste aller Hilfe-Videos
-DocType: Agriculture Analysis Criteria,Soil Texture,Bodentextur
-DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Bezeichnung des Kontos bei der Bank, bei der der Scheck eingereicht wurde, auswählen."
-DocType: Selling Settings,Allow user to edit Price List Rate in transactions,"Benutzer erlauben, die Preisliste in Transaktionen zu bearbeiten"
-DocType: Pricing Rule,Max Qty,Maximalmenge
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
-						Please enter a valid Invoice","Row {0}: Rechnung {1} ist ungültig, könnte es abgebrochen werden / nicht vorhanden. \ Bitte geben Sie eine gültige Rechnung"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,"Zeile {0}: ""Zahlung zu Kunden-/Lieferantenauftrag"" sollte immer als ""Vorkasse"" eingestellt werden"
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Chemische Industrie
-DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,"Standard Bank / Geldkonto wird automatisch in Gehalts Journal Entry aktualisiert werden, wenn dieser Modus ausgewählt ist."
-DocType: BOM,Raw Material Cost(Company Currency),Rohstoffkosten (Gesellschaft Währung)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +783,All items have already been transferred for this Production Order.,Alle Artikel wurden schon für diesen Fertigungsauftrag übernommen.
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},"Row # {0}: Die Rate kann nicht größer sein als die Rate, die in {1} {2}"
-apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,Meter
-DocType: Workstation,Electricity Cost,Stromkosten
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +22,Lab testing datetime cannot be before collection datetime,Lab-Testdatum kann nicht vor dem Erfassungsdatum liegen
-DocType: HR Settings,Don't send Employee Birthday Reminders,Keine Mitarbeitergeburtstagserinnerungen senden
-DocType: Expense Claim,Total Advance Amount,Gesamtvorauszahlungsbetrag
-DocType: Delivery Stop,Estimated Arrival,Voraussichtliche Ankunft
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Einstellungen speichern
-DocType: Delivery Stop,Notified by Email,Benachrichtigung per E-Mail
-DocType: Item,Inspection Criteria,Prüfkriterien
-apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Übergeben
-DocType: BOM Website Item,BOM Website Item,BOM Webseitenartikel
-apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Briefkopf und Logo hochladen. (Beides kann später noch bearbeitet werden.)
-DocType: Timesheet Detail,Bill,Rechnung
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date is entered as past date,Weiter Abschreibungen Datum wird als vergangenes Datum eingegeben
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Weiß
-DocType: SMS Center,All Lead (Open),Alle Leads (offen)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +257,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: Menge nicht für {4} in Lager {1} zum Zeitpunkt des Eintrags Entsendung ({2} {3})
-apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,Sie können nur eine Option aus der Liste der Kontrollkästchen auswählen.
-DocType: Purchase Invoice,Get Advances Paid,Gezahlte Anzahlungen aufrufen
-DocType: Item,Automatically Create New Batch,Automatisch neue Charge erstellen
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635,Assigning {0} to {1} (row {2}),Zuweisen von {0} zu {1} (Zeile {2})
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Make ,Erstellen
-DocType: Student Admission,Admission Start Date,Stichtag zum Zulassungsbeginn
-DocType: Journal Entry,Total Amount in Words,Gesamtsumme in Worten
-apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Neuer Angestellter
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,"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."
-apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Mein Warenkorb
-apps/erpnext/erpnext/controllers/selling_controller.py +129,Order Type must be one of {0},Bestelltyp muss aus {0} sein
-DocType: Lead,Next Contact Date,Nächstes Kontaktdatum
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Anfangsmenge
-DocType: Healthcare Settings,Appointment Reminder,Termin Erinnerung
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478,Please enter Account for Change Amount,Bitte geben Sie Konto für Änderungsbetrag
-DocType: Program Enrollment Tool Student,Student Batch Name,Studentenstapelname
-DocType: Consultation,Doctor,Arzt
-DocType: Holiday List,Holiday List Name,Urlaubslistenname
-DocType: Repayment Schedule,Balance Loan Amount,Bilanz Darlehensbetrag
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Unterrichtszeiten
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +235,Stock Options,Lager-Optionen
-DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Deaktivieren Sie das Abrufen der letzten Kaufdetails in der Bestellung
-DocType: Journal Entry Account,Expense Claim,Aufwandsabrechnung
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +267,Do you really want to restore this scrapped asset?,Wollen Sie dieses entsorgte Gut wirklich wiederherstellen?
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Qty for {0},Menge für {0}
-DocType: Leave Application,Leave Application,Urlaubsantrag
-DocType: Patient,Patient Relation,Patientenbeziehung
-apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Urlaubszuordnungs-Werkzeug
-DocType: Item,Hub Category to Publish,Zu veröffentlichende Hub-Kategorie
-DocType: Leave Block List,Leave Block List Dates,Urlaubssperrenliste Termine
-DocType: Sales Invoice,Billing Address GSTIN,Rechnungsadresse Steuernummer
-DocType: Assessment Plan,Evaluate,Bewerten
-DocType: Workstation,Net Hour Rate,Nettostundensatz
-DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Einstandspreis-Kaufbeleg
-DocType: Company,Default Terms,Allgemeine Geschäftsbedingungen
-DocType: Supplier Scorecard Period,Criteria,Kriterien
-DocType: Packing Slip Item,Packing Slip Item,Position auf dem Packzettel
-DocType: Purchase Invoice,Cash/Bank Account,Bar-/Bankkonto
-apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Bitte geben Sie eine {0}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,Removed items with no change in quantity or value.,Artikel wurden ohne Veränderung der Menge oder des Wertes entfernt.
-DocType: Delivery Note,Delivery To,Lieferung an
-apps/erpnext/erpnext/stock/doctype/item/item.js +386,Variant creation has been queued.,Die Variantenerstellung wurde in die Warteschlange gestellt.
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Arbeitszusammenfassung für {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +695,Attribute table is mandatory,Attributtabelle ist zwingend erforderlich
-DocType: Production Plan,Get Sales Orders,Kundenaufträge aufrufen
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68,{0} can not be negative,{0} kann nicht negativ sein
-DocType: Training Event,Self-Study,Selbststudium
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +26,Soil compositions do not add up to 100,Bodenzusammensetzungen ergeben nicht 100
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +554,Discount,Rabatt
-DocType: Membership,Membership,Mitgliedschaft
-DocType: Asset,Total Number of Depreciations,Gesamtzahl der Abschreibungen
-DocType: Sales Invoice Item,Rate With Margin,Betrag mit Marge
-DocType: Workstation,Wages,Lohn
-DocType: Asset Maintenance,Maintenance Manager Name,Name des Wartungs-Managers
-DocType: Agriculture Task,Urgent,Dringend
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Bitte eine gültige Zeilen-ID für die Zeile {0} in Tabelle {1} angeben
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Variable kann nicht gefunden werden:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +790,Please select a field to edit from numpad,Bitte wähle ein Feld aus numpad aus
-apps/erpnext/erpnext/stock/doctype/item/item.py +263,Cannot be a fixed asset item as Stock Ledger is created.,"Kann keine Anlageposition sein, wenn das Stock Ledger erstellt wird."
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Gehen Sie zum Desktop und starten Sie ERPNext
-DocType: Item,Manufacturer,Hersteller
-DocType: Landed Cost Item,Purchase Receipt Item,Kaufbeleg-Artikel
-DocType: Purchase Receipt,PREC-RET-,PREC-Ret
-DocType: POS Profile,Sales Invoice Payment,Ausgangsrechnung-Zahlungen
-DocType: Quality Inspection Template,Quality Inspection Template Name,Name der Qualitätsinspektionsvorlage
-DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Lager im Kundenauftrag reserviert / Fertigwarenlager
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Verkaufsbetrag
-DocType: Repayment Schedule,Interest Amount,Zinsbetrag
-DocType: Serial No,Creation Document No,Belegerstellungs-Nr.
-DocType: Share Transfer,Issue,Anfrage
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Aufzeichnungen
-DocType: Asset,Scrapped,Entsorgt
-DocType: Purchase Invoice,Returns,Retouren
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,Fertigungslager
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Seriennummer {0} ist mit Wartungsvertrag versehen bis {1}
-apps/erpnext/erpnext/config/hr.py +35,Recruitment,Rekrutierung
-DocType: Lead,Organization Name,Firmenname
-DocType: Tax Rule,Shipping State,Versandstatus
-,Projected Quantity as Source,Projizierte Menge als Quelle
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,"Artikel müssen über die Schaltfläche ""Artikel von Kaufbeleg übernehmen"" hinzugefügt werden"
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858,Delivery Trip,Liefertrip
-DocType: Student,A-,A-
-DocType: Share Transfer,Transfer Type,Übertragungsart
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Vertriebskosten
-DocType: Consultation,Diagnosis,Diagnose
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standard-Kauf
-DocType: GL Entry,Against,Zu
-DocType: Item,Default Selling Cost Center,Standard-Vertriebskostenstelle
-DocType: Sales Partner,Implementation Partner,Umsetzungspartner
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1623,ZIP Code,Postleitzahl
-apps/erpnext/erpnext/controllers/selling_controller.py +251,Sales Order {0} is {1},Kundenauftrag {0} ist {1}
-DocType: Opportunity,Contact Info,Kontakt-Information
-apps/erpnext/erpnext/config/stock.py +319,Making Stock Entries,Lagerbuchungen erstellen
-DocType: Packing Slip,Net Weight UOM,Nettogewichtmaßeinheit
-DocType: Item,Default Supplier,Standardlieferant
-DocType: Manufacturing Settings,Over Production Allowance Percentage,Prozensatz erlaubter Überproduktion
-DocType: Employee Loan,Repayment Schedule,Rückzahlungsplan
-DocType: Shipping Rule Condition,Shipping Rule Condition,Versandbedingung
-DocType: Holiday List,Get Weekly Off Dates,Wöchentliche Abwesenheitstermine abrufen
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Enddatum kann nicht vor Startdatum liegen
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337,Invoice can't be made for zero billing hour,Die Rechnung kann nicht für die Null-Rechnungsstunde erstellt werden
-DocType: Sales Person,Select company name first.,Zuerst den Firmennamen auswählen.
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189,Email sent to {0},E-Mail an {0} gesendet
-apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Angebote von Lieferanten
-apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Ersetzen Sie die Stückliste und aktualisieren Sie den aktuellen Preis in allen Stücklisten
-apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},An {0} | {1} {2}
-DocType: Delivery Trip,Driver Name,Fahrername
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Durchschnittsalter
-DocType: Education Settings,Attendance Freeze Date,Anwesenheit Einfrieren Datum
-apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Bitte ein paar Lieferanten angeben. Diese können Firmen oder Einzelpersonen sein.
-apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Alle Produkte
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimum Lead Age (Tage)
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +59,All BOMs,Alle Stücklisten
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Hotelzimmer vom Typ {0} sind auf {1} nicht verfügbar
-DocType: Patient,Default Currency,Standardwährung
-DocType: Expense Claim,From Employee,Von Mitarbeiter
-DocType: Driver,Cellphone Number,Handynummer
-apps/erpnext/erpnext/controllers/accounts_controller.py +471,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Achtung: Das System erkennt keine überhöhten Rechnungen, da der Betrag für Artikel {0} in {1} gleich Null ist"
-DocType: Journal Entry,Make Difference Entry,Differenzbuchung erstellen
-DocType: Upload Attendance,Attendance From Date,Anwesenheit von Datum
-DocType: Appraisal Template Goal,Key Performance Area,Entscheidender Leistungsbereich
-DocType: Program Enrollment,Transportation,Transport
-apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,Ungültige Attribute
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +235,{0} {1} must be submitted,{0} {1} muss vorgelegt werden
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},Menge muss kleiner oder gleich {0} sein
-DocType: SMS Center,Total Characters,Gesamtanzahl Zeichen
-DocType: Employee Advance,Claimed,Behauptet
-DocType: Crop,Row Spacing,Zeilenabstand
-apps/erpnext/erpnext/controllers/buying_controller.py +164,Please select BOM in BOM field for Item {0},Bitte aus dem Stücklistenfeld eine Stückliste für Artikel {0} auswählen
-DocType: C-Form Invoice Detail,C-Form Invoice Detail,Kontakt-Formular Rechnungsdetail
-DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Rechnung zum Zahlungsabgleich
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38,Contribution %,Beitrag in %
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Nach den Kaufeinstellungen, wenn Bestellbedarf == &#39;JA&#39;, dann für die Erstellung der Kaufrechnung, muss der Benutzer die Bestellung zuerst für den Eintrag {0}"
-DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Meldenummern des Unternehmens für Ihre Unterlagen. Steuernummern usw.
-DocType: Sales Partner,Distributor,Lieferant
-DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Warenkorb-Versandregel
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,Fertigungsauftrag {0} muss vor Stornierung dieses Kundenauftages abgebrochen werden
-apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',"Bitte ""Zusätzlichen Rabatt anwenden auf"" aktivieren"
-,Ordered Items To Be Billed,"Bestellte Artikel, die abgerechnet werden müssen"
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Von-Bereich muss kleiner sein als Bis-Bereich
-DocType: Global Defaults,Global Defaults,Allgemeine Voreinstellungen
-apps/erpnext/erpnext/projects/doctype/project/project.py +228,Project Collaboration Invitation,Projekt-Zusammenarbeit Einladung
-DocType: Salary Slip,Deductions,Abzüge
-DocType: Leave Allocation,LAL/,LAL /
-DocType: Setup Progress Action,Action Name,Aktionsname
-apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Startjahr
-apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},Die ersten 2 Ziffern von GSTIN sollten mit der Statusnummer {0} übereinstimmen
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +63,PDC/LC,PDC / LC
-DocType: Purchase Invoice,Start date of current invoice's period,Startdatum der laufenden Rechnungsperiode
-DocType: Salary Slip,Leave Without Pay,Unbezahlter Urlaub
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +385,Capacity Planning Error,Fehler in der Kapazitätsplanung
-,Trial Balance for Party,Summen- und Saldenliste für Gruppe
-DocType: Lead,Consultant,Berater
-DocType: Salary Slip,Earnings,Einkünfte
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +428,Finished Item {0} must be entered for Manufacture type entry,Fertiger Artikel {0} muss für eine Fertigungsbuchung eingegeben werden
-apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Eröffnungsbilanz
-,GST Sales Register,GST Verkaufsregister
-DocType: Sales Invoice Advance,Sales Invoice Advance,Anzahlung auf Ausgangsrechnung
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Nichts anzufragen
-apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Wählen Sie Ihre Domains
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Ein weitere Budgetplan  '{0}' existiert bereits gegen {1} {2} 'für das Geschäftsjahr {3}
-DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Felder werden nur zum Zeitpunkt der Erstellung kopiert.
-DocType: Setup Progress Action,Domains,Domainen
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',"Das ""Tatsächliche Startdatum"" kann nicht nach dem  ""Tatsächlichen Enddatum"" liegen"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Verwaltung
-DocType: Cheque Print Template,Payer Settings,Payer Einstellungen
-DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Dies wird an den Artikelcode der Variante angehängt. Beispiel: Wenn Ihre Abkürzung ""SM"" und der Artikelcode ""T-SHIRT"" sind, so ist der Artikelcode der Variante ""T-SHIRT-SM"""
-DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Nettolohn (in Worten) wird angezeigt, sobald Sie die Gehaltsabrechnung speichern."
-DocType: Purchase Invoice,Is Return,Ist Rückgabe
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,Caution,Vorsicht
-apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +16,Start day is greater than end day in task '{0}',Starttag ist größer als Endtag in Aufgabe &#39;{0}&#39;
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815,Return / Debit Note,Return / Lastschrift
-DocType: Price List Country,Price List Country,Preisliste Land
-DocType: Item,UOMs,Maßeinheiten
-apps/erpnext/erpnext/stock/utils.py +212,{0} valid serial nos for Item {1},{0} gültige Seriennummern für Artikel {1}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Artikelnummer kann nicht für Seriennummer geändert werden
-DocType: Purchase Invoice Item,UOM Conversion Factor,Maßeinheit-Umrechnungsfaktor
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Bitte geben Sie Item Code zu Chargennummer erhalten
-DocType: Stock Settings,Default Item Group,Standard-Artikelgruppe
-DocType: Employee Loan,Partially Disbursed,teil~~POS=TRUNC Zahlter
-apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Gewähren Sie Informationen.
-apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Lieferantendatenbank
-DocType: Account,Balance Sheet,Bilanz
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750,Cost Center For Item with Item Code ',Kostenstelle für den Artikel mit der Artikel-Nr.
-DocType: Fee Validity,Valid Till,Gültig bis
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2500,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Zahlungsmittel ist nicht konfiguriert. Bitte überprüfen Sie, ob ein Konto in den Zahlungsmodi oder in einem Verkaufsstellen-Profil eingestellt wurde."
-apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Das gleiche Einzelteil kann nicht mehrfach eingegeben werden.
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","Weitere Konten können unter Gruppen angelegt werden, aber Buchungen können zu nicht-Gruppen erstellt werden"
-DocType: Lead,Lead,Lead
-DocType: Email Digest,Payables,Verbindlichkeiten
-DocType: Course,Course Intro,Kurs Intro
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Lagerbuchung {0} erstellt
-apps/erpnext/erpnext/controllers/buying_controller.py +316,Row #{0}: Rejected Qty can not be entered in Purchase Return,Zeile #{0}: Abgelehnte Menge kann nicht in Kaufrückgabe eingegeben werden
-,Purchase Order Items To Be Billed,"Bei Lieferanten bestellte Artikel, die noch abgerechnet werden müssen"
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63,Updating estimated arrival times.,Aktualisierung der geschätzten Ankunftszeiten
-DocType: Program Enrollment Tool,Enrollment Details,Anmeldedetails
-DocType: Purchase Invoice Item,Net Rate,Nettopreis
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152,Please select a customer,Bitte wählen Sie einen Kunden aus
-DocType: Purchase Invoice Item,Purchase Invoice Item,Eingangsrechnungs-Artikel
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Buchungen auf das Lagerbuch und Hauptbuch-Buchungen werden für die gewählten Kaufbelege umgebucht
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Position 1
-DocType: Holiday,Holiday,Urlaub
-DocType: Support Settings,Close Issue After Days,Vorfall schließen nach
-DocType: Leave Control Panel,Leave blank if considered for all branches,"Freilassen, wenn für alle Filialen gültig"
-DocType: Bank Guarantee,Validity in Days,Gültigkeit in Tagen
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},Kontaktformular nicht anwendbar auf  Rechnung: {0}
-DocType: Payment Reconciliation,Unreconciled Payment Details,Nicht abgeglichene Zahlungen
-apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Mitglied Aktivität
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Auftragszähler
-DocType: Global Defaults,Current Fiscal Year,Laufendes Geschäftsjahr
-DocType: Purchase Order,Group same items,Gruppe gleichen Artikel
-DocType: Purchase Invoice,Disable Rounded Total,"""Gesamtsumme runden"" abschalten"
-DocType: Employee Loan Application,Repayment Info,Die Rückzahlung Info
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,"""Buchungen"" kann nicht leer sein"
-DocType: Maintenance Team Member,Maintenance Role,Wartungsrolle
-apps/erpnext/erpnext/utilities/transaction_base.py +88,Duplicate row {0} with same {1},Dupliziere Zeile {0} mit demselben {1}
-,Trial Balance,Probebilanz
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Das Geschäftsjahr {0} nicht gefunden
-apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Mitarbeiter anlegen
-DocType: Sales Order,SO-,DAMIT-
-DocType: Hotel Room Reservation,Hotel Reservation User,Hotelreservierung Benutzer
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Bitte zuerst Präfix auswählen
-DocType: Student,O-,O-
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Forschung
-DocType: Maintenance Visit Purpose,Work Done,Arbeit erledigt
-apps/erpnext/erpnext/controllers/item_variant.py +35,Please specify at least one attribute in the Attributes table,Bitte geben Sie mindestens ein Attribut in der Attributtabelle ein
-DocType: Announcement,All Students,Alle Schüler
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Artikel {0} darf kein Lagerartikel sein
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Hauptbuch anzeigen
-DocType: Grading Scale,Intervals,Intervalle
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Frühestens
-apps/erpnext/erpnext/stock/doctype/item/item.py +525,"An Item Group exists with same name, please change the item name or rename the item group",Eine Artikelgruppe mit dem gleichen Namen existiert bereits. Bitte den Artikelnamen ändern oder die Artikelgruppe umbenennen
-DocType: Crop Cycle,Less than a year,Weniger als ein Jahr
-apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobil-Nr
-apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Rest der Welt
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Der Artikel {0} kann keine Charge haben
-DocType: Crop,Yield UOM,Ertrag UOM
-,Budget Variance Report,Budget-Abweichungsbericht
-DocType: Salary Slip,Gross Pay,Bruttolohn
-DocType: Item,Is Item from Hub,Ist ein Gegenstand aus dem Hub
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Activity Type is mandatory.,Row {0}: Leistungsart ist obligatorisch.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Ausgeschüttete Dividenden
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Hauptbuch
-DocType: Stock Reconciliation,Difference Amount,Differenzmenge
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +112,Dr {0} on Leave on {1},Dr {0} bei Verlassen auf {1}
-DocType: Purchase Invoice,Reverse Charge,Reverse Charge
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Gewinnrücklagen
-DocType: Purchase Invoice,05-Change in POS,05-Änderung am POS
-DocType: Vehicle Log,Service Detail,Service Detail
-DocType: BOM,Item Description,Artikelbeschreibung
-DocType: Student Sibling,Student Sibling,Studenten Geschwister
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18,Payment Mode,Zahlungsweise
-DocType: Purchase Invoice,Supplied Items,Gelieferte Artikel
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Bitte setzen Sie ein aktives Menü für Restaurant {0}
-DocType: Student,STUD.,ZUCHT.
-DocType: Production Order,Qty To Manufacture,Herzustellende Menge
-DocType: Email Digest,New Income,Neuer Verdienst
-DocType: Buying Settings,Maintain same rate throughout purchase cycle,Gleiche Preise während des gesamten Einkaufszyklus beibehalten
-DocType: Opportunity Item,Opportunity Item,Chance-Artikel
-,Student and Guardian Contact Details,Student and Guardian Kontaktdaten
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53,Row {0}: For supplier {0} Email Address is required to send email,"Zeile {0}: um E-Mails senden zu können, ist eine E-Mail-Adresse für den Anbieter {0} erforderlich."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Temporäre Eröffnungskonten
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10,View Hub,Hub anzeigen
-,Employee Leave Balance,Übersicht der Urlaubskonten der Mitarbeiter
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Saldo für Konto {0} muss immer {1} sein
-DocType: Patient Appointment,More Info,Weitere Informationen
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Bewertungsrate erforderlich für den Posten in der Zeile {0}
-DocType: Supplier Scorecard,Scorecard Actions,Scorecard-Aktionen
-apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Beispiel: Master in Informatik
-DocType: Purchase Invoice,Rejected Warehouse,Ausschusslager
-DocType: GL Entry,Against Voucher,Gegenbeleg
-DocType: Item,Default Buying Cost Center,Standard-Einkaufskostenstelle
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Um ERPNext bestmöglich zu nutzen, empfehlen wir Ihnen, sich die Zeit zu nehmen diese Hilfevideos anzusehen."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,nach
-DocType: Supplier Quotation Item,Lead Time in days,Lieferzeit in Tagen
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Übersicht der Verbindlichkeiten
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Die Zahlung des Gehalts von {0} {1}
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Keine Berechtigung gesperrtes Konto {0} zu bearbeiten
-DocType: Journal Entry,Get Outstanding Invoices,Ausstehende Rechnungen aufrufen
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Kundenauftrag {0} ist nicht gültig
-DocType: Supplier Scorecard,Warn for new Request for Quotations,Warnung für neue Angebotsanfrage
-apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Bestellungen helfen Ihnen bei der Planung und Follow-up auf Ihre Einkäufe
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Labortestverordnungen
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166,"The total Issue / Transfer quantity {0} in Material Request {1}  \
-							cannot be greater than requested quantity {2} for Item {3}",Die gesamte Ausgabe / Transfer Menge {0} in Material anfordern {1} \ kann nicht größer sein als die angeforderte Menge {2} für Artikel {3}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Klein
-DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Eröffnen des Rechnungserstellungswerkzeugs
-DocType: Education Settings,Employee Number,Mitarbeiternummer
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Fall-Nr. (n) bereits in Verwendung. Versuchen Sie eine Fall-Nr. ab {0}
-DocType: Project,% Completed,% abgeschlossen
-,Invoiced Amount (Exculsive Tax),Rechnungsbetrag (ohne MwSt.)
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Position 2
-DocType: Supplier,SUPP-,des Liefe-
-DocType: Training Event,Training Event,Schulungsveranstaltung
-DocType: Item,Auto re-order,Automatische Nachbestellung
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Gesamtsumme erreicht
-DocType: Employee,Place of Issue,Ausgabeort
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Vertrag
-DocType: Plant Analysis,Laboratory Testing Datetime,Labortest Datetime
-DocType: Email Digest,Add Quote,Angebot hinzufügen
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +973,UOM coversion factor required for UOM: {0} in Item: {1},Maßeinheit-Umrechnungsfaktor ist erforderlich für Maßeinheit: {0} bei Artikel: {1}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Indirekte Aufwendungen
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +97,Row {0}: Qty is mandatory,Zeile {0}: Menge ist zwingend erforderlich
-DocType: Agriculture Analysis Criteria,Agriculture,Landwirtschaft
-apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Master Data,Sync Master Data
-DocType: Asset Repair,Repair Cost,Reparaturkosten
-apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Ihre Produkte oder Dienstleistungen
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Einloggen fehlgeschlagen
-DocType: Special Test Items,Special Test Items,Spezielle Testartikel
-DocType: Mode of Payment,Mode of Payment,Zahlungsweise
-apps/erpnext/erpnext/stock/doctype/item/item.py +201,Website Image should be a public file or website URL,Das Webseiten-Bild sollte eine öffentliche Datei oder eine Webseiten-URL sein
-DocType: Student Applicant,AP,AP
-DocType: Purchase Invoice Item,BOM,Stückliste
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Dies ist eine Root-Artikelgruppe und kann nicht bearbeitet werden.
-DocType: Journal Entry Account,Purchase Order,Lieferantenauftrag
-DocType: Vehicle,Fuel UOM,Kraftstoff UOM
-DocType: Warehouse,Warehouse Contact Info,Kontaktinformation des Lager
-DocType: Payment Entry,Write Off Difference Amount,Differenzbetrag Abschreibung
-DocType: Volunteer,Volunteer Name,Freiwilliger Name
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +433,"{0}: Employee email not found, hence email not sent","{0}: Mitarbeiter E-Mail nicht gefunden, E-Mail daher nicht gesendet"
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Versandregel gilt nicht für Land {0}
-DocType: Item,Foreign Trade Details,Außenhandelsdetails
-,Assessment Plan Status,Status des Bewertungsplans
-DocType: Email Digest,Annual Income,Jährliches Einkommen
-DocType: Serial No,Serial No Details,Details zur Seriennummer
-DocType: Purchase Invoice Item,Item Tax Rate,Artikelsteuersatz
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Bitte wählen Sie Arzt und Datum
-DocType: Student Group Student,Group Roll Number,Gruppenrolle Nummer
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry",Für {0} können nur Habenkonten mit einer weiteren Sollbuchung verknüpft werden
-apps/erpnext/erpnext/projects/doctype/project/project.py +82,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Summe aller Aufgabe Gewichte sollten 1. Bitte stellen Sie Gewichte aller Projektaufgaben werden entsprechend
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588,Delivery Note {0} is not submitted,Lieferschein {0} ist nicht gebucht
-apps/erpnext/erpnext/stock/get_item_details.py +148,Item {0} must be a Sub-contracted Item,Artikel {0} muss ein unterbeauftragter Artikel sein
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Betriebsvermögen
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Die Preisregel wird zunächst basierend auf dem Feld ""Anwenden auf"" ausgewählt. Dieses kann ein Artikel, eine Artikelgruppe oder eine Marke sein."
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +246,Please set the Item Code first,Bitte legen Sie zuerst den Itemcode fest
-DocType: Item,ITEM-,ARTKL-
-apps/erpnext/erpnext/controllers/selling_controller.py +122,Total allocated percentage for sales team should be 100,Insgesamt verteilte Prozentmenge für Vertriebsteam sollte 100 sein
-DocType: Sales Invoice Item,Edit Description,Beschreibung bearbeiten
-DocType: Antibiotic,Antibiotic,Antibiotikum
-,Team Updates,Team-Updates
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912,For Supplier,Für Lieferant
-DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Das Festlegen des Kontotyps hilft bei der Auswahl dieses Kontos bei Transaktionen.
-DocType: Purchase Invoice,Grand Total (Company Currency),Gesamtbetrag (Firmenwährung)
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Druckformat erstellen
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Fee Erstellt
-apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Hat keinen Artikel finden genannt {0}
-DocType: Supplier Scorecard Criteria,Criteria Formula,Kriterien Formel
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Summe Auslieferungen
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Es kann nur eine Versandbedingung mit dem Wert ""0"" oder ""leer"" für ""Bis-Wert"" geben"
-DocType: Authorization Rule,Transaction,Transaktion
-DocType: Patient Appointment,Duration,Dauer
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Hinweis: Diese Kostenstelle ist eine Gruppe. Buchungen können nicht zu Gruppen erstellt werden.
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,Es sind Unterlager für dieses Lager vorhanden. Sie können dieses Lager daher nicht löschen.
-DocType: Item,Website Item Groups,Webseiten-Artikelgruppen
-DocType: Purchase Invoice,Total (Company Currency),Gesamtsumme (Firmenwährung)
-DocType: Daily Work Summary Group,Reminder,Erinnerung
-apps/erpnext/erpnext/stock/utils.py +207,Serial number {0} entered more than once,Seriennummer {0} wurde mehrfach erfasst
-DocType: Journal Entry,Journal Entry,Buchungssatz
-DocType: Expense Claim Advance,Unclaimed amount,Nicht beanspruchte Menge
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} Elemente in Bearbeitung
-DocType: Workstation,Workstation Name,Name des Arbeitsplatzes
-DocType: Grading Scale Interval,Grade Code,Grade-Code
-DocType: POS Item Group,POS Item Group,POS Artikelgruppe
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-Mail-Bericht:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +608,BOM {0} does not belong to Item {1},Stückliste {0} gehört nicht zum Artikel {1}
-DocType: Sales Partner,Target Distribution,Aufteilung der Zielvorgaben
-DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Abschluss der vorläufigen Beurteilung
-DocType: Salary Slip,Bank Account No.,Bankkonto-Nr.
-DocType: Naming Series,This is the number of the last created transaction with this prefix,Dies ist die Nummer der letzten erstellten Transaktion mit diesem Präfix
-DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
-{total_score} (the total score from that period),
-{period_number} (the number of periods to present day)
-","Scorecard-Variablen können verwendet werden, sowie: {total_score} (die Gesamtpunktzahl aus diesem Zeitraum), {period_number} (die Anzahl der Perioden bis heute)"
-DocType: Quality Inspection Reading,Reading 8,Ablesewert 8
-DocType: Sales Partner,Agent,Beauftragter
-DocType: Purchase Invoice,Taxes and Charges Calculation,Berechnung der Steuern und Gebühren
-DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Vermögensabschreibung automatisch verbuchen
-DocType: BOM Operation,Workstation,Arbeitsplatz
-DocType: Request for Quotation Supplier,Request for Quotation Supplier,Angebotsanfrage Lieferant
-DocType: Healthcare Settings,Registration Message,Registrierungsnachricht
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Hardware
-DocType: Prescription Dosage,Prescription Dosage,Verschreibungspflichtige Dosierung
-DocType: Attendance,HR Manager,Leiter der Personalabteilung
-apps/erpnext/erpnext/accounts/party.py +176,Please select a Company,Bitte ein Unternehmen auswählen
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Bevorzugter Urlaub
-DocType: Purchase Invoice,Supplier Invoice Date,Lieferantenrechnungsdatum
-DocType: Asset Settings,This value is used for pro-rata temporis calculation,Dieser Wert wird für die pro-rata-temporis-Berechnung verwendet
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Sie müssen Ihren Einkaufswagen aktivieren.
-DocType: Payment Entry,Writeoff,Abschreiben
-DocType: Stock Settings,Naming Series Prefix,Naming Series Prefix
-DocType: Appraisal Template Goal,Appraisal Template Goal,Bewertungsvorlage zur Zielorientierung
-DocType: Salary Component,Earning,Einkommen
-DocType: Supplier Scorecard,Scoring Criteria,Bewertungskriterien
-DocType: Purchase Invoice,Party Account Currency,Gruppenkonten-Währung
-,BOM Browser,Stücklisten-Browser
-apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Bitte aktualisieren Sie Ihren Status für diese Trainingsveranstaltung
-DocType: Item Barcode,EAN,EAN
-DocType: Purchase Taxes and Charges,Add or Deduct,Addieren/Subtrahieren
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Überlagernde Bedingungen gefunden zwischen:
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,"""Zu Buchungssatz"" {0} ist bereits mit einem anderen Beleg abgeglichen"
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Gesamtbestellwert
-apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Lebensmittel
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Alter Bereich 3
-DocType: Maintenance Schedule Item,No of Visits,Anzahl der Besuche
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Wartungsplan {0} existiert gegen {1}
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,einschreibende Student
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Die Währung des Abschlusskontos muss {0} sein
-apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Summe der Punkte für alle Ziele sollte 100 sein. Aktueller Stand {0}
-DocType: Project,Start and End Dates,Start- und Enddatum
-,Delivered Items To Be Billed,"Gelieferte Artikel, die abgerechnet werden müssen"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Open BOM {0}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Lager kann für Seriennummer nicht geändert werden
-DocType: Authorization Rule,Average Discount,Durchschnittlicher Rabatt
-DocType: Purchase Invoice Item,UOM,UOM
-DocType: Rename Tool,Utilities,Dienstprogramme
-DocType: POS Profile,Accounting,Buchhaltung
-DocType: Employee,EMP/,MA/
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Bitte wählen Sie Chargen für Chargen
-DocType: Asset,Depreciation Schedules,Abschreibungen Termine
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192,Following accounts might be selected in GST Settings:,In den GST-Einstellungen können folgende Konten ausgewählt werden:
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,Application period cannot be outside leave allocation period,Beantragter Zeitraum kann nicht außerhalb der beantragten Urlaubszeit liegen
-DocType: Activity Cost,Projects,Projekte
-DocType: Payment Request,Transaction Currency,Transaktionswährung
-apps/erpnext/erpnext/controllers/buying_controller.py +30,From {0} | {1} {2},Von {0} | {1} {2}
-DocType: Production Order Operation,Operation Description,Vorgangsbeschreibung
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Start- und Schlußdatum des Geschäftsjahres können nicht geändert werden, wenn das Geschäftsjahr gespeichert wurde."
-DocType: Quotation,Shopping Cart,Warenkorb
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Durchschnittlicher täglicher Abgang
-DocType: POS Profile,Campaign,Kampagne
-DocType: Supplier,Name and Type,Name und Typ
-DocType: Physician,Contacts and Address,Kontakte und Adresse
-DocType: Purchase Invoice,Contact Person,Kontaktperson
-apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date',"""Voraussichtliches Startdatum"" kann nicht nach dem ""Voraussichtlichen Enddatum"" liegen"
-DocType: Course Scheduling Tool,Course End Date,Kurs Enddatum
-DocType: Holiday List,Holidays,Ferien
-DocType: Sales Order Item,Planned Quantity,Geplante Menge
-DocType: Purchase Invoice Item,Item Tax Amount,Artikelsteuerbetrag
-DocType: Water Analysis,Water Analysis Criteria,Wasseranalysekriterien
-DocType: Item,Maintain Stock,Lager verwalten
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +226,Stock Entries already created for Production Order ,Es wurden bereits Lagerbuchungen zum Fertigungsauftrag erstellt
-DocType: Employee,Prefered Email,Bevorzugte E-Mail
-DocType: Student Admission,Eligibility and Details,Teilnahmeberechtigung und Details
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38,Net Change in Fixed Asset,Nettoveränderung des Anlagevermögens
-DocType: Leave Control Panel,Leave blank if considered for all designations,"Freilassen, wenn für alle Einstufungen gültig"
-apps/erpnext/erpnext/controllers/accounts_controller.py +799,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Kosten für den Typ ""real"" in Zeile {0} können nicht in den Artikelpreis mit eingeschlossen werden"
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +382,Max: {0},Max: {0}
-apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Von Datum und Uhrzeit
-DocType: Email Digest,For Company,Für Firma
-apps/erpnext/erpnext/config/support.py +17,Communication log.,Kommunikationsprotokoll
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195,"Request for Quotation is disabled to access from portal, for more check portal settings.","Angebotsanfrage ist für den Zugriff aus dem Portal deaktiviert, für mehr Kontrolle Portaleinstellungen."
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Bitte richten Sie das Mitarbeiterbenennungssystem in Human Resource&gt; HR Settings ein
-DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Einkaufsbetrag
-DocType: Sales Invoice,Shipping Address Name,Lieferadresse Bezeichnung
-DocType: Material Request,Terms and Conditions Content,Allgemeine Geschäftsbedingungen Inhalt
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Beim Erstellen des Kursplans sind Fehler aufgetreten
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581,cannot be greater than 100,Kann nicht größer als 100 sein
-apps/erpnext/erpnext/stock/doctype/item/item.py +751,Item {0} is not a stock Item,Artikel {0} ist kein Lagerartikel
-DocType: Maintenance Visit,Unscheduled,Außerplanmäßig
-DocType: Employee,Owned,Im Besitz von
-DocType: Salary Detail,Depends on Leave Without Pay,Hängt von unbezahltem Urlaub ab
-DocType: Pricing Rule,"Higher the number, higher the priority","Je höher die Zahl, desto höher die Priorität"
-,Purchase Invoice Trends,Trendanalyse Eingangsrechnungen
-DocType: Employee,Better Prospects,Bessere Vorhersage
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +217,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Zeile # {0}: Der Batch {1} hat nur {2} Menge. Bitte wähle eine andere Charge aus, die {3} Menge zur Verfügung hat oder die Zeile in mehrere Zeilen aufteilt, um aus mehreren Chargen zu liefern / auszutauschen"
-DocType: Vehicle,License Plate,Nummernschild
-DocType: Appraisal,Goals,Ziele
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +349,Select POS Profile,Kassenprofil auswählen
-DocType: Warranty Claim,Warranty / AMC Status,Status der Garantie / des jährlichen Wartungsvertrags
-,Accounts Browser,Kontenbrowser
-DocType: Payment Entry Reference,Payment Entry Reference,Zahlungsreferenz
-DocType: GL Entry,GL Entry,Buchung zum Hauptbuch
-DocType: HR Settings,Employee Settings,Mitarbeitereinstellungen
-,Batch-Wise Balance History,Chargenbezogener Bestandsverlauf
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Die Druckeinstellungen im jeweiligen Druckformat aktualisiert
-DocType: Package Code,Package Code,Paketnummer
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Auszubildende(r)
-DocType: Purchase Invoice,Company GSTIN,Unternehmen GSTIN
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,Negative Quantity is not allowed,Negative Menge ist nicht erlaubt
-DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
-Used for Taxes and Charges",Die Tabelle Steuerdetails wird aus dem Artikelstamm als Zeichenfolge entnommen und in diesem Feld gespeichert. Wird verwendet für Steuern und Abgaben
-DocType: Supplier Scorecard Period,SSC-,SSC-
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Mitarbeiter können nicht an sich selbst Bericht erstatten
-DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Wenn das Konto gesperrt ist, sind einem eingeschränkten Benutzerkreis Buchungen erlaubt."
-DocType: Email Digest,Bank Balance,Kontostand
-apps/erpnext/erpnext/accounts/party.py +241,Accounting Entry for {0}: {1} can only be made in currency: {2},Eine Buchung für {0}: {1} kann nur in der Währung: {2} vorgenommen werden
-DocType: Job Opening,"Job profile, qualifications required etc.","Stellenbeschreibung, erforderliche Qualifikationen usw."
-DocType: Journal Entry Account,Account Balance,Kontostand
-apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Steuerregel für Transaktionen
-DocType: Rename Tool,Type of document to rename.,"Dokumententyp, der umbenannt werden soll."
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Für das Eingangskonto {2} ist ein Kunde erforderlich
-DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Gesamte Steuern und Gebühren (Firmenwährung)
-DocType: Weather,Weather Parameter,Wetterparameter
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Gewinn- und Verlustrechnung für nicht geschlossenes Finanzjahr zeigen.
-DocType: Lab Test Template,Collection Details,Sammlungsdetails
-DocType: POS Profile,Allow Print Before Pay,Druck vor Bezahlung zulassen
-DocType: Land Unit,Linked Soil Texture,Verbundene Bodentextur
-DocType: Shipping Rule,Shipping Account,Versandkonto
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Konto {2} ist inaktiv
-apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,"Kundenaufträge anlegen, um Arbeit zu planen und pünktliche Lieferung sicherzustellen"
-DocType: Quality Inspection,Readings,Ablesungen
-DocType: Stock Entry,Total Additional Costs,Gesamte Zusatzkosten
-DocType: Course Schedule,SH,Sch
-DocType: BOM,Scrap Material Cost(Company Currency),Ausschussmaterialkosten (Firmenwährung)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Unterbaugruppen
-DocType: Asset,Asset Name,Asset-Name
-DocType: Project,Task Weight,Vorgangsgewichtung
-DocType: Shipping Rule Condition,To Value,Bis-Wert
-DocType: Asset Movement,Stock Manager,Lagerleiter
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +158,Source warehouse is mandatory for row {0},Ausgangslager ist für Zeile {0} zwingend erforderlich
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Die Zahlungsbedingung in Zeile {0} ist möglicherweise ein Duplikat.
-apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Landwirtschaft (beta)
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863,Packing Slip,Packzettel
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Büromiete
-apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Einstellungen für SMS-Gateway verwalten
-DocType: Disease,Common Name,Gemeinsamen Namen
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Import fehlgeschlagen!
-apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Noch keine Adresse hinzugefügt.
-DocType: Workstation Working Hour,Workstation Working Hour,Arbeitsplatz-Arbeitsstunde
-DocType: Vital Signs,Blood Pressure,Blutdruck
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Analytiker
-DocType: Item,Inventory,Lagerbestand
-DocType: Item,Sales Details,Verkaufsdetails
-DocType: Quality Inspection,QI-,QI-
-DocType: Opportunity,With Items,Mit Artikeln
-DocType: Asset Maintenance,Maintenance Team,Wartungs Team
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,In Menge
-DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Validieren Sie den eingeschriebenen Kurs für Studierende in der Studentengruppe
-DocType: Notification Control,Expense Claim Rejected,Aufwandsabrechnung abgelehnt
-DocType: Item,Item Attribute,Artikelattribut
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Regierung
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Kostenabrechnung {0} existiert bereits für das Fahrzeug Log
-apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Name des Institutes
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Bitte geben Sie Rückzahlungsbetrag
-apps/erpnext/erpnext/config/stock.py +309,Item Variants,Artikelvarianten
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Dienstleistungen
-DocType: HR Settings,Email Salary Slip to Employee,Gehaltsabrechnung per E-Mail an Mitarbeiter senden
-DocType: Cost Center,Parent Cost Center,Übergeordnete Kostenstelle
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Select Possible Supplier,Wählen Mögliche Lieferant
-DocType: Sales Invoice,Source,Quelle
-DocType: Customer,"Select, to make the customer searchable with these fields","Wählen Sie, um den Kunden mit diesen Feldern durchsuchbar zu machen"
-apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Zeige geschlossen
-DocType: Leave Type,Is Leave Without Pay,Ist unbezahlter Urlaub
-apps/erpnext/erpnext/stock/doctype/item/item.py +260,Asset Category is mandatory for Fixed Asset item,Anlagekategorie ist obligatorisch für Posten des Anlagevermögens
-DocType: Fee Validity,Fee Validity,Gebührengültigkeit
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,"Keine Datensätze in der Tabelle ""Zahlungen"" gefunden"
-apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},{0} steht im Konflikt mit {1} bezüglich {2} {3}
-DocType: Student Attendance Tool,Students HTML,Studenten HTML
-DocType: POS Profile,Apply Discount,Rabatt anwenden
-DocType: GST HSN Code,GST HSN Code,GST HSN Code
-DocType: Employee External Work History,Total Experience,Gesamterfahrung
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Bitte richten Sie die Nummerierungsserie für die Teilnahme über Setup&gt; Nummerierungsserie ein
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,offene Projekte
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295,Packing Slip(s) cancelled,Packzettel storniert
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36,Cash Flow from Investing,Cashflow aus Investitionen
-DocType: Program Course,Program Course,Programm Kurs
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Fracht- und Versandkosten
-DocType: Homepage,Company Tagline for website homepage,Unternehmensschlagzeile für die Internet-Homepage
-DocType: Item Group,Item Group Name,Name der Artikelgruppe
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Vergriffen
-DocType: Student,Date of Leaving,Austrittsdatum
-DocType: Pricing Rule,For Price List,Für Preisliste
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Direktsuche
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Standardeinstellungen festlegen
-apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Leads erstellen
-DocType: Maintenance Schedule,Schedules,Zeitablaufpläne
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +464,POS Profile is required to use Point-of-Sale,"POS-Profil ist erforderlich, um Point-of-Sale zu verwenden"
-DocType: Purchase Invoice Item,Net Amount,Nettobetrag
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} sind nicht gebucht, deshalb kann die Aktion nicht abgeschlossen werden"
-DocType: Purchase Order Item Supplied,BOM Detail No,Stückliste Detailnr.
-DocType: Landed Cost Voucher,Additional Charges,Zusätzliche Kosten
-DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Zusätzlicher Rabatt (Firmenwährung)
-DocType: Supplier Scorecard,Supplier Scorecard,Lieferanten-Scorecard
-DocType: Plant Analysis,Result Datetime,Ergebnis Datetime
-apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Bitte neues Konto aus dem Kontenplan erstellen.
-,Support Hour Distribution,Stützzeitverteilung
-DocType: Maintenance Visit,Maintenance Visit,Wartungsbesuch
-DocType: Student,Leaving Certificate Number,Leaving Certificate Nummer
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +63,"Appointment cancelled, Please review and cancel the invoice {0}",der Termin wurde abgesagt. Bitte Rechnung {0} prüfen und abbrechen bzw. stornieren.
-DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Verfügbare Losgröße im Lager
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Druckformat aktualisieren
-DocType: Landed Cost Voucher,Landed Cost Help,Hilfe zum Einstandpreis
-DocType: Purchase Invoice,Select Shipping Address,Lieferadresse auswählen
-apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Mitgliedschaftsdetails
-DocType: Leave Block List,Block Holidays on important days.,Urlaub an wichtigen Tagen sperren.
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220,Please input all required Result Value(s),Bitte geben Sie alle erforderlichen Ergebniswerte ein
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94,Accounts Receivable Summary,Übersicht der Forderungen
-DocType: Employee Loan,Monthly Repayment Amount,Monatlicher Rückzahlungsbetrag
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Rechnungen öffnen
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,"Bitte in einem Mitarbeiterdatensatz das Feld Nutzer-ID setzen, um die Rolle Mitarbeiter zuzuweisen"
-DocType: UOM,UOM Name,Maßeinheit-Name
-DocType: GST HSN Code,HSN Code,HSN-Code
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39,Contribution Amount,Beitragshöhe
-DocType: Purchase Invoice,Shipping Address,Lieferadresse
-DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"Dieses Werkzeug hilft Ihnen dabei, die Menge und die Bewertung von Bestand im System zu aktualisieren oder zu ändern. Es wird in der Regel verwendet, um die Systemwerte und den aktuellen Bestand Ihrer Lager zu synchronisieren."
-DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"""In Worten"" wird sichtbar, sobald Sie den Lieferschein speichern."
-DocType: Expense Claim,EXP,BA
-DocType: Water Analysis,Container,Container
-apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} erscheint mehrfach in Zeile {2} &amp; {3}
-DocType: Healthcare Settings,Manage Sample Collection,Probenahme sammeln
-DocType: Production Plan,Ignore Existing Ordered Quantity,Bestehende Bestellmenge ignorieren
-DocType: Patient,Tobacco Past Use,Tabak Verwendung
-DocType: Sales Invoice Item,Brand Name,Bezeichnung der Marke
-DocType: Purchase Receipt,Transporter Details,Informationen zum Transporteur
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Benutzer {0} ist bereits dem Arzt {1} zugeordnet
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2684,Default warehouse is required for selected item,Standard Lager wird für das ausgewählte Element erforderlich
-apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Kiste
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038,Possible Supplier,Mögliche Lieferant
-DocType: Budget,Monthly Distribution,Monatsbezogene Verteilung
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Empfängerliste ist leer. Bitte eine Empfängerliste erstellen
-apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Gesundheitswesen (Beta)
-DocType: Production Plan Sales Order,Production Plan Sales Order,Produktionsplan für Kundenauftrag
-DocType: Sales Partner,Sales Partner Target,Vertriebspartner-Ziel
-DocType: Loan Type,Maximum Loan Amount,Maximaler Darlehensbetrag
-DocType: Pricing Rule,Pricing Rule,Preisregel
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Duplikat Rollennummer für den Schüler {0}
-DocType: Budget,Action if Annual Budget Exceeded,Erwünschte Aktion bei überschrittenem jährlichem Budget
-apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Von der Materialanfrage zum Lieferantenauftrag
-DocType: Shopping Cart Settings,Payment Success URL,Payment Success URL
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Zeile # {0}: Zurückgegebener Artikel {1} existiert nicht in {2} {3}
-DocType: Purchase Receipt,PREC-,PREC-
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankkonten
-,Bank Reconciliation Statement,Kontoauszug zum Kontenabgleich
-DocType: Consultation,Medical Coding,Medizinische Kodierung
-DocType: Healthcare Settings,Reminder Message,Erinnerungsmeldung
-,Lead Name,Name des Leads
-,POS,Verkaufsstelle
-DocType: C-Form,III,III
-apps/erpnext/erpnext/config/stock.py +314,Opening Stock Balance,Eröffnungsbestände
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} darf nur einmal vorkommen
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Erfolgreich zugewiesene Abwesenheiten für {0}
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Keine Artikel zum Verpacken
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Bitte richten Sie das Instructor Naming System in Education&gt; Education Settings ein
-DocType: Shipping Rule Condition,From Value,Von-Wert
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +593,Manufacturing Quantity is mandatory,Eingabe einer Fertigungsmenge ist erforderlich
-DocType: Employee Loan,Repayment Method,Rückzahlweg
-DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Wenn diese Option aktiviert, wird die Startseite der Standardartikelgruppe für die Website sein"
-DocType: Quality Inspection Reading,Reading 4,Ablesewert 4
-apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Ansprüche auf Kostenübernahme durch das Unternehmen
-apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Die Schüler im Herzen des Systems sind, fügen Sie alle Ihre Schüler"
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: Räumungsdatum {1} kann nicht vor dem Scheck Datum sein {2}
-DocType: Asset Maintenance Task,Certificate Required,Zertifikat erforderlich
-DocType: Company,Default Holiday List,Standard-Urlaubsliste
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196,Row {0}: From Time and To Time of {1} is overlapping with {2},"Row {0}: Von Zeit und Zeit, um von {1} überlappt mit {2}"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Lager-Verbindlichkeiten
-DocType: Purchase Invoice,Supplier Warehouse,Lieferantenlager
-DocType: Opportunity,Contact Mobile No,Kontakt-Mobiltelefonnummer
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +395,Select Company,Unternehmen auswählen
-,Material Requests for which Supplier Quotations are not created,"Materialanfragen, für die keine Lieferantenangebote erstellt werden"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Der Benutzer {0} hat kein Standard-POS-Profil. Aktivieren Sie für diesen Benutzer die Standardeinstellung in der Zeile {1}.
-DocType: Student Group,Set 0 for no limit,Stellen Sie 0 für keine Grenze
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +123,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"Der Tag/die Tage, für den/die Sie Urlaub beantragen, sind Ferien. Deshalb müssen Sie keinen Urlaub beantragen."
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,"Zeile {idx}: {field} wird benötigt, um die Eröffnungsrechnung {invoice_type} zu erstellen"
-DocType: Customer,Primary Address and Contact Detail,Primäre Adresse und Kontaktdetails
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Zahlungsemail erneut senden
-apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Neuer Vorgang
-DocType: Consultation,Appointment,Termin
-apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Angebot erstellen
-apps/erpnext/erpnext/config/education.py +226,Other Reports,Weitere Berichte
-apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Bitte wählen Sie mindestens eine Domain aus.
-DocType: Dependent Task,Dependent Task,Abhängiger Vorgang
-apps/erpnext/erpnext/stock/doctype/item/item.py +443,Conversion factor for default Unit of Measure must be 1 in row {0},Umrechnungsfaktor für Standardmaßeinheit muss in Zeile {0} 1 sein
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +189,Leave of type {0} cannot be longer than {1},Abwesenheit vom Typ {0} kann nicht länger sein als {1}
-DocType: Manufacturing Settings,Try planning operations for X days in advance.,Arbeitsgänge für X Tage im Voraus planen.
-DocType: HR Settings,Stop Birthday Reminders,Geburtstagserinnerungen ausschalten
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Bitte setzen Sie Standard-Abrechnungskreditorenkonto in Gesellschaft {0}
-DocType: SMS Center,Receiver List,Empfängerliste
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1093,Search Item,Suche Artikel
-DocType: Payment Schedule,Payment Amount,Zahlungsbetrag
-DocType: Patient Appointment,Referring Physician,Auf den Physiker bezogen
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Verbrauchte Menge
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100,Net Change in Cash,Nettoveränderung der Barmittel
-DocType: Assessment Plan,Grading Scale,Bewertungsskala
-apps/erpnext/erpnext/stock/doctype/item/item.py +437,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Maßeinheit {0} wurde mehr als einmal in die Umrechnungsfaktor-Tabelle eingetragen
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +639,Already completed,Schon erledigt
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Stock In Hand
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Importvorgang erfolgreich!
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Zahlungsanordnung bereits vorhanden ist {0}
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Aufwendungen für in Umlauf gebrachte Artikel
-DocType: Physician,Hospital,Krankenhaus
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +385,Quantity must not be more than {0},Menge darf nicht mehr als {0} sein
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Zurück Geschäftsjahr nicht geschlossen
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Alter (Tage)
-DocType: Quotation Item,Quotation Item,Angebotsposition
-DocType: Customer,Customer POS Id,Kunden-POS-ID
-DocType: Account,Account Name,Kontenname
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Von-Datum kann später liegen als Bis-Datum
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Seriennummer {0} mit Menge {1} kann nicht eine Teilmenge sein
-apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Stammdaten zum Lieferantentyp
-DocType: Purchase Order Item,Supplier Part Number,Lieferanten-Artikelnummer
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Umrechnungskurs kann nicht 0 oder 1 sein
-DocType: Share Balance,To No,Zu Nein
-DocType: Subscription,Reference Document,Referenzdokument
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229,{0} {1} is cancelled or stopped,{0} {1} wird abgebrochen oder  beendet
-DocType: Accounts Settings,Credit Controller,Kredit-Controller
-DocType: Grant Application,Applicant Type,Bewerbertyp
-DocType: Purchase Invoice,03-Deficiency in services,03-Mangel an Dienstleistungen
-DocType: Delivery Note,Vehicle Dispatch Date,Datum des Versands mit dem Fahrzeug
-DocType: Healthcare Settings,Default Medical Code Standard,Default Medical Code Standard
-DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Kaufbeleg {0} wurde nicht übertragen
-DocType: Company,Default Payable Account,Standard-Verbindlichkeitenkonto
-apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Einstellungen zum Warenkorb, z.B. Versandregeln, Preislisten usw."
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% berechnet
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Reservierte Menge
-DocType: Party Account,Party Account,Gruppenkonto
-apps/erpnext/erpnext/config/setup.py +122,Human Resources,Personalwesen
-DocType: Lead,Upper Income,Gehobenes Einkommen
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Ablehnen
-DocType: Journal Entry Account,Debit in Company Currency,Soll in Unternehmenswährung
-DocType: BOM Item,BOM Item,Stücklisten-Artikel
-DocType: Appraisal,For Employee,Für Mitarbeiter
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Machen Disbursement Eintrag
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Row {0}: Voraus gegen Lieferant muss belasten werden
-DocType: Company,Default Values,Standardwerte
-DocType: Membership,INR,INR
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frequenz} Übersicht
-DocType: Expense Claim,Total Amount Reimbursed,Gesamterstattungsbetrag
-apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Dies basiert auf Protokollen gegen dieses Fahrzeug. Siehe Zeitleiste unten für Details
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Zu Eingangsrechnung {0} vom {1}
-DocType: Customer,Default Price List,Standardpreisliste
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +322,Asset Movement record {0} created,Asset-Bewegung Datensatz {0} erstellt
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Sie können das Geschäftsjahr {0} nicht löschen. Das Geschäftsjahr {0} ist als Standard in den globalen Einstellungen festgelegt
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Ein Kunde mit demselben Namen existiert bereits
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Dies wird Gehaltsabrechnungen übermitteln und eine periodengerechte Journalbuchung erstellen. Willst du fortfahren?
-DocType: Purchase Invoice,Total Net Weight,Gesamtnettogewicht
-DocType: Purchase Invoice,Eligibility For ITC,Berechtigung für ITC
-DocType: Journal Entry,Entry Type,Buchungstyp
-,Customer Credit Balance,Kunden-Kreditlinien
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28,Net Change in Accounts Payable,Nettoveränderung der Verbindlichkeiten
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,EcritureLet,EcritureLet
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +216,Credit limit has been crossed for customer {0} ({1}/{2}),Das Kreditlimit wurde für den Kunden {0} ({1} / {2}) überschritten.
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',"Kunde erforderlich für ""Kundenbezogener Rabatt"""
-apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Zahlungstermine anhand der Journale aktualisieren
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Preisgestaltung
-DocType: Quotation,Term Details,Details der Geschäftsbedingungen
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Kann nicht mehr als {0} Studenten für diese Studentengruppe einschreiben.
-apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),Summe (ohne Steuern)
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Anazhl Leads
-apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} muss größer 0 sein
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30,Stock Available,Lager verfügbar
-DocType: Manufacturing Settings,Capacity Planning For (Days),Kapazitätsplanung für (Tage)
-apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Beschaffung
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66,None of the items have any change in quantity or value.,Keiner der Artikel hat irgendeine Änderung bei Mengen oder Kosten.
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Pflichtfeld - Programm
-DocType: Special Test Template,Result Component,Ergebniskomponente
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garantieanspruch
-,Lead Details,Einzelheiten zum Lead
-DocType: Volunteer,Availability and Skills,Verfügbarkeit und Fähigkeiten
-DocType: Salary Slip,Loan repayment,Darlehensrückzahlung
-DocType: Purchase Invoice,End date of current invoice's period,Schlußdatum der laufenden Eingangsrechnungsperiode
-DocType: Pricing Rule,Applicable For,Anwenden für
-DocType: Lab Test,Technician Name,Techniker Name
-DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Unlink Zahlung auf Annullierung der Rechnung
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Der eingegebene aktuelle Kilometerstand sollte größer sein als der Anfangskilometerstand {0}
-DocType: Restaurant Reservation,No Show,Keine Show
-DocType: Shipping Rule Country,Shipping Rule Country,Versandregel für Land
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Urlaub und Anwesenheit
-DocType: Maintenance Visit,Partially Completed,Teilweise abgeschlossen
-apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Moderate Empfindlichkeit
-DocType: Leave Type,Include holidays within leaves as leaves,Urlaube innerhalb von Abwesenheiten als Abwesenheiten mit einbeziehen
-DocType: Sales Invoice,Packed Items,Verpackte Artikel
-apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garantieantrag zu Serien-Nr.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +192,'Total','Gesamtbetrag'
-DocType: Shopping Cart Settings,Enable Shopping Cart,Warenkorb aktivieren
-DocType: Employee,Permanent Address,Feste Adresse
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
-						than Grand Total {2}",Anzahlung zu {0} {1} kann nicht größer sein als als Gesamtsumme {2}
-DocType: Patient,Medication,Medikation
-DocType: Production Plan,Include Non Stock Items,Nicht verfügbare Artikel einschließen
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Bitte Artikelnummer auswählen
-DocType: Student Sibling,Studying in Same Institute,Studieren in Same-Institut
-DocType: Territory,Territory Manager,Gebietsleiter
-DocType: Packed Item,To Warehouse (Optional),Eingangslager (Optional)
-DocType: GST Settings,GST Accounts,GST-Konten
-DocType: Payment Entry,Paid Amount (Company Currency),Gezahlter Betrag (Firmenwährung)
-DocType: Purchase Invoice,Additional Discount,Zusätzlicher Rabatt
-DocType: Selling Settings,Selling Settings,Vertriebseinstellungen
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Aktion bestätigen
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Online-Auktionen
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,Please specify either Quantity or Valuation Rate or both,Bitte entweder die Menge oder den Wertansatz oder beides eingeben
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Erfüllung
-apps/erpnext/erpnext/templates/generators/item.html +82,View in Cart,Ansicht Warenkorb
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Marketingkosten
-,Item Shortage Report,Artikelengpass-Bericht
-apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Kann keine Standardkriterien erstellen. Bitte benennen Sie die Kriterien um
-apps/erpnext/erpnext/stock/doctype/item/item.js +282,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Gewicht ist angegeben, bitte auch ""Gewichts-Maßeinheit"" angeben"
-DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materialanfrage wurde für die Erstellung dieser Lagerbuchung verwendet
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Nächstes Abschreibedatum ist obligatorisch für neue Anlagen
-DocType: Student Group Creation Tool,Separate course based Group for every Batch,Separate Kursbasierte Gruppe für jede Charge
-apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Einzelnes Element eines Artikels
-DocType: Fee Category,Fee Category,Preis Kategorie
-DocType: Agriculture Task,Next Business Day,Nächster Arbeitstag
-DocType: Drug Prescription,Dosage by time interval,Dosierung nach Zeitintervall
-DocType: Cash Flow Mapper,Section Header,Abschnittsüberschrift
-,Student Fee Collection,Studiengebühren Sammlung
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Termindauer (min.)
-DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Eine Buchung für jede Lagerbewegung erstellen
-DocType: Leave Allocation,Total Leaves Allocated,Insgesamt zugewiesene Urlaubstage
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Angabe des Lagers ist in Zeile {0} erforderlich
-apps/erpnext/erpnext/public/js/setup_wizard.js +145,Please enter valid Financial Year Start and End Dates,Bitte geben Sie für das Geschäftsjahr einen gültigen Start- und Endtermin an.
-DocType: Employee,Date Of Retirement,Zeitpunkt der Pensionierung
-DocType: Upload Attendance,Get Template,Vorlage aufrufen
-DocType: Material Request,Transferred,Übergeben
-DocType: Vehicle,Doors,Türen
-apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext Setup abgeschlossen!
-DocType: Healthcare Settings,Collect Fee for Patient Registration,Sammeln Sie die Gebühr für die Patientenregistrierung
-apps/erpnext/erpnext/stock/doctype/item/item.py +677,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Attribute nach Bestandsgeschäft können nicht geändert werden. Erstelle einen neuen Artikel und übertrage den Bestand auf den neuen Artikel
-DocType: Course Assessment Criteria,Weightage,Gewichtung
-DocType: Purchase Invoice,Tax Breakup,Steuererhebung
-DocType: Packing Slip,PS-,PS-
-DocType: Member,Non Profit Member,Non-Profit-Mitglied
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,"{0} {1}: Kostenstelle ist erforderlich für ""Gewinn- und Verlust"" Konto {2}. Bitte erstellen Sie eine Standard-Kostenstelle für das Unternehmen."
-DocType: Payment Schedule,Payment Term,Zahlungsbedingung
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +167,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. Bitte den Kundennamen ändern oder die Kundengruppe umbenennen
-DocType: Land Unit,Area,Bereich
-apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Neuer Kontakt
-DocType: Territory,Parent Territory,Übergeordnete Region
-DocType: Purchase Invoice,Place of Supply,Ort der Versorgung
-DocType: Quality Inspection Reading,Reading 2,Ablesewert 2
-DocType: Stock Entry,Material Receipt,Materialannahme
-DocType: Homepage,Products,Produkte
-DocType: Announcement,Instructor,Lehrer
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Artikel auswählen (optional)
-DocType: Fee Schedule Student Group,Fee Schedule Student Group,Fee Zeitplan Student Group
-DocType: Student,AB+,AB+
-DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Wenn dieser Artikel Varianten hat, dann kann er bei den Kundenaufträgen, etc. nicht ausgewählt werden"
-DocType: Lead,Next Contact By,Nächster Kontakt durch
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Quantity required for Item {0} in row {1},Für Artikel {0} in Zeile {1} benötigte Menge
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,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"
-DocType: Quotation,Order Type,Bestellart
-,Item-wise Sales Register,Artikelbezogene Übersicht der Verkäufe
-DocType: Asset,Gross Purchase Amount,Bruttokaufbetrag
-apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Eröffnungssalden
-DocType: Asset,Depreciation Method,Abschreibungsmethode
-DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Ist diese Steuer im Basispreis enthalten?
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Summe Vorgabe
-DocType: Soil Texture,Sand Composition (%),Sandzusammensetzung (%)
-DocType: Job Applicant,Applicant for a Job,Bewerber für einen Job
-DocType: Production Plan Material Request,Production Plan Material Request,Produktionsplan-Material anfordern
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Keine Fertigungsaufträge erstellt
-DocType: Stock Reconciliation,Reconciliation JSON,Abgleich JSON (JavaScript Object Notation)
-apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Zu viele Spalten. Exportieren Sie den Bericht und drucken Sie ihn mit einem Tabellenkalkulationsprogramm aus.
-DocType: Purchase Invoice Item,Batch No,Chargennummer
-DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Zusammenfassen mehrerer Kundenaufträge zu einer Kundenbestellung erlauben
-DocType: Student Group Instructor,Student Group Instructor,Student Group Instructor
-DocType: Grant Application,Assessment  Mark (Out of 10),Bewertungsnote (von 10)
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobil Nein
-apps/erpnext/erpnext/setup/doctype/company/company.py +218,Main,Haupt
-apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Variante
-DocType: Naming Series,Set prefix for numbering series on your transactions,Präfix für die Seriennummerierung Ihrer Transaktionen festlegen
-DocType: Employee Attendance Tool,Employees HTML,Mitarbeiter HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +457,Default BOM ({0}) must be active for this item or its template,Standardstückliste ({0}) muss für diesen Artikel oder dessen Vorlage aktiv sein
-DocType: Employee,Leave Encashed?,Urlaub eingelöst?
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,"Feld ""Chance von"" ist zwingend erforderlich"
-DocType: Email Digest,Annual Expenses,Jährliche Kosten
-DocType: Item,Variants,Varianten
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1139,Make Purchase Order,Lieferantenauftrag anlegen
-DocType: SMS Center,Send To,Senden an
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +134,There is not enough leave balance for Leave Type {0},Es gibt nicht genügend verfügbaren Urlaub für Urlaubstyp {0}
-DocType: Payment Reconciliation Payment,Allocated amount,Zugewiesene Menge
-DocType: Sales Team,Contribution to Net Total,Beitrag zum Gesamtnetto
-DocType: Sales Invoice Item,Customer's Item Code,Kunden-Artikel-Nr.
-DocType: Stock Reconciliation,Stock Reconciliation,Bestandsabgleich
-DocType: Territory,Territory Name,Name der Region (Gebiet)
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +204,Work-in-Progress Warehouse is required before Submit,Fertigungslager wird vor dem Übertragen benötigt
-apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Bewerber für einen Job
-DocType: Purchase Order Item,Warehouse and Reference,Lager und Referenz
-DocType: Supplier,Statutory info and other general information about your Supplier,Rechtlich notwendige und andere allgemeine Informationen über Ihren Lieferanten
-DocType: Item,Serial Nos and Batches,Seriennummern und Chargen
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Schülergruppenstärke
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +256,Against Journal Entry {0} does not have any unmatched {1} entry,"""Zu Buchungssatz"" {0} hat nur abgeglichene {1} Buchungen"
-apps/erpnext/erpnext/config/hr.py +142,Appraisals,Beurteilungen
-apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Schulungsveranstaltungen
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Doppelte Seriennummer für Posten {0} eingegeben
-DocType: Shipping Rule Condition,A condition for a Shipping Rule,Bedingung für eine Versandregel
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,Bitte eingeben
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Wartungsprotokoll
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236,Please set filter based on Item or Warehouse,Bitte setzen Sie Filter basierend auf Artikel oder Lager
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Artikelcode&gt; Artikelgruppe&gt; Marke
-DocType: Packing Slip,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)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +798,Discount amount cannot be greater than 100%,Rabattbetrag kann nicht größer als 100% sein
-DocType: Sales Order,To Deliver and Bill,Auszuliefern und Abzurechnen
-DocType: Student Group,Instructors,Lehrer
-DocType: GL Entry,Credit Amount in Account Currency,(Gut)Haben-Betrag in Kontowährung
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +598,BOM {0} must be submitted,Stückliste {0} muss übertragen werden
-apps/erpnext/erpnext/config/accounts.py +460,Share Management,Aktienverwaltung
-DocType: Authorization Control,Authorization Control,Berechtigungskontrolle
-apps/erpnext/erpnext/controllers/buying_controller.py +327,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Abgelehnt Warehouse ist obligatorisch gegen zurückgewiesen Artikel {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Payment,Bezahlung
-apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.",Lager {0} ist nicht mit einem Konto verknüpft. Bitte wählen Sie ein Konto in den Einstellungen für das Lager oder legen Sie das Standard Lagerkonto in den Einstellungen für  {1} fest.
-apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Verwalten Sie Ihre Aufträge
-DocType: Production Order Operation,Actual Time and Cost,Tatsächliche Laufzeit und Kosten
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materialanfrage von maximal {0} kann für Artikel {1} zum Kundenauftrag {2} gemacht werden
-DocType: Crop,Crop Spacing,Fruchtabstand
-DocType: Course,Course Abbreviation,Kurs Abkürzung
-DocType: Student Leave Application,Student Leave Application,Student Urlaubsantrag
-DocType: Item,Will also apply for variants,Gilt auch für Varianten
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +217,"Asset cannot be cancelled, as it is already {0}","Vermögen kann nicht rückgängig gemacht werden, da es ohnehin schon {0} ist"
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Mitarbeiter {0} am {1} nur halbtags anwesend
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Insgesamt Arbeitszeit sollte nicht größer sein als die maximale Arbeitszeit {0}
-apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Am
-apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Artikel zum Zeitpunkt des Verkaufs bündeln
-DocType: Material Request Plan Item,Actual Qty,Tatsächliche Anzahl
-DocType: Sales Invoice Item,References,Referenzen
-DocType: Quality Inspection Reading,Reading 10,Ablesewert 10
-DocType: Item,Barcodes,Barcodes
-DocType: Hub Category,Hub Node,Hub-Knoten
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Sie haben ein Duplikat eines Artikels eingetragen. Bitte korrigieren und erneut versuchen.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Mitarbeiter/-in
-DocType: Asset Movement,Asset Movement,Asset-Bewegung
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2199,New Cart,neue Produkte Warenkorb
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Artikel {0} ist kein Fortsetzungsartikel
-DocType: SMS Center,Create Receiver List,Empfängerliste erstellen
-DocType: Vehicle,Wheels,Räder
-DocType: Packing Slip,To Package No.,Bis Paket Nr.
-DocType: Patient Relation,Family,Familie
-DocType: Production Plan,Material Requests,Materialwünsche
-DocType: Warranty Claim,Issue Date,Ausstellungsdatum
-DocType: Activity Cost,Activity Cost,Aktivitätskosten
-DocType: Sales Invoice Timesheet,Timesheet Detail,Timesheet-Detail
-DocType: Purchase Receipt Item Supplied,Consumed Qty,Verbrauchte Anzahl
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekommunikation
-apps/erpnext/erpnext/accounts/party.py +264,Billing currency must be equal to either default company's currency or party account currency,Die Abrechnungswährung muss entweder der Währung der Standardfirma oder der Währung des Partnerkontos entsprechen
-DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Zeigt an, dass das Paket ein Teil dieser Lieferung ist (nur Entwurf)"
-DocType: Soil Texture,Loam,Lehm
-apps/erpnext/erpnext/controllers/accounts_controller.py +700,Row {0}: Due Date cannot be before posting date,Zeile {0}: Fälligkeitsdatum darf nicht vor dem Buchungsdatum liegen
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Zahlungsbuchung erstellen
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Menge für Artikel {0} muss kleiner sein als {1}
-,Sales Invoice Trends,Ausgangsrechnung-Trendanalyse
-DocType: Leave Application,Apply / Approve Leaves,Urlaub eintragen/genehmigen
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Für
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Kann sich nur auf eine Zeile beziehen, wenn die Berechnungsart der Kosten entweder ""auf vorherige Zeilensumme"" oder ""auf vorherigen Zeilenbetrag"" ist"
-DocType: Sales Order Item,Delivery Warehouse,Auslieferungslager
-apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Baum der finanziellen Kostenstellen.
-DocType: Serial No,Delivery Document No,Lieferdokumentennummer
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Bitte setzen Sie &quot;Gewinn / Verlustrechnung auf die Veräußerung von Vermögenswerten&quot; in Gesellschaft {0}
-DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Artikel vom Kaufbeleg übernehmen
-DocType: Serial No,Creation Date,Erstelldatum
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Artikel {0}ist mehrfach in Preisliste {1} aufgeführt
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Selling must be checked, if Applicable For is selected as {0}","Vertrieb muss aktiviert werden, wenn ""Anwenden auf"" ausgewählt ist bei {0}"
-DocType: Production Plan Material Request,Material Request Date,Material Auftragsdatum
-DocType: Purchase Order Item,Supplier Quotation Item,Lieferantenangebotsposition
-DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Deaktiviert die Erstellung von Zeitprotokollen zu Fertigungsaufträgen. Arbeitsgänge werden nicht zu Fertigungsaufträgen nachverfolgt
-DocType: Student,Student Mobile Number,Student Mobile Number
-DocType: Item,Has Variants,Hat Varianten
-apps/erpnext/erpnext/controllers/accounts_controller.py +487,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Für Artikel {0} in Zeile {1} kann mehr als {2} nicht überbucht werden. Um Überfakturierung zu ermöglichen, legen Sie bitte in Stock Settings fest"
-apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Update-Antwort
-apps/erpnext/erpnext/public/js/utils.js +232,You have already selected items from {0} {1},Sie haben bereits Elemente aus {0} {1} gewählt
-DocType: Monthly Distribution,Name of the Monthly Distribution,Bezeichnung der monatsweisen Verteilung
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Batch-ID ist obligatorisch
-DocType: Sales Person,Parent Sales Person,Übergeordneter Vertriebsmitarbeiter
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100,The seller and the buyer cannot be the same,Der Verkäufer und der Käufer können nicht identisch sein
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Wählen Sie zuerst das Programm aus
-DocType: Patient Appointment,Patient Age,Patient Alter
-apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Projekte verwalten
-DocType: Supplier,Supplier of Goods or Services.,Lieferant von Waren oder Dienstleistungen.
-DocType: Budget,Fiscal Year,Geschäftsjahr
-DocType: Asset Maintenance Log,Planned,Geplant
-DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,"Default-Forderungskonten, die verwendet werden sollen, wenn sie nicht in Patient eingestellt sind, um Konsultationsgebühren zu buchen."
-DocType: Vehicle Log,Fuel Price,Kraftstoff-Preis
-DocType: Budget,Budget,Budget
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Set offen
-apps/erpnext/erpnext/stock/doctype/item/item.py +257,Fixed Asset Item must be a non-stock item.,Posten des Anlagevermögens muss ein Nichtlagerposition sein.
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budget kann {0} nicht zugewiesen werden, da es kein Ertrags- oder Aufwandskonto ist"
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Erreicht
-DocType: Student Admission,Application Form Route,Antragsformular Strecke
-apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Region / Kunde
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,"Urlaubstyp {0} kann nicht zugeordnet werden, da unbezahlter Urlaub."
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Zeile {0}: Zugeteilte Menge {1} muss kleiner als oder gleich dem ausstehenden Betrag in Rechnung {2} sein
-DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"""In Worten"" wird sichtbar, sobald Sie die Ausgangsrechnung speichern."
-DocType: Lead,Follow Up,Nachverfolgen
-DocType: Item,Is Sales Item,Ist Verkaufsartikel
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Artikelgruppenbaumstruktur
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Artikel {0} ist nicht für Seriennummern eingerichtet. Artikelstamm prüfen
-DocType: Maintenance Visit,Maintenance Time,Wartungszeit
-,Amount to Deliver,Liefermenge
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +334,Same item has been entered multiple times. {0},Gleiches Element wurde mehrfach eingegeben. {0}
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Der Begriff Startdatum kann nicht früher als das Jahr Anfang des Akademischen Jahres an dem der Begriff verknüpft ist (Akademisches Jahr {}). Bitte korrigieren Sie die Daten und versuchen Sie es erneut.
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190,There were errors.,Es sind Fehler aufgetreten.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +167,Employee {0} has already applied for {1} between {2} and {3} : ,Der Mitarbeiter {0} hat bereits einen Antrag auf {1} zwischen {2} und {3} gestellt:
-DocType: Guardian,Guardian Interests,Wächter Interessen
-DocType: Naming Series,Current Value,Aktueller Wert
-apps/erpnext/erpnext/controllers/accounts_controller.py +272,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Mehrere Geschäftsjahre existieren für das Datum {0}. Bitte setzen Unternehmen im Geschäftsjahr
-DocType: Education Settings,Instructor Records to be created by,Instructor Records werden erstellt von
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} erstellt
-DocType: GST Account,GST Account,GST Konto
-DocType: Delivery Note Item,Against Sales Order,Zu Kundenauftrag
-,Serial No Status,Seriennummern-Status
-DocType: Payment Entry Reference,Outstanding,Ausstehend
-DocType: Supplier,Warn POs,Warnen Sie POs
-,Daily Timesheet Summary,Tägliche Zeiterfassungsübersicht
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
-						must be greater than or equal to {2}","Zeile {0}: Um Periodizität {1} zu setzen, muss die Differenz aus Von-Datum und Bis-Datum größer oder gleich {2} sein"
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Dies basiert auf Lagerbewegungen. Siehe {0} für Details
-DocType: Pricing Rule,Selling,Vertrieb
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +385,Amount {0} {1} deducted against {2},Menge {0} {1} abgezogen gegen {2}
-DocType: Employee,Salary Information,Gehaltsinformationen
-DocType: Sales Person,Name and Employee ID,Name und Mitarbeiter-ID
-apps/erpnext/erpnext/accounts/party.py +309,Due Date cannot be before Posting Date,Fälligkeitsdatum kann nicht vor dem Buchungsdatum liegen
-DocType: Website Item Group,Website Item Group,Webseiten-Artikelgruppe
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +458,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Es wurde kein Lohnzettel für die oben ausgewählten Kriterien oder den bereits eingereichten Gehaltsbeleg gefunden
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Zölle und Steuern
-DocType: Projects Settings,Projects Settings,Projekteinstellungen
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Bitte den Stichtag eingeben
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} Zahlungsbuchungen können nicht nach {1} gefiltert werden
-DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabelle für Artikel, der auf der Webseite angezeigt wird"
-DocType: Purchase Order Item Supplied,Supplied Qty,Gelieferte Anzahl
-DocType: Purchase Order Item,Material Request Item,Materialanfrageartikel
-apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Artikelgruppenstruktur
-DocType: Production Plan,Total Produced Qty,Gesamtproduktionsmenge
-DocType: Payroll Entry,Get Employee Details,Erhalten Sie Mitarbeiterdetails
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,"Für diese Berechnungsart kann keine Zeilennummern zugeschrieben werden, die größer oder gleich der aktuellen Zeilennummer ist"
-DocType: Asset,Sold,Verkauft
-,Item-wise Purchase History,Artikelbezogene Einkaufshistorie
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Bitte auf ""Zeitplan generieren"" klicken, um die Seriennummer für Artikel {0} abzurufen"
-DocType: Account,Frozen,Gesperrt
-,Open Production Orders,Offene Fertigungsaufträge
-DocType: Sales Invoice Payment,Base Amount (Company Currency),Basisbetrag (Gesellschaft Währung)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Raw Materials,Rohes Material
-DocType: Payment Reconciliation Payment,Reference Row,Referenzreihe
-DocType: Installation Note,Installation Time,Installationszeit
-DocType: Sales Invoice,Accounting Details,Buchhaltungs-Details
-apps/erpnext/erpnext/setup/doctype/company/company.js +113,Delete all the Transactions for this Company,Löschen aller Transaktionen dieser Firma
-DocType: Patient,O Positive,0 +
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Zeile #{0}: Arbeitsgang {1} ist für {2} die Menge an Fertigerzeugnissen im Produktionsauftrag # {3} abgeschlossen. Bitte den Status des Arbeitsgangs über die Zeitprotokolle aktualisieren
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investitionen
-DocType: Issue,Resolution Details,Details zur Entscheidung
-apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Zuteilungen
-DocType: Item Quality Inspection Parameter,Acceptance Criteria,Akzeptanzkriterien
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Bitte geben Sie Materialwünsche in der obigen Tabelle
-DocType: Item Attribute,Attribute Name,Attributname
-DocType: BOM,Show In Website,Auf der Webseite anzeigen
-DocType: Shopping Cart Settings,Show Quantity in Website,Zeigen Menge in Webseite
-DocType: Employee Loan Application,Total Payable Amount,Zahlenden Gesamtbetrag
-DocType: Task,Expected Time (in hours),Voraussichtliche Zeit (in Stunden)
-DocType: Item Reorder,Check in (group),Check-in (Gruppe)
-DocType: Soil Texture,Silt,Schlick
-,Qty to Order,Zu bestellende Menge
-DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Der Kontenkopf unter Eigen- oder Fremdkapital, in dem Gewinn / Verlust verbucht wird"
-apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Gantt-Diagramm aller Aufgaben
-DocType: Opportunity,Mins to First Response,Minuten zum First Response
-DocType: Pricing Rule,Margin Type,Margenart
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} Stunden
-DocType: Course,Default Grading Scale,Standard-Bewertungsskala
-DocType: Appraisal,For Employee Name,Für Mitarbeiter-Name
-DocType: Holiday List,Clear Table,Tabelle leeren
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Verfügbare Steckplätze
-DocType: C-Form Invoice Detail,Invoice No,Rechnung Nr.
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Zahlung ausführen
-DocType: Room,Room Name,Raumname
-DocType: Prescription Duration,Prescription Duration,Verschreibungsdauer
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +82,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Da der Resturlaub bereits in den zukünftigen Datensatz für Urlaube {1} übertragen wurde, kann der Urlaub nicht vor {0} genehmigt/abgelehnt werden."
-DocType: Activity Cost,Costing Rate,Kalkulationsbetrag
-apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Kundenadressen und Ansprechpartner
-,Campaign Efficiency,Effizienz der Kampagne
-DocType: Discussion,Discussion,Diskussion
-DocType: Payment Entry,Transaction ID,Transaktions-ID
-DocType: Volunteer,Anytime,Jederzeit
-DocType: Patient,Surgical History,Chirurgische Geschichte
-DocType: Employee,Resignation Letter Date,Datum des Kündigungsschreibens
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Preisregeln werden zudem nach Menge angewandt.
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +131,Not Set,Nicht festgelegt
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +334,Please set the Date Of Joining for employee {0},Bitte setzen Sie das Datum des Beitritts für Mitarbeiter {0}
-DocType: Task,Total Billing Amount (via Time Sheet),Gesamtrechnungsbetrag (über Arbeitszeitblatt)
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Umsatz Bestandskunden
-DocType: Soil Texture,Silty Clay Loam,Siltiger Ton Lehm
-DocType: Chapter,Chapter,Kapitel
-apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Paar
-DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,"Das Standardkonto wird in POS-Rechnung automatisch aktualisiert, wenn dieser Modus ausgewählt ist."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +961,Select BOM and Qty for Production,Wählen Sie Stückliste und Menge für die Produktion
-DocType: Asset,Depreciation Schedule,Abschreibungsplan
-apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Vertriebspartner Adressen und Kontakte
-DocType: Bank Reconciliation Detail,Against Account,Gegenkonto
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Lieferant&gt; Lieferantentyp
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +53,Half Day Date should be between From Date and To Date,Halbtages Datum sollte zwischen Von-Datum und eine aktuelle
-DocType: Maintenance Schedule Detail,Actual Date,Tatsächliches Datum
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139,Please set the Default Cost Center in {0} company.,Legen Sie die Standardkostenstelle in der Firma {0} fest.
-DocType: Item,Has Batch No,Hat Chargennummer
-apps/erpnext/erpnext/public/js/utils.js +106,Annual Billing: {0},Jährliche Abrechnung: {0}
-apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Waren- und Dienstleistungssteuer (GST Indien)
-DocType: Delivery Note,Excise Page Number,Seitenzahl entfernen
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227,"Company, From Date and To Date is mandatory",Firma: ab Datum und bis Datum ist obligatorisch
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Holen Sie sich von der Beratung
-DocType: Asset,Purchase Date,Kaufdatum
-DocType: Volunteer,Volunteer Type,Freiwilliger Typ
-DocType: Student,Personal Details,Persönliche Daten
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Bitte setzen &#39;Asset-Abschreibungen Kostenstelle&#39; in Gesellschaft {0}
-,Maintenance Schedules,Wartungspläne
-DocType: Task,Actual End Date (via Time Sheet),Das tatsächliche Enddatum (durch Zeiterfassung)
-DocType: Soil Texture,Soil Type,Bodenart
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +380,Amount {0} {1} against {2} {3},Menge {0} {1} gegen {2} {3}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,New Message,Neue Nachricht
-,Quotation Trends,Trendanalyse Angebote
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160,Item Group not mentioned in item master for item {0},Artikelgruppe ist im Artikelstamm für Artikel {0} nicht erwähnt
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368,Debit To account must be a Receivable account,Sollkonto muss ein Forderungskonto sein
-DocType: Shipping Rule,Shipping Amount,Versandbetrag
-DocType: Supplier Scorecard Period,Period Score,Periodenspieler
-apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Kunden hinzufügen
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Ausstehender Betrag
-DocType: Lab Test Template,Special,Besondere
-DocType: Purchase Order Item Supplied,Conversion Factor,Umrechnungsfaktor
-DocType: Purchase Order,Delivered,Geliefert
-,Vehicle Expenses,Fahrzeugkosten
-DocType: Serial No,Invoice Details,Rechnungs-Details
-DocType: Grant Application,Show on Website,Auf der Website anzeigen
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,Expected value after useful life must be greater than or equal to {0},Erwartungswert nach Nutzungsdauer muss größer sein als oder gleich {0}
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Beginnen am
-DocType: Hub Category,Hub Category,Hub-Kategorie
-DocType: Purchase Invoice,SEZ,SEZ
-DocType: Purchase Receipt,Vehicle Number,Fahrzeugnummer
-DocType: Employee Loan,Loan Amount,Darlehensbetrag
-apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Briefkopf hinzufügen
-DocType: Program Enrollment,Self-Driving Vehicle,Selbstfahrendes Fahrzeug
-DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Supplier Scorecard Standing
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +442,Row {0}: Bill of Materials not found for the Item {1},Zeile {0}: Bill of Materials nicht für den Artikel gefunden {1}
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Die Gesamtmenge des beantragten Urlaubs {0} kann nicht kleiner sein als die bereits genehmigten Urlaube {1} für den Zeitraum
-DocType: Journal Entry,Accounts Receivable,Forderungen
-,Supplier-Wise Sales Analytics,Lieferantenbezogene Analyse der Verkäufe
-DocType: Purchase Invoice,Availed ITC Central Tax,Availed ITC Central Tax
-DocType: Salary Structure,Select employees for current Salary Structure,Ausgewählte Mitarbeiter für aktuelle Gehaltsstruktur
-DocType: Sales Invoice,Company Address Name,Firmenanschrift Name
-DocType: Production Order,Use Multi-Level BOM,Mehrstufige Stückliste verwenden
-DocType: Bank Reconciliation,Include Reconciled Entries,Abgeglichene Buchungen einbeziehen
-DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Elternkurs (Leer lassen, wenn dies nicht Teil des Elternkurses ist)"
-DocType: Leave Control Panel,Leave blank if considered for all employee types,"Freilassen, wenn für alle Mitarbeitertypen gültig"
-DocType: Landed Cost Voucher,Distribute Charges Based On,Kosten auf folgender Grundlage verteilen
-DocType: Projects Settings,Timesheets,Zeiterfassungen
-DocType: HR Settings,HR Settings,Einstellungen zum Modul Personalwesen
-DocType: Salary Slip,net pay info,Netto-Zahlung Info
-DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Dieser Wert wird in der Default Sales Price List aktualisiert.
-DocType: Email Digest,New Expenses,Neue Ausgaben
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79,PDC/LC Amount,PDC / LC-Menge
-DocType: Shareholder,Shareholder,Aktionär
-DocType: Purchase Invoice,Additional Discount Amount,Zusätzlicher Rabatt
-DocType: Cash Flow Mapper,Position,Position
-DocType: Patient,Patient Details,Patientendetails
-DocType: Patient,B Positive,B Positiv
-apps/erpnext/erpnext/controllers/accounts_controller.py +595,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Menge muss 1 sein, als Element eine Anlage ist. Bitte verwenden Sie separate Zeile für mehrere Menge."
-DocType: Leave Block List Allow,Leave Block List Allow,Urlaubssperrenliste zulassen
-apps/erpnext/erpnext/setup/doctype/company/company.py +317,Abbr can not be blank or space,"""Abbr"" kann nicht leer oder Space sein"
-DocType: Patient Medical Record,Patient Medical Record,Patient Medizinische Aufzeichnung
-apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Gruppe an konzernfremde
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Sport
-DocType: Loan Type,Loan Name,Darlehensname
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Summe Tatsächlich
-DocType: Lab Test UOM,Test UOM,Test UOM
-DocType: Student Siblings,Student Siblings,Studenten Geschwister
-apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Einheit
-apps/erpnext/erpnext/stock/get_item_details.py +138,Please specify Company,Bitte Firma angeben
-,Customer Acquisition and Loyalty,Kundengewinnung und -bindung
-DocType: Asset Maintenance Task,Maintenance Task,Wartungsaufgabe
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118,Please set B2C Limit in GST Settings.,Bitte setzen Sie B2C Limit in den GST Einstellungen.
-DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Lager, in dem zurückerhaltene Artikel aufbewahrt werden (Sperrlager)"
-DocType: Production Order,Skip Material Transfer,Materialübertragung überspringen
-apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Der Wechselkurs für {0} bis {1} für das Stichtag {2} kann nicht gefunden werden. Bitte erstellen Sie einen Exchange Exchange-Eintrag manuell
-DocType: POS Profile,Price List,Preisliste
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,"{0} ist jetzt das Standardgeschäftsjahr. Bitte aktualisieren Sie Ihren Browser, damit die Änderungen wirksam werden."
-apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Aufwandsabrechnungen
-DocType: Issue,Support,Support
-,BOM Search,Stücklisten-Suche
-DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Veröffentlichen Sie &quot;In Stock&quot; oder &quot;Nicht verfügbar&quot; auf Hub basierend auf dem in diesem Lager verfügbaren Bestand.
-DocType: Vehicle,Fuel Type,Treibstoffart
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Bitte die Firmenwährung angeben
-DocType: Workstation,Wages per hour,Lohn pro Stunde
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Lagerbestand in Charge {0} wird für Artikel {2} im Lager {3} negativ {1}
-apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Folgende Materialanfragen wurden automatisch auf der Grundlage der Nachbestellmenge des Artikels generiert
-DocType: Email Digest,Pending Sales Orders,Bis Kundenaufträge
-apps/erpnext/erpnext/controllers/accounts_controller.py +311,Account {0} is invalid. Account Currency must be {1},Konto {0} ist ungültig. Kontenwährung muss {1} sein
-DocType: Healthcare Settings,Remind Before,Vorher erinnern
-apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Maßeinheit-Umrechnungsfaktor ist erforderlich in der Zeile {0}
-DocType: Production Plan Item,material_request_item,material_request_item
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Referenzdokumenttyp muss eine der Kundenauftrag, Verkaufsrechnung oder einen Journaleintrag sein"
-DocType: Salary Component,Deduction,Abzug
-DocType: Item,Retain Sample,Probe aufbewahren
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Row {0}: Von Zeit und zu Zeit ist obligatorisch.
-DocType: Stock Reconciliation Item,Amount Difference,Mengendifferenz
-apps/erpnext/erpnext/stock/get_item_details.py +356,Item Price added for {0} in Price List {1},Artikel Preis hinzugefügt für {0} in Preisliste {1}
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Bitte die Mitarbeiter-ID dieses Vertriebsmitarbeiters angeben
-DocType: Territory,Classification of Customers by region,Einteilung der Kunden nach Region
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,In Produktion
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +60,Difference Amount must be zero,Differenzbetrag muss Null sein
-DocType: Project,Gross Margin,Handelsspanne
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,Please enter Production Item first,Bitte zuerst Herstellungsartikel eingeben
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Berechneter Stand des Bankauszugs
-DocType: Normal Test Template,Normal Test Template,Normale Testvorlage
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,deaktivierter Benutzer
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919,Quotation,Angebot
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984,Cannot set a received RFQ to No Quote,"Kann einen empfangenen RFQ nicht auf ""kein Zitat"" setzen."
-DocType: Quotation,QTN-,ANG-
-DocType: Salary Slip,Total Deduction,Gesamtabzug
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18,Select an account to print in account currency,"Wählen Sie ein Konto aus, das in der Kontowährung gedruckt werden soll"
-,Production Analytics,Produktions-Analysen
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Dies beruht auf Transaktionen gegen diesen Patienten. Siehe Zeitleiste unten für Details
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +203,Cost Updated,Kosten aktualisiert
-DocType: Patient,Date of Birth,Geburtsdatum
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Artikel {0} wurde bereits zurück gegeben
-DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,"""Geschäftsjahr"" steht für ein Finazgeschäftsjahr. Alle Buchungen und anderen größeren Transaktionen werden mit dem ""Geschäftsjahr"" verglichen."
-DocType: Opportunity,Customer / Lead Address,Kunden- / Lead-Adresse
-DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Supplier Scorecard Setup
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Name des Bewertungsplans
-apps/erpnext/erpnext/stock/doctype/item/item.py +232,Warning: Invalid SSL certificate on attachment {0},Warnung: Ungültiges SSL-Zertifikat für Anlage {0}
-apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Leads helfen bei der Kundengewinnung, fügen Sie alle Ihre Kontakte und mehr als Ihre Leads hinzu"
-DocType: Production Order Operation,Actual Operation Time,Tatsächliche Betriebszeit
-DocType: Authorization Rule,Applicable To (User),Anwenden auf (Benutzer)
-DocType: Purchase Taxes and Charges,Deduct,Abziehen
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Job Description,Tätigkeitsbeschreibung
-DocType: Student Applicant,Applied,angewandt
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Re-open,Wiedereröffnen
-DocType: Sales Invoice Item,Qty as per Stock UOM,Menge in Lagermaßeinheit
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Namen
-DocType: Purchase Invoice,02-Post Sale Discount,02-Post Sale Rabatt
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Sonderzeichen außer ""-"", ""#"", ""."" und ""/"" sind in der Serienbezeichnung nicht erlaubt"
-DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Verkaufskampagne verfolgen: Leads, Angebote, Kundenaufträge usw. von Kampagnen beobachten um die Kapitalverzinsung (RoI) zu messen."
-,SO Qty,Kd.-Auftr.-Menge
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91,The field To Shareholder cannot be blank,Das Feld An Aktionär darf nicht leer sein
-DocType: Guardian,Work Address,Arbeitsadresse
-DocType: Appraisal,Calculate Total Score,Gesamtwertung berechnen
-DocType: Asset Repair,Manufacturing Manager,Fertigungsleiter
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Seriennummer {0} ist innerhalb der Garantie bis {1}
-DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimal zulässiger Wert
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,Der Benutzer {0} existiert bereits
-apps/erpnext/erpnext/hooks.py +109,Shipments,Lieferungen
-DocType: Payment Entry,Total Allocated Amount (Company Currency),Aufteilbaren Gesamtbetrag (Gesellschaft Währung)
-DocType: Purchase Order Item,To be delivered to customer,Zur Auslieferung an den Kunden
-DocType: BOM,Scrap Material Cost,Ausschusssmaterialkosten
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,Seriennummer {0} gehört zu keinem Lager
-DocType: Grant Application,Email Notification Sent,E-Mail-Benachrichtigung gesendet
-DocType: Purchase Invoice,In Words (Company Currency),In Worten (Firmenwährung)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1009,"Item Code, warehouse, quantity are required on row","Artikelnummer, Lager, Menge sind in der Zeile erforderlich"
-DocType: Pricing Rule,Supplier,Lieferant
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Zahlungsdetails anzeigen
-DocType: Consultation,Consultation Time,Konsultationszeit
-DocType: C-Form,Quarter,Quartal
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Sonstige Aufwendungen
-DocType: Global Defaults,Default Company,Standardfirma
-apps/erpnext/erpnext/controllers/stock_controller.py +227,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 auf den gesamten Lagerwert hat"
-DocType: Payment Request,PR,PR
-DocType: Cheque Print Template,Bank Name,Name der Bank
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,-Über
-DocType: Employee Loan,Employee Loan Account,Mitarbeiterdarlehenskonto
-DocType: Leave Application,Total Leave Days,Urlaubstage insgesamt
-DocType: Email Digest,Note: Email will not be sent to disabled users,Hinweis: E-Mail wird nicht an gesperrte Nutzer gesendet
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Anzahl der Interaktion
-apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Einstellungen zur Artikelvariante
-apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Firma auswählen...
-DocType: Leave Control Panel,Leave blank if considered for all departments,"Freilassen, wenn für alle Abteilungen gültig"
-apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Art der Beschäftigung (Unbefristeter Vertrag, befristeter Vertrag, Praktikum etc.)"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,{0} is mandatory for Item {1},{0} Artikel ist zwingend erfoderlich für {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"Item {0}: {1} qty produced, ","Artikel {0}: {1} Menge produziert,"
-DocType: Payroll Entry,Fortnightly,vierzehntägig
-DocType: Currency Exchange,From Currency,Von Währung
-DocType: Vital Signs,Weight (In Kilogram),Gewicht (in Kilogramm)
-DocType: Chapter,"chapters/chapter_name
-leave blank automatically set after saving chapter.",chapters / chapter_name lassen das Feld nach dem Speichern des Kapitels automatisch leer.
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Please set GST Accounts in GST Settings,Bitte legen Sie die GST-Konten in den GST-Einstellungen fest
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31,Type of Business,Geschäftsart
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Bitte zugewiesenen Betrag, Rechnungsart und Rechnungsnummer in mindestens einer Zeile auswählen"
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Kosten eines neuen Kaufs
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35,All tasks for the detected diseases were imported,Alle Aufgaben für die erkannten Krankheiten wurden importiert
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Kundenauftrag für den Artikel {0} erforderlich
-DocType: Grant Application,Grant Description,Gewähren Beschreibung
-DocType: Purchase Invoice Item,Rate (Company Currency),Preis (Firmenwährung)
-DocType: Student Guardian,Others,Andere
-DocType: Payment Entry,Unallocated Amount,Nicht zugewiesene Betrag
-apps/erpnext/erpnext/templates/includes/product_page.js +90,Cannot find a matching Item. Please select some other value for {0}.,Ein passender Artikel kann nicht gefunden werden. Bitte einen anderen Wert für {0} auswählen.
-DocType: POS Profile,Taxes and Charges,Steuern und Gebühren
-DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produkt oder Dienstleistung, die gekauft, verkauft oder auf Lager gehalten wird."
-apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Keine Updates mehr
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Die Berechnungsart kann für die erste Zeile nicht auf ""bezogen auf Menge der vorhergenden Zeile"" oder auf ""bezogen auf Gesamtmenge der vorhergenden Zeile"" gesetzt werden"
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Dies deckt alle mit diesem Setup verbundenen Scorecards ab
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Unterartikel sollte nicht ein Produkt-Bundle sein. Bitte Artikel `{0}` entfernen und speichern.
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Bankwesen
-apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Zeiterfassung hinzufügen
-DocType: Vehicle Service,Service Item,Serviceposition
-DocType: Bank Guarantee,Bank Guarantee,Bankgarantie
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,"Bitte auf ""Zeitplan generieren"" klicken, um den Zeitplan zu erhalten"
-DocType: Bin,Ordered Quantity,Bestellte Menge
-apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","z. B. ""Fertigungs-Werkzeuge für Hersteller"""
-DocType: Grading Scale,Grading Scale Intervals,Notenskala Intervalle
-apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Jahresüberschuss
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Konteneintrag für {2} kann nur in folgender Währung vorgenommen werden: {3}
-DocType: Fee Schedule,In Process,Während des Fertigungsprozesses
-DocType: Authorization Rule,Itemwise Discount,Artikelbezogener Rabatt
-apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Baum der Finanzbuchhaltung.
-DocType: Cash Flow Mapping,Cash Flow Mapping,Cashflow-Mapping
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} zu Kundenauftrag{1}
-DocType: Account,Fixed Asset,Anlagevermögen
-apps/erpnext/erpnext/config/stock.py +324,Serialized Inventory,Serialisierter Lagerbestand
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,E-Mail nicht im Standardkontakt gefunden
-DocType: Employee Loan,Account Info,Kontoinformation
-DocType: Activity Type,Default Billing Rate,Standard-Rechnungspreis
-DocType: Fees,Include Payment,Zahlung einschließen
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Schülergruppen erstellt.
-DocType: Sales Invoice,Total Billing Amount,Gesamtrechnungsbetrag
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Das Programm in der Gebührenstruktur und die Studentengruppe {0} unterscheiden sich.
-DocType: Fee Schedule,Receivable Account,Forderungskonto
-apps/erpnext/erpnext/controllers/accounts_controller.py +617,Row #{0}: Asset {1} is already {2},Row # {0}: Vermögens {1} ist bereits {2}
-DocType: Quotation Item,Stock Balance,Lagerbestand
-apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Vom Kundenauftrag zum Zahlungseinang
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,CEO
-DocType: Purchase Invoice,With Payment of Tax,Mit Zahlung der Steuer
-DocType: Expense Claim Detail,Expense Claim Detail,Aufwandsabrechnungsdetail
-DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICATE FÜR LIEFERANTEN
-DocType: Land Unit,Is Container,Ist ein Container
-DocType: Crop Cycle,This will be day 1 of the crop cycle,Dies ist Tag 1 des Erntezyklus
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871,Please select correct account,Bitte richtiges Konto auswählen
-DocType: Purchase Invoice Item,Weight UOM,Gewichts-Maßeinheit
-apps/erpnext/erpnext/config/accounts.py +466,List of available Shareholders with folio numbers,Liste der verfügbaren Aktionäre mit Folio-Nummern
-DocType: Salary Structure Employee,Salary Structure Employee,Gehaltsstruktur Mitarbeiter
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Zeige Variantenattribute
-DocType: Student,Blood Group,Blutgruppe
-DocType: Course,Course Name,Kursname
-DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Benutzer, die die Urlaubsanträge eines bestimmten Mitarbeiters genehmigen können"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Büroausstattung
-DocType: Purchase Invoice Item,Qty,Menge
-DocType: Fiscal Year,Companies,Firmen
-DocType: Supplier Scorecard,Scoring Setup,Scoring Setup
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronik
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326,Debit ({0}),Soll ({0})
-DocType: Stock Settings,Raise Material Request when stock reaches re-order level,"Materialanfrage erstellen, wenn der Lagerbestand unter einen Wert sinkt"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Vollzeit
-DocType: Payroll Entry,Employees,Mitarbeiter
-DocType: Employee,Contact Details,Kontakt-Details
-DocType: C-Form,Received Date,Empfangsdatum
-DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Wenn eine Standardvorlage unter den Vorlagen ""Steuern und Abgaben beim Verkauf"" erstellt wurde, bitte eine Vorlage auswählen und auf die Schaltfläche unten klicken."
-DocType: BOM Scrap Item,Basic Amount (Company Currency),Grundbetrag (Gesellschaft Währung)
-DocType: Student,Guardians,Wächter
-DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Die Preise werden nicht angezeigt, wenn Preisliste nicht gesetzt"
-DocType: Stock Entry,Total Incoming Value,Summe der Einnahmen
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To is required,Debit Um erforderlich
-apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Zeiterfassungen helfen den Überblick über Zeit, Kosten und Abrechnung für Aktivitäten von Ihrem Team getan"
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Einkaufspreisliste
-apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Vorlagen der Lieferanten-Scorecard-Variablen.
-DocType: Job Offer Term,Offer Term,Angebotsfrist
-DocType: Asset,Quality Manager,Qualitätsmanager
-DocType: Job Applicant,Job Opening,Offene Stellen
-DocType: Payment Reconciliation,Payment Reconciliation,Zahlungsabgleich
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Bitte den Namen der verantwortlichen Person auswählen
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Technologie
-DocType: Hub Settings,Unregister from Hub,Heben Sie die Registrierung von Hub auf
-apps/erpnext/erpnext/public/js/utils.js +108,Total Unpaid: {0},Noch nicht bezahlt: {0}
-DocType: BOM Website Operation,BOM Website Operation,BOM Webseite Vorgang
-apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Materialanfragen (MAF) und Fertigungsaufträge generieren
-DocType: Supplier Scorecard,Supplier Score,Lieferantenbewertung
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +208,Total Invoiced Amt,Gesamtrechnungsbetrag
-DocType: Supplier,Warn RFQs,Warnung Ausschreibungen
-DocType: BOM,Conversion Rate,Wechselkurs
-apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Produkt Suche
-DocType: Assessment Plan,To Time,Bis-Zeit
-DocType: Authorization Rule,Approving Role (above authorized value),Genehmigende Rolle (über dem autorisierten Wert)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Habenkonto muss ein Verbindlichkeitenkonto sein
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,"Bitte wählen Sie den Studenteneintritt aus, der für den bezahlten Studenten obligatorisch ist"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +348,BOM recursion: {0} cannot be parent or child of {2},Stücklisten-Rekursion: {0} kann nicht übergeordnetes Element oder Unterpunkt von {2} sein
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21,Please select a Price List to publish pricing,"Bitte wählen Sie eine Preisliste aus, um Preise zu veröffentlichen"
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Budgetliste
-DocType: Production Order Operation,Completed Qty,Gefertigte Menge
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry",Für {0} können nur Sollkonten mit einer weiteren Habenbuchung verknüpft werden
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Preisliste {0} ist deaktiviert
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Row {0}: Abgeschlossene Menge kann nicht mehr sein als {1} für den Betrieb {2}
-DocType: Manufacturing Settings,Allow Overtime,Überstunden zulassen
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry",Serialized Item {0} kann nicht mit der Bestandsabstimmung aktualisiert werden. Bitte verwenden Sie den Stock Entry
-DocType: Training Event Employee,Training Event Employee,Schulungsveranstaltung Mitarbeiter
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1017,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximum Samples - {0} kann für Batch {1} und Item {2} beibehalten werden.
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Zeitfenster hinzufügen
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Seriennummern für Artikel {1} erforderlich. Sie haben {2} zur Verfügung gestellt.
-DocType: Stock Reconciliation Item,Current Valuation Rate,Aktueller Wertansatz
-DocType: Item,Customer Item Codes,Kundenartikelnummern
-DocType: Training Event,Advance,Vorschuss
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,um wiederkehrend zu sein.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Exchange-Gewinn / Verlust
-DocType: Opportunity,Lost Reason,Verlustgrund
-apps/erpnext/erpnext/controllers/accounts_controller.py +264,Row #{0}: Account {1} does not belong to company {2},Zeile # {0}: Konto {1} gehört nicht zur Firma {2}
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Kann DocType {0} nicht finden
-apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Neue Adresse
-DocType: Quality Inspection,Sample Size,Stichprobenumfang
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Bitte geben Sie Eingangsbeleg
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Alle Artikel sind bereits abgerechnet
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',"Bitte eine eine gültige ""Von Fall Nr."" angeben"
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,"Weitere Kostenstellen können unter Gruppen angelegt werden, aber Buchungen können zu nicht-Gruppen erstellt werden"
-apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Benutzer und Berechtigungen
-DocType: Vehicle Log,VLOG.,VLOG.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +996,Production Orders Created: {0},Fertigungsaufträge Erstellt: {0}
-DocType: Branch,Branch,Filiale
-DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
-DocType: Delivery Trip,Fulfillment User,Benutzungsbenutzer
-apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Druck und Branding
-DocType: Company,Total Monthly Sales,Gesamtmonatsumsatz
-DocType: Agriculture Analysis Criteria,Weather,Wetter
-DocType: Bin,Actual Quantity,Tatsächlicher Bestand
-DocType: Shipping Rule,example: Next Day Shipping,Beispiel: Versand am nächsten Tag
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Seriennummer {0} wurde nicht gefunden
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291,Subscription has been {0},Abonnement wurde {0}
-DocType: Fee Schedule Program,Fee Schedule Program,Fee Zeitplan Programm
-DocType: Fee Schedule Program,Student Batch,Student Batch
-apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Schüler anlegen
-DocType: Supplier Scorecard Scoring Standing,Min Grade,Min
-apps/erpnext/erpnext/projects/doctype/project/project.py +216,You have been invited to collaborate on the project: {0},Sie wurden zur Zusammenarbeit für das Projekt {0} eingeladen.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +135,Physician not available on {0},Arzt nicht verfügbar auf {0}
-DocType: Leave Block List Date,Block Date,Datum sperren
-DocType: Crop,Crop,Ernte
-DocType: Purchase Receipt,Supplier Delivery Note,Lieferumfang
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Jetzt bewerben
-apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Tatsächliche Menge {0} / Wartezeit {1}
-DocType: Purchase Invoice,E-commerce GSTIN,E-Commerce GSTIN
-DocType: Sales Order,Not Delivered,Nicht geliefert
-,Bank Clearance Summary,Zusammenfassung Bankabwicklungen
-apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Tägliche, wöchentliche und monatliche E-Mail-Berichte erstellen und verwalten"
-DocType: Appraisal Goal,Appraisal Goal,Bewertungsziel
-DocType: Stock Reconciliation Item,Current Amount,Aktuelle Höhe
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,Gebäude
-DocType: Fee Schedule,Fee Structure,Gebührenstruktur
-DocType: Timesheet Detail,Costing Amount,Kalkulationsbetrag
-DocType: Student Admission Program,Application Fee,Anmeldegebühr
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52,Submit Salary Slip,Gehaltsabrechnung übertragen
-apps/erpnext/erpnext/controllers/selling_controller.py +136,Maxiumm discount for Item {0} is {1}%,Maximaler Rabatt für Artikel {0} beträgt {1}%
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Mengenimport
-DocType: Sales Partner,Address & Contacts,Adresse & Kontaktinformationen
-DocType: SMS Log,Sender Name,Absendername
-DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Landwirtschaft Analysekriterien
-DocType: POS Profile,[Select],[Select]
-DocType: Vital Signs,Blood Pressure (diastolic),Blutdruck (diastolisch)
-DocType: SMS Log,Sent To,Gesendet An
-DocType: Agriculture Task,Holiday Management,Ferienmanagement
-DocType: Payment Request,Make Sales Invoice,Verkaufsrechnung erstellen
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,Software
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,Nächste Kontakt Datum kann nicht in der Vergangenheit liegen
-DocType: Company,For Reference Only.,Nur zu Referenzzwecken.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Arzt {0} nicht verfügbar auf {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2565,Select Batch No,Wählen Sie Batch No
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61,Invalid {0}: {1},Ungültige(r/s) {0}: {1}
-,GSTR-1,GSTR-1
-DocType: Purchase Invoice,PINV-RET-,PINV-Ret
-DocType: Fee Validity,Reference Inv,Referenz ERE
-DocType: Sales Invoice Advance,Advance Amount,Anzahlungsbetrag
-DocType: Manufacturing Settings,Capacity Planning,Kapazitätsplanung
-DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Abrundung (Firmenwährung
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,"""Von-Datum"" ist erforderlich"
-DocType: Journal Entry,Reference Number,Referenznummer
-DocType: Employee,Employment Details,Beschäftigungsdetails
-DocType: Employee,New Workplace,Neuer Arbeitsplatz
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,"Als ""abgeschlossen"" markieren"
-apps/erpnext/erpnext/stock/get_item_details.py +127,No Item with Barcode {0},Kein Artikel mit Barcode {0}
-DocType: Normal Test Items,Require Result Value,Erforderlichen Ergebniswert
-DocType: Item,Show a slideshow at the top of the page,Diaschau oben auf der Seite anzeigen
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +527,Boms,Stücklisten
-apps/erpnext/erpnext/stock/doctype/item/item.py +161,Stores,Lagerräume
-DocType: Project Type,Projects Manager,Projektleiter
-DocType: Serial No,Delivery Time,Zeitpunkt der Lieferung
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Alter basierend auf
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +66,Appointment cancelled,Termin abgesagt
-DocType: Item,End of Life,Ende der Lebensdauer
-apps/erpnext/erpnext/demo/setup/setup_data.py +331,Travel,Reise
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +182,No active or default Salary Structure found for employee {0} for the given dates,Keine aktive oder Standard-Gehaltsstruktur für Mitarbeiter gefunden {0} für die angegebenen Daten
-DocType: Leave Block List,Allow Users,Benutzer zulassen
-DocType: Purchase Order,Customer Mobile No,Mobilnummer des Kunden
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Wiederkehrend
-DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Details zur Cashflow-Mapping-Vorlage
-DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Einnahmen und Ausgaben für Produktbereiche oder Abteilungen separat verfolgen.
-DocType: Rename Tool,Rename Tool,Werkzeug zum Umbenennen
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Kosten aktualisieren
-DocType: Item Reorder,Item Reorder,Artikelnachbestellung
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Anzeigen Gehaltsabrechnung
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849,Transfer Material,Material übergeben
-DocType: Fees,Send Payment Request,Zahlungsauftrag senden
-DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.",Arbeitsgänge und Betriebskosten angeben und eine eindeutige Arbeitsgang-Nr. für diesen Arbeitsgang angeben.
-DocType: Water Analysis,Origin,Ursprung
-apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Dieses Dokument ist über dem Limit von {0} {1} für item {4}. Machen Sie eine andere {3} gegen die gleiche {2}?
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1154,Please set recurring after saving,Bitte setzen Sie wiederkehrende nach dem Speichern
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769,Select change amount account,Wählen Sie Änderungsbetrag Konto
-DocType: Purchase Invoice,Price List Currency,Preislistenwährung
-DocType: Naming Series,User must always select,Benutzer muss immer auswählen
-DocType: Stock Settings,Allow Negative Stock,Negativen Lagerbestand zulassen
-DocType: Installation Note,Installation Note,Installationshinweis
-DocType: Soil Texture,Clay,Lehm
-DocType: Topic,Topic,Thema
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45,Cash Flow from Financing,Cashflow aus Finanzierung
-DocType: Budget Account,Budget Account,Budget Konto
-DocType: Quality Inspection,Verified By,Geprüft durch
-apps/erpnext/erpnext/setup/doctype/company/company.py +78,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Die Standardwährung der Firma kann nicht geändern werden, weil es bestehende Transaktionen gibt. Transaktionen müssen abgebrochen werden, um die Standardwährung zu ändern."
-DocType: Cash Flow Mapping,Is Income Tax Liability,Ist Einkommensteuerpflicht
-DocType: Grading Scale Interval,Grade Description,Grade Beschreibung
-DocType: Stock Entry,Purchase Receipt No,Kaufbeleg Nr.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Anzahlung
-DocType: Sales Invoice, Shipping Bill Number,Versandscheinnummer
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Rückverfolgbarkeit
-DocType: Asset Maintenance Log,Actions performed,Aktionen ausgeführt
-DocType: Cash Flow Mapper,Section Leader,Abteilungsleiter
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Mittelherkunft (Verbindlichkeiten)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Menge in Zeile {0} ({1}) muss die gleiche sein wie die hergestellte Menge {2}
-DocType: Supplier Scorecard Scoring Standing,Employee,Mitarbeiter
-DocType: Asset Repair,Failure Date,Fehlerdatum
-DocType: Sample Collection,Collected Time,Gesammelte Zeit
-DocType: Company,Sales Monthly History,Verkäufe Monatliche Geschichte
-DocType: Asset Maintenance Task,Next Due Date,Nächstes Fälligkeitsdatum
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Wählen Sie Batch
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} wird voll in Rechnung gestellt
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +47,Vital Signs,Vitalfunktionen
-DocType: Training Event,End Time,Endzeit
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Aktive Gehaltsstruktur {0} für diesen Mitarbeiter gefunden {1} mit den folgenden Daten
-DocType: Payment Entry,Payment Deductions or Loss,Zahlung Abzüge oder Verlust
-DocType: Soil Analysis,Soil Analysis Criterias,Kriterien für die Bodenanalyse
-apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Allgemeine Vertragsbedingungen für den Verkauf und Einkauf
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Gruppieren nach Beleg
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,"Sind Sie sicher, dass Sie diesen Termin stornieren möchten?"
-DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Preisangebot für das Hotelzimmer
-apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Vertriebspipeline
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Bitte setzen Sie Standardkonto in Gehaltskomponente {0}
-apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Benötigt am
-DocType: Rename Tool,File to Rename,"Datei, die umbenannt werden soll"
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Bitte wählen Sie Stückliste für Artikel in Zeile {0}
-apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Konto {0} stimmt nicht mit der Firma {1} im Rechnungsmodus überein: {2}
-apps/erpnext/erpnext/controllers/buying_controller.py +289,Specified BOM {0} does not exist for Item {1},Angegebene Stückliste {0} gibt es nicht für Artikel {1}
-DocType: Soil Texture,Sandy Loam,Sandiger Lehm
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Wartungsplan {0} muss vor Stornierung dieses Kundenauftrages aufgehoben werden
-DocType: POS Profile,Applicable for Users,Anwendbar für Benutzer
-DocType: Notification Control,Expense Claim Approved,Aufwandsabrechnung genehmigt
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +320,Salary Slip of employee {0} already created for this period,Gehaltsabrechnung der Mitarbeiter {0} für diesen Zeitraum bereits erstellt
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Arzneimittel
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Aufwendungen für bezogene Artikel
-DocType: Selling Settings,Sales Order Required,Kundenauftrag erforderlich
-DocType: Purchase Invoice,Credit To,Gutschreiben auf
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceDate,Stückdatum
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Aktive Leads / Kunden
-DocType: Employee Education,Post Graduate,Graduation veröffentlichen
-DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Wartungsplandetail
-DocType: Supplier Scorecard,Warn for new Purchase Orders,Warnung für neue Bestellungen
-DocType: Quality Inspection Reading,Reading 9,Ablesewert 9
-DocType: Supplier,Is Frozen,Ist gesperrt
-apps/erpnext/erpnext/stock/utils.py +224,Group node warehouse is not allowed to select for transactions,Gruppenknoten Lager ist nicht für Transaktionen zu wählen erlaubt
-DocType: Buying Settings,Buying Settings,Einkaufs-Einstellungen
-DocType: Stock Entry Detail,BOM No. for a Finished Good Item,Stücklisten-Nr. für einen fertigen Artikel
-DocType: Upload Attendance,Attendance To Date,Anwesenheit bis Datum
-DocType: Request for Quotation Supplier,No Quote,Kein Zitat
-DocType: Warranty Claim,Raised By,Gemeldet durch
-DocType: Payment Gateway Account,Payment Account,Zahlungskonto
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909,Please specify Company to proceed,Bitte Firma angeben um fortzufahren
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27,Net Change in Accounts Receivable,Nettoveränderung der Forderungen
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Ausgleich für
-DocType: Job Offer,Accepted,Genehmigt
-DocType: Grant Application,Organization,Firma
-DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
-DocType: SG Creation Tool Course,Student Group Name,Schülergruppenname
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Explosionsansicht anzeigen
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Gebühren anlegen
-apps/erpnext/erpnext/setup/doctype/company/company.js +91,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Bitte sicher stellen, dass wirklich alle Transaktionen für diese Firma gelöscht werden sollen. Die Stammdaten bleiben bestehen. Diese Aktion kann nicht rückgängig gemacht werden."
-apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Suchergebnisse
-DocType: Room,Room Number,Zimmernummer
-apps/erpnext/erpnext/utilities/transaction_base.py +103,Invalid reference {0} {1},Ungültige Referenz {0} {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) kann nicht größer sein als die geplante Menge ({2}) im Fertigungsauftrag {3}
-DocType: Shipping Rule,Shipping Rule Label,Bezeichnung der Versandregel
-DocType: Journal Entry Account,Payroll Entry,Personalabrechnung
-apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Steuervorlage erstellen
-apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Benutzer-Forum
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +318,Raw Materials cannot be blank.,Rohmaterial kann nicht leer sein
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498,"Could not update stock, invoice contains drop shipping item.","Lager konnte nicht aktualisiert werden, Rechnung enthält Direktversand-Artikel."
-DocType: Lab Test Sample,Lab Test Sample,Labortestprobe
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491,Quick Journal Entry,Schnellbuchung
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,"Sie können den Preis nicht ändern, wenn eine Stückliste für einen Artikel aufgeführt ist"
-DocType: Restaurant,Invoice Series Prefix,Rechnungsserie Präfix
-DocType: Employee,Previous Work Experience,Vorherige Berufserfahrung
-DocType: Stock Entry,For Quantity,Für Menge
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Bitte die geplante Menge für Artikel {0} in Zeile {1} eingeben
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93,Google Maps integration is not enabled,Die Google Maps-Integration ist nicht aktiviert
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} wurde nicht übertragen
-DocType: Member,Membership Expiry Date,Ablaufdatum der Mitgliedschaft
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} muss im Retourenschein negativ sein
-,Minutes to First Response for Issues,Minutes to First Response für Probleme
-DocType: Purchase Invoice,Terms and Conditions1,Allgemeine Geschäftsbedingungen1
-apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,"Der Name des Instituts, für die Sie setzen dieses System."
-DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.",Buchung wurde bis zu folgendem Zeitpunkt gesperrt. Bearbeiten oder ändern kann nur die Person in unten stehender Rolle.
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Bitte das Dokument vor dem Erstellen eines Wartungsplans abspeichern
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Aktueller Preis in allen Stücklisten aktualisiert
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Projektstatus
-DocType: UOM,Check this to disallow fractions. (for Nos),"Hier aktivieren, um keine Bruchteile zuzulassen (für Nr.)"
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +446,The following Production Orders were created:,Die folgenden Fertigungsaufträge wurden erstellt:
-DocType: Student Admission Program,Naming Series (for Student Applicant),Namens Series (für Studienbewerber)
-DocType: Delivery Note,Transporter Name,Name des Transportunternehmers
-DocType: Authorization Rule,Authorized Value,Autorisierter Wert
-DocType: BOM,Show Operations,zeigen Operationen
-,Minutes to First Response for Opportunity,Minuten bis zur ersten Antwort auf Opportunität
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Summe Abwesenheit
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +848,Item or Warehouse for row {0} does not match Material Request,Artikel oder Lager in Zeile {0} stimmen nicht mit Materialanfrage überein
-apps/erpnext/erpnext/config/stock.py +191,Unit of Measure,Maßeinheit
-DocType: Fiscal Year,Year End Date,Enddatum des Geschäftsjahres
-DocType: Task Depends On,Task Depends On,Vorgang hängt ab von
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026,Opportunity,Chance
-,Completed Production Orders,Abgeschlossene Fertigungsaufträge
-DocType: Operation,Default Workstation,Standard-Arbeitsplatz
-DocType: Notification Control,Expense Claim Approved Message,Benachrichtigung über genehmigte Aufwandsabrechnung
-DocType: Payment Entry,Deductions or Loss,Abzüge oder Verlust
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} ist geschlossen
-DocType: Email Digest,How frequently?,Wie häufig?
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Gesammelt gesammelt: {0}
-DocType: Purchase Receipt,Get Current Stock,Aktuellen Lagerbestand aufrufen
-DocType: Purchase Invoice,ineligible,nicht förderfähig
-apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Stücklistenstruktur
-DocType: Student,Joining Date,Beitrittsdatum
-,Employees working on a holiday,Die Mitarbeiter an einem Feiertag arbeiten
-DocType: Share Balance,Current State,Aktuellen Zustand
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Anwesend setzen
-DocType: Share Transfer,From Shareholder,Vom Aktionär
-DocType: Project,% Complete Method,% abgeschlossene Methode
-apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Droge
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Startdatum der Wartung kann nicht vor dem Liefertermin für Seriennummer {0} liegen
-DocType: Production Order,Actual End Date,Tatsächliches Enddatum
-DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Ist Finanzkostenanpassung
-DocType: BOM,Operating Cost (Company Currency),Betriebskosten (Gesellschaft Währung)
-DocType: Purchase Invoice,PINV-,PINV-
-DocType: Authorization Rule,Applicable To (Role),Anwenden auf (Rolle)
-DocType: BOM Update Tool,Replace BOM,Erstelle Stückliste
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Code {0} existiert bereits
-DocType: Employee Advance,Purpose,Zweck
-DocType: Company,Fixed Asset Depreciation Settings,Einstellungen Abschreibungen auf Sachanlagen
-DocType: Item,Will also apply for variants unless overrridden,"Gilt auch für Varianten, sofern nicht außer Kraft gesetzt"
-DocType: Purchase Invoice,Advances,Anzahlungen
-DocType: Production Order,Manufacture against Material Request,"Herstellen, gegen Material anfordern"
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Assessment Group: ,Beurteilungsgruppe:
-DocType: Item Reorder,Request for,Anfrage für
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,"Genehmigender Benutzer kann nicht derselbe Benutzer sein wie derjenige, auf den die Regel anzuwenden ist"
-DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Grundbetrag (nach Lagermaßeinheit)
-DocType: SMS Log,No of Requested SMS,Anzahl angeforderter SMS
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Unbezahlter Urlaub passt nicht zu den bestätigten Urlaubsanträgen.
-DocType: Campaign,Campaign-.####,Kampagne-.####
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Nächste Schritte
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796,Please supply the specified items at the best possible rates,Bitte geben Sie die angegebenen Elemente zu den bestmöglichen Preisen
-DocType: Membership,USD,US Dollar
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Rechnung erstellen
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80,Remaining Balance,Die verbleibende Summe
-DocType: Selling Settings,Auto close Opportunity after 15 days,Auto schließen Gelegenheit nach 15 Tagen
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Kaufaufträge sind für {0} wegen einer Scorecard von {1} nicht erlaubt.
-apps/erpnext/erpnext/stock/doctype/item/item.py +497,Barcode {0} is not a valid {1} code,Der Barcode {0} ist kein gültiger {1} Code
-apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,Ende Jahr
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Lead%
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Vertragsende muss weiter in der Zukunft liegen als Eintrittsdatum sein
-DocType: Driver,Driver,Treiber
-DocType: Vital Signs,Nutrition Values,Ernährungswerte
-DocType: Lab Test Template,Is billable,Ist abrechenbar
-DocType: Delivery Note,DN-,DN-
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Sowohl &quot;Physician Schedule&quot; als auch &quot;Time Per Appointment&quot; müssen für Dr {0} festgelegt werden
-DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Ein Drittanbieter/Händler/Kommissionär/verbundenes Unternehmen/Wiederverkäufer, der die Produkte auf Provisionsbasis verkauft."
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} zu Lieferantenauftrag {1}
-DocType: Patient,Patient Demographics,Patienten-Demographie
-DocType: Task,Actual Start Date (via Time Sheet),Das tatsächliche Startdatum (durch Zeiterfassung)
-apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,"Dies ist eine Beispiel-Webseite, von ERPNext automatisch generiert"
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Alter Bereich 1
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +210,Total advance amount cannot be greater than total claimed amount,Der gesamte Vorauszahlungsbetrag darf nicht höher sein als der gesamte beanspruchte Betrag
-DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
-
-#### Note
-
-The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
-
-#### Description of Columns
-
-1. Calculation Type: 
-    - This can be on **Net Total** (that is the sum of basic amount).
-    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
-    - **Actual** (as mentioned).
-2. Account Head: The Account ledger under which this tax will be booked
-3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
-4. Description: Description of the tax (that will be printed in invoices / quotes).
-5. Rate: Tax rate.
-6. Amount: Tax amount.
-7. Total: Cumulative total to this point.
-8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
-9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
-10. Add or Deduct: Whether you want to add or deduct the tax.","Standard-Steuer-Vorlage, die für alle Kauftransaktionen angewandt werden kann. Diese Vorlage kann eine Liste der Steuern und auch anderer Kosten wie ""Versand"", ""Versicherung"", ""Handhabung"" usw. enthalten. 
-
- #### Hinweis 
-
-Der Steuersatz, den sie hier definieren, wird der Standardsteuersatz für alle Artikel. Wenn es Artikel mit davon abweichenden Steuersätzen gibt, müssen diese in der Tabelle ""Artikelsteuer"" im Artikelstamm hinzugefügt werden.
-
- #### Beschreibung der Spalten 
-
-1. Berechnungsart: 
-- Dies kann sein ""Auf Nettosumme"" (das ist die Summe der Grundbeträge).
-- ""Auf vorherige Zeilensumme/-Betrag"" (für kumulative Steuern oder Abgaben). Wenn diese Option ausgewählt wird, wird die Steuer als Prozentsatz der vorherigen Zeilesumme/des vorherigen Zeilenbetrags (in der Steuertabelle) angewendet.
-- ""Unmittelbar"" (wie bereits erwähnt).
-2. Kontobezeichnung: Das Konto, auf das diese Steuer gebucht wird.
-3. Kostenstelle: Ist die Steuer/Gebühr ein Ertrag (wie Versand) oder ein Aufwand, muss sie gegen eine Kostenstelle gebucht werden.
-4. Beschreibung: Beschreibung der Steuer (wird auf Rechnungen und Angeboten abgedruckt).
-5. Satz: Steuersatz.
-6. Betrag: Steuerbetrag.
-7. Gesamt: Kumulierte Summe bis zu diesem Punkt.
-8. Zeile eingeben: Wenn ""Basierend auf Vorherige Zeile"" eingestellt wurde, kann hier die Zeilennummer ausgewählt werden, die als Basis für diese Berechnung (voreingestellt ist die vorherige Zeile) herangezogen wird.
-9. Steuern oder Gebühren berücksichtigen: In diesem Abschnitt kann festgelegt werden, ob die Steuer/Gebühr nur für die Bewertung (kein Teil der Gesamtsumme) oder nur für die Gesamtsumme (vermehrt nicht den Wert des Artikels) oder für beides verwendet wird.
-10. Hinzufügen oder abziehen: Gibt an, ob die Steuer/Abgabe hinzugefügt oder abgezogen wird."
-DocType: Homepage,Homepage,Webseite
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Arzt auswählen ...
-DocType: Grant Application,Grant Application Details ,Gewähren Sie Anwendungsdetails
-DocType: Purchase Receipt Item,Recd Quantity,Erhaltene Menge
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Gebühren-Aufzeichnungen erstellt - {0}
-DocType: Asset Category Account,Asset Category Account,Anlagekategorie Konto
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,Row #{0} (Payment Table): Amount must be positive,Zeile # {0} (Zahlungstabelle): Betrag muss positiv sein
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteNum,CompteNum
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},"Es können nicht mehr Artikel {0} produziert werden, als die über Kundenaufträge bestellte Stückzahl {1}"
-apps/erpnext/erpnext/stock/doctype/item/item.js +362,Select Attribute Values,Wählen Sie Attributwerte
-DocType: Purchase Invoice,Reason For Issuing document,Grund für das ausstellende Dokument
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Lagerbuchung {0} wurde nicht übertragen
-DocType: Payment Reconciliation,Bank / Cash Account,Bank / Geldkonto
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,Weiter Kontakt Durch nicht als Lead E-Mail-Adresse identisch sein
-DocType: Tax Rule,Billing City,Stadt laut Rechnungsadresse
-DocType: Asset,Manual,Handbuch
-DocType: Salary Component Account,Salary Component Account,Gehaltskomponente Account
-DocType: Global Defaults,Hide Currency Symbol,Währungssymbol ausblenden
-apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Spenderinformationen
-apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","z. B. Bank, Bargeld, Kreditkarte"
-DocType: Lead Source,Source Name,Quellenname
-DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normaler Ruhe-Blutdruck bei einem Erwachsenen ist etwa 120 mmHg systolisch und 80 mmHg diastolisch, abgekürzt &quot;120/80 mmHg&quot;"
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Legen Sie die Haltbarkeit der Artikel in Tagen fest, um den Verfall basierend auf Herstellungsdatum plus Eigenleben festzulegen"
-DocType: Journal Entry,Credit Note,Gutschrift
-DocType: Projects Settings,Ignore Employee Time Overlap,Mitarbeiterüberschneidungen ignorieren
-DocType: Warranty Claim,Service Address,Serviceadresse
-DocType: Asset Maintenance Task,Calibration,Kalibrierung
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,{0} is a company holiday,{0} ist ein Firmenurlaub
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Betriebs- und Geschäftsausstattung
-DocType: Item,Manufacture,Fertigung
-apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Einrichtung Unternehmen
-,Lab Test Report,Lab Testbericht
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Bitte zuerst den Lieferschein
-DocType: Student Applicant,Application Date,Antragsdatum
-DocType: Salary Detail,Amount based on formula,"Menge, bezogen auf Formel"
-DocType: Purchase Invoice,Currency and Price List,Währung und Preisliste
-DocType: Opportunity,Customer / Lead Name,Kunden- / Lead-Name
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Abrechnungsdatum nicht erwähnt
-apps/erpnext/erpnext/config/manufacturing.py +7,Production,Produktion
-DocType: Guardian,Occupation,Beruf
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Zeile {0}: Startdatum muss vor dem Enddatum liegen
-DocType: Crop,Planting Area,Pflanzfläche
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Summe (Anzahl)
-DocType: Installation Note Item,Installed Qty,Installierte Anzahl
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Dies könnte wegen einiger ungültiger E-Mail-Adressen in der
-apps/erpnext/erpnext/utilities/user_progress.py +28,You added ,Du hast hinzugefügt
-DocType: Purchase Taxes and Charges,Parenttype,Typ des übergeordneten Elements
-apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,Trainingsergebnis
-DocType: Purchase Invoice,Is Paid,Ist bezahlt
-DocType: Salary Structure,Total Earning,Gesamteinnahmen
-DocType: Purchase Receipt,Time at which materials were received,"Zeitpunkt, zu dem Materialien empfangen wurden"
-DocType: Products Settings,Products per Page,Produkte pro Seite
-DocType: Stock Ledger Entry,Outgoing Rate,Verkaufspreis
-apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Stammdaten zu Unternehmensfilialen
-apps/erpnext/erpnext/controllers/accounts_controller.py +312, or ,oder
-DocType: Sales Order,Billing Status,Abrechnungsstatus
-apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Einen Fall melden
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Versorgungsaufwendungen
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,Über 90
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +247,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Journal Entry {1} nicht Konto {2} oder bereits abgestimmt gegen einen anderen Gutschein
-DocType: Supplier Scorecard Criteria,Criteria Weight,Kriterien Gewicht
-DocType: Buying Settings,Default Buying Price List,Standard-Einkaufspreisliste
-DocType: Payroll Entry,Salary Slip Based on Timesheet,Gehaltsabrechnung Basierend auf Timesheet
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43,Buying Rate,Kaufrate
-DocType: Notification Control,Sales Order Message,Benachrichtigung über Kundenauftrag
-apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Standardwerte wie Firma, Währung, aktuelles Geschäftsjahr usw. festlegen"
-DocType: Payment Entry,Payment Type,Zahlungsart
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +240,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Bitte wählen Sie einen Batch für Item {0}. Es ist nicht möglich, eine einzelne Charge zu finden, die diese Anforderung erfüllt"
-DocType: Hub Category,Parent Category,Übergeordnete Kategorie
-DocType: Payroll Entry,Select Employees,Mitarbeiter auswählen
-DocType: Opportunity,Potential Sales Deal,Möglicher Verkaufsabschluss
-DocType: Complaint,Complaints,Beschwerden
-DocType: Payment Entry,Cheque/Reference Date,Scheck-/ Referenzdatum
-DocType: Purchase Invoice,Total Taxes and Charges,Gesamte Steuern und Gebühren
-DocType: Employee,Emergency Contact,Notfallkontakt
-DocType: Bank Reconciliation Detail,Payment Entry,Zahlung
-,sales-browser,Umsatz-Browser
-apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Hauptbuch
-DocType: Patient Medical Record,PMR-,PMR-
-DocType: Drug Prescription,Drug Code,Drug Code
-DocType: Target Detail,Target  Amount,Zielbetrag
-DocType: POS Profile,Print Format for Online,Online-Druckformat
-DocType: Shopping Cart Settings,Shopping Cart Settings,Warenkorb-Einstellungen
-DocType: Journal Entry,Accounting Entries,Buchungen
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Wenn die ausgewählte Preisregel für &quot;Rate&quot; festgelegt wurde, wird die Preisliste überschrieben. Der Preisregelpreis ist der Endpreis, daher sollte kein weiterer Rabatt angewendet werden. Daher wird es in Transaktionen wie Kundenauftrag, Bestellung usw. im Feld &#39;Preis&#39; und nicht im Feld &#39;Preislistenpreis&#39; abgerufen."
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Doppelter Eintrag/doppelte Buchung. Bitte überprüfen Sie Autorisierungsregel {0}
-DocType: Journal Entry Account,Reference Due Date,Referenz Fälligkeitsdatum
-DocType: Purchase Order,Ref SQ,Ref-SQ
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Eingangsbeleg muss vorgelegt werden
-DocType: Purchase Invoice Item,Received Qty,Erhaltene Menge
-DocType: Stock Entry Detail,Serial No / Batch,Seriennummer / Charge
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Nicht bezahlt und nicht geliefert
-DocType: Product Bundle,Parent Item,Übergeordneter Artikel
-DocType: Account,Account Type,Kontentyp
-DocType: Delivery Note,DN-RET-,DN-Ret
-apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Keine Zeitblätter
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,Urlaubstyp {0} kann nicht in die Zukunft übertragen werden
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Wartungsplan wird nicht für alle Elemente erzeugt. Bitte klicken Sie auf ""Zeitplan generieren"""
-,To Produce,Zu produzieren
-apps/erpnext/erpnext/config/hr.py +93,Payroll,Lohn-und Gehaltsabrechnung
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Für Zeile {0} in {1}. Um {2} in die Artikel-Bewertung mit einzubeziehen, muss auch Zeile {3} mit enthalten sein"
-apps/erpnext/erpnext/utilities/activation.py +101,Make User,Benutzer anlegen
-DocType: Packing Slip,Identification of the package for the delivery (for print),Kennzeichnung des Paketes für die Lieferung (für den Druck)
-DocType: Bin,Reserved Quantity,Reservierte Menge
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Bitte geben Sie eine gültige Email Adresse an
-DocType: Volunteer Skill,Volunteer Skill,Freiwillige Fähigkeit
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +780,Please select an item in the cart,Bitte wählen Sie einen Artikel im Warenkorb
-DocType: Landed Cost Voucher,Purchase Receipt Items,Kaufbeleg-Artikel
-apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Formulare anpassen
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,Rückstand
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Abschreibungsbetrag in der Zeit
-apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Deaktiviert Vorlage muss nicht Standard-Vorlage sein
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +313,For row {0}: Enter planned qty,Für Zeile {0}: Geben Sie die geplante Menge ein
-DocType: Shareholder,SH-,SCH-
-DocType: Account,Income Account,Ertragskonto
-DocType: Payment Request,Amount in customer's currency,Betrag in Kundenwährung
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825,Delivery,Auslieferung
-DocType: Volunteer,Weekdays,Wochentage
-DocType: Stock Reconciliation Item,Current Qty,Aktuelle Anzahl
-DocType: Restaurant Menu,Restaurant Menu,Speisekarte
-apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Vorherige
-DocType: Appraisal Goal,Key Responsibility Area,Entscheidender Verantwortungsbereich
-apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Studenten Batches helfen Ihnen die Teilnahme, Einschätzungen und Gebühren für Studenten verfolgen"
-DocType: Payment Entry,Total Allocated Amount,Insgesamt zugewiesener Betrag
-apps/erpnext/erpnext/setup/doctype/company/company.py +151,Set default inventory account for perpetual inventory,Inventurkonto für permanente Inventur auswählen
-DocType: Item Reorder,Material Request Type,Materialanfragetyp
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Journaleintrag für die Gehälter von {0} bis {1}
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Senden Sie Grant Review E-Mail
-apps/erpnext/erpnext/accounts/page/pos/pos.js +848,"LocalStorage is full, did not save","Localstorage voll ist, nicht speichern"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,Row {0}: UOM Conversion Factor is mandatory,Zeile {0}: Umrechnungsfaktor für Maßeinheit ist zwingend erforderlich
-apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Raumkapazität
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Ref,Ref.
-DocType: Lab Test,LP-,LP-
-DocType: Healthcare Settings,Registration Fee,Registrierungsgebühr
-DocType: Budget,Cost Center,Kostenstelle
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,Beleg #
-DocType: Notification Control,Purchase Order Message,Lieferantenauftrags-Nachricht
-DocType: Tax Rule,Shipping Country,Zielland der Lieferung
-DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Ausblenden Kundensteuernummer aus Verkaufstransaktionen
-DocType: Upload Attendance,Upload HTML,HTML hochladen
-DocType: Employee,Relieving Date,Freistellungsdatum
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.",Die Preisregel überschreibt die Preisliste. Bitte einen Rabattsatz aufgrund bestimmter Kriterien definieren.
-DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Lager kann nur über Lagerbuchung / Lieferschein / Kaufbeleg geändert werden
-DocType: Employee Education,Class / Percentage,Klasse / Anteil
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Leiter Marketing und Vertrieb
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Einkommensteuer
-apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Leads nach Branchentyp nachverfolgen
-apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Gehe zu Briefpapier
-DocType: Item Supplier,Item Supplier,Artikellieferant
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1255,Please enter Item Code to get batch no,Bitte die Artikelnummer eingeben um die Chargennummer zu erhalten
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880,Please select a value for {0} quotation_to {1},Bitte einen Wert für {0} Angebot an {1} auswählen
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414,No Items selected for transfer,Keine Elemente für die Übertragung ausgewählt
-apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Alle Adressen
-DocType: Company,Stock Settings,Lager-Einstellungen
-apps/erpnext/erpnext/accounts/doctype/account/account.py +183,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Zusammenführung ist nur möglich, wenn folgende Eigenschaften in beiden Datensätzen identisch sind:  Gruppe, Root-Typ, Firma"
-DocType: Vehicle,Electric,elektrisch
-DocType: Task,% Progress,% Fortschritt
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Gewinn / Verlust aus der Veräußerung von Vermögenswerten
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Kontonummer für Konto {0} ist nicht verfügbar. <br> Bitte richten Sie Ihren Kontenplan korrekt ein.
-DocType: Task,Depends on Tasks,Abhängig von Vorgang
-apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Baumstruktur der Kundengruppen verwalten
-DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Anhänge können ohne Erlaubnis des Einkaufswagens angezeigt werden
-DocType: Normal Test Items,Result Value,Ergebnis Wert
-DocType: Hotel Room,Hotels,Hotels
-DocType: Supplier Quotation,SQTN-,SQTN-
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Neuer Kostenstellenname
-DocType: Leave Control Panel,Leave Control Panel,Urlaubsverwaltung
-DocType: Project,Task Completion,Aufgabenerledigung
-apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Nicht lagernd
-DocType: Volunteer,Volunteer Skills,Freiwillige Fähigkeiten
-DocType: Appraisal,HR User,Nutzer Personalabteilung
-DocType: Purchase Invoice,Taxes and Charges Deducted,Steuern und Gebühren abgezogen
-apps/erpnext/erpnext/hooks.py +142,Issues,Probleme
-apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status muss einer aus {0} sein
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Erinnerung an GSTIN Sent zu aktualisieren
-DocType: Sales Invoice,Debit To,Belasten auf
-DocType: Restaurant Menu Item,Restaurant Menu Item,Restaurant-Menüpunkt
-DocType: Delivery Note,Required only for sample item.,Nur erforderlich für Probeartikel.
-DocType: Stock Ledger Entry,Actual Qty After Transaction,Tatsächliche Anzahl nach Transaktionen
-apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Kein Gehaltszettel gefunden zwischen {0} und {1}
-,Pending SO Items For Purchase Request,Ausstehende Artikel aus Kundenaufträgen für Lieferantenanfrage
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Student Admissions
-apps/erpnext/erpnext/accounts/party.py +389,{0} {1} is disabled,{0} {1} ist deaktiviert
-DocType: Supplier,Billing Currency,Abrechnungswährung
-DocType: Sales Invoice,SINV-RET-,SINV-Ret
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Besonders groß
-DocType: Crop,Scientific Name,Wissenschaftlicher Name
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,insgesamt Blätter
-DocType: Customer,"Reselect, if the chosen contact is edited after save","Wählen Sie erneut, wenn der ausgewählte Kontakt nach dem Speichern bearbeitet wird"
-DocType: Consultation,In print,in Druckbuchstaben
-,Profit and Loss Statement,Gewinn- und Verlustrechnung
-DocType: Bank Reconciliation Detail,Cheque Number,Schecknummer
-,Sales Browser,Vertriebs-Browser
-DocType: Journal Entry,Total Credit,Gesamt-Haben
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Achtung: Zu Lagerbuchung {2} gibt es eine andere Gegenbuchung {0} # {1}
-apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Lokal
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Darlehen und Anzahlungen (Aktiva)
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Schuldner
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Groß
-DocType: Homepage Featured Product,Homepage Featured Product,auf Webseite vorgestelltes Produkt
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +247,All Assessment Groups,Alle Bewertungsgruppen
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Neuer Lagername
-apps/erpnext/erpnext/accounts/report/financial_statements.py +257,Total {0} ({1}),Insgesamt {0} ({1})
-DocType: C-Form Invoice Detail,Territory,Region
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,"Bitte bei ""Besuche erforderlich"" NEIN angeben"
-DocType: Stock Settings,Default Valuation Method,Standard-Bewertungsmethode
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Gebühr
-apps/erpnext/erpnext/setup/doctype/company/company.js +154,Update in progress. It might take a while.,Aktualisierung läuft. Es kann eine Weile dauern.
-DocType: Production Plan Item,Produced Qty,Produzierte Menge
-DocType: Vehicle Log,Fuel Qty,Kraftstoff-Menge
-DocType: Production Order Operation,Planned Start Time,Geplante Startzeit
-DocType: Course,Assessment,Beurteilung
-DocType: Payment Entry Reference,Allocated,Zugewiesen
-apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Bilanz schliessen und in die Gewinn und Verlustrechnung übernehmen
-DocType: Student Applicant,Application Status,Bewerbungsstatus
-DocType: Sensitivity Test Items,Sensitivity Test Items,Empfindlichkeitstests
-DocType: Fees,Fees,Gebühren
-DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Wechselkurs zum Umrechnen einer Währung in eine andere angeben
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Angebot {0} wird storniert
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +114,Total Outstanding Amount,Offener Gesamtbetrag
-DocType: Sales Partner,Targets,Ziele
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54,Please register the SIREN number in the company information file,Bitte registrieren Sie die SIREN-Nummer in der Unternehmensinformationsdatei
-DocType: Price List,Price List Master,Preislisten-Vorlagen
-DocType: GST Account,CESS Account,CESS-Konto
-DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Alle Verkaufstransaktionen können für mehrere verschiedene ""Vertriebsmitarbeiter"" markiert werden, so dass Ziele festgelegt und überwacht werden können."
-,S.O. No.,Nummer der Lieferantenbestellung
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Bitte Kunden aus Lead {0} erstellen
-apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Wählen Sie Patient aus
-DocType: Price List,Applicable for Countries,Anwenden für Länder
-DocType: Supplier Scorecard Scoring Variable,Parameter Name,Parametername
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Studentengruppenname ist obligatorisch in Zeile {0}
-DocType: Homepage,Products to be shown on website homepage,"Produkte, die auf der Webseite angezeigt werden"
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Dies ist eine Root-Kundengruppe und kann nicht bearbeitet werden.
-DocType: Student,AB-,AB-
-DocType: POS Profile,Ignore Pricing Rule,Preisregel ignorieren
-DocType: Employee Education,Graduate,Akademiker
-DocType: Leave Block List,Block Days,Tage sperren
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Lieferadresse hat kein Land, das für diese Versandregel benötigt wird"
-DocType: Journal Entry,Excise Entry,Eintrag/Buchung entfernen
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Warnung: Kundenauftrag {0} zu Kunden-Bestellung bereits vorhanden {1}
-DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
-
-Examples:
-
-1. Validity of the offer.
-1. Payment Terms (In Advance, On Credit, part advance etc).
-1. What is extra (or payable by the Customer).
-1. Safety / usage warning.
-1. Warranty if any.
-1. Returns Policy.
-1. Terms of shipping, if applicable.
-1. Ways of addressing disputes, indemnity, liability, etc.
-1. Address and Contact of your Company.","Allgemeine Geschäftsbedingungen, die bei Ver- und Einkäufen verwendet werden können.
-
- Beispiele: 
-
-1. Gültigkeit des Angebots.
-2. Zahlungsbedingungen (Vorkasse, auf Rechnung, Teilweise Vorkasse usw.)
-3. Was ist eine Extraleistung (oder vom Kunden zu tragen).
-4. Warnhinweise zur Sicherheit/Nutzung.
-5. Garantie, falls vorhanden.
-6. Rückgabebedingungen.
-7. Lieferbedingungen, falls zutreffend.
-8. Beschwerdemanagement, Schadensersatz, Haftung usw. 
-9. Adresse und Kontaktdaten des Unternehmens."
-DocType: Issue,Issue Type,Fehlertyp
-DocType: Attendance,Leave Type,Urlaubstyp
-DocType: Purchase Invoice,Supplier Invoice Details,Lieferant Rechnungsdetails
-DocType: Agriculture Task,Ignore holidays,Feiertage ignorieren
-apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Aufwands-/Differenz-Konto ({0}) muss ein ""Gewinn oder Verlust""-Konto sein"
-DocType: Project,Copied From,Kopiert von
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340,Invoice already created for all billing hours,Die Rechnung wurde bereits für alle Abrechnungsstunden erstellt
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Name Fehler: {0}
-DocType: Cash Flow Mapping,Is Finance Cost,Ist Finanzen Kosten
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,"""Anwesenheit von Mitarbeiter"" {0} ist bereits markiert"
-DocType: Packing Slip,If more than one package of the same type (for print),Wenn es mehr als ein Paket von der gleichen Art (für den Druck) gibt
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Bitte setzen Sie den Standardkunden in den Restauranteinstellungen
-,Salary Register,Gehalt Register
-DocType: Warehouse,Parent Warehouse,Übergeordnetes Lager
-DocType: C-Form Invoice Detail,Net Total,Nettosumme
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +546,Default BOM not found for Item {0} and Project {1},Standard-Stückliste nicht gefunden für Position {0} und Projekt {1}
-apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Definieren Sie verschiedene Darlehensarten
-DocType: Bin,FCFS Rate,"""Wer-zuerst-kommt-mahlt-zuerst""-Anteil (Windhundverfahren)"
-DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Ausstehender Betrag
-apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Zeit (in Min)
-DocType: Project Task,Working,In Bearbeitung
-DocType: Stock Ledger Entry,Stock Queue (FIFO),Lagerverfahren (FIFO)
-apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Geschäftsjahr
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} gehört nicht zu Firma {1}
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,"Konnte die Kriterien-Score-Funktion für {0} nicht lösen. Stellen Sie sicher, dass die Formel gültig ist."
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,"Kosten, wie auf"
-DocType: Healthcare Settings,Out Patient Settings,Einstellungen für ambulante Patienten
-DocType: Account,Round Off,Abschliessen
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259,Quantity must be positive,Menge muss größer Null sein
-DocType: Material Request Plan Item,Requested Qty,Angeforderte Menge
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96,The fields From Shareholder and To Shareholder cannot be blank,Die Felder Von Aktionär und An Anteilinhaber dürfen nicht leer sein
-DocType: Tax Rule,Use for Shopping Cart,Für den Einkaufswagen verwenden
-apps/erpnext/erpnext/controllers/item_variant.py +98,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Wert {0} für Attribut {1} existiert nicht in der Liste der gültigen Artikelattributwerte für den Posten {2}
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Wählen Sie Seriennummern
-DocType: BOM Item,Scrap %,Ausschuss %
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection",Die Kosten werden gemäß Ihrer Wahl anteilig verteilt basierend auf Artikelmenge oder -preis
-DocType: Maintenance Visit,Purposes,Zwecke
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Mindestens ein Artikel sollte mit negativer Menge in das Rückgabedokument eingegeben werden
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations",Arbeitsgang {0} ist länger als alle verfügbaren Arbeitszeiten am Arbeitsplatz {1}. Bitte den Vorgang in mehrere Teilarbeitsgänge aufteilen.
-DocType: Membership,Membership Status,Mitgliedsstatus
-,Requested,Angefordert
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Keine Anmerkungen
-DocType: Asset,In Maintenance,In Wartung
-DocType: Purchase Invoice,Overdue,Überfällig
-DocType: Account,Stock Received But Not Billed,"Empfangener, aber nicht berechneter Lagerbestand"
-apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root Account must be a group,Root-Konto muss eine Gruppe sein
-DocType: Consultation,Drug Prescription,Medikament Rezept
-DocType: Fees,FEE.,GEBÜHR.
-DocType: Employee Loan,Repaid/Closed,Vergolten / Geschlossen
-DocType: Item,Total Projected Qty,Prognostizierte Gesamtmenge
-DocType: Monthly Distribution,Distribution Name,Bezeichnung der Verteilung
-apps/erpnext/erpnext/stock/stock_ledger.py +477,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Bewertungsrate, die für die Position {0} nicht gefunden wurde, die für die Buchungseinträge für {1} {2} erforderlich ist. Wenn die Position als Nullbewertungssatz in der {1} abgewickelt wird, erwähnen Sie bitte in der Tabelle {1}. Andernfalls erstellen Sie bitte eine eingehende Bestandsabwicklung für die Position oder erwähnen Sie den Bewertungssatz im Positionsdatensatz und versuchen Sie dann, diesen Eintrag einzureichen"
-DocType: Course,Course Code,Kursnummer
-apps/erpnext/erpnext/controllers/stock_controller.py +337,Quality Inspection required for Item {0},Qualitätsprüfung für den Posten erforderlich {0}
-DocType: POS Settings,Use POS in Offline Mode,POS im Offline-Modus verwenden
-DocType: Supplier Scorecard,Supplier Variables,Lieferantenvariablen
-DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Kurs, zu dem die Währung des Kunden in die Basiswährung des Unternehmens umgerechnet wird"
-DocType: Purchase Invoice Item,Net Rate (Company Currency),Nettopreis (Firmenwährung)
-DocType: Salary Detail,Condition and Formula Help,Zustand und Formel-Hilfe
-apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Baumstruktur der Regionen verwalten
-DocType: Journal Entry Account,Sales Invoice,Ausgangsrechnung
-DocType: Journal Entry Account,Party Balance,Gruppen-Saldo
-DocType: Cash Flow Mapper,Section Subtotal,Abschnitt Zwischensumme
-apps/erpnext/erpnext/accounts/page/pos/pos.js +498,Please select Apply Discount On,"Bitte ""Rabatt anwenden auf"" auswählen"
-DocType: Stock Settings,Sample Retention Warehouse,Beispiel Retention Warehouse
-DocType: Company,Default Receivable Account,Standard-Forderungskonto
-DocType: Physician,Physician Schedule,Arzt Zeitplan
-DocType: Purchase Invoice,Deemed Export,Ausgenommener Export
-DocType: Stock Entry,Material Transfer for Manufacture,Materialübertrag für Herstellung
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Der Rabatt-Prozentsatz kann entweder auf eine Preisliste oder auf alle Preislisten angewandt werden.
-DocType: Subscription,Half-yearly,Halbjährlich
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,Accounting Entry for Stock,Lagerbuchung
-DocType: Lab Test,LabTest Approver,LabTest Genehmiger
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61,You have already assessed for the assessment criteria {}.,Sie haben bereits für die Bewertungskriterien beurteilt.
-DocType: Vehicle Service,Engine Oil,Motoröl
-DocType: Sales Invoice,Sales Team1,Verkaufsteam1
-apps/erpnext/erpnext/stock/doctype/item/item.py +546,Item {0} does not exist,Artikel {0} existiert nicht
-DocType: Sales Invoice,Customer Address,Kundenadresse
-DocType: Employee Loan,Loan Details,Darlehensdetails
-DocType: Company,Default Inventory Account,Standard Inventurkonto
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192,The folio numbers are not matching,Die Folionummern stimmen nicht überein
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Row {0}: Abgeschlossen Menge muss größer als Null sein.
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +249,Payment Request for {0},Zahlungsanforderung für {0}
-DocType: Item Barcode,Barcode Type,Barcode-Typ
-DocType: Antibiotic,Antibiotic Name,Antibiotika-Name
-DocType: Purchase Invoice,Apply Additional Discount On,Zusätzlichen Rabatt gewähren auf
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Art auswählen...
-DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,"Eine Verknüpfung zu allen Landeinheiten, in denen die Kulturpflanze wächst"
-DocType: Account,Root Type,Root-Typ
-DocType: Item,FIFO,FIFO
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Zeile # {0}: Es kann nicht mehr als {1} für Artikel {2} zurückgegeben werden
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +45,Plot,Linie
-DocType: Item Group,Show this slideshow at the top of the page,Diese Diaschau oben auf der Seite anzeigen
-DocType: BOM,Item UOM,Artikelmaßeinheit
-DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Steuerbetrag nach Abzug von Rabatt (Firmenwährung)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +164,Target warehouse is mandatory for row {0},Eingangslager ist für Zeile {0} zwingend erforderlich
-DocType: Cheque Print Template,Primary Settings,Primäre Einstellungen
-DocType: Purchase Invoice,Select Supplier Address,Lieferantenadresse auswählen
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Mitarbeiter hinzufügen
-DocType: Purchase Invoice Item,Quality Inspection,Qualitätsprüfung
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Besonders klein
-DocType: Company,Standard Template,Standard Template
-DocType: Training Event,Theory,Theorie
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806,Warning: Material Requested Qty is less than Minimum Order Qty,Achtung : Materialanfragemenge ist geringer als die Mindestbestellmenge
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Konto {0} ist gesperrt
-DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Juristische Person/Niederlassung mit einem separaten Kontenplan, die zum Unternehmen gehört."
-DocType: Payment Request,Mute Email,Mute Email
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Lebensmittel, Getränke und Tabak"
-DocType: Account,Account Number,Kontonummer
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +720,Can only make payment against unbilled {0},Zahlung kann nur zu einer noch nicht abgerechneten {0} erstellt werden
-apps/erpnext/erpnext/controllers/selling_controller.py +101,Commission rate cannot be greater than 100,Provisionssatz kann nicht größer als 100 sein
-DocType: Volunteer,Volunteer,Freiwillige
-DocType: Stock Entry,Subcontract,Zulieferer
-apps/erpnext/erpnext/public/js/utils/party.js +166,Please enter {0} first,Bitte geben Sie zuerst {0} ein
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,Keine Antworten
-DocType: Production Order Operation,Actual End Time,Tatsächliche Endzeit
-DocType: Item,Manufacturer Part Number,Herstellernummer
-DocType: Production Order Operation,Estimated Time and Cost,Geschätzte Zeit und Kosten
-DocType: Bin,Bin,Lagerfach
-DocType: Crop,Crop Name,Name der Frucht
-DocType: SMS Log,No of Sent SMS,Anzahl abgesendeter SMS
-DocType: Antibiotic,Healthcare Administrator,Gesundheitswesen Administrator
-apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Ziel setzen
-DocType: Dosage Strength,Dosage Strength,Dosierungsstärke
-DocType: Account,Expense Account,Aufwandskonto
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Software
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Farbe
-DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriterien des Beurteilungsplans
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +118,Expiry date is mandatory for selected item,Das Verfallsdatum ist für den ausgewählten Artikel obligatorisch
-DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Vermeidung von Bestellungen
-apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,Anfällig
-DocType: Patient Appointment,Scheduled,Geplant
-apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Angebotsanfrage.
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Bitte einen Artikel auswählen, bei dem ""Ist Lagerartikel"" mit ""Nein"" und ""Ist Verkaufsartikel"" mit ""Ja"" bezeichnet ist, und es kein anderes Produkt-Bundle gibt"
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Kunden auswählen
-DocType: Student Log,Academic,akademisch
-DocType: Patient,Personal and Social History,Persönliche und gesellschaftliche Geschichte
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,Benutzer {0} erstellt
-DocType: Fee Schedule,Fee Breakup for each student,Fee Breakup für jeden Schüler
-apps/erpnext/erpnext/controllers/accounts_controller.py +540,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Insgesamt Voraus ({0}) gegen Bestellen {1} kann nicht größer sein als die Gesamtsumme ({2})
-DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,"Bitte ""Monatsweise Verteilung"" wählen, um Ziele ungleichmäßig über Monate zu verteilen."
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Code ändern
-DocType: Purchase Invoice Item,Valuation Rate,Wertansatz
-DocType: Stock Reconciliation,SR/,SR /
-DocType: Vehicle,Diesel,Diesel
-apps/erpnext/erpnext/stock/get_item_details.py +388,Price List Currency not selected,Preislistenwährung nicht ausgewählt
-DocType: Purchase Invoice,Availed ITC Cess,Erreichte ITC Cess
-,Student Monthly Attendance Sheet,Schülermonatsanwesenheits
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Versandregel gilt nur für den Verkauf
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Startdatum des Projekts
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18,Until,Bis
-DocType: Rename Tool,Rename Log,Protokoll umbenennen
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Student Group oder Kursplan ist Pflicht
-DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Pflegen Abrechnungszeiten und Arbeitszeiten Same auf Stundenzettel
-DocType: Maintenance Visit Purpose,Against Document No,Zu Dokument Nr.
-DocType: BOM,Scrap,Abfall / Ausschuss
-apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,Gehen Sie zu Instruktoren
-apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Vertriebspartner verwalten
-DocType: Quality Inspection,Inspection Type,Art der Prüfung
-DocType: Fee Validity,Visited yet,Besucht noch
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Lagerhäuser mit bestehenden Transaktion nicht zu einer Gruppe umgewandelt werden.
-DocType: Assessment Result Tool,Result HTML,Ergebnis HTML
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Verfällt am
-apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Schüler hinzufügen
-apps/erpnext/erpnext/public/js/utils.js +270,Please select {0},Bitte {0} auswählen
-DocType: C-Form,C-Form No,Kontakt-Formular-Nr.
-DocType: BOM,Exploded_items,Aufgelöste Artikel
-apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,"Liste Ihrer Produkte oder Dienstleistungen, die Sie kaufen oder verkaufen."
-DocType: Water Analysis,Storage Temperature,Lagertemperatur
-DocType: Employee Attendance Tool,Unmarked Attendance,Unmarkierte Teilnahme
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Wissenschaftler
-DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Programm-Enrollment-Tool Studenten
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Startdatum sollte weniger als Enddatum für Aufgabe {0} sein
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Name oder E-Mail-Adresse ist zwingend erforderlich
-DocType: Member,MEM-,MEM-
-DocType: Instructor,Instructor Log,Kursleiterprotokoll
-DocType: Purchase Order Item,Returned Qty,Zurückgegebene Menge
-DocType: Student,Exit,Verlassen
-apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Root-Typ ist zwingend erforderlich
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Fehler beim Installieren der Voreinstellungen
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} hat derzeit eine {1} Supplier Scorecard stehen, und Anfragen an diesen Lieferanten sollten mit Vorsicht ausgegeben werden."
-DocType: Chapter,Non Profit Manager,Non-Profit-Manager
-DocType: BOM,Total Cost(Company Currency),Gesamtkosten (Gesellschaft Währung)
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Seriennummer {0} erstellt
-DocType: Homepage,Company Description for website homepage,Firmen-Beschreibung für Internet-Homepage
-DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Zum Vorteil für die Kunden, können diese Kodes in Druckformaten wie Rechnungen und Lieferscheinen verwendet werden"
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,suplier Namen
-apps/erpnext/erpnext/accounts/report/financial_statements.py +172,Could not retrieve information for {0}.,Informationen für {0} konnten nicht abgerufen werden.
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134,Opening Entry Journal,Eröffnungseintragsjournal
-DocType: Sales Invoice,Time Sheet List,Zeitblatt Liste
-DocType: Employee,You can enter any date manually,Sie können jedes Datum manuell eingeben
-DocType: Healthcare Settings,Result Printed,Ergebnis Gedruckt
-DocType: Asset Category Account,Depreciation Expense Account,Aufwandskonto Abschreibungen
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Probationary Period,Probezeit
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Ansicht {0}
-DocType: Customer Group,Only leaf nodes are allowed in transaction,In dieser Transaktion sind nur Unterknoten erlaubt
-DocType: Project,Total Costing Amount (via Timesheets),Gesamtkalkulationsbetrag (über Arbeitszeittabellen)
-DocType: Employee Advance,Expense Approver,Ausgabenbewilliger
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Row {0}: Voraus gegen Kunde muss Kredit
-apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-Group-Gruppe
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Batch ist obligatorisch in Zeile {0}
-DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kaufbeleg-Artikel geliefert
-apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Bis Datum und Uhrzeit
-apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Protokolle über den SMS-Versand
-DocType: Accounts Settings,Make Payment via Journal Entry,Zahlung über Journaleintrag
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +218,Printed On,Gedruckt auf
-DocType: Item,Inspection Required before Delivery,Inspektion Notwendige vor der Auslieferung
-DocType: Item,Inspection Required before Purchase,"Inspektion erforderlich, bevor Kauf"
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Ausstehende Aktivitäten
-DocType: Patient Appointment,Reminded,Erinnert
-DocType: Patient,PID-,PID-
-DocType: Chapter Member,Chapter Member,Kapitel Mitglied
-DocType: Material Request Plan Item,Minimum Order Quantity,Mindestbestellmenge
-apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Ihre Organisation
-DocType: Fee Component,Fees Category,Gebühren Kategorie
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Bitte Freistellungsdatum eingeben.
-apps/erpnext/erpnext/controllers/trends.py +149,Amt,Menge
-DocType: Supplier Scorecard,Notify Employee,Mitarbeiter benachrichtigen
-DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Namen der Kampagne eingeben, wenn der Ursprung der Anfrage eine Kampagne ist"
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Zeitungsverleger
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Geschäftsjahr auswählen
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Voraussichtlicher Liefertermin sollte nach Kundenauftragsdatum erfolgen
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Meldebestand
-DocType: Company,Chart Of Accounts Template,Kontenvorlage
-DocType: Attendance,Attendance Date,Anwesenheitsdatum
-apps/erpnext/erpnext/stock/get_item_details.py +352,Item Price updated for {0} in Price List {1},Artikel Preis aktualisiert für {0} in der Preisliste {1}
-DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Gehaltsaufteilung nach Einkommen und Abzügen.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Account with child nodes cannot be converted to ledger,Ein Konto mit Unterknoten kann nicht in ein Kontoblatt umgewandelt werden
-DocType: Purchase Invoice Item,Accepted Warehouse,Annahmelager
-DocType: Bank Reconciliation Detail,Posting Date,Buchungsdatum
-DocType: Item,Valuation Method,Bewertungsmethode
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Halbtages
-DocType: Sales Invoice,Sales Team,Verkaufsteam
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Duplicate entry,Doppelter Eintrag/doppelte Buchung
-DocType: Program Enrollment Tool,Get Students,Holen Studenten
-DocType: Serial No,Under Warranty,Innerhalb der Garantie
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516,[Error],[Fehler]
-DocType: Sales Order,In Words will be visible once you save the Sales Order.,"""In Worten"" wird sichtbar, sobald Sie den Kundenauftrag speichern."
-,Employee Birthday,Mitarbeiter-Geburtstag
-apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Bitte wählen Sie das Abschlussdatum für die abgeschlossene Reparatur
-DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Studenten Batch Teilnahme Werkzeug
-apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,Grenze überschritten
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Geplante bis
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Risikokapital
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,"Ein Semester mit diesem ""Semesterjahr""'{0} und ""Semesternamen' {1} ist bereits vorhanden. Bitte ändern Sie diese entsprechend und versuchen Sie es erneut."
-DocType: UOM,Must be Whole Number,Muss eine ganze Zahl sein
-DocType: Leave Control Panel,New Leaves Allocated (In Days),Neue Urlaubszuordnung (in Tagen)
-DocType: Purchase Invoice,Invoice Copy,Rechnungskopie
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Seriennummer {0} existiert nicht
-DocType: Sales Invoice Item,Customer Warehouse (Optional),Kundenlagerkonto (optional)
-DocType: Pricing Rule,Discount Percentage,Rabatt in Prozent
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Reserviert für Unteraufträge
-DocType: Payment Reconciliation Invoice,Invoice Number,Rechnungsnummer
-DocType: Shopping Cart Settings,Orders,Bestellungen
-DocType: Employee Leave Approver,Leave Approver,Urlaubsgenehmiger
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Bitte wählen Sie eine Charge
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalLib,JournalLib
-DocType: Assessment Group,Assessment Group Name,Name der Beurteilungsgruppe
-DocType: Manufacturing Settings,Material Transferred for Manufacture,Material zur Herstellung übertragen
-DocType: Landed Cost Item,Receipt Document Type,Receipt Dokumenttyp
-DocType: Daily Work Summary Settings,Select Companies,Wählen Firmen
-,Issued Items Against Production Order,Zu Fertigungsauftrag ausgegebene Artikel
-DocType: Antibiotic,Healthcare,Gesundheitswesen
-DocType: Target Detail,Target Detail,Zieldetail
-apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Einzelvariante
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Alle Jobs
-DocType: Sales Order,% of materials billed against this Sales Order,% der Materialien welche zu diesem Kundenauftrag gebucht wurden
-DocType: Program Enrollment,Mode of Transportation,Beförderungsart
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Periodenabschlussbuchung
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Wählen Sie Abteilung ...
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Kostenstelle mit bestehenden Transaktionen kann nicht in eine Gruppe umgewandelt werden
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +367,Amount {0} {1} {2} {3},Menge {0} {1} {2} {3}
-DocType: Account,Depreciation,Abschreibung
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102,The number of shares and the share numbers are inconsistent,Die Anzahl der Aktien und die Aktienanzahl sind inkonsistent
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Lieferant(en)
-DocType: Employee Attendance Tool,Employee Attendance Tool,MItarbeiter-Anwesenheits-Werkzeug
-DocType: Guardian Student,Guardian Student,Wächter Studenten
-DocType: Supplier,Credit Limit,Kreditlimit
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Durchschn. Preislistenpreis verkaufen
-DocType: Salary Component,Salary Component,Gehaltskomponente
-apps/erpnext/erpnext/accounts/utils.py +495,Payment Entries {0} are un-linked,Zahlungs Einträge {0} sind un-linked
-DocType: GL Entry,Voucher No,Belegnr.
-,Lead Owner Efficiency,Lead Besitzer Effizienz
-DocType: Leave Allocation,Leave Allocation,Urlaubszuordnung
-DocType: Payment Request,Recipient Message And Payment Details,Empfänger der Nachricht und Zahlungsdetails
-DocType: Training Event,Trainer Email,Trainer E-Mail
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Materialanfrage {0} erstellt
-DocType: Restaurant Reservation,No of People,Nein von Menschen
-apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Vorlage für Geschäftsbedingungen oder Vertrag
-DocType: Purchase Invoice,Address and Contact,Adresse und Kontakt
-DocType: Cheque Print Template,Is Account Payable,Ist Konto zahlbar
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Auf nicht gegen Kaufbeleg aktualisiert werden {0}
-DocType: Support Settings,Auto close Issue after 7 days,Auto schließen Ausgabe nach 7 Tagen
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Da der Resturlaub bereits in den zukünftigen Datensatz für Urlaube {1} übertragen wurde, kann der Urlaub nicht vor {0} zugeteilt werden."
-apps/erpnext/erpnext/accounts/party.py +318,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Hinweis: Stichtag übersteigt das vereinbarte Zahlungsziel um {0} Tag(e)
-apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Studienbewerber
-DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL FÜR EMPFÄNGER
-DocType: Asset Category Account,Accumulated Depreciation Account,Abschreibungskonto
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Diese E-Mail ist automatisch generiert
-DocType: Stock Settings,Freeze Stock Entries,Lagerbuchungen sperren
-DocType: Program Enrollment,Boarding Student,Boarding Student
-DocType: Asset,Expected Value After Useful Life,Erwartungswert nach der Ausmusterung
-DocType: Item,Reorder level based on Warehouse,Meldebestand auf Basis des Lagers
-DocType: Activity Cost,Billing Rate,Abrechnungsbetrag
-,Qty to Deliver,Zu liefernde Menge
-,Stock Analytics,Bestandsanalyse
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +518,Operations cannot be left blank,Der Betrieb kann nicht leer sein
-DocType: Maintenance Visit Purpose,Against Document Detail No,Zu Dokumentendetail Nr.
-apps/erpnext/erpnext/regional/france/utils.py +30,Deletion is not permitted for country {0},Das Löschen ist für das Land {0} nicht zulässig.
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +105,Party Type is mandatory,Party-Typ ist Pflicht
-DocType: Quality Inspection,Outgoing,Ausgang
-DocType: Material Request,Requested For,Angefordert für
-DocType: Quotation Item,Against Doctype,Zu DocType
-apps/erpnext/erpnext/controllers/buying_controller.py +414,{0} {1} is cancelled or closed,{0} {1} wurde abgebrochen oder geschlossen
-DocType: Asset,Calculate Depreciation,Abschreibung berechnen
-DocType: Delivery Note,Track this Delivery Note against any Project,Diesen Lieferschein in jedem Projekt nachverfolgen
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35,Net Cash from Investing,Nettocashflow aus Investitionen
-DocType: Production Order,Work-in-Progress Warehouse,Fertigungslager
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Vermögen {0} muss eingereicht werden
-DocType: Fee Schedule Program,Total Students,Insgesamt Studenten
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Besucherrekord {0} existiert gegen Studenten {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Referenz #{0} vom {1}
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Die Abschreibungen Ausgeschieden aufgrund der Veräußerung von Vermögenswerten
-DocType: Member,Member,Mitglied
-apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Adressen verwalten
-DocType: Pricing Rule,Item Code,Artikelabkürzung
-DocType: Serial No,Warranty / AMC Details,Details der Garantie / des jährlichen Wartungsvertrags
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Wählen Sie die Schüler manuell für die aktivitätsbasierte Gruppe aus
-DocType: Journal Entry,User Remark,Benutzerbemerkung
-DocType: Lead,Market Segment,Marktsegment
-DocType: Agriculture Analysis Criteria,Agriculture Manager,Landwirtschaftsmanager
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},Gezahlten Betrag kann nicht größer sein als die Gesamt negativ ausstehenden Betrag {0}
-DocType: Supplier Scorecard Period,Variables,Variablen
-DocType: Employee Internal Work History,Employee Internal Work History,Interne Berufserfahrung des Mitarbeiters
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249,Closing (Dr),Schlußstand (Soll)
-DocType: Cheque Print Template,Cheque Size,Scheck Größe
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,Seriennummer {0} ist nicht auf Lager
-apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Steuervorlage für Verkaufstransaktionen
-DocType: Sales Invoice,Write Off Outstanding Amount,Offenen Betrag abschreiben
-apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Konto {0} stimmt nicht mit der Firma {1} überein
-DocType: Education Settings,Current Academic Year,Laufendes akademisches Jahr
-DocType: Stock Settings,Default Stock UOM,Standardlagermaßeinheit
-DocType: Asset,Number of Depreciations Booked,Anzahl der gebuchten Abschreibungen
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Gegen Mitarbeiterdarlehen: {0}
-DocType: Landed Cost Item,Receipt Document,Eingangsbeleg
-DocType: Employee Education,School/University,Schule/Universität
-DocType: Payment Request,Reference Details,Referenzdetails
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Expected Value After Useful Life must be less than Gross Purchase Amount,Erwartungswert nach der Ausmusterung muss kleiner sein als Bruttokaufbetrag
-DocType: Sales Invoice Item,Available Qty at Warehouse,Verfügbarer Lagerbestand
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Rechnungsbetrag
-DocType: Share Transfer,(including),(einschließlich)
-DocType: Asset,Double Declining Balance,Doppelte degressive
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Geschlosser Auftrag kann nicht abgebrochen werden. Bitte  wiedereröffnen um abzubrechen.
-DocType: Student Guardian,Father,Vater
-apps/erpnext/erpnext/controllers/accounts_controller.py +626,'Update Stock' cannot be checked for fixed asset sale,Beim Verkauf von Anlagevermögen darf 'Lagerbestand aktualisieren' nicht ausgewählt sein.
-DocType: Bank Reconciliation,Bank Reconciliation,Kontenabgleich
-DocType: Attendance,On Leave,Im Urlaub
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Updates abholen
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Konto {2} gehört nicht zur Firma {3}
-apps/erpnext/erpnext/stock/doctype/item/item.js +368,Select at least one value from each of the attributes.,Wählen Sie mindestens einen Wert für jedes der Attribute aus.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166,Material Request {0} is cancelled or stopped,Materialanfrage {0} wird storniert oder gestoppt
-apps/erpnext/erpnext/config/hr.py +310,Leave Management,Urlaube verwalten
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Gruppieren nach Konto
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21,Please select Employee,Bitte wählen Sie Mitarbeiter
-DocType: Sales Order,Fully Delivered,Komplett geliefert
-DocType: Lead,Lower Income,Niedrigeres Einkommen
-DocType: Restaurant Order Entry,Current Order,Aktueller Auftrag
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +183,Source and target warehouse cannot be same for row {0},Ausgangs- und Eingangslager können nicht gleich sein für die Zeile {0}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Differenzkonto muss ein Vermögens-/Verbindlichkeiten-Konto sein, da dieser Lagerabgleich eine Eröffnungsbuchung ist"
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Zahlter Betrag kann nicht größer sein als Darlehensbetrag {0}
-apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Gehen Sie zu Programme
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +203,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Zeile {0} # Der zugewiesene Betrag {1} darf nicht größer sein als der nicht beanspruchte Betrag {2}
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Lieferantenauftragsnummer ist für den Artikel {0} erforderlich
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +945,Production Order not created,Fertigungsauftrag nicht erstellt
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',"""Von-Datum"" muss nach ""Bis-Datum"" liegen"
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Kann nicht den Status als Student ändern {0} ist mit Studenten Anwendung verknüpft {1}
-DocType: Asset,Fully Depreciated,vollständig abgeschriebene
-DocType: Item Barcode,UPC-A,UPC-A
-,Stock Projected Qty,Prognostizierte Lagerbestandsmenge
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444,Customer {0} does not belong to project {1},Customer {0} gehört nicht zum Projekt {1}
-DocType: Employee Attendance Tool,Marked Attendance HTML,Marked Teilnahme HTML
-apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers",Angebote sind Offerten an einen Kunden zur Lieferung von Materialien bzw. zur Erbringung von Leistungen.
-DocType: Sales Invoice,Customer's Purchase Order,Kundenauftrag
-DocType: Consultation,Patient,Patient
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Kreditprüfung im Kundenauftrag umgehen
-DocType: Land Unit,Check if it is a hydroponic unit,"Überprüfen Sie, ob es sich um eine hydroponische Einheit handelt"
-apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Seriennummer und Chargen
-DocType: Warranty Claim,From Company,Von Firma
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Die Summe der Ergebnisse von Bewertungskriterien muss {0} sein.
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Bitte setzen Sie Anzahl der Abschreibungen gebucht
-DocType: Supplier Scorecard Period,Calculations,Berechnungen
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Wert oder Menge
-DocType: Payment Terms Template,Payment Terms,Zahlungsbedingungen
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +448,Productions Orders cannot be raised for:,Fertigungsaufträge können nicht angehoben werden:
-apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minute
-DocType: Purchase Invoice,Purchase Taxes and Charges,Einkaufsteuern und -abgaben
-DocType: Chapter,Meetup Embed HTML,Meetup HTML einbetten
-apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Gehen Sie zu Lieferanten
-,Qty to Receive,Anzunehmende Menge
-DocType: Leave Block List,Leave Block List Allowed,Urlaubssperrenliste zugelassen
-DocType: Grading Scale Interval,Grading Scale Interval,Notenskala Interval
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Kostenabrechnung für Fahrzeug Log {0}
-DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Rabatt (%) auf Preisliste Rate mit Margin
-apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Alle Lagerhäuser
-DocType: Sales Partner,Retailer,Einzelhändler
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Habenkonto muss ein Bilanzkonto sein
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Alle Lieferantentypen
-DocType: Donor,Donor,Spender
-DocType: Global Defaults,Disable In Words,"""Betrag in Worten"" abschalten"
-apps/erpnext/erpnext/stock/doctype/item/item.py +59,Item Code is mandatory because Item is not automatically numbered,"Artikelnummer ist zwingend erforderlich, da der Artikel nicht automatisch nummeriert wird"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Angebot {0} nicht vom Typ {1}
-DocType: Maintenance Schedule Item,Maintenance Schedule Item,Wartungsplanposten
-DocType: Sales Order,%  Delivered,%  geliefert
-apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,"Bitte legen Sie die E-Mail-ID für den Studenten an, um die Zahlungsanfrage zu senden"
-DocType: Production Order,PRO-,PROFI-
-DocType: Patient,Medical History,Krankengeschichte
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Kontokorrentkredit-Konto
-DocType: Patient,Patient ID,Patienten-ID
-DocType: Physician Schedule,Schedule Name,Planungsname
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Gehaltsabrechnung erstellen
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840,Add All Suppliers,Alle Lieferanten hinzufügen
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +89,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Zeile # {0}: Zugeordneter Betrag darf nicht größer als ausstehender Betrag sein.
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Stückliste durchsuchen
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Gedeckte Kredite
-DocType: Purchase Invoice,Edit Posting Date and Time,Bearbeiten von Buchungsdatum und -uhrzeit erlauben
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Bitte setzen Abschreibungen im Zusammenhang mit Konten in der Anlagekategorie {0} oder Gesellschaft {1}
-DocType: Lab Test Groups,Normal Range,Normalbereich
-DocType: Academic Term,Academic Year,Schuljahr
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Verfügbarer Verkauf
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Anfangsstand Eigenkapital
-DocType: Lead,CRM,CRM
-DocType: Purchase Invoice,N,N
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Verbleibend
-DocType: Appraisal,Appraisal,Bewertung
-DocType: Purchase Invoice,GST Details,GST Details
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},E-Mail an Lieferanten versandt {0}
-DocType: Item,Default Sales Unit of Measure,Default Sales Maßeinheit
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Academic Year: ,Akademisches Jahr:
-DocType: Opportunity,OPTY-,CHNC-
-apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Ereignis wiederholen
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Zeichnungsberechtigte/-r
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Gebühren anlegen
-DocType: Project,Total Purchase Cost (via Purchase Invoice),Summe Einkaufskosten (über Einkaufsrechnung)
-DocType: Training Event,Start Time,Startzeit
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +400,Select Quantity,Menge wählen
-DocType: Customs Tariff Number,Customs Tariff Number,Zolltarifnummer
-DocType: Patient Appointment,Patient Appointment,Patiententermin
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,"Genehmigende Rolle kann nicht dieselbe Rolle sein wie diejenige, auf die die Regel anzuwenden ist"
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Abmelden von diesem E-Mail-Bericht
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830,Get Suppliers By,Holen Sie sich Lieferanten durch
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +172,{0} not found for Item {1},{0} für Artikel {1} nicht gefunden
-apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Gehen Sie zu den Kursen
-DocType: Accounts Settings,Show Inclusive Tax In Print,Inklusivsteuer im Druck anzeigen
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory","Bankkonto, Von Datum und Bis sind obligatorisch"
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Mitteilung gesendet
-apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Account with child nodes cannot be set as ledger,Konto mit untergeordneten Knoten kann nicht als Hauptbuch festgelegt werden
-DocType: C-Form,II,II
-DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Kurs, zu dem die Währung der Preisliste in die Basiswährung des Kunden umgerechnet wird"
-DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobetrag (Firmenwährung)
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +213,Total advance amount cannot be greater than total sanctioned amount,Der gesamte Vorschussbetrag darf nicht höher sein als der Gesamtbetrag der Sanktion
-DocType: Salary Slip,Hour Rate,Stundensatz
-DocType: Stock Settings,Item Naming By,Artikelbezeichnung nach
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Eine weitere Periodenabschlussbuchung {0} wurde nach {1} erstellt
-DocType: Production Order,Material Transferred for Manufacturing,Material zur Herstellung übertragen
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41,Account {0} does not exists,Konto {0} existiert nicht
-DocType: Project,Project Type,Projekttyp
-apps/erpnext/erpnext/projects/doctype/task/task.py +142,Child Task exists for this Task. You can not delete this Task.,Untergeordnete Aufgabe existiert für diese Aufgabe. Sie können diese Aufgabe nicht löschen.
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,DateLet,DateLet
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Entweder Zielstückzahl oder Zielmenge ist zwingend erforderlich.
-apps/erpnext/erpnext/config/projects.py +51,Cost of various activities,Aufwendungen für verschiedene Tätigkeiten
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Einstellen Events auf {0}, da die Mitarbeiter auf die beigefügten unter Verkaufs Personen keine Benutzer-ID {1}"
-DocType: Timesheet,Billing Details,Rechnungsdetails
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,Source and target warehouse must be different,Quell- und Ziel-Warehouse müssen unterschiedlich sein
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Aktualisierung von Transaktionen älter als {0} nicht erlaubt
-DocType: BOM,Inspection Required,Prüfung erforderlich
-DocType: Purchase Invoice Item,PR Detail,PR-Detail
-DocType: Driving License Category,Class,Klasse
-DocType: Sales Order,Fully Billed,Voll berechnet
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Versandregel gilt nur für den Einkauf
-DocType: Vital Signs,BMI,BMI
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Barmittel
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Auslieferungslager für Lagerartikel {0} erforderlich
-DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Das Bruttogewicht des Pakets. Normalerweise Nettogewicht + Verpackungsgweicht. (Für den Ausdruck)
-DocType: Assessment Plan,Program,Programm
-DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Benutzer mit dieser Rolle sind berechtigt Konten zu sperren und  Buchungen zu gesperrten Konten zu erstellen/verändern
-DocType: Serial No,Is Cancelled,Ist storniert
-DocType: Student Group,Group Based On,Gruppe basiert auf
-DocType: Journal Entry,Bill Date,Rechnungsdatum
-DocType: Healthcare Settings,Laboratory SMS Alerts,Labor-SMS-Benachrichtigungen
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Service-Item, Art, Häufigkeit und Kosten Betrag erforderlich"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Wenn es mehrere Preisregeln mit der höchsten Priorität gibt, werden folgende interne Prioritäten angewandt:"
-DocType: Plant Analysis Criteria,Plant Analysis Criteria,Anlagenanalysekriterien
-DocType: Cheque Print Template,Cheque Height,Scheck Höhe
-DocType: Supplier,Supplier Details,Lieferantendetails
-DocType: Setup Progress,Setup Progress,Setup Fortschritt
-DocType: Hub Settings,Publish Items to Hub,Artikel über den Hub veröffentlichen
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Von-Wert muss weniger sein als Bis-Wert in Zeile {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Überweisung
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Alle prüfen
-DocType: Vehicle Log,Invoice Ref,Rechnung Ref
-DocType: Company,Default Income Account,Standard-Ertragskonto
-apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Kundengruppe / Kunde
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Unclosed Geschäftsjahre Gewinn / Verlust (Credit)
-DocType: Sales Invoice,Time Sheets,Zeitblätter
-DocType: Lab Test Template,Change In Item,Änderung im Artikel
-DocType: Payment Gateway Account,Default Payment Request Message,Standard Payment Request Message
-DocType: Item Group,Check this if you want to show in website,"Aktivieren, wenn der Inhalt auf der Webseite angezeigt werden soll"
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338,Balance ({0}),Saldo ({0})
-apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bank- und Zahlungsverkehr
-,Welcome to ERPNext,Willkommen bei ERPNext
-apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Vom Lead zum Angebot
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,E-Mail-Erinnerungen werden an alle Parteien mit E-Mail-Kontakten gesendet
-DocType: Patient,A Negative,Ein Negativ
-apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Nichts mehr zu zeigen.
-DocType: Lead,From Customer,Von Kunden
-apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Anrufe
-apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Ein Produkt
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,Chargen
-apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Machen Sie Fee Schedule
-DocType: Purchase Order Item Supplied,Stock UOM,Lagermaßeinheit
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Lieferantenauftrag {0} wurde nicht übertragen
-DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normaler Referenzbereich für einen Erwachsenen ist 16-20 Atemzüge / Minute (RCP 2012)
-DocType: Customs Tariff Number,Tariff Number,Tarifnummer
-DocType: Production Order Item,Available Qty at WIP Warehouse,Verfügbare Menge bei WIP Warehouse
-apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Geplant
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} does not belong to Warehouse {1},Seriennummer {0} gehört nicht zu Lager {1}
-apps/erpnext/erpnext/controllers/status_updater.py +174,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Hinweis: Das System überprüft Überlieferungen und Überbuchungen zu Artikel {0} nicht da Stückzahl oder Menge 0 sind
-DocType: Notification Control,Quotation Message,Angebotsmitteilung
-DocType: Employee Loan,Employee Loan Application,MItarbeiterdarlehensantrag
-DocType: Issue,Opening Date,Eröffnungsdatum
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86,Please save the patient first,Bitte speichern Sie den Patienten zuerst
-apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Die Teilnahme wurde erfolgreich markiert.
-DocType: Program Enrollment,Public Transport,Öffentlicher Verkehr
-DocType: Soil Texture,Silt Composition (%),Schlammzusammensetzung (%)
-DocType: Journal Entry,Remark,Bemerkung
-DocType: Healthcare Settings,Avoid Confirmation,Vermeidung von Bestätigung
-DocType: Purchase Receipt Item,Rate and Amount,Preis und Menge
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +171,Account Type for {0} must be {1},Accounttyp für {0} muss {1} sein
-DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,"Default-Einkommen Konten verwendet werden, wenn nicht in Arzt eingestellt zu buchen Beratung Gebühren."
-apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Urlaube und Feiertage
-DocType: Education Settings,Current Academic Term,Laufendes akademische Semester
-DocType: Sales Order,Not Billed,Nicht abgerechnet
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Beide Lager müssen zur gleichen Firma gehören
-apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Noch keine Kontakte hinzugefügt.
-DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Einstandskosten
-,Item Balance (Simple),Artikelguthaben (einfach)
-apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Rechnungen von Lieferanten
-DocType: POS Profile,Write Off Account,Abschreibungs-Konto
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +210,Debit Note Amt,Debit Note Amt
-apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Rabattbetrag
-DocType: Purchase Invoice,Return Against Purchase Invoice,Zurück zur Einkaufsrechnung
-DocType: Item,Warranty Period (in days),Garantiefrist (in Tagen)
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Fehler beim Festlegen der Standardeinstellungen
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Beziehung mit Guardian1
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +787,Please select BOM against item {0},Bitte wählen Sie Stückliste gegen Artikel {0}
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Rechnungen erstellen
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Cash from Operations,Nettocashflow aus laufender Geschäftstätigkeit
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Position 4
-DocType: Student Admission,Admission End Date,Stichtag für Zulassungsende
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Zulieferung
-DocType: Journal Entry Account,Journal Entry Account,Journalbuchungskonto
-apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Student Group
-DocType: Shopping Cart Settings,Quotation Series,Nummernkreis für Angebote
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57,"An item exists with same name ({0}), please change the item group name or rename the item",Ein Artikel mit dem gleichen Namen existiert bereits ({0}). Bitte den Namen der Artikelgruppe ändern oder den Artikel umbenennen
-DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriterien für die Bodenanalyse
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2039,Please select customer,Bitte wählen Sie Kunde
-DocType: C-Form,I,ich
-DocType: Company,Asset Depreciation Cost Center,Kostenstelle für Anlagenabschreibung
-DocType: Production Plan Sales Order,Sales Order Date,Kundenauftrags-Datum
-DocType: Sales Invoice Item,Delivered Qty,Gelieferte Stückzahl
-DocType: Assessment Plan,Assessment Plan,Beurteilungsplan
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Kunde {0} wird erstellt.
-DocType: Stock Settings,Limit Percent,Limit-Prozent
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Derzeit ist kein Bestand in einem Lager verfügbar
-,Payment Period Based On Invoice Date,Zahlungszeitraum basierend auf Rechnungsdatum
-DocType: Sample Collection,No. of print,Anzahl Druck
-DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Hotelzimmer-Reservierungselement
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Fehlende Wechselkurse für {0}
-DocType: Assessment Plan,Examiner,Prüfer
-DocType: Student,Siblings,Geschwister
-DocType: Journal Entry,Stock Entry,Lagerbuchung
-DocType: Payment Entry,Payment References,Bezahlung Referenzen
-DocType: C-Form,C-FORM-,C-FORM-
-DocType: Vehicle,Insurance Details,Versicherungsdetails
-DocType: Account,Payable,Zahlbar
-DocType: Share Balance,Share Type,Art der Freigabe
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Bitte geben Sie Laufzeiten
-apps/erpnext/erpnext/shopping_cart/cart.py +378,Debtors ({0}),Schuldnern ({0})
-DocType: Pricing Rule,Margin,Marge
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Neue Kunden
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Rohgewinn %
-DocType: Appraisal Goal,Weightage (%),Gewichtung (%)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +499,Change POS Profile,Ändern Sie das POS-Profil
-DocType: Bank Reconciliation Detail,Clearance Date,Abrechnungsdatum
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Beurteilung
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Bruttokaufbetrag ist erforderlich
-apps/erpnext/erpnext/setup/doctype/company/company.js +95,Company name not same,Firmenname nicht gleich
-DocType: Lead,Address Desc,Adresszusatz
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +108,Party is mandatory,Partei ist obligatorisch
-DocType: Journal Entry,JV-,JV-
-apps/erpnext/erpnext/controllers/accounts_controller.py +707,Rows with duplicate due dates in other rows were found: {list},Zeilen mit doppelten Fälligkeitsdaten in anderen Zeilen wurden gefunden: {list}
-DocType: Topic,Topic Name,Thema Name
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,Atleast one of the Selling or Buying must be selected,Mindestens ein Eintrag aus Vertrieb oder Einkauf muss ausgewählt werden
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290,Select an employee to get the employee advance.,"Wählen Sie einen Mitarbeiter aus, um den Mitarbeiter vorab zu erreichen."
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Bitte wähle ein gültiges Datum aus
-apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Wählen Sie die Art Ihres Unternehmens.
-DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
-<br>
-Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
-<br>
-Descriptive for tests which have multiple result components and corresponding result entry fields. 
-<br>
-Grouped for test templates which are a group of other test templates.
-<br>
-No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Single für Ergebnisse, die nur einen einzigen Eingang, Ergebnis UOM und Normalwert erfordern <br> Compound für Ergebnisse, die mehrere Eingabefelder mit entsprechenden Ereignisnamen, Ergebnis-UOMs und Normalwerten erfordern <br> Beschreibend für Tests mit mehreren Ergebniskomponenten und entsprechenden Ergebniserfassungsfeldern. <br> Gruppiert für Testvorlagen, die eine Gruppe von anderen Testvorlagen sind. <br> Kein Ergebnis für Tests ohne Ergebnisse. Außerdem wird kein Labortest erstellt. z.B. Sub-Tests für gruppierte Ergebnisse."
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,Row #{0}: Duplicate entry in References {1} {2},Zeile # {0}: Eintrag in Referenzen {1} {2} duplizieren
-apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,"Ort, an dem Arbeitsgänge der Fertigung ablaufen."
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Als Prüfer
-DocType: Asset Movement,Source Warehouse,Ausgangslager
-DocType: Installation Note,Installation Date,Datum der Installation
-apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Aktienbuch
-apps/erpnext/erpnext/controllers/accounts_controller.py +605,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Vermögens {1} gehört nicht zur Gesellschaft {2}
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Verkaufsrechnung {0} erstellt
-DocType: Employee,Confirmation Date,Datum bestätigen
-DocType: C-Form,Total Invoiced Amount,Gesamtrechnungsbetrag
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50,Min Qty can not be greater than Max Qty,Mindestmenge kann nicht größer als Maximalmenge sein
-DocType: Soil Texture,Silty Clay,Siltiger Ton
-DocType: Account,Accumulated Depreciation,Kumulierte Abschreibungen
-DocType: Supplier Scorecard Scoring Standing,Standing Name,Standing Name
-DocType: Stock Entry,Customer or Supplier Details,Kunden- oder Lieferanten-Details
-DocType: Employee Loan Application,Required by Date,Erforderlich by Date
-DocType: Lead,Lead Owner,Eigentümer des Leads
-DocType: Production Plan,Sales Orders Detail,Kundenauftragsdetails
-DocType: Bin,Requested Quantity,die angeforderte Menge
-DocType: Patient,Marital Status,Familienstand
-DocType: Stock Settings,Auto Material Request,Automatische Materialanfrage
-DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Verfügbare Chargenmenge im Ausgangslager
-DocType: Customer,CUST-,CUST-
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Idevise,Idevis
-DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruttolohn - Gesamtabzug - Darlehensrückzahlung
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29,Current BOM and New BOM can not be same,Aktuelle Stückliste und neue Stückliste können nicht identisch sein
-apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,Gehaltsabrechnung ID
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Zeitpunkt der Pensionierung muss nach dem Eintrittsdatum liegen
-apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Mehrere Varianten
-DocType: Sales Invoice,Against Income Account,Zu Ertragskonto
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% geliefert
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Artikel {0}: Bestellmenge {1} kann nicht weniger als Mindestbestellmenge {2} (im Artikel definiert) sein.
-DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Prozentuale Aufteilung der monatsweisen Verteilung
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49,Please login as another user.,Bitte melden Sie sich als anderer Benutzer an.
-DocType: Daily Work Summary Group User,Daily Work Summary Group User,Tägliche Arbeit Zusammenfassung Gruppenbenutzer
-DocType: Territory,Territory Targets,Ziele für die Region
-DocType: Soil Analysis,Ca/Mg,Ca / Mg
-DocType: Delivery Note,Transporter Info,Informationen zum Transportunternehmer
-apps/erpnext/erpnext/accounts/utils.py +502,Please set default {0} in Company {1},Bitte setzen Sie default {0} in Gesellschaft {1}
-DocType: Cheque Print Template,Starting position from top edge,Ausgangsposition von der Oberkante
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33,Same supplier has been entered multiple times,Same Anbieter wurde mehrmals eingegeben
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Bruttogewinn / Verlust
-,Warehouse wise Item Balance Age and Value,Lagerweise Item Balance Alter und Wert
-DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Lieferantenauftrags-Artikel geliefert
-apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Firmenname kann keine Firma sein
-apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Briefköpfe für Druckvorlagen
-apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,"Bezeichnungen für Druckvorlagen, z. B. Proforma-Rechnung"
-DocType: Program Enrollment,Walking,Gehen
-DocType: Student Guardian,Student Guardian,Studenten Wächter
-DocType: Member,Member Name,Mitgliedsname
-DocType: Stock Settings,Use Naming Series,Verwenden Sie die Namensreihen
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,"Bewertungsart Gebühren kann nicht als ""inklusive"" markiert werden"
-DocType: POS Profile,Update Stock,Lagerbestand aktualisieren
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,im Abonnement
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"Unterschiedliche Maßeinheiten für Artikel führen zu falschen Werten für das (Gesamt-)Nettogewicht. Es muss sicher gestellt sein, dass das Nettogewicht jedes einzelnen Artikels in der gleichen Maßeinheit angegeben ist."
-DocType: Membership,Payment Details,Zahlungsdetails
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,Stückpreis
-DocType: Asset,Journal Entry for Scrap,Journaleintrag für Ausschuss
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Bitte Artikel vom Lieferschein nehmen
-apps/erpnext/erpnext/accounts/utils.py +472,Journal Entries {0} are un-linked,Buchungssätze {0} sind nicht verknüpft
-apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Aufzeichnung jeglicher Kommunikation vom Typ Email, Telefon, Chat, Besuch usw."
-DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing
-DocType: Manufacturer,Manufacturers used in Items,Hersteller im Artikel verwendet
-apps/erpnext/erpnext/accounts/general_ledger.py +168,Please mention Round Off Cost Center in Company,Bitte Abschlusskostenstelle in Firma vermerken
-DocType: Purchase Invoice,Terms,Geschäftsbedingungen
-DocType: Academic Term,Term Name,Semesterbezeichnung
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332,Credit ({0}),Guthaben ({0})
-DocType: Buying Settings,Purchase Order Required,Lieferantenauftrag erforderlich
-,Item-wise Sales History,Artikelbezogene Verkaufshistorie
-DocType: Expense Claim,Total Sanctioned Amount,Summe genehmigter Beträge
-DocType: Land Unit,Land Unit,Landeinheit
-,Purchase Analytics,Einkaufsanalyse
-DocType: Sales Invoice Item,Delivery Note Item,Lieferschein-Artikel
-DocType: Asset Maintenance Log,Task,Aufgabe
-DocType: Purchase Taxes and Charges,Reference Row #,Referenz-Zeile #
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Chargennummer ist zwingend erforderlich für Artikel {0}
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Dies ist ein Root-Vertriebsmitarbeiter und kann nicht bearbeitet werden.
-DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Wenn ausgewählt, wird der in dieser Komponente angegebene oder berechnete Wert nicht zu den Erträgen oder Abzügen beitragen. Der Wert kann jedoch durch andere Komponenten referenziert werden, die hinzugefügt oder abgezogen werden können."
-DocType: Asset Settings,Number of Days in Fiscal Year,Anzahl der Tage im Geschäftsjahr
-,Stock Ledger,Lagerbuch
-apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Preis: {0}
-DocType: Company,Exchange Gain / Loss Account,Exchange-Gewinn / Verlustrechnung
-apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Mitarbeiter und Teilnahme
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +92,Purpose must be one of {0},Zweck muss einer von diesen sein: {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Fill the form and save it,Formular ausfüllen und speichern
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Community-Forum
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Tatsächliche Menge auf Lager
-DocType: Homepage,"URL for ""All Products""",URL für &quot;Alle Produkte&quot;
-DocType: Leave Application,Leave Balance Before Application,Urlaubstage vor Antrag
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,SMS verschicken
-DocType: Supplier Scorecard Criteria,Max Score,Max. Ergebnis
-DocType: Cheque Print Template,Width of amount in word,Breite der Menge in Wort
-DocType: Company,Default Letter Head,Standardbriefkopf
-DocType: Purchase Order,Get Items from Open Material Requests,Holen Sie Angebote von Material öffnen Anfragen
-DocType: Hotel Room Amenity,Billable,Abrechenbar
-DocType: Lab Test Template,Standard Selling Rate,Standard-Verkaufspreis
-DocType: Account,Rate at which this tax is applied,"Kurs, zu dem dieser Steuersatz angewandt wird"
-DocType: Cash Flow Mapper,Section Name,Abteilungsname
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77,Reorder Qty,Nachbestellmenge
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Laufende Stellenangebote
-DocType: Company,Stock Adjustment Account,Bestandskorrektur-Konto
-apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Abschreiben
-DocType: Timesheet Detail,Operation ID,Arbeitsgang-ID
-DocType: Employee,"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."
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Von {1}
-DocType: Task,depends_on,hängt ab von
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Warteschlange für die Aktualisierung der neuesten Preis in allen Stückliste. Es kann einige Minuten dauern.
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Name des neuen Kontos. Hinweis: Bitte keine Konten für Kunden und Lieferanten erstellen
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Setzen Sie die Namensserie für {0} über Setup&gt; Einstellungen&gt; Namensserie
-apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Landesspezifische Standard-Adressvorlagen
-DocType: Water Analysis,Appearance,Aussehen
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Durchschn. Preislistenpreis kaufen
-DocType: Sales Order Item,Supplier delivers to Customer,Lieferant liefert an Kunden
-apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Mitgliederinformation.
-apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) ist ausverkauft
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Anlagenpflege
-,Sales Payment Summary,Zusammenfassung der Verkaufszahlung
-DocType: Restaurant,Restaurant,Restaurant
-apps/erpnext/erpnext/accounts/party.py +321,Due / Reference Date cannot be after {0},Fälligkeits-/Stichdatum kann nicht nach {0} liegen
-apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Daten-Import und -Export
-DocType: Patient,Account Details,Kontendaten
-DocType: Crop,Materials Required,Benötigte Materialien
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Keine Studenten gefunden
-DocType: Medical Department,Medical Department,Medizinische Abteilung
-DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Kriterien
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Rechnungsbuchungsdatum
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Verkaufen
-DocType: Purchase Invoice,Rounded Total,Gerundete Gesamtsumme
-DocType: Product Bundle,List items that form the package.,"Die Artikel auflisten, die das Paket bilden."
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39,Not permitted. Please disable the Test Template,Nicht gestattet. Bitte deaktivieren Sie die Testvorlage
-apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Prozentuale Aufteilung sollte gleich 100% sein
-DocType: Crop Cycle,Linked Land Unit,Verbundene Landeinheit
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Bitte wählen Sie Buchungsdatum vor dem Party-Auswahl
-DocType: Program Enrollment,School House,School House
-DocType: Serial No,Out of AMC,Außerhalb des jährlichen Wartungsvertrags
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Anzahl der Abschreibungen gebucht kann nicht größer sein als Gesamtzahl der abschreibungen
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Wartungsbesuch erstellen
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +222,Please contact to the user who have Sales Master Manager {0} role,"Bitte den Benutzer kontaktieren, der die Vertriebsleiter {0}-Rolle inne hat"
-DocType: Company,Default Cash Account,Standardbarkonto
-apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Unternehmensstammdaten (nicht Kunde oder Lieferant)
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Dies hängt von der Anwesenheit dieses Studierenden ab
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Keine Studenten in
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179,Add more items or open full form,Weitere Elemente hinzufügen oder vollständiges Formular öffnen
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Lieferscheine {0} müssen vor Löschung dieser Kundenaufträge storniert werden
-apps/erpnext/erpnext/utilities/user_progress.py +256,Go to Users,Gehen Sie zu den Benutzern
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Summe aus gezahltem Betrag + ausgebuchter Betrag darf nicht größer der Gesamtsumme sein
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} ist keine gültige Chargennummer für Artikel {1}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +131,Note: There is not enough leave balance for Leave Type {0},Hinweis: Es gibt nicht genügend Urlaubsguthaben für Abwesenheitstyp {0}
-apps/erpnext/erpnext/regional/india/utils.py +16,Invalid GSTIN or Enter NA for Unregistered,Ungültiges GSTIN oder NA für unregistriert eingeben
-DocType: Training Event,Seminar,Seminar
-DocType: Program Enrollment Fee,Program Enrollment Fee,Programm Einschreibegebühr
-DocType: Item,Supplier Items,Lieferantenartikel
-DocType: Opportunity,Opportunity Type,Chance-Typ
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Neue Firma
-apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Transaktionen können nur durch den Ersteller der Firma gelöscht werden
-apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Falsche Anzahl von Buchungen im Hauptbuch gefunden. Möglicherweise wurde für die Transaktion ein falsches Konto gewählt.
-DocType: Employee,Prefered Contact Email,Bevorzugte Kontakt E-Mail
-DocType: Cheque Print Template,Cheque Width,Scheck Breite
-DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Bestätigen Sie den  Verkaufspreis für den Posten gegen  den Einkaufspreis oder Bewertungskurs
-DocType: Fee Schedule,Fee Schedule,Gebührenordnung
-DocType: Hub Settings,Publish Availability,Verfügbarkeit veröffentlichen
-DocType: Company,Create Chart Of Accounts Based On,Erstellen Sie Konten basierend auf
-apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Kann es nicht in Nicht-Gruppe konvertieren. Untergeordnete Aufgaben sind vorhanden.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Geburtsdatum kann nicht später liegen als heute.
-,Stock Ageing,Lager-Abschreibungen
-apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Student {0} existiert gegen Studienbewerber {1}
-DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Rundungsanpassung (Firmenwährung)
-apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Zeiterfassung
-DocType: Volunteer,Afternoon,Nachmittag
-apps/erpnext/erpnext/controllers/accounts_controller.py +257,{0} '{1}' is disabled,{0} '{1}' ist deaktiviert
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,"Als ""geöffnet"" markieren"
-DocType: Cheque Print Template,Scanned Cheque,Gescannte Scheck
-DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Beim Ausführen von Transaktionen automatisch E-Mails an Kontakte senden.
-DocType: Timesheet,Total Billable Amount,Insgesamt abrechenbare Betrag
-DocType: Customer,Credit Limit and Payment Terms,Kreditlimit und Zahlungsbedingungen
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Position 3
-apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Auftragserfassung
-DocType: Purchase Order,Customer Contact Email,Kontakt-E-Mail des Kunden
-DocType: Warranty Claim,Item and Warranty Details,Einzelheiten Artikel und Garantie
-DocType: Chapter,Chapter Members,Kapitel Mitglieder
-DocType: Sales Team,Contribution (%),Beitrag (%)
-apps/erpnext/erpnext/controllers/accounts_controller.py +101,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Hinweis: Zahlungsbuchung wird nicht erstellt, da kein ""Kassen- oder Bankkonto"" angegeben wurde"
-apps/erpnext/erpnext/projects/doctype/project/project.py +69,Project {0} already exists,Projekt {0} existiert bereits
-DocType: Medical Department,Nursing User,Krankenpfleger
-DocType: Plant Analysis,Plant Analysis Criterias,Kriterien für die Pflanzenanalyse
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Responsibilities,Verantwortung
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Gültigkeitszeitraum dieses Angebots ist beendet.
-DocType: Expense Claim Account,Expense Claim Account,Kostenabrechnung Konto
-DocType: Accounts Settings,Allow Stale Exchange Rates,feste Wechselkurse erlauben
-DocType: Sales Person,Sales Person Name,Name des Vertriebsmitarbeiters
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Bitte mindestens eine Rechnung in die Tabelle eingeben
-apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Benutzer hinzufügen
-DocType: POS Item Group,Item Group,Artikelgruppe
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Student Group: ,Studentengruppe:
-DocType: Item,Safety Stock,Sicherheitsbestand
-DocType: Healthcare Settings,Healthcare Settings,Gesundheitswesen
-apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,Fortschritt-% eines Vorgangs darf nicht größer 100 sein.
-DocType: Stock Reconciliation Item,Before reconciliation,Vor Ausgleich
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},An {0}
-DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Steuern und Gebühren hinzugerechnet (Firmenwährung)
-apps/erpnext/erpnext/stock/doctype/item/item.py +475,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Artikelsteuer Zeile {0} muss ein Konto vom Typ ""Steuer"" oder ""Erträge"" oder ""Aufwendungen"" oder ""Besteuerbar"" haben"
-DocType: Sales Order,Partly Billed,Teilweise abgerechnet
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Artikel {0} muss ein Posten des Anlagevermögens sein
-apps/erpnext/erpnext/stock/doctype/item/item.js +343,Make Variants,Stellen Sie Varianten her
-DocType: Item,Default BOM,Standardstückliste
-DocType: Project,Total Billed Amount (via Sales Invoices),Gesamtabrechnungsbetrag (über Verkaufsrechnungen)
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +113,Debit Note Amount,Lastschriftbetrag
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106,"There are inconsistencies between the rate, no of shares and the amount calculated","Es gibt Unstimmigkeiten zwischen dem Kurs, der Anzahl der Aktien und dem berechneten Betrag"
-apps/erpnext/erpnext/setup/doctype/company/company.js +89,Please re-type company name to confirm,Bitte zum Bestätigen Firmenname erneut eingeben
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +211,Total Outstanding Amt,Offener Gesamtbetrag
-DocType: Journal Entry,Printing Settings,Druckeinstellungen
-DocType: Employee Advance,Advance Account,Vorauskonto
-DocType: Job Offer,Job Offer Terms,Stellenangebot Bedingungen
-DocType: Sales Invoice,Include Payment (POS),(POS) Zahlung einschließen
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Gesamt-Soll muss gleich Gesamt-Haben sein. Die Differenz ist {0}
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Fahrzeugbau
-DocType: Vehicle,Insurance Company,Versicherungsunternehmen
-DocType: Asset Category Account,Fixed Asset Account,Feste Asset-Konto
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,Variable
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Von Lieferschein
-DocType: Chapter,Members,Mitglieder
-DocType: Student,Student Email Address,Studenten E-Mail-Adresse
-DocType: Item,Hub Warehouse,Hublager
-DocType: Assessment Plan,From Time,Von-Zeit
-DocType: Hotel Settings,Hotel Settings,Hoteleinstellungen
-apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Auf Lager:
-DocType: Notification Control,Custom Message,Benutzerdefinierte Mitteilung
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investment-Banking
-DocType: Purchase Invoice,input,Eingang
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Kassen- oder Bankkonto ist zwingend notwendig  um eine Zahlungsbuchung zu erstellen
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Schüleradresse
-DocType: Purchase Invoice,Price List Exchange Rate,Preislisten-Wechselkurs
-apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Die Kontonummer {0} wurde bereits im Konto {1} verwendet.
-DocType: POS Profile,POS Profile Name,POS-Profilname
-DocType: Hotel Room Reservation,Booked,Gebucht
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxLib,CompAuxLib
-DocType: Purchase Invoice Item,Rate,Preis
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Praktikant
-DocType: Delivery Stop,Address Name,Adress-Name
-DocType: Stock Entry,From BOM,Von Stückliste
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639,Splitting {0} units of {1},Aufteilen von {0} Einheiten von {1}
-DocType: Assessment Code,Assessment Code,Beurteilungs-Code
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Grundeinkommen
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Lagertransaktionen vor {0} werden gesperrt
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',"Bitte auf ""Zeitplan generieren"" klicken"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,"Referenznr. ist zwingend erforderlich, wenn Referenz-Tag eingegeben wurde"
-DocType: Bank Reconciliation Detail,Payment Document,Zahlungsbeleg
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Fehler bei der Auswertung der Kriterienformel
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Eintrittsdatum muss nach dem Geburtsdatum liegen
-DocType: Salary Slip,Salary Structure,Gehaltsstruktur
-DocType: Account,Bank,Bank
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Fluggesellschaft
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853,Issue Material,Material ausgeben
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Beim Erstellen von Wiederholungen ist ein Fehler aufgetreten
-DocType: Material Request Item,For Warehouse,Für Lager
-DocType: Employee,Offer Date,Angebotsdatum
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Angebote
-apps/erpnext/erpnext/accounts/page/pos/pos.js +735,You are in offline mode. You will not be able to reload until you have network.,"Sie befinden sich im Offline-Modus. Aktualisieren ist nicht möglich, bis Sie wieder online sind."
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Keine Studentengruppen erstellt.
-DocType: Purchase Invoice Item,Serial No,Seriennummer
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Monatlicher Rückzahlungsbetrag kann nicht größer sein als Darlehensbetrag
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Bitte zuerst die Einzelheiten zur Wartung eingeben
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Row # {0}: Voraussichtlicher Liefertermin kann nicht vor Bestelldatum sein
-DocType: Purchase Invoice,Print Language,Drucksprache
-DocType: Salary Slip,Total Working Hours,Gesamtarbeitszeit
-DocType: Sales Invoice,Customer PO Details,Kundenauftragsdetails
-DocType: Subscription,Next Schedule Date,Nächste Termine Datum
-DocType: Stock Entry,Including items for sub assemblies,Einschließlich der Artikel für Unterbaugruppen
-DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Temporäres Eröffnungskonto
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1962,Enter value must be positive,Geben Sie Wert muss positiv sein
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446,All Territories,Alle Regionen
-DocType: Purchase Invoice,Items,Artikel
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,Student ist bereits eingetragen sind.
-DocType: Fiscal Year,Year Name,Name des Jahrs
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Es gibt mehr Feiertage als Arbeitstage in diesem Monat.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78,PDC/LC Ref,PDC / LC Ref.-Nr.
-DocType: Product Bundle Item,Product Bundle Item,Produkt-Bundle-Artikel
-DocType: Sales Partner,Sales Partner Name,Name des Vertriebspartners
-apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Angebostanfrage
-DocType: Payment Reconciliation,Maximum Invoice Amount,Maximaler Rechnungsbetrag
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Montantdevise,Montantdevise
-apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hämatologie
-DocType: Normal Test Items,Normal Test Items,Normale Testartikel
-DocType: Student Language,Student Language,Student Sprache
-apps/erpnext/erpnext/config/selling.py +23,Customers,Kundschaft
-DocType: Cash Flow Mapping,Is Working Capital,Ist Arbeitskapital
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Bestellung / Quot%
-apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Datensatz Patient Vitals
-DocType: Fee Schedule,Institution,Institution
-DocType: Asset,Partially Depreciated,Teilweise abgeschrieben
-DocType: Issue,Opening Time,Öffnungszeit
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Von- und Bis-Daten erforderlich
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Wertpapier- & Rohstoffbörsen
-apps/erpnext/erpnext/stock/doctype/item/item.py +688,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Standard-Maßeinheit für Variante '{0}' muss dieselbe wie in der Vorlage '{1}' sein
-DocType: Shipping Rule,Calculate Based On,Berechnen auf Grundlage von
-DocType: Delivery Note Item,From Warehouse,Ab Lager
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Keine Mitarbeiter für die genannten Kriterien
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +946,No Items with Bill of Materials to Manufacture,Keine Elemente mit Bill of Materials zu Herstellung
-DocType: Hotel Settings,Default Customer,Standardkunde
-DocType: Assessment Plan,Supervisor Name,Name des Vorgesetzten
-DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Bestätigen Sie nicht, ob der Termin für denselben Tag erstellt wurde"
-DocType: Program Enrollment Course,Program Enrollment Course,Programm Einschreibung Kurs
-DocType: Purchase Taxes and Charges,Valuation and Total,Bewertung und Summe
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Scorecards
-DocType: Tax Rule,Shipping City,Zielstadt der Lieferung
-DocType: Notification Control,Customize the Notification,Mitteilungstext anpassen
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Cash Flow from Operations,Cashflow aus Geschäftstätigkeit
-DocType: Purchase Invoice,Shipping Rule,Versandregel
-DocType: Patient Relation,Spouse,Ehepartner
-DocType: Lab Test Groups,Add Test,Test hinzufügen
-DocType: Manufacturer,Limited to 12 characters,Limitiert auf 12 Zeichen
-DocType: Journal Entry,Print Heading,Druckkopf
-apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Lieferung Trip-Service-Touren zu Kunden.
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Summe kann nicht Null sein
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,"""Tage seit dem letzten Auftrag"" muss größer oder gleich Null sein"
-DocType: Plant Analysis Criteria,Maximum Permissible Value,Maximaler zulässiger Wert
-DocType: Journal Entry Account,Employee Advance,Mitarbeitervorschuss
-DocType: Payroll Entry,Payroll Frequency,Payroll Frequency
-DocType: Lab Test Template,Sensitivity,Empfindlichkeit
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +932,Raw Material,Rohmaterial
-DocType: Leave Application,Follow via Email,Per E-Mail nachverfolgen
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Pflanzen und Maschinen
-DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Steuerbetrag nach Abzug von Rabatt
-DocType: Daily Work Summary Settings,Daily Work Summary Settings,tägliche Arbeitszusammenfassung-Einstellungen
-apps/erpnext/erpnext/controllers/buying_controller.py +457,Please enter Reqd by Date,Bitte geben Sie Requd by Date ein
-DocType: Payment Entry,Internal Transfer,Interner Transfer
-DocType: Asset Maintenance,Maintenance Tasks,Wartungsaufgaben
-apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Entweder Zielstückzahl oder Zielmenge ist zwingend erforderlich
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Posting Date first,Bitte zuerst ein Buchungsdatum auswählen
-apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Eröffnungsdatum sollte vor dem Abschlussdatum liegen
-DocType: Leave Control Panel,Carry Forward,Übertragen
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Kostenstelle mit bestehenden Transaktionen kann nicht in Sachkonto umgewandelt werden
-DocType: Department,Days for which Holidays are blocked for this department.,"Tage, an denen eine Urlaubssperre für diese Abteilung gilt."
-DocType: Crop Cycle,Detected Disease,Erkannte Krankheit
-,Produced,Produziert
-DocType: Item,Item Code for Suppliers,Artikelnummer für Lieferanten
-DocType: Issue,Raised By (Email),Gemeldet von (E-Mail)
-DocType: Training Event,Trainer Name,Trainer-Name
-DocType: Mode of Payment,General,Allgemein
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Letzte Kommunikation
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Abzug nicht möglich, wenn Kategorie ""Wertbestimmtung"" oder ""Wertbestimmung und Summe"" ist"
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Seriennummern sind erforderlich für den Artikel mit Seriennummer {0}
-apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Zahlungen und Rechnungen abgleichen
-DocType: Journal Entry,Bank Entry,Bankbuchung
-DocType: Authorization Rule,Applicable To (Designation),Anwenden auf (Bezeichnung)
-,Profitability Analysis,Wirtschaftlichkeitsanalyse
-DocType: Fees,Student Email,Schüler E-Mail
-DocType: Supplier,Prevent POs,Vermeiden Sie POs
-DocType: Patient,"Allergies, Medical and Surgical History","Allergien, medizinische- und chirurgische Vergangenheit"
-apps/erpnext/erpnext/templates/generators/item.html +77,Add to Cart,In den Warenkorb legen
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Gruppieren nach
-DocType: Guardian,Interests,Interessen
-apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Aktivieren / Deaktivieren der Währungen
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +110,Dr {0} on Half day Leave on {1},Dr {0} am Halbtag Leave am {1}
-DocType: Production Plan,Get Material Request,Get-Material anfordern
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Portoaufwendungen
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Gesamtsumme
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Unterhaltung & Freizeit
-,Item Variant Details,Details der Artikelvariante
-DocType: Quality Inspection,Item Serial No,Artikel-Seriennummer
-apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Erstellen Sie Mitarbeiterdaten
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Summe Anwesend
-apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Buchhaltungsauszüge
-DocType: Drug Prescription,Hour,Stunde
-DocType: Restaurant Order Entry,Last Sales Invoice,Letzte Verkaufsrechnung
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +789,Please select Qty against item {0},Bitte wählen Sie Menge für Artikel {0}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,"""Neue Seriennummer"" kann keine Lagerangabe enthalten. Lagerangaben müssen durch eine Lagerbuchung oder einen Kaufbeleg erstellt werden"
-DocType: Lead,Lead Type,Lead-Typ
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,You are not authorized to approve leaves on Block Dates,"Sie sind nicht berechtigt, Urlaube für geblockte Termine zu genehmigen"
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +392,All these items have already been invoiced,Alle diese Artikel sind bereits in Rechnung gestellt
-DocType: Company,Monthly Sales Target,Monatliches Verkaufsziel
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Kann von {0} genehmigt werden
-DocType: Hotel Room,Hotel Room Type,Hotel Zimmertyp
-DocType: Item,Default Material Request Type,Standard-Material anfordern Typ
-DocType: Supplier Scorecard,Evaluation Period,Bewertungszeitraum
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Unbekannt
-DocType: Shipping Rule,Shipping Rule Conditions,Versandbedingungen
-DocType: Purchase Invoice,Export Type,Exporttyp
-DocType: Salary Slip Loan,Salary Slip Loan,Gehalts-Slip-Darlehen
-DocType: BOM Update Tool,The new BOM after replacement,Die neue Stückliste nach dem Austausch
-,Point of Sale,Verkaufsstelle
-DocType: Payment Entry,Received Amount,erhaltenen Betrag
-DocType: Patient,Widow,Witwe
-DocType: GST Settings,GSTIN Email Sent On,GSTIN E-Mail gesendet
-DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop von Guardian
-DocType: Crop,Planting UOM,UOM anlegen
-DocType: Account,Tax,Steuer
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,nicht markiert
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Rechnungszusammenfassung öffnen
-DocType: Education Settings,Education Manager,Ausbildungsleiter
-DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Die minimale Länge zwischen jeder Pflanze im Feld für optimales Wachstum
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",Chargenartikel {0} kann nicht durch Lagerabgleich aktualisiert werden. Bitte stattdessen einen Lagereintrag verwenden.
-DocType: Quality Inspection,Report Date,Berichtsdatum
-DocType: Student,Middle Name,Zweiter Vorname
-DocType: C-Form,Invoices,Eingangsrechnungen
-DocType: Water Analysis,Type of Sample,Art der Probe
-DocType: Batch,Source Document Name,Quelldokumentname
-DocType: Production Plan,Get Raw Materials For Production,Holen Sie sich Rohstoffe für die Produktion
-DocType: Job Opening,Job Title,Stellenbezeichnung
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
-					have been quoted. Updating the RFQ quote status.","{0} zeigt an, dass {1} kein Angebot anbietet, aber alle Items wurden zitiert. Aktualisieren des RFQ-Zitatstatus."
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1012,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximum Samples - {0} wurden bereits für Batch {1} und Artikel {2} in Batch {3} gespeichert.
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Type in Buying Settings.,Bitte legen Sie den Liefertyp in den Kaufeinstellungen fest.
-DocType: Manufacturing Settings,Update BOM Cost Automatically,Aktualisieren Sie die Stücklistenkosten automatisch
-DocType: Lab Test,Test Name,Testname
-apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Benutzer erstellen
-apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Gramm
-DocType: Supplier Scorecard,Per Month,Pro Monat
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +433,Quantity to Manufacture must be greater than 0.,Menge Herstellung muss größer als 0 sein.
-DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Berechnen Sie den anteiligen Abschreibungsplan basierend auf dem Geschäftsjahr
-apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Besuchsbericht für Wartungsauftrag
-DocType: Stock Entry,Update Rate and Availability,Preis und Verfügbarkeit aktualisieren
-DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"Zur bestellten Menge zusätzlich zulässiger Prozentsatz, der angenommen oder geliefert werden kann. Beispiel: Wenn 100 Einheiten bestellt wurden, und die erlaubte Spanne 10 % beträgt, dann können 110 Einheiten angenommen werden."
-DocType: POS Customer Group,Customer Group,Kundengruppe
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),Neue Batch-ID (optional)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Aufwandskonto ist zwingend für Artikel {0}
-DocType: BOM,Website Description,Webseiten-Beschreibung
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47,Net Change in Equity,Nettoveränderung des Eigenkapitals
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +220,Please cancel Purchase Invoice {0} first,Bitte stornieren Einkaufsrechnung {0} zuerst
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-Mail-Adresse muss eindeutig sein, diese wird bereits für {0} verwendet"
-DocType: Serial No,AMC Expiry Date,Verfalldatum des jährlichen Wartungsvertrags
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +871,Receipt,Kaufbeleg
-,Sales Register,Übersicht über den Umsatz
-DocType: Daily Work Summary Group,Send Emails At,Die E-Mails senden um
-DocType: Quotation,Quotation Lost Reason,Grund für verlorenes Angebotes
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Transaction reference no {0} dated {1},Transaktion Referenznummer {0} vom {1}
-apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Es gibt nichts zu bearbeiten.
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Zusammenfassung für diesen Monat und anstehende Aktivitäten
-apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Fügen Sie, neben Ihnen selbst, weitere Benutzer zu Ihrer Organisation hinzu."
-DocType: Customer Group,Customer Group Name,Kundengruppenname
-apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Noch keine Kunden!
-apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Geldflussrechnung
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +472,No material request created,Es wurde keine Materialanforderung erstellt
-apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Darlehensbetrag darf nicht höher als der Maximalbetrag {0} sein
-apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Lizenz
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491,Please remove this Invoice {0} from C-Form {1},Bitte diese Rechnung {0} vom Kontaktformular {1} entfernen
-DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Bitte auf ""Übertragen"" klicken, wenn auch die Abwesenheitskonten des vorangegangenen Geschäftsjahrs in dieses Geschäftsjahr einbezogen werden sollen"
-DocType: GL Entry,Against Voucher Type,Gegenbeleg-Art
-DocType: Physician,Phone (R),Telefon (R)
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Zeitschlitze hinzugefügt
-DocType: Item,Attributes,Attribute
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Schablone aktivieren
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,Bitte Abschreibungskonto eingeben
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Letztes Bestelldatum
-DocType: Patient,B Negative,B Negativ
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Der Wartungsstatus muss abgebrochen oder zum Senden abgeschlossen werden
-DocType: Hotel Room,Hotel Room,Hotelzimmer
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Konto {0} gehört nicht zu Firma {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884,Serial Numbers in row {0} does not match with Delivery Note,Seriennummern in Zeile {0} stimmt nicht mit der Lieferschein überein
-DocType: Student,Guardian Details,Wächter-Details
-DocType: C-Form,C-Form,Kontakt-Formular
-apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Anwesenheit für mehrere Mitarbeiter markieren
-DocType: Agriculture Task,Start Day,Starttag
-DocType: Vehicle,Chassis No,Fahrwerksnummer
-DocType: Payment Request,Initiated,Initiiert
-DocType: Production Order,Planned Start Date,Geplanter Starttermin
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613,Please select a BOM,Bitte wählen Sie eine Stückliste
-DocType: Purchase Invoice,Availed ITC Integrated Tax,Erhaltene ITC Integrierte Steuer
-DocType: Serial No,Creation Document Type,Belegerstellungs-Typ
-DocType: Project Task,View Timesheet,Arbeitszeittabelle anzeigen
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Enddatum muss größer sein als Startdatum
-DocType: Leave Type,Is Encash,Ist Inkasso
-DocType: Leave Allocation,New Leaves Allocated,Neue Urlaubszuordnung
-apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Projektbezogene Daten sind für das Angebot nicht verfügbar
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Endet am
-DocType: Project,Expected End Date,Voraussichtliches Enddatum
-DocType: Budget Account,Budget Amount,Budgetbetrag
-DocType: Donor,Donor Name,Name des Spenders
-DocType: Appraisal Template,Appraisal Template Title,Bezeichnung der Bewertungsvorlage
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},"Mitarbeiter Von Datum {0} für {1} kann nicht sein, bevor Mitarbeiter-Beitritt Datum {2}"
-apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Werbung
-DocType: Patient,Alcohol Current Use,Aktueller Alkoholkonsum
-DocType: Student Admission Program,Student Admission Program,Studentenzulassungsprogramm
-DocType: Payment Entry,Account Paid To,Eingangskonto
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Übergeordneter Artikel {0} darf kein Lagerartikel sein
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +461,"Could not submit any Salary Slip <br>\
-			Possible reasons: <br>\
-			1. Net pay is less than 0. <br>\
-			2. Company Email Address specified in employee master is not valid. <br>",Es konnte kein Gehaltschein eingereicht werden <br> \ Mögliche Gründe: <br> \ 1. Nettogehalt ist kleiner als 0. <br> \ 2. Die im Mitarbeiterstamm angegebene Firmen-E-Mail-Adresse ist nicht gültig. <br>
-apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Alle Produkte oder Dienstleistungen
-DocType: Expense Claim,More Details,Weitere Details
-DocType: Supplier Quotation,Supplier Address,Lieferantenadresse
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Budget für Konto {1} gegen {2} {3} ist {4}. Es wird durch {5} überschritten.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695,Row {0}# Account must be of type 'Fixed Asset',"Konto in Zeile {0} muss vom Typ ""Anlagevermögen"" sein"
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Ausgabe-Menge
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,und unchcked Deaktiviert in der
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Serie ist zwingend erforderlich
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Finanzdienstleistungen
-DocType: Student Sibling,Student ID,Studenten ID
-apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Arten von Aktivitäten für Time Logs
-DocType: Opening Invoice Creation Tool,Sales,Vertrieb
-DocType: Stock Entry Detail,Basic Amount,Grundbetrag
-DocType: Training Event,Exam,Prüfung
-DocType: Complaint,Complaint,Beschwerde
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462,Warehouse required for stock Item {0},Angabe des Lagers ist für den Lagerartikel {0} erforderlich
-DocType: Leave Allocation,Unused leaves,Ungenutzter Urlaub
-DocType: Patient,Alcohol Past Use,Vergangener Alkoholkonsum
-DocType: Fertilizer Content,Fertilizer Content,Dünger Inhalt
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187,Cr,Haben
-DocType: Tax Rule,Billing State,Verwaltungsbezirk laut Rechnungsadresse
-DocType: Share Transfer,Transfer,Übertragung
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917,Fetch exploded BOM (including sub-assemblies),Abruf der aufgelösten Stückliste (einschließlich der Unterbaugruppen)
-DocType: Authorization Rule,Applicable To (Employee),Anwenden auf (Mitarbeiter)
-apps/erpnext/erpnext/controllers/accounts_controller.py +136,Due Date is mandatory,Fälligkeitsdatum wird zwingend vorausgesetzt
-apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Schrittweite für Attribut {0} kann nicht 0 sein
-apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Zimmer gebucht
-DocType: Journal Entry,Pay To / Recd From,Zahlen an/Erhalten von
-DocType: Naming Series,Setup Series,Serie bearbeiten
-DocType: Payment Reconciliation,To Invoice Date,Um Datum Rechnung
-DocType: Shareholder,Contact HTML,Kontakt-HTML
-apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Anmeldegebühr kann nicht Null sein
-DocType: Disease,Treatment Period,Behandlungszeitraum
-apps/erpnext/erpnext/education/api.py +338,Result already Submitted,Ergebnis bereits übergeben
-apps/erpnext/erpnext/controllers/buying_controller.py +169,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Das reservierte Warehouse ist für das Element {0} in den bereitgestellten Rohmaterialien obligatorisch
-,Inactive Customers,Inaktive Kunden
-DocType: Student Admission Program,Maximum Age,Maximales Alter
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,"Bitte warten Sie 3 Tage, bevor Sie die Erinnerung erneut senden."
-DocType: Landed Cost Voucher,LCV,LCV
-DocType: Landed Cost Voucher,Purchase Receipts,Kaufbelege
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Wie wird die Preisregel angewandt?
-DocType: Stock Entry,Delivery Note No,Lieferschein-Nummer
-DocType: Cheque Print Template,Message to show,Nachricht anzeigen
-apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Einzelhandel
-DocType: Student Attendance,Absent,Abwesend
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Produkt-Bundle
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Der Score konnte nicht gefunden werden bei {0}. Sie müssen stehende Noten von 0 bis 100 haben
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Zeile {0}: Ungültige Referenz {1}
-DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Vorlage für Einkaufssteuern und -abgaben
-DocType: Timesheet,TS-,ZB-
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Debit- oder Kreditbetrag ist für {2} erforderlich
-DocType: GL Entry,Remarks,Bemerkungen
-DocType: Hotel Room Amenity,Hotel Room Amenity,Zimmerausstattung
-DocType: Payment Entry,Account Paid From,Ausgangskonto
-DocType: Purchase Order Item Supplied,Raw Material Item Code,Rohmaterial-Artikelnummer
-DocType: Task,Parent Task,Übergeordnete Aufgabe
-DocType: Journal Entry,Write Off Based On,Abschreibung basierend auf
-apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,neue Verkaufsanfrage
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Drucken und Papierwaren
-DocType: Stock Settings,Show Barcode Field,Anzeigen Barcode-Feld
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809,Send Supplier Emails,Lieferantenemails senden
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +97,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Gehalt bereits verarbeitet für den Zeitraum zwischen {0} und {1}, freiBewerbungsFrist kann nicht zwischen diesem Datum liegen."
-DocType: Chapter Member,Leave Reason,Verlasse die Vernunft
-DocType: Guardian Interest,Guardian Interest,Wächter Interesse
-DocType: Volunteer,Availability,Verfügbarkeit
-apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Standardwerte für POS-Rechnungen einrichten
-apps/erpnext/erpnext/config/hr.py +182,Training,Ausbildung
-DocType: Timesheet,Employee Detail,Mitarbeiterdetails
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 E-Mail-ID
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Nächster Termin des Tages und wiederholen Sie auf Tag des Monats müssen gleich sein
-DocType: Lab Prescription,Test Code,Testcode
-apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Einstellungen für die Internet-Homepage
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs sind nicht zulässig für {0} aufgrund einer Scorecard von {1}
-DocType: Job Offer,Awaiting Response,Warte auf Antwort
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Über
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1462,Total Amount {0},Gesamtbetrag {0}
-apps/erpnext/erpnext/controllers/item_variant.py +303,Invalid attribute {0} {1},Ungültiges Attribut {0} {1}
-DocType: Supplier,Mention if non-standard payable account,"Erwähnen Sie, wenn nicht standardmäßig zahlbares Konto"
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25,Please select the assessment group other than 'All Assessment Groups',Bitte wählen Sie die Bewertungsgruppe außer &quot;All Assessment Groups&quot;
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Zeile {0}: Kostenstelle ist für einen Eintrag {1} erforderlich
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureDate,EcritureDatum
-DocType: Training Event Employee,Optional,Optional
-DocType: Salary Slip,Earning & Deduction,Einkünfte & Abzüge
-DocType: Agriculture Analysis Criteria,Water Analysis,Wasseranalyse
-DocType: Chapter,Region,Region
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,"Optional. Diese Einstellung wird verwendet, um in verschiedenen Transaktionen zu filtern."
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110,Negative Valuation Rate is not allowed,Negative Bewertung ist nicht erlaubt
-DocType: Holiday List,Weekly Off,Wöchentlich frei
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Reload verknüpfte Analyse
-DocType: Fiscal Year,"For e.g. 2012, 2012-13","Für z. B. 2012, 2012-13"
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Vorläufiger Gewinn / Verlust (Haben)
-DocType: Sales Invoice,Return Against Sales Invoice,Zurück zur Kundenrechnung
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Position 5
-DocType: Serial No,Creation Time,Zeitpunkt der Erstellung
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Gesamtumsatz
-DocType: Patient,Other Risk Factors,Andere Risikofaktoren
-DocType: Sales Invoice,Product Bundle Help,Produkt-Bundle-Hilfe
-,Monthly Attendance Sheet,Monatliche Anwesenheitsliste
-DocType: Production Order Item,Production Order Item,Fertigungsauftrags-Artikel
-apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Kein Datensatz gefunden
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Kosten für Ausschuss-Entsorgung
-apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Kostenstelle ist zwingend erfoderlich für Artikel {2}
-DocType: Vehicle,Policy No,Politik keine
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686,Get Items from Product Bundle,Artikel aus dem Produkt-Bundle übernehmen
-DocType: Asset,Straight Line,Gerade Linie
-DocType: Project User,Project User,Projektarbeit Benutzer
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,Split,Teilt
-DocType: GL Entry,Is Advance,Ist Vorkasse
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,"""Anwesenheit ab Datum"" und ""Anwesenheit bis Datum"" sind zwingend"
-apps/erpnext/erpnext/controllers/buying_controller.py +156,Please enter 'Is Subcontracted' as Yes or No,"Bitte bei ""Untervergeben"" JA oder NEIN eingeben"
-DocType: Item,Default Purchase Unit of Measure,Default Purchase Maßeinheit
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Letztes Kommunikationstag
-DocType: Sales Team,Contact No.,Kontakt-Nr.
-DocType: Bank Reconciliation,Payment Entries,Zahlungs Einträge
-DocType: Land Unit,Land Unit Details,Landeinheit Details
-DocType: Land Unit,Latitude,Breite
-DocType: Production Order,Scrap Warehouse,Ausschusslager
-DocType: Production Order,Check if material transfer entry is not required,"Prüfen Sie, ob keine Materialübertragung erforderlich ist"
-DocType: Program Enrollment Tool,Get Students From,Holen Studenten aus
-apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,Veröffentlichen Sie Artikel auf der Website
-apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Gruppieren Sie Ihre Schüler in den Reihen
-DocType: Authorization Rule,Authorization Rule,Autorisierungsregel
-DocType: POS Profile,Offline POS Section,Offline-POS-Bereich
-DocType: Sales Invoice,Terms and Conditions Details,Allgemeine Geschäftsbedingungen Details
-apps/erpnext/erpnext/templates/generators/item.html +100,Specifications,Technische Daten
-DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Vorlage für Verkaufssteuern und -abgaben
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Insgesamt (Credit)
-DocType: Repayment Schedule,Payment Date,Zahlungsdatum
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Neue Batch-Menge
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Kleidung & Zubehör
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,"Die gewichtete Notenfunktion konnte nicht gelöst werden. Stellen Sie sicher, dass die Formel gültig ist."
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Nummer der Bestellung
-DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML/Banner, das oben auf der Produktliste angezeigt wird."
-DocType: Shipping Rule,Specify conditions to calculate shipping amount,Bedingungen zur Berechnung der Versandkosten angeben
-DocType: Program Enrollment,Institute's Bus,Instituts-Bus
-DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Rolle darf Konten sperren und gesperrte Buchungen bearbeiten
-DocType: Supplier Scorecard Scoring Variable,Path,Pfad
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,"Kostenstelle kann nicht in ein Kontenblatt umgewandelt werden, da sie Unterknoten hat"
-DocType: Production Plan,Total Planned Qty,Geplante Gesamtmenge
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,Opening Value,Öffnungswert
-DocType: Salary Detail,Formula,Formel
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serien #
-DocType: Lab Test Template,Lab Test Template,Labortestvorlage
-apps/erpnext/erpnext/setup/doctype/company/company.py +181,Sales Account,Verkaufskonto
-DocType: Purchase Invoice Item,Total Weight,Gesamtgewicht
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Provision auf den Umsatz
-DocType: Job Offer Term,Value / Description,Wert / Beschreibung
-apps/erpnext/erpnext/controllers/accounts_controller.py +629,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Vermögens {1} kann nicht vorgelegt werden, es ist bereits {2}"
-DocType: Tax Rule,Billing Country,Land laut Rechnungsadresse
-DocType: Purchase Order Item,Expected Delivery Date,Geplanter Liefertermin
-DocType: Restaurant Order Entry,Restaurant Order Entry,Restaurantbestellung
-apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Soll und Haben nicht gleich für {0} #{1}. Unterschied ist {2}.
-DocType: Asset Maintenance Task,Assign To Name,Zu Name zuweisen
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Bewirtungskosten
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98,Make Material Request,Materialanforderung anlegen
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Offene-Posten {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Ausgangsrechnung {0} muss vor Stornierung dieses Kundenauftrags abgebrochen werden
-DocType: Consultation,Age,Alter
-DocType: Sales Invoice Timesheet,Billing Amount,Rechnungsbetrag
-DocType: Cash Flow Mapping,Select Maximum Of 1,Wählen Sie Maximal 1 aus
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ungültzige Anzahl für Artikel {0} angegeben. Anzahl sollte größer als 0 sein.
-DocType: Company,Default Employee Advance Account,Standard Mitarbeiter Advance Account
-apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Urlaubsanträge
-apps/erpnext/erpnext/accounts/doctype/account/account.py +164,Account with existing transaction can not be deleted,Ein Konto mit bestehenden Transaktionen kann nicht gelöscht werden
-DocType: Vehicle,Last Carbon Check,Last Kohlenstoff prüfen
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Rechtskosten
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Bitte wählen Sie die Menge aus
-apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Machen Sie offene Rechnungen für Verkauf und Kauf
-DocType: Purchase Invoice,Posting Time,Buchungszeit
-DocType: Timesheet,% Amount Billed,% des Betrages berechnet
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +130,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.","""Zeit pro Termin"" wurde für Dr. {0} nicht festgelegt. Fügen Sie ihn dem Arzt-Master hinzu."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Telefonkosten
-DocType: Sales Partner,Logo,Logo
-DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Hier aktivieren, wenn der Benutzer gezwungen sein soll, vor dem Speichern eine Serie auszuwählen. Bei Aktivierung gibt es keine Standardvorgabe."
-apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Serial No {0},Kein Artikel mit Seriennummer {0}
-DocType: Email Digest,Open Notifications,Offene Benachrichtigungen
-DocType: Payment Entry,Difference Amount (Company Currency),Differenzbetrag (Gesellschaft Währung)
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Direkte Aufwendungen
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Neuer Kundenumsatz
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Reisekosten
-DocType: Maintenance Visit,Breakdown,Ausfall
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Benutzerdefiniertes Feld Abonnement im Doctype {0} hinzufügen
-apps/erpnext/erpnext/controllers/accounts_controller.py +813,Account: {0} with currency: {1} can not be selected,Konto: {0} mit Währung: {1} kann nicht ausgewählt werden
-DocType: Purchase Receipt Item,Sample Quantity,Beispielmenge
-DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Aktualisieren Sie die Stücklistenkosten automatisch über den Scheduler, basierend auf dem aktuellen Bewertungspreis / Preisliste / letzter Kaufpreis der Rohstoffe."
-DocType: Bank Reconciliation Detail,Cheque Date,Scheckdatum
-apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Über-Konto {1} gehört nicht zur Firma: {2}
-apps/erpnext/erpnext/setup/doctype/company/company.js +106,Successfully deleted all transactions related to this company!,Alle Transaktionen dieser Firma wurden erfolgreich gelöscht!
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Zum
-DocType: Appraisal,HR,HR
-DocType: Program Enrollment,Enrollment Date,Enrollment Datum
-DocType: Healthcare Settings,Out Patient SMS Alerts,SMS-Benachrichtungen für ambulante Patienten
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Probezeit
-apps/erpnext/erpnext/config/hr.py +115,Salary Components,Gehaltskomponenten
-DocType: Program Enrollment Tool,New Academic Year,Neues Studienjahr
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811,Return / Credit Note,Return / Gutschrift
-DocType: Stock Settings,Auto insert Price List rate if missing,"Preisliste automatisch einfügen, wenn sie fehlt"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +112,Total Paid Amount,Summe gezahlte Beträge
-DocType: GST Settings,B2C Limit,B2C-Grenze
-DocType: Production Order Item,Transferred Qty,Übergebene Menge
-apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigieren
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Planung
-DocType: Share Balance,Issued,Ausgestellt
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Studentische Tätigkeit
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Lieferanten-ID
-DocType: Payment Request,Payment Gateway Details,Payment Gateway-Details
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +277,Quantity should be greater than 0,Menge sollte größer 0 sein
-DocType: Journal Entry,Cash Entry,Kassenbuchung
-DocType: Production Plan,Get Items For Production Order,Holen Sie Artikel für Produktionsauftrag
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Kindknoten können nur unter Gruppenknoten erstellt werden.
-DocType: Leave Application,Half Day Date,Halbtagesdatum
-DocType: Academic Year,Academic Year Name,Schuljahr-Bezeichnung
-DocType: Sales Partner,Contact Desc,Kontakt-Beschr.
-apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Grund für Beurlaubung, wie Erholung, krank usw."
-DocType: Email Digest,Send regular summary reports via Email.,Regelmäßig zusammenfassende Berichte per E-Mail senden.
-DocType: Payment Entry,PE-,PE-
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +280,Please set default account in Expense Claim Type {0},Bitte setzen Sie Standardkonto in Kostenabrechnung Typ {0}
-DocType: Assessment Result,Student Name,Name des Studenten
-DocType: Brand,Item Manager,Artikel-Manager
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Payroll Kreditoren
-DocType: Buying Settings,Default Supplier Type,Standardlieferantentyp
-DocType: Plant Analysis,Collection Datetime,Sammlung Datetime
-DocType: Production Order,Total Operating Cost,Gesamtbetriebskosten
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Hinweis: Artikel {0} mehrfach eingegeben
-apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Alle Kontakte
-apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Firmenkürzel
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Benutzer {0} existiert nicht
-DocType: Payment Term,Day(s) after invoice date,Tag (e) nach Rechnungsdatum
-DocType: Payment Schedule,Payment Schedule,Zahlungsplan
-DocType: Subscription,SUB-,SUB-
-DocType: Item Attribute Value,Abbreviation,Abkürzung
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Zahlung existiert bereits
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Keine Berechtigung da {0} die Höchstgrenzen überschreitet
-apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Stammdaten zur Gehaltsvorlage
-apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Pathologie
-DocType: Restaurant Order Entry,Restaurant Table,Restaurant-Tisch
-DocType: Hotel Room,Hotel Manager,Hotelmanager
-DocType: Leave Type,Max Days Leave Allowed,Maximal zulässige Urlaubstage
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Steuerregel für Einkaufswagen einstellen
-DocType: Purchase Invoice,Taxes and Charges Added,Steuern und Gebühren hinzugefügt
-,Sales Funnel,Verkaufstrichter
-apps/erpnext/erpnext/setup/doctype/company/company.py +49,Abbreviation is mandatory,Abkürzung ist zwingend erforderlich
-DocType: Project,Task Progress,Vorgangsentwicklung
-apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Einkaufswagen
-,Qty to Transfer,Zu versendende Menge
-apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Angebote an Leads oder Kunden
-DocType: Stock Settings,Role Allowed to edit frozen stock,Rolle darf gesperrten Bestand bearbeiten
-,Territory Target Variance Item Group-Wise,Artikelgruppenbezogene regionale Zielabweichung
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Alle Kundengruppen
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,Monatlich akkumuliert
-apps/erpnext/erpnext/controllers/accounts_controller.py +774,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} ist zwingend erforderlich. Möglicherweise wurde der Datensatz für die Währungsumrechung für {1} bis {2} nicht erstellt.
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +43,Tax Template is mandatory.,Steuer-Vorlage ist erforderlich.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Konto {0}: Hauptkonto {1} existiert nicht
-DocType: Purchase Invoice Item,Price List Rate (Company Currency),Preisliste (Firmenwährung)
-DocType: Products Settings,Products Settings,Produkte Einstellungen
-,Item Price Stock,Artikel Preis Lagerbestand
-DocType: Lab Prescription,Test Created,Test erstellt
-DocType: Healthcare Settings,Custom Signature in Print,Kundenspezifische Unterschrift im Druck
-DocType: Account,Temporary,Temporär
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +102,Customer LPO No.,Kunden-LPO-Nr.
-DocType: Program,Courses,Kurse
-DocType: Monthly Distribution Percentage,Percentage Allocation,Prozentuale Aufteilung
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Sekretärin
-DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Wenn deaktivieren, wird &quot;in den Wörtern&quot; Feld nicht in einer Transaktion sichtbar sein"
-DocType: Serial No,Distinct unit of an Item,Eindeutige Einheit eines Artikels
-DocType: Supplier Scorecard Criteria,Criteria Name,Kriterien Name
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295,Please set Company,Bitte setzen Unternehmen
-DocType: Pricing Rule,Buying,Einkauf
-apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Krankheiten und Dünger
-DocType: HR Settings,Employee Records to be created by,Mitarbeiter-Datensätze werden erstellt nach
-DocType: Patient,AB Negative,AB -
-DocType: Sample Collection,SMPL-,SMPL-
-DocType: POS Profile,Apply Discount On,Rabatt anwenden auf
-DocType: Member,Membership Type,Art der Mitgliedschaft
-,Reqd By Date,Benötigt nach Datum
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Gläubiger
-DocType: Assessment Plan,Assessment Name,Name der Beurteilung
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +88,Show PDC in Print,Zeige PDC im Druck
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Zeile # {0}: Seriennummer ist zwingend erforderlich
-DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Artikelbezogene Steuer-Details
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Job Offer,Jobangebot
-apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Abkürzung des Institutes
-,Item-wise Price List Rate,Artikelbezogene Preisliste
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1073,Supplier Quotation,Lieferantenangebot
-DocType: Quotation,In Words will be visible once you save the Quotation.,"""In Worten"" wird sichtbar, sobald Sie das Angebot speichern."
-apps/erpnext/erpnext/utilities/transaction_base.py +160,Quantity ({0}) cannot be a fraction in row {1},Menge ({0}) kann in Zeile {1} keine Teilmenge sein
-DocType: Consultation,C-,C-
-DocType: Attendance,ATT-,ATT-
-apps/erpnext/erpnext/stock/doctype/item/item.py +491,Barcode {0} already used in Item {1},Barcode {0} wird bereits für Artikel {1} verwendet
-apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Regeln für das Hinzufügen von Versandkosten.
-DocType: Hotel Room,Extra Bed Capacity,Zusatzbett Kapazität
-DocType: Item,Opening Stock,Anfangsbestand
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Kunde ist verpflichtet
-DocType: Lab Test,Result Date,Ergebnis Datum
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77,PDC/LC Date,PDC / LC Datum
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,"{0} ist zwingend für ""Zurück"""
-DocType: Purchase Order,To Receive,Um zu empfangen
-apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,nutzer@kundendomain.tld
-DocType: Asset,Asset Owner,Eigentümer der Anlage
-DocType: Employee,Personal Email,Persönliche E-Mail
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Gesamtabweichung
-DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Wenn aktiviert, bucht das System Bestandsbuchungen automatisch."
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Maklerprovision
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +196,Attendance for employee {0} is already marked for this day,Die Teilnahme für Mitarbeiter {0} ist bereits für diesen Tag markiert
-DocType: Production Order Operation,"in Minutes
-Updated via 'Time Log'","""In Minuten"" über 'Zeitprotokoll' aktualisiert"
-DocType: Customer,From Lead,Von Lead
-apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Für die Produktion freigegebene Bestellungen
-apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Geschäftsjahr auswählen ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567,POS Profile required to make POS Entry,"Verkaufsstellen-Profil benötigt, um Verkaufsstellen-Buchung zu erstellen"
-DocType: Program Enrollment Tool,Enroll Students,einschreiben Studenten
-DocType: Lab Test,Approved Date,Genehmigter Termin
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standard-Vertrieb
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +152,Atleast one warehouse is mandatory,Mindestens ein Lager ist zwingend erforderlich
-DocType: Serial No,Out of Warranty,Außerhalb der Garantie
-DocType: BOM Update Tool,Replace,Ersetzen
-apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Keine Produkte gefunden
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} zu Verkaufsrechnung {1}
-DocType: Antibiotic,Laboratory User,Laborbenutzer
-DocType: Sales Invoice,SINV-,SINV-
-DocType: Request for Quotation Item,Project Name,Projektname
-DocType: Customer,Mention if non-standard receivable account,"Vermerken, wenn es sich um kein Standard-Forderungskonto handelt"
-DocType: Journal Entry Account,If Income or Expense,Wenn Ertrag oder Aufwand
-DocType: Production Order,Required Items,Erforderliche Elemente
-DocType: Stock Ledger Entry,Stock Value Difference,Lagerwert-Differenz
-apps/erpnext/erpnext/config/learn.py +229,Human Resource,Personal
-DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Zahlung zum Zahlungsabgleich
-DocType: Disease,Treatment Task,Behandlungsaufgabe
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Steuerguthaben
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +653,Production Order has been {0},Fertigungsauftrag wurde {0}
-DocType: BOM Item,BOM No,Stücklisten-Nr.
-DocType: Instructor,INS/,INS /
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,Buchungssatz {0} gehört nicht zu Konto {1} oder ist bereits mit einem anderen Beleg abgeglichen
-DocType: Item,Moving Average,Gleitender Durchschnitt
-DocType: BOM Update Tool,The BOM which will be replaced,"Die Stückliste (BOM), wird ersetzt."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,Elektronische Ausrüstungen
-DocType: Asset,Maintenance Required,Wartung erforderlich
-DocType: Account,Debit,Soll
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Abwesenheiten müssen ein Vielfaches von 0,5 sein"
-DocType: Production Order,Operation Cost,Kosten eines Arbeitsgangs
-apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Anwesenheiten aus einer CSV-Datei hochladen
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Offener Betrag
-DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Ziele artikelgruppenbezogen für diesen Vertriebsmitarbeiter festlegen.
-DocType: Stock Settings,Freeze Stocks Older Than [Days],Bestände älter als [Tage] sperren
-apps/erpnext/erpnext/controllers/accounts_controller.py +599,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Vermögens ist obligatorisch für Anlage Kauf / Verkauf
-DocType: Asset Maintenance Team,Maintenance Team Name,Name des Wartungsteams
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Wenn zwei oder mehrere Preisregeln basierend auf den oben genannten Bedingungen gefunden werden, wird eine Vorrangregelung angewandt. Priorität ist eine Zahl zwischen 0 und 20, wobei der Standardwert Null (leer) ist. Die höhere Zahl hat  Vorrang, wenn es mehrere Preisregeln zu den gleichen Bedingungen gibt."
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,"Der Kunde ist obligatorisch, wenn &quot;Verkaufschance&quot; als Kunde ausgewählt wurde"
-apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Geschäftsjahr: {0} existiert nicht
-DocType: Currency Exchange,To Currency,In Währung
-DocType: Leave Block List,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."
-apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Arten der Aufwandsabrechnung
-apps/erpnext/erpnext/controllers/selling_controller.py +147,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Der Verkaufspreis für Artikel {0} ist niedriger als {1}. Der Verkaufspreis sollte wenigstens {2} sein.
-DocType: Item,Taxes,Steuern
-DocType: Purchase Invoice,capital goods,Kapitalgüter
-DocType: Purchase Invoice Item,Weight Per Unit,Gewicht pro Einheit
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Bezahlt und nicht ausgeliefert
-DocType: Project,Default Cost Center,Standardkostenstelle
-DocType: Bank Guarantee,End Date,Enddatum
-apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Lagerbuchungen
-DocType: Budget,Budget Accounts,Budget Konten
-DocType: Employee,Internal Work History,Interne Arbeits-Historie
-DocType: Depreciation Schedule,Accumulated Depreciation Amount,Aufgelaufener Abschreibungsbetrag
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Kapitalbeteiligungsgesellschaft
-DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Supplier Scorecard Variable
-DocType: Employee Loan,Fully Disbursed,in voller Höhe ausgezahlt
-DocType: Maintenance Visit,Customer Feedback,Kundenrückmeldung
-DocType: Account,Expense,Kosten
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54,Score cannot be greater than Maximum Score,Score kann nicht größer sein als maximale Punktzahl
-apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Kunden und Lieferanten
-DocType: Item Attribute,From Range,Von-Bereich
-DocType: BOM,Set rate of sub-assembly item based on BOM,Setzen Sie die Menge der Unterbaugruppe auf der Grundlage der Stückliste
-DocType: Hotel Room Reservation,Invoiced,In Rechnung gestellt
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},Syntaxfehler in Formel oder Bedingung: {0}
-DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,tägliche Arbeitszusammenfassung-Einstellungen Ihrer Firma
-apps/erpnext/erpnext/stock/utils.py +125,Item {0} ignored since it is not a stock item,"Artikel {0} ignoriert, da es sich nicht um einen Lagerartikel handelt"
-DocType: Appraisal,APRSL,APRSL
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Diesen Fertigungsauftrag zur Weiterverarbeitung buchen.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Um Preisregeln in einer bestimmten Transaktion nicht zu verwenden, sollten alle geltenden Preisregeln deaktiviert sein."
-DocType: Payment Term,Day(s) after the end of the invoice month,Tag (e) nach dem Ende des Rechnungsmonats
-DocType: Assessment Group,Parent Assessment Group,Übergeordnete Bewertungsgruppe
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Arbeitsplätze
-,Sales Order Trends,Trendanalyse Kundenaufträge
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,The 'From Package No.' field must neither be empty nor it's value less than 1.,Die &#39;Von Paketnummer&#39; Das Feld darf weder leer sein noch einen Wert kleiner als 1 haben.
-DocType: Employee,Held On,Festgehalten am
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,Produktions-Artikel
-,Employee Information,Mitarbeiterinformationen
-DocType: Stock Entry Detail,Additional Cost,Zusätzliche Kosten
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48,"Can not filter based on Voucher No, if grouped by Voucher","Wenn nach Beleg gruppiert wurde, kann nicht auf Grundlage von Belegen gefiltert werden."
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918,Make Supplier Quotation,Lieferantenangebot erstellen
-DocType: Quality Inspection,Incoming,Eingehend
-apps/erpnext/erpnext/setup/doctype/company/company.js +70,Default tax templates for sales and purchase are created.,Standardsteuervorlagen für Verkauf und Einkauf werden erstellt.
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57,Assessment Result record {0} already exists.,Beurteilungsergebnis {0} existiert bereits.
-DocType: BOM,Materials Required (Exploded),Benötigte Materialien (erweitert)
-apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',"Bitte setzen Sie den Firmenfilter leer, wenn Group By &quot;Company&quot;"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Buchungsdatum kann nicht Datum in der Zukunft sein
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Zeile # {0}: Seriennummer {1} stimmt nicht mit {2} {3} überein
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,zur Erzeugung der wiederkehrenden
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Erholungsurlaub
-DocType: Agriculture Task,End Day,Ende Tag
-DocType: Batch,Batch ID,Chargen-ID
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Hinweis: {0}
-,Delivery Note Trends,Entwicklung Lieferscheine
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Zusammenfassung dieser Woche
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Anzahl auf Lager
-DocType: Delivery Trip,Calculate Estimated Arrival Times,Berechnen Sie die voraussichtliche Ankunftszeit
-apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Konto: {0} kann nur über Lagertransaktionen aktualisiert werden
-DocType: Student Group Creation Tool,Get Courses,Erhalten Sie Kurse
-DocType: GL Entry,Party,Gruppe
-DocType: Healthcare Settings,Patient Name,Patientenname
-DocType: Variant Field,Variant Field,Variantfeld
-DocType: Sales Order,Delivery Date,Liefertermin
-DocType: Opportunity,Opportunity Date,Datum der Chance
-DocType: Purchase Receipt,Return Against Purchase Receipt,Zurück zum Kaufbeleg
-DocType: Water Analysis,Person Responsible,Verantwortliche Person
-DocType: Request for Quotation Item,Request for Quotation Item,Angebotsanfrage Artikel
-DocType: Purchase Order,To Bill,Abrechnen
-DocType: Material Request,% Ordered,% bestellt
-DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Für die Kursbasierte Studentengruppe wird der Kurs für jeden Schüler aus den eingeschriebenen Kursen in der Programmregistrierung validiert.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Akkordarbeit
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Durchschnittlicher Einkaufspreis
-DocType: Share Balance,From No,Von Nr
-DocType: Task,Actual Time (in Hours),Tatsächliche Zeit (in Stunden)
-DocType: Employee,History In Company,Historie im Unternehmen
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,New Message from {sender},Neue Nachricht von {Absender}
-DocType: Customer,Customer Primary Address,Hauptadresse des Kunden
-apps/erpnext/erpnext/config/learn.py +107,Newsletters,Newsletter
-DocType: Drug Prescription,Description/Strength,Beschreibung / Stärke
-DocType: Share Balance,Is Company,Ist die Firma
-DocType: Stock Ledger Entry,Stock Ledger Entry,Buchung im Lagerbuch
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Das gleiche Einzelteil wurde mehrfach eingegeben
-DocType: Department,Leave Block List,Urlaubssperrenliste
-DocType: Purchase Invoice,Tax ID,Steuer ID
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Artikel {0} ist nicht für Seriennummern eingerichtet. Spalte muss leer sein
-DocType: Accounts Settings,Accounts Settings,Konteneinstellungen
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Genehmigen
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69,"Malformatted address for {0}, please fix to continue.","Malformatierte Adresse für {0}, bitte korrigieren, um fortzufahren."
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix",Die Nummer des neuen Kontos wird als Präfix in den Kontonamen aufgenommen
-DocType: Maintenance Team Member,Team Member,Teammitglied
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Kein Ergebnis zur Einreichung
-DocType: Customer,Sales Partner and Commission,Vertriebspartner und Verprovisionierung
-DocType: Employee Loan,Rate of Interest (%) / Year,Zinssatz (%) / Jahr
-,Project Quantity,Projekt Menge
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Insgesamt {0} für alle Elemente gleich Null ist, sein kann, sollten Sie &quot;Verteilen Gebühren auf der Grundlage&quot; ändern"
-DocType: Opportunity,To Discuss,Infos zur Diskussion
-apps/erpnext/erpnext/stock/stock_ledger.py +377,{0} units of {1} needed in {2} to complete this transaction.,{0} Einheiten von {1} benötigt in {2} zum Abschluss dieser Transaktion.
-DocType: Loan Type,Rate of Interest (%) Yearly,Zinssatz (%) Jahres
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Temporäre Konten
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Schwarz
-DocType: BOM Explosion Item,BOM Explosion Item,Position der aufgelösten Stückliste
-DocType: Shareholder,Contact List,Kontaktliste
-DocType: Account,Auditor,Prüfer
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} Elemente hergestellt
-apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Erfahren Sie mehr
-DocType: Cheque Print Template,Distance from top edge,Die Entfernung von der Oberkante
-apps/erpnext/erpnext/stock/get_item_details.py +367,Price List {0} is disabled or does not exist,Preisliste {0} ist deaktiviert oder nicht vorhanden ist
-DocType: Purchase Invoice,Return,Zurück
-DocType: Production Order Operation,Production Order Operation,Arbeitsgang im Fertigungsauftrag
-DocType: Pricing Rule,Disable,Deaktivieren
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +178,Mode of payment is required to make a payment,"Modus der Zahlung ist erforderlich, um eine Zahlung zu leisten"
-DocType: Project Task,Pending Review,Wartet auf Überprüfung
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Bearbeiten Sie die ganze Seite für weitere Optionen wie Assets, Seriennummern, Chargen usw."
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Termine und Konsultationen
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} ist nicht im Batch {2}
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}",Anlagewert-{0} ist bereits entsorgt {1}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +72,Cheques Required,Überprüfungen erforderlich
-DocType: Task,Total Expense Claim (via Expense Claim),Gesamtbetrag der Aufwandsabrechnung (über Aufwandsabrechnung)
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Abwesend setzen
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Fehler beim Einrichten der Firma
-DocType: Asset Repair,Asset Repair,Anlagenreparatur
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +142,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Row {0}: Währung der BOM # {1} sollte auf die gewählte Währung gleich {2}
-DocType: Journal Entry Account,Exchange Rate,Wechselkurs
-DocType: Patient,Additional information regarding the patient,Zusätzliche Informationen zum Patienten
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585,Sales Order {0} is not submitted,Kundenauftrag {0} wurde nicht übertragen
-DocType: Homepage,Tag Line,Tag-Linie
-DocType: Fee Component,Fee Component,Fee-Komponente
-apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Flottenmanagement
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1071,Add items from,Elemente hinzufügen aus
-apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Kulturen und Länder
-DocType: Cheque Print Template,Regular,Regulär
-DocType: Fertilizer,Density (if liquid),Dichte (falls flüssig)
-apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Insgesamt weightage aller Bewertungskriterien muss 100% betragen
-DocType: Purchase Order Item,Last Purchase Rate,Letzter Anschaffungspreis
-DocType: Account,Asset,Vermögenswert
-DocType: Project Task,Task ID,Aufgaben-ID
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,"Für Artikel {0} kann es kein Lager geben, da es Varianten gibt"
-DocType: Lab Test,Mobile,Mobile
-,Sales Person-wise Transaction Summary,Vertriebsmitarbeiterbezogene Zusammenfassung der Transaktionen
-DocType: Training Event,Contact Number,Kontaktnummer
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Lager {0} existiert nicht
-DocType: Monthly Distribution,Monthly Distribution Percentages,Prozentuale Aufteilungen der monatsweisen Verteilung
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +110,The selected item cannot have Batch,Der ausgewählte Artikel kann keine Charge haben
-DocType: Delivery Note,% of materials delivered against this Delivery Note,% dieser Lieferscheinmenge geliefert
-DocType: Asset Maintenance Log,Has Certificate,Hat Zertifikat
-DocType: Project,Customer Details,Kundendaten
-DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Überprüfen Sie, ob das Asset eine vorbeugende Wartung oder Kalibrierung erfordert"
-apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,Firmenkürzel darf nicht mehr als 5 Zeichen haben
-DocType: Employee,Reports to,Berichte an
-,Unpaid Expense Claim,Unbezahlte Kostenabrechnung
-DocType: Payment Entry,Paid Amount,Gezahlter Betrag
-apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Entdecken Sie den Verkaufszyklus
-DocType: Assessment Plan,Supervisor,Supervisor
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869,Retention Stock Entry,Vorratsbestandseintrag
-,Available Stock for Packing Items,Verfügbarer Bestand für Verpackungsartikel
-DocType: Item Variant,Item Variant,Artikelvariante
-DocType: Assessment Result Tool,Assessment Result Tool,Beurteilungsergebniswerkzeug
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Als Vorgesetzter
-DocType: BOM Scrap Item,BOM Scrap Item,BOM Ausschussartikel
-apps/erpnext/erpnext/accounts/page/pos/pos.js +895,Submitted orders can not be deleted,Übermittelt Aufträge können nicht gelöscht werden
-apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Konto bereits im Soll, es ist nicht mehr möglich das Konto als Habenkonto festzulegen"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Qualitätsmanagement
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Artikel {0} wurde deaktiviert
-DocType: Project,Total Billable Amount (via Timesheets),Gesamter abrechenbarer Betrag (über Arbeitszeittabellen)
-DocType: Agriculture Task,Previous Business Day,Voriger Geschäftstag
-DocType: Employee Loan,Repay Fixed Amount per Period,Repay fixen Betrag pro Periode
-apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Bitte die Menge für Artikel {0} eingeben
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +210,Credit Note Amt,Kreditnachweis amt
-DocType: Employee External Work History,Employee External Work History,Externe Berufserfahrung des Mitarbeiters
-DocType: Opening Invoice Creation Tool,Purchase,Einkauf
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Bilanzmenge
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Ziele können nicht leer sein
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,Enrolling students,Einschreibung von Studenten
-DocType: Item Group,Parent Item Group,Übergeordnete Artikelgruppe
-DocType: Appointment Type,Appointment Type,Termintyp
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} für {1}
-DocType: Healthcare Settings,Valid number of days,Gültige Anzahl von Tagen
-apps/erpnext/erpnext/setup/doctype/company/company.js +39,Cost Centers,Kostenstellen
-DocType: Land Unit,Linked Plant Analysis,Linked-Plant-Analyse
-DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Kurs, zu dem die Währung des Lieferanten in die Basiswährung des Unternehmens umgerechnet wird"
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Zeile #{0}: Timing-Konflikte mit Zeile {1}
-DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Nullbewertung zulassen
-DocType: Training Event Employee,Invited,Eingeladen
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Mehrere aktive Gehaltsstrukturen für Mitarbeiter gefunden {0} für die angegebenen Daten
-apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Setup-Gateway-Konten.
-DocType: Employee,Employment Type,Art der Beschäftigung
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Anlagevermögen
-DocType: Payment Entry,Set Exchange Gain / Loss,Stellen Sie Exchange-Gewinn / Verlust
-,GST Purchase Register,GST Kaufregister
-,Cash Flow,Cash Flow
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Der kombinierte Rechnungsanteil muss 100% betragen
-DocType: Item Group,Default Expense Account,Standardaufwandskonto
-DocType: GST Account,CGST Account,CGST Konto
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Studenten E-Mail-ID
-DocType: Employee,Notice (days),Meldung(s)(-Tage)
-DocType: Tax Rule,Sales Tax Template,Umsatzsteuer-Vorlage
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2494,Select items to save the invoice,"Wählen Sie Elemente, um die Rechnung zu speichern"
-DocType: Employee,Encashment Date,Inkassodatum
-DocType: Training Event,Internet,Internet
-DocType: Special Test Template,Special Test Template,Spezielle Testvorlage
-DocType: Account,Stock Adjustment,Bestandskorrektur
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Es gibt Standard-Aktivitätskosten für Aktivitätsart - {0}
-DocType: Production Order,Planned Operating Cost,Geplante Betriebskosten
-DocType: Academic Term,Term Start Date,Semesteranfang
-apps/erpnext/erpnext/config/accounts.py +471,List of all share transactions,Liste aller Aktientransaktionen
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Anzahl der Chancen
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244,Please find attached {0} #{1},Bitte Anhang beachten {0} #{1}
-apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Durchschnittsrate
-apps/erpnext/erpnext/controllers/accounts_controller.py +721,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Der gesamte Zahlungsbetrag im Zahlungsplan muss gleich Groß / Abgerundet sein
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Kontoauszug Bilanz nach Hauptbuch
-DocType: Job Applicant,Applicant Name,Bewerbername
-DocType: Authorization Rule,Customer / Item Name,Kunde / Artikelname
-DocType: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Wenn diese Option aktiviert ist, werden die letzten Einkaufsdetails von Artikeln nicht aus früheren Bestellungen oder Kaufquittungen abgerufen"
-DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 
-
-The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".
-
-For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.
-
-Note: BOM = Bill of Materials","Fassen Sie eine Gruppe von Artikeln zu einem neuen Artikel zusammen. Dies ist nützlich, wenn Sie bestimmte Artikel zu einem Paket bündeln und einen Bestand an Artikel-Bündeln erhalten und nicht einen Bestand der einzelnen Artikel. Das Artikel-Bündel erhält für das Attribut ""Ist Lagerartikel"" den Wert ""Nein"" und für das Attribut ""Ist Verkaufsartikel"" den Wert ""Ja"". Beispiel: Wenn Sie Laptops und Tragetaschen getrennt verkaufen und einen bestimmten Preis anbieten, wenn der Kunde beides zusammen kauft, dann wird der Laptop mit der Tasche zusammen ein neuer Bündel-Artikel. Anmerkung: BOM = Stückliste"
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Seriennummer ist für Artikel {0} zwingend erforderlich
-DocType: Item Variant Attribute,Attribute,Attribut
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Bitte Von-/Bis-Bereich genau angeben
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Eröffnung {0} Rechnung erstellt
-DocType: Serial No,Under AMC,Innerhalb des jährlichen Wartungsvertrags
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Artikelpreis wird unter Einbezug von Belegen über den Einstandspreis neu berechnet
-apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Standardeinstellungen für Vertriebstransaktionen
-DocType: Guardian,Guardian Of ,Wächter von
-DocType: Grading Scale Interval,Threshold,Schwelle
-DocType: BOM Update Tool,Current BOM,Aktuelle Stückliste
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +25,Balance (Dr - Cr),Balance (Dr - Cr)
-apps/erpnext/erpnext/public/js/utils.js +55,Add Serial No,Seriennummer hinzufügen
-DocType: Production Order Item,Available Qty at Source Warehouse,Verfügbare Menge bei Source Warehouse
-apps/erpnext/erpnext/config/support.py +22,Warranty,Garantie
-DocType: Purchase Invoice,Debit Note Issued,Lastschrift ausgestellt am
-DocType: Production Order,Warehouses,Lager
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} Anlagevermögen kann nicht übertragen werden
-DocType: Hotel Room Pricing,Hotel Room Pricing,Hotel Zimmerpreise
-apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Dieser Artikel ist eine Variante von {0} (Vorlage).
-DocType: Workstation,per hour,pro Stunde
-apps/erpnext/erpnext/config/buying.py +7,Purchasing,Einkauf
-DocType: Announcement,Announcement,Ankündigung
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84,Customer LPO,Kunden LPO
-DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Für die Batch-basierte Studentengruppe wird die Student Batch für jeden Schüler aus der Programmregistrierung validiert.
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Lager kann nicht gelöscht werden, da es Buchungen im Lagerbuch gibt."
-apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Großhandel
-DocType: Expense Claim Advance,Expense Claim Advance,Spesenabrechnung
-DocType: Lab Test,Report Preference,Berichtsvorgabe
-apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Freiwillige Informationen.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Projektleiter
-,Quoted Item Comparison,Vergleich angebotener Artikel
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Überlappung beim Scoring zwischen {0} und {1}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Versand
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74,Max discount allowed for item: {0} is {1}%,Maximal erlaubter Rabatt für Artikel: {0} ist {1}%
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Nettoinventarwert als auf
-DocType: Crop,Produce,Produzieren
-DocType: Hotel Settings,Default Taxes and Charges,Standard-Steuern und -Abgaben
-DocType: Account,Receivable,Forderung
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Zeile #{0}: Es ist nicht erlaubt den Lieferanten zu wechseln, da bereits ein Lieferantenauftrag vorhanden ist"
-DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Rolle, welche Transaktionen, die das gesetzte Kreditlimit überschreiten, übertragen darf."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +980,Select Items to Manufacture,Wählen Sie die Elemente Herstellung
-DocType: Delivery Stop,Delivery Stop,Liefer Stopp
-apps/erpnext/erpnext/accounts/page/pos/pos.js +963,"Master data syncing, it might take some time","Stammdaten-Synchronisierung, kann es einige Zeit dauern,"
-DocType: Item,Material Issue,Materialentnahme
-DocType: Employee Education,Qualification,Qualifikation
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42,View Salary Slips,Gehaltsabrechnungen anzeigen
-DocType: Item Price,Item Price,Artikelpreis
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Reinigungsmittel
-DocType: BOM,Show Items,Elemente anzeigen
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,"Von Zeit sein kann, nicht größer ist als auf die Zeit."
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92,Do you want to notify all the customers by email?,Möchten Sie alle Kunden per E-Mail benachrichtigen?
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Film & Fernsehen
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Bestellt
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Fortsetzen
-DocType: Salary Detail,Component,Komponente
-DocType: Assessment Criteria,Assessment Criteria Group,Beurteilungskriterien Gruppe
-DocType: Healthcare Settings,Patient Name By,Patientenname Von
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Kumulierte Abschreibungen Öffnungs muss kleiner sein als gleich {0}
-DocType: Warehouse,Warehouse Name,Lagername
-DocType: Naming Series,Select Transaction,Bitte Transaktionen auswählen
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Bitte genehmigende Rolle oder genehmigenden Nutzer eingeben
-DocType: Journal Entry,Write Off Entry,Abschreibungsbuchung
-DocType: BOM,Rate Of Materials Based On,Anteil der zu Grunde liegenden Materialien
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Support-Analyse
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Alle abwählen
-DocType: POS Profile,Terms and Conditions,Allgemeine Geschäftsbedingungen
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},"Bis-Datum sollte im Geschäftsjahr liegen. Unter der Annahme, dass Bis-Datum = {0} ist"
-DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Hier können Sie Größe, Gewicht, Allergien, medizinische Belange usw. pflegen"
-DocType: Leave Block List,Applies to Company,Gilt für Firma
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +231,Cannot cancel because submitted Stock Entry {0} exists,"Stornierung nicht möglich, weil übertragene Lagerbuchung {0} existiert"
-DocType: Employee Loan,Disbursement Date,Valuta-
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,"Keine ""Empfänger"" angegeben"
-DocType: BOM Update Tool,Update latest price in all BOMs,Aktualisieren Sie den aktuellen Preis in allen Stücklisten
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +39,Medical Record,Krankenakte
-DocType: Vehicle,Vehicle,Fahrzeug
-DocType: Purchase Invoice,In Words,In Worten
-apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} muss eingereicht werden
-DocType: POS Profile,Item Groups,Artikelgruppen
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Heute hat {0} Geburtstag!
-DocType: Sales Order Item,For Production,Für die Produktion
-DocType: Payment Request,payment_url,payment_url
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186,Please add a Temporary Opening account in Chart of Accounts,Bitte fügen Sie ein Konto für die vorübergehende Eröffnung im Kontenplan hinzu
-DocType: Customer,Customer Primary Contact,Hauptkontakt des Kunden
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154,Period Closing Journal,Periodenabschluss-Journal
-DocType: Project Task,View Task,Aufgabe anzeigen
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Chance/ Lead%
-DocType: Material Request,MREQ-,MREQ-
-DocType: Payment Schedule,Invoice Portion,Rechnungsteil
-,Asset Depreciations and Balances,Anlagenbschreibungen und Balances
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +363,Amount {0} {1} transferred from {2} to {3},Menge {0} {1} übertragen von {2} auf {3}
-DocType: Sales Invoice,Get Advances Received,Erhaltene Anzahlungen aufrufen
-DocType: Email Digest,Add/Remove Recipients,Empfänger hinzufügen/entfernen
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +498,Transaction not allowed against stopped Production Order {0},Transaktion für angehaltenen Fertigungsauftrag {0} nicht erlaubt
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Um dieses Geschäftsjahr als Standard festzulegen, auf ""Als Standard festlegen"" anklicken"
-DocType: Production Plan,Include Subcontracted Items,Subkontrahierte Artikel einbeziehen
-apps/erpnext/erpnext/projects/doctype/project/project.py +218,Join,Beitreten
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Engpassmenge
-apps/erpnext/erpnext/stock/doctype/item/item.py +671,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Nach der Bestandsübertragung können die Varianteneigenschaften nicht geändert werden. Sie müssen dafür einen neuen Artikel erstellen.
-apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item variant {0} exists with same attributes,Artikelvariante {0} mit denselben Attributen existiert
-DocType: Employee Loan,Repay from Salary,Repay von Gehalts
-DocType: Leave Application,LAP/,RUNDE/
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Anfordern Zahlung gegen {0} {1} für Menge {2}
-DocType: Salary Slip,Salary Slip,Gehaltsabrechnung
-DocType: Lead,Lost Quotation,Verlorene Angebote
-apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Studentenchargen
-DocType: Pricing Rule,Margin Rate or Amount,Marge oder Betrag
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,"""Bis-Datum"" ist erforderlich,"
-DocType: Packing Slip,"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."
-DocType: Sales Invoice Item,Sales Order Item,Kundenauftrags-Artikel
-DocType: Salary Slip,Payment Days,Zahlungsziel
-DocType: Stock Settings,Convert Item Description to Clean HTML,Elementbeschreibung in HTML bereinigen
-DocType: Patient,Dormant,ruhend
-DocType: Salary Slip,Total Interest Amount,Gesamtzinsbetrag
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Lagerhäuser mit untergeordneten Knoten kann nicht umgewandelt werden Ledger
-DocType: BOM,Manage cost of operations,Arbeitsgangkosten verwalten
-DocType: Accounts Settings,Stale Days,Stale Tage
-DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Wenn eine der ausgewählten Transaktionen den Status ""übertragen"" erreicht hat, geht automatisch ein E-Mail-Fenster auf. Damit kann eine E-Mail mit dieser Transaktion als Anhang an die verknüpften Kontaktdaten gesendet werden. Der Benutzer kann auswählen, ob er diese E-Mail absenden will."
-apps/erpnext/erpnext/config/setup.py +14,Global Settings,Allgemeine Einstellungen
-DocType: Crop,Row Spacing UOM,Zeilenabstand UOM
-DocType: Assessment Result Detail,Assessment Result Detail,Details zum Beurteilungsergebnis
-DocType: Employee Education,Employee Education,Mitarbeiterschulung
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Doppelte Artikelgruppe in der Artikelgruppentabelle gefunden
-DocType: Land Unit,Parent Land Unit,Elternlandeinheit
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1113,It is needed to fetch Item Details.,"Wird gebraucht, um Artikeldetails abzurufen"
-DocType: Fertilizer,Fertilizer Name,Dünger Name
-DocType: Salary Slip,Net Pay,Nettolohn
-DocType: Cash Flow Mapping Accounts,Account,Konto
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Seriennummer {0} bereits erhalten
-,Requested Items To Be Transferred,"Angeforderte Artikel, die übertragen werden sollen"
-DocType: Expense Claim,Vehicle Log,Fahrzeug Log
-DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Vorhandensein eines Fiebers (Temp .: 38,5 ° C / 101,3 ° F oder anhaltende Temperatur&gt; 38 ° C / 100,4 ° F)"
-DocType: Customer,Sales Team Details,Verkaufsteamdetails
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1351,Delete permanently?,Dauerhaft löschen?
-DocType: Expense Claim,Total Claimed Amount,Gesamtforderung
-apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Mögliche Opportunität für den Vertrieb
-DocType: Shareholder,Folio no.,Folio Nr.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246,Invalid {0},Ungültige(r) {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Krankheitsbedingte Abwesenheit
-DocType: Email Digest,Email Digest,E-Mail-Bericht
-DocType: Delivery Note,Billing Address Name,Name der Rechnungsadresse
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Kaufhäuser
-,Item Delivery Date,Artikel Liefertermin
-DocType: Production Plan,Material Requested,Material angefordert
-DocType: Warehouse,PIN,STIFT
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116,Error '{0}' occured. Arguments {1}.,Der Fehler &#39;{0}&#39; ist aufgetreten. Argumente {1}
-DocType: Bin,Reserved Qty for sub contract,Reservierte Menge für Unterauftrag
-DocType: Sales Invoice,Base Change Amount (Company Currency),Base-Änderungsbetrag (Gesellschaft Währung)
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Keine Buchungen für die folgenden Lager
-apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Speichern Sie das Dokument zuerst.
-apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},Nur {0} auf Lager für Artikel {1}
-DocType: Account,Chargeable,Gebührenpflichtig
-DocType: Company,Change Abbreviation,Abkürzung ändern
-DocType: Expense Claim Detail,Expense Date,Datum der Aufwendung
-DocType: Item,Max Discount (%),Maximaler Rabatt (%)
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Kredit-Tage können keine negative Zahl sein
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Letzter Bestellbetrag
-DocType: Cash Flow Mapper,e.g Adjustments for:,zB Anpassungen für:
-apps/erpnext/erpnext/stock/doctype/item/item.py +274," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item",{0} Probe zurückhalten basiert auf einer Charge. Bitte setzen Sie Hat Chargennummer um eine Probe des Artikels zu behalten
-DocType: Task,Is Milestone,Ist Meilenstein
-DocType: Delivery Stop,Email Sent To,E-Mail versandt an
-DocType: Budget,Warn,Warnen
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Möchten Sie die Registrierung wirklich aufheben?
-DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Sonstige wichtige Anmerkungen, die in die Datensätze aufgenommen werden sollten."
-DocType: Asset Maintenance,Manufacturing User,Nutzer Fertigung
-DocType: Purchase Invoice,Raw Materials Supplied,Gelieferte Rohmaterialien
-DocType: C-Form,Series,Nummernkreise
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +283,Currency of the price list {0} must be {1} or {2},Die Währung der Preisliste {0} muss {1} oder {2}
-DocType: Appraisal,Appraisal Template,Bewertungsvorlage
-DocType: Soil Texture,Ternary Plot,Ternäres Grundstück
-DocType: Item Group,Item Classification,Artikeleinteilung
-DocType: Driver,License Number,Lizenznummer
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Leiter der kaufmännischen Abteilung
-DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Zweck des Wartungsbesuchs
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Rechnungsempfänger
-DocType: Crop,Period,Periode
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Hauptbuch
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Mitarbeiter {0} am {1} im Urlaub
-apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Leads anzeigen
-DocType: Program Enrollment Tool,New Program,Neues Programm
-DocType: Item Attribute Value,Attribute Value,Attributwert
-,Itemwise Recommended Reorder Level,Empfohlener artikelbezogener Meldebestand
-DocType: Salary Detail,Salary Detail,Gehalt Details
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,Bitte zuerst {0} auswählen
-DocType: Appointment Type,Physician,Arzt
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +858,Batch {0} of Item {1} has expired.,Charge {0} von Artikel {1} ist abgelaufen.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Konsultationen
-DocType: Sales Invoice,Commission,Provision
-apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Zeitblatt für die Fertigung.
-apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Zwischensumme
-DocType: Physician,Charges,Gebühren
-DocType: Salary Detail,Default Amount,Standard-Betrag
-DocType: Lab Test Template,Descriptive,Beschreibend
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,Lager im System nicht gefunden
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Zusammenfassung dieses Monats
-DocType: Quality Inspection Reading,Quality Inspection Reading,Ablesung zur Qualitätsprüfung
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,"""Lagerbestände sperren, wenn älter als"" sollte kleiner sein als %d Tage."
-DocType: Tax Rule,Purchase Tax Template,Umsatzsteuer-Vorlage
-apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,"Setzen Sie ein Verkaufsziel, das Sie für Ihr Unternehmen erreichen möchten."
-,Project wise Stock Tracking,Projektbezogene Lagerbestandsverfolgung
-DocType: GST HSN Code,Regional,Regional
-apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Labor
-DocType: Stock Entry Detail,Actual Qty (at source/target),Tatsächliche Anzahl (am Ursprung/Ziel)
-DocType: Item Customer Detail,Ref Code,Ref-Code
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Kundengruppe ist im POS-Profil erforderlich
-apps/erpnext/erpnext/config/hr.py +12,Employee records.,Mitarbeiterdatensätze
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Please set Next Depreciation Date,Bitte setzen Sie Next Abschreibungen Datum
-DocType: HR Settings,Payroll Settings,Einstellungen zur Gehaltsabrechnung
-apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Nicht verknüpfte Rechnungen und Zahlungen verknüpfen
-DocType: POS Settings,POS Settings,POS-Einstellungen
-apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Bestellung aufgeben
-DocType: Email Digest,New Purchase Orders,Neue Bestellungen an Lieferanten
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Root kann keine übergeordnete Kostenstelle haben
-apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Marke auswählen ...
-apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Non-Profit (Beta)
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Ausbildungsveranstaltungen / Ergebnisse
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Kumulierte Abschreibungen auf
-DocType: Sales Invoice,C-Form Applicable,Anwenden auf Kontakt-Formular
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +438,Operation Time must be greater than 0 for Operation {0},Betriebszeit muss für die Operation {0} größer als 0 sein
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Lager ist erforderlich
-DocType: Shareholder,Address and Contacts,Adresse und Kontaktinformationen
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Fehler beim Erstellen der Website
-DocType: Soil Analysis,Mg/K,Mg / K
-DocType: UOM Conversion Detail,UOM Conversion Detail,Maßeinheit-Umrechnungs-Detail
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924,Retention Stock Entry already created or Sample Quantity not provided,Aufbewahrungsbestandseintrag bereits angelegt oder Musterbestand nicht bereitgestellt
-DocType: Program,Program Abbreviation,Programm Abkürzung
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +426,Production Order cannot be raised against a Item Template,Ein Fertigungsauftrag kann nicht zu einer Artikel-Vorlage gemacht werden
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Kosten werden im Kaufbeleg für jede Position aktualisiert
-DocType: Warranty Claim,Resolved By,Entschieden von
-DocType: Bank Guarantee,Start Date,Startdatum
-apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Urlaube für einen Zeitraum zuordnen
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Schecks und Kautionen fälschlicherweise gelöscht
-apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Konto {0}: Sie können dieses Konto sich selbst nicht als Über-Konto zuweisen
-DocType: Purchase Invoice Item,Price List Rate,Preisliste
-apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Erstellen Sie Angebote
-DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","""Auf Lager"" oder ""Nicht auf Lager"" basierend auf dem in diesem Lager enthaltenen Bestand anzeigen"
-apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Stückliste
-DocType: Item,Average time taken by the supplier to deliver,Durchschnittliche Lieferzeit des Lieferanten
-DocType: Sample Collection,Collected By,Gesammelt von
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,Beurteilungsergebnis
-DocType: Hotel Room Package,Hotel Room Package,Hotelzimmer-Paket
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Stunden
-DocType: Project,Expected Start Date,Voraussichtliches Startdatum
-DocType: Purchase Invoice,04-Correction in Invoice,04-Korrektur in der Rechnung
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Bericht über Variantendetails
-DocType: Setup Progress Action,Setup Progress Action,Setup Fortschrittsaktion
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Kauf Preisliste
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,"Artikel entfernen, wenn keine Gebühren angerechnet werden können"
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Bitte wählen Sie Wartungsstatus als erledigt oder entfernen Sie das Abschlussdatum
-DocType: Supplier,Default Payment Terms Template,Standardvorlage für Zahlungsbedingungen
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Transaktionswährung muß gleiche wie Payment Gateway Währung
-DocType: Payment Entry,Receive,Empfangen
-apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Angebote:
-DocType: Maintenance Visit,Fully Completed,Vollständig abgeschlossen
-apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% abgeschlossen
-DocType: Employee,Educational Qualification,Schulische Qualifikation
-DocType: Workstation,Operating Costs,Betriebskosten
-DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Erwünschte Aktion bei überschrittenem kumuliertem Monatsbudget
-DocType: Subscription,Submit on creation,Buchen beim Erstellen
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +476,Currency for {0} must be {1},Währung für {0} muss {1} sein
-DocType: Asset,Disposal Date,Verkauf Datum
-DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","E-Mails werden an alle aktiven Mitarbeiter des Unternehmens an der angegebenen Stunde gesendet werden, sofern sie nicht im Urlaub sind. Die Zusammenfassung der Antworten wird um Mitternacht versandt werden."
-DocType: Employee Leave Approver,Employee Leave Approver,Urlaubsgenehmiger des Mitarbeiters
-apps/erpnext/erpnext/stock/doctype/item/item.py +509,Row {0}: An Reorder entry already exists for this warehouse {1},Zeile {0}: Es gibt bereits eine Nachbestellungsbuchung für dieses Lager {1}
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Kann nicht als verloren deklariert werden, da bereits ein Angebot erstellt wurde."
-apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Training Feedback
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +495,Production Order {0} must be submitted,Fertigungsauftrag {0} muss übertragen werden
-DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Lieferanten-Scorecard-Kriterien
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Bitte Start -und Enddatum für den Artikel {0} auswählen
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Kurs ist obligatorisch in Zeile {0}
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Bis-Datum kann nicht vor Von-Datum liegen
-DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DocType
-DocType: Cash Flow Mapper,Section Footer,Abschnitt Fußzeile
-apps/erpnext/erpnext/stock/doctype/item/item.js +275,Add / Edit Prices,Preise hinzufügen / bearbeiten
-DocType: Batch,Parent Batch,Übergeordnete Charge
-DocType: Cheque Print Template,Cheque Print Template,Scheck Druckvorlage
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Kostenstellenplan
-DocType: Lab Test Template,Sample Collection,Beispielsammlung
-,Requested Items To Be Ordered,"Angefragte Artikel, die bestellt werden sollen"
-apps/erpnext/erpnext/public/js/hub/hub_page.js +137,My Orders,Meine Bestellungen
-DocType: Price List,Price List Name,Preislistenname
-DocType: BOM,Manufacturing,Fertigung
-,Ordered Items To Be Delivered,"Bestellte Artikel, die geliefert werden müssen"
-DocType: Account,Income,Einkommen
-DocType: Industry Type,Industry Type,Wirtschaftsbranche
-apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Etwas ist schiefgelaufen!
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +106,Warning: Leave application contains following block dates,Achtung: Die Urlaubsverwaltung enthält die folgenden gesperrten Daten
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275,Sales Invoice {0} has already been submitted,Ausgangsrechnung {0} wurde bereits übertragen
-DocType: Supplier Scorecard Scoring Criteria,Score,Ergebnis
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Das Geschäftsjahr {0} existiert nicht
-DocType: Asset Maintenance Log,Completion Date,Fertigstellungstermin
-DocType: Purchase Invoice Item,Amount (Company Currency),Betrag (Firmenwährung)
-DocType: Agriculture Analysis Criteria,Agriculture User,Benutzer Landwirtschaft
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Gültig bis Datum kann nicht vor Transaktionsdatum sein
-apps/erpnext/erpnext/stock/stock_ledger.py +381,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,"Es werden {0} Einheiten von {1} in {2} auf {3} {4} für {5} benötigt, um diesen Vorgang abzuschließen."
-DocType: Fee Schedule,Student Category,Studenten-Kategorie
-DocType: Announcement,Student,Schüler
-apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Stammdaten der Organisationseinheit (Abteilung)
-DocType: Shipping Rule,Shipping Rule Type,Versandregeltyp
-apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Geh zu den Zimmern
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Bitte eine Nachricht vor dem Versenden eingeben
-DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKAT FÜR LIEFERANTEN
-DocType: Email Digest,Pending Quotations,Ausstehende Angebote
-apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Verkaufsstellen-Profil
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +24,{0} should be a value between 0 and 100,{0} sollte ein Wert zwischen 0 und 100 sein
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +94,Next Depreciation Date cannot be before Available-for-use Date,Das nächste Abschreibungsdatum darf nicht vor dem Verfügbarkeitsdatum liegen
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Ungesicherte Kredite
-DocType: Cost Center,Cost Center Name,Kostenstellenbezeichnung
-DocType: Student,B+,B+
-DocType: HR Settings,Max working hours against Timesheet,Max Arbeitszeit gegen Stundenzettel
-DocType: Maintenance Schedule Detail,Scheduled Date,Geplantes Datum
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +209,Total Paid Amt,Summe gezahlte Beträge
-DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Mitteilungen mit mehr als 160 Zeichen werden in mehrere Nachrichten aufgeteilt
-DocType: Purchase Receipt Item,Received and Accepted,Erhalten und bestätigt
-DocType: Hub Settings,Company and Seller Profile,Firmen- und Verkäuferprofil
-,GST Itemised Sales Register,GST Einzelverkaufsregister
-DocType: Soil Texture,Silt Loam,Schlamm
-,Serial No Service Contract Expiry,Ablaufdatum des Wartungsvertrags zu Seriennummer
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Sie können ein Konto nicht gleichzeitig be- und entlasten
-DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Der durchschnittliche Puls eines Erwachsenen liegt zwischen 60 und 80 Schlägen pro Minute.
-DocType: Naming Series,Help HTML,HTML-Hilfe
-DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Creation Tool
-DocType: Item,Variant Based On,Variante basierend auf
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Summe der zugeordneten Gewichtungen sollte 100% sein. Sie ist {0}
-apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Ihre Lieferanten
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Bitte korrigieren Sie die
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,"Kann nicht als verloren gekennzeichnet werden, da ein Kundenauftrag dazu existiert."
-DocType: Request for Quotation Item,Supplier Part No,Lieferant Teile-Nr
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Kann nicht abschreiben, wenn die Kategorie ""Bewertung"" oder ""Bewertung und Total 'ist"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370,Received From,Erhalten von
-DocType: Lead,Converted,umgewandelt
-DocType: Item,Has Serial No,Hat Seriennummer
-DocType: Employee,Date of Issue,Ausstellungsdatum
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Nach den Kaufeinstellungen, wenn Kaufbedarf erforderlich == &#39;JA&#39;, dann für die Erstellung der Kauf-Rechnung, muss der Benutzer die Kaufbeleg zuerst für den Eintrag {0}"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Zeile #{0}: Lieferanten für Artikel {1} einstellen
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Row {0}: Stunden-Wert muss größer als Null sein.
-apps/erpnext/erpnext/stock/doctype/item/item.py +194,Website Image {0} attached to Item {1} cannot be found,"Das Webseiten-Bild {0}, das an Artikel {1} angehängt wurde, kann nicht gefunden werden"
-DocType: Issue,Content Type,Inhaltstyp
-DocType: Asset,Assets,Vermögenswerte
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Rechner
-DocType: Item,List this Item in multiple groups on the website.,Diesen Artikel in mehreren Gruppen auf der Webseite auflisten.
-DocType: Payment Term,Due Date Based On,Fälligkeitsdatum basiert auf
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Bitte legen Sie die Standard-Kundengruppe und das Territorium in Selling Settings fest
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not exist,{0} {1} existiert nicht
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,"Bitte die Option ""Unterschiedliche Währungen"" aktivieren um Konten mit anderen Währungen zu erlauben"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +87,Item: {0} does not exist in the system,Artikel: {0} ist nicht im System vorhanden
-apps/erpnext/erpnext/accounts/doctype/account/account.py +106,You are not authorized to set Frozen value,Sie haben keine Berechtigung gesperrte Werte zu setzen
-DocType: Payment Reconciliation,Get Unreconciled Entries,Nicht zugeordnete Buchungen aufrufen
-DocType: Payment Reconciliation,From Invoice Date,Ab Rechnungsdatum
-DocType: Healthcare Settings,Laboratory Settings,Laboreinstellungen
-apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Setzen Sie den Lieferanten erfolgreich
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Einlösung gewähren
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Unternehmenszweck
-DocType: Crop,Byproducts,Nebenprodukte
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,An Lager
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Alle Studenten Admissions
-,Average Commission Rate,Durchschnittlicher Provisionssatz
-DocType: Share Balance,No of Shares,Anzahl der Aktien
-apps/erpnext/erpnext/stock/doctype/item/item.py +447,'Has Serial No' can not be 'Yes' for non-stock item,"""Hat Seriennummer"" kann bei Nicht-Lagerartikeln nicht ""Ja"" sein"
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Wählen Sie Status
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Die Anwesenheit kann nicht für zukünftige Termine markiert werden
-DocType: Pricing Rule,Pricing Rule Help,Hilfe zur Preisregel
-DocType: School House,House Name,Hausname
-DocType: Fee Schedule,Total Amount per Student,Gesamtbetrag pro Student
-DocType: Purchase Taxes and Charges,Account Head,Kontobezeichnung
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Elektro
-apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Fügen Sie den Rest Ihrer Organisation als Nutzer hinzu. Sie können auch Kunden zu Ihrem Portal einladen indem Sie sie aus den Kontakten die Einladung senden
-DocType: Stock Entry,Total Value Difference (Out - In),Gesamt-Wertdifferenz (Aus - Ein)
-DocType: Grant Application,Requested Amount,Gewünschter Betrag
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Zeile {0}: Wechselkurs ist erforderlich
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},Benutzer-ID ist für Mitarbeiter {0} nicht eingegeben
-DocType: Vehicle,Vehicle Value,Fahrzeugwert
-DocType: Crop Cycle,Detected Diseases,Erkannte Krankheiten
-DocType: Stock Entry,Default Source Warehouse,Standard-Ausgangslager
-DocType: Item,Customer Code,Kunden-Nr.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Geburtstagserinnerung für {0}
-DocType: Asset Maintenance Task,Last Completion Date,Letztes Fertigstellungsdatum
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Tage seit dem letzten Auftrag
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365,Debit To account must be a Balance Sheet account,Sollkonto muss ein Bilanzkonto sein
-DocType: Buying Settings,Naming Series,Nummernkreis
-DocType: Leave Block List,Leave Block List Name,Name der Urlaubssperrenliste
-apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Versicherung Startdatum sollte weniger als Versicherung Enddatum
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Wertpapiere
-DocType: Timesheet,Production Detail,Produktionsdetail
-DocType: Restaurant,Active Menu,Aktives Menü
-DocType: Target Detail,Target Qty,Zielmenge
-DocType: Shopping Cart Settings,Checkout Settings,Kasse Einstellungen
-DocType: Student Attendance,Present,Anwesend
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Lieferschein {0} darf nicht gebucht werden
-DocType: Notification Control,Sales Invoice Message,Mitteilung zur Ausgangsrechnung
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Abschlußkonto {0} muss vom Typ Verbindlichkeiten/Eigenkapital sein
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +324,Salary Slip of employee {0} already created for time sheet {1},Gehaltsabrechnung der Mitarbeiter {0} bereits für Zeitblatt erstellt {1}
-DocType: Vehicle Log,Odometer,Tacho
-DocType: Production Plan Item,Ordered Qty,Bestellte Menge
-apps/erpnext/erpnext/stock/doctype/item/item.py +743,Item {0} is disabled,Artikel {0} ist deaktiviert
-DocType: Stock Settings,Stock Frozen Upto,Bestand gesperrt bis
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930,BOM does not contain any stock item,Stückliste enthält keine Lagerware
-DocType: Chapter,Chapter Head,Kapitel Kopf
-DocType: Payment Term,Month(s) after the end of the invoice month,Monat (e) nach dem Ende des Rechnungsmonats
-apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Projektaktivität/-vorgang.
-DocType: Vehicle Log,Refuelling Details,Betankungs Einzelheiten
-apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Gehaltsabrechnungen generieren
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +24,Lab result datetime cannot be before testing datetime,Lab-Ergebnis datetime kann nicht vor dem Testen von datetime liegen
-DocType: POS Profile,Allow user to edit Discount,"Erlaube dem Nutzer, den Rabatt zu bearbeiten"
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55,Get customers from,Holen Sie Kunden von
-DocType: Production Plan Item,Include Exploded Items,Explodierte Elemente einschließen
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45,"Buying must be checked, if Applicable For is selected as {0}","Einkauf muss ausgewählt sein, wenn ""Anwenden auf"" auf {0} gesetzt wurde"
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Discount muss kleiner als 100 sein
-DocType: Shipping Rule,Restrict to Countries,Auf Länder beschränken
-DocType: Purchase Invoice,Write Off Amount (Company Currency),Abschreibungs-Betrag (Firmenwährung)
-DocType: Sales Invoice Timesheet,Billing Hours,Abgerechnete Stunden
-DocType: Project,Total Sales Amount (via Sales Order),Gesamtverkaufsbetrag (über Kundenauftrag)
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +548,Default BOM for {0} not found,Standardstückliste für {0} nicht gefunden
-apps/erpnext/erpnext/stock/doctype/item/item.py +513,Row #{0}: Please set reorder quantity,Zeile #{0}: Bitte Nachbestellmenge angeben
-apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,"Tippen Sie auf Elemente, um sie hier hinzuzufügen"
-DocType: Fees,Program Enrollment,Programm Einschreibung
-DocType: Share Transfer,To Folio No,Zu Folio Nein
-DocType: Landed Cost Voucher,Landed Cost Voucher,Beleg über Einstandskosten
-apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Bitte {0} setzen
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} ist ein inaktiver Schüler
-DocType: Employee,Health Details,Gesundheitsdaten
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Zur Erstellung eines Zahlungsauftrags ist ein Referenzdokument erforderlich
-DocType: Soil Texture,Sandy Clay,Sandiger Lehm
-DocType: Grant Application,Assessment  Manager,Bewertungsmanager
-DocType: Payment Entry,Allocate Payment Amount,Zahlungsbetrag zuweisen
-DocType: Employee External Work History,Salary,Gehalt
-DocType: Serial No,Delivery Document Type,Lieferdokumententyp
-DocType: Sales Order,Partly Delivered,Teilweise geliefert
-DocType: Item Variant Settings,Do not update variants on save,Aktualisieren Sie keine Varianten beim Speichern
-DocType: Email Digest,Receivables,Forderungen
-DocType: Lead Source,Lead Source,Lead Ursprung
-DocType: Customer,Additional information regarding the customer.,Zusätzliche Informationen bezüglich des Kunden.
-DocType: Quality Inspection Reading,Reading 5,Ablesewert 5
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +231,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} ist mit {2} verbunden, aber das Gegenkonto ist {3}"
-apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Lab-Tests anzeigen
-DocType: Purchase Invoice,Y,Y
-DocType: Maintenance Visit,Maintenance Date,Wartungsdatum
-DocType: Purchase Invoice Item,Rejected Serial No,Abgelehnte Seriennummer
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,Jahresbeginn oder Enddatum überlappt mit {0}. Um dies zu verhindern setzen Sie eine Firma.
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +129,Please mention the Lead Name in Lead {0},Bitte erwähnen Sie den Lead Name in Lead {0}
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Startdatum sollte für den Artikel {0} vor dem Enddatum liegen
-DocType: Item,"Example: ABCD.#####
-If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Beispiel: ABCD.##### 
- Wenn ""Serie"" eingestellt ist und ""Seriennummer"" in den Transaktionen nicht aufgeführt ist, dann wird eine Seriennummer automatisch auf der Grundlage dieser Serie erstellt. Wenn immer explizit Seriennummern für diesen Artikel aufgeführt werden sollen, muss das Feld leer gelassen werden."
-DocType: Upload Attendance,Upload Attendance,Anwesenheit hochladen
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +571,BOM and Manufacturing Quantity are required,Stückliste und Fertigungsmenge werden benötigt
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Alter Bereich 2
-DocType: SG Creation Tool Course,Max Strength,Max Kraft
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Voreinstellungen installieren
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85,No Delivery Note selected for Customer {},Kein Lieferschein für den Kunden {} ausgewählt
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25,BOM replaced,Stückliste ersetzt
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1043,Select Items based on Delivery Date,Wählen Sie die Positionen nach dem Lieferdatum aus
-DocType: Grant Application,Has any past Grant Record,Hat einen früheren Grant Record
-,Sales Analytics,Vertriebsanalyse
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127,Available {0},Verfügbar {0}
-,Prospects Engaged But Not Converted,"Perspektiven engagiert, aber nicht umgewandelt"
-DocType: Manufacturing Settings,Manufacturing Settings,Fertigungseinstellungen
-apps/erpnext/erpnext/config/setup.py +56,Setting up Email,E-Mail einrichten
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobil Nein
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Bitte die Standardwährung in die Firmenstammdaten eingeben
-DocType: Stock Entry Detail,Stock Entry Detail,Lagerbuchungsdetail
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Tägliche Erinnerungen
-DocType: Products Settings,Home Page is Products,"Startseite ist ""Products"""
-,Asset Depreciation Ledger,Anlagenabschreibungensbuch
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +90,Tax Rule Conflicts with {0},Steuer-Regel steht in Konflikt mit {0}
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Neuer Kontoname
-DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Kosten gelieferter Rohmaterialien
-DocType: Selling Settings,Settings for Selling Module,Einstellungen Verkauf
-DocType: Hotel Room Reservation,Hotel Room Reservation,Hotelzimmer Reservierung
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Kundenservice
-DocType: BOM,Thumbnail,Thumbnail
-DocType: Item Customer Detail,Item Customer Detail,kundenspezifisches Artikeldetail
-apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Bewerber/-in einen Arbeitsplatz anbieten
-DocType: Notification Control,Prompt for Email on Submission of,E-Mail anregen bei der Übertragung von
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Die Gesamtmenge des beantragten Urlaubs übersteigt die Tage in der Periode
-DocType: Land Unit,Linked Soil Analysis,Verbundene Bodenanalyse
-DocType: Pricing Rule,Percentage,Prozentsatz
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Artikel {0} muss ein Lagerartikel sein
-DocType: Manufacturing Settings,Default Work In Progress Warehouse,Standard-Fertigungslager
-apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Standardeinstellungen für Buchhaltungstransaktionen
-DocType: Maintenance Visit,MV,MV
-DocType: Restaurant,Default Tax Template,Standardsteuervorlage
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66,{0} Students have been enrolled,{0} Studenten wurden angemeldet
-DocType: Fees,Student Details,Studenten Details
-DocType: Purchase Invoice Item,Stock Qty,Lagermenge
-DocType: Employee Loan,Repayment Period in Months,Rückzahlungsfrist in Monaten
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Fehler: Keine gültige ID?
-DocType: Naming Series,Update Series Number,Nummernkreis-Wert aktualisieren
-DocType: Account,Equity,Eigenkapital
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: ""Gewinn und Verlust"" Konto-Art {2} ist nicht in Eröffnungs-Buchung erlaubt"
-DocType: Sales Order,Printing Details,Druckdetails
-DocType: Task,Closing Date,Abschlussdatum
-DocType: Sales Order Item,Produced Quantity,Produzierte Menge
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Ingenieur
-DocType: Journal Entry,Total Amount Currency,Insgesamt Betrag Währung
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Unterbaugruppen suchen
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Artikelnummer wird in Zeile {0} benötigt
-DocType: GST Account,SGST Account,SGST-Konto
-apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Gehen Sie zu Artikeln
-DocType: Sales Partner,Partner Type,Partnertyp
-DocType: Purchase Taxes and Charges,Actual,Tatsächlich
-DocType: Restaurant Menu,Restaurant Manager,Restaurantmanager
-DocType: Authorization Rule,Customerwise Discount,Kundenspezifischer Rabatt
-apps/erpnext/erpnext/config/projects.py +41,Timesheet for tasks.,Zeitraport für Vorgänge.
-DocType: Purchase Invoice,Against Expense Account,Zu Aufwandskonto
-DocType: Production Order,Production Order,Fertigungsauftrag
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282,Installation Note {0} has already been submitted,Installationshinweis {0} wurde bereits übertragen
-DocType: Bank Reconciliation,Get Payment Entries,Get Payment-Einträge
-DocType: Quotation Item,Against Docname,Zu Dokumentenname
-DocType: SMS Center,All Employee (Active),Alle Mitarbeiter (Aktiv)
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Jetzt ansehen
-DocType: BOM,Raw Material Cost,Rohmaterialkosten
-DocType: Item Reorder,Re-Order Level,Meldebestand
-apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gantt-Diagramm
-DocType: Crop Cycle,Cycle Type,Zyklustyp
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Teilzeit
-DocType: Employee,Applicable Holiday List,Geltende Urlaubsliste
-DocType: Employee,Cheque,Scheck
-DocType: Training Event,Employee Emails,Mitarbeiter E-Mails
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Serie aktualisiert
-apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Report Type is mandatory,Berichtstyp ist zwingend erforderlich
-DocType: Item,Serial Number Series,Serie der Seriennummer
-apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Angabe des Lagers ist für Lagerartikel {0} in Zeile {1} zwingend erfoderlich
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Einzel- & Großhandel
-DocType: Issue,First Responded On,Zuerst geantwortet auf
-DocType: Website Item Group,Cross Listing of Item in multiple groups,Kreuzweise Auflistung des Artikels in mehreren Gruppen
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Start- und Enddatum des Geschäftsjahres sind für das Geschäftsjahr {0} bereits gesetzt
-DocType: Projects Settings,Ignore User Time Overlap,Benutzerzeitüberlappung ignorieren
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Abrechnungsdatum aktualisiert
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Split Batch
-DocType: Stock Settings,Batch Identification,Chargenidentifikation
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,Erfolgreich abgestimmt
-DocType: Request for Quotation Supplier,Download PDF,PDF Herunterladen
-DocType: Production Order,Planned End Date,Geplantes Enddatum
-DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,"Versteckte Liste, die die Liste der mit dem Aktionär verknüpften Kontakte enthält"
-apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informationen zum Spendertyp
-DocType: Request for Quotation,Supplier Detail,Lieferant Details
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Fehler in Formel oder Bedingung: {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +94,Invoiced Amount,Rechnungsbetrag
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Kriteriengewichte müssen zusammen 100% ergeben.
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Anwesenheit
-apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,Lagerartikel
-DocType: BOM,Materials,Materialien
-DocType: Leave Block List,"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, für die sie gelten soll, hinzugefügt werden."
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111,Creating {0},Erstellen von {0}
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Quelle und Ziel-Warehouse kann nicht gleich sein
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +573,Posting date and posting time is mandatory,Buchungsdatum und Buchungszeit sind zwingend erfoderlich
-apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Steuervorlage für Einkaufstransaktionen
-,Item Prices,Artikelpreise
-DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"""In Worten"" wird sichtbar, sobald Sie den Lieferantenauftrag speichern."
-DocType: Period Closing Voucher,Period Closing Voucher,Periodenabschlussbeleg
-DocType: Consultation,Review Details,Bewertung Details
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185,The shareholder does not belong to this company,Der Aktionär gehört nicht zu dieser Gesellschaft
-DocType: Dosage Form,Dosage Form,Dosierungsform
-apps/erpnext/erpnext/config/selling.py +67,Price List master.,Preislisten-Vorlagen
-DocType: Task,Review Date,Überprüfungsdatum
-DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serie für Asset Depreciation Entry (Journal Entry)
-DocType: Membership,Member Since,Mitglied seit
-DocType: Purchase Invoice,Advance Payments,Anzahlungen
-DocType: Purchase Taxes and Charges,On Net Total,Auf Nettosumme
-apps/erpnext/erpnext/controllers/item_variant.py +92,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Wert für das Attribut {0} muss im Bereich von {1} bis {2} in den Schritten von {3} für Artikel {4}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +175,Target warehouse in row {0} must be same as Production Order,Eingangslager in Zeile {0} muss dem Fertigungsauftrag entsprechen
-DocType: Restaurant Reservation,Waitlisted,Warteliste
-apps/erpnext/erpnext/accounts/doctype/account/account.py +124,Currency can not be changed after making entries using some other currency,"Die Währung kann nicht geändert werden, wenn Buchungen in einer anderen Währung getätigt wurden"
-DocType: Shipping Rule,Fixed,Fest
-DocType: Vehicle Service,Clutch Plate,Kupplungsscheibe
-DocType: Company,Round Off Account,Abschlusskonto
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Verwaltungskosten
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Beratung
-DocType: Customer Group,Parent Customer Group,Übergeordnete Kundengruppe
-DocType: Journal Entry,Subscription,Abonnement
-DocType: Purchase Invoice,Contact Email,Kontakt-E-Mail
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Gebührenermittlung ausstehend
-DocType: Appraisal Goal,Score Earned,Erreichte Punktzahl
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240,Notice Period,Mitteilungsfrist
-DocType: Asset Category,Asset Category Name,Anlagekategorie Name
-apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Dies ist ein Root-Gebiet und kann nicht bearbeitet werden.
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Neuer Verkaufspersonenname
-DocType: Packing Slip,Gross Weight UOM,Bruttogewicht-Maßeinheit
-DocType: Asset Maintenance Task,Preventive Maintenance,Vorbeugende Wartung
-DocType: Delivery Note Item,Against Sales Invoice,Zu Ausgangsrechnung
-DocType: Purchase Invoice,07-Others,07-Andere
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Bitte geben Sie Seriennummern für serialisierte Artikel ein
-DocType: Bin,Reserved Qty for Production,Reserviert Menge für Produktion
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureNum,EcritureNum
-DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Nicht anhaken, wenn Sie keine Stapelverarbeitung beim Anlegen von Kurs basierten Gruppen wünschen."
-DocType: Asset,Frequency of Depreciation (Months),Die Häufigkeit der Abschreibungen (Monate)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500,Credit Account,Guthabenkonto
-DocType: Landed Cost Item,Landed Cost Item,Einstandspreis-Artikel
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Nullwerte anzeigen
-DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Menge eines Artikels nach der Herstellung/dem Umpacken auf Basis vorgegebener Mengen von Rohmaterial
-DocType: Lab Test,Test Group,Testgruppe
-DocType: Payment Reconciliation,Receivable / Payable Account,Forderungen-/Verbindlichkeiten-Konto
-DocType: Delivery Note Item,Against Sales Order Item,Zu Kundenauftrags-Position
-DocType: Company,Company Logo,Firmenlogo
-apps/erpnext/erpnext/stock/doctype/item/item.py +708,Please specify Attribute Value for attribute {0},Bitte Attributwert für Attribut {0} angeben
-DocType: Item,Default Warehouse,Standardlager
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Budget kann nicht einem Gruppenkonto {0} zugeordnet werden
-DocType: Healthcare Settings,Patient Registration,Patientenregistrierung
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Bitte übergeordnete Kostenstelle eingeben
-DocType: Delivery Note,Print Without Amount,Drucken ohne Betrag
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,Abschreibungen Datum
-DocType: Issue,Support Team,Support-Team
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Verfällt (in Tagen)
-DocType: Appraisal,Total Score (Out of 5),Gesamtwertung (max 5)
-DocType: Fee Structure,FS.,FS.
-DocType: Student Attendance Tool,Batch,Charge
-DocType: Donor,Donor Type,Spendertyp
-apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Saldo
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Bitte wählen Sie das Unternehmen aus
-DocType: Room,Seating Capacity,Sitzplatzkapazität
-DocType: Issue,ISS-,ISS-
-DocType: Lab Test Groups,Lab Test Groups,Labortestgruppen
-DocType: Project,Total Expense Claim (via Expense Claims),Gesamtbetrag der Aufwandsabrechnung (über Aufwandsabrechnungen)
-DocType: GST Settings,GST Summary,GST Zusammenfassung
-apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,"Bitte aktivieren Sie das standardmäßig eingehende Konto, bevor Sie die Daily Work Summary Group erstellen"
-DocType: Assessment Result,Total Score,Gesamtpunktzahl
-DocType: Journal Entry,Debit Note,Lastschrift
-DocType: Stock Entry,As per Stock UOM,Gemäß Lagermaßeinheit
-apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Nicht abgelaufen
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49,ValidDate,Gültiges Datum
-DocType: Student Log,Achievement,Leistung
-DocType: Batch,Source Document Type,Quelldokumenttyp
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Folgende Kurspläne wurden erstellt
-DocType: Journal Entry,Total Debit,Gesamt-Soll
-DocType: Manufacturing Settings,Default Finished Goods Warehouse,Standard-Fertigwarenlager
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +124,Please select Patient,Bitte wählen Sie Patient
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Vertriebsmitarbeiter
-DocType: Hotel Room Package,Amenities,Ausstattung
-apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Budget und Kostenstellen
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Mehrere Standard-Zahlungsarten sind nicht erlaubt
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,für die
-,Appointment Analytics,Terminanalytik
-DocType: Vehicle Service,Half Yearly,Halbjährlich
-DocType: Lead,Blog Subscriber,Blog-Abonnent
-DocType: Guardian,Alternate Number,Alternative Nummer
-DocType: Healthcare Settings,Consultations in valid days,Konsultationen in gültigen Tagen
-DocType: Assessment Plan Criteria,Maximum Score,Maximale Punktzahl
-apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Regeln erstellen um Transaktionen auf Basis von Werten zu beschränken
-DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Cash Flow Mapping Konten
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Gruppenrolle Nr
-DocType: Batch,Manufacturing Date,Herstellungsdatum
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Gebührenermittlung fehlgeschlagen
-DocType: Opening Invoice Creation Tool,Create Missing Party,Erstelle fehlende Partei
-DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Lassen Sie dies leer, wenn Sie Studentengruppen pro Jahr anlegen."
-DocType: HR Settings,"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 Urlaubstage und dies reduziert den Wert des Gehalts pro Tag."
-DocType: Purchase Invoice,Total Advance,Summe der Anzahlungen
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Vorlagencode ändern
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Der Begriff Enddatum kann nicht früher als der Begriff Startdatum. Bitte korrigieren Sie die Daten und versuchen Sie es erneut.
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Quot Count
-,BOM Stock Report,BOM Stock Report
-DocType: Stock Reconciliation Item,Quantity Difference,Mengendifferenz
-DocType: Employee Advance,EA-,EA-
-DocType: Opportunity Item,Basic Rate,Grundpreis
-DocType: GL Entry,Credit Amount,Guthaben-Summe
-DocType: Cheque Print Template,Signatory Position,Unterzeichner Position
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173,Set as Lost,"Als ""verloren"" markieren"
-DocType: Timesheet,Total Billable Hours,Insgesamt abrechenbare Stunden
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Zahlungsnachweis
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Dies basiert auf Transaktionen gegen diesen Kunden. Siehe Zeitleiste unten für Details
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Zeile {0}: Zugewiesener Betrag {1} muss kleiner oder gleich der Zahlungsmenge {2} sein
-DocType: Program Enrollment Tool,New Academic Term,Neuer akademischer Begriff
-,Course wise Assessment Report,Kursweise Assessment Report
-DocType: Purchase Invoice,Availed ITC State/UT Tax,Erhaltene ITC-Status- / UT-Steuer
-DocType: Tax Rule,Tax Rule,Steuer-Regel
-DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Gleiche Preise während des gesamten Verkaufszyklus beibehalten
-DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Zeiten außerhalb der normalen Arbeitszeiten am Arbeitsplatz zulassen.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +120,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} hat keinen Arzt-Zeitplan. Fügen Sie es dem Arzt-Master hinzu
-apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Kunden in der Warteschlange
-DocType: Driver,Issuing Date,Ausstellungsdatum
-DocType: Student,Nationality,Staatsangehörigkeit
-,Items To Be Requested,Anzufragende Artikel
-DocType: Purchase Order,Get Last Purchase Rate,Letzten Einkaufspreis aufrufen
-DocType: Company,Company Info,Informationen über das Unternehmen
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1384,Select or add new customer,Wählen oder neue Kunden hinzufügen
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +171,Cost center is required to book an expense claim,"Eine Kostenstelle ist erforderlich, um einen Aufwandsanspruch zu buchen."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Mittelverwendung (Aktiva)
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Dies hängt von der Anwesenheit dieses Mitarbeiters ab
-DocType: Assessment Result,Summary,Zusammenfassung
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Markieren Sie die Anwesenheit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494,Debit Account,Sollkonto
-DocType: Fiscal Year,Year Start Date,Startdatum des Geschäftsjahres
-DocType: Attendance,Employee Name,Mitarbeitername
-DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restaurantbestellzugangsposten
-DocType: Purchase Invoice,Rounded Total (Company Currency),Gerundete Gesamtsumme (Firmenwährung)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Cannot covert to Group because Account Type is selected.,"Kann nicht in keine Gruppe umgewandelt werden, weil Kontentyp ausgewählt ist."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} wurde geändert. Bitte aktualisieren.
-DocType: Leave Block List,Stop users from making Leave Applications on following days.,"Benutzer davon abhalten, Urlaubsanträge für folgende Tage einzureichen."
-DocType: Asset Maintenance Team,Maintenance Team Members,Mitglieder des Wartungsteams
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Gesamtbetrag des Einkaufs
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Lieferant Quotation {0} erstellt
-apps/erpnext/erpnext/accounts/report/financial_statements.py +101,End Year cannot be before Start Year,End-Jahr kann nicht gleich oder kleiner dem Start-Jahr sein.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233,Employee Benefits,Vergünstigungen an Mitarbeiter
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264,Packed quantity must equal quantity for Item {0} in row {1},Verpackte Menge muss gleich der Menge des Artikel {0} in Zeile {1} sein
-DocType: Production Order,Manufactured Qty,Produzierte Menge
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78,The shares don't exist with the {0},Die Freigaben existieren nicht mit der {0}
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Rechnung erstellt
-DocType: Asset,Out of Order,Außer Betrieb
-DocType: Purchase Receipt Item,Accepted Quantity,Angenommene Menge
-DocType: Projects Settings,Ignore Workstation Time Overlap,Arbeitszeitüberlappung ignorieren
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Bitte stellen Sie eine Standard-Feiertagsliste für Mitarbeiter {0} oder Gesellschaft {1}
-apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} existiert nicht
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Wählen Sie Chargennummern aus
-apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Rechnungen an Kunden
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Projekt-ID
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Zeile Nr. {0}: Betrag kann nicht größer als der ausstehende Betrag zur Aufwandsabrechnung {1} sein. Ausstehender Betrag ist {2}
-DocType: Assessment Plan,Schedule,Zeitplan
-DocType: Account,Parent Account,Übergeordnetes Konto
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,Verfügbar
-DocType: Quality Inspection Reading,Reading 3,Ablesewert 3
-,Hub,Hub
-DocType: GL Entry,Voucher Type,Belegtyp
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1716,Price List not found or disabled,Preisliste nicht gefunden oder deaktiviert
-DocType: Student Applicant,Approved,Genehmigt
-apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Preis
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',"Freigestellter Angestellter {0} muss als ""entlassen"" gekennzeichnet werden"
-DocType: Hub Settings,Last Sync On,Letzte Synchronisierung an
-DocType: Guardian,Guardian,Wächter
-DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Erstelle einen fehlenden Kunden oder Lieferanten.
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Bewertung {0} für Mitarbeiter {1} im angegebenen Datumsbereich erstellt
-DocType: Academic Term,Education,Bildung
-apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,Entf
-DocType: Selling Settings,Campaign Naming By,Benennung der Kampagnen nach
-DocType: Employee,Current Address Is,Aktuelle Adresse ist
-apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Monatliches Verkaufsziel (
-apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,geändert
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Optional. Stellt die Standardwährung des Unternehmens ein, falls nichts angegeben ist."
-DocType: Sales Invoice,Customer GSTIN,Kunde GSTIN
-DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Liste der erkannten Krankheiten auf dem Feld. Wenn diese Option ausgewählt ist, wird automatisch eine Liste mit Aufgaben zur Behandlung der Krankheit hinzugefügt"
-DocType: Asset Repair,Repair Status,Reparaturstatus
-apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Buchungssätze
-DocType: Delivery Note Item,Available Qty at From Warehouse,Verfügbare Stückzahl im Ausgangslager
-DocType: POS Profile,Account for Change Amount,Konto für Änderungsbetrag
-DocType: Purchase Invoice,input service,Eingabeservice
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Zeile {0}: Gruppe / Konto stimmt nicht mit {1} / {2} in {3} {4} überein
-DocType: Maintenance Team Member,Maintenance Team Member,Wartungsteammitglied
-DocType: Agriculture Analysis Criteria,Soil Analysis,Bodenanalyse
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13,Course Code: ,Kurscode:
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Bitte das Aufwandskonto angeben
-DocType: Account,Stock,Lager
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Referenzdokumenttyp muss eine der Bestellung, Rechnung oder Kaufjournaleintrag sein"
-DocType: Employee,Current Address,Aktuelle Adresse
-DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Wenn der Artikel eine Variante eines anderen Artikels ist, dann werden Beschreibung, Bild, Preise, Steuern usw. aus der Vorlage übernommen, sofern nicht ausdrücklich etwas angegeben ist."
-DocType: Serial No,Purchase / Manufacture Details,Einzelheiten zu Kauf / Herstellung
-DocType: Assessment Group,Assessment Group,Beurteilungsgruppe
-apps/erpnext/erpnext/config/stock.py +329,Batch Inventory,Chargenverwaltung
-DocType: Employee,Contract End Date,Vertragsende
-DocType: Sales Order,Track this Sales Order against any Project,Diesen Kundenauftrag in jedem Projekt nachverfolgen
-DocType: Sales Invoice Item,Discount and Margin,Rabatt und Marge
-DocType: Lab Test,Prescription,Rezept
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Nicht verfügbar
-DocType: Pricing Rule,Min Qty,Mindestmenge
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Vorlage deaktivieren
-DocType: GL Entry,Transaction Date,Transaktionsdatum
-DocType: Production Plan Item,Planned Qty,Geplante Menge
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Summe Steuern
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +191,For Quantity (Manufactured Qty) is mandatory,Für Menge (hergestellte Menge) ist zwingend erforderlich
-DocType: Stock Entry,Default Target Warehouse,Standard-Eingangslager
-DocType: Purchase Invoice,Net Total (Company Currency),Nettosumme (Firmenwährung)
-apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Das Jahr Enddatum kann nicht früher als das Jahr Startdatum. Bitte korrigieren Sie die Daten und versuchen Sie es erneut.
-DocType: Notification Control,Purchase Receipt Message,Kaufbeleg-Nachricht
-DocType: BOM,Scrap Items,Ausschussartikel
-DocType: Production Order,Actual Start Date,Tatsächliches Startdatum
-DocType: Sales Order,% of materials delivered against this Sales Order,% der für diesen Kundenauftrag gelieferten Materialien
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Legen Sie den Zahlungsmodus fest
-DocType: Grant Application,Withdrawn,Zurückgezogen
-DocType: Hub Settings,Hub Settings,Hub-Einstellungen
-DocType: Project,Gross Margin %,Handelsspanne %
-DocType: BOM,With Operations,Mit Arbeitsgängen
-apps/erpnext/erpnext/accounts/party.py +260,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Es wurden bereits Buchungen in der Währung {0} für Firma {1} vorgenommen. Bitte ein Forderungs- oder Verbindlichkeiten-Konto mit Währung {0} wählen.
-DocType: Asset,Is Existing Asset,Ist bereits bestehenden Asset
-DocType: Salary Detail,Statistical Component,Statistische Komponente
-DocType: Warranty Claim,If different than customer address,Wenn anders als Kundenadresse
-DocType: Purchase Invoice,Without Payment of Tax,Ohne Steuerbefreiung
-DocType: BOM Operation,BOM Operation,Stücklisten-Vorgang
-apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Erfüllung
-DocType: Purchase Taxes and Charges,On Previous Row Amount,Auf vorherigen Zeilenbetrag
-DocType: Item,Has Expiry Date,Hat Ablaufdatum
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +282,Transfer Asset,Asset übertragen
-DocType: POS Profile,POS Profile,Verkaufsstellen-Profil
-DocType: Training Event,Event Name,Veranstaltungsname
-DocType: Physician,Phone (Office),Telefon (Büro)
-apps/erpnext/erpnext/hooks.py +151,Admission,Eintritt
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Zulassung für {0}
-apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Saisonbedingte Besonderheiten zu Budgets, Zielen usw."
-DocType: Supplier Scorecard Scoring Variable,Variable Name,Variablennamen
-apps/erpnext/erpnext/stock/get_item_details.py +144,"Item {0} is a template, please select one of its variants","Artikel {0} ist eine Vorlage, bitte eine seiner Varianten wählen"
-DocType: Asset,Asset Category,Anlagekategorie
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Nettolohn kann nicht negativ sein
-DocType: Purchase Order,Advance Paid,Angezahlt
-DocType: Item,Item Tax,Artikelsteuer
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Material to Supplier,Material an den Lieferanten
-DocType: Soil Texture,Loamy Sand,Lehmiger Sand
-DocType: Production Plan,Material Request Planning,Materialanforderungsplanung
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +630,Excise Invoice,Verbrauch Rechnung
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0} erscheint% mehr als einmal
-DocType: Expense Claim,Employees Email Id,E-Mail-ID des Mitarbeiters
-DocType: Employee Attendance Tool,Marked Attendance,Marked Teilnahme
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Laufende Verbindlichkeiten
-apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Massen-SMS an Kontakte versenden
-DocType: Patient,A Positive,A +
-DocType: Program,Program Name,Programmname
-DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Steuern oder Gebühren berücksichtigen für
-DocType: Driver,Driving License Category,Führerscheinkategorie
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158,No Reference,Keine Referenz
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Die tatsächliche Menge ist zwingend erforderlich
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} hat derzeit eine {1} Supplier Scorecard stehen, und Bestellungen an diesen Lieferanten sollten mit Vorsicht erteilt werden."
-DocType: Asset Maintenance Team,Asset Maintenance Team,Asset-Wartungsteam
-DocType: Employee Loan,Loan Type,Art des Darlehens
-DocType: Scheduling Tool,Scheduling Tool,Scheduling-Werkzeug
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Kreditkarte
-DocType: BOM,Item to be manufactured or repacked,Zu fertigender oder umzupackender Artikel
-DocType: Employee Education,Major/Optional Subjects,Wichtiger/wahlweiser Betreff
-DocType: Sales Invoice Item,Drop Ship,Streckengeschäft
-DocType: Driver,Suspended,Suspendiert
-DocType: Training Event,Attendees,Teilnehmer
-DocType: Employee,"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 pflegen"
-DocType: Academic Term,Term End Date,Semesterende
-DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Steuern und Gebühren abgezogen (Firmenwährung)
-DocType: Item Group,General Settings,Grundeinstellungen
-apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Von-Währung und Bis-Währung können nicht gleich sein
-DocType: Stock Entry,Repack,Umpacken
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Sie müssen das Formular speichern um fortzufahren
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Bitte wählen Sie zuerst die Firma aus
-DocType: Item Attribute,Numeric Values,Numerische Werte
-apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Logo anhängen
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,Lagerbestände
-DocType: Customer,Commission Rate,Provisionssatz
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Erstellte {0} Scorecards für {1} zwischen:
-apps/erpnext/erpnext/stock/doctype/item/item.js +475,Make Variant,Variante anlegen
-apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Urlaubsanträge pro Abteilung sperren
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +150,"Payment Type must be one of Receive, Pay and Internal Transfer","Zahlungsart muss eine der Receive sein, Pay und interne Übertragung"
-apps/erpnext/erpnext/config/selling.py +179,Analytics,Analysetools
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Der Warenkorb ist leer
-DocType: Vehicle,Model,Modell
-DocType: Production Order,Actual Operating Cost,Tatsächliche Betriebskosten
-DocType: Payment Entry,Cheque/Reference No,Scheck-/ Referenznummer
-DocType: Soil Texture,Clay Loam,Ton Lehm
-apps/erpnext/erpnext/accounts/doctype/account/account.py +81,Root cannot be edited.,Root kann nicht bearbeitet werden.
-DocType: Item,Units of Measure,Maßeinheiten
-DocType: Manufacturing Settings,Allow Production on Holidays,Fertigung im Urlaub zulassen
-DocType: Sales Invoice,Customer's Purchase Order Date,Kundenauftragsdatum
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Grundkapital
-DocType: Shopping Cart Settings,Show Public Attachments,Öffentliche Anhänge anzeigen
-DocType: Packing Slip,Package Weight Details,Details zum Verpackungsgewicht
-DocType: Restaurant Reservation,Reservation Time,Reservierungszeit
-DocType: Payment Gateway Account,Payment Gateway Account,Payment Gateway Konto
-DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,"Nach Abschluss der Zahlung, Benutzer auf ausgewählte Seite weiterleiten."
-DocType: Company,Existing Company,Bestehende Firma
-DocType: Healthcare Settings,Result Emailed,Ergebnis Emailed
-apps/erpnext/erpnext/controllers/buying_controller.py +87,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Steuer-Kategorie wurde in ""Total"" geändert, da alle Artikel keine Lagerartikel sind"
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Bitte eine CSV-Datei auswählen.
-DocType: Student Leave Application,Mark as Present,Als anwesend markieren
-DocType: Supplier Scorecard,Indicator Color,Indikatorfarbe
-DocType: Purchase Order,To Receive and Bill,Um zu empfangen und abzurechnen
-apps/erpnext/erpnext/controllers/buying_controller.py +455,Row #{0}: Reqd by Date cannot be before Transaction Date,Zeilennr. {0}: Erforderlich nach Datum darf nicht vor dem Transaktionsdatum liegen
-apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Ausgewählte Artikel
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Konstrukteur
-apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Vorlage für Allgemeine Geschäftsbedingungen
-DocType: Serial No,Delivery Details,Lieferdetails
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495,Cost Center is required in row {0} in Taxes table for type {1},Kostenstelle wird in Zeile {0} der Steuertabelle für Typ {1} gebraucht
-DocType: Program,Program Code,Programmcode
-DocType: Terms and Conditions,Terms and Conditions Help,Allgemeine Geschäftsbedingungen Hilfe
-,Item-wise Purchase Register,Artikelbezogene Übersicht der Einkäufe
-DocType: Driver,Expiry Date,Verfallsdatum
-DocType: Healthcare Settings,Employee name and designation in print,Name und Bezeichnung des Mitarbeiters im Druck
-,accounts-browser,Konten-Browser
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Bitte zuerst Kategorie auswählen
-apps/erpnext/erpnext/config/projects.py +13,Project master.,Projekt-Stammdaten
-apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Um eine Überberechnung oder eine Überbestellung zu ermöglichen, muss die Einstellung in den Lagereinstellungen oder im Artikel angepasst werden."
-DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Kein Symbol wie $ usw. neben Währungen anzeigen.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431, (Half Day),(Halbtags)
-DocType: Payment Term,Credit Days,Zahlungsziel
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,"Bitte wählen Sie Patient, um Labortests zu erhalten"
-apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Machen Schüler Batch
-DocType: Fee Schedule,FRQ.,FRQ
-DocType: Leave Type,Is Carry Forward,Ist Übertrag
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841,Get Items from BOM,Artikel aus der Stückliste holen
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Lieferzeittage
-DocType: Cash Flow Mapping,Is Income Tax Expense,Ist Einkommensteueraufwand
-apps/erpnext/erpnext/controllers/accounts_controller.py +620,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Datum der Veröffentlichung muss als Kaufdatum gleich sein {1} des Asset {2}
-DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Überprüfen Sie dies, wenn der Student im Gasthaus des Instituts wohnt."
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Bitte geben Sie Kundenaufträge in der obigen Tabelle
-,Stock Summary,Lager-Zusammenfassung
-apps/erpnext/erpnext/config/assets.py +54,Transfer an asset from one warehouse to another,Übertragen Sie einen Vermögenswert von einem Lager zum anderen
-DocType: Vehicle,Petrol,Benzin
-apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Stückliste
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Zeile {0}: Gruppen-Typ und Gruppe sind für Forderungen-/Verbindlichkeiten-Konto {1} zwingend erforderlich
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref-Datum
-DocType: Employee,Reason for Leaving,Grund für den Austritt
-DocType: BOM Operation,Operating Cost(Company Currency),Betriebskosten (Gesellschaft Währung)
-DocType: Employee Loan Application,Rate of Interest,Zinssatz
-DocType: Expense Claim Detail,Sanctioned Amount,Genehmigter Betrag
-DocType: Item,Shelf Life In Days,Haltbarkeit in Tagen
-DocType: GL Entry,Is Opening,Ist Eröffnungsbuchung
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Zeile {0}: Sollbuchung kann nicht mit ein(em) {1} verknüpft werden
-DocType: Journal Entry,Subscription Section,Abonnementbereich
-apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Konto {0} existiert nicht
-DocType: Training Event,Training Program,Trainingsprogramm
-DocType: Account,Cash,Bargeld
-DocType: Employee,Short biography for website and other publications.,Kurzbiographie für die Webseite und andere Publikationen.
+b'DocType: Employee',b'Salary Mode',b'Gehaltsmodus'
+b'DocType: Patient',b'Divorced',b'Geschieden'
+b'DocType: Buying Settings',b'Allow Item to be added multiple times in a transaction',"b'Zulassen, dass ein Artikel mehrfach in einer Transaktion hinzugef\xc3\xbcgt werden kann'"
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33',b'Cancel Material Visit {0} before cancelling this Warranty Claim',b'Materialkontrolle {0} stornieren vor Abbruch dieses Garantieantrags'
+b'apps/erpnext/erpnext/config/education.py +118',b'Assessment Reports',b'Bewertungsberichte'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19',b'Consumer Products',b'Verbrauchsg\xc3\xbcter'
+b'DocType: Purchase Receipt',b'Subscription Detail',b'Abonnement Detail'
+b'DocType: Supplier Scorecard',b'Notify Supplier',b'Lieferanten benachrichtigen'
+b'DocType: Item',b'Customer Items',b'Kunden-Artikel'
+b'DocType: Project',b'Costing and Billing',b'Kalkulation und Abrechnung'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +48',b'Account {0}: Parent account {1} can not be a ledger',b'Konto {0}: \xc3\x9cbergeordnetes Konto {1} kann kein Kontenblatt sein'
+b'DocType: Item',b'Publish Item to hub.erpnext.com',b'Artikel \xc3\xbcber hub.erpnext.com ver\xc3\xb6ffentlichen'
+b'apps/erpnext/erpnext/config/setup.py +88',b'Email Notifications',b'E-Mail-Benachrichtigungen'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26',b'Evaluation',b'Beurteilung'
+b'DocType: Item',b'Default Unit of Measure',b'Standardma\xc3\x9feinheit'
+b'DocType: SMS Center',b'All Sales Partner Contact',b'Alle Vertriebspartnerkontakte'
+b'DocType: Employee',b'Leave Approvers',b'Urlaubsgenehmiger'
+b'DocType: Sales Partner',b'Dealer',b'H\xc3\xa4ndler'
+b'DocType: Work Order',b'WO-',b'WO-'
+b'DocType: Consultation',b'Investigations',b'Untersuchungen'
+b'DocType: Restaurant Order Entry',b'Click Enter To Add',b'Klicken Sie zum Hinzuf\xc3\xbcgen auf Hinzuf\xc3\xbcgen.'
+b'DocType: Employee',b'Rented',b'Gemietet'
+b'DocType: Purchase Order',b'PO-',b'PO-'
+b'DocType: Vehicle Service',b'Mileage',b'Kilometerstand'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +253',b'Do you really want to scrap this asset?',b'M\xc3\xb6chten Sie diesen Gegenstand wirklich entsorgen?'
+b'DocType: Drug Prescription',b'Update Schedule',b'Aktualisierungsplan'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44',b'Select Default Supplier',b'Standard -Lieferant ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37',b'Currency is required for Price List {0}',b'W\xc3\xa4hrung f\xc3\xbcr Preisliste {0} erforderlich'
+b'DocType: Sales Taxes and Charges Template',b'* Will be calculated in the transaction.',b'* Wird in der Transaktion berechnet.'
+b'DocType: Purchase Order',b'Customer Contact',b'Kundenkontakt'
+b'DocType: Patient Appointment',b'Check availability',b'Verf\xc3\xbcgbarkeit pr\xc3\xbcfen'
+b'DocType: Job Applicant',b'Job Applicant',b'Bewerber'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6',b'This is based on transactions against this Supplier. See timeline below for details',b'Dies basiert auf Transaktionen gegen diesen Lieferanten. Siehe Zeitleiste unten f\xc3\xbcr Details'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120',b'Legal',b'Rechtswesen'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191',b'Actual type tax cannot be included in Item rate in row {0}',b'Tats\xc3\xa4chliche Steuerart kann nicht im Artikelpreis in Zeile {0} beinhaltet sein'
+b'DocType: Bank Guarantee',b'Customer',b'Kunde'
+b'DocType: Purchase Receipt Item',b'Required By',b'Ben\xc3\xb6tigt von'
+b'DocType: Delivery Note',b'Return Against Delivery Note',b'Zur\xc3\xbcck zum Lieferschein'
+b'DocType: Purchase Order',b'% Billed',b'% verrechnet'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43',b'Exchange Rate must be same as {0} {1} ({2})',b'Wechselkurs muss derselbe wie {0} {1} ({2}) sein'
+b'DocType: Sales Invoice',b'Customer Name',b'Kundenname'
+b'DocType: Vehicle',b'Natural Gas',b'Erdgas'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64',b'Bank account cannot be named as {0}',b'Bankname {0} ung\xc3\xbcltig'
+b'DocType: Account',b'Heads (or groups) against which Accounting Entries are made and balances are maintained.',"b'Typen (oder Gruppen), zu denen Buchungseintr\xc3\xa4ge vorgenommen und Salden gef\xc3\xbchrt werden.'"
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196',b'Outstanding for {0} cannot be less than zero ({1})',b'Ausst\xc3\xa4nde f\xc3\xbcr {0} k\xc3\xb6nnen nicht kleiner als Null sein ({1})'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348',b'There are no submitted Salary Slips to process.',b'Es gibt keine eingereichten Salary Slips zu verarbeiten.'
+b'DocType: Manufacturing Settings',b'Default 10 mins',b'Standard 10 Minuten'
+b'DocType: Leave Type',b'Leave Type Name',b'Bezeichnung der Abwesenheit'
+b'apps/erpnext/erpnext/templates/pages/projects.js +62',b'Show open',b'zeigen open'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8',b'It is necessary to take this action today itself for the above mentioned recurring',"b'Es ist notwendig, diese Handlung heute selbst f\xc3\xbcr die oben erw\xc3\xa4hnten wiederkehrenden zu nehmen'"
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156',b'Series Updated Successfully',b'Nummernkreise erfolgreich ge\xc3\xa4ndert'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6',b'Checkout',b'Auschecken'
+b'DocType: Pricing Rule',b'Apply On',b'Anwenden auf'
+b'DocType: Item Price',b'Multiple Item prices.',b'Mehrere verschiedene Artikelpreise'
+,b'Purchase Order Items To Be Received',b'Eingehende Lieferantenauftrags-Artikel'
+b'DocType: SMS Center',b'All Supplier Contact',b'Alle Lieferantenkontakte'
+b'DocType: Support Settings',b'Support Settings',b'Support-Einstellungen'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +75',b'Expected End Date can not be less than Expected Start Date',b'Voraussichtliches Enddatum kann nicht vor dem voraussichtlichen Startdatum liegen'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +121',b'Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ',b'Zeile #{0}: Preis muss derselbe wie {1}: {2} ({3} / {4}) sein'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241',b'New Leave Application',b'Neuer Urlaubsantrag'
+,b'Batch Item Expiry Status',b'Stapelobjekt Ablauf-Status'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184',b'Bank Draft',b'Bankwechsel'
+b'DocType: Membership',b'membership validaty section',b'Mitgliedschaft validity Abschnitt'
+b'DocType: Mode of Payment Account',b'Mode of Payment Account',b'Art des Zahlungskontos'
+b'DocType: Consultation',b'Consultation',b'Beratung'
+b'DocType: Accounts Settings',b'Show Payment Schedule in Print',b'Zeige Zahlungstermin in Drucken'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19',b'Sales and Returns',b'Verkauf und Retouren'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +56',b'Show Variants',b'Varianten anzeigen'
+b'DocType: Academic Term',b'Academic Term',b'Semester'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14',b'Material',b'Stoff'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66',b'Making website',b'Website erstellen'
+b'DocType: Opening Invoice Creation Tool Item',b'Quantity',b'Menge'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546',b'Accounts table cannot be blank.',b'Kontenliste darf nicht leer sein.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154',b'Loans (Liabilities)',b'Darlehen/Kredite (Verbindlichkeiten)'
+b'DocType: Employee Education',b'Year of Passing',b'Abschlussjahr'
+b'DocType: Item',b'Country of Origin',b'Herkunftsland'
+b'DocType: Soil Texture',b'Soil Texture Criteria',b'Bodentextur Kriterien'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +25',b'In Stock',b'Auf Lager'
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16',b'Primary Contact Details',b'Prim\xc3\xa4re Kontaktdaten'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46',b'Open Issues',b'offene Probleme'
+b'DocType: Production Plan Item',b'Production Plan Item',b'Artikel auf dem Produktionsplan'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +149',b'User {0} is already assigned to Employee {1}',b'Benutzer {0} ist bereits Mitarbeiter {1} zugewiesen'
+b'DocType: Lab Test Groups',b'Add new line',b'Neue Zeile hinzuf\xc3\xbcgen'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31',b'Health Care',b'Gesundheitswesen'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65',b'Delay in payment (Days)',b'Zahlungsverzug (Tage)'
+b'DocType: Payment Terms Template Detail',b'Payment Terms Template Detail',b'Details zur Zahlungsbedingungsvorlage'
+b'DocType: Hotel Room Reservation',b'Guest Name',b'Gastname'
+b'DocType: Lab Prescription',b'Lab Prescription',b'Labor Rezept'
+,b'Delay Days',b'Verz\xc3\xb6gerungstage'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26',b'Service Expense',b'Dienstzeitaufwand'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899',b'Serial Number: {0} is already referenced in Sales Invoice: {1}',b'Seriennummer: {0} wird bereits in der Verkaufsrechnung referenziert: {1}'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889',b'Invoice',b'Rechnung'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145',b'Make Retention Stock Entry',b'Machen Sie den Vorratsbestandseintrag'
+b'DocType: Purchase Invoice Item',b'Item Weight Details',b'Artikel Gewicht Details'
+b'DocType: Asset Maintenance Log',b'Periodicity',b'H\xc3\xa4ufigkeit'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21',b'Fiscal Year {0} is required',b'Fiscal Year {0} ist erforderlich'
+b'DocType: Crop Cycle',b'The minimum distance between rows of plants for optimum growth',b'Der Mindestabstand zwischen den Pflanzenreihen f\xc3\xbcr optimales Wachstum'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21',b'Defense',b'Verteidigung'
+b'DocType: Salary Component',b'Abbr',b'K\xc3\xbcrzel'
+b'DocType: Appraisal Goal',b'Score (0-5)',b'Punktzahl (0-5)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225',b'Row {0}: {1} {2} does not match with {3}',b'Zeile {0}: {1} {2} stimmt nicht mit {3} \xc3\xbcberein'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77',b'Row # {0}:',b'Zeile # {0}:'
+b'DocType: Timesheet',b'Total Costing Amount',b'Gesamtkalkulation Betrag'
+b'DocType: Delivery Note',b'Vehicle No',b'Fahrzeug-Nr.'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163',b'Please select Price List',b'Bitte eine Preisliste ausw\xc3\xa4hlen'
+b'DocType: Accounts Settings',b'Currency Exchange Settings',b'W\xc3\xa4hrungsaustausch Einstellungen'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94',b'Row #{0}: Payment document is required to complete the trasaction',"b'Row # {0}: Zahlungsbeleg ist erforderlich, um die trasaction abzuschlie\xc3\x9fen'"
+b'DocType: Work Order Operation',b'Work In Progress',b'Laufende Arbeit/-en'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13',b'Please select date',b'Bitte w\xc3\xa4hlen Sie Datum'
+b'DocType: Daily Work Summary Group',b'Holiday List',b'Urlaubs\xc3\xbcbersicht'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88',b'Please setup numbering series for Attendance via Setup &gt; Numbering Series',b'Bitte richten Sie die Nummerierungsserie f\xc3\xbcr die Teilnahme \xc3\xbcber Setup&gt; Nummerierungsserie ein'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127',b'Accountant',b'Buchhalter'
+b'DocType: Hub Settings',b'Selling Price List',b'Verkaufspreisliste'
+b'DocType: Patient',b'Tobacco Current Use',b'Tabakstrom Verwendung'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56',b'Selling Rate',b'Verkaufsrate'
+b'DocType: Cost Center',b'Stock User',b'Lager-Benutzer'
+b'DocType: Soil Analysis',b'(Ca+Mg)/K',b'(Ca + Mg) / K'
+b'DocType: Company',b'Phone No',b'Telefonnummer'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239',b'New {0}: #{1}',b'Neu {0}: #{1}'
+b'DocType: Delivery Trip',b'Initial Email Notification Sent',b'Erste E-Mail-Benachrichtigung gesendet'
+,b'Sales Partners Commission',b'Vertriebspartner-Provision'
+b'DocType: Soil Texture',b'Sandy Clay Loam',b'Sandiger Ton Lehm'
+b'DocType: Purchase Invoice',b'Rounding Adjustment',b'Rundungseinstellung'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +46',b'Abbreviation cannot have more than 5 characters',b'Abk\xc3\xbcrzung darf nicht l\xc3\xa4nger als 5 Zeichen sein'
+b'DocType: Physician Schedule Time Slot',b'Physician Schedule Time Slot',b'Arzt Zeitplan Zeitplan'
+b'DocType: Payment Request',b'Payment Request',b'Zahlungsaufforderung'
+b'DocType: Asset',b'Value After Depreciation',b'Wert nach Abschreibung'
+b'DocType: Student',b'O+',b'O +'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8',b'Related',b'Zugeh\xc3\xb6rig'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43',"b""Attendance date can not be less than employee's joining date""",b'Die Teilnahme Datum kann nicht kleiner sein als Verbindungsdatum des Mitarbeiters'
+b'DocType: Grading Scale',b'Grading Scale Name',b'Notenskala Namen'
+b'DocType: Subscription',b'Repeat on Day',b'Wiederholen am Tag'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +41',b'This is a root account and cannot be edited.',b'Dies ist ein Root-Konto und kann nicht bearbeitet werden.'
+b'DocType: Sales Invoice',b'Company Address',b'Firmenanschrift'
+b'DocType: BOM',b'Operations',b'Arbeitsvorbereitung'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38',b'Cannot set authorization on basis of Discount for {0}',b'Genehmigung kann nicht auf der Basis des Rabattes f\xc3\xbcr {0} festgelegt werden'
+b'DocType: Rename Tool',"b'Attach .csv file with two columns, one for the old name and one for the new name'","b'.csv-Datei mit zwei Zeilen, eine f\xc3\xbcr den alten und eine f\xc3\xbcr den neuen Namen, anh\xc3\xa4ngen'"
+b'apps/erpnext/erpnext/accounts/utils.py +73',b'{0} {1} not in any active Fiscal Year.',b'{0} {1} nicht in einem aktiven Gesch\xc3\xa4ftsjahr.'
+b'DocType: Packed Item',b'Parent Detail docname',b'\xc3\x9cbergeordnetes Detail Dokumentenname'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69',"b'Reference: {0}, Item Code: {1} and Customer: {2}'","b'Referenz: {0}, Item Code: {1} und Kunde: {2}'"
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Kg',b'kg'
+b'apps/erpnext/erpnext/config/hr.py +45',b'Opening for a Job.',b'Stellenausschreibung'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114',b'BOM is not specified for subcontracting item {0} at row {1}',b'Die St\xc3\xbcckliste ist f\xc3\xbcr die Lohnbearbeitungseinheit {0} in der Zeile {1} nicht angegeben.'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149',b'{0} Result submittted',b'{0} Ergebnis \xc3\xbcbermittelt'
+b'DocType: Item Attribute',b'Increment',b'Schrittweite'
+b'apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74',b'Timespan',b'Zeitspanne'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +58',b'Select Warehouse...',b'Lager ausw\xc3\xa4hlen ...'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6',b'Advertising',b'Werbung'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22',b'Same Company is entered more than once',b'Gleiche Firma wurde mehr als einmal eingegeben'
+b'DocType: Patient',b'Married',b'Verheiratet'
+b'apps/erpnext/erpnext/accounts/party.py +41',b'Not permitted for {0}',b'Nicht zul\xc3\xa4ssig f\xc3\xbcr {0}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593',b'Get items from',b'Holen Sie Elemente aus'
+b'DocType: Price List',b'Price Not UOM Dependant',b'Preis nicht UOM abh\xc3\xa4ngig'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467',b'Stock cannot be updated against Delivery Note {0}',b'Lager kann nicht mit Lieferschein {0} aktualisiert werden'
+b'apps/erpnext/erpnext/templates/pages/home.py +25',b'Product {0}',b'Produkt {0}'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +43',b'No items listed',b'Keine Artikel aufgef\xc3\xbchrt'
+b'DocType: Asset Repair',b'Error Description',b'Fehlerbeschreibung'
+b'DocType: Payment Reconciliation',b'Reconcile',b'Abgleichen'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30',b'Grocery',b'Lebensmittelgesch\xc3\xa4ft'
+b'DocType: Quality Inspection Reading',b'Reading 1',b'Ablesewert 1'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40',b'Pension Funds',b'Pensionsfonds'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +91',b'Next Depreciation Date cannot be before Purchase Date',b'N\xc3\xa4chstes Abschreibedatum kann nicht vor dem Kaufdatum sein'
+b'DocType: Crop',b'Perennial',b'Staude'
+b'DocType: Consultation',b'Consultation Date',b'Konsultationsdatum'
+b'DocType: Accounts Settings',b'Use Custom Cash Flow Format',b'Verwenden Sie das benutzerdefinierte Cashflow-Format'
+b'DocType: SMS Center',b'All Sales Person',b'Alle Vertriebsmitarbeiter'
+b'DocType: Monthly Distribution',b'**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.',"b'** Monatliche Aussch\xc3\xbcttung ** hilft Ihnen, das Budget / Ziel \xc3\xbcber Monate zu verteilen, wenn Sie Saisonalit\xc3\xa4t in Ihrem Unternehmen haben.'"
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1753',b'Not items found',b'Nicht Artikel gefunden'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184',b'Salary Structure Missing',b'Gehaltsstruktur Fehlende'
+b'DocType: Lead',b'Person Name',b'Name der Person'
+b'DocType: Sales Invoice Item',b'Sales Invoice Item',b'Ausgangsrechnungs-Artikel'
+b'DocType: Account',b'Credit',b'Haben'
+b'DocType: POS Profile',b'Write Off Cost Center',b'Kostenstelle f\xc3\xbcr Abschreibungen'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +117',"b'e.g. ""Primary School"" or ""University""'","b'z.B. ""Grundschule"" oder ""Universit\xc3\xa4t""'"
+b'apps/erpnext/erpnext/config/stock.py +28',b'Stock Reports',b'Lagerberichte'
+b'DocType: Warehouse',b'Warehouse Detail',b'Lagerdetail'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33',b'The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',b'Der Begriff Enddatum kann nicht sp\xc3\xa4ter sein als das Jahr Enddatum des Akademischen Jahres an dem der Begriff verkn\xc3\xbcpft ist (Akademisches Jahr {}). Bitte korrigieren Sie die Daten und versuchen Sie es erneut.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +269',"b'""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item'","b'""Ist Anlageverm\xc3\xb6gen"" kann nicht deaktiviert werden, da Anlagebuchung gegen den Artikel vorhanden'"
+b'DocType: Delivery Trip',b'Departure Time',b'Abfahrtszeit'
+b'DocType: Vehicle Service',b'Brake Oil',b'Brems\xc3\xb6l'
+b'DocType: Tax Rule',b'Tax Type',b'Steuerart'
+,b'Completed Work Orders',b'Abgeschlossene Arbeitsauftr\xc3\xa4ge'
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +581',b'Taxable Amount',b'Steuerpflichtiger Betrag'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160',b'You are not authorized to add or update entries before {0}',b'Sie haben keine Berechtigung Buchungen vor {0} hinzuzuf\xc3\xbcgen oder zu aktualisieren'
+b'DocType: BOM',b'Item Image (if not slideshow)',b'Artikelbild (wenn keine Diashow)'
+b'DocType: Work Order Operation',b'(Hour Rate / 60) * Actual Operation Time',b'(Stundensatz / 60) * tats\xc3\xa4chliche Betriebszeit'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103',b'Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry',b'Row # {0}: Referenzdokumenttyp muss einer der Kostenanspr\xc3\xbcche oder des Journaleintrags sein'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975',b'Select BOM',b'W\xc3\xa4hlen Sie BOM'
+b'DocType: SMS Log',b'SMS Log',b'SMS-Protokoll'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Delivered Items',b'Aufwendungen f\xc3\xbcr gelieferte Artikel'
+b'apps/erpnext/erpnext/config/hr.py +127',b'Manage advance amount given to the Employee',b'Verwalten Sie den Vorschussbetrag an den Mitarbeiter'
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38',b'The holiday on {0} is not between From Date and To Date',b'Der Urlaub am {0} ist nicht zwischen dem Von-Datum und dem Bis-Datum'
+b'DocType: Student Log',b'Student Log',b'Studenten Log'
+b'apps/erpnext/erpnext/config/buying.py +165',b'Templates of supplier standings.',b'Vorlagen der Lieferantenwertung.'
+b'DocType: Lead',b'Interested',b'Interessiert'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216',b'Opening',b'Er\xc3\xb6ffnung'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32',b'From {0} to {1}',b'Von {0} bis {1}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234',b'Program: ',b'Programm:'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50',b'Failed to setup taxes',b'Fehler beim Einrichten der Steuern'
+b'DocType: Item',b'Copy From Item Group',b'Von Artikelgruppe kopieren'
+b'DocType: Delivery Trip',b'Delivery Notification',b'Versandbenachrichtigung'
+b'DocType: Journal Entry',b'Opening Entry',b'Er\xc3\xb6ffnungsbuchung'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25',b'Account Pay Only',b'Reines Zahlungskonto'
+b'DocType: Employee Loan',b'Repay Over Number of Periods',b'Repay \xc3\xbcber Anzahl der Perioden'
+b'DocType: Stock Entry',b'Additional Costs',b'Zus\xc3\xa4tzliche Kosten'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +138',b'Account with existing transaction can not be converted to group.',b'Ein Konto mit bestehenden Transaktionen kann nicht in eine Gruppe umgewandelt werden'
+b'DocType: Lead',b'Product Enquiry',b'Produktanfrage'
+b'DocType: Education Settings',b'Validate Batch for Students in Student Group',b'Validiere Charge f\xc3\xbcr Studierende in der Studentengruppe'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35',b'No leave record found for employee {0} for {1}',b'Kein Urlaubssatz f\xc3\xbcr Mitarbeiter gefunden {0} von {1}'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23',b'Please enter company first',b'Bitte zuerst die Firma angeben'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365',b'Please select Company first',b'Bitte zuerst Firma ausw\xc3\xa4hlen'
+b'DocType: Employee Education',b'Under Graduate',b'Schulabg\xc3\xa4nger'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27',b'Target On',b'Ziel auf'
+b'DocType: BOM',b'Total Cost',b'Gesamtkosten'
+b'DocType: Soil Analysis',b'Ca/K',b'Ca / K'
+b'DocType: Journal Entry Account',b'Employee Loan',b'MItarbeiterdarlehen'
+b'DocType: Fee Schedule',b'Send Payment Request Email',b'Sende Zahlungsauftrag E-Mail'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268',b'Item {0} does not exist in the system or has expired',b'Artikel {0} ist nicht im System vorhanden oder abgelaufen'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44',b'Real Estate',b'Immobilien'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1',b'Statement of Account',b'Kontoauszug'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41',b'Pharmaceuticals',b'Pharmaprodukte'
+b'DocType: Purchase Invoice Item',b'Is Fixed Asset',b'Ist Anlageverm\xc3\xb6gen'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273',"b'Available qty is {0}, you need {1}'","b'Verf\xc3\xbcgbare Menge ist {0}, m\xc3\xbcssen Sie {1}'"
+b'DocType: Expense Claim Detail',b'Claim Amount',b'Betrag einfordern'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +653',b'Work Order has been {0}',b'Arbeitsauftrag wurde {0}'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56',b'Duplicate customer group found in the cutomer group table',b'Doppelte Kundengruppe in der cutomer Gruppentabelle gefunden'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31',b'Supplier Type / Supplier',b'Lieferantentyp / Lieferant'
+b'DocType: Naming Series',b'Prefix',b'Pr\xc3\xa4fix'
+b'apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7',b'Event Location',b'Veranstaltungsort'
+b'DocType: Asset Settings',b'Asset Settings',b'Anlageneinstellungen'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68',b'Consumable',b'Verbrauchsgut'
+b'DocType: Student',b'B-',b'B-'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98',b'Successfully unregistered.',b'Erfolgreich nicht registriert.'
+b'DocType: Assessment Result',b'Grade',b'Klasse'
+b'DocType: Restaurant Table',b'No of Seats',b'Anzahl der Sitze'
+b'DocType: Subscription',"b'To add dynamic subject, use jinja tags like\n\n<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>'","b'Um dynamisches Thema hinzuzuf\xc3\xbcgen, benutze Jinja-Tags wie <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>'"
+b'DocType: Sales Invoice Item',b'Delivered By Supplier',b'Geliefert von Lieferant'
+b'DocType: Asset Maintenance Task',b'Asset Maintenance Task',b'Asset-Wartungsaufgabe'
+b'DocType: SMS Center',b'All Contact',b'Alle Kontakte'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232',b'Annual Salary',b'Jahresgehalt'
+b'DocType: Daily Work Summary',b'Daily Work Summary',b't\xc3\xa4gliche Arbeitszusammenfassung'
+b'DocType: Period Closing Voucher',b'Closing Fiscal Year',b'Abschluss des Gesch\xc3\xa4ftsjahres'
+b'apps/erpnext/erpnext/accounts/party.py +392',b'{0} {1} is frozen',b'{0} {1} ist gesperrt'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +140',b'Please select Existing Company for creating Chart of Accounts',b'Bitte w\xc3\xa4hlen Sie Bestehende Unternehmen f\xc3\xbcr die Erstellung von Konten'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80',b'Stock Expenses',b'Lagerkosten'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'W\xc3\xa4hlen Sie Target Warehouse'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.js +80',b'Please enter Preferred Contact Email',b'Bitte geben Sie Bevorzugte Kontakt per E-Mail'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxNum',b'CompAuxNum'
+b'DocType: Journal Entry',b'Contra Entry',b'Gegenbuchung'
+b'DocType: Journal Entry Account',b'Credit in Company Currency',b'(Gut)Haben in Unternehmensw\xc3\xa4hrung'
+b'DocType: Lab Test UOM',b'Lab Test UOM',b'Labortest UOM'
+b'DocType: Delivery Note',b'Installation Status',b'Installationsstatus'
+b'DocType: BOM',b'Quality Inspection Template',b'Qualit\xc3\xa4tsinspektionsvorlage'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135',b'Do you want to update attendance?<br>Present: {0}\\\n\t\t\t\t\t<br>Absent: {1}',b'Wollen Sie die Teilnahme zu aktualisieren? <br> Present: {0} \\ <br> Abwesend: {1}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +334',b'Accepted + Rejected Qty must be equal to Received quantity for Item {0}',b'Akzeptierte + abgelehnte Menge muss f\xc3\xbcr diese Position {0} gleich der erhaltenen Menge sein'
+b'DocType: Request for Quotation',b'RFQ-',b'RFQ-'
+b'DocType: Item',b'Supply Raw Materials for Purchase',b'Rohmaterial f\xc3\xbcr Einkauf bereitstellen'
+b'DocType: Agriculture Analysis Criteria',b'Fertilizer',b'D\xc3\xbcnger'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152',b'At least one mode of payment is required for POS invoice.',b'Mindestens eine Art der Bezahlung ist f\xc3\xbcr POS-Rechnung erforderlich.'
+b'DocType: Products Settings',b'Show Products as a List',b'Produkte anzeigen als Liste'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +532',b'Item {0} is not active or end of life has been reached',b'Artikel {0} ist nicht aktiv oder hat das Ende der Lebensdauer erreicht'
+b'DocType: Student Admission Program',b'Minimum Age',b'Mindestalter'
+b'apps/erpnext/erpnext/utilities/user_progress.py +190',b'Example: Basic Mathematics',b'Beispiel: Basismathematik'
+b'DocType: Customer',b'Primary Address',b'Hauptadresse'
+b'DocType: Production Plan',b'Material Request Detail',b'Materialanforderungsdetail'
+b'DocType: Selling Settings',b'Default Quotation Validity Days',b'Standard-Angebotsg\xc3\xbcltigkeitstage'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +800',"b'To include tax in row {0} in Item rate, taxes in rows {1} must also be included'","b'Um Steuern im Artikelpreis in Zeile {0} einzubeziehen, m\xc3\xbcssen Steuern in den Zeilen {1} ebenfalls einbezogen sein'"
+b'apps/erpnext/erpnext/config/hr.py +223',b'Settings for HR Module',b'Einstellungen f\xc3\xbcr das Personal-Modul'
+b'DocType: SMS Center',b'SMS Center',b'SMS-Center'
+b'DocType: Sales Invoice',b'Change Amount',b'Anzahl \xc3\xa4ndern'
+b'DocType: GST Settings',b'Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.',b'Rechnungswert f\xc3\xbcr B2C festlegen B2CL und B2CS basierend auf diesem Rechnungswert berechnet.'
+b'DocType: BOM Update Tool',b'New BOM',b'Neue St\xc3\xbcckliste'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36',b'Show only POS',b'Zeige nur POS'
+b'DocType: Driver',b'Driving License Categories',b'F\xc3\xbchrerscheinkategorien'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118',b'Please enter Delivery Date',b'Bitte geben Sie das Lieferdatum ein'
+b'DocType: Depreciation Schedule',b'Make Depreciation Entry',b'Neuen Abschreibungseintrag erstellen'
+b'DocType: Appraisal Template Goal',b'KRA',b'KRA'
+b'DocType: Lead',b'Request Type',b'Anfragetyp'
+b'apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17',b'Make Employee',b'Mitarbeiter anlegen'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14',b'Broadcasting',b'Rundfunk'
+b'apps/erpnext/erpnext/config/accounts.py +313',b'Setup mode of POS (Online / Offline)',b'Einrichtungsmodus des POS (Online / Offline)'
+b'DocType: Manufacturing Settings',b'Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order',b'Deaktiviert die Erstellung von Zeitprotokollen f\xc3\xbcr Arbeitsauftr\xc3\xa4ge. Vorg\xc3\xa4nge d\xc3\xbcrfen nicht gegen den Arbeitsauftrag verfolgt werden'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191',b'Execution',b'Ausf\xc3\xbchrung'
+b'apps/erpnext/erpnext/config/manufacturing.py +62',b'Details of the operations carried out.',b'Details der durchgef\xc3\xbchrten Arbeitsg\xc3\xa4nge'
+b'DocType: Asset Maintenance Log',b'Maintenance Status',b'Wartungsstatus'
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10',b'Membership Details',b'Mitgliedschaftsdetails'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56',b'{0} {1}: Supplier is required against Payable account {2}',b'{0} {1}: F\xc3\xbcr das Kreditorenkonto ist ein Lieferant erforderlich {2}'
+b'apps/erpnext/erpnext/config/selling.py +52',b'Items and Pricing',b'Artikel und Preise'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2',b'Total hours: {0}',b'Stundenzahl: {0}'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43',b'From Date should be within the Fiscal Year. Assuming From Date = {0}',"b'Von-Datum sollte im Gesch\xc3\xa4ftsjahr liegen. Unter der Annahme, Von-Datum = {0}'"
+b'DocType: Drug Prescription',b'Interval',b'Intervall'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253',b'Preference',b'Pr\xc3\xa4ferenz'
+b'DocType: Grant Application',b'Individual',b'Einzelperson'
+b'DocType: Academic Term',b'Academics User',b'Benutzer: Lehre'
+b'DocType: Cheque Print Template',b'Amount In Figure',b'Betrag als Zahl'
+b'DocType: Employee Loan Application',b'Loan Info',b'Darlehensinformation'
+b'apps/erpnext/erpnext/config/maintenance.py +12',b'Plan for maintenance visits.',b'Plan f\xc3\xbcr Wartungsbesuche'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Period',b'Supplier Scorecard Zeitraum'
+b'DocType: Share Transfer',b'Share Transfer',b'Weitergabe \xc3\xbcbertragen'
+b'DocType: POS Profile',b'Customer Groups',b'Kundengruppen'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +51',b'Financial Statements',b'Jahresabschluss'
+b'DocType: Guardian',b'Students',b'Studenten'
+b'apps/erpnext/erpnext/config/selling.py +91',b'Rules for applying pricing and discount.',b'Regeln f\xc3\xbcr die Anwendung von Preisen und Rabatten'
+b'DocType: Daily Work Summary',b'Daily Work Summary Group',b'T\xc3\xa4gliche Arbeitszusammenfassungsgruppe'
+b'DocType: Physician Schedule',b'Time Slots',b'Zeitfenster'
+b'apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14',b'Price List must be applicable for Buying or Selling',b'Preisliste muss f\xc3\xbcr Einkauf oder Vertrieb g\xc3\xbcltig sein'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79',b'Installation date cannot be before delivery date for Item {0}',b'Installationsdatum kann nicht vor dem Liefertermin f\xc3\xbcr Artikel {0} liegen'
+b'DocType: Pricing Rule',b'Discount on Price List Rate (%)',b'Rabatt auf die Preisliste (%)'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112',b'Item Template',b'Artikelvorlage'
+b'apps/erpnext/erpnext/healthcare/setup.py +215',b'Biochemistry',b'Biochemie'
+b'DocType: Job Offer',b'Select Terms and Conditions',b'Bitte Gesch\xc3\xa4ftsbedingungen ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72',b'Out Value',b'Out Wert'
+b'DocType: Production Plan',b'Sales Orders',b'Kundenauftr\xc3\xa4ge'
+b'DocType: Purchase Taxes and Charges',b'Valuation',b'Bewertung'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +390',b'Set as Default',b'Als Standard festlegen'
+b'DocType: Production Plan',b'PLN-',b'PLN-'
+,b'Purchase Order Trends',b'Entwicklung Lieferantenauftr\xc3\xa4ge'
+b'apps/erpnext/erpnext/utilities/user_progress.py +78',b'Go to Customers',b'Gehen Sie zu Kunden'
+b'DocType: Hotel Room Reservation',b'Late Checkin',b'Sp\xc3\xa4ter Check-In'
+b'apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7',b'The request for quotation can be accessed by clicking on the following link',b'Die Angebotsanfrage kann durch einen Klick auf den folgenden Link abgerufen werden'
+b'apps/erpnext/erpnext/config/hr.py +81',b'Allocate leaves for the year.',b'Urlaube f\xc3\xbcr ein Jahr zuordnen'
+b'DocType: SG Creation Tool Course',b'SG Creation Tool Course',b'SG Creation Tool-Kurs'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275',b'Insufficient Stock',b'Nicht genug Lagermenge.'
+b'DocType: Manufacturing Settings',b'Disable Capacity Planning and Time Tracking',b'Kapazit\xc3\xa4tsplanung und Zeiterfassung deaktivieren'
+b'DocType: Email Digest',b'New Sales Orders',b'Neue Kundenauftr\xc3\xa4ge'
+b'DocType: Bank Guarantee',b'Bank Account',b'Bankkonto'
+b'DocType: Leave Type',b'Allow Negative Balance',b'Negativen Saldo zulassen'
+b'apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13',"b""You cannot delete Project Type 'External'""",b'Sie k\xc3\xb6nnen den Projekttyp &#39;Extern&#39; nicht l\xc3\xb6schen'
+b'DocType: Employee',b'Create User',b'Benutzer erstellen'
+b'DocType: Selling Settings',b'Default Territory',b'Standardregion'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53',b'Television',b'Fernsehen'
+b'DocType: Work Order Operation',"b""Updated via 'Time Log'""","b'Aktualisiert \xc3\xbcber ""Zeitprotokoll""'"
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +430',b'Advance amount cannot be greater than {0} {1}',b'Anzahlung kann nicht gr\xc3\xb6\xc3\x9fer sein als {0} {1}'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalCode',b'Journalcode'
+b'DocType: Naming Series',b'Series List for this Transaction',b'Nummernkreise zu diesem Vorgang'
+b'DocType: Company',b'Enable Perpetual Inventory',b'Permanente Inventur aktivieren'
+b'DocType: Company',b'Default Payroll Payable Account',b'Standardabrechnungskreditorenkonto'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51',b'Update Email Group',b'E-Mail-Gruppe aktualisieren'
+b'DocType: Sales Invoice',b'Is Opening Entry',b'Ist Er\xc3\xb6ffnungsbuchung'
+b'DocType: Lab Test Template',"b'If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. '","b'Wenn nicht markiert, wird das Element nicht in der Verkaufsrechnung angezeigt, sondern kann bei der Gruppentesterstellung verwendet werden.'"
+b'DocType: Customer Group',b'Mention if non-standard receivable account applicable',"b'Vermerken, wenn kein Standard-Forderungskonto verwendbar ist'"
+b'DocType: Course Schedule',b'Instructor Name',b'Ausbilder-Name'
+b'DocType: Supplier Scorecard',b'Criteria Setup',b'Kriterieneinstellung'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206',b'For Warehouse is required before Submit',"b'""F\xc3\xbcr Lager"" wird vor dem \xc3\x9cbertragen ben\xc3\xb6tigt'"
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8',b'Received On',b'Eingegangen am'
+b'DocType: Sales Partner',b'Reseller',b'Wiederverk\xc3\xa4ufer'
+b'DocType: Codification Table',b'Medical Code',b'Medizinischer Code'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20',b'Please enter Company',b'Bitte Firmenname angeben'
+b'DocType: Delivery Note Item',b'Against Sales Invoice Item',b'Zu Ausgangsrechnungs-Position'
+b'DocType: Agriculture Analysis Criteria',b'Linked Doctype',b'Verkn\xc3\xbcpfter Doctype'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44',b'Net Cash from Financing',b'Nettocashflow aus Finanzierung'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2375',"b'LocalStorage is full , did not save'","b'LocalStorage ist voll, nicht gespeichert'"
+b'DocType: Lead',b'Address & Contact',b'Adresse & Kontakt'
+b'DocType: Leave Allocation',b'Add unused leaves from previous allocations',b'Ungenutzten Urlaub von vorherigen Zuteilungen hinzuf\xc3\xbcgen'
+b'DocType: Sales Partner',b'Partner website',b'Partner-Website'
+b'DocType: Restaurant Order Entry',b'Add Item',b'Artikel hinzuf\xc3\xbcgen'
+b'DocType: Lab Test',b'Custom Result',b'Benutzerdefiniertes Ergebnis'
+b'DocType: Delivery Stop',b'Contact Name',b'Ansprechpartner'
+b'DocType: Course Assessment Criteria',b'Course Assessment Criteria',b'Kursbeurteilungskriterien'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18',b'Tax Id: ',b'Steuer ID:'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216',b'Student ID: ',b'Studenten ID:'
+b'DocType: POS Customer Group',b'POS Customer Group',b'POS Kundengruppe'
+b'DocType: Land Unit',b'Land Unit describing various land assets',b'Land Unit beschreibt verschiedene Land Verm\xc3\xb6genswerte'
+b'DocType: Cheque Print Template',b'Line spacing for amount in words',b'Zeilenabstand f\xc3\xbcr Betrag in Worten'
+b'DocType: Vehicle',b'Additional Details',b'Weitere Details'
+b'apps/erpnext/erpnext/templates/generators/bom.html +85',b'No description given',b'Keine Beschreibung angegeben'
+b'apps/erpnext/erpnext/config/buying.py +13',b'Request for purchase.',b'Lieferantenanfrage'
+b'DocType: Lab Test',b'Submitted Date',b'Eingeschriebenes Datum'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6',b'This is based on the Time Sheets created against this project',b'Dies wird auf der Grundlage der Zeitbl\xc3\xa4tter gegen dieses Projekt erstellt'
+,b'Open Work Orders',b'Arbeitsauftr\xc3\xa4ge \xc3\xb6ffnen'
+b'DocType: Payment Term',b'Credit Months',b'Kreditmonate'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409',b'Net Pay cannot be less than 0',b'Net Pay kann nicht kleiner als 0'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',"b'To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription'","b'Um das Senden von sich wiederholenden Fehlerbenachrichtigungen aus dem System zu beenden, haben wir das Feld Deaktiviert im Abonnement aktiviert.'"
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +121',b'Relieving Date must be greater than Date of Joining',b'Freitstellungsdatum muss nach dem Eintrittsdatum liegen'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240',b'Leaves per Year',b'Abwesenheiten pro Jahr'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130',"b""Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.""","b'Zeile {0}: Wenn es sich um eine Vorkasse-Buchung handelt, bitte ""Ist Vorkasse"" zu Konto {1} anklicken, .'"
+b'apps/erpnext/erpnext/stock/utils.py +219',b'Warehouse {0} does not belong to company {1}',b'Lager {0} geh\xc3\xb6rt nicht zu Firma {1}'
+b'DocType: Email Digest',b'Profit & Loss',b'Profiteinbu\xc3\x9fe'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Litre',b'Liter'
+b'DocType: Task',b'Total Costing Amount (via Time Sheet)',b'Gesamtkostenbetrag (\xc3\xbcber Arbeitszeitblatt)'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76',b'Please setup Students under Student Groups',b'Bitte richten Sie Sch\xc3\xbcler unter Sch\xc3\xbclergruppen ein'
+b'DocType: Item Website Specification',b'Item Website Specification',b'Artikel-Webseitenspezifikation'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449',b'Leave Blocked',b'Urlaub gesperrt'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +740',b'Item {0} has reached its end of life on {1}',b'Artikel {0} hat das Ende seiner Lebensdauer erreicht zum Datum {1}'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83',b'Bank Entries',b'Bank-Eintr\xc3\xa4ge'
+b'DocType: Crop',b'Annual',b'J\xc3\xa4hrlich'
+b'DocType: Stock Reconciliation Item',b'Stock Reconciliation Item',b'Bestandsabgleich-Artikel'
+b'DocType: Stock Entry',b'Sales Invoice No',b'Ausgangsrechnungs-Nr.'
+b'DocType: Material Request Item',b'Min Order Qty',b'Mindestbestellmenge'
+b'DocType: Student Group Creation Tool Course',b'Student Group Creation Tool Course',b'Student Group Creation Tool-Kurs'
+b'DocType: Lead',b'Do Not Contact',b'Nicht Kontakt aufnehmen'
+b'apps/erpnext/erpnext/utilities/user_progress.py +210',b'People who teach at your organisation',"b'Menschen, die in Ihrer Organisation lehren'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135',b'Software Developer',b'Software-Entwickler'
+b'DocType: Item',b'Minimum Order Qty',b'Mindestbestellmenge'
+b'DocType: Pricing Rule',b'Supplier Type',b'Lieferantentyp'
+b'DocType: Course Scheduling Tool',b'Course Start Date',b'Kursbeginn'
+,b'Student Batch-Wise Attendance',b'Student Batch-Wise Teilnahme'
+b'DocType: POS Profile',b'Allow user to edit Rate',b'Benutzer darf H\xc3\xb6he bearbeiten'
+b'DocType: Item',b'Publish in Hub',b'Im Hub ver\xc3\xb6ffentlichen'
+b'DocType: Student Admission',b'Student Admission',b'Studenten Eintritt'
+,b'Terretory',b'Region'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +762',b'Item {0} is cancelled',b'Artikel {0} wird storniert'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064',b'Material Request',b'Materialanfrage'
+b'DocType: Bank Reconciliation',b'Update Clearance Date',b'Abwicklungsdatum aktualisieren'
+,b'GSTR-2',b'GSTR-2'
+b'DocType: Item',b'Purchase Details',b'Einkaufsdetails'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407',"b""Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}""","b'Artikel {0} in Tabelle ""Rohmaterialien geliefert"" des Lieferantenauftrags {1} nicht gefunden'"
+b'DocType: Salary Slip',b'Total Principal Amount',b'Gesamtbetrag'
+b'DocType: Student Guardian',b'Relation',b'Beziehung'
+b'DocType: Student Guardian',b'Mother',b'Mutter'
+b'DocType: Restaurant Reservation',b'Reservation End Time',b'Reservierungsendzeit'
+b'DocType: Crop',b'Biennial',b'Biennale'
+b'apps/erpnext/erpnext/config/selling.py +18',b'Confirmed orders from Customers.',b'Best\xc3\xa4tigte Auftr\xc3\xa4ge von Kunden'
+b'DocType: Purchase Receipt Item',b'Rejected Quantity',b'Ausschuss-Menge'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.py +80',b'Payment request {0} created',b'Zahlungsauftrag {0} erstellt'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Open Orders',b'Offene Bestellungen'
+b'apps/erpnext/erpnext/healthcare/setup.py +255',b'Low Sensitivity',b'Geringe Empfindlichkeit'
+b'DocType: Notification Control',b'Notification Control',b'Benachrichtungseinstellungen'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +17',b'Please confirm once you have completed your training',"b'Bitte best\xc3\xa4tigen Sie, sobald Sie Ihre Ausbildung abgeschlossen haben'"
+b'DocType: Lead',b'Suggestions',b'Vorschl\xc3\xa4ge'
+b'DocType: Territory',b'Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.',b'Artikelgruppenbezogene Budgets f\xc3\xbcr diese Region erstellen. Durch Setzen der Auslieferungseinstellungen k\xc3\xb6nnen auch saisonale Aspekte mit einbezogen werden.'
+b'DocType: Payment Term',b'Payment Term Name',b'Name der Zahlungsbedingung'
+b'DocType: Healthcare Settings',b'Create documents for sample collection',b'Erstellen Sie Dokumente f\xc3\xbcr die Probenahme'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276',b'Payment against {0} {1} cannot be greater than Outstanding Amount {2}',b'Zahlung zu {0} {1} kann nicht gr\xc3\xb6\xc3\x9fer als ausstehender Betrag {2} sein'
+b'DocType: Shareholder',b'Address HTML',b'Adresse im HTML-Format'
+b'DocType: Lead',b'Mobile No.',b'Mobilfunknr.'
+b'DocType: Maintenance Schedule',b'Generate Schedule',b'Zeitplan generieren'
+b'DocType: Purchase Invoice Item',b'Expense Head',b'Ausgabenbezeichnung'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138',b'Please select Charge Type first',b'Bitte zuerst Chargentyp ausw\xc3\xa4hlen'
+b'DocType: Crop',"b'You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. '","b'Sie k\xc3\xb6nnen hier alle Aufgaben definieren, die f\xc3\xbcr diese Kultur durchgef\xc3\xbchrt werden sollen. Das Tagesfeld wird verwendet, um den Tag zu nennen, an dem die Aufgabe ausgef\xc3\xbchrt werden muss, wobei 1 der 1. Tag usw. ist.'"
+b'DocType: Student Group Student',b'Student Group Student',b'Student Group Student'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Latest',b'Neueste(r/s)'
+b'DocType: Asset Maintenance Task',b'2 Yearly',b'Alle 2 Jahre'
+b'DocType: Education Settings',b'Education Settings',b'Bildungseinstellungen'
+b'DocType: Vehicle Service',b'Inspection',b'Kontrolle'
+b'DocType: Supplier Scorecard Scoring Standing',b'Max Grade',b'Max Grade'
+b'DocType: Email Digest',b'New Quotations',b'Neue Angebote'
+b'DocType: HR Settings',b'Emails salary slip to employee based on preferred email selected in Employee',b'E-Mails Gehaltsabrechnung an Mitarbeiter auf Basis von bevorzugten E-Mail in Mitarbeiter ausgew\xc3\xa4hlt'
+b'DocType: Employee',b'The first Leave Approver in the list will be set as the default Leave Approver',b'Der erste Urlaubsgenehmiger auf der Liste wird als standardm\xc3\xa4\xc3\x9figer Urlaubsgenehmiger festgesetzt'
+b'DocType: Tax Rule',b'Shipping County',b'Versand-Landesbezirk/-Gemeinde/-Kreis'
+b'apps/erpnext/erpnext/config/desktop.py +167',b'Learn',b'Lernen'
+b'DocType: Asset',b'Next Depreciation Date',b'N\xc3\xa4chstes Abschreibungsdatum'
+b'apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3',b'Activity Cost per Employee',b'Aktivit\xc3\xa4tskosten je Mitarbeiter'
+b'DocType: Accounts Settings',b'Settings for Accounts',b'Konteneinstellungen'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673',b'Supplier Invoice No exists in Purchase Invoice {0}',b'Lieferantenrechnung existiert in Kauf Rechnung {0}'
+b'apps/erpnext/erpnext/config/selling.py +118',b'Manage Sales Person Tree.',b'Baumstruktur der Vertriebsmitarbeiter verwalten'
+b'DocType: Job Applicant',b'Cover Letter',b'Motivationsschreiben'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37',b'Outstanding Cheques and Deposits to clear',b'Ausstehende Schecks und Anzahlungen zum verbuchen'
+b'DocType: Item',b'Synced With Hub',b'Synchronisiert mit Hub'
+b'DocType: Driver',b'Fleet Manager',b'Flottenmanager'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542',b'Row #{0}: {1} can not be negative for item {2}',b'Row # {0}: {1} kann f\xc3\xbcr Artikel nicht negativ sein {2}'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59',b'Wrong Password',b'Falsches Passwort'
+b'DocType: Item',b'Variant Of',b'Variante von'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406',"b""Completed Qty can not be greater than 'Qty to Manufacture'""","b'Gefertigte Menge kann nicht gr\xc3\xb6\xc3\x9fer sein als ""Menge f\xc3\xbcr Herstellung""'"
+b'DocType: Period Closing Voucher',b'Closing Account Head',b'Bezeichnung des Abschlusskontos'
+b'DocType: Employee',b'External Work History',b'Externe Arbeits-Historie'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +111',b'Circular Reference Error',b'Zirkelschluss-Fehler'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206',b'Student Report Card',b'Sch\xc3\xbclerbericht-Karte'
+b'DocType: Appointment Type',b'Is Inpatient',b'Ist station\xc3\xa4r'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55',b'Guardian1 Name',b'Guardian1 Namen'
+b'DocType: Delivery Note',b'In Words (Export) will be visible once you save the Delivery Note.',"b'""In Worten (Export)"" wird sichtbar, sobald Sie den Lieferschein speichern.'"
+b'DocType: Cheque Print Template',b'Distance from left edge',b'Entfernung vom linken Rand'
+b'apps/erpnext/erpnext/utilities/bot.py +29',b'{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2})',b'{0} Einheiten [{1}] (# Form / Item / {1}) im Lager [{2}] (# Form / Lager / {2})'
+b'DocType: Lead',b'Industry',b'Industrie'
+b'DocType: Employee',b'Job Profile',b'Stellenbeschreibung'
+b'DocType: BOM Item',b'Rate & Amount',b'Rate &amp; Betrag'
+b'apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6',b'This is based on transactions against this Company. See timeline below for details',b'Dies beruht auf Transaktionen gegen diese Gesellschaft. Siehe Zeitleiste unten f\xc3\xbcr Details'
+b'DocType: Stock Settings',b'Notify by Email on creation of automatic Material Request',b'Bei Erstellung einer automatischen Materialanfrage per E-Mail benachrichtigen'
+b'apps/erpnext/erpnext/healthcare/setup.py +259',b'Resistant',b'Best\xc3\xa4ndig'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77',b'Please set Hotel Room Rate on {}',b'Bitte setzen Sie den Zimmerpreis auf {}'
+b'DocType: Journal Entry',b'Multi Currency',b'Unterschiedliche W\xc3\xa4hrungen'
+b'DocType: Opening Invoice Creation Tool',b'Invoice Type',b'Rechnungstyp'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939',b'Delivery Note',b'Lieferschein'
+b'DocType: Consultation',b'Encounter Impression',b'Begegnung Eindruck'
+b'apps/erpnext/erpnext/config/learn.py +82',b'Setting up Taxes',b'Steuern einrichten'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134',b'Cost of Sold Asset',b'Herstellungskosten des verkauften Verm\xc3\xb6gens'
+b'DocType: Volunteer',b'Morning',b'Morgen'
+b'apps/erpnext/erpnext/accounts/utils.py +350',b'Payment Entry has been modified after you pulled it. Please pull it again.',"b'Zahlungsbuchung wurde ge\xc3\xa4ndert, nachdem sie abgerufen wurde. Bitte erneut abrufen.'"
+b'DocType: Program Enrollment Tool',b'New Student Batch',b'Neue Studentencharge'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +479',b'{0} entered twice in Item Tax',b'{0} in Artikelsteuer doppelt eingegeben'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113',b'Summary for this week and pending activities',b'Zusammenfassung f\xc3\xbcr diese Woche und anstehende Aktivit\xc3\xa4ten'
+b'DocType: Student Applicant',b'Admitted',b'Zugelassen'
+b'DocType: Workstation',b'Rent Cost',b'Mietkosten'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81',b'Amount After Depreciation',b'Betrag nach Abschreibungen'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97',b'Upcoming Calendar Events',b'Die n\xc3\xa4chsten Kalender Ereignisse'
+b'apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1',b'Variant Attributes',b'Variantenattribute'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85',b'Please select month and year',b'Bitte Monat und Jahr ausw\xc3\xa4hlen'
+b'DocType: Employee',b'Company Email',b'Email-Adresse der Firma'
+b'DocType: GL Entry',b'Debit Amount in Account Currency',b'Soll-Betrag in Kontow\xc3\xa4hrung'
+b'DocType: Supplier Scorecard',b'Scoring Standings',b'Punkte z\xc3\xa4hlen'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Bestellwert'
+b'apps/erpnext/erpnext/config/accounts.py +27',b'Bank/Cash transactions against party or for internal transfer',b'Bank / Geldgesch\xc3\xa4fte gegen Partei oder f\xc3\xbcr die interne \xc3\x9cbertragung'
+b'DocType: Shipping Rule',b'Valid for Countries',b'G\xc3\xbcltig f\xc3\xbcr folgende L\xc3\xa4nder'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +55',"b""This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set""","b'Dieser Artikel ist eine Vorlage und kann nicht in Transaktionen verwendet werden. Artikelattribute werden in die Varianten kopiert, es sein denn es wurde ""nicht kopieren"" ausgew\xc3\xa4hlt'"
+b'DocType: Grant Application',b'Grant Application',b'Antrag bewilligen'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69',b'Total Order Considered',b'Gesch\xc3\xa4tzte Summe der Bestellungen'
+b'apps/erpnext/erpnext/config/hr.py +243',"b'Employee designation (e.g. CEO, Director etc.).'","b'Mitarbeiterbezeichnung (z. B. Gesch\xc3\xa4ftsf\xc3\xbchrer, Direktor etc.)'"
+b'DocType: Sales Invoice',"b""Rate at which Customer Currency is converted to customer's base currency""","b'Kurs, zu dem die Kundenw\xc3\xa4hrung in die Basisw\xc3\xa4hrung des Kunden umgerechnet wird'"
+b'DocType: Course Scheduling Tool',b'Course Scheduling Tool',b'Kursplanung Werkzeug'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +623',b'Row #{0}: Purchase Invoice cannot be made against an existing asset {1}',b'Row # {0}: Kauf Rechnung kann nicht gegen einen bereits bestehenden Asset vorgenommen werden {1}'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257',b'[Urgent] Error while creating recurring %s for %s',b'[Dringend] Fehler beim Erstellen von wiederkehrenden% s f\xc3\xbcr% s'
+b'DocType: Land Unit',b'LInked Analysis',b'Verkn\xc3\xbcpfte Analyse'
+b'DocType: Item Tax',b'Tax Rate',b'Steuersatz'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73',b'Application period cannot be across two allocation records',b'Der Bewerbungszeitraum kann nicht \xc3\xbcber zwei Zuordnungss\xc3\xa4tze liegen'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59',b'{0} already allocated for Employee {1} for period {2} to {3}',b'{0} bereits an Mitarbeiter {1} zugeteilt f\xc3\xbcr den Zeitraum {2} bis {3}'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141',b'Purchase Invoice {0} is already submitted',b'Eingangsrechnung {0} wurde bereits \xc3\xbcbertragen'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92',b'Row # {0}: Batch No must be same as {1} {2}',b'Zeile # {0}: Chargennummer muss dieselbe sein wie {1} {2}'
+b'DocType: Material Request Plan Item',b'Material Request Plan Item',b'Materialanforderung Planelement'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52',b'Convert to non-Group',b'In nicht-Gruppe umwandeln'
+b'DocType: Project Update',b'Good/Steady',b'Gut / Stetig'
+b'DocType: C-Form Invoice Detail',b'Invoice Date',b'Rechnungsdatum'
+b'DocType: GL Entry',b'Debit Amount',b'Soll-Betrag'
+b'apps/erpnext/erpnext/accounts/party.py +248',b'There can only be 1 Account per Company in {0} {1}',b'Es kann nur EIN Konto pro Unternehmen in {0} {1} geben'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426',b'Please see attachment',b'Bitte Anhang beachten'
+b'DocType: Purchase Order',b'% Received',b'% erhalten'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3',b'Create Student Groups',b'Studentengruppen erstellen'
+b'DocType: Volunteer',b'Weekends',b'Wochenenden'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Credit Note Amount',b'Gutschriftbetrag'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187',b'{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3}',b'{0} ({1}) darf nicht gr\xc3\xb6\xc3\x9fer sein als geplante Menge ({2}) im Arbeitsauftrag {3}'
+b'DocType: Setup Progress Action',b'Action Document',b'Aktions-Dokument'
+b'DocType: Chapter Member',b'Website URL',b'Webseiten-URL'
+,b'Finished Goods',b'Fertigerzeugnisse'
+b'DocType: Delivery Note',b'Instructions',b'Anweisungen'
+b'DocType: Quality Inspection',b'Inspected By',b'kontrolliert durch'
+b'DocType: Asset Maintenance Log',b'Maintenance Type',b'Wartungstyp'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45',b'{0} - {1} is not enrolled in the Course {2}',b'{0} - {1} ist nicht im Kurs {2} eingeschrieben'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225',b'Student Name: ',b'Name des Studenten:'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59',b'Serial No {0} does not belong to Delivery Note {1}',b'Seriennummer {0} geh\xc3\xb6rt nicht zu Lieferschein {1}'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97',"b""There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.""","b'Es scheint ein Problem mit der GoCardless-Konfiguration des Servers zu geben. Keine Sorge, im Falle eines Fehlers wird der Betrag Ihrem Konto gutgeschrieben.'"
+b'apps/erpnext/erpnext/templates/pages/demo.html +47',b'ERPNext Demo',b'ERPNext Demo'
+b'apps/erpnext/erpnext/public/js/utils/item_selector.js +20',b'Add Items',b'Mehrere Artikel hinzuf\xc3\xbcgen'
+b'DocType: Item Quality Inspection Parameter',b'Item Quality Inspection Parameter',b'Parameter der Artikel-Qualit\xc3\xa4tspr\xc3\xbcfung'
+b'DocType: Depreciation Schedule',b'Schedule Date',b'Geplantes Datum'
+b'apps/erpnext/erpnext/config/hr.py +116',"b'Earnings, Deductions and other Salary components'","b'Gehalt, Abz\xc3\xbcge und andere Gehaltskomponenten'"
+b'DocType: Packed Item',b'Packed Item',b'Verpackter Artikel'
+b'DocType: Job Offer Term',b'Job Offer Term',b'Jobangebot'
+b'apps/erpnext/erpnext/config/buying.py +65',b'Default settings for buying transactions.',b'Standardeinstellungen f\xc3\xbcr Einkaufstransaktionen'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29',b'Activity Cost exists for Employee {0} against Activity Type - {1}',b'Aktivit\xc3\xa4tskosten bestehen f\xc3\xbcr Arbeitnehmer {0} zur Aktivit\xc3\xa4tsart {1}'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Pflichtfeld - Holen Sie sich Studenten aus'
+b'DocType: Program Enrollment',b'Enrolled courses',b'Eingeschriebene Kurse'
+b'DocType: Currency Exchange',b'Currency Exchange',b'W\xc3\xa4hrungs-Umrechnung'
+b'DocType: Opening Invoice Creation Tool Item',b'Item Name',b'Artikelname'
+b'DocType: Authorization Rule',b'Approving User  (above authorized value)',b'Genehmigender Benutzer (\xc3\xbcber dem autorisierten Wert)'
+b'DocType: Email Digest',b'Credit Balance',b'Verf\xc3\xbcgbarer Kredit'
+b'DocType: Employee',b'Widowed',b'Verwitwet'
+b'DocType: Request for Quotation',b'Request for Quotation',b'Angebotsanfrage'
+b'DocType: Healthcare Settings',b'Require Lab Test Approval',b'Erforderliche Labortests genehmigen'
+b'DocType: Salary Slip Timesheet',b'Working Hours',b'Arbeitszeit'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59',b'Total Outstanding',b'Absolut aussergew\xc3\xb6hnlich'
+b'DocType: Naming Series',b'Change the starting / current sequence number of an existing series.',b'Anfangs- / Ist-Wert eines Nummernkreises \xc3\xa4ndern.'
+b'DocType: Dosage Strength',b'Strength',b'St\xc3\xa4rke'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1534',b'Create a new Customer',b'Erstellen Sie einen neuen Kunden'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59',"b'If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.'","b'Wenn mehrere Preisregeln weiterhin gleichrangig gelten, werden die Benutzer aufgefordert, Vorrangregelungen manuell zu erstellen, um den Konflikt zu l\xc3\xb6sen.'"
+b'apps/erpnext/erpnext/utilities/activation.py +90',b'Create Purchase Orders',b'Bestellungen erstellen'
+,b'Purchase Register',b'\xc3\x9cbersicht \xc3\xbcber Eink\xc3\xa4ufe'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116',b'Patient not found',b'Patient nicht gefunden'
+b'DocType: Scheduling Tool',b'Rechedule',b'neu Terminieren'
+b'DocType: Landed Cost Item',b'Applicable Charges',b'Anfallende Geb\xc3\xbchren'
+b'DocType: Workstation',b'Consumable Cost',b'Verbrauchskosten'
+b'DocType: Purchase Receipt',b'Vehicle Date',b'Fahrzeug-Datum'
+b'DocType: Student Log',b'Medical',b'Medizinisch'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175',b'Reason for losing',b'Grund f\xc3\xbcr das Verlieren'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +52',b'Update Account Number',b'Kontonummer aktualisieren'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +44',b'Lead Owner cannot be same as the Lead',b'Lead-Besitzer k\xc3\xb6nnen nicht gleich dem Lead sein'
+b'apps/erpnext/erpnext/accounts/utils.py +356',b'Allocated amount can not greater than unadjusted amount',b'Zugeteilter Betrag kann nicht gr\xc3\xb6\xc3\x9fer sein als nicht angepasster Betrag'
+b'DocType: Announcement',b'Receiver',b'Empf\xc3\xa4nger'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83',b'Workstation is closed on the following dates as per Holiday List: {0}',b'Arbeitsplatz ist an folgenden Tagen gem\xc3\xa4\xc3\x9f der Urlaubsliste geschlossen: {0}'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32',b'Opportunities',b'Chancen'
+b'DocType: Lab Test Template',b'Single',b'Ledig'
+b'DocType: Salary Slip',b'Total Loan Repayment',b'Insgesamt Loan R\xc3\xbcckzahlung'
+b'DocType: Account',b'Cost of Goods Sold',b'Selbstkosten'
+b'DocType: Subscription',b'Yearly',b'J\xc3\xa4hrlich'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230',b'Please enter Cost Center',b'Bitte die Kostenstelle eingeben'
+b'DocType: Drug Prescription',b'Dosage',b'Dosierung'
+b'DocType: Journal Entry Account',b'Sales Order',b'Kundenauftrag'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69',b'Avg. Selling Rate',b'Durchschnittlicher Verkaufspreis'
+b'DocType: Assessment Plan',b'Examiner Name',b'Pr\xc3\xbcfer-Name'
+b'DocType: Lab Test Template',b'No Result',b'Kein Ergebnis'
+b'DocType: Purchase Invoice Item',b'Quantity and Rate',b'Menge und Preis'
+b'DocType: Delivery Note',b'% Installed',b'% installiert'
+b'apps/erpnext/erpnext/utilities/user_progress.py +230',b'Classrooms/ Laboratories etc where lectures can be scheduled.',"b'Die Klassenr\xc3\xa4ume / Laboratorien usw., wo Vortr\xc3\xa4ge k\xc3\xb6nnen geplant werden.'"
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46',b'Please enter company name first',b'Bitte zuerst den Firmennamen angeben'
+b'DocType: Purchase Invoice',b'Supplier Name',b'Lieferantenname'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25',b'Read the ERPNext Manual',b'Lesen Sie das ERPNext-Handbuch'
+b'DocType: Purchase Invoice',b'01-Sales Return',b'01-Verkaufsr\xc3\xbcckgabe'
+b'DocType: Account',b'Is Group',b'Ist Gruppe'
+b'DocType: Email Digest',b'Pending Purchase Orders',b'Bis Bestellungen'
+b'DocType: Stock Settings',b'Automatically Set Serial Nos based on FIFO',b'Automatisch Seriennummern auf Basis FIFO einstellen'
+b'DocType: Accounts Settings',b'Check Supplier Invoice Number Uniqueness',"b'Aktivieren, damit dieselbe Lieferantenrechnungsnummer nur einmal vorkommen kann'"
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34',b'Primary Address Details',b'Prim\xc3\xa4re Adressendetails'
+b'DocType: Vehicle Service',b'Oil Change',b'\xc3\x96lwechsel'
+b'DocType: Asset Maintenance Log',b'Asset Maintenance Log',b'Anlagenwartungsprotokoll'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57',"b""'To Case No.' cannot be less than 'From Case No.'""","b'""Bis Fall Nr."" kann nicht kleiner als ""Von Fall Nr."" sein'"
+b'DocType: Chapter',b'Non Profit',b'Gemeinn\xc3\xbctzig'
+b'DocType: Production Plan',b'Not Started',b'Nicht begonnen'
+b'DocType: Lead',b'Channel Partner',b'Vertriebspartner'
+b'DocType: Account',b'Old Parent',b'Alte \xc3\xbcbergeordnetes Element'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Pflichtfeld - Akademisches Jahr'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220',b'{0} {1} is not associated with {2} {3}',b'{0} {1} ist nicht mit {2} {3} verkn\xc3\xbcpft'
+b'DocType: Notification Control',b'Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.',"b'Einleitenden Text anpassen, der zu dieser E-Mail geh\xc3\xb6rt. Jede Transaktion hat einen eigenen Einleitungstext.'"
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176',b'Please set default payable account for the company {0}',b'Bitte setzen Sie das Zahlungsverzugskonto f\xc3\xbcr die Firma {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +511',b'Transaction not allowed against stopped Work Order {0}',b'Die Transaktion ist f\xc3\xbcr den angehaltenen Arbeitsauftrag {0} nicht zul\xc3\xa4ssig.'
+b'DocType: Setup Progress Action',b'Min Doc Count',b'Min'
+b'apps/erpnext/erpnext/config/manufacturing.py +84',b'Global settings for all manufacturing processes.',b'Allgemeine Einstellungen f\xc3\xbcr alle Fertigungsprozesse'
+b'DocType: Accounts Settings',b'Accounts Frozen Upto',b'Konten gesperrt bis'
+b'DocType: SMS Log',b'Sent On',b'Gesendet am'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +700',b'Attribute {0} selected multiple times in Attributes Table',b'Attribut {0} mehrfach in Attributetabelle ausgew\xc3\xa4ht'
+b'DocType: HR Settings',b'Employee record is created using selected field. ',b'Mitarbeiter-Datensatz wird erstellt anhand des ausgew\xc3\xa4hlten Feldes.'
+b'DocType: Sales Order',b'Not Applicable',b'Nicht anwenden'
+b'apps/erpnext/erpnext/config/hr.py +70',b'Holiday master.',b'Stammdaten zum Urlaub'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85',b'Opening Invoice Item',b'Rechnungsposition \xc3\xb6ffnen'
+b'DocType: Request for Quotation Item',b'Required Date',b'Angefragtes Datum'
+b'DocType: Delivery Note',b'Billing Address',b'Rechnungsadresse'
+b'DocType: BOM',b'Costing',b'Kalkulation'
+b'DocType: Tax Rule',b'Billing County',b'Rechnung: Landesbezirk - Gemeinde - Kreis'
+b'DocType: Purchase Taxes and Charges',"b'If checked, the tax amount will be considered as already included in the Print Rate / Print Amount'","b'Wenn aktiviert, wird der Steuerbetrag als bereits in den Druckkosten enthalten erachtet.'"
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceRef',b'St\xc3\xbcckRef'
+b'DocType: Request for Quotation',b'Message for Supplier',b'Nachricht f\xc3\xbcr Lieferanten'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40',b'Work Order',b'Arbeitsauftrag'
+b'DocType: Driver',b'DRIVER-.#####',b'TREIBER-.#####'
+b'DocType: Sales Invoice',b'Total Qty',b'Gesamtmenge'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 E-Mail-ID'
+b'DocType: Item',b'Show in Website (Variant)',b'Auf der Website anzeigen (Variante)'
+b'DocType: Employee',b'Health Concerns',b'Gesundheitsfragen'
+b'DocType: Payroll Entry',b'Select Payroll Period',b'W\xc3\xa4hlen Sie Abrechnungsperiode'
+b'DocType: Purchase Invoice',b'Unpaid',b'Unbezahlt'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49',b'Reserved for sale',b'Reserviert f\xc3\xbcr Verkauf'
+b'DocType: Packing Slip',b'From Package No.',b'Von Paket Nr.'
+b'DocType: Item Attribute',b'To Range',b'Bis-Bereich'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29',b'Securities and Deposits',b'Wertpapiere und Einlagen'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46',"b""Can't change valuation method, as there are transactions against some items which does not have it's own valuation method""","b'Kann die Bewertungsmethode nicht \xc3\xa4ndern, da es Transaktionen gegen einige Posten gibt, f\xc3\xbcr die es keine eigene Bewertungsmethode gibt'"
+b'DocType: Student Report Generation Tool',b'Attended by Parents',b'Von Eltern besucht'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82',b'Total leaves allocated is mandatory',b'Die Gesamtmenge des zugeteilten Urlaubs ist zwingend erforderlich'
+b'DocType: Patient',b'AB Positive',b'AB +'
+b'DocType: Job Opening',b'Description of a Job Opening',b'Stellenbeschreibung'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110',b'Pending activities for today',b'Ausstehende Aktivit\xc3\xa4ten f\xc3\xbcr heute'
+b'apps/erpnext/erpnext/config/hr.py +24',b'Attendance record.',b'Anwesenheitsnachweis'
+b'DocType: Salary Structure',b'Salary Component for timesheet based payroll.',b'Gehaltskomponente f\xc3\xbcr Zeiterfassung basierte Abrechnung.'
+b'DocType: Sales Order Item',b'Used for Production Plan',b'Wird f\xc3\xbcr den Produktionsplan verwendet'
+b'DocType: Employee Loan',b'Total Payment',b'Gesamtzahlung'
+b'DocType: Manufacturing Settings',b'Time Between Operations (in mins)',b'Zeit zwischen den Arbeitsg\xc3\xa4ngen (in Minuten)'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132',b'{0} {1} is cancelled so the action cannot be completed',"b'{0} {1} wurde abgebrochen, deshalb kann die Aktion nicht abgeschlossen werden'"
+b'DocType: Customer',b'Buyer of Goods and Services.',b'K\xc3\xa4ufer von Waren und Dienstleistungen.'
+b'DocType: Journal Entry',b'Accounts Payable',b'Verbindlichkeiten'
+b'DocType: Patient',b'Allergies',b'Allergien'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33',b'The selected BOMs are not for the same item',b'Die ausgew\xc3\xa4hlten St\xc3\xbccklisten sind nicht f\xc3\xbcr den gleichen Artikel'
+b'DocType: Supplier Scorecard Standing',b'Notify Other',b'Andere benachrichtigen'
+b'DocType: Vital Signs',b'Blood Pressure (systolic)',b'Blutdruck (systolisch)'
+b'DocType: Pricing Rule',b'Valid Upto',b'G\xc3\xbcltig bis'
+b'DocType: Training Event',b'Workshop',b'Werkstatt'
+b'DocType: Supplier Scorecard Scoring Standing',b'Warn Purchase Orders',b'Warnung Bestellungen'
+b'apps/erpnext/erpnext/utilities/user_progress.py +67',b'List a few of your customers. They could be organizations or individuals.',b'Bitte ein paar Kunden angeben. Dies k\xc3\xb6nnen Firmen oder Einzelpersonen sein.'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23',b'Enough Parts to Build',b'Genug Teile zu bauen'
+b'DocType: POS Profile User',b'POS Profile User',b'POS-Profilbenutzer'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128',b'Direct Income',b'Direkte Ertr\xc3\xa4ge'
+b'DocType: Patient Appointment',b'Date TIme',b'Terminzeit'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45',"b'Can not filter based on Account, if grouped by Account'","b'Wenn nach Konto gruppiert wurde, kann nicht auf Grundlage des Kontos gefiltert werden.'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130',b'Administrative Officer',b'Administrativer Benutzer'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39',b'Setting up company and taxes',b'Gr\xc3\xbcndung von Unternehmen und Steuern'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Bitte w\xc3\xa4hlen Sie Kurs'
+b'DocType: Codification Table',b'Codification Table',b'Kodifizierungstabelle'
+b'DocType: Timesheet Detail',b'Hrs',b'Std'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349',b'Please select Company',b'Bitte Firma ausw\xc3\xa4hlen'
+b'DocType: Stock Entry Detail',b'Difference Account',b'Differenzkonto'
+b'DocType: Purchase Invoice',b'Supplier GSTIN',b'Lieferant GSTIN'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +47',b'Cannot close task as its dependant task {0} is not closed.',"b'Aufgabe kann nicht geschlossen werden, da die von ihr abh\xc3\xa4ngige Aufgabe {0} nicht geschlossen ist.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435',b'Please enter Warehouse for which Material Request will be raised',"b'Bitte das Lager eingeben, f\xc3\xbcr das eine Materialanfrage erhoben wird'"
+b'DocType: Work Order',b'Additional Operating Cost',b'Zus\xc3\xa4tzliche Betriebskosten'
+b'DocType: Lab Test Template',b'Lab Routine',b'Laborroutine'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20',b'Cosmetics',b'Kosmetika'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18',b'Please select Completion Date for Completed Asset Maintenance Log',b'Bitte w\xc3\xa4hlen Sie Fertigstellungsdatum f\xc3\xbcr das abgeschlossene Anlagenpflegeprotokoll'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +552',"b'To merge, following properties must be same for both items'","b'Um zwei Produkte zusammenzuf\xc3\xbchren, m\xc3\xbcssen folgende Eigenschaften f\xc3\xbcr beide Produkte gleich sein'"
+b'DocType: Shipping Rule',b'Net Weight',b'Nettogewicht'
+b'DocType: Employee',b'Emergency Phone',b'Notruf'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82',b'{0} {1} does not exist.',b'{0} {1} ist nicht vorhanden.'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29',b'Buy',b'Kaufen'
+,b'Serial No Warranty Expiry',b'Ablaufdatum der Garantie zu Seriennummer'
+b'DocType: Sales Invoice',b'Offline POS Name',b'Offline-Verkaufsstellen-Name'
+b'apps/erpnext/erpnext/utilities/user_progress.py +180',b'Student Application',b'Studentische Bewerbung'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Bitte definieren Sie Grade for Threshold 0%'
+b'DocType: Sales Order',b'To Deliver',b'Auszuliefern'
+b'DocType: Purchase Invoice Item',b'Item',b'Artikel'
+b'apps/erpnext/erpnext/healthcare/setup.py +256',b'High Sensitivity',b'Hohe Empfindlichkeit'
+b'apps/erpnext/erpnext/config/non_profit.py +48',b'Volunteer Type information.',b'Informationen zum Freiwilligentyp.'
+b'DocType: Cash Flow Mapping Template',b'Cash Flow Mapping Template',b'Cashflow-Mapping-Vorlage'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2555',b'Serial no item cannot be a fraction',b'Serien-Nr Element kann nicht ein Bruchteil sein'
+b'DocType: Journal Entry',b'Difference (Dr - Cr)',b'Differenz (Soll - Haben)'
+b'DocType: Account',b'Profit and Loss',b'Gewinn und Verlust'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104',"b'Not permitted, configure Lab Test Template as required'","b'Nicht zul\xc3\xa4ssig, konfigurieren Sie Lab Test Vorlage wie erforderlich'"
+b'DocType: Patient',b'Risk Factors',b'Risikofaktoren'
+b'DocType: Patient',b'Occupational Hazards and Environmental Factors',b'Berufsrisiken und Umweltfaktoren'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239',b'Stock Entries already created for Work Order ',"b'Lagereintr\xc3\xa4ge, die bereits f\xc3\xbcr den Arbeitsauftrag erstellt wurden'"
+b'DocType: Vital Signs',b'Respiratory rate',b'Atemfrequenz'
+b'apps/erpnext/erpnext/config/stock.py +334',b'Managing Subcontracting',b'Unterauftr\xc3\xa4ge vergeben'
+b'DocType: Vital Signs',b'Body Temperature',b'K\xc3\xb6rpertemperatur'
+b'DocType: Project',b'Project will be accessible on the website to these users',b'Projekt wird auf der Website f\xc3\xbcr diese Benutzer zug\xc3\xa4nglich sein'
+b'DocType: Detected Disease',b'Disease',b'Krankheit'
+b'apps/erpnext/erpnext/config/projects.py +29',b'Define Project type.',b'Projekttyp definieren'
+b'DocType: Supplier Scorecard',b'Weighting Function',b'Gewichtungsfunktion'
+b'DocType: Physician',b'OP Consulting Charge',b'OP Beratungsgeb\xc3\xbchr'
+b'apps/erpnext/erpnext/utilities/user_progress.py +28',b'Setup your ',b'Richten Sie Ihre'
+b'DocType: Student Report Generation Tool',b'Show Marks',b'Markierungen anzeigen'
+b'DocType: Quotation',"b""Rate at which Price list currency is converted to company's base currency""","b'Kurs, zu dem die W\xc3\xa4hrung der Preisliste in die Basisw\xc3\xa4hrung des Unternehmens umgerechnet wird'"
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +70',b'Account {0} does not belong to company: {1}',b'Konto {0} geh\xc3\xb6rt nicht zu Firma: {1}'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +52',b'Abbreviation already used for another company',b'Abk\xc3\xbcrzung bereits f\xc3\xbcr ein anderes Unternehmen verwendet'
+b'DocType: Selling Settings',b'Default Customer Group',b'Standardkundengruppe'
+b'DocType: Asset Repair',b'ARLOG-',b'ARLOG-'
+b'DocType: Global Defaults',"b""If disable, 'Rounded Total' field will not be visible in any transaction""","b'Wenn deaktiviert, wird das Feld ""Gerundeter Gesamtbetrag"" in keiner Transaktion angezeigt'"
+b'DocType: BOM',b'Operating Cost',b'Betriebskosten'
+b'DocType: Crop',b'Produced Items',b'Produzierte Artikel'
+b'DocType: Sales Order Item',b'Gross Profit',b'Rohgewinn'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49',b'Increment cannot be 0',b'Schrittweite kann nicht 0 sein'
+b'DocType: Company',b'Delete Company Transactions',b'L\xc3\xb6schen der Transaktionen dieser Firma'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364',b'Reference No and Reference Date is mandatory for Bank transaction',b'Referenznummer und Referenzdatum ist obligatorisch f\xc3\xbcr Bankengesch\xc3\xa4ft'
+b'DocType: Purchase Receipt',b'Add / Edit Taxes and Charges',b'Hinzuf\xc3\xbcgen/Bearbeiten von Steuern und Abgaben'
+b'DocType: Payment Entry Reference',b'Supplier Invoice No',b'Lieferantenrechnungsnr.'
+b'DocType: Territory',b'For reference',b'Zu Referenzzwecken'
+b'DocType: Healthcare Settings',b'Appointment Confirmation',b'Terminbest\xc3\xa4tigung'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158',"b'Cannot delete Serial No {0}, as it is used in stock transactions'","b'Die Seriennummer {0} kann nicht gel\xc3\xb6scht werden, da sie in Lagertransaktionen verwendet wird'"
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256',b'Closing (Cr)',b'Schlu\xc3\x9fstand (Haben)'
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1',b'Hello',b'Hallo'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118',b'Move Item',b'Element verschieben'
+b'DocType: Serial No',b'Warranty Period (Days)',b'Garantiefrist (Tage)'
+b'DocType: Installation Note Item',b'Installation Note Item',b'Bestandteil des Installationshinweises'
+b'DocType: Production Plan Item',b'Pending Qty',b'Ausstehende Menge'
+b'DocType: Budget',b'Ignore',b'Ignorieren'
+b'apps/erpnext/erpnext/accounts/party.py +396',b'{0} {1} is not active',b'{0} {1} ist nicht aktiv'
+b'apps/erpnext/erpnext/config/accounts.py +272',b'Setup cheque dimensions for printing',b'Setup-Kontrollma\xc3\x9fe f\xc3\xbcr den Druck'
+b'DocType: Salary Slip',b'Salary Slip Timesheet',b'Gehaltszettel Timesheet'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +160',b'Supplier Warehouse mandatory for sub-contracted Purchase Receipt',b'Lieferantenlager notwendig f\xc3\xbcr Kaufbeleg aus Unterauftr\xc3\xa4gen'
+b'DocType: Pricing Rule',b'Valid From',b'G\xc3\xbcltig ab'
+b'DocType: Sales Invoice',b'Total Commission',b'Gesamtprovision'
+b'DocType: Pricing Rule',b'Sales Partner',b'Vertriebspartner'
+b'apps/erpnext/erpnext/config/buying.py +150',b'All Supplier scorecards.',b'Alle Lieferanten-Scorecards.'
+b'DocType: Buying Settings',b'Purchase Receipt Required',b'Kaufbeleg notwendig'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188',b'Target warehouse in row {0} must be same as Work Order',b'Das Ziellager in der Zeile {0} muss mit dem Arbeitsauftrag \xc3\xbcbereinstimmen'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +155',b'Valuation Rate is mandatory if Opening Stock entered',"b'Bewertungskurs ist obligatorisch, wenn \xc3\x96ffnung Stock eingegeben'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143',b'No records found in the Invoice table',b'Keine Datens\xc3\xa4tze in der Rechnungstabelle gefunden'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34',b'Please select Company and Party Type first',b'Bitte zuerst Firma und Gruppentyp ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31',"b'Already set default in pos profile {0} for user {1}, kindly disabled default'","b'Im Standardprofil {0} f\xc3\xbcr den Benutzer {1} ist der Standard bereits festgelegt, standardm\xc3\xa4\xc3\x9fig deaktiviert'"
+b'apps/erpnext/erpnext/config/accounts.py +293',b'Financial / accounting year.',b'Finanz-/Rechnungsjahr'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9',b'Accumulated Values',b'Kumulierte Werte'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162',"b'Sorry, Serial Nos cannot be merged'","b'Verzeihung! Seriennummern k\xc3\xb6nnen nicht zusammengef\xc3\xbchrt werden,'"
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72',b'Territory is Required in POS Profile',b'Territory ist im POS-Profil erforderlich'
+b'DocType: Supplier',b'Prevent RFQs',b'Vermeidung von Ausschreibungen'
+b'apps/erpnext/erpnext/utilities/activation.py +83',b'Make Sales Order',b'Kundenauftrag erstellen'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168',b'Salary Slip submitted for period from {0} to {1}',b'Gehaltszettel f\xc3\xbcr Zeitraum von {0} bis {1} eingereicht'
+b'DocType: Project Task',b'Project Task',b'Projektvorgang'
+,b'Lead Id',b'Lead-ID'
+b'DocType: C-Form Invoice Detail',b'Grand Total',b'Gesamtbetrag'
+b'DocType: Assessment Plan',b'Course',b'Kurs'
+b'DocType: Timesheet',b'Payslip',b'payslip'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +4',b'Item Cart',b'Artikel Warenkorb'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38',b'Fiscal Year Start Date should not be greater than Fiscal Year End Date',b'Das Startdatum des Gesch\xc3\xa4ftsjahres sollte nicht nach dem Enddatum des Gsch\xc3\xa4ftsjahres liegen'
+b'DocType: Issue',b'Resolution',b'Entscheidung'
+b'DocType: C-Form',b'IV',b'IV'
+b'apps/erpnext/erpnext/templates/pages/order.html +76',b'Delivered: {0}',b'Geliefert: {0}'
+b'DocType: Expense Claim',b'Payable Account',b'Verbindlichkeiten-Konto'
+b'DocType: Payment Entry',b'Type of Payment',b'Zahlungsart'
+b'DocType: Sales Order',b'Billing and Delivery Status',b'Abrechnungs- und Lieferstatus'
+b'DocType: Job Applicant',b'Resume Attachment',b'Resume-Anlage'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58',b'Repeat Customers',b'Bestandskunden'
+b'DocType: Leave Control Panel',b'Allocate',b'Zuweisen'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108',b'Create Variant',b'Erstellen Sie eine Variante'
+b'DocType: Sales Invoice',b'Shipping Bill Date',b'Lieferschein-Datum'
+b'DocType: Production Plan',b'Production Plan',b'Produktionsplan'
+b'DocType: Opening Invoice Creation Tool',b'Opening Invoice Creation Tool',b'\xc3\x96ffnen des Rechnungserstellungswerkzeugs'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853',b'Sales Return',b'R\xc3\xbccklieferung'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96',"b""Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period""",b'Hinweis: Die aufteilbaren Gesamt Bl\xc3\xa4tter {0} sollte nicht kleiner sein als bereits genehmigt Bl\xc3\xa4tter {1} f\xc3\xbcr den Zeitraum'
+,b'Total Stock Summary',b'Gesamt Stock Zusammenfassung'
+b'DocType: Announcement',b'Posted By',b'Geschrieben von'
+b'DocType: Item',b'Delivered by Supplier (Drop Ship)',b'durch Lieferanten geliefert (Streckengesch\xc3\xa4ft)'
+b'DocType: Healthcare Settings',b'Confirmation Message',b'Best\xc3\xa4tigungsmeldung'
+b'apps/erpnext/erpnext/config/crm.py +12',b'Database of potential customers.',b'Datenbank potentieller Kunden.'
+b'DocType: Authorization Rule',b'Customer or Item',b'Kunde oder Artikel'
+b'apps/erpnext/erpnext/config/selling.py +28',b'Customer database.',b'Kundendatenbank'
+b'DocType: Quotation',b'Quotation To',b'Angebot f\xc3\xbcr'
+b'DocType: Lead',b'Middle Income',b'Mittleres Einkommen'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228',b'Opening (Cr)',b'Anfangssstand (Haben)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +872',b'Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.',"b'Die Standard-Ma\xc3\x9feinheit f\xc3\xbcr Artikel {0} kann nicht direkt ge\xc3\xa4ndert werden, weil Sie bereits einige Transaktionen mit einer anderen Ma\xc3\x9feinheit durchgef\xc3\xbchrt haben. Sie m\xc3\xbcssen einen neuen Artikel erstellen, um eine andere Standard-Ma\xc3\x9feinheit verwenden zuk\xc3\xb6nnen.'"
+b'apps/erpnext/erpnext/accounts/utils.py +354',b'Allocated amount can not be negative',b'Zugewiesene Menge kann nicht negativ sein'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Bitte setzen Sie das Unternehmen'
+b'DocType: Share Balance',b'Share Balance',b'Anteilsbestand'
+b'DocType: Purchase Order Item',b'Billed Amt',b'Rechnungsbetrag'
+b'DocType: Training Result Employee',b'Training Result Employee',b'Trainingsergebnis Mitarbeiter'
+b'DocType: Warehouse',b'A logical Warehouse against which stock entries are made.',b'Ein logisches Lager zu dem Lagerbuchungen gemacht werden.'
+b'DocType: Repayment Schedule',b'Principal Amount',b'Nennbetrag'
+b'DocType: Employee Loan Application',b'Total Payable Interest',b'Insgesamt f\xc3\xa4llige Zinsen'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57',b'Total Outstanding: {0}',b'Gesamtsumme: {0}'
+b'DocType: Sales Invoice Timesheet',b'Sales Invoice Timesheet',b'Ausgangsrechnung-Zeiterfassung'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118',b'Reference No & Reference Date is required for {0}',b'Referenznr. & Referenz-Tag sind erforderlich f\xc3\xbcr {0}'
+b'DocType: Payroll Entry',b'Select Payment Account to make Bank Entry',b'W\xc3\xa4hlen Sie ein Zahlungskonto f\xc3\xbcr die Buchung'
+b'DocType: Hotel Settings',b'Default Invoice Naming Series',b'Standard-Rechnungsbenennungsserie'
+b'apps/erpnext/erpnext/utilities/activation.py +136',"b'Create Employee records to manage leaves, expense claims and payroll'","b'Erstellen Sie Mitarbeiterdaten Bl\xc3\xa4tter, Spesenabrechnung und Gehaltsabrechnung zu verwalten'"
+b'DocType: Restaurant Reservation',b'Restaurant Reservation',b'Restaurant Reservierung'
+b'DocType: Land Unit',b'Land Unit Name',b'Name der Landeinheit'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190',b'Proposal Writing',b'Verfassen von Angeboten'
+b'DocType: Payment Entry Deduction',b'Payment Entry Deduction',b'Zahlungsabzug'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14',b'Wrapping up',b'Aufwickeln'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35',b'Notify Customers via Email',b'Benachrichtigen Sie Kunden per E-Mail'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35',b'Another Sales Person {0} exists with the same Employee id',b'Ein weiterer Vertriebsmitarbeiter {0} existiert bereits mit der gleichen Mitarbeiter ID'
+b'DocType: Employee Advance',b'Claimed Amount',b'Anspruchsbetrag'
+b'apps/erpnext/erpnext/config/education.py +180',b'Masters',b'St\xc3\xa4mme'
+b'DocType: Assessment Plan',b'Maximum Assessment Score',b'Maximale Beurteilung Score'
+b'apps/erpnext/erpnext/config/accounts.py +138',b'Update Bank Transaction Dates',b'Kontenabgleich'
+b'apps/erpnext/erpnext/config/projects.py +41',b'Time Tracking',b'Zeiterfassung'
+b'DocType: Purchase Invoice',b'DUPLICATE FOR TRANSPORTER',b'DUPLIKAT F\xc3\x9cR TRANSPORTER'
+b'apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49',b'Row {0}# Paid Amount cannot be greater than requested advance amount',b'Zeile {0} # Bezahlter Betrag darf nicht gr\xc3\xb6\xc3\x9fer sein als der angeforderte Vorschussbetrag'
+b'DocType: Fiscal Year Company',b'Fiscal Year Company',b'Gesch\xc3\xa4ftsjahr Firma'
+b'DocType: Packing Slip Item',b'DN Detail',b'DN-Detail'
+b'DocType: Training Event',b'Conference',b'Konferenz'
+b'DocType: Timesheet',b'Billed',b'Abgerechnet'
+b'DocType: Batch',b'Batch Description',b'Chargenbeschreibung'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Erstelle Studentengruppen'
+b'apps/erpnext/erpnext/accounts/utils.py +727',"b'Payment Gateway Account not created, please create one manually.'","b'Payment Gateway-Konto nicht erstellt haben, erstellen Sie bitte ein manuell.'"
+b'DocType: Supplier Scorecard',b'Per Year',b'Pro Jahr'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51',b'Not eligible for the admission in this program as per DOB',b'Nicht f\xc3\xbcr die Aufnahme in dieses Programm nach DOB geeignet'
+b'DocType: Sales Invoice',b'Sales Taxes and Charges',b'Umsatzsteuern und Geb\xc3\xbchren auf den Verkauf'
+b'DocType: Employee',b'Organization Profile',b'Firmenprofil'
+b'DocType: Vital Signs',b'Height (In Meter)',b'H\xc3\xb6he (In Meter)'
+b'DocType: Student',b'Sibling Details',b'Geschwister-Details'
+b'DocType: Vehicle Service',b'Vehicle Service',b'Fahrzeug-Service'
+b'apps/erpnext/erpnext/config/setup.py +101',b'Automatically triggers the feedback request based on conditions.',b'Automatisch l\xc3\xb6st die Anfrage Feedback basierend auf Bedingungen.'
+b'DocType: Employee',b'Reason for Resignation',b'K\xc3\xbcndigungsgrund'
+b'apps/erpnext/erpnext/config/hr.py +152',b'Template for performance appraisals.',b'Vorlage f\xc3\xbcr Mitarbeiterbeurteilungen'
+b'DocType: Sales Invoice',b'Credit Note Issued',b'Gutschrift ausgel\xc3\xb6st'
+b'DocType: Project Task',b'Weight',b'Gewicht'
+b'DocType: Payment Reconciliation',b'Invoice/Journal Entry Details',b'Einzelheiten zu Rechnungs-/Journalbuchungen'
+b'apps/erpnext/erpnext/accounts/utils.py +83',"b""{0} '{1}' not in Fiscal Year {2}""","b""{0} '{1}' nicht im Gesch\xc3\xa4ftsjahr {2}"""
+b'DocType: Buying Settings',b'Settings for Buying Module',b'Einstellungen Einkauf'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21',b'Asset {0} does not belong to company {1}',b'Anlagewert-{0} geh\xc3\xb6rt nicht zur Firma {1}'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70',b'Please enter Purchase Receipt first',b'Bitte zuerst Kaufbeleg eingeben'
+b'DocType: Buying Settings',b'Supplier Naming By',b'Bezeichnung des Lieferanten nach'
+b'DocType: Activity Type',b'Default Costing Rate',b'Standardkosten'
+b'DocType: Maintenance Schedule',b'Maintenance Schedule',b'Wartungsplan'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36',"b'Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.'","b'Dann werden Preisregeln bezogen auf Kunde, Kundengruppe, Region, Lieferant, Lieferantentyp, Kampagne, Vertriebspartner usw. ausgefiltert'"
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29',b'Net Change in Inventory',b'Nettover\xc3\xa4nderung des Bestands'
+b'apps/erpnext/erpnext/config/hr.py +162',b'Employee Loan Management',b'Verwaltung der Mitarbeiterdarlehen'
+b'DocType: Employee',b'Passport Number',b'Passnummer'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60',b'Relation with Guardian2',b'Beziehung mit Guardian2'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124',b'Manager',b'Leiter'
+b'DocType: Payment Entry',b'Payment From / To',b'Zahlung von / an'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +170',b'New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0}',b'Neue Kreditlimit ist weniger als die aktuellen ausstehenden Betrag f\xc3\xbcr den Kunden. Kreditlimit hat atleast sein {0}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428',b'Please set account in Warehouse {0}',b'Bitte Konto in Lager {0} setzen'
+b'apps/erpnext/erpnext/controllers/trends.py +39',"b""'Based On' and 'Group By' can not be same""","b'""basierend auf"" und ""guppiert nach"" k\xc3\xb6nnen nicht gleich sein'"
+b'DocType: Sales Person',b'Sales Person Targets',b'Ziele f\xc3\xbcr Vertriebsmitarbeiter'
+b'DocType: Installation Note',b'IN-',b'IM-'
+b'DocType: Work Order Operation',b'In minutes',b'In Minuten'
+b'DocType: Issue',b'Resolution Date',b'Datum der Entscheidung'
+b'DocType: Lab Test Template',b'Compound',b'Verbindung'
+b'DocType: Student Batch Name',b'Batch Name',b'Chargenname'
+b'DocType: Fee Validity',b'Max number of visit',b'Maximaler Besuch'
+,b'Hotel Room Occupancy',b'Hotelzimmerbelegung'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358',b'Timesheet created:',b'Timesheet erstellt:'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931',b'Please set default Cash or Bank account in Mode of Payment {0}',"b'Bitte Standardeinstellungen f\xc3\xbcr Kassen- oder Bankkonto in ""Zahlungsart"" {0} setzen'"
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24',b'Enroll',b'Einschreiben'
+b'DocType: GST Settings',b'GST Settings',b'GST-Einstellungen'
+b'DocType: Selling Settings',b'Customer Naming By',b'Benennung der Kunden nach'
+b'DocType: Student Leave Application',b'Will show the student as Present in Student Monthly Attendance Report',"b'Zeigen die Sch\xc3\xbcler, wie sie in Studenten monatlichen Anwesenheitsbericht'"
+b'DocType: Depreciation Schedule',b'Depreciation Amount',b'Abschreibungsbetrag'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56',b'Convert to Group',b'In Gruppe umwandeln'
+b'DocType: Delivery Trip',b'TOUR-.#####',b'TOUR-.#####'
+b'DocType: Activity Cost',b'Activity Type',b'Aktivit\xc3\xa4tsart'
+b'DocType: Request for Quotation',b'For individual supplier',b'F\xc3\xbcr einzelne Anbieter'
+b'DocType: BOM Operation',b'Base Hour Rate(Company Currency)',b'Basis Stundensatz (Gesellschaft W\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47',b'Delivered Amount',b'Gelieferte Menge'
+b'DocType: Quotation Item',b'Item Balance',b'die Balance der Gegenst\xc3\xa4nde'
+b'DocType: Sales Invoice',b'Packing List',b'Packliste'
+b'apps/erpnext/erpnext/config/buying.py +28',b'Purchase Orders given to Suppliers.',b'An Lieferanten erteilte Lieferantenauftr\xc3\xa4ge'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43',b'Publishing',b'Ver\xc3\xb6ffentlichung'
+b'DocType: Accounts Settings',b'Report Settings',b'Berichteinstellungen'
+b'DocType: Activity Cost',b'Projects User',b'Nutzer Projekt'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Consumed',b'Verbraucht'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158',b'{0}: {1} not found in Invoice Details table',b'{0}: {1} nicht in der Rechnungs-Details-Tabelle gefunden'
+b'DocType: Asset',b'Asset Owner Company',b'Eigent\xc3\xbcmergesellschaft'
+b'DocType: Company',b'Round Off Cost Center',b'Abschluss-Kostenstelle'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242',b'Maintenance Visit {0} must be cancelled before cancelling this Sales Order',b'Wartungsbesuch {0} muss vor Stornierung dieses Kundenauftrages abgebrochen werden'
+b'DocType: Asset Maintenance Log',b'AML-',b'AML-'
+b'DocType: Item',b'Material Transfer',b'Material\xc3\xbcbertrag'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24',b'Could not find path for ',b'Konnte keinen Weg finden'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221',b'Opening (Dr)',b'Anfangsstand (Soll)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39',b'Posting timestamp must be after {0}',b'Buchungszeitstempel muss nach {0} liegen'
+b'apps/erpnext/erpnext/config/accounts.py +39',b'To make recurring documents',b'Um wiederkehrende Dokumente zu machen'
+,b'GST Itemised Purchase Register',b'GST Itemized Purchase Register'
+b'DocType: Course Scheduling Tool',b'Reschedule',b'Neu planen'
+b'DocType: Employee Loan',b'Total Interest Payable',b'Gesamtsumme der Zinszahlungen'
+b'DocType: Landed Cost Taxes and Charges',b'Landed Cost Taxes and Charges',b'Einstandspreis Steuern und Geb\xc3\xbchren'
+b'DocType: Work Order Operation',b'Actual Start Time',b'Tats\xc3\xa4chliche Startzeit'
+b'DocType: BOM Operation',b'Operation Time',b'Zeit f\xc3\xbcr einen Arbeitsgang'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316',b'Finish',b'Fertig'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412',b'Base',b'Basis'
+b'DocType: Timesheet',b'Total Billed Hours',b'Insgesamt Angek\xc3\xbcndigt Stunden'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1530',b'Write Off Amount',b'Abschreibungs-Betrag'
+b'DocType: Leave Block List Allow',b'Allow User',b'Benutzer zulassen'
+b'DocType: Journal Entry',b'Bill No',b'Rechnungsnr.'
+b'DocType: Company',b'Gain/Loss Account on Asset Disposal',b'Gewinn / Verlustrechnung auf die Ver\xc3\xa4u\xc3\x9ferung von Verm\xc3\xb6genswerten'
+b'DocType: Vehicle Log',b'Service Details',b'Service Details'
+b'DocType: Subscription',b'Quarterly',b'Quartalsweise'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47',b'EcritureLib',b'EcritureLib'
+b'DocType: Lab Test Template',b'Grouped',b'Gruppiert'
+b'DocType: Selling Settings',b'Delivery Note Required',b'Lieferschein erforderlich'
+b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Bankgarantie Nummer'
+b'DocType: Assessment Criteria',b'Assessment Criteria',b'Beurteilungskriterien'
+b'DocType: BOM Item',b'Basic Rate (Company Currency)',b'Grundpreis (Firmenw\xc3\xa4hrung)'
+b'DocType: Student Attendance',b'Student Attendance',b'Sch\xc3\xbclerzahl'
+b'DocType: Sales Invoice Timesheet',b'Time Sheet',b'Zeitblatt'
+b'DocType: Manufacturing Settings',b'Backflush Raw Materials Based On',b'R\xc3\xbcckmeldung Rohmaterialien auf Basis von'
+b'DocType: Sales Invoice',b'Port Code',b'Portcode'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957',b'Reserve Warehouse',b'Lager reservieren'
+b'DocType: Lead',b'Lead is an Organization',b'Lead ist eine Organisation'
+b'DocType: Guardian Interest',b'Interest',b'Zinsen'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10',b'Pre Sales',b'Vorverkauf'
+b'DocType: Instructor Log',b'Other Details',b'Sonstige Einzelheiten'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18',b'Suplier',b'suplier'
+b'DocType: Lab Test',b'Test Template',b'Testvorlage'
+b'DocType: Restaurant Order Entry Item',b'Served',b'Serviert'
+b'apps/erpnext/erpnext/config/non_profit.py +13',b'Chapter information.',b'Gruppeninformation'
+b'DocType: Account',b'Accounts',b'Rechnungswesen'
+b'DocType: Vehicle',b'Odometer Value (Last)',b'(letzter) Tachostand'
+b'apps/erpnext/erpnext/config/buying.py +160',b'Templates of supplier scorecard criteria.',b'Vorlagen der Lieferanten-Scorecard-Kriterien.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109',b'Marketing',b'Marketing'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303',b'Payment Entry is already created',b'Payment Eintrag bereits erstellt'
+b'DocType: Request for Quotation',b'Get Suppliers',b'Holen Sie sich Lieferanten'
+b'DocType: Purchase Receipt Item Supplied',b'Current Stock',b'Aktueller Lagerbestand'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +610',b'Row #{0}: Asset {1} does not linked to Item {2}',b'Row # {0}: Verm\xc3\xb6gens {1} nicht auf Artikel verkn\xc3\xbcpft {2}'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15',b'Please setup Instructor Naming System in Education &gt; Education Settings',b'Bitte richten Sie das Instructor Naming System in Education&gt; Education Settings ein'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394',b'Preview Salary Slip',b'Vorschau Gehaltsabrechnung'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54',b'Account {0} has been entered multiple times',b'Konto {0} wurde mehrmals eingegeben'
+b'DocType: Account',b'Expenses Included In Valuation',b'In der Bewertung enthaltene Aufwendungen'
+b'apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37',b'You can only renew if your membership expires within 30 days',"b'Sie k\xc3\xb6nnen nur verl\xc3\xa4ngern, wenn Ihre Mitgliedschaft innerhalb von 30 Tagen abl\xc3\xa4uft'"
+b'DocType: Land Unit',b'Longitude',b'L\xc3\xa4ngengrad'
+,b'Absent Student Report',b'Bericht: Abwesende Studenten'
+b'DocType: Crop',b'Crop Spacing UOM',b'Crop-Abstand UOM'
+b'DocType: Accounts Settings',b'Only select if you have setup Cash Flow Mapper documents',"b'W\xc3\xa4hlen Sie nur aus, wenn Sie Cash Flow Mapper-Dokumente eingerichtet haben'"
+b'DocType: Email Digest',b'Next email will be sent on:',b'N\xc3\xa4chste E-Mail wird gesendet am:'
+b'DocType: Supplier Scorecard',b'Per Week',b'Pro Woche'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +666',b'Item has variants.',b'Artikel hat Varianten.'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154',b'Total Student',b'Gesamtstudent'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65',b'Item {0} not found',b'Artikel {0} nicht gefunden'
+b'DocType: Bin',b'Stock Value',b'Lagerwert'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +239',b'Company {0} does not exist',b'Gesellschaft {0} existiert nicht'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40',b'{0} has fee validity till {1}',b'{0} hat die G\xc3\xbcltigkeitsdauer bis {1}'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54',b'Tree Type',b'Struktur-Typ'
+b'DocType: BOM Explosion Item',b'Qty Consumed Per Unit',b'Verbrauchte Menge pro Einheit'
+b'DocType: GST Account',b'IGST Account',b'IGST Konto'
+b'DocType: Serial No',b'Warranty Expiry Date',b'Ablaufsdatum der Garantie'
+b'DocType: Material Request Item',b'Quantity and Warehouse',b'Menge und Lager'
+b'DocType: Hub Settings',b'Unregister',b'Registrierung aufheben'
+b'DocType: Sales Invoice',b'Commission Rate (%)',b'Provisionssatz (%)'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Bitte w\xc3\xa4hlen Sie Programm'
+b'DocType: Project',b'Estimated Cost',b'Gesch\xc3\xa4tzte Kosten'
+b'DocType: Purchase Order',b'Link to material requests',b'mit Materialanforderungen verkn\xc3\xbcpfen'
+b'DocType: Hub Settings',b'Publish',b'Ver\xc3\xb6ffentlichen'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7',b'Aerospace',b'Luft- und Raumfahrt'
+,b'Fichier des Ecritures Comptables [FEC]',b'Fichier des Ecritures Comptables [FEC]'
+b'DocType: Journal Entry',b'Credit Card Entry',b'Kreditkarten-Buchung'
+b'apps/erpnext/erpnext/config/accounts.py +57',b'Company and Accounts',b'Firma und Konten'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70',b'In Value',b'Wert bei'
+b'DocType: Asset Settings',b'Depreciation Options',b'Abschreibungsoptionen'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +35',b'Invalid Posting Time',b'Ung\xc3\xbcltige Buchungszeit'
+b'DocType: Lead',b'Campaign Name',b'Kampagnenname'
+b'DocType: Hotel Room',b'Capacity',b'Kapazit\xc3\xa4t'
+b'DocType: Selling Settings',b'Close Opportunity After Days',b'Gelegenheit schliessen nach'
+,b'Reserved',b'Reserviert'
+b'DocType: Driver',b'License Details',b'Lizenzdetails'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85',b'The field From Shareholder cannot be blank',b'Das Feld Von Aktion\xc3\xa4r darf nicht leer sein'
+b'DocType: Purchase Order',b'Supply Raw Materials',b'Rohmaterial bereitstellen'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10',b'Current Assets',b'Umlaufverm\xc3\xb6gen'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121',b'{0} is not a stock Item',b'{0} ist kein Lagerartikel'
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6',"b""Please share your feedback to the training by clicking on 'Training Feedback' and then 'New'""","b'Bitte teilen Sie Ihr Feedback mit dem Training ab, indem Sie auf &#39;Training Feedback&#39; und dann &#39;New&#39; klicken.'"
+b'DocType: Mode of Payment Account',b'Default Account',b'Standardkonto'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +273',b'Please select Sample Retention Warehouse in Stock Settings first',b'Bitte w\xc3\xa4hlen Sie in den Lagereinstellungen zuerst das Muster-Aufbewahrungslager aus'
+b'DocType: Payment Entry',b'Received Amount (Company Currency)',b'Erhaltene Menge (Gesellschaft W\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192',b'Lead must be set if Opportunity is made from Lead',"b'Lead muss eingestellt werden, wenn eine Opportunity aus dem Lead entsteht'"
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136',b'Payment Cancelled. Please check your GoCardless Account for more details',b'Zahlung abgebrochen. Bitte \xc3\xbcberpr\xc3\xbcfen Sie Ihr GoCardless Konto f\xc3\xbcr weitere Details'
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29',b'Please select weekly off day',b'Bitte die w\xc3\xb6chentlichen Auszeittage ausw\xc3\xa4hlen'
+b'DocType: Patient',b'O Negative',b'0 -'
+b'DocType: Work Order Operation',b'Planned End Time',b'Geplante Endzeit'
+,b'Sales Person Target Variance Item Group-Wise',b'Artikelgruppenbezogene Zielabweichung des Vertriebsmitarbeiters'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +93',b'Account with existing transaction cannot be converted to ledger',b'Ein Konto mit bestehenden Transaktionen kann nicht in ein Kontoblatt umgewandelt werden'
+b'apps/erpnext/erpnext/config/non_profit.py +33',b'Memebership Type Details',b'Details zum Membership-Typ'
+b'DocType: Delivery Note',"b""Customer's Purchase Order No""",b'Kundenauftragsnr.'
+b'DocType: Budget',b'Budget Against',b'Budget gegen'
+b'DocType: Employee',b'Cell Number',b'Mobiltelefonnummer'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450',"b""There's no employee for the given criteria. Check that Salary Slips have not already been created.""","b'Es gibt keinen Angestellten f\xc3\xbcr die gegebenen Kriterien. \xc3\x9cberpr\xc3\xbcfen Sie, ob Gehaltsabrechnungen nicht bereits erstellt wurden.'"
+b'apps/erpnext/erpnext/stock/reorder_item.py +194',b'Auto Material Requests Generated',b'Automatische Materialanfragen generiert'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7',b'Lost',b'Verloren'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152',"b""You can not enter current voucher in 'Against Journal Entry' column""","b'Momentan k\xc3\xb6nnen keine Belege in die Spalte ""Zu Buchungssatz"" eingegeben werden'"
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50',b'Reserved for manufacturing',b'f\xc3\xbcr die Herstellung Reserviert'
+b'DocType: Soil Texture',b'Sand',b'Sand'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25',b'Energy',b'Energie'
+b'DocType: Opportunity',b'Opportunity From',b'Chance von'
+b'apps/erpnext/erpnext/config/hr.py +98',b'Monthly salary statement.',b'Monatliche Gehaltsabrechnung'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887',b'Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.',b'Zeile {0}: {1} F\xc3\xbcr den Eintrag {2} ben\xc3\xb6tigte Seriennummern. Du hast {3} zur Verf\xc3\xbcgung gestellt.'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79',b'Please select a table',b'Bitte w\xc3\xa4hlen Sie eine Tabelle'
+b'DocType: BOM',b'Website Specifications',b'Webseiten-Spezifikationen'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78',"b""{0} is an invalid email address in 'Recipients'""","b'{0} ist eine ung\xc3\xbcltige E-Mail-Adresse in ""Empf\xc3\xa4nger""'"
+b'DocType: Special Test Items',b'Particulars',b'Einzelheiten'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24',b'{0}: From {0} of type {1}',b'{0}: Von {0} vom Typ {1}'
+b'DocType: Warranty Claim',b'CI-',b'CI-'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +300',b'Row {0}: Conversion Factor is mandatory',b'Row {0}: Umrechnungsfaktor ist zwingend erfoderlich'
+b'DocType: Student',b'A+',b'A+'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344',"b'Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}'","b'Es sind mehrere Preisregeln mit gleichen Kriterien vorhanden, l\xc3\xb6sen Sie Konflikte, indem Sie Priorit\xc3\xa4ten zuweisen. Preis Regeln: {0}'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519',b'Cannot deactivate or cancel BOM as it is linked with other BOMs',"b'St\xc3\xbcckliste kann nicht deaktiviert oder storniert werden, weil sie mit anderen St\xc3\xbccklisten verkn\xc3\xbcpft ist'"
+b'DocType: Asset',b'Maintenance',b'Wartung'
+b'DocType: Item Attribute Value',b'Item Attribute Value',b'Attributwert des Artikels'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +406',b'Please Update your Project Status',b'Bitte aktualisieren Sie Ihren Projektstatus'
+b'DocType: Item',b'Maximum sample quantity that can be retained',"b'Maximale Probenmenge, die beibehalten werden kann'"
+b'DocType: Project Update',b'How is the Project Progressing Right Now?',b'Wie l\xc3\xa4uft das Projekt jetzt?'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418',b'Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3}',b'Zeile {0} # Artikel {1} kann nicht mehr als {2} gegen Bestellung {3} \xc3\xbcbertragen werden.'
+b'apps/erpnext/erpnext/config/selling.py +158',b'Sales campaigns.',b'Vertriebskampagnen'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117',b'Make Timesheet',b'Machen Sie Timesheet'
+b'DocType: Sales Taxes and Charges Template',"b'Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.'","b'Standard-Steuer-Vorlage, die f\xc3\xbcr alle Kauftransaktionen angewandt werden kann. Diese Vorlage kann eine Liste der Steuern und auch anderer Kosten wie ""Versand"", ""Versicherung"", ""Handhabung"" usw. enthalten. \n\n #### Hinweis \n\nDer Steuersatz, den sie hier definieren, wird der Standardsteuersatz f\xc3\xbcr alle Artikel. Wenn es Artikel mit davon abweichenden Steuers\xc3\xa4tzen gibt, m\xc3\xbcssen diese in der Tabelle ""Artikelsteuer"" im Artikelstamm hinzugef\xc3\xbcgt werden.\n\n #### Beschreibung der Spalten \n\n1. Berechnungsart: \n- Dies kann sein ""Auf Nettosumme"" (das ist die Summe der Grundbetr\xc3\xa4ge).\n- ""Auf vorherige Zeilensumme/-Betrag"" (f\xc3\xbcr kumulative Steuern oder Abgaben). Wenn diese Option ausgew\xc3\xa4hlt wird, wird die Steuer als Prozentsatz der vorherigen Zeilesumme/des vorherigen Zeilenbetrags (in der Steuertabelle) angewendet.\n- ""Unmittelbar"" (wie bereits erw\xc3\xa4hnt).\n2. Kontobezeichnung: Das Konto, auf das diese Steuer gebucht wird.\n3. Kostenstelle: Ist die Steuer/Geb\xc3\xbchr ein Ertrag (wie Versand) oder ein Aufwand, muss sie gegen eine Kostenstelle gebucht werden.\n4. Beschreibung: Beschreibung der Steuer (wird auf Rechnungen und Angeboten abgedruckt).\n5. Satz: Steuersatz.\n6. Betrag: Steuerbetrag.\n7. Gesamt: Kumulierte Summe bis zu diesem Punkt.\n8. Zeile eingeben: Wenn ""Basierend auf Vorherige Zeile"" eingestellt wurde, kann hier die Zeilennummer ausgew\xc3\xa4hlt werden, die als Basis f\xc3\xbcr diese Berechnung (voreingestellt ist die vorherige Zeile) herangezogen wird.\n9. Ist diese Steuer im Basispreis enthalten?: Wenn dieser Punkt aktiviert ist, wird diese Steuer nicht unter dem Artikelstamm angezeigt, aber in den Grundpreis der Tabelle der Hauptartikel mit eingerechnet. Das ist n\xc3\xbctzlich, wenn ein Pauschalpreis  (inklusive aller Steuern)  an den Kunden gegeben werden soll.'"
+b'DocType: Employee',b'Bank A/C No.',b'Bankkonto-Nr.'
+b'DocType: Bank Guarantee',b'Project',b'Projekt'
+b'DocType: Quality Inspection Reading',b'Reading 7',b'Ablesewert\xc2\xa07'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9',b'Partially Ordered',b'teilweise geordnete'
+b'DocType: Lab Test',b'Lab Test',b'Labortest'
+b'DocType: Student Report Generation Tool',b'Student Report Generation Tool',b'Werkzeug zur Erstellung von Sch\xc3\xbclerberichten'
+b'DocType: Expense Claim Detail',b'Expense Claim Type',b'Art der Aufwandsabrechnung'
+b'DocType: Shopping Cart Settings',b'Default settings for Shopping Cart',b'Standardeinstellungen f\xc3\xbcr den Warenkorb'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27',b'Add Timeslots',b'Zeitfenster hinzuf\xc3\xbcgen'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138',b'Asset scrapped via Journal Entry {0}',b'Gegenstand entsorgt \xc3\xbcber Journaleintrag {0}'
+b'DocType: Employee Loan',b'Interest Income Account',b'Zinsertr\xc3\xa4ge Konto'
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58',b'Review Invitation Sent',b'Einladung \xc3\xbcberpr\xc3\xbcfen gesendet'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13',b'Biotechnology',b'Biotechnologie'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109',b'Office Maintenance Expenses',b'B\xc3\xbcro-Wartungskosten'
+b'apps/erpnext/erpnext/utilities/user_progress.py +54',b'Go to ',b'Gehe zu'
+b'apps/erpnext/erpnext/config/learn.py +47',b'Setting up Email Account',b'Einrichten E-Mail-Konto'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21',b'Please enter Item first',b'Bitte zuerst den Artikel angeben'
+b'DocType: Asset Repair',b'Downtime',b'Ausfallzeit'
+b'DocType: Account',b'Liability',b'Verbindlichkeit'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220',b'Sanctioned Amount cannot be greater than Claim Amount in Row {0}.',b'Genehmigter Betrag kann nicht gr\xc3\xb6\xc3\x9fer als geforderter Betrag in Zeile {0} sein.'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11',b'Academic Term: ',b'Akademischer Ausdruck:'
+b'DocType: Salary Detail',b'Do not include in total',b'Nicht in Summe'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206',b'Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series',b'Setzen Sie die Namensserie f\xc3\xbcr {0} \xc3\xbcber Setup&gt; Einstellungen&gt; Namensserie'
+b'DocType: Company',b'Default Cost of Goods Sold Account',b'Standard-Herstellkosten'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1019',b'Sample quantity {0} cannot be more than received quantity {1}',b'Die Beispielmenge {0} darf nicht mehr als die empfangene Menge {1} sein'
+b'apps/erpnext/erpnext/stock/get_item_details.py +369',b'Price List not selected',b'Preisliste nicht ausgew\xc3\xa4hlt'
+b'DocType: Employee',b'Family Background',b'Famili\xc3\xa4rer Hintergrund'
+b'DocType: Request for Quotation Supplier',b'Send Email',b'E-Mail absenden'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +228',b'Warning: Invalid Attachment {0}',b'Warnung: Ung\xc3\xbcltige Anlage {0}'
+b'DocType: Item',b'Max Sample Quantity',b'Max. Probenmenge'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766',b'No Permission',b'Keine Berechtigung'
+b'DocType: Vital Signs',b'Heart Rate / Pulse',b'Herzfrequenz / Puls'
+b'DocType: Company',b'Default Bank Account',b'Standardbankkonto'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59',"b'To filter based on Party, select Party Type first'","b'Um auf der Grundlage von Gruppen zu filtern, bitte zuerst den Gruppentyp w\xc3\xa4hlen'"
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48',"b""'Update Stock' can not be checked because items are not delivered via {0}""","b'""Lager aktualisieren"" kann nicht ausgew\xc3\xa4hlt werden, da Artikel nicht \xc3\xbcber {0} geliefert wurden'"
+b'DocType: Vehicle',b'Acquisition Date',b'Kaufdatum'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Nos',b'Stk'
+b'DocType: Item',b'Items with higher weightage will be shown higher',b'Artikel mit h\xc3\xb6herem Gewicht werden weiter oben angezeigt'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14',b'Lab Tests and Vital Signs',b'Labortests und Lebenszeichen'
+b'DocType: Bank Reconciliation Detail',b'Bank Reconciliation Detail',b'Ausf\xc3\xbchrlicher Kontenabgleich'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +614',b'Row #{0}: Asset {1} must be submitted',b'Row # {0}: Verm\xc3\xb6gens {1} muss eingereicht werden'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40',b'No employee found',b'Kein Mitarbeiter gefunden'
+b'DocType: Subscription',b'Stopped',b'Angehalten'
+b'DocType: Item',b'If subcontracted to a vendor',b'Wenn an einen Zulieferer untervergeben'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Studentengruppe ist bereits aktualisiert.'
+b'apps/erpnext/erpnext/config/projects.py +18',b'Project Update.',b'Projektaktualisierung'
+b'DocType: SMS Center',b'All Customer Contact',b'Alle Kundenkontakte'
+b'DocType: Land Unit',b'Tree Details',b'Baum-Details'
+b'DocType: Training Event',b'Event Status',b'Event Status'
+b'DocType: Volunteer',b'Availability Timeslot',b'Verf\xc3\xbcgbarkeitszeitfenster'
+,b'Support Analytics',b'Support-Analyse'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365',"b'If you have any questions, please get back to us.'","b'Wenn Sie Fragen haben, wenden Sie sich bitte an uns.'"
+b'DocType: Cash Flow Mapper',b'Cash Flow Mapper',b'Cashflow Mapper'
+b'DocType: Item',b'Website Warehouse',b'Webseiten-Lager'
+b'DocType: Payment Reconciliation',b'Minimum Invoice Amount',b'Mindestabrechnung'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111',b'{0} {1}: Cost Center {2} does not belong to Company {3}',b'{0} {1}: Kostenstelle {2} geh\xc3\xb6rt nicht zur Firma {3}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +92',b'Upload your letter head (Keep it web friendly as 900px by 100px)',b'Laden Sie Ihren Briefkopf hoch (Halten Sie ihn webfreundlich mit 900x100px)'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88',b'{0} {1}: Account {2} cannot be a Group',b'{0} {1}: Konto {2} darf keine Gruppe sein'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63',"b""Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table""",b'Artikel Row {idx}: {} {Doctype docname} existiert nicht in der oben &#39;{Doctype}&#39; Tisch'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295',b'Timesheet {0} is already completed or cancelled',b'Timesheet {0} ist bereits abgeschlossen oder abgebrochen'
+b'apps/erpnext/erpnext/templates/pages/projects.html +42',b'No tasks',b'keine Vorg\xc3\xa4nge'
+b'DocType: Item Variant Settings',b'Copy Fields to Variant',b'Kopiere Felder auf Varianten'
+b'DocType: Asset',b'Opening Accumulated Depreciation',b'\xc3\x96ffnungs Kumulierte Abschreibungen'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49',b'Score must be less than or equal to 5',b'Punktzahl mu\xc3\x9f kleiner oder gleich 5 sein'
+b'DocType: Program Enrollment Tool',b'Program Enrollment Tool',b'Programm-Enrollment-Tool'
+b'apps/erpnext/erpnext/config/accounts.py +335',b'C-Form records',b'Kontakt-Formular Datens\xc3\xa4tze'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73',b'The shares already exist',b'Die Aktien sind bereits vorhanden'
+b'apps/erpnext/erpnext/config/selling.py +316',b'Customer and Supplier',b'Kunde und Lieferant'
+b'DocType: Email Digest',b'Email Digest Settings',b'Einstellungen zum t\xc3\xa4glichen E-Mail-Bericht'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367',b'Thank you for your business!',b'Vielen Dank f\xc3\xbcr Ihr Unternehmen!'
+b'apps/erpnext/erpnext/config/support.py +12',b'Support queries from customers.',b'Support-Anfragen von Kunden'
+b'DocType: Setup Progress Action',b'Action Doctype',b'Aktions-Doctype'
+b'DocType: HR Settings',b'Retirement Age',b'Rentenalter'
+b'DocType: Bin',b'Moving Average Rate',b'Wert f\xc3\xbcr den Gleitenden Durchschnitt'
+b'DocType: Production Plan',b'Select Items',b'Artikel ausw\xc3\xa4hlen'
+b'DocType: Share Transfer',b'To Shareholder',b'An den Aktion\xc3\xa4r'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372',b'{0} against Bill {1} dated {2}',b'{0} zu Rechnung {1} vom {2}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Institution',b'Einrichtung Einrichtung'
+b'DocType: Program Enrollment',b'Vehicle/Bus Number',b'Fahrzeug / Bus Nummer'
+b'apps/erpnext/erpnext/education/doctype/course/course.js +17',b'Course Schedule',b'Kurstermine'
+b'DocType: Request for Quotation Supplier',b'Quote Status',b'Zitat Status'
+b'DocType: GoCardless Settings',b'Webhooks Secret',b'Webhooks Geheimnis'
+b'DocType: Maintenance Visit',b'Completion Status',b'Fertigstellungsstatus'
+b'DocType: Daily Work Summary Group',b'Select Users',b'W\xc3\xa4hlen Sie Benutzer aus'
+b'DocType: Hotel Room Pricing Item',b'Hotel Room Pricing Item',b'Hotelzimmer-Preisartikel'
+b'DocType: HR Settings',b'Enter retirement age in years',b'Geben Sie das Rentenalter in Jahren'
+b'DocType: Crop',b'Target Warehouse',b'Eingangslager'
+b'DocType: Payroll Employee Detail',b'Payroll Employee Detail',b'Personalabrechnung Mitarbeiter Detail'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128',b'Please select a warehouse',b'Bitte w\xc3\xa4hlen Sie ein Lager aus'
+b'DocType: Cheque Print Template',b'Starting location from left edge',b'Startposition vom linken Rand'
+b'DocType: Item',b'Allow over delivery or receipt upto this percent',b'\xc3\x9cberlieferung bis zu diesem Prozentsatz zulassen'
+b'DocType: Stock Entry',b'STE-',b'STE-'
+b'DocType: Upload Attendance',b'Import Attendance',b'Import von Anwesenheiten'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +124',b'All Item Groups',b'Alle Artikelgruppen'
+b'apps/erpnext/erpnext/config/setup.py +89',b'Automatically compose message on submission of transactions.',b'Automatisch beim \xc3\x9cbertragen von Transaktionen Mitteilungen verfassen'
+b'DocType: Work Order',b'Item To Manufacture',b'Zu fertigender Artikel'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteLib',b'CompteLib'
+b'apps/erpnext/erpnext/buying/utils.py +80',b'{0} {1} status is {2}',b'{0} {1} Status ist {2}'
+b'DocType: Water Analysis',b'Collection Temperature ',b'Sammlungs-Temperatur'
+b'DocType: Employee',b'Provide Email Address registered in company',b'Geben Sie E-Mail-Adresse in Unternehmen registriert'
+b'DocType: Shopping Cart Settings',b'Enable Checkout',b'Aktivieren Kasse'
+b'apps/erpnext/erpnext/config/learn.py +202',b'Purchase Order to Payment',b'Vom Lieferantenauftrag zur Zahlung'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48',b'Projected Qty',b'Geplante Menge'
+b'DocType: Sales Invoice',b'Payment Due Date',b'Zahlungsstichtag'
+b'DocType: Drug Prescription',b'Interval UOM',b'Intervall UOM'
+b'DocType: Customer',"b'Reselect, if the chosen address is edited after save'","b'W\xc3\xa4hlen Sie erneut, wenn die gew\xc3\xa4hlte Adresse nach dem Speichern bearbeitet wird'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +522',b'Item Variant {0} already exists with same attributes',b'Artikelvariante {0} mit denselben Attributen existiert bereits'
+b'DocType: Item',b'Hub Publishing Details',b'Hub-Ver\xc3\xb6ffentlichungsdetails'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117',"b""'Opening'""","b'""Er\xc3\xb6ffnung""'"
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130',b'Open To Do',b'offene Aufgaben'
+b'DocType: Notification Control',b'Delivery Note Message',b'Lieferschein-Nachricht'
+b'DocType: Lab Test Template',b'Result Format',b'Ergebnisformat'
+b'DocType: Expense Claim',b'Expenses',b'Ausgaben'
+b'DocType: Item Variant Attribute',b'Item Variant Attribute',b'Artikelvariantenattribut'
+,b'Purchase Receipt Trends',b'Trendanalyse Kaufbelege'
+b'DocType: Payroll Entry',b'Bimonthly',b'Zweimonatlich'
+b'DocType: Vehicle Service',b'Brake Pad',b'Bremsklotz'
+b'DocType: Fertilizer',b'Fertilizer Contents',b'D\xc3\xbcnger Inhalt'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119',b'Research & Development',b'Forschung & Entwicklung'
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20',b'Amount to Bill',b'Rechnungsbetrag'
+b'DocType: Company',b'Registration Details',b'Details zur Registrierung'
+b'DocType: Timesheet',b'Total Billed Amount',b'Gesamtrechnungsbetrag'
+b'DocType: Item Reorder',b'Re-Order Qty',b'Nachbestellmenge'
+b'DocType: Leave Block List Date',b'Leave Block List Date',b'Urlaubssperrenliste Datum'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94',b'BOM #{0}: Raw material cannot be same as main Item',b'St\xc3\xbcckliste # {0}: Rohstoff kann nicht gleich dem Artikel sein.'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92',b'Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges',b'Gesamt Die Geb\xc3\xbchren in Kauf Eingangspositionen Tabelle muss als Gesamt Steuern und Abgaben gleich sein'
+b'DocType: Sales Team',b'Incentives',b'Anreize'
+b'DocType: SMS Log',b'Requested Numbers',b'Angeforderte Nummern'
+b'DocType: Volunteer',b'Evening',b'Abend'
+b'DocType: Customer',b'Bypass credit limit check at Sales Order',b'Kreditlimitpr\xc3\xbcfung im Kundenauftrag umgehen'
+b'apps/erpnext/erpnext/config/hr.py +147',b'Performance appraisal.',b'Mitarbeiterbeurteilung'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100',"b""Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart""","b'Aktivieren &quot;Verwendung f\xc3\xbcr Einkaufswagen&quot;, wie Einkaufswagen aktiviert ist und es sollte mindestens eine Steuerregel f\xc3\xbcr Einkaufswagen sein'"
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +412',"b'Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.'","b'Zahlung {0} ist mit der Bestellung {1} verkn\xc3\xbcpft, \xc3\xbcberpr\xc3\xbcfen Sie bitte, ob es als Anteil in dieser Rechnung gezogen werden sollte.'"
+b'DocType: Sales Invoice Item',b'Stock Details',b'Lagerdetails'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29',b'Project Value',b'Projektwert'
+b'apps/erpnext/erpnext/config/selling.py +326',b'Point-of-Sale',b'Verkaufsstelle'
+b'DocType: Fee Schedule',b'Fee Creation Status',b'Status Geb\xc3\xbchrenermittlung'
+b'DocType: Vehicle Log',b'Odometer Reading',b'Tachostand'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +116',"b""Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'""","b'Konto bereits im Haben, es ist nicht mehr m\xc3\xb6glich das Konto als Sollkonto festzulegen'"
+b'DocType: Account',b'Balance must be',b'Saldo muss sein'
+b'DocType: Hub Settings',b'Publish Pricing',b'Preise ver\xc3\xb6ffentlichen'
+b'DocType: Notification Control',b'Expense Claim Rejected Message',b'Benachrichtigung \xc3\xbcber abgelehnte Aufwandsabrechnung'
+,b'Available Qty',b'Verf\xc3\xbcgbare Menge'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Total',b'Auf vorherige Zeilensumme'
+b'DocType: Purchase Invoice Item',b'Rejected Qty',b'Abgelehnt Menge'
+b'DocType: Setup Progress Action',b'Action Field',b'Aktions-Feld'
+b'DocType: Healthcare Settings',b'Manage Customer',b'Kunden verwalten'
+b'DocType: Delivery Trip',b'Delivery Stops',b'Lieferstopps'
+b'DocType: Salary Slip',b'Working Days',b'Arbeitstage'
+b'DocType: Serial No',b'Incoming Rate',b'Eingangsbewertung'
+b'DocType: Packing Slip',b'Gross Weight',b'Bruttogewicht'
+,b'Final Assessment Grades',b'Endg\xc3\xbcltige Bewertungsma\xc3\x9fst\xc3\xa4be'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47',b'Enable Hub',b'Hub aktivieren'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +110',b'The name of your company for which you are setting up this system.',"b'Name der Firma, f\xc3\xbcr die dieses System eingerichtet wird.'"
+b'DocType: HR Settings',b'Include holidays in Total no. of Working Days',b'Urlaub in die Gesamtzahl der Arbeitstage mit einbeziehen'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108',b'Setup your Institute in ERPNext',b'Richten Sie Ihr Institut in ERPNext ein'
+b'DocType: Agriculture Analysis Criteria',b'Plant Analysis',b'Anlagenanalyse'
+b'DocType: Job Applicant',b'Hold',b'Anhalten'
+b'DocType: Project Update',b'Progress Details',b'Fortschritt Details'
+b'DocType: Employee',b'Date of Joining',b'Eintrittsdatum'
+b'DocType: Naming Series',b'Update Series',b'Nummernkreise aktualisieren'
+b'DocType: Supplier Quotation',b'Is Subcontracted',b'Ist Untervergabe'
+b'DocType: Restaurant Table',b'Minimum Seating',b'Mindestbestuhlung'
+b'DocType: Item Attribute',b'Item Attribute Values',b'Artikel-Attributwerte'
+b'DocType: Examination Result',b'Examination Result',b'Pr\xc3\xbcfungsergebnis'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845',b'Purchase Receipt',b'Kaufbeleg'
+,b'Received Items To Be Billed',"b'Von Lieferanten gelieferte Artikel, die noch abgerechnet werden m\xc3\xbcssen'"
+b'apps/erpnext/erpnext/config/accounts.py +303',b'Currency exchange rate master.',b'Stammdaten zur W\xc3\xa4hrungsumrechnung'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209',b'Reference Doctype must be one of {0}',b'Referenz Doctype muss man von {0}'
+b'apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46',b'Filter Total Zero Qty',b'Gesamtmenge filtern'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341',b'Unable to find Time Slot in the next {0} days for Operation {1}',b'In den n\xc3\xa4chsten {0} Tagen kann f\xc3\xbcr den Arbeitsgang {1} kein Zeitfenster gefunden werden'
+b'DocType: Work Order',b'Plan material for sub-assemblies',b'Materialplanung f\xc3\xbcr Unterbaugruppen'
+b'apps/erpnext/erpnext/config/selling.py +97',b'Sales Partners and Territory',b'Vertriebspartner und Territorium'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +600',b'BOM {0} must be active',b'St\xc3\xbcckliste {0} muss aktiv sein'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414',b'No Items available for transfer',b'Keine Artikel zur \xc3\x9cbertragung verf\xc3\xbcgbar'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218',b'Closing (Opening + Total)',b'Schlie\xc3\x9fen (Er\xc3\xb6ffnung + Gesamt)'
+b'DocType: Journal Entry',b'Depreciation Entry',b'Abschreibungs Eintrag'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32',b'Please select the document type first',b'Bitte zuerst den Dokumententyp ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65',b'Cancel Material Visits {0} before cancelling this Maintenance Visit',b'Materialkontrolle {0} stornieren vor Abbruch dieses Wartungsbesuchs'
+b'DocType: Crop Cycle',b'ISO 8016 standard',b'ISO 8016 Standard'
+b'DocType: Pricing Rule',b'Rate or Discount',b'Rate oder Rabatt'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213',b'Serial No {0} does not belong to Item {1}',b'Seriennummer {0} geh\xc3\xb6rt nicht zu Artikel {1}'
+b'DocType: Purchase Receipt Item Supplied',b'Required Qty',b'Erforderliche Anzahl'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126',b'Warehouses with existing transaction can not be converted to ledger.',b'Lagerh\xc3\xa4user mit bestehenden Transaktion kann nicht in Ledger umgewandelt werden.'
+b'DocType: Bank Reconciliation',b'Total Amount',b'Gesamtsumme'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32',b'Internet Publishing',b'Ver\xc3\xb6ffentlichung im Internet'
+b'DocType: Prescription Duration',b'Number',b'Nummer'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25',b'Creating {0} Invoice',b'{0} Rechnung erstellen'
+b'DocType: Medical Code',b'Medical Code Standard',b'Medizinischer Code Standard'
+b'DocType: Soil Texture',b'Clay Composition (%)',b'Tonzusammensetzung (%)'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81',b'Please save before assigning task.',b'Bitte vor dem Zuweisen der Aufgabe speichern.'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74',b'Balance Value',b'Bilanzwert'
+b'DocType: Lab Test',b'Lab Technician',b'Labortechniker'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38',b'Sales Price List',b'Verkaufspreisliste'
+b'DocType: Healthcare Settings',"b'If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.'","b'Wenn aktiviert, wird ein Kunde erstellt, der Patient zugeordnet ist. Patientenrechnungen werden gegen diesen Kunden angelegt. Sie k\xc3\xb6nnen den vorhandenen Kunden auch beim Erstellen von Patient ausw\xc3\xa4hlen.'"
+b'DocType: Bank Reconciliation',b'Account Currency',b'Kontenw\xc3\xa4hrung'
+b'DocType: Lab Test',b'Sample ID',b'Muster-ID'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +167',b'Please mention Round Off Account in Company',b'Bitte Abschlusskonto in Firma vermerken'
+b'DocType: Purchase Receipt',b'Range',b'Bandbreite'
+b'DocType: Supplier',b'Default Payable Accounts',b'Standard-Verbindlichkeitenkonten'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49',b'Employee {0} is not active or does not exist',b'Mitarbeiter {0} ist nicht aktiv oder existiert nicht'
+b'DocType: Fee Structure',b'Components',b'Komponenten'
+b'DocType: Item Barcode',b'Item Barcode',b'Artikelbarcode'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +329',b'Please enter Asset Category in Item {0}',b'Bitte geben Sie Anlagekategorie in Artikel {0}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +661',b'Item Variants {0} updated',b'Artikelvarianten {0} aktualisiert'
+b'DocType: Quality Inspection Reading',b'Reading 6',b'Ablesewert\xc2\xa06'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9',"b'to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field\nof this'","b'erzeugt werden Wenn Sie versp\xc3\xa4tet sind, m\xc3\xbcssen Sie das Feld &quot;Wiederholen am Tag des Monats&quot; manuell \xc3\xa4ndern'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961',b'Cannot {0} {1} {2} without any negative outstanding invoice',b'Kann nicht {0} {1} {2} ohne negative ausstehende Rechnung'
+b'DocType: Share Transfer',b'From Folio No',b'Aus Folio Nr'
+b'DocType: Purchase Invoice Advance',b'Purchase Invoice Advance',b'Vorkasse zur Eingangsrechnung'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199',b'Row {0}: Credit entry can not be linked with a {1}',b'Zeile {0}: Habenbuchung kann nicht mit ein(em) {1} verkn\xc3\xbcpft werden'
+b'apps/erpnext/erpnext/config/accounts.py +246',b'Define budget for a financial year.',b'Budget f\xc3\xbcr ein Gesch\xc3\xa4ftsjahr angeben.'
+b'DocType: Lead',b'LEAD-',b'LEAD-'
+b'DocType: Employee',b'Permanent Address Is',b'Feste Adresse ist'
+b'DocType: Work Order Operation',b'Operation completed for how many finished goods?',b'F\xc3\xbcr wie viele fertige Erzeugnisse wurde der Arbeitsgang abgeschlossen?'
+b'DocType: Payment Terms Template',b'Payment Terms Template',b'Vorlage Zahlungsbedingungen'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +51',b'The Brand',b'Die Marke'
+b'DocType: Employee',b'Exit Interview Details',b'Details zum Austrittsgespr\xc3\xa4ch'
+b'DocType: Item',b'Is Purchase Item',b'Ist Einkaufsartikel'
+b'DocType: Journal Entry Account',b'Purchase Invoice',b'Eingangsrechnung'
+b'DocType: Stock Ledger Entry',b'Voucher Detail No',b'Belegdetail-Nr.'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +789',b'New Sales Invoice',b'Neue Ausgangsrechnung'
+b'DocType: Stock Entry',b'Total Outgoing Value',b'Gesamtwert Auslieferungen'
+b'DocType: Physician',b'Appointments',b'Termine'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +223',b'Opening Date and Closing Date should be within same Fiscal Year',b'Er\xc3\xb6ffnungsdatum und Abschlussdatum sollten im gleichen Gesch\xc3\xa4ftsjahr sein'
+b'DocType: Lead',b'Request for Information',b'Informationsanfrage'
+,b'LeaderBoard',b'Bestenliste'
+b'DocType: Sales Invoice Item',b'Rate With Margin (Company Currency)',b'Rate mit Margin (Unternehmensw\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +802',b'Sync Offline Invoices',b'Sync Offline-Rechnungen'
+b'DocType: Payment Request',b'Paid',b'Bezahlt'
+b'DocType: Program Fee',b'Program Fee',b'Programmgeb\xc3\xbchr'
+b'DocType: BOM Update Tool',"b'Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.'","b'Ersetzen Sie eine bestimmte St\xc3\xbcckliste in allen anderen St\xc3\xbccklisten, wo sie verwendet wird. Es wird die alte BOM-Link ersetzen, die Kosten aktualisieren und die &quot;BOM Explosion Item&quot; -Tabelle nach neuer St\xc3\xbcckliste regenerieren. Es aktualisiert auch den aktuellen Preis in allen St\xc3\xbccklisten.'"
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447',b'The following Work Orders were created:',b'Die folgenden Arbeitsauftr\xc3\xa4ge wurden erstellt:'
+b'DocType: Salary Slip',b'Total in words',b'Summe in Worten'
+b'DocType: Material Request Item',b'Lead Time Date',b'Lieferzeit und -datum'
+,b'Employee Advance Summary',b'Mitarbeiter Vorausschau'
+b'DocType: Asset',b'Available-for-use Date',b'Verf\xc3\xbcgbarkeitsdatum'
+b'DocType: Guardian',b'Guardian Name',b'W\xc3\xa4chter-Name'
+b'DocType: Cheque Print Template',b'Has Print Format',b'Hat ein Druckformat'
+b'DocType: Employee Loan',b'Sanctioned',b'sanktionierte'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +75',b' is mandatory. Maybe Currency Exchange record is not created for ',b'ist zwingend erforderlich. Vielleicht wurde kein Datensatz f\xc3\xbcr den Geldwechsel erstellt f\xc3\xbcr'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139',b'Row #{0}: Please specify Serial No for Item {1}',b'Zeile #{0}: Bitte Seriennummer f\xc3\xbcr Artikel {1} angeben'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54',b'Supplier &gt; Supplier Type',b'Lieferant&gt; Lieferantentyp'
+b'DocType: Crop Cycle',b'Crop Cycle',b'Erntezyklus'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633',"b""For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.""","b'F\xc3\xbcr Artikel aus ""Produkt-Bundles"" werden Lager, Seriennummer und Chargennummer aus der Tabelle ""Packliste"" ber\xc3\xbccksichtigt. Wenn Lager und Chargennummer f\xc3\xbcr alle Packst\xc3\xbccke in jedem Artikel eines Produkt-Bundles gleich sind, k\xc3\xb6nnen diese Werte in die Tabelle ""Hauptpositionen"" eingetragen werden, Die Werte werden in die Tabelle ""Packliste"" kopiert.'"
+b'DocType: Student Admission',b'Publish on website',b'Ver\xc3\xb6ffentlichen Sie auf der Website'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651',b'Supplier Invoice Date cannot be greater than Posting Date',b'Lieferant Rechnungsdatum kann nicht gr\xc3\xb6\xc3\x9fer sein als Datum der Ver\xc3\xb6ffentlichung'
+b'DocType: Purchase Invoice Item',b'Purchase Order Item',b'Lieferantenauftrags-Artikel'
+b'DocType: Agriculture Task',b'Agriculture Task',b'Landwirtschaftsaufgabe'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132',b'Indirect Income',b'Indirekte Ertr\xc3\xa4ge'
+b'DocType: Student Attendance Tool',b'Student Attendance Tool',b'Sch\xc3\xbclerteilnahme Werkzeug'
+b'DocType: Restaurant Menu',b'Price List (Auto created)',b'Preisliste (automatisch erstellt)'
+b'DocType: Cheque Print Template',b'Date Settings',b'Datums-Einstellungen'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48',b'Variance',b'Abweichung'
+,b'Company Name',b'Firmenname'
+b'DocType: SMS Center',b'Total Message(s)',b'Summe Nachricht(en)'
+b'DocType: Share Balance',b'Purchased',b'Gekauft'
+b'DocType: Item Variant Settings',b'Rename Attribute Value in Item Attribute.',b'Benennen Sie Attributwert in Elementattribut um.'
+b'DocType: Purchase Invoice',b'Additional Discount Percentage',b'Zus\xc3\xa4tzlicher prozentualer Rabatt'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24',b'View a list of all the help videos',b'Sehen Sie eine Liste aller Hilfe-Videos'
+b'DocType: Agriculture Analysis Criteria',b'Soil Texture',b'Bodentextur'
+b'DocType: Bank Reconciliation',b'Select account head of the bank where cheque was deposited.',"b'Bezeichnung des Kontos bei der Bank, bei der der Scheck eingereicht wurde, ausw\xc3\xa4hlen.'"
+b'DocType: Selling Settings',b'Allow user to edit Price List Rate in transactions',"b'Benutzer erlauben, die Preisliste in Transaktionen zu bearbeiten'"
+b'DocType: Pricing Rule',b'Max Qty',b'Maximalmenge'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25',b'Print Report Card',b'Berichtskarte drucken'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30',"b'Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \\\n\t\t\t\t\t\tPlease enter a valid Invoice'","b'Row {0}: Rechnung {1} ist ung\xc3\xbcltig, k\xc3\xb6nnte es abgebrochen werden / nicht vorhanden. \\ Bitte geben Sie eine g\xc3\xbcltige Rechnung'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132',b'Row {0}: Payment against Sales/Purchase Order should always be marked as advance',"b'Zeile {0}: ""Zahlung zu Kunden-/Lieferantenauftrag"" sollte immer als ""Vorkasse"" eingestellt werden'"
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16',b'Chemical',b'Chemische Industrie'
+b'DocType: Salary Component Account',b'Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.',"b'Standard Bank / Geldkonto wird automatisch in Gehalts Journal Entry aktualisiert werden, wenn dieser Modus ausgew\xc3\xa4hlt ist.'"
+b'DocType: BOM',b'Raw Material Cost(Company Currency)',b'Rohstoffkosten (Gesellschaft W\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',"b'Row # {0}: Die Rate kann nicht gr\xc3\xb6\xc3\x9fer sein als die Rate, die in {1} {2}'"
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Meter',b'Meter'
+b'DocType: Workstation',b'Electricity Cost',b'Stromkosten'
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23',b'Lab testing datetime cannot be before collection datetime',b'Lab-Testdatum kann nicht vor dem Erfassungsdatum liegen'
+b'DocType: HR Settings',"b""Don't send Employee Birthday Reminders""",b'Keine Mitarbeitergeburtstagserinnerungen senden'
+b'DocType: Expense Claim',b'Total Advance Amount',b'Gesamtvorauszahlungsbetrag'
+b'DocType: Delivery Stop',b'Estimated Arrival',b'Voraussichtliche Ankunft'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34',b'Save Settings',b'Einstellungen speichern'
+b'DocType: Delivery Stop',b'Notified by Email',b'Benachrichtigung per E-Mail'
+b'DocType: Item',b'Inspection Criteria',b'Pr\xc3\xbcfkriterien'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14',b'Transfered',b'\xc3\x9cbergeben'
+b'DocType: BOM Website Item',b'BOM Website Item',b'BOM Webseitenartikel'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +52',b'Upload your letter head and logo. (you can edit them later).',b'Briefkopf und Logo hochladen. (Beides kann sp\xc3\xa4ter noch bearbeitet werden.)'
+b'DocType: Timesheet Detail',b'Bill',b'Rechnung'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +88',b'Next Depreciation Date is entered as past date',b'Weiter Abschreibungen Datum wird als vergangenes Datum eingegeben'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208',b'White',b'Wei\xc3\x9f'
+b'DocType: SMS Center',b'All Lead (Open)',b'Alle Leads (offen)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270',b'Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3})',b'Row {0}: Menge nicht f\xc3\xbcr {4} in Lager {1} zum Zeitpunkt des Eintrags Entsendung ({2} {3})'
+b'apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18',b'You can only select a maximum of one option from the list of check boxes.',b'Sie k\xc3\xb6nnen nur eine Option aus der Liste der Kontrollk\xc3\xa4stchen ausw\xc3\xa4hlen.'
+b'DocType: Purchase Invoice',b'Get Advances Paid',b'Gezahlte Anzahlungen aufrufen'
+b'DocType: Item',b'Automatically Create New Batch',b'Automatisch neue Charge erstellen'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635',b'Assigning {0} to {1} (row {2})',b'Zuweisen von {0} zu {1} (Zeile {2})'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Make ',b'Erstellen'
+b'DocType: Student Admission',b'Admission Start Date',b'Stichtag zum Zulassungsbeginn'
+b'DocType: Journal Entry',b'Total Amount in Words',b'Gesamtsumme in Worten'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29',b'New Employee',b'Neuer Angestellter'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7',"b""There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.""","b'Es ist ein Fehler aufgetreten. Ein m\xc3\xb6glicher Grund k\xc3\xb6nnte sein, dass Sie das Formular nicht gespeichert haben. Bitte kontaktieren Sie support@erpnext.com wenn das Problem weiterhin besteht.'"
+b'apps/erpnext/erpnext/templates/pages/cart.html +5',b'My Cart',b'Mein Warenkorb'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +130',b'Order Type must be one of {0}',b'Bestelltyp muss aus {0} sein'
+b'DocType: Lead',b'Next Contact Date',b'N\xc3\xa4chstes Kontaktdatum'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36',b'Opening Qty',b'Anfangsmenge'
+b'DocType: Healthcare Settings',b'Appointment Reminder',b'Termin Erinnerung'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478',b'Please enter Account for Change Amount',b'Bitte geben Sie Konto f\xc3\xbcr \xc3\x84nderungsbetrag'
+b'DocType: Program Enrollment Tool Student',b'Student Batch Name',b'Studentenstapelname'
+b'DocType: Consultation',b'Doctor',b'Arzt'
+b'DocType: Holiday List',b'Holiday List Name',b'Urlaubslistenname'
+b'DocType: Repayment Schedule',b'Balance Loan Amount',b'Bilanz Darlehensbetrag'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14',b'Schedule Course',b'Unterrichtszeiten'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236',b'Stock Options',b'Lager-Optionen'
+b'DocType: Buying Settings',b'Disable Fetching Last Purchase Details in Purchase Order',b'Deaktivieren Sie das Abrufen der letzten Kaufdetails in der Bestellung'
+b'DocType: Journal Entry Account',b'Expense Claim',b'Aufwandsabrechnung'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +267',b'Do you really want to restore this scrapped asset?',b'Wollen Sie dieses entsorgte Gut wirklich wiederherstellen?'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381',b'Qty for {0}',b'Menge f\xc3\xbcr {0}'
+b'DocType: Leave Application',b'Leave Application',b'Urlaubsantrag'
+b'DocType: Patient',b'Patient Relation',b'Patientenbeziehung'
+b'apps/erpnext/erpnext/config/hr.py +80',b'Leave Allocation Tool',b'Urlaubszuordnungs-Werkzeug'
+b'DocType: Item',b'Hub Category to Publish',b'Zu ver\xc3\xb6ffentlichende Hub-Kategorie'
+b'DocType: Leave Block List',b'Leave Block List Dates',b'Urlaubssperrenliste\xc2\xa0Termine'
+b'DocType: Sales Invoice',b'Billing Address GSTIN',b'Rechnungsadresse Steuernummer'
+b'DocType: Assessment Plan',b'Evaluate',b'Bewerten'
+b'DocType: Workstation',b'Net Hour Rate',b'Nettostundensatz'
+b'DocType: Landed Cost Purchase Receipt',b'Landed Cost Purchase Receipt',b'Einstandspreis-Kaufbeleg'
+b'DocType: Company',b'Default Terms',b'Allgemeine Gesch\xc3\xa4ftsbedingungen'
+b'DocType: Supplier Scorecard Period',b'Criteria',b'Kriterien'
+b'DocType: Packing Slip Item',b'Packing Slip Item',b'Position auf dem Packzettel'
+b'DocType: Purchase Invoice',b'Cash/Bank Account',b'Bar-/Bankkonto'
+b'apps/erpnext/erpnext/public/js/queries.js +96',b'Please specify a {0}',b'Bitte geben Sie eine {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73',b'Removed items with no change in quantity or value.',b'Artikel wurden ohne Ver\xc3\xa4nderung der Menge oder des Wertes entfernt.'
+b'DocType: Delivery Note',b'Delivery To',b'Lieferung an'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +415',b'Variant creation has been queued.',b'Die Variantenerstellung wurde in die Warteschlange gestellt.'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100',b'Work Summary for {0}',b'Arbeitszusammenfassung f\xc3\xbcr {0}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +696',b'Attribute table is mandatory',b'Attributtabelle ist zwingend erforderlich'
+b'DocType: Production Plan',b'Get Sales Orders',b'Kundenauftr\xc3\xa4ge aufrufen'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68',b'{0} can not be negative',b'{0} kann nicht negativ sein'
+b'DocType: Training Event',b'Self-Study',b'Selbststudium'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27',b'Soil compositions do not add up to 100',b'Bodenzusammensetzungen ergeben nicht 100'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558',b'Discount',b'Rabatt'
+b'DocType: Membership',b'Membership',b'Mitgliedschaft'
+b'DocType: Asset',b'Total Number of Depreciations',b'Gesamtzahl der Abschreibungen'
+b'DocType: Sales Invoice Item',b'Rate With Margin',b'Betrag mit Marge'
+b'DocType: Workstation',b'Wages',b'Lohn'
+b'DocType: Asset Maintenance',b'Maintenance Manager Name',b'Name des Wartungs-Managers'
+b'DocType: Agriculture Task',b'Urgent',b'Dringend'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174',b'Please specify a valid Row ID for row {0} in table {1}',b'Bitte eine g\xc3\xbcltige Zeilen-ID f\xc3\xbcr die Zeile {0} in Tabelle {1} angeben'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84',b'Unable to find variable: ',b'Variable kann nicht gefunden werden:'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +794',b'Please select a field to edit from numpad',b'Bitte w\xc3\xa4hle ein Feld aus numpad aus'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +264',b'Cannot be a fixed asset item as Stock Ledger is created.',"b'Kann keine Anlageposition sein, wenn das Stock Ledger erstellt wird.'"
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23',b'Go to the Desktop and start using ERPNext',b'Gehen Sie zum Desktop und starten Sie ERPNext'
+b'DocType: Item',b'Manufacturer',b'Hersteller'
+b'DocType: Landed Cost Item',b'Purchase Receipt Item',b'Kaufbeleg-Artikel'
+b'DocType: Purchase Receipt',b'PREC-RET-',b'PREC-Ret'
+b'DocType: POS Profile',b'Sales Invoice Payment',b'Ausgangsrechnung-Zahlungen'
+b'DocType: Quality Inspection Template',b'Quality Inspection Template Name',b'Name der Qualit\xc3\xa4tsinspektionsvorlage'
+b'DocType: Project',b'First Email',b'Erste E-Mail'
+b'DocType: Production Plan Item',b'Reserved Warehouse in Sales Order / Finished Goods Warehouse',b'Lager im Kundenauftrag reserviert / Fertigwarenlager'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71',b'Selling Amount',b'Verkaufsbetrag'
+b'DocType: Repayment Schedule',b'Interest Amount',b'Zinsbetrag'
+b'DocType: Serial No',b'Creation Document No',b'Belegerstellungs-Nr.'
+b'DocType: Share Transfer',b'Issue',b'Anfrage'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11',b'Records',b'Aufzeichnungen'
+b'DocType: Asset',b'Scrapped',b'Entsorgt'
+b'DocType: Purchase Invoice',b'Returns',b'Retouren'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42',b'WIP Warehouse',b'Fertigungslager'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195',b'Serial No {0} is under maintenance contract upto {1}',b'Seriennummer {0} ist mit Wartungsvertrag versehen bis {1}'
+b'apps/erpnext/erpnext/config/hr.py +35',b'Recruitment',b'Rekrutierung'
+b'DocType: Lead',b'Organization Name',b'Firmenname'
+b'DocType: Tax Rule',b'Shipping State',b'Versandstatus'
+,b'Projected Quantity as Source',b'Projizierte Menge als Quelle'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61',"b""Item must be added using 'Get Items from Purchase Receipts' button""","b'Artikel m\xc3\xbcssen \xc3\xbcber die Schaltfl\xc3\xa4che ""Artikel von Kaufbeleg \xc3\xbcbernehmen"" hinzugef\xc3\xbcgt werden'"
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858',b'Delivery Trip',b'Liefertrip'
+b'DocType: Student',b'A-',b'A-'
+b'DocType: Share Transfer',b'Transfer Type',b'\xc3\x9cbertragungsart'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117',b'Sales Expenses',b'Vertriebskosten'
+b'DocType: Consultation',b'Diagnosis',b'Diagnose'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18',b'Standard Buying',b'Standard-Kauf'
+b'DocType: GL Entry',b'Against',b'Zu'
+b'DocType: Item',b'Default Selling Cost Center',b'Standard-Vertriebskostenstelle'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +85',b'Disc',b'Scheibe'
+b'DocType: Sales Partner',b'Implementation Partner',b'Umsetzungspartner'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1624',b'ZIP Code',b'Postleitzahl'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +252',b'Sales Order {0} is {1}',b'Kundenauftrag {0} ist {1}'
+b'DocType: Opportunity',b'Contact Info',b'Kontakt-Information'
+b'apps/erpnext/erpnext/config/stock.py +319',b'Making Stock Entries',b'Lagerbuchungen erstellen'
+b'DocType: Packing Slip',b'Net Weight UOM',b'Nettogewichtma\xc3\x9feinheit'
+b'DocType: Item',b'Default Supplier',b'Standardlieferant'
+b'DocType: Manufacturing Settings',b'Over Production Allowance Percentage',b'Prozensatz erlaubter \xc3\x9cberproduktion'
+b'DocType: Employee Loan',b'Repayment Schedule',b'R\xc3\xbcckzahlungsplan'
+b'DocType: Shipping Rule Condition',b'Shipping Rule Condition',b'Versandbedingung'
+b'DocType: Holiday List',b'Get Weekly Off Dates',b'W\xc3\xb6chentliche Abwesenheitstermine abrufen'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33',b'End Date can not be less than Start Date',b'Enddatum kann nicht vor Startdatum liegen'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337',"b""Invoice can't be made for zero billing hour""",b'Die Rechnung kann nicht f\xc3\xbcr die Null-Rechnungsstunde erstellt werden'
+b'DocType: Sales Person',b'Select company name first.',b'Zuerst den Firmennamen ausw\xc3\xa4hlen.'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189',b'Email sent to {0}',b'E-Mail an {0} gesendet'
+b'apps/erpnext/erpnext/config/buying.py +23',b'Quotations received from Suppliers.',b'Angebote von Lieferanten'
+b'apps/erpnext/erpnext/config/manufacturing.py +74',b'Replace BOM and update latest price in all BOMs',b'Ersetzen Sie die St\xc3\xbcckliste und aktualisieren Sie den aktuellen Preis in allen St\xc3\xbccklisten'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +27',b'To {0} | {1} {2}',b'An {0} | {1} {2}'
+b'DocType: Delivery Trip',b'Driver Name',b'Fahrername'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40',b'Average Age',b'Durchschnittsalter'
+b'DocType: Education Settings',b'Attendance Freeze Date',b'Anwesenheit Einfrieren Datum'
+b'apps/erpnext/erpnext/utilities/user_progress.py +110',b'List a few of your suppliers. They could be organizations or individuals.',b'Bitte ein paar Lieferanten angeben. Diese k\xc3\xb6nnen Firmen oder Einzelpersonen sein.'
+b'apps/erpnext/erpnext/templates/pages/home.html +31',b'View All Products',b'Alle Produkte'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimum Lead Alter (Tage)'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60',b'All BOMs',b'Alle St\xc3\xbccklisten'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35',b'Hotel Rooms of type {0} are unavailable on {1}',b'Hotelzimmer vom Typ {0} sind auf {1} nicht verf\xc3\xbcgbar'
+b'DocType: Patient',b'Default Currency',b'Standardw\xc3\xa4hrung'
+b'DocType: Expense Claim',b'From Employee',b'Von Mitarbeiter'
+b'DocType: Driver',b'Cellphone Number',b'Handynummer'
+b'DocType: Project',b'Monitor Progress',b'\xc3\x9cberwachung der Fortschritte'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +472',b'Warning: System will not check overbilling since amount for Item {0} in {1} is zero',"b'Achtung: Das System erkennt keine \xc3\xbcberh\xc3\xb6hten Rechnungen, da der Betrag f\xc3\xbcr Artikel {0} in {1} gleich Null ist'"
+b'DocType: Journal Entry',b'Make Difference Entry',b'Differenzbuchung erstellen'
+b'DocType: Upload Attendance',b'Attendance From Date',b'Anwesenheit von Datum'
+b'DocType: Appraisal Template Goal',b'Key Performance Area',b'Entscheidender Leistungsbereich'
+b'DocType: Program Enrollment',b'Transportation',b'Transport'
+b'apps/erpnext/erpnext/controllers/item_variant.py +94',b'Invalid Attribute',b'Ung\xc3\xbcltige Attribute'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240',b'{0} {1} must be submitted',b'{0} {1} muss vorgelegt werden'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159',b'Quantity must be less than or equal to {0}',b'Menge muss kleiner oder gleich {0} sein'
+b'DocType: SMS Center',b'Total Characters',b'Gesamtanzahl Zeichen'
+b'DocType: Employee Advance',b'Claimed',b'Behauptet'
+b'DocType: Crop',b'Row Spacing',b'Zeilenabstand'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +164',b'Please select BOM in BOM field for Item {0}',b'Bitte aus dem St\xc3\xbccklistenfeld eine St\xc3\xbcckliste f\xc3\xbcr Artikel {0} ausw\xc3\xa4hlen'
+b'DocType: C-Form Invoice Detail',b'C-Form Invoice Detail',b'Kontakt-Formular Rechnungsdetail'
+b'DocType: Payment Reconciliation Invoice',b'Payment Reconciliation Invoice',b'Rechnung zum Zahlungsabgleich'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38',b'Contribution %',b'Beitrag in %'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215',"b""As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}""","b'Nach den Kaufeinstellungen, wenn Bestellbedarf == &#39;JA&#39;, dann f\xc3\xbcr die Erstellung der Kaufrechnung, muss der Benutzer die Bestellung zuerst f\xc3\xbcr den Eintrag {0}'"
+b'DocType: Company',b'Company registration numbers for your reference. Tax numbers etc.',b'Meldenummern des Unternehmens f\xc3\xbcr Ihre Unterlagen. Steuernummern usw.'
+b'DocType: Sales Partner',b'Distributor',b'Lieferant'
+b'DocType: Shopping Cart Shipping Rule',b'Shopping Cart Shipping Rule',b'Warenkorb-Versandregel'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +71',"b""Please set 'Apply Additional Discount On'""","b'Bitte ""Zus\xc3\xa4tzlichen Rabatt anwenden auf"" aktivieren'"
+,b'Ordered Items To Be Billed',"b'Bestellte Artikel, die abgerechnet werden m\xc3\xbcssen'"
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46',b'From Range has to be less than To Range',b'Von-Bereich muss kleiner sein als Bis-Bereich'
+b'DocType: Global Defaults',b'Global Defaults',b'Allgemeine Voreinstellungen'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +230',b'Project Collaboration Invitation',b'Projekt-Zusammenarbeit Einladung'
+b'DocType: Salary Slip',b'Deductions',b'Abz\xc3\xbcge'
+b'DocType: Leave Allocation',b'LAL/',b'LAL /'
+b'DocType: Setup Progress Action',b'Action Name',b'Aktionsname'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +75',b'Start Year',b'Startjahr'
+b'apps/erpnext/erpnext/regional/india/utils.py +25',b'First 2 digits of GSTIN should match with State number {0}',b'Die ersten 2 Ziffern von GSTIN sollten mit der Statusnummer {0} \xc3\xbcbereinstimmen'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68',b'PDC/LC',b'PDC / LC'
+b'DocType: Purchase Invoice',"b""Start date of current invoice's period""",b'Startdatum der laufenden Rechnungsperiode'
+b'DocType: Salary Slip',b'Leave Without Pay',b'Unbezahlter Urlaub'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385',b'Capacity Planning Error',b'Fehler in der Kapazit\xc3\xa4tsplanung'
+,b'Trial Balance for Party',b'Summen- und Saldenliste f\xc3\xbcr Gruppe'
+b'DocType: Lead',b'Consultant',b'Berater'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356',b'Parents Teacher Meeting Attendance',b'Eltern Lehrer Treffen Teilnahme'
+b'DocType: Salary Slip',b'Earnings',b'Eink\xc3\xbcnfte'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +441',b'Finished Item {0} must be entered for Manufacture type entry',b'Fertiger Artikel {0} muss f\xc3\xbcr eine Fertigungsbuchung eingegeben werden'
+b'apps/erpnext/erpnext/config/learn.py +87',b'Opening Accounting Balance',b'Er\xc3\xb6ffnungsbilanz'
+,b'GST Sales Register',b'GST Verkaufsregister'
+b'DocType: Sales Invoice Advance',b'Sales Invoice Advance',b'Anzahlung auf Ausgangsrechnung'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552',b'Nothing to request',b'Nichts anzufragen'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +18',b'Select your Domains',b'W\xc3\xa4hlen Sie Ihre Domains'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34',"b""Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3}""","b""Ein weitere Budgetplan  '{0}' existiert bereits gegen {1} {2} 'f\xc3\xbcr das Gesch\xc3\xa4ftsjahr {3}"""
+b'DocType: Item Variant Settings',b'Fields will be copied over only at time of creation.',b'Felder werden nur zum Zeitpunkt der Erstellung kopiert.'
+b'DocType: Setup Progress Action',b'Domains',b'Domainen'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +41',"b""'Actual Start Date' can not be greater than 'Actual End Date'""","b'Das ""Tats\xc3\xa4chliche Startdatum"" kann nicht nach dem  ""Tats\xc3\xa4chlichen Enddatum"" liegen'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117',b'Management',b'Verwaltung'
+b'DocType: Cheque Print Template',b'Payer Settings',b'Payer Einstellungen'
+b'DocType: Item Attribute Value',"b'This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""'","b'Dies wird an den Artikelcode der Variante angeh\xc3\xa4ngt. Beispiel: Wenn Ihre Abk\xc3\xbcrzung ""SM"" und der Artikelcode ""T-SHIRT"" sind, so ist der Artikelcode der Variante ""T-SHIRT-SM""'"
+b'DocType: Salary Slip',b'Net Pay (in words) will be visible once you save the Salary Slip.',"b'Nettolohn (in Worten) wird angezeigt, sobald Sie die Gehaltsabrechnung speichern.'"
+b'DocType: Purchase Invoice',b'Is Return',b'Ist R\xc3\xbcckgabe'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',b'Caution',b'Vorsicht'
+b'apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17',"b""Start day is greater than end day in task '{0}'""",b'Starttag ist gr\xc3\xb6\xc3\x9fer als Endtag in Aufgabe &#39;{0}&#39;'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815',b'Return / Debit Note',b'Return / Lastschrift'
+b'DocType: Price List Country',b'Price List Country',b'Preisliste Land'
+b'DocType: Item',b'UOMs',b'Ma\xc3\x9feinheiten'
+b'apps/erpnext/erpnext/stock/utils.py +212',b'{0} valid serial nos for Item {1}',b'{0} g\xc3\xbcltige Seriennummern f\xc3\xbcr Artikel {1}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57',b'Item Code cannot be changed for Serial No.',b'Artikelnummer kann nicht f\xc3\xbcr Seriennummer ge\xc3\xa4ndert werden'
+b'DocType: Purchase Invoice Item',b'UOM Conversion Factor',b'Ma\xc3\x9feinheit-Umrechnungsfaktor'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40',b'Please enter Item Code to get Batch Number',b'Bitte geben Sie Item Code zu Chargennummer erhalten'
+b'DocType: Stock Settings',b'Default Item Group',b'Standard-Artikelgruppe'
+b'DocType: Employee Loan',b'Partially Disbursed',b'teil~~POS=TRUNC Zahlter'
+b'apps/erpnext/erpnext/config/non_profit.py +73',b'Grant information.',b'Gew\xc3\xa4hren Sie Informationen.'
+b'apps/erpnext/erpnext/config/buying.py +38',b'Supplier database.',b'Lieferantendatenbank'
+b'DocType: Account',b'Balance Sheet',b'Bilanz'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750',"b""Cost Center For Item with Item Code '""",b'Kostenstelle f\xc3\xbcr den Artikel mit der Artikel-Nr.'
+b'DocType: Fee Validity',b'Valid Till',b'G\xc3\xbcltig bis'
+b'DocType: Student Report Generation Tool',b'Total Parents Teacher Meeting',b'Total Eltern Lehrer Treffen'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2516',"b'Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.'","b'Zahlungsmittel ist nicht konfiguriert. Bitte \xc3\xbcberpr\xc3\xbcfen Sie, ob ein Konto in den Zahlungsmodi oder in einem Verkaufsstellen-Profil eingestellt wurde.'"
+b'apps/erpnext/erpnext/buying/utils.py +74',b'Same item cannot be entered multiple times.',b'Das gleiche Einzelteil kann nicht mehrfach eingegeben werden.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30',"b'Further accounts can be made under Groups, but entries can be made against non-Groups'","b'Weitere Konten k\xc3\xb6nnen unter Gruppen angelegt werden, aber Buchungen k\xc3\xb6nnen zu nicht-Gruppen erstellt werden'"
+b'DocType: Lead',b'Lead',b'Lead'
+b'DocType: Email Digest',b'Payables',b'Verbindlichkeiten'
+b'DocType: Course',b'Course Intro',b'Kurs Intro'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +105',b'Stock Entry {0} created',b'Lagerbuchung {0} erstellt'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +306',b'Row #{0}: Rejected Qty can not be entered in Purchase Return',b'Zeile #{0}: Abgelehnte Menge kann nicht in Kaufr\xc3\xbcckgabe eingegeben werden'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +182',b'Changing Customer Group for the selected Customer is not allowed.',b'Die \xc3\x84nderung der Kundengruppe f\xc3\xbcr den ausgew\xc3\xa4hlten Kunden ist nicht zul\xc3\xa4ssig.'
+,b'Purchase Order Items To Be Billed',"b'Bei Lieferanten bestellte Artikel, die noch abgerechnet werden m\xc3\xbcssen'"
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63',b'Updating estimated arrival times.',b'Aktualisierung der gesch\xc3\xa4tzten Ankunftszeiten'
+b'DocType: Program Enrollment Tool',b'Enrollment Details',b'Anmeldedetails'
+b'DocType: Purchase Invoice Item',b'Net Rate',b'Nettopreis'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152',b'Please select a customer',b'Bitte w\xc3\xa4hlen Sie einen Kunden aus'
+b'DocType: Purchase Invoice Item',b'Purchase Invoice Item',b'Eingangsrechnungs-Artikel'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58',b'Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts',b'Buchungen auf das Lagerbuch und Hauptbuch-Buchungen werden f\xc3\xbcr die gew\xc3\xa4hlten Kaufbelege umgebucht'
+b'DocType: Student Report Generation Tool',b'Assessment Terms',b'Bewertungsbedingungen'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8',b'Item 1',b'Position 1'
+b'DocType: Holiday',b'Holiday',b'Urlaub'
+b'DocType: Support Settings',b'Close Issue After Days',b'Vorfall schlie\xc3\x9fen nach'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all branches',"b'Freilassen, wenn f\xc3\xbcr alle Filialen g\xc3\xbcltig'"
+b'DocType: Bank Guarantee',b'Validity in Days',b'G\xc3\xbcltigkeit in Tagen'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21',b'C-form is not applicable for Invoice: {0}',b'Kontaktformular nicht anwendbar auf  Rechnung: {0}'
+b'DocType: Payment Reconciliation',b'Unreconciled Payment Details',b'Nicht abgeglichene Zahlungen'
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6',b'Member Activity',b'Mitglied Aktivit\xc3\xa4t'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Auftragsz\xc3\xa4hler'
+b'DocType: Global Defaults',b'Current Fiscal Year',b'Laufendes Gesch\xc3\xa4ftsjahr'
+b'DocType: Purchase Order',b'Group same items',b'Gruppe gleichen Artikel'
+b'DocType: Purchase Invoice',b'Disable Rounded Total',"b'""Gesamtsumme runden"" abschalten'"
+b'DocType: Employee Loan Application',b'Repayment Info',b'Die R\xc3\xbcckzahlung Info'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448',"b""'Entries' cannot be empty""","b'""Buchungen"" kann nicht leer sein'"
+b'DocType: Maintenance Team Member',b'Maintenance Role',b'Wartungsrolle'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +92',b'Duplicate row {0} with same {1}',b'Dupliziere Zeile {0} mit demselben {1}'
+,b'Trial Balance',b'Probebilanz'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443',b'Fiscal Year {0} not found',b'Das Gesch\xc3\xa4ftsjahr {0} nicht gefunden'
+b'apps/erpnext/erpnext/config/hr.py +309',b'Setting up Employees',b'Mitarbeiter anlegen'
+b'DocType: Sales Order',b'SO-',b'DAMIT-'
+b'DocType: Hotel Room Reservation',b'Hotel Reservation User',b'Hotelreservierung Benutzer'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158',b'Please select prefix first',b'Bitte zuerst Pr\xc3\xa4fix ausw\xc3\xa4hlen'
+b'DocType: Student',b'O-',b'O-'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189',b'Research',b'Forschung'
+b'DocType: Maintenance Visit Purpose',b'Work Done',b'Arbeit erledigt'
+b'apps/erpnext/erpnext/controllers/item_variant.py +35',b'Please specify at least one attribute in the Attributes table',b'Bitte geben Sie mindestens ein Attribut in der Attributtabelle ein'
+b'DocType: Announcement',b'All Students',b'Alle Sch\xc3\xbcler'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +45',b'Item {0} must be a non-stock item',b'Artikel {0} darf kein Lagerartikel sein'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +18',b'View Ledger',b'Hauptbuch anzeigen'
+b'DocType: Grading Scale',b'Intervals',b'Intervalle'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Earliest',b'Fr\xc3\xbchestens'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +526',"b'An Item Group exists with same name, please change the item name or rename the item group'",b'Eine Artikelgruppe mit dem gleichen Namen existiert bereits. Bitte den Artikelnamen \xc3\xa4ndern oder die Artikelgruppe umbenennen'
+b'DocType: Crop Cycle',b'Less than a year',b'Weniger als ein Jahr'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52',b'Student Mobile No.',b'Student Mobil-Nr'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105',b'Rest Of The World',b'Rest der Welt'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81',b'The Item {0} cannot have Batch',b'Der Artikel {0} kann keine Charge haben'
+b'DocType: Crop',b'Yield UOM',b'Ertrag UOM'
+,b'Budget Variance Report',b'Budget-Abweichungsbericht'
+b'DocType: Salary Slip',b'Gross Pay',b'Bruttolohn'
+b'DocType: Item',b'Is Item from Hub',b'Ist ein Gegenstand aus dem Hub'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118',b'Row {0}: Activity Type is mandatory.',b'Row {0}: Leistungsart ist obligatorisch.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166',b'Dividends Paid',b'Ausgesch\xc3\xbcttete Dividenden'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36',b'Accounting Ledger',b'Hauptbuch'
+b'DocType: Stock Reconciliation',b'Difference Amount',b'Differenzmenge'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107',b'Dr {0} on Leave on {1}',b'Dr {0} bei Verlassen auf {1}'
+b'DocType: Purchase Invoice',b'Reverse Charge',b'Reverse Charge'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172',b'Retained Earnings',b'Gewinnr\xc3\xbccklagen'
+b'DocType: Purchase Invoice',b'05-Change in POS',b'05-\xc3\x84nderung am POS'
+b'DocType: Vehicle Log',b'Service Detail',b'Service Detail'
+b'DocType: BOM',b'Item Description',b'Artikelbeschreibung'
+b'DocType: Student Sibling',b'Student Sibling',b'Studenten Geschwister'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18',b'Payment Mode',b'Zahlungsweise'
+b'DocType: Purchase Invoice',b'Supplied Items',b'Gelieferte Artikel'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85',b'Please set an active menu for Restaurant {0}',b'Bitte setzen Sie ein aktives Men\xc3\xbc f\xc3\xbcr Restaurant {0}'
+b'DocType: Student',b'STUD.',b'ZUCHT.'
+b'DocType: Work Order',b'Qty To Manufacture',b'Herzustellende Menge'
+b'DocType: Email Digest',b'New Income',b'Neuer Verdienst'
+b'DocType: Buying Settings',b'Maintain same rate throughout purchase cycle',b'Gleiche Preise w\xc3\xa4hrend des gesamten Einkaufszyklus beibehalten'
+b'DocType: Opportunity Item',b'Opportunity Item',b'Chance-Artikel'
+,b'Student and Guardian Contact Details',b'Student and Guardian Kontaktdaten'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53',b'Row {0}: For supplier {0} Email Address is required to send email',"b'Zeile {0}: um E-Mails senden zu k\xc3\xb6nnen, ist eine E-Mail-Adresse f\xc3\xbcr den Anbieter {0} erforderlich.'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72',b'Temporary Opening',b'Tempor\xc3\xa4re Er\xc3\xb6ffnungskonten'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10',b'View Hub',b'Hub anzeigen'
+,b'Employee Leave Balance',b'\xc3\x9cbersicht der Urlaubskonten der Mitarbeiter'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147',b'Balance for Account {0} must always be {1}',b'Saldo f\xc3\xbcr Konto {0} muss immer {1} sein'
+b'DocType: Patient Appointment',b'More Info',b'Weitere Informationen'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180',b'Valuation Rate required for Item in row {0}',b'Bewertungsrate erforderlich f\xc3\xbcr den Posten in der Zeile {0}'
+b'DocType: Supplier Scorecard',b'Scorecard Actions',b'Scorecard-Aktionen'
+b'apps/erpnext/erpnext/utilities/user_progress.py +169',b'Example: Masters in Computer Science',b'Beispiel: Master in Informatik'
+b'DocType: Purchase Invoice',b'Rejected Warehouse',b'Ausschusslager'
+b'DocType: GL Entry',b'Against Voucher',b'Gegenbeleg'
+b'DocType: Item',b'Default Buying Cost Center',b'Standard-Einkaufskostenstelle'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6',"b'To get the best out of ERPNext, we recommend that you take some time and watch these help videos.'","b'Um ERPNext bestm\xc3\xb6glich zu nutzen, empfehlen wir Ihnen, sich die Zeit zu nehmen diese Hilfevideos anzusehen.'"
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +76',b' to ',b'nach'
+b'DocType: Supplier Quotation Item',b'Lead Time in days',b'Lieferzeit in Tagen'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70',b'Accounts Payable Summary',b'\xc3\x9cbersicht der Verbindlichkeiten'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326',b'Payment of salary from {0} to {1}',b'Die Zahlung des Gehalts von {0} {1}'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213',b'Not authorized to edit frozen Account {0}',b'Keine Berechtigung gesperrtes Konto {0} zu bearbeiten'
+b'DocType: Journal Entry',b'Get Outstanding Invoices',b'Ausstehende Rechnungen aufrufen'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84',b'Sales Order {0} is not valid',b'Kundenauftrag {0} ist nicht g\xc3\xbcltig'
+b'DocType: Supplier Scorecard',b'Warn for new Request for Quotations',b'Warnung f\xc3\xbcr neue Angebotsanfrage'
+b'apps/erpnext/erpnext/utilities/activation.py +91',b'Purchase orders help you plan and follow up on your purchases',b'Bestellungen helfen Ihnen bei der Planung und Follow-up auf Ihre Eink\xc3\xa4ufe'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151',b'Lab Test Prescriptions',b'Labortestverordnungen'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166',b'The total Issue / Transfer quantity {0} in Material Request {1}  \\\n\t\t\t\t\t\t\tcannot be greater than requested quantity {2} for Item {3}',b'Die gesamte Ausgabe / Transfer Menge {0} in Material anfordern {1} \\ kann nicht gr\xc3\xb6\xc3\x9fer sein als die angeforderte Menge {2} f\xc3\xbcr Artikel {3}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197',b'Small',b'Klein'
+b'DocType: Opening Invoice Creation Tool Item',b'Opening Invoice Creation Tool Item',b'Er\xc3\xb6ffnen des Rechnungserstellungswerkzeugs'
+b'DocType: Education Settings',b'Employee Number',b'Mitarbeiternummer'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67',b'Case No(s) already in use. Try from Case No {0}',b'Fall-Nr. (n) bereits in Verwendung. Versuchen Sie eine Fall-Nr. ab {0}'
+b'DocType: Project',b'% Completed',b'% abgeschlossen'
+,b'Invoiced Amount (Exculsive Tax)',b'Rechnungsbetrag (ohne MwSt.)'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14',b'Item 2',b'Position 2'
+b'DocType: Supplier',b'SUPP-',b'des Liefe-'
+b'DocType: Training Event',b'Training Event',b'Schulungsveranstaltung'
+b'DocType: Item',b'Auto re-order',b'Automatische Nachbestellung'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59',b'Total Achieved',b'Gesamtsumme erreicht'
+b'DocType: Employee',b'Place of Issue',b'Ausgabeort'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101',b'Contract',b'Vertrag'
+b'DocType: Plant Analysis',b'Laboratory Testing Datetime',b'Labortest Datetime'
+b'DocType: Email Digest',b'Add Quote',b'Angebot hinzuf\xc3\xbcgen'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +987',b'UOM coversion factor required for UOM: {0} in Item: {1}',b'Ma\xc3\x9feinheit-Umrechnungsfaktor ist erforderlich f\xc3\xbcr Ma\xc3\x9feinheit: {0} bei Artikel: {1}'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92',b'Indirect Expenses',b'Indirekte Aufwendungen'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98',b'Row {0}: Qty is mandatory',b'Zeile {0}: Menge ist zwingend erforderlich'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture',b'Landwirtschaft'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +794',b'Sync Master Data',b'Sync Master Data'
+b'DocType: Asset Repair',b'Repair Cost',b'Reparaturkosten'
+b'apps/erpnext/erpnext/utilities/user_progress.py +138',b'Your Products or Services',b'Ihre Produkte oder Dienstleistungen'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15',b'Failed to login',b'Einloggen fehlgeschlagen'
+b'DocType: Special Test Items',b'Special Test Items',b'Spezielle Testartikel'
+b'DocType: Mode of Payment',b'Mode of Payment',b'Zahlungsweise'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +202',b'Website Image should be a public file or website URL',b'Das Webseiten-Bild sollte eine \xc3\xb6ffentliche Datei oder eine Webseiten-URL sein'
+b'DocType: Student Applicant',b'AP',b'AP'
+b'DocType: Purchase Invoice Item',b'BOM',b'St\xc3\xbcckliste'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37',b'This is a root item group and cannot be edited.',b'Dies ist eine Root-Artikelgruppe und kann nicht bearbeitet werden.'
+b'DocType: Journal Entry Account',b'Purchase Order',b'Lieferantenauftrag'
+b'DocType: Vehicle',b'Fuel UOM',b'Kraftstoff UOM'
+b'DocType: Warehouse',b'Warehouse Contact Info',b'Kontaktinformation des Lager'
+b'DocType: Payment Entry',b'Write Off Difference Amount',b'Differenzbetrag Abschreibung'
+b'DocType: Volunteer',b'Volunteer Name',b'Freiwilliger Name'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434',"b'{0}: Employee email not found, hence email not sent'","b'{0}: Mitarbeiter E-Mail nicht gefunden, E-Mail daher nicht gesendet'"
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85',b'Shipping rule not applicable for country {0}',b'Versandregel gilt nicht f\xc3\xbcr Land {0}'
+b'DocType: Item',b'Foreign Trade Details',b'Au\xc3\x9fenhandelsdetails'
+,b'Assessment Plan Status',b'Status des Bewertungsplans'
+b'DocType: Email Digest',b'Annual Income',b'J\xc3\xa4hrliches Einkommen'
+b'DocType: Serial No',b'Serial No Details',b'Details zur Seriennummer'
+b'DocType: Purchase Invoice Item',b'Item Tax Rate',b'Artikelsteuersatz'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89',b'Please select Physician and Date',b'Bitte w\xc3\xa4hlen Sie Arzt und Datum'
+b'DocType: Student Group Student',b'Group Roll Number',b'Gruppenrolle Nummer'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145',"b'For {0}, only credit accounts can be linked against another debit entry'",b'F\xc3\xbcr {0} k\xc3\xb6nnen nur Habenkonten mit einer weiteren Sollbuchung verkn\xc3\xbcpft werden'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +84',b'Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly',b'Summe aller Aufgabe Gewichte sollten 1. Bitte stellen Sie Gewichte aller Projektaufgaben werden entsprechend'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588',b'Delivery Note {0} is not submitted',b'Lieferschein {0} ist nicht gebucht'
+b'apps/erpnext/erpnext/stock/get_item_details.py +148',b'Item {0} must be a Sub-contracted Item',b'Artikel {0} muss ein unterbeauftragter Artikel sein'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43',b'Capital Equipments',b'Betriebsverm\xc3\xb6gen'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33',"b""Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.""","b'Die Preisregel wird zun\xc3\xa4chst basierend auf dem Feld ""Anwenden auf"" ausgew\xc3\xa4hlt. Dieses kann ein Artikel, eine Artikelgruppe oder eine Marke sein.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246',b'Please set the Item Code first',b'Bitte legen Sie zuerst den Itemcode fest'
+b'DocType: Item',b'ITEM-',b'ARTKL-'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +123',b'Total allocated percentage for sales team should be 100',b'Insgesamt verteilte Prozentmenge f\xc3\xbcr Vertriebsteam sollte 100 sein'
+b'DocType: Sales Invoice Item',b'Edit Description',b'Beschreibung bearbeiten'
+b'DocType: Antibiotic',b'Antibiotic',b'Antibiotikum'
+,b'Team Updates',b'Team-Updates'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912',b'For Supplier',b'F\xc3\xbcr Lieferant'
+b'DocType: Account',b'Setting Account Type helps in selecting this Account in transactions.',b'Das Festlegen des Kontotyps hilft bei der Auswahl dieses Kontos bei Transaktionen.'
+b'DocType: Purchase Invoice',b'Grand Total (Company Currency)',b'Gesamtbetrag (Firmenw\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Create Print Format',b'Druckformat erstellen'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5',b'Fee Created',b'Fee Erstellt'
+b'apps/erpnext/erpnext/utilities/bot.py +39',b'Did not find any item called {0}',b'Hat keinen Artikel finden genannt {0}'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Formula',b'Kriterien Formel'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Total Outgoing',b'Summe Auslieferungen'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39',"b'There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""'","b'Es kann nur eine Versandbedingung mit dem Wert ""0"" oder ""leer"" f\xc3\xbcr ""Bis-Wert"" geben'"
+b'DocType: Authorization Rule',b'Transaction',b'Transaktion'
+b'DocType: Patient Appointment',b'Duration',b'Dauer'
+b'apps/erpnext/erpnext/controllers/status_updater.py +160',"b'For an item {0}, quantity must be positive number'",b'F\xc3\xbcr eine Position {0} muss die Menge eine positive Zahl sein'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27',b'Note: This Cost Center is a Group. Cannot make accounting entries against groups.',b'Hinweis: Diese Kostenstelle ist eine Gruppe. Buchungen k\xc3\xb6nnen nicht zu Gruppen erstellt werden.'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53',b'Child warehouse exists for this warehouse. You can not delete this warehouse.',b'Es sind Unterlager f\xc3\xbcr dieses Lager vorhanden. Sie k\xc3\xb6nnen dieses Lager daher nicht l\xc3\xb6schen.'
+b'DocType: Item',b'Website Item Groups',b'Webseiten-Artikelgruppen'
+b'DocType: Purchase Invoice',b'Total (Company Currency)',b'Gesamtsumme (Firmenw\xc3\xa4hrung)'
+b'DocType: Daily Work Summary Group',b'Reminder',b'Erinnerung'
+b'apps/erpnext/erpnext/stock/utils.py +207',b'Serial number {0} entered more than once',b'Seriennummer {0} wurde mehrfach erfasst'
+b'DocType: Journal Entry',b'Journal Entry',b'Buchungssatz'
+b'DocType: Expense Claim Advance',b'Unclaimed amount',b'Nicht beanspruchte Menge'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148',b'{0} items in progress',b'{0} Elemente in Bearbeitung'
+b'DocType: Workstation',b'Workstation Name',b'Name des Arbeitsplatzes'
+b'DocType: Grading Scale Interval',b'Grade Code',b'Grade-Code'
+b'DocType: POS Item Group',b'POS Item Group',b'POS Artikelgruppe'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17',b'Email Digest:',b'E-Mail-Bericht:'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613',b'BOM {0} does not belong to Item {1}',b'St\xc3\xbcckliste {0} geh\xc3\xb6rt nicht zum Artikel {1}'
+b'DocType: Sales Partner',b'Target Distribution',b'Aufteilung der Zielvorgaben'
+b'DocType: Purchase Invoice',b'06-Finalization of Provisional assessment',b'06-Abschluss der vorl\xc3\xa4ufigen Beurteilung'
+b'DocType: Salary Slip',b'Bank Account No.',b'Bankkonto-Nr.'
+b'DocType: Naming Series',b'This is the number of the last created transaction with this prefix',b'Dies ist die Nummer der letzten erstellten Transaktion mit diesem Pr\xc3\xa4fix'
+b'DocType: Supplier Scorecard',"b'Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n'","b'Scorecard-Variablen k\xc3\xb6nnen verwendet werden, sowie: {total_score} (die Gesamtpunktzahl aus diesem Zeitraum), {period_number} (die Anzahl der Perioden bis heute)'"
+b'DocType: Quality Inspection Reading',b'Reading 8',b'Ablesewert\xc2\xa08'
+b'DocType: Sales Partner',b'Agent',b'Beauftragter'
+b'DocType: Purchase Invoice',b'Taxes and Charges Calculation',b'Berechnung der Steuern und Geb\xc3\xbchren'
+b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Verm\xc3\xb6gensabschreibung automatisch verbuchen'
+b'DocType: BOM Operation',b'Workstation',b'Arbeitsplatz'
+b'DocType: Request for Quotation Supplier',b'Request for Quotation Supplier',b'Angebotsanfrage Lieferant'
+b'DocType: Healthcare Settings',b'Registration Message',b'Registrierungsnachricht'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154',b'Hardware',b'Hardware'
+b'DocType: Prescription Dosage',b'Prescription Dosage',b'Verschreibungspflichtige Dosierung'
+b'DocType: Attendance',b'HR Manager',b'Leiter der Personalabteilung'
+b'apps/erpnext/erpnext/accounts/party.py +175',b'Please select a Company',b'Bitte ein Unternehmen ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92',b'Privilege Leave',b'Bevorzugter Urlaub'
+b'DocType: Purchase Invoice',b'Supplier Invoice Date',b'Lieferantenrechnungsdatum'
+b'DocType: Asset Settings',b'This value is used for pro-rata temporis calculation',b'Dieser Wert wird f\xc3\xbcr die pro-rata-temporis-Berechnung verwendet'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90',b'You need to enable Shopping Cart',b'Sie m\xc3\xbcssen Ihren Einkaufswagen aktivieren.'
+b'DocType: Payment Entry',b'Writeoff',b'Abschreiben'
+b'DocType: Stock Settings',b'Naming Series Prefix',b'Naming Series Prefix'
+b'DocType: Appraisal Template Goal',b'Appraisal Template Goal',b'Bewertungsvorlage zur Zielorientierung'
+b'DocType: Salary Component',b'Earning',b'Einkommen'
+b'DocType: Supplier Scorecard',b'Scoring Criteria',b'Bewertungskriterien'
+b'DocType: Purchase Invoice',b'Party Account Currency',b'Gruppenkonten-W\xc3\xa4hrung'
+,b'BOM Browser',b'St\xc3\xbccklisten-Browser'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +13',b'Please update your status for this training event',b'Bitte aktualisieren Sie Ihren Status f\xc3\xbcr diese Trainingsveranstaltung'
+b'DocType: Item Barcode',b'EAN',b'EAN'
+b'DocType: Purchase Taxes and Charges',b'Add or Deduct',b'Addieren/Subtrahieren'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148',b'Overlapping conditions found between:',b'\xc3\x9cberlagernde Bedingungen gefunden zwischen:'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187',b'Against Journal Entry {0} is already adjusted against some other voucher',"b'""Zu Buchungssatz"" {0} ist bereits mit einem anderen Beleg abgeglichen'"
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68',b'Total Order Value',b'Gesamtbestellwert'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +328',b'Food',b'Lebensmittel'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57',b'Ageing Range 3',b'Alter Bereich 3'
+b'DocType: Maintenance Schedule Item',b'No of Visits',b'Anzahl der Besuche'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165',b'Maintenance Schedule {0} exists against {1}',b'Wartungsplan {0} existiert gegen {1}'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36',b'Enrolling student',b'einschreibende Student'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33',b'Currency of the Closing Account must be {0}',b'Die W\xc3\xa4hrung des Abschlusskontos muss {0} sein'
+b'apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21',b'Sum of points for all goals should be 100. It is {0}',b'Summe der Punkte f\xc3\xbcr alle Ziele sollte 100 sein. Aktueller Stand {0}'
+b'DocType: Project',b'Start and End Dates',b'Start- und Enddatum'
+,b'Delivered Items To Be Billed',"b'Gelieferte Artikel, die abgerechnet werden m\xc3\xbcssen'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16',b'Open BOM {0}',b'Open BOM {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60',b'Warehouse cannot be changed for Serial No.',b'Lager kann f\xc3\xbcr Seriennummer nicht ge\xc3\xa4ndert werden'
+b'DocType: Authorization Rule',b'Average Discount',b'Durchschnittlicher Rabatt'
+b'DocType: Project Update',b'Great/Quickly',b'Gro\xc3\x9fartig / Schnell'
+b'DocType: Purchase Invoice Item',b'UOM',b'UOM'
+b'DocType: Rename Tool',b'Utilities',b'Dienstprogramme'
+b'DocType: POS Profile',b'Accounting',b'Buchhaltung'
+b'DocType: Employee',b'EMP/',b'MA/'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133',b'Please select batches for batched item ',b'Bitte w\xc3\xa4hlen Sie Chargen f\xc3\xbcr Chargen'
+b'DocType: Asset',b'Depreciation Schedules',b'Abschreibungen Termine'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192',b'Following accounts might be selected in GST Settings:',b'In den GST-Einstellungen k\xc3\xb6nnen folgende Konten ausgew\xc3\xa4hlt werden:'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70',b'Application period cannot be outside leave allocation period',b'Beantragter Zeitraum kann nicht au\xc3\x9ferhalb der beantragten Urlaubszeit liegen'
+b'DocType: Activity Cost',b'Projects',b'Projekte'
+b'DocType: Payment Request',b'Transaction Currency',b'Transaktionsw\xc3\xa4hrung'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +30',b'From {0} | {1} {2}',b'Von {0} | {1} {2}'
+b'DocType: Work Order Operation',b'Operation Description',b'Vorgangsbeschreibung'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34',b'Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.',"b'Start- und Schlu\xc3\x9fdatum des Gesch\xc3\xa4ftsjahres k\xc3\xb6nnen nicht ge\xc3\xa4ndert werden, wenn das Gesch\xc3\xa4ftsjahr gespeichert wurde.'"
+b'DocType: Quotation',b'Shopping Cart',b'Warenkorb'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Avg Daily Outgoing',b'Durchschnittlicher t\xc3\xa4glicher Abgang'
+b'DocType: POS Profile',b'Campaign',b'Kampagne'
+b'DocType: Supplier',b'Name and Type',b'Name und Typ'
+b'DocType: Physician',b'Contacts and Address',b'Kontakte und Adresse'
+b'DocType: Purchase Invoice',b'Contact Person',b'Kontaktperson'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +38',"b""'Expected Start Date' can not be greater than 'Expected End Date'""","b'""Voraussichtliches Startdatum"" kann nicht nach dem ""Voraussichtlichen Enddatum"" liegen'"
+b'DocType: Course Scheduling Tool',b'Course End Date',b'Kurs Enddatum'
+b'DocType: Holiday List',b'Holidays',b'Ferien'
+b'DocType: Sales Order Item',b'Planned Quantity',b'Geplante Menge'
+b'DocType: Purchase Invoice Item',b'Item Tax Amount',b'Artikelsteuerbetrag'
+b'DocType: Water Analysis',b'Water Analysis Criteria',b'Wasseranalysekriterien'
+b'DocType: Item',b'Maintain Stock',b'Lager verwalten'
+b'DocType: Employee',b'Prefered Email',b'Bevorzugte E-Mail'
+b'DocType: Student Admission',b'Eligibility and Details',b'Teilnahmeberechtigung und Details'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38',b'Net Change in Fixed Asset',b'Nettover\xc3\xa4nderung des Anlageverm\xc3\xb6gens'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all designations',"b'Freilassen, wenn f\xc3\xbcr alle Einstufungen g\xc3\xbcltig'"
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +806',"b""Charge of type 'Actual' in row {0} cannot be included in Item Rate""","b'Kosten f\xc3\xbcr den Typ ""real"" in Zeile {0} k\xc3\xb6nnen nicht in den Artikelpreis mit eingeschlossen werden'"
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382',b'Max: {0}',b'Max: {0}'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'From Datetime',b'Von Datum und Uhrzeit'
+b'DocType: Email Digest',b'For Company',b'F\xc3\xbcr Firma'
+b'apps/erpnext/erpnext/config/support.py +17',b'Communication log.',b'Kommunikationsprotokoll'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195',"b'Request for Quotation is disabled to access from portal, for more check portal settings.'","b'Angebotsanfrage ist f\xc3\xbcr den Zugriff aus dem Portal deaktiviert, f\xc3\xbcr mehr Kontrolle Portaleinstellungen.'"
+b'DocType: Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72',b'Buying Amount',b'Einkaufsbetrag'
+b'DocType: Sales Invoice',b'Shipping Address Name',b'Lieferadresse Bezeichnung'
+b'DocType: Material Request',b'Terms and Conditions Content',b'Allgemeine Gesch\xc3\xa4ftsbedingungen Inhalt'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18',b'There were errors creating Course Schedule',b'Beim Erstellen des Kursplans sind Fehler aufgetreten'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581',b'cannot be greater than 100',b'Kann nicht gr\xc3\xb6\xc3\x9fer als 100 sein'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +752',b'Item {0} is not a stock Item',b'Artikel {0} ist kein Lagerartikel'
+b'DocType: Maintenance Visit',b'Unscheduled',b'Au\xc3\x9ferplanm\xc3\xa4\xc3\x9fig'
+b'DocType: Employee',b'Owned',b'Im Besitz von'
+b'DocType: Salary Detail',b'Depends on Leave Without Pay',b'H\xc3\xa4ngt von unbezahltem Urlaub ab'
+b'DocType: Pricing Rule',"b'Higher the number, higher the priority'","b'Je h\xc3\xb6her die Zahl, desto h\xc3\xb6her die Priorit\xc3\xa4t'"
+,b'Purchase Invoice Trends',b'Trendanalyse Eingangsrechnungen'
+b'DocType: Employee',b'Better Prospects',b'Bessere Vorhersage'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +217',"b'Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches'","b'Zeile # {0}: Der Batch {1} hat nur {2} Menge. Bitte w\xc3\xa4hle eine andere Charge aus, die {3} Menge zur Verf\xc3\xbcgung hat oder die Zeile in mehrere Zeilen aufteilt, um aus mehreren Chargen zu liefern / auszutauschen'"
+b'DocType: Vehicle',b'License Plate',b'Nummernschild'
+b'DocType: Appraisal',b'Goals',b'Ziele'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +353',b'Select POS Profile',b'Kassenprofil ausw\xc3\xa4hlen'
+b'DocType: Warranty Claim',b'Warranty / AMC Status',b'Status der Garantie / des j\xc3\xa4hrlichen Wartungsvertrags'
+,b'Accounts Browser',b'Kontenbrowser'
+b'DocType: Payment Entry Reference',b'Payment Entry Reference',b'Zahlungsreferenz'
+b'DocType: GL Entry',b'GL Entry',b'Buchung zum Hauptbuch'
+b'DocType: HR Settings',b'Employee Settings',b'Mitarbeitereinstellungen'
+,b'Batch-Wise Balance History',b'Chargenbezogener Bestandsverlauf'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73',b'Print settings updated in respective print format',b'Die Druckeinstellungen im jeweiligen Druckformat aktualisiert'
+b'DocType: Package Code',b'Package Code',b'Paketnummer'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105',b'Apprentice',b'Auszubildende(r)'
+b'DocType: Purchase Invoice',b'Company GSTIN',b'Unternehmen GSTIN'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105',b'Negative Quantity is not allowed',b'Negative Menge ist nicht erlaubt'
+b'DocType: Purchase Invoice Item',b'Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges',b'Die Tabelle Steuerdetails wird aus dem Artikelstamm als Zeichenfolge entnommen und in diesem Feld gespeichert. Wird verwendet f\xc3\xbcr Steuern und Abgaben'
+b'DocType: Supplier Scorecard Period',b'SSC-',b'SSC-'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +159',b'Employee cannot report to himself.',b'Mitarbeiter k\xc3\xb6nnen nicht an sich selbst Bericht erstatten'
+b'DocType: Account',"b'If the account is frozen, entries are allowed to restricted users.'","b'Wenn das Konto gesperrt ist, sind einem eingeschr\xc3\xa4nkten Benutzerkreis Buchungen erlaubt.'"
+b'DocType: Email Digest',b'Bank Balance',b'Kontostand'
+b'apps/erpnext/erpnext/accounts/party.py +240',b'Accounting Entry for {0}: {1} can only be made in currency: {2}',b'Eine Buchung f\xc3\xbcr {0}: {1} kann nur in der W\xc3\xa4hrung: {2} vorgenommen werden'
+b'DocType: Job Opening',"b'Job profile, qualifications required etc.'","b'Stellenbeschreibung, erforderliche Qualifikationen usw.'"
+b'DocType: Journal Entry Account',b'Account Balance',b'Kontostand'
+b'apps/erpnext/erpnext/config/accounts.py +183',b'Tax Rule for transactions.',b'Steuerregel f\xc3\xbcr Transaktionen'
+b'DocType: Rename Tool',b'Type of document to rename.',"b'Dokumententyp, der umbenannt werden soll.'"
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53',b'{0} {1}: Customer is required against Receivable account {2}',b'{0} {1}: F\xc3\xbcr das Eingangskonto {2} ist ein Kunde erforderlich'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges (Company Currency)',b'Gesamte Steuern und Geb\xc3\xbchren (Firmenw\xc3\xa4hrung)'
+b'DocType: Weather',b'Weather Parameter',b'Wetterparameter'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60',"b""Show unclosed fiscal year's P&L balances""",b'Gewinn- und Verlustrechnung f\xc3\xbcr nicht geschlossenes Finanzjahr zeigen.'
+b'DocType: Lab Test Template',b'Collection Details',b'Sammlungsdetails'
+b'DocType: POS Profile',b'Allow Print Before Pay',b'Druck vor Bezahlung zulassen'
+b'DocType: Land Unit',b'Linked Soil Texture',b'Verbundene Bodentextur'
+b'DocType: Shipping Rule',b'Shipping Account',b'Versandkonto'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92',b'{0} {1}: Account {2} is inactive',b'{0} {1}: Konto {2} ist inaktiv'
+b'apps/erpnext/erpnext/utilities/activation.py +82',b'Make Sales Orders to help you plan your work and deliver on-time',"b'Kundenauftr\xc3\xa4ge anlegen, um Arbeit zu planen und p\xc3\xbcnktliche Lieferung sicherzustellen'"
+b'DocType: Quality Inspection',b'Readings',b'Ablesungen'
+b'DocType: Stock Entry',b'Total Additional Costs',b'Gesamte Zusatzkosten'
+b'DocType: Course Schedule',b'SH',b'Sch'
+b'DocType: BOM',b'Scrap Material Cost(Company Currency)',b'Ausschussmaterialkosten (Firmenw\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66',b'Sub Assemblies',b'Unterbaugruppen'
+b'DocType: Asset',b'Asset Name',b'Asset-Name'
+b'DocType: Project',b'Task Weight',b'Vorgangsgewichtung'
+b'DocType: Shipping Rule Condition',b'To Value',b'Bis-Wert'
+b'DocType: Asset Movement',b'Stock Manager',b'Lagerleiter'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171',b'Source warehouse is mandatory for row {0}',b'Ausgangslager ist f\xc3\xbcr Zeile {0} zwingend erforderlich'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38',b'The Payment Term at row {0} is possibly a duplicate.',b'Die Zahlungsbedingung in Zeile {0} ist m\xc3\xb6glicherweise ein Duplikat.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +30',b'Agriculture (beta)',b'Landwirtschaft (beta)'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863',b'Packing Slip',b'Packzettel'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110',b'Office Rent',b'B\xc3\xbcromiete'
+b'apps/erpnext/erpnext/config/setup.py +111',b'Setup SMS gateway settings',b'Einstellungen f\xc3\xbcr SMS-Gateway verwalten'
+b'DocType: Disease',b'Common Name',b'Gemeinsamen Namen'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61',b'Import Failed!',b'Import fehlgeschlagen!'
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +20',b'No address added yet.',b'Noch keine Adresse hinzugef\xc3\xbcgt.'
+b'DocType: Workstation Working Hour',b'Workstation Working Hour',b'Arbeitsplatz-Arbeitsstunde'
+b'DocType: Vital Signs',b'Blood Pressure',b'Blutdruck'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125',b'Analyst',b'Analytiker'
+b'DocType: Item',b'Inventory',b'Lagerbestand'
+b'DocType: Item',b'Sales Details',b'Verkaufsdetails'
+b'DocType: Quality Inspection',b'QI-',b'QI-'
+b'DocType: Opportunity',b'With Items',b'Mit Artikeln'
+b'DocType: Asset Maintenance',b'Maintenance Team',b'Wartungs Team'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'In Qty',b'In Menge'
+b'DocType: Education Settings',b'Validate Enrolled Course for Students in Student Group',b'Validieren Sie den eingeschriebenen Kurs f\xc3\xbcr Studierende in der Studentengruppe'
+b'DocType: Notification Control',b'Expense Claim Rejected',b'Aufwandsabrechnung abgelehnt'
+b'DocType: Item',b'Item Attribute',b'Artikelattribut'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147',b'Government',b'Regierung'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40',b'Expense Claim {0} already exists for the Vehicle Log',b'Kostenabrechnung {0} existiert bereits f\xc3\xbcr das Fahrzeug Log'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +64',b'Institute Name',b'Name des Institutes'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117',b'Please enter repayment Amount',b'Bitte geben Sie R\xc3\xbcckzahlungsbetrag'
+b'apps/erpnext/erpnext/config/stock.py +309',b'Item Variants',b'Artikelvarianten'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +29',b'Services',b'Dienstleistungen'
+b'DocType: HR Settings',b'Email Salary Slip to Employee',b'Gehaltsabrechnung per E-Mail an Mitarbeiter senden'
+b'DocType: Cost Center',b'Parent Cost Center',b'\xc3\x9cbergeordnete Kostenstelle'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041',b'Select Possible Supplier',b'W\xc3\xa4hlen M\xc3\xb6gliche Lieferant'
+b'DocType: Sales Invoice',b'Source',b'Quelle'
+b'DocType: Customer',"b'Select, to make the customer searchable with these fields'","b'W\xc3\xa4hlen Sie, um den Kunden mit diesen Feldern durchsuchbar zu machen'"
+b'apps/erpnext/erpnext/templates/pages/projects.html +31',b'Show closed',b'Zeige geschlossen'
+b'DocType: Leave Type',b'Is Leave Without Pay',b'Ist unbezahlter Urlaub'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +261',b'Asset Category is mandatory for Fixed Asset item',b'Anlagekategorie ist obligatorisch f\xc3\xbcr Posten des Anlageverm\xc3\xb6gens'
+b'DocType: Fee Validity',b'Fee Validity',b'Geb\xc3\xbchreng\xc3\xbcltigkeit'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146',b'No records found in the Payment table',"b'Keine Datens\xc3\xa4tze in der Tabelle ""Zahlungen"" gefunden'"
+b'apps/erpnext/erpnext/education/utils.py +19',b'This {0} conflicts with {1} for {2} {3}',b'{0} steht im Konflikt mit {1} bez\xc3\xbcglich {2} {3}'
+b'DocType: Student Attendance Tool',b'Students HTML',b'Studenten HTML'
+b'DocType: POS Profile',b'Apply Discount',b'Rabatt anwenden'
+b'DocType: GST HSN Code',b'GST HSN Code',b'GST HSN Code'
+b'DocType: Employee External Work History',b'Total Experience',b'Gesamterfahrung'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70',b'Open Projects',b'offene Projekte'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295',b'Packing Slip(s) cancelled',b'Packzettel storniert'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36',b'Cash Flow from Investing',b'Cashflow aus Investitionen'
+b'DocType: Program Course',b'Program Course',b'Programm Kurs'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99',b'Freight and Forwarding Charges',b'Fracht- und Versandkosten'
+b'DocType: Homepage',b'Company Tagline for website homepage',b'Unternehmensschlagzeile f\xc3\xbcr die Internet-Homepage'
+b'DocType: Item Group',b'Item Group Name',b'Name der Artikelgruppe'
+b'apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27',b'Taken',b'Vergriffen'
+b'DocType: Student',b'Date of Leaving',b'Austrittsdatum'
+b'DocType: Pricing Rule',b'For Price List',b'F\xc3\xbcr Preisliste'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27',b'Executive Search',b'Direktsuche'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55',b'Setting defaults',b'Standardeinstellungen festlegen'
+b'apps/erpnext/erpnext/utilities/activation.py +63',b'Create Leads',b'Leads erstellen'
+b'DocType: Maintenance Schedule',b'Schedules',b'Zeitablaufpl\xc3\xa4ne'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +468',b'POS Profile is required to use Point-of-Sale',"b'POS-Profil ist erforderlich, um Point-of-Sale zu verwenden'"
+b'DocType: Purchase Invoice Item',b'Net Amount',b'Nettobetrag'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141',b'{0} {1} has not been submitted so the action cannot be completed',"b'{0} {1} sind nicht gebucht, deshalb kann die Aktion nicht abgeschlossen werden'"
+b'DocType: Purchase Order Item Supplied',b'BOM Detail No',b'St\xc3\xbcckliste Detailnr.'
+b'DocType: Landed Cost Voucher',b'Additional Charges',b'Zus\xc3\xa4tzliche Kosten'
+b'DocType: Purchase Invoice',b'Additional Discount Amount (Company Currency)',b'Zus\xc3\xa4tzlicher Rabatt (Firmenw\xc3\xa4hrung)'
+b'DocType: Supplier Scorecard',b'Supplier Scorecard',b'Lieferanten-Scorecard'
+b'DocType: Plant Analysis',b'Result Datetime',b'Ergebnis Datetime'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +21',b'Please create new account from Chart of Accounts.',b'Bitte neues Konto aus dem Kontenplan erstellen.'
+,b'Support Hour Distribution',b'St\xc3\xbctzzeitverteilung'
+b'DocType: Maintenance Visit',b'Maintenance Visit',b'Wartungsbesuch'
+b'DocType: Student',b'Leaving Certificate Number',b'Leaving Certificate Nummer'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58',"b'Appointment cancelled, Please review and cancel the invoice {0}'",b'der Termin wurde abgesagt. Bitte Rechnung {0} pr\xc3\xbcfen und abbrechen bzw. stornieren.'
+b'DocType: Sales Invoice Item',b'Available Batch Qty at Warehouse',b'Verf\xc3\xbcgbare Losgr\xc3\xb6\xc3\x9fe im Lager'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Update Print Format',b'Druckformat aktualisieren'
+b'DocType: Landed Cost Voucher',b'Landed Cost Help',b'Hilfe zum Einstandpreis'
+b'DocType: Purchase Invoice',b'Select Shipping Address',b'Lieferadresse ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/config/non_profit.py +28',b'Memebership Details',b'Mitgliedschaftsdetails'
+b'DocType: Leave Block List',b'Block Holidays on important days.',b'Urlaub an wichtigen Tagen sperren.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220',b'Please input all required Result Value(s)',b'Bitte geben Sie alle erforderlichen Ergebniswerte ein'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106',b'Accounts Receivable Summary',b'\xc3\x9cbersicht der Forderungen'
+b'DocType: Employee Loan',b'Monthly Repayment Amount',b'Monatlicher R\xc3\xbcckzahlungsbetrag'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9',b'Opening Invoices',b'Rechnungen \xc3\xb6ffnen'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +195',b'Please set User ID field in an Employee record to set Employee Role',"b'Bitte in einem Mitarbeiterdatensatz das Feld Nutzer-ID setzen, um die Rolle Mitarbeiter zuzuweisen'"
+b'DocType: UOM',b'UOM Name',b'Ma\xc3\x9feinheit-Name'
+b'DocType: GST HSN Code',b'HSN Code',b'HSN-Code'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39',b'Contribution Amount',b'Beitragsh\xc3\xb6he'
+b'DocType: Purchase Invoice',b'Shipping Address',b'Lieferadresse'
+b'DocType: Stock Reconciliation',b'This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.',"b'Dieses Werkzeug hilft Ihnen dabei, die Menge und die Bewertung von Bestand im System zu aktualisieren oder zu \xc3\xa4ndern. Es wird in der Regel verwendet, um die Systemwerte und den aktuellen Bestand Ihrer Lager zu synchronisieren.'"
+b'DocType: Delivery Note',b'In Words will be visible once you save the Delivery Note.',"b'""In Worten"" wird sichtbar, sobald Sie den Lieferschein speichern.'"
+b'DocType: Expense Claim',b'EXP',b'BA'
+b'DocType: Water Analysis',b'Container',b'Container'
+b'apps/erpnext/erpnext/education/utils.py +50',b'Student {0} - {1} appears Multiple times in row {2} & {3}',b'Student {0} - {1} erscheint mehrfach in Zeile {2} &amp; {3}'
+b'DocType: Project',b'Day to Send',b'Tag zum Senden'
+b'DocType: Healthcare Settings',b'Manage Sample Collection',b'Probenahme sammeln'
+b'DocType: Production Plan',b'Ignore Existing Ordered Quantity',b'Bestehende Bestellmenge ignorieren'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66',b'Please set the series to be used.',b'Bitte legen Sie die zu verwendende Serie fest.'
+b'DocType: Patient',b'Tobacco Past Use',b'Tabak Verwendung'
+b'DocType: Sales Invoice Item',b'Brand Name',b'Bezeichnung der Marke'
+b'DocType: Purchase Receipt',b'Transporter Details',b'Informationen zum Transporteur'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55',b'User {0} is already assigned to Physician {1}',b'Benutzer {0} ist bereits dem Arzt {1} zugeordnet'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2700',b'Default warehouse is required for selected item',b'Standard Lager wird f\xc3\xbcr das ausgew\xc3\xa4hlte Element erforderlich'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Box',b'Kiste'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038',b'Possible Supplier',b'M\xc3\xb6gliche Lieferant'
+b'DocType: Budget',b'Monthly Distribution',b'Monatsbezogene Verteilung'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68',b'Receiver List is empty. Please create Receiver List',b'Empf\xc3\xa4ngerliste ist leer. Bitte eine Empf\xc3\xa4ngerliste erstellen'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +31',b'Healthcare (beta)',b'Gesundheitswesen (Beta)'
+b'DocType: Production Plan Sales Order',b'Production Plan Sales Order',b'Produktionsplan f\xc3\xbcr Kundenauftrag'
+b'DocType: Sales Partner',b'Sales Partner Target',b'Vertriebspartner-Ziel'
+b'DocType: Loan Type',b'Maximum Loan Amount',b'Maximaler Darlehensbetrag'
+b'DocType: Pricing Rule',b'Pricing Rule',b'Preisregel'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Duplikat Rollennummer f\xc3\xbcr den Sch\xc3\xbcler {0}'
+b'DocType: Budget',b'Action if Annual Budget Exceeded',b'Erw\xc3\xbcnschte Aktion bei \xc3\xbcberschrittenem j\xc3\xa4hrlichem Budget'
+b'apps/erpnext/erpnext/config/learn.py +197',b'Material Request to Purchase Order',b'Von der Materialanfrage zum Lieferantenauftrag'
+b'DocType: Shopping Cart Settings',b'Payment Success URL',b'Payment Success URL'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81',b'Row # {0}: Returned Item {1} does not exists in {2} {3}',b'Zeile # {0}: Zur\xc3\xbcckgegebener Artikel {1} existiert nicht in {2} {3}'
+b'DocType: Purchase Receipt',b'PREC-',b'PREC-'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16',b'Bank Accounts',b'Bankkonten'
+,b'Bank Reconciliation Statement',b'Kontoauszug zum Kontenabgleich'
+b'DocType: Consultation',b'Medical Coding',b'Medizinische Kodierung'
+b'DocType: Healthcare Settings',b'Reminder Message',b'Erinnerungsmeldung'
+,b'Lead Name',b'Name des Leads'
+,b'POS',b'Verkaufsstelle'
+b'DocType: C-Form',b'III',b'III'
+b'apps/erpnext/erpnext/config/stock.py +314',b'Opening Stock Balance',b'Er\xc3\xb6ffnungsbest\xc3\xa4nde'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58',b'{0} must appear only once',b'{0} darf nur einmal vorkommen'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59',b'Leaves Allocated Successfully for {0}',b'Erfolgreich zugewiesene Abwesenheiten f\xc3\xbcr {0}'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42',b'No Items to pack',b'Keine Artikel zum Verpacken'
+b'DocType: Shipping Rule Condition',b'From Value',b'Von-Wert'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +606',b'Manufacturing Quantity is mandatory',b'Eingabe einer Fertigungsmenge ist erforderlich'
+b'DocType: Employee Loan',b'Repayment Method',b'R\xc3\xbcckzahlweg'
+b'DocType: Products Settings',"b'If checked, the Home page will be the default Item Group for the website'","b'Wenn diese Option aktiviert, wird die Startseite der Standardartikelgruppe f\xc3\xbcr die Website sein'"
+b'DocType: Quality Inspection Reading',b'Reading 4',b'Ablesewert\xc2\xa04'
+b'apps/erpnext/erpnext/config/hr.py +132',b'Claims for company expense.',b'Anspr\xc3\xbcche auf Kosten\xc3\xbcbernahme durch das Unternehmen'
+b'apps/erpnext/erpnext/utilities/activation.py +118',"b'Students are at the heart of the system, add all your students'","b'Die Sch\xc3\xbcler im Herzen des Systems sind, f\xc3\xbcgen Sie alle Ihre Sch\xc3\xbcler'"
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97',b'Row #{0}: Clearance date {1} cannot be before Cheque Date {2}',b'Row # {0}: R\xc3\xa4umungsdatum {1} kann nicht vor dem Scheck Datum sein {2}'
+b'DocType: Asset Maintenance Task',b'Certificate Required',b'Zertifikat erforderlich'
+b'DocType: Company',b'Default Holiday List',b'Standard-Urlaubsliste'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196',b'Row {0}: From Time and To Time of {1} is overlapping with {2}',b'Zeile {0}: Zeit\xc3\xbcberlappung in {1} mit {2}'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145',b'Stock Liabilities',b'Lager-Verbindlichkeiten'
+b'DocType: Purchase Invoice',b'Supplier Warehouse',b'Lieferantenlager'
+b'DocType: Opportunity',b'Contact Mobile No',b'Kontakt-Mobiltelefonnummer'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399',b'Select Company',b'Unternehmen ausw\xc3\xa4hlen'
+,b'Material Requests for which Supplier Quotations are not created',"b'Materialanfragen, f\xc3\xbcr die keine Lieferantenangebote erstellt werden'"
+b'DocType: Student Report Generation Tool',b'Print Section',b'Druckbereich'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34',"b""User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.""",b'Der Benutzer {0} hat kein Standard-POS-Profil. Aktivieren Sie f\xc3\xbcr diesen Benutzer die Standardeinstellung in der Zeile {1}.'
+b'DocType: Student Group',b'Set 0 for no limit',b'Stellen Sie 0 f\xc3\xbcr keine Grenze'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122',b'The day(s) on which you are applying for leave are holidays. You need not apply for leave.',"b'Der Tag/die Tage, f\xc3\xbcr den/die Sie Urlaub beantragen, sind Ferien. Deshalb m\xc3\xbcssen Sie keinen Urlaub beantragen.'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64',b'Row {idx}: {field} is required to create the Opening {invoice_type} Invoices',"b'Zeile {idx}: {field} wird ben\xc3\xb6tigt, um die Er\xc3\xb6ffnungsrechnung {invoice_type} zu erstellen'"
+b'DocType: Customer',b'Primary Address and Contact Detail',b'Prim\xc3\xa4re Adresse und Kontaktdetails'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20',b'Resend Payment Email',b'Zahlungsemail erneut senden'
+b'apps/erpnext/erpnext/templates/pages/projects.html +27',b'New task',b'Neuer Vorgang'
+b'DocType: Consultation',b'Appointment',b'Termin'
+b'apps/erpnext/erpnext/utilities/activation.py +74',b'Make Quotation',b'Angebot erstellen'
+b'apps/erpnext/erpnext/config/education.py +230',b'Other Reports',b'Weitere Berichte'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +39',b'Please select at least one domain.',b'Bitte w\xc3\xa4hlen Sie mindestens eine Domain aus.'
+b'DocType: Dependent Task',b'Dependent Task',b'Abh\xc3\xa4ngiger Vorgang'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +444',b'Conversion factor for default Unit of Measure must be 1 in row {0}',b'Umrechnungsfaktor f\xc3\xbcr Standardma\xc3\x9feinheit muss in Zeile {0} 1 sein'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188',b'Leave of type {0} cannot be longer than {1}',b'Abwesenheit vom Typ {0} kann nicht l\xc3\xa4nger sein als {1}'
+b'DocType: Manufacturing Settings',b'Try planning operations for X days in advance.',b'Arbeitsg\xc3\xa4nge f\xc3\xbcr X Tage im Voraus planen.'
+b'DocType: HR Settings',b'Stop Birthday Reminders',b'Geburtstagserinnerungen ausschalten'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235',b'Please set Default Payroll Payable Account in Company {0}',b'Bitte setzen Sie Standard-Abrechnungskreditorenkonto in Gesellschaft {0}'
+b'DocType: SMS Center',b'Receiver List',b'Empf\xc3\xa4ngerliste'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1094',b'Search Item',b'Suche Artikel'
+b'DocType: Payment Schedule',b'Payment Amount',b'Zahlungsbetrag'
+b'DocType: Patient Appointment',b'Referring Physician',b'Auf den Physiker bezogen'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46',b'Consumed Amount',b'Verbrauchte Menge'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100',b'Net Change in Cash',b'Nettover\xc3\xa4nderung der Barmittel'
+b'DocType: Assessment Plan',b'Grading Scale',b'Bewertungsskala'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +438',b'Unit of Measure {0} has been entered more than once in Conversion Factor Table',b'Ma\xc3\x9feinheit {0} wurde mehr als einmal in die Umrechnungsfaktor-Tabelle eingetragen'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +639',b'Already completed',b'Schon erledigt'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33',b'Stock In Hand',b'Stock In Hand'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64',b'Import Successful!',b'Importvorgang erfolgreich!'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29',b'Payment Request already exists {0}',b'Zahlungsanordnung bereits vorhanden ist {0}'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Issued Items',b'Aufwendungen f\xc3\xbcr in Umlauf gebrachte Artikel'
+b'DocType: Physician',b'Hospital',b'Krankenhaus'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385',b'Quantity must not be more than {0}',b'Menge darf nicht mehr als {0} sein'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117',b'Previous Financial Year is not closed',b'Zur\xc3\xbcck Gesch\xc3\xa4ftsjahr nicht geschlossen'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46',b'Age (Days)',b'Alter (Tage)'
+b'DocType: Quotation Item',b'Quotation Item',b'Angebotsposition'
+b'DocType: Customer',b'Customer POS Id',b'Kunden-POS-ID'
+b'DocType: Account',b'Account Name',b'Kontenname'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40',b'From Date cannot be greater than To Date',b'Von-Datum kann sp\xc3\xa4ter liegen als Bis-Datum'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198',b'Serial No {0} quantity {1} cannot be a fraction',b'Seriennummer {0} mit Menge {1} kann nicht eine Teilmenge sein'
+b'apps/erpnext/erpnext/config/buying.py +43',b'Supplier Type master.',b'Stammdaten zum Lieferantentyp'
+b'DocType: Purchase Order Item',b'Supplier Part Number',b'Lieferanten-Artikelnummer'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108',b'Conversion rate cannot be 0 or 1',b'Umrechnungskurs kann nicht 0 oder 1 sein'
+b'DocType: Share Balance',b'To No',b'Zu Nein'
+b'DocType: Subscription',b'Reference Document',b'Referenzdokument'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229',b'{0} {1} is cancelled or stopped',b'{0} {1} wird abgebrochen oder  beendet'
+b'DocType: Accounts Settings',b'Credit Controller',b'Kredit-Controller'
+b'DocType: Grant Application',b'Applicant Type',b'Bewerbertyp'
+b'DocType: Purchase Invoice',b'03-Deficiency in services',b'03-Mangel an Dienstleistungen'
+b'DocType: Delivery Note',b'Vehicle Dispatch Date',b'Datum des Versands mit dem Fahrzeug'
+b'DocType: Healthcare Settings',b'Default Medical Code Standard',b'Default Medical Code Standard'
+b'DocType: Purchase Invoice Item',b'HSN/SAC',b'HSN / SAC'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237',b'Purchase Receipt {0} is not submitted',b'Kaufbeleg {0} wurde nicht \xc3\xbcbertragen'
+b'DocType: Company',b'Default Payable Account',b'Standard-Verbindlichkeitenkonto'
+b'apps/erpnext/erpnext/config/website.py +17',"b'Settings for online shopping cart such as shipping rules, price list etc.'","b'Einstellungen zum Warenkorb, z.B. Versandregeln, Preislisten usw.'"
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +113',b'{0}% Billed',b'{0}% berechnet'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18',b'Reserved Qty',b'Reservierte Menge'
+b'DocType: Party Account',b'Party Account',b'Gruppenkonto'
+b'apps/erpnext/erpnext/config/setup.py +122',b'Human Resources',b'Personalwesen'
+b'DocType: Lead',b'Upper Income',b'Gehobenes Einkommen'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17',b'Reject',b'Ablehnen'
+b'DocType: Journal Entry Account',b'Debit in Company Currency',b'Soll in Unternehmensw\xc3\xa4hrung'
+b'DocType: BOM Item',b'BOM Item',b'St\xc3\xbccklisten-Artikel'
+b'DocType: Appraisal',b'For Employee',b'F\xc3\xbcr Mitarbeiter'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49',b'Make Disbursement Entry',b'Machen Disbursement Eintrag'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138',b'Row {0}: Advance against Supplier must be debit',b'Row {0}: Voraus gegen Lieferant muss belasten werden'
+b'DocType: Company',b'Default Values',b'Standardwerte'
+b'DocType: Membership',b'INR',b'INR'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60',b'{frequency} Digest',b'{Frequenz} \xc3\x9cbersicht'
+b'DocType: Expense Claim',b'Total Amount Reimbursed',b'Gesamterstattungsbetrag'
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5',b'This is based on logs against this Vehicle. See timeline below for details',b'Dies basiert auf Protokollen gegen dieses Fahrzeug. Siehe Zeitleiste unten f\xc3\xbcr Details'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90',b'Against Supplier Invoice {0} dated {1}',b'Zu Eingangsrechnung {0} vom {1}'
+b'DocType: Customer',b'Default Price List',b'Standardpreisliste'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +322',b'Asset Movement record {0} created',b'Asset-Bewegung Datensatz {0} erstellt'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51',b'You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings',b'Sie k\xc3\xb6nnen das Gesch\xc3\xa4ftsjahr {0} nicht l\xc3\xb6schen. Das Gesch\xc3\xa4ftsjahr {0} ist als Standard in den globalen Einstellungen festgelegt'
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20',b'A customer with the same name already exists',b'Ein Kunde mit demselben Namen existiert bereits'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185',b'This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?',b'Dies wird Gehaltsabrechnungen \xc3\xbcbermitteln und eine periodengerechte Journalbuchung erstellen. Willst du fortfahren?'
+b'DocType: Purchase Invoice',b'Total Net Weight',b'Gesamtnettogewicht'
+b'DocType: Purchase Invoice',b'Eligibility For ITC',b'Berechtigung f\xc3\xbcr ITC'
+b'DocType: Journal Entry',b'Entry Type',b'Buchungstyp'
+,b'Customer Credit Balance',b'Kunden-Kreditlinien'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28',b'Net Change in Accounts Payable',b'Nettover\xc3\xa4nderung der Verbindlichkeiten'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'EcritureLet',b'EcritureLet'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +209',b'Credit limit has been crossed for customer {0} ({1}/{2})',b'Das Kreditlimit wurde f\xc3\xbcr den Kunden {0} ({1} / {2}) \xc3\xbcberschritten.'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42',"b""Customer required for 'Customerwise Discount'""","b'Kunde erforderlich f\xc3\xbcr ""Kundenbezogener Rabatt""'"
+b'apps/erpnext/erpnext/config/accounts.py +140',b'Update bank payment dates with journals.',b'Zahlungstermine anhand der Journale aktualisieren'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21',b'Pricing',b'Preisgestaltung'
+b'DocType: Quotation',b'Term Details',b'Details der Gesch\xc3\xa4ftsbedingungen'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30',b'Cannot enroll more than {0} students for this student group.',b'Kann nicht mehr als {0} Studenten f\xc3\xbcr diese Studentengruppe einschreiben.'
+b'apps/erpnext/erpnext/templates/print_formats/includes/total.html +4',b'Total (Without Tax)',b'Summe (ohne Steuern)'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'Anzahl Leads'
+b'apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15',b'{0} must be greater than 0',b'{0} muss gr\xc3\xb6\xc3\x9fer 0 sein'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30',b'Stock Available',b'Lager verf\xc3\xbcgbar'
+b'DocType: Manufacturing Settings',b'Capacity Planning For (Days)',b'Kapazit\xc3\xa4tsplanung f\xc3\xbcr (Tage)'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10',b'Procurement',b'Beschaffung'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66',b'None of the items have any change in quantity or value.',b'Keiner der Artikel hat irgendeine \xc3\x84nderung bei Mengen oder Kosten.'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Pflichtfeld - Programm'
+b'DocType: Special Test Template',b'Result Component',b'Ergebniskomponente'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46',b'Warranty Claim',b'Garantieanspruch'
+,b'Lead Details',b'Einzelheiten zum Lead'
+b'DocType: Volunteer',b'Availability and Skills',b'Verf\xc3\xbcgbarkeit und F\xc3\xa4higkeiten'
+b'DocType: Salary Slip',b'Loan repayment',b'Darlehensr\xc3\xbcckzahlung'
+b'DocType: Purchase Invoice',"b""End date of current invoice's period""",b'Schlu\xc3\x9fdatum der laufenden Eingangsrechnungsperiode'
+b'DocType: Pricing Rule',b'Applicable For',b'Anwenden f\xc3\xbcr'
+b'DocType: Lab Test',b'Technician Name',b'Techniker Name'
+b'DocType: Accounts Settings',b'Unlink Payment on Cancellation of Invoice',b'Unlink Zahlung auf Annullierung der Rechnung'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16',b'Current Odometer reading entered should be greater than initial Vehicle Odometer {0}',b'Der eingegebene aktuelle Kilometerstand sollte gr\xc3\xb6\xc3\x9fer sein als der Anfangskilometerstand {0}'
+b'DocType: Restaurant Reservation',b'No Show',b'Keine Show'
+b'DocType: Shipping Rule Country',b'Shipping Rule Country',b'Versandregel f\xc3\xbcr Land'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10',b'Leave and Attendance',b'Urlaub und Anwesenheit'
+b'DocType: Maintenance Visit',b'Partially Completed',b'Teilweise abgeschlossen'
+b'apps/erpnext/erpnext/healthcare/setup.py +257',b'Moderate Sensitivity',b'Moderate Empfindlichkeit'
+b'DocType: Leave Type',b'Include holidays within leaves as leaves',b'Urlaube innerhalb von Abwesenheiten als Abwesenheiten mit einbeziehen'
+b'DocType: Sales Invoice',b'Packed Items',b'Verpackte Artikel'
+b'apps/erpnext/erpnext/config/support.py +27',b'Warranty Claim against Serial No.',b'Garantieantrag zu Serien-Nr.'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197',"b""'Total'""","b""'Gesamtbetrag'"""
+b'DocType: Shopping Cart Settings',b'Enable Shopping Cart',b'Warenkorb aktivieren'
+b'DocType: Employee',b'Permanent Address',b'Feste Adresse'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260',b'Advance paid against {0} {1} cannot be greater \\\n\t\t\t\t\t\tthan Grand Total {2}',b'Anzahlung zu {0} {1} kann nicht gr\xc3\xb6\xc3\x9fer sein als als Gesamtsumme {2}'
+b'DocType: Consultation',b'Medication',b'Medikation'
+b'DocType: Production Plan',b'Include Non Stock Items',b'Nicht verf\xc3\xbcgbare Artikel einschlie\xc3\x9fen'
+b'DocType: Project Update',b'Challenging/Slow',b'Schwierig / Langsam'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147',b'Please select item code',b'Bitte Artikelnummer ausw\xc3\xa4hlen'
+b'DocType: Student Sibling',b'Studying in Same Institute',b'Studieren in Same-Institut'
+b'DocType: Territory',b'Territory Manager',b'Gebietsleiter'
+b'DocType: Packed Item',b'To Warehouse (Optional)',b'Eingangslager (Optional)'
+b'DocType: GST Settings',b'GST Accounts',b'GST-Konten'
+b'DocType: Payment Entry',b'Paid Amount (Company Currency)',b'Gezahlter Betrag (Firmenw\xc3\xa4hrung)'
+b'DocType: Purchase Invoice',b'Additional Discount',b'Zus\xc3\xa4tzlicher Rabatt'
+b'DocType: Selling Settings',b'Selling Settings',b'Vertriebseinstellungen'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83',b'Confirm Action',b'Aktion best\xc3\xa4tigen'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39',b'Online Auctions',b'Online-Auktionen'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100',b'Please specify either Quantity or Valuation Rate or both',b'Bitte entweder die Menge oder den Wertansatz oder beides eingeben'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18',b'Fulfillment',b'Erf\xc3\xbcllung'
+b'apps/erpnext/erpnext/templates/generators/item.html +82',b'View in Cart',b'Ansicht Warenkorb'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103',b'Marketing Expenses',b'Marketingkosten'
+,b'Item Shortage Report',b'Artikelengpass-Bericht'
+b'apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15',"b""Can't create standard criteria. Please rename the criteria""",b'Kann keine Standardkriterien erstellen. Bitte benennen Sie die Kriterien um'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +311',"b'Weight is mentioned,\\nPlease mention ""Weight UOM"" too'","b'Gewicht ist angegeben, bitte auch ""Gewichts-Ma\xc3\x9feinheit"" angeben'"
+b'DocType: Stock Entry Detail',b'Material Request used to make this Stock Entry',b'Materialanfrage wurde f\xc3\xbcr die Erstellung dieser Lagerbuchung verwendet'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +68',b'Next Depreciation Date is mandatory for new asset',b'N\xc3\xa4chstes Abschreibedatum ist obligatorisch f\xc3\xbcr neue Anlagen'
+b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Separate Kursbasierte Gruppe f\xc3\xbcr jede Charge'
+b'apps/erpnext/erpnext/config/support.py +32',b'Single unit of an Item.',b'Einzelnes Element eines Artikels'
+b'DocType: Fee Category',b'Fee Category',b'Preis Kategorie'
+b'DocType: Agriculture Task',b'Next Business Day',b'N\xc3\xa4chster Arbeitstag'
+b'DocType: Drug Prescription',b'Dosage by time interval',b'Dosierung nach Zeitintervall'
+b'DocType: Cash Flow Mapper',b'Section Header',b'Abschnitts\xc3\xbcberschrift'
+,b'Student Fee Collection',b'Studiengeb\xc3\xbchren Sammlung'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24',b'Appointment Duration (mins)',b'Termindauer (min.)'
+b'DocType: Accounts Settings',b'Make Accounting Entry For Every Stock Movement',b'Eine Buchung f\xc3\xbcr jede Lagerbewegung erstellen'
+b'DocType: Leave Allocation',b'Total Leaves Allocated',b'Insgesamt zugewiesene Urlaubstage'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163',b'Warehouse required at Row No {0}',b'Angabe des Lagers ist in Zeile {0} erforderlich'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +145',b'Please enter valid Financial Year Start and End Dates',b'Bitte geben Sie f\xc3\xbcr das Gesch\xc3\xa4ftsjahr einen g\xc3\xbcltigen Start- und Endtermin an.'
+b'DocType: Employee',b'Date Of Retirement',b'Zeitpunkt der Pensionierung'
+b'DocType: Upload Attendance',b'Get Template',b'Vorlage aufrufen'
+b'DocType: Material Request',b'Transferred',b'\xc3\x9cbergeben'
+b'DocType: Vehicle',b'Doors',b'T\xc3\xbcren'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117',b'ERPNext Setup Complete!',b'ERPNext Setup abgeschlossen!'
+b'DocType: Healthcare Settings',b'Collect Fee for Patient Registration',b'Sammeln Sie die Geb\xc3\xbchr f\xc3\xbcr die Patientenregistrierung'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +678',b'Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item',b'Attribute nach Bestandsgesch\xc3\xa4ft k\xc3\xb6nnen nicht ge\xc3\xa4ndert werden. Erstelle einen neuen Artikel und \xc3\xbcbertrage den Bestand auf den neuen Artikel'
+b'DocType: Course Assessment Criteria',b'Weightage',b'Gewichtung'
+b'DocType: Purchase Invoice',b'Tax Breakup',b'Steuererhebung'
+b'DocType: Packing Slip',b'PS-',b'PS-'
+b'DocType: Member',b'Non Profit Member',b'Non-Profit-Mitglied'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67',"b""{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.""","b'{0} {1}: Kostenstelle ist erforderlich f\xc3\xbcr ""Gewinn- und Verlust"" Konto {2}. Bitte erstellen Sie eine Standard-Kostenstelle f\xc3\xbcr das Unternehmen.'"
+b'DocType: Payment Schedule',b'Payment Term',b'Zahlungsbedingung'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +160',b'A Customer Group exists with same name please change the Customer name or rename the Customer Group',b'Eine Kundengruppe mit dem gleichen Namen existiert bereits. Bitte den Kundennamen \xc3\xa4ndern oder die Kundengruppe umbenennen'
+b'DocType: Land Unit',b'Area',b'Bereich'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +37',b'New Contact',b'Neuer Kontakt'
+b'DocType: Territory',b'Parent Territory',b'\xc3\x9cbergeordnete Region'
+b'DocType: Purchase Invoice',b'Place of Supply',b'Ort der Versorgung'
+b'DocType: Quality Inspection Reading',b'Reading 2',b'Ablesewert\xc2\xa02'
+b'DocType: Stock Entry',b'Material Receipt',b'Materialannahme'
+b'DocType: Homepage',b'Products',b'Produkte'
+b'DocType: Announcement',b'Instructor',b'Lehrer'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61',b'Select Item (optional)',b'Artikel ausw\xc3\xa4hlen (optional)'
+b'DocType: Fee Schedule Student Group',b'Fee Schedule Student Group',b'Fee Zeitplan Student Group'
+b'DocType: Student',b'AB+',b'AB+'
+b'DocType: Item',"b'If this item has variants, then it cannot be selected in sales orders etc.'","b'Wenn dieser Artikel Varianten hat, dann kann er bei den Kundenauftr\xc3\xa4gen, etc. nicht ausgew\xc3\xa4hlt werden'"
+b'DocType: Lead',b'Next Contact By',b'N\xc3\xa4chster Kontakt durch'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325',b'Quantity required for Item {0} in row {1}',b'F\xc3\xbcr Artikel {0} in Zeile {1} ben\xc3\xb6tigte Menge'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45',b'Warehouse {0} can not be deleted as quantity exists for Item {1}',"b'Lager {0} kann nicht gel\xc3\xb6scht werden, da noch ein Bestand f\xc3\xbcr Artikel {1} existiert'"
+b'DocType: Quotation',b'Order Type',b'Bestellart'
+,b'Item-wise Sales Register',b'Artikelbezogene \xc3\x9cbersicht der Verk\xc3\xa4ufe'
+b'DocType: Asset',b'Gross Purchase Amount',b'Bruttokaufbetrag'
+b'apps/erpnext/erpnext/utilities/user_progress.py +39',b'Opening Balances',b'Er\xc3\xb6ffnungssalden'
+b'DocType: Asset',b'Depreciation Method',b'Abschreibungsmethode'
+b'DocType: Purchase Taxes and Charges',b'Is this Tax included in Basic Rate?',b'Ist diese Steuer im Basispreis enthalten?'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Target',b'Summe Vorgabe'
+b'DocType: Soil Texture',b'Sand Composition (%)',b'Sandzusammensetzung (%)'
+b'DocType: Job Applicant',b'Applicant for a Job',b'Bewerber f\xc3\xbcr einen Job'
+b'DocType: Production Plan Material Request',b'Production Plan Material Request',b'Produktionsplan-Material anfordern'
+b'DocType: Stock Reconciliation',b'Reconciliation JSON',b'Abgleich\xc2\xa0JSON (JavaScript Object Notation)'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.html +3',b'Too many columns. Export the report and print it using a spreadsheet application.',b'Zu viele Spalten. Exportieren Sie den Bericht und drucken Sie ihn mit einem Tabellenkalkulationsprogramm aus.'
+b'DocType: Purchase Invoice Item',b'Batch No',b'Chargennummer'
+b'DocType: Selling Settings',"b""Allow multiple Sales Orders against a Customer's Purchase Order""",b'Zusammenfassen mehrerer Kundenauftr\xc3\xa4ge zu einer Kundenbestellung erlauben'
+b'DocType: Student Group Instructor',b'Student Group Instructor',b'Student Group Instructor'
+b'DocType: Grant Application',b'Assessment  Mark (Out of 10)',b'Bewertungsnote (von 10)'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61',b'Guardian2 Mobile No',b'Guardian2 Mobil Nein'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +218',b'Main',b'Haupt'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +72',b'Variant',b'Variante'
+b'DocType: Naming Series',b'Set prefix for numbering series on your transactions',b'Pr\xc3\xa4fix f\xc3\xbcr die Seriennummerierung Ihrer Transaktionen festlegen'
+b'DocType: Employee Attendance Tool',b'Employees HTML',b'Mitarbeiter HTML'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +458',b'Default BOM ({0}) must be active for this item or its template',b'Standardst\xc3\xbcckliste ({0}) muss f\xc3\xbcr diesen Artikel oder dessen Vorlage aktiv sein'
+b'DocType: Employee',b'Leave Encashed?',b'Urlaub eingel\xc3\xb6st?'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32',b'Opportunity From field is mandatory',"b'Feld ""Chance von"" ist zwingend erforderlich'"
+b'DocType: Email Digest',b'Annual Expenses',b'J\xc3\xa4hrliche Kosten'
+b'DocType: Item',b'Variants',b'Varianten'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1148',b'Make Purchase Order',b'Lieferantenauftrag anlegen'
+b'DocType: SMS Center',b'Send To',b'Senden an'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133',b'There is not enough leave balance for Leave Type {0}',b'Es gibt nicht gen\xc3\xbcgend verf\xc3\xbcgbaren Urlaub f\xc3\xbcr Urlaubstyp {0}'
+b'DocType: Payment Reconciliation Payment',b'Allocated amount',b'Zugewiesene Menge'
+b'DocType: Sales Team',b'Contribution to Net Total',b'Beitrag zum Gesamtnetto'
+b'DocType: Sales Invoice Item',"b""Customer's Item Code""",b'Kunden-Artikel-Nr.'
+b'DocType: Stock Reconciliation',b'Stock Reconciliation',b'Bestandsabgleich'
+b'DocType: Territory',b'Territory Name',b'Name der Region (Gebiet)'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204',b'Work-in-Progress Warehouse is required before Submit',b'Fertigungslager wird vor dem \xc3\x9cbertragen ben\xc3\xb6tigt'
+b'apps/erpnext/erpnext/config/hr.py +40',b'Applicant for a Job.',b'Bewerber f\xc3\xbcr einen Job'
+b'DocType: Purchase Order Item',b'Warehouse and Reference',b'Lager und Referenz'
+b'DocType: Supplier',b'Statutory info and other general information about your Supplier',b'Rechtlich notwendige und andere allgemeine Informationen \xc3\xbcber Ihren Lieferanten'
+b'DocType: Item',b'Serial Nos and Batches',b'Seriennummern und Chargen'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'Sch\xc3\xbclergruppenst\xc3\xa4rke'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261',b'Against Journal Entry {0} does not have any unmatched {1} entry',"b'""Zu Buchungssatz"" {0} hat nur abgeglichene {1} Buchungen'"
+b'apps/erpnext/erpnext/config/hr.py +142',b'Appraisals',b'Beurteilungen'
+b'apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8',b'Training Events',b'Schulungsveranstaltungen'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205',b'Duplicate Serial No entered for Item {0}',b'Doppelte Seriennummer f\xc3\xbcr Posten {0} eingegeben'
+b'apps/erpnext/erpnext/config/selling.py +179',b'Track Leads by Lead Source.',b'Verfolgen Sie Leads nach Lead Source.'
+b'DocType: Shipping Rule Condition',b'A condition for a Shipping Rule',b'Bedingung f\xc3\xbcr eine Versandregel'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +167',b'Please enter ',b'Bitte eingeben'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43',b'Maintenance Log',b'Wartungsprotokoll'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236',b'Please set filter based on Item or Warehouse',b'Bitte setzen Sie Filter basierend auf Artikel oder Lager'
+b'DocType: Packing Slip',b'The net weight of this package. (calculated automatically as sum of net weight of items)',b'Das Nettogewicht dieses Pakets. (Automatisch als Summe der einzelnen Nettogewichte berechnet)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +802',b'Discount amount cannot be greater than 100%',b'Rabattbetrag kann nicht gr\xc3\xb6\xc3\x9fer als 100% sein'
+b'DocType: Sales Order',b'To Deliver and Bill',b'Auszuliefern und Abzurechnen'
+b'DocType: Student Group',b'Instructors',b'Lehrer'
+b'DocType: GL Entry',b'Credit Amount in Account Currency',b'(Gut)Haben-Betrag in Kontow\xc3\xa4hrung'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +603',b'BOM {0} must be submitted',b'St\xc3\xbcckliste {0} muss \xc3\xbcbertragen werden'
+b'apps/erpnext/erpnext/config/accounts.py +460',b'Share Management',b'Aktienverwaltung'
+b'DocType: Authorization Control',b'Authorization Control',b'Berechtigungskontrolle'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +317',b'Row #{0}: Rejected Warehouse is mandatory against rejected Item {1}',b'Row # {0}: Abgelehnt Warehouse ist obligatorisch gegen zur\xc3\xbcckgewiesen Artikel {1}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Payment',b'Bezahlung'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +92',"b'Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.'",b'Lager {0} ist nicht mit einem Konto verkn\xc3\xbcpft. Bitte w\xc3\xa4hlen Sie ein Konto in den Einstellungen f\xc3\xbcr das Lager oder legen Sie das Standard Lagerkonto in den Einstellungen f\xc3\xbcr  {1} fest.'
+b'apps/erpnext/erpnext/utilities/activation.py +81',b'Manage your orders',b'Verwalten Sie Ihre Auftr\xc3\xa4ge'
+b'DocType: Work Order Operation',b'Actual Time and Cost',b'Tats\xc3\xa4chliche Laufzeit und Kosten'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56',b'Material Request of maximum {0} can be made for Item {1} against Sales Order {2}',b'Materialanfrage von maximal {0} kann f\xc3\xbcr Artikel {1} zum Kundenauftrag {2} gemacht werden'
+b'DocType: Crop',b'Crop Spacing',b'Fruchtabstand'
+b'DocType: Course',b'Course Abbreviation',b'Kurs Abk\xc3\xbcrzung'
+b'DocType: Student Leave Application',b'Student Leave Application',b'Student Urlaubsantrag'
+b'DocType: Item',b'Will also apply for variants',b'Gilt auch f\xc3\xbcr Varianten'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +217',"b'Asset cannot be cancelled, as it is already {0}'","b'Verm\xc3\xb6gen kann nicht r\xc3\xbcckg\xc3\xa4ngig gemacht werden, da es ohnehin schon {0} ist'"
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29',b'Employee {0} on Half day on {1}',b'Mitarbeiter {0} am {1} nur halbtags anwesend'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42',b'Total working hours should not be greater than max working hours {0}',b'Insgesamt Arbeitszeit sollte nicht gr\xc3\xb6\xc3\x9fer sein als die maximale Arbeitszeit {0}'
+b'apps/erpnext/erpnext/templates/pages/task_info.html +90',b'On',b'Am'
+b'apps/erpnext/erpnext/config/selling.py +62',b'Bundle items at time of sale.',b'Artikel zum Zeitpunkt des Verkaufs b\xc3\xbcndeln'
+b'DocType: Material Request Plan Item',b'Actual Qty',b'Tats\xc3\xa4chliche Anzahl'
+b'DocType: Sales Invoice Item',b'References',b'Referenzen'
+b'DocType: Quality Inspection Reading',b'Reading 10',b'Ablesewert\xc2\xa010'
+b'DocType: Item',b'Barcodes',b'Barcodes'
+b'DocType: Hub Category',b'Hub Node',b'Hub-Knoten'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78',b'You have entered duplicate items. Please rectify and try again.',b'Sie haben ein Duplikat eines Artikels eingetragen. Bitte korrigieren und erneut versuchen.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129',b'Associate',b'Mitarbeiter/-in'
+b'DocType: Asset Movement',b'Asset Movement',b'Asset-Bewegung'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508',b'Work Order {0} must be submitted',b'Arbeitsauftrag {0} muss eingereicht werden'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2214',b'New Cart',b'neue Produkte Warenkorb'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44',b'Item {0} is not a serialized Item',b'Artikel {0} ist kein Fortsetzungsartikel'
+b'DocType: SMS Center',b'Create Receiver List',b'Empf\xc3\xa4ngerliste erstellen'
+b'DocType: Vehicle',b'Wheels',b'R\xc3\xa4der'
+b'DocType: Packing Slip',b'To Package No.',b'Bis Paket Nr.'
+b'DocType: Patient Relation',b'Family',b'Familie'
+b'DocType: Production Plan',b'Material Requests',b'Materialw\xc3\xbcnsche'
+b'DocType: Warranty Claim',b'Issue Date',b'Ausstellungsdatum'
+b'DocType: Activity Cost',b'Activity Cost',b'Aktivit\xc3\xa4tskosten'
+b'DocType: Sales Invoice Timesheet',b'Timesheet Detail',b'Timesheet-Detail'
+b'DocType: Purchase Receipt Item Supplied',b'Consumed Qty',b'Verbrauchte Anzahl'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52',b'Telecommunications',b'Telekommunikation'
+b'apps/erpnext/erpnext/accounts/party.py +263',"b""Billing currency must be equal to either default company's currency or party account currency""",b'Die Abrechnungsw\xc3\xa4hrung muss entweder der W\xc3\xa4hrung der Standardfirma oder der W\xc3\xa4hrung des Partnerkontos entsprechen'
+b'DocType: Packing Slip',b'Indicates that the package is a part of this delivery (Only Draft)',"b'Zeigt an, dass das Paket ein Teil dieser Lieferung ist (nur Entwurf)'"
+b'DocType: Soil Texture',b'Loam',b'Lehm'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +705',b'Row {0}: Due Date cannot be before posting date',b'Zeile {0}: F\xc3\xa4lligkeitsdatum darf nicht vor dem Buchungsdatum liegen'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36',b'Make Payment Entry',b'Zahlungsbuchung erstellen'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129',b'Quantity for Item {0} must be less than {1}',b'Menge f\xc3\xbcr Artikel {0} muss kleiner sein als {1}'
+,b'Sales Invoice Trends',b'Ausgangsrechnung-Trendanalyse'
+b'DocType: Leave Application',b'Apply / Approve Leaves',b'Urlaub eintragen/genehmigen'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'For',b'F\xc3\xbcr'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167',"b""Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'""","b'Kann sich nur auf eine Zeile beziehen, wenn die Berechnungsart der Kosten entweder ""auf vorherige Zeilensumme"" oder ""auf vorherigen Zeilenbetrag"" ist'"
+b'DocType: Sales Order Item',b'Delivery Warehouse',b'Auslieferungslager'
+b'apps/erpnext/erpnext/config/accounts.py +241',b'Tree of financial Cost Centers.',b'Baum der finanziellen Kostenstellen.'
+b'DocType: Serial No',b'Delivery Document No',b'Lieferdokumentennummer'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191',"b""Please set 'Gain/Loss Account on Asset Disposal' in Company {0}""",b'Bitte setzen Sie &quot;Gewinn / Verlustrechnung auf die Ver\xc3\xa4u\xc3\x9ferung von Verm\xc3\xb6genswerten&quot; in Gesellschaft {0}'
+b'DocType: Landed Cost Voucher',b'Get Items From Purchase Receipts',b'Artikel vom Kaufbeleg \xc3\xbcbernehmen'
+b'DocType: Serial No',b'Creation Date',b'Erstelldatum'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33',b'Item {0} appears multiple times in Price List {1}',b'Artikel {0}ist mehrfach in Preisliste {1} aufgef\xc3\xbchrt'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41',"b'Selling must be checked, if Applicable For is selected as {0}'","b'Vertrieb muss aktiviert werden, wenn ""Anwenden auf"" ausgew\xc3\xa4hlt ist bei {0}'"
+b'DocType: Production Plan Material Request',b'Material Request Date',b'Material Auftragsdatum'
+b'DocType: Purchase Order Item',b'Supplier Quotation Item',b'Lieferantenangebotsposition'
+b'DocType: Student',b'Student Mobile Number',b'Student Mobile Number'
+b'DocType: Item',b'Has Variants',b'Hat Varianten'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +488',"b'Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings'","b'F\xc3\xbcr Artikel {0} in Zeile {1} kann mehr als {2} nicht \xc3\xbcberbucht werden. Um \xc3\x9cberfakturierung zu erm\xc3\xb6glichen, legen Sie bitte in Stock Settings fest'"
+b'apps/erpnext/erpnext/templates/emails/training_event.html +11',b'Update Response',b'Update-Antwort'
+b'apps/erpnext/erpnext/public/js/utils.js +232',b'You have already selected items from {0} {1}',b'Sie haben bereits Elemente aus {0} {1} gew\xc3\xa4hlt'
+b'DocType: Monthly Distribution',b'Name of the Monthly Distribution',b'Bezeichnung der monatsweisen Verteilung'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Batch-ID ist obligatorisch'
+b'DocType: Sales Person',b'Parent Sales Person',b'\xc3\x9cbergeordneter Vertriebsmitarbeiter'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100',b'The seller and the buyer cannot be the same',b'Der Verk\xc3\xa4ufer und der K\xc3\xa4ufer k\xc3\xb6nnen nicht identisch sein'
+b'DocType: Project',b'Collect Progress',b'Sammle Fortschritte'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24',b'Select the program first',b'W\xc3\xa4hlen Sie zuerst das Programm aus'
+b'DocType: Patient Appointment',b'Patient Age',b'Patient Alter'
+b'apps/erpnext/erpnext/config/learn.py +253',b'Managing Projects',b'Projekte verwalten'
+b'DocType: Supplier',b'Supplier of Goods or Services.',b'Lieferant von Waren oder Dienstleistungen.'
+b'DocType: Budget',b'Fiscal Year',b'Gesch\xc3\xa4ftsjahr'
+b'DocType: Asset Maintenance Log',b'Planned',b'Geplant'
+b'DocType: Healthcare Settings',b'Default receivable accounts to be used if not set in Patient to book Consultation charges.',"b'Default-Forderungskonten, die verwendet werden sollen, wenn sie nicht in Patient eingestellt sind, um Konsultationsgeb\xc3\xbchren zu buchen.'"
+b'DocType: Vehicle Log',b'Fuel Price',b'Kraftstoff-Preis'
+b'DocType: Budget',b'Budget',b'Budget'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65',b'Set Open',b'Set offen'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +258',b'Fixed Asset Item must be a non-stock item.',b'Posten des Anlageverm\xc3\xb6gens muss ein Nichtlagerposition sein.'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50',"b""Budget cannot be assigned against {0}, as it's not an Income or Expense account""","b'Budget kann {0} nicht zugewiesen werden, da es kein Ertrags- oder Aufwandskonto ist'"
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51',b'Achieved',b'Erreicht'
+b'DocType: Student Admission',b'Application Form Route',b'Antragsformular Strecke'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66',b'Territory / Customer',b'Region / Kunde'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44',b'Leave Type {0} cannot be allocated since it is leave without pay',"b'Urlaubstyp {0} kann nicht zugeordnet werden, da unbezahlter Urlaub.'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167',b'Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2}',b'Zeile {0}: Zugeteilte Menge {1} muss kleiner als oder gleich dem ausstehenden Betrag in Rechnung {2} sein'
+b'DocType: Sales Invoice',b'In Words will be visible once you save the Sales Invoice.',"b'""In Worten"" wird sichtbar, sobald Sie die Ausgangsrechnung speichern.'"
+b'DocType: Lead',b'Follow Up',b'Nachverfolgen'
+b'DocType: Item',b'Is Sales Item',b'Ist Verkaufsartikel'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21',b'Item Group Tree',b'Artikelgruppenbaumstruktur'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69',b'Item {0} is not setup for Serial Nos. Check Item master',b'Artikel {0} ist nicht f\xc3\xbcr Seriennummern eingerichtet. Artikelstamm pr\xc3\xbcfen'
+b'DocType: Maintenance Visit',b'Maintenance Time',b'Wartungszeit'
+,b'Amount to Deliver',b'Liefermenge'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335',b'Same item has been entered multiple times. {0}',b'Gleiches Element wurde mehrfach eingegeben. {0}'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30',b'The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',b'Der Begriff Startdatum kann nicht fr\xc3\xbcher als das Jahr Anfang des Akademischen Jahres an dem der Begriff verkn\xc3\xbcpft ist (Akademisches Jahr {}). Bitte korrigieren Sie die Daten und versuchen Sie es erneut.'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190',b'There were errors.',b'Es sind Fehler aufgetreten.'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166',b'Employee {0} has already applied for {1} between {2} and {3} : ',b'Der Mitarbeiter {0} hat bereits einen Antrag auf {1} zwischen {2} und {3} gestellt:'
+b'DocType: Guardian',b'Guardian Interests',b'W\xc3\xa4chter Interessen'
+b'DocType: Naming Series',b'Current Value',b'Aktueller Wert'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +273',b'Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year',b'Mehrere Gesch\xc3\xa4ftsjahre existieren f\xc3\xbcr das Datum {0}. Bitte setzen Unternehmen im Gesch\xc3\xa4ftsjahr'
+b'DocType: Education Settings',b'Instructor Records to be created by',b'Instructor Records werden erstellt von'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229',b'{0} created',b'{0} erstellt'
+b'DocType: GST Account',b'GST Account',b'GST Konto'
+b'DocType: Delivery Note Item',b'Against Sales Order',b'Zu Kundenauftrag'
+,b'Serial No Status',b'Seriennummern-Status'
+b'DocType: Payment Entry Reference',b'Outstanding',b'Ausstehend'
+b'DocType: Supplier',b'Warn POs',b'Warnen Sie POs'
+,b'Daily Timesheet Summary',b'T\xc3\xa4gliche Zeiterfassungs\xc3\xbcbersicht'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137',"b'Row {0}: To set {1} periodicity, difference between from and to date \\\n\t\t\t\t\t\tmust be greater than or equal to {2}'","b'Zeile {0}: Um Periodizit\xc3\xa4t {1} zu setzen, muss die Differenz aus Von-Datum und Bis-Datum gr\xc3\xb6\xc3\x9fer oder gleich {2} sein'"
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6',b'This is based on stock movement. See {0} for details',b'Dies basiert auf Lagerbewegungen. Siehe {0} f\xc3\xbcr Details'
+b'DocType: Pricing Rule',b'Selling',b'Vertrieb'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392',b'Amount {0} {1} deducted against {2}',b'Menge {0} {1} abgezogen gegen {2}'
+b'DocType: Employee',b'Salary Information',b'Gehaltsinformationen'
+b'DocType: Sales Person',b'Name and Employee ID',b'Name und Mitarbeiter-ID'
+b'apps/erpnext/erpnext/accounts/party.py +308',b'Due Date cannot be before Posting Date',b'F\xc3\xa4lligkeitsdatum kann nicht vor dem Buchungsdatum liegen'
+b'DocType: Website Item Group',b'Website Item Group',b'Webseiten-Artikelgruppe'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463',b'No salary slip found to submit for the above selected criteria OR salary slip already submitted',b'Es wurde kein Lohnzettel f\xc3\xbcr die oben ausgew\xc3\xa4hlten Kriterien oder den bereits eingereichten Gehaltsbeleg gefunden'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150',b'Duties and Taxes',b'Z\xc3\xb6lle und Steuern'
+b'DocType: Projects Settings',b'Projects Settings',b'Projekteinstellungen'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356',b'Please enter Reference date',b'Bitte den Stichtag eingeben'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44',b'{0} payment entries can not be filtered by {1}',b'{0} Zahlungsbuchungen k\xc3\xb6nnen nicht nach {1} gefiltert werden'
+b'DocType: Item Website Specification',b'Table for Item that will be shown in Web Site',"b'Tabelle f\xc3\xbcr Artikel, der auf der Webseite angezeigt wird'"
+b'DocType: Purchase Order Item Supplied',b'Supplied Qty',b'Gelieferte Anzahl'
+b'DocType: Purchase Order Item',b'Material Request Item',b'Materialanfrageartikel'
+b'apps/erpnext/erpnext/config/selling.py +75',b'Tree of Item Groups.',b'Artikelgruppenstruktur'
+b'DocType: Production Plan',b'Total Produced Qty',b'Gesamtproduktionsmenge'
+b'DocType: Payroll Entry',b'Get Employee Details',b'Erhalten Sie Mitarbeiterdetails'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177',b'Cannot refer row number greater than or equal to current row number for this Charge type',"b'F\xc3\xbcr diese Berechnungsart kann keine Zeilennummern zugeschrieben werden, die gr\xc3\xb6\xc3\x9fer oder gleich der aktuellen Zeilennummer ist'"
+b'DocType: Asset',b'Sold',b'Verkauft'
+,b'Item-wise Purchase History',b'Artikelbezogene Einkaufshistorie'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230',"b""Please click on 'Generate Schedule' to fetch Serial No added for Item {0}""","b'Bitte auf ""Zeitplan generieren"" klicken, um die Seriennummer f\xc3\xbcr Artikel {0} abzurufen'"
+b'DocType: Account',b'Frozen',b'Gesperrt'
+b'DocType: Sales Invoice Payment',b'Base Amount (Company Currency)',b'Basisbetrag (Gesellschaft W\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928',b'Raw Materials',b'Rohes Material'
+b'DocType: Payment Reconciliation Payment',b'Reference Row',b'Referenzreihe'
+b'DocType: Installation Note',b'Installation Time',b'Installationszeit'
+b'DocType: Sales Invoice',b'Accounting Details',b'Buchhaltungs-Details'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +113',b'Delete all the Transactions for this Company',b'L\xc3\xb6schen aller Transaktionen dieser Firma'
+b'DocType: Patient',b'O Positive',b'0 +'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68',b'Investments',b'Investitionen'
+b'DocType: Issue',b'Resolution Details',b'Details zur Entscheidung'
+b'apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3',b'Allocations',b'Zuteilungen'
+b'DocType: Item Quality Inspection Parameter',b'Acceptance Criteria',b'Akzeptanzkriterien'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159',b'Please enter Material Requests in the above table',b'Bitte geben Sie Materialw\xc3\xbcnsche in der obigen Tabelle'
+b'DocType: Item Attribute',b'Attribute Name',b'Attributname'
+b'DocType: BOM',b'Show In Website',b'Auf der Webseite anzeigen'
+b'DocType: Shopping Cart Settings',b'Show Quantity in Website',b'Zeigen Menge in Webseite'
+b'DocType: Employee Loan Application',b'Total Payable Amount',b'Zahlenden Gesamtbetrag'
+b'DocType: Task',b'Expected Time (in hours)',b'Voraussichtliche Zeit (in Stunden)'
+b'DocType: Item Reorder',b'Check in (group)',b'Check-in (Gruppe)'
+b'DocType: Soil Texture',b'Silt',b'Schlick'
+,b'Qty to Order',b'Zu bestellende Menge'
+b'DocType: Period Closing Voucher',"b'The account head under Liability or Equity, in which Profit/Loss will be booked'","b'Der Kontenkopf unter Eigen- oder Fremdkapital, in dem Gewinn / Verlust verbucht wird'"
+b'apps/erpnext/erpnext/config/projects.py +36',b'Gantt chart of all tasks.',b'Gantt-Diagramm aller Aufgaben'
+b'DocType: Opportunity',b'Mins to First Response',b'Minuten zum First Response'
+b'DocType: Pricing Rule',b'Margin Type',b'Margenart'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15',b'{0} hours',b'{0} Stunden'
+b'DocType: Course',b'Default Grading Scale',b'Standard-Bewertungsskala'
+b'DocType: Appraisal',b'For Employee Name',b'F\xc3\xbcr Mitarbeiter-Name'
+b'DocType: Holiday List',b'Clear Table',b'Tabelle leeren'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119',b'Available slots',b'Verf\xc3\xbcgbare Steckpl\xc3\xa4tze'
+b'DocType: C-Form Invoice Detail',b'Invoice No',b'Rechnung Nr.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363',b'Make Payment',b'Zahlung ausf\xc3\xbchren'
+b'DocType: Room',b'Room Name',b'Raumname'
+b'DocType: Prescription Duration',b'Prescription Duration',b'Verschreibungsdauer'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81',"b'Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Da der Resturlaub bereits in den zuk\xc3\xbcnftigen Datensatz f\xc3\xbcr Urlaube {1} \xc3\xbcbertragen wurde, kann der Urlaub nicht vor {0} genehmigt/abgelehnt werden.'"
+b'DocType: Activity Cost',b'Costing Rate',b'Kalkulationsbetrag'
+b'apps/erpnext/erpnext/config/selling.py +234',b'Customer Addresses And Contacts',b'Kundenadressen und Ansprechpartner'
+,b'Campaign Efficiency',b'Effizienz der Kampagne'
+b'DocType: Discussion',b'Discussion',b'Diskussion'
+b'DocType: Payment Entry',b'Transaction ID',b'Transaktions-ID'
+b'DocType: Volunteer',b'Anytime',b'Jederzeit'
+b'DocType: Patient',b'Surgical History',b'Chirurgische Geschichte'
+b'DocType: Employee',b'Resignation Letter Date',b'Datum des K\xc3\xbcndigungsschreibens'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39',b'Pricing Rules are further filtered based on quantity.',b'Preisregeln werden zudem nach Menge angewandt.'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127',b'Not Set',b'Nicht festgelegt'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Bitte setzen Sie das Datum des Beitritts f\xc3\xbcr Mitarbeiter {0}'
+b'DocType: Task',b'Total Billing Amount (via Time Sheet)',b'Gesamtrechnungsbetrag (\xc3\xbcber Arbeitszeitblatt)'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61',b'Repeat Customer Revenue',b'Umsatz Bestandskunden'
+b'DocType: Soil Texture',b'Silty Clay Loam',b'Siltiger Ton Lehm'
+b'DocType: Chapter',b'Chapter',b'Gruppe'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Pair',b'Paar'
+b'DocType: Mode of Payment Account',b'Default account will be automatically updated in POS Invoice when this mode is selected.',"b'Das Standardkonto wird in POS-Rechnung automatisch aktualisiert, wenn dieser Modus ausgew\xc3\xa4hlt ist.'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970',b'Select BOM and Qty for Production',b'W\xc3\xa4hlen Sie St\xc3\xbcckliste und Menge f\xc3\xbcr die Produktion'
+b'DocType: Asset',b'Depreciation Schedule',b'Abschreibungsplan'
+b'apps/erpnext/erpnext/config/selling.py +124',b'Sales Partner Addresses And Contacts',b'Vertriebspartner Adressen und Kontakte'
+b'DocType: Bank Reconciliation Detail',b'Against Account',b'Gegenkonto'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52',b'Half Day Date should be between From Date and To Date',b'Halbtages Datum sollte zwischen Von-Datum und eine aktuelle'
+b'DocType: Maintenance Schedule Detail',b'Actual Date',b'Tats\xc3\xa4chliches Datum'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139',b'Please set the Default Cost Center in {0} company.',b'Legen Sie die Standardkostenstelle in der Firma {0} fest.'
+b'DocType: Item',b'Has Batch No',b'Hat Chargennummer'
+b'apps/erpnext/erpnext/public/js/utils.js +106',b'Annual Billing: {0}',b'J\xc3\xa4hrliche Abrechnung: {0}'
+b'apps/erpnext/erpnext/config/accounts.py +200',b'Goods and Services Tax (GST India)',b'Waren- und Dienstleistungssteuer (GST Indien)'
+b'DocType: Delivery Note',b'Excise Page Number',b'Seitenzahl entfernen'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227',"b'Company, From Date and To Date is mandatory'",b'Firma: ab Datum und bis Datum ist obligatorisch'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33',b'Get from Consultation',b'Holen Sie sich von der Beratung'
+b'DocType: Asset',b'Purchase Date',b'Kaufdatum'
+b'DocType: Volunteer',b'Volunteer Type',b'Freiwilliger Typ'
+b'DocType: Student',b'Personal Details',b'Pers\xc3\xb6nliche Daten'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193',"b""Please set 'Asset Depreciation Cost Center' in Company {0}""",b'Bitte setzen &#39;Asset-Abschreibungen Kostenstelle&#39; in Gesellschaft {0}'
+,b'Maintenance Schedules',b'Wartungspl\xc3\xa4ne'
+b'DocType: Task',b'Actual End Date (via Time Sheet)',b'Das tats\xc3\xa4chliche Enddatum (durch Zeiterfassung)'
+b'DocType: Soil Texture',b'Soil Type',b'Bodenart'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387',b'Amount {0} {1} against {2} {3}',b'Menge {0} {1} gegen {2} {3}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277',b'New Message',b'Neue Nachricht'
+,b'Quotation Trends',b'Trendanalyse Angebote'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160',b'Item Group not mentioned in item master for item {0}',b'Artikelgruppe ist im Artikelstamm f\xc3\xbcr Artikel {0} nicht erw\xc3\xa4hnt'
+b'DocType: GoCardless Mandate',b'GoCardless Mandate',b'GoCardless-Mandat'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368',b'Debit To account must be a Receivable account',b'Sollkonto muss ein Forderungskonto sein'
+b'DocType: Shipping Rule',b'Shipping Amount',b'Versandbetrag'
+b'DocType: Supplier Scorecard Period',b'Period Score',b'Periodenspieler'
+b'apps/erpnext/erpnext/utilities/user_progress.py +66',b'Add Customers',b'Kunden hinzuf\xc3\xbcgen'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Pending Amount',b'Ausstehender Betrag'
+b'DocType: Lab Test Template',b'Special',b'Besondere'
+b'DocType: Purchase Order Item Supplied',b'Conversion Factor',b'Umrechnungsfaktor'
+b'DocType: Purchase Order',b'Delivered',b'Geliefert'
+,b'Vehicle Expenses',b'Fahrzeugkosten'
+b'DocType: Serial No',b'Invoice Details',b'Rechnungs-Details'
+b'DocType: Grant Application',b'Show on Website',b'Auf der Website anzeigen'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +212',b'Expected value after useful life must be greater than or equal to {0}',b'Erwartungswert nach Nutzungsdauer muss gr\xc3\xb6\xc3\x9fer sein als oder gleich {0}'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29',b'Start on',b'Beginnen am'
+b'DocType: Hub Category',b'Hub Category',b'Hub-Kategorie'
+b'DocType: Purchase Invoice',b'SEZ',b'SEZ'
+b'DocType: Purchase Receipt',b'Vehicle Number',b'Fahrzeugnummer'
+b'DocType: Employee Loan',b'Loan Amount',b'Darlehensbetrag'
+b'DocType: Student Report Generation Tool',b'Add Letterhead',b'Briefkopf hinzuf\xc3\xbcgen'
+b'DocType: Program Enrollment',b'Self-Driving Vehicle',b'Selbstfahrendes Fahrzeug'
+b'DocType: Supplier Scorecard Standing',b'Supplier Scorecard Standing',b'Supplier Scorecard Standing'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443',b'Row {0}: Bill of Materials not found for the Item {1}',b'Zeile {0}: Bill of Materials nicht f\xc3\xbcr den Artikel gefunden {1}'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98',b'Total allocated leaves {0} cannot be less than already approved leaves {1} for the period',b'Die Gesamtmenge des beantragten Urlaubs {0} kann nicht kleiner sein als die bereits genehmigten Urlaube {1} f\xc3\xbcr den Zeitraum'
+b'DocType: Journal Entry',b'Accounts Receivable',b'Forderungen'
+,b'Supplier-Wise Sales Analytics',b'Lieferantenbezogene Analyse der Verk\xc3\xa4ufe'
+b'DocType: Purchase Invoice',b'Availed ITC Central Tax',b'Availed ITC Central Tax'
+b'DocType: Salary Structure',b'Select employees for current Salary Structure',b'Ausgew\xc3\xa4hlte Mitarbeiter f\xc3\xbcr aktuelle Gehaltsstruktur'
+b'DocType: Sales Invoice',b'Company Address Name',b'Firmenanschrift Name'
+b'DocType: Work Order',b'Use Multi-Level BOM',b'Mehrstufige St\xc3\xbcckliste verwenden'
+b'DocType: Bank Reconciliation',b'Include Reconciled Entries',b'Abgeglichene Buchungen einbeziehen'
+b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Elternkurs (Leer lassen, wenn dies nicht Teil des Elternkurses ist)'"
+b'DocType: Leave Control Panel',b'Leave blank if considered for all employee types',"b'Freilassen, wenn f\xc3\xbcr alle Mitarbeitertypen g\xc3\xbcltig'"
+b'DocType: Landed Cost Voucher',b'Distribute Charges Based On',b'Kosten auf folgender Grundlage verteilen'
+b'DocType: Projects Settings',b'Timesheets',b'Zeiterfassungen'
+b'DocType: HR Settings',b'HR Settings',b'Einstellungen zum Modul Personalwesen'
+b'DocType: Salary Slip',b'net pay info',b'Netto-Zahlung Info'
+b'DocType: Lab Test Template',b'This value is updated in the Default Sales Price List.',b'Dieser Wert wird in der Default Sales Price List aktualisiert.'
+b'DocType: Email Digest',b'New Expenses',b'Neue Ausgaben'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79',b'PDC/LC Amount',b'PDC / LC-Menge'
+b'DocType: Shareholder',b'Shareholder',b'Aktion\xc3\xa4r'
+b'DocType: Purchase Invoice',b'Additional Discount Amount',b'Zus\xc3\xa4tzlicher Rabatt'
+b'DocType: Cash Flow Mapper',b'Position',b'Position'
+b'DocType: Patient',b'Patient Details',b'Patientendetails'
+b'DocType: Patient',b'B Positive',b'B Positiv'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +596',"b'Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.'","b'Row # {0}: Menge muss 1 sein, als Element eine Anlage ist. Bitte verwenden Sie separate Zeile f\xc3\xbcr mehrere Menge.'"
+b'DocType: Leave Block List Allow',b'Leave Block List Allow',b'Urlaubssperrenliste\xc2\xa0zulassen'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +317',b'Abbr can not be blank or space',"b'""Abbr"" kann nicht leer oder Space sein'"
+b'DocType: Patient Medical Record',b'Patient Medical Record',b'Patient Medizinische Aufzeichnung'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +68',b'Group to Non-Group',b'Gruppe an konzernfremde'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50',b'Sports',b'Sport'
+b'DocType: Loan Type',b'Loan Name',b'Darlehensname'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Actual',b'Summe Tats\xc3\xa4chlich'
+b'DocType: Lab Test UOM',b'Test UOM',b'Test UOM'
+b'DocType: Student Siblings',b'Student Siblings',b'Studenten Geschwister'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Unit',b'Einheit'
+b'apps/erpnext/erpnext/stock/get_item_details.py +138',b'Please specify Company',b'Bitte Firma angeben'
+,b'Customer Acquisition and Loyalty',b'Kundengewinnung und -bindung'
+b'DocType: Asset Maintenance Task',b'Maintenance Task',b'Wartungsaufgabe'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118',b'Please set B2C Limit in GST Settings.',b'Bitte setzen Sie B2C Limit in den GST Einstellungen.'
+b'DocType: Purchase Invoice',b'Warehouse where you are maintaining stock of rejected items',"b'Lager, in dem zur\xc3\xbcckerhaltene Artikel aufbewahrt werden (Sperrlager)'"
+b'DocType: Work Order',b'Skip Material Transfer',b'Material\xc3\xbcbertragung \xc3\xbcberspringen'
+b'apps/erpnext/erpnext/setup/utils.py +109',b'Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually',b'Der Wechselkurs f\xc3\xbcr {0} bis {1} f\xc3\xbcr das Stichtag {2} kann nicht gefunden werden. Bitte erstellen Sie einen Exchange Exchange-Eintrag manuell'
+b'DocType: POS Profile',b'Price List',b'Preisliste'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22',b'{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.',"b'{0} ist jetzt das Standardgesch\xc3\xa4ftsjahr. Bitte aktualisieren Sie Ihren Browser, damit die \xc3\x84nderungen wirksam werden.'"
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +45',b'Expense Claims',b'Aufwandsabrechnungen'
+b'DocType: Issue',b'Support',b'Support'
+,b'BOM Search',b'St\xc3\xbccklisten-Suche'
+b'DocType: Project',b'Total Consumed Material Cost  (via Stock Entry)',b'Summe der verbrauchten Materialkosten (\xc3\xbcber die Bestandsbuchung)'
+b'DocType: Item',"b'Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.'",b'Ver\xc3\xb6ffentlichen Sie &quot;In Stock&quot; oder &quot;Nicht verf\xc3\xbcgbar&quot; auf Hub basierend auf dem in diesem Lager verf\xc3\xbcgbaren Bestand.'
+b'DocType: Vehicle',b'Fuel Type',b'Treibstoffart'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27',b'Please specify currency in Company',b'Bitte die Firmenw\xc3\xa4hrung angeben'
+b'DocType: Workstation',b'Wages per hour',b'Lohn pro Stunde'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47',b'Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}',b'Lagerbestand in Charge {0} wird f\xc3\xbcr Artikel {2} im Lager {3} negativ {1}'
+b'apps/erpnext/erpnext/templates/emails/reorder_item.html +1',"b""Following Material Requests have been raised automatically based on Item's re-order level""",b'Folgende Materialanfragen wurden automatisch auf der Grundlage der Nachbestellmenge des Artikels generiert'
+b'DocType: Email Digest',b'Pending Sales Orders',b'Bis Kundenauftr\xc3\xa4ge'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +312',b'Account {0} is invalid. Account Currency must be {1}',b'Konto {0} ist ung\xc3\xbcltig. Kontenw\xc3\xa4hrung muss {1} sein'
+b'DocType: Healthcare Settings',b'Remind Before',b'Vorher erinnern'
+b'apps/erpnext/erpnext/buying/utils.py +34',b'UOM Conversion factor is required in row {0}',b'Ma\xc3\x9feinheit-Umrechnungsfaktor ist erforderlich in der Zeile {0}'
+b'DocType: Production Plan Item',b'material_request_item',b'material_request_item'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087',"b'Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry'","b'Row # {0}: Referenzdokumenttyp muss eine der Kundenauftrag, Verkaufsrechnung oder einen Journaleintrag sein'"
+b'DocType: Salary Component',b'Deduction',b'Abzug'
+b'DocType: Item',b'Retain Sample',b'Probe aufbewahren'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115',b'Row {0}: From Time and To Time is mandatory.',b'Row {0}: Von Zeit und zu Zeit ist obligatorisch.'
+b'DocType: Stock Reconciliation Item',b'Amount Difference',b'Mengendifferenz'
+b'apps/erpnext/erpnext/stock/get_item_details.py +356',b'Item Price added for {0} in Price List {1}',b'Artikel Preis hinzugef\xc3\xbcgt f\xc3\xbcr {0} in Preisliste {1}'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8',b'Please enter Employee Id of this sales person',b'Bitte die Mitarbeiter-ID dieses Vertriebsmitarbeiters angeben'
+b'DocType: Territory',b'Classification of Customers by region',b'Einteilung der Kunden nach Region'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71',b'In Production',b'In Produktion'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65',b'Difference Amount must be zero',b'Differenzbetrag muss Null sein'
+b'DocType: Project',b'Gross Margin',b'Handelsspanne'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61',b'Please enter Production Item first',b'Bitte zuerst Herstellungsartikel eingeben'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45',b'Calculated Bank Statement balance',b'Berechneter Stand des Bankauszugs'
+b'DocType: Normal Test Template',b'Normal Test Template',b'Normale Testvorlage'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64',b'disabled user',b'deaktivierter Benutzer'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919',b'Quotation',b'Angebot'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984',b'Cannot set a received RFQ to No Quote',"b'Kann einen empfangenen RFQ nicht auf ""kein Zitat"" setzen.'"
+b'DocType: Quotation',b'QTN-',b'ANG-'
+b'DocType: Salary Slip',b'Total Deduction',b'Gesamtabzug'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18',b'Select an account to print in account currency',"b'W\xc3\xa4hlen Sie ein Konto aus, das in der Kontow\xc3\xa4hrung gedruckt werden soll'"
+,b'Production Analytics',b'Produktions-Analysen'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6',b'This is based on transactions against this Patient. See timeline below for details',b'Dies beruht auf Transaktionen gegen diesen Patienten. Siehe Zeitleiste unten f\xc3\xbcr Details'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204',b'Cost Updated',b'Kosten aktualisiert'
+b'DocType: Patient',b'Date of Birth',b'Geburtsdatum'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133',b'Item {0} has already been returned',b'Artikel {0} wurde bereits zur\xc3\xbcck gegeben'
+b'DocType: Fiscal Year',b'**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.',"b'""Gesch\xc3\xa4ftsjahr"" steht f\xc3\xbcr ein Finazgesch\xc3\xa4ftsjahr. Alle Buchungen und anderen gr\xc3\xb6\xc3\x9feren Transaktionen werden mit dem ""Gesch\xc3\xa4ftsjahr"" verglichen.'"
+b'DocType: Opportunity',b'Customer / Lead Address',b'Kunden- / Lead-Adresse'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Setup',b'Supplier Scorecard Setup'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133',b'Assessment Plan Name',b'Name des Bewertungsplans'
+b'DocType: Work Order Operation',b'Work Order Operation',b'Arbeitsauftrag Operation'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +233',b'Warning: Invalid SSL certificate on attachment {0}',b'Warnung: Ung\xc3\xbcltiges SSL-Zertifikat f\xc3\xbcr Anlage {0}'
+b'apps/erpnext/erpnext/utilities/activation.py +64',"b'Leads help you get business, add all your contacts and more as your leads'","b'Leads helfen bei der Kundengewinnung, f\xc3\xbcgen Sie alle Ihre Kontakte und mehr als Ihre Leads hinzu'"
+b'DocType: Work Order Operation',b'Actual Operation Time',b'Tats\xc3\xa4chliche Betriebszeit'
+b'DocType: Authorization Rule',b'Applicable To (User)',b'Anwenden auf (Benutzer)'
+b'DocType: Purchase Taxes and Charges',b'Deduct',b'Abziehen'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238',b'Job Description',b'T\xc3\xa4tigkeitsbeschreibung'
+b'DocType: Student Applicant',b'Applied',b'angewandt'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874',b'Re-open',b'Wiederer\xc3\xb6ffnen'
+b'DocType: Sales Invoice Item',b'Qty as per Stock UOM',b'Menge in Lagerma\xc3\x9feinheit'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59',b'Guardian2 Name',b'Guardian2 Namen'
+b'DocType: Purchase Invoice',b'02-Post Sale Discount',b'02-Post Sale Rabatt'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132',"b'Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series'","b'Sonderzeichen au\xc3\x9fer ""-"", ""#"", ""."" und ""/"" sind in der Serienbezeichnung nicht erlaubt'"
+b'DocType: Campaign',"b'Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.'","b'Verkaufskampagne verfolgen: Leads, Angebote, Kundenauftr\xc3\xa4ge usw. von Kampagnen beobachten um die Kapitalverzinsung (RoI) zu messen.'"
+,b'SO Qty',b'Kd.-Auftr.-Menge'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91',b'The field To Shareholder cannot be blank',b'Das Feld An Aktion\xc3\xa4r darf nicht leer sein'
+b'DocType: Guardian',b'Work Address',b'Arbeitsadresse'
+b'DocType: Appraisal',b'Calculate Total Score',b'Gesamtwertung berechnen'
+b'DocType: Health Insurance',b'Health Insurance',b'Krankenversicherung'
+b'DocType: Asset Repair',b'Manufacturing Manager',b'Fertigungsleiter'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191',b'Serial No {0} is under warranty upto {1}',b'Seriennummer {0} ist innerhalb der Garantie bis {1}'
+b'DocType: Plant Analysis Criteria',b'Minimum Permissible Value',b'Minimal zul\xc3\xa4ssiger Wert'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41',b'User {0} already exists',b'Der Benutzer {0} existiert bereits'
+b'apps/erpnext/erpnext/hooks.py +109',b'Shipments',b'Lieferungen'
+b'DocType: Payment Entry',b'Total Allocated Amount (Company Currency)',b'Aufteilbaren Gesamtbetrag (Gesellschaft W\xc3\xa4hrung)'
+b'DocType: Purchase Order Item',b'To be delivered to customer',b'Zur Auslieferung an den Kunden'
+b'DocType: BOM',b'Scrap Material Cost',b'Ausschusssmaterialkosten'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227',b'Serial No {0} does not belong to any Warehouse',b'Seriennummer {0} geh\xc3\xb6rt zu keinem Lager'
+b'DocType: Grant Application',b'Email Notification Sent',b'E-Mail-Benachrichtigung gesendet'
+b'DocType: Purchase Invoice',b'In Words (Company Currency)',b'In Worten (Firmenw\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018',"b'Item Code, warehouse, quantity are required on row'","b'Artikelnummer, Lager, Menge sind in der Zeile erforderlich'"
+b'DocType: Pricing Rule',b'Supplier',b'Lieferant'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41',b'Show Payment Details',b'Zahlungsdetails anzeigen'
+b'DocType: Consultation',b'Consultation Time',b'Konsultationszeit'
+b'DocType: C-Form',b'Quarter',b'Quartal'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106',b'Miscellaneous Expenses',b'Sonstige Aufwendungen'
+b'DocType: Global Defaults',b'Default Company',b'Standardfirma'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +227',b'Expense or Difference account is mandatory for Item {0} as it impacts overall stock value',"b'Ausgaben- oder Differenz-Konto ist Pflicht f\xc3\xbcr Artikel {0}, da es Auswirkungen auf den gesamten Lagerwert hat'"
+b'DocType: Payment Request',b'PR',b'PR'
+b'DocType: Cheque Print Template',b'Bank Name',b'Name der Bank'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30',b'-Above',b'-\xc3\x9cber'
+b'DocType: Employee Loan',b'Employee Loan Account',b'Mitarbeiterdarlehenskonto'
+b'DocType: Leave Application',b'Total Leave Days',b'Urlaubstage insgesamt'
+b'DocType: Email Digest',b'Note: Email will not be sent to disabled users',b'Hinweis: E-Mail wird nicht an gesperrte Nutzer gesendet'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Anzahl der Interaktion'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +105',b'Item Variant Settings',b'Einstellungen zur Artikelvariante'
+b'apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37',b'Select Company...',b'Firma ausw\xc3\xa4hlen...'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all departments',"b'Freilassen, wenn f\xc3\xbcr alle Abteilungen g\xc3\xbcltig'"
+b'apps/erpnext/erpnext/config/hr.py +228',"b'Types of employment (permanent, contract, intern etc.).'","b'Art der Besch\xc3\xa4ftigung (Unbefristeter Vertrag, befristeter Vertrag, Praktikum etc.)'"
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434',b'{0} is mandatory for Item {1}',b'{0} Artikel ist zwingend erfoderlich f\xc3\xbcr {1}'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136',"b'Item {0}: {1} qty produced, '","b'Artikel {0}: {1} Menge produziert,'"
+b'DocType: Payroll Entry',b'Fortnightly',b'vierzehnt\xc3\xa4gig'
+b'DocType: Currency Exchange',b'From Currency',b'Von W\xc3\xa4hrung'
+b'DocType: Vital Signs',b'Weight (In Kilogram)',b'Gewicht (in Kilogramm)'
+b'DocType: Chapter',b'chapters/chapter_name\nleave blank automatically set after saving chapter.',b'chapters / chapter_name lassen das Feld nach dem Speichern des Kapitels automatisch leer.'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202',b'Please set GST Accounts in GST Settings',b'Bitte legen Sie die GST-Konten in den GST-Einstellungen fest'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31',b'Type of Business',b'Gesch\xc3\xa4ftsart'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171',"b'Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row'","b'Bitte zugewiesenen Betrag, Rechnungsart und Rechnungsnummer in mindestens einer Zeile ausw\xc3\xa4hlen'"
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128',b'Cost of New Purchase',b'Kosten eines neuen Kaufs'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35',b'All tasks for the detected diseases were imported',b'Alle Aufgaben f\xc3\xbcr die erkannten Krankheiten wurden importiert'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97',b'Sales Order required for Item {0}',b'Kundenauftrag f\xc3\xbcr den Artikel {0} erforderlich'
+b'DocType: Grant Application',b'Grant Description',b'Gew\xc3\xa4hren Beschreibung'
+b'DocType: Purchase Invoice Item',b'Rate (Company Currency)',b'Preis (Firmenw\xc3\xa4hrung)'
+b'DocType: Student Guardian',b'Others',b'Andere'
+b'DocType: Payment Entry',b'Unallocated Amount',b'Nicht zugewiesene Betrag'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +91',b'Cannot find a matching Item. Please select some other value for {0}.',b'Ein passender Artikel kann nicht gefunden werden. Bitte einen anderen Wert f\xc3\xbcr {0} ausw\xc3\xa4hlen.'
+b'DocType: POS Profile',b'Taxes and Charges',b'Steuern und Geb\xc3\xbchren'
+b'DocType: Item',"b'A Product or a Service that is bought, sold or kept in stock.'","b'Produkt oder Dienstleistung, die gekauft, verkauft oder auf Lager gehalten wird.'"
+b'apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44',b'No more updates',b'Keine Updates mehr'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171',"b""Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row""","b'Die Berechnungsart kann f\xc3\xbcr die erste Zeile nicht auf ""bezogen auf Menge der vorhergenden Zeile"" oder auf ""bezogen auf Gesamtmenge der vorhergenden Zeile"" gesetzt werden'"
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6',b'This covers all scorecards tied to this Setup',b'Dies deckt alle mit diesem Setup verbundenen Scorecards ab'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29',b'Child Item should not be a Product Bundle. Please remove item `{0}` and save',b'Unterartikel sollte nicht ein Produkt-Bundle sein. Bitte Artikel `{0}` entfernen und speichern.'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12',b'Banking',b'Bankwesen'
+b'apps/erpnext/erpnext/utilities/activation.py +108',b'Add Timesheets',b'Zeiterfassung hinzuf\xc3\xbcgen'
+b'DocType: Vehicle Service',b'Service Item',b'Serviceposition'
+b'DocType: Bank Guarantee',b'Bank Guarantee',b'Bankgarantie'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39',"b""Please click on 'Generate Schedule' to get schedule""","b'Bitte auf ""Zeitplan generieren"" klicken, um den Zeitplan zu erhalten'"
+b'DocType: Bin',b'Ordered Quantity',b'Bestellte Menge'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +118',"b'e.g. ""Build tools for builders""'","b'z. B. ""Fertigungs-Werkzeuge f\xc3\xbcr Hersteller""'"
+b'DocType: Grading Scale',b'Grading Scale Intervals',b'Notenskala Intervalle'
+b'apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39',b'Profit for the year',b'Jahres\xc3\xbcberschuss'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125',b'{0} {1}: Accounting Entry for {2} can only be made in currency: {3}',b'{0} {1}: Konteneintrag f\xc3\xbcr {2} kann nur in folgender W\xc3\xa4hrung vorgenommen werden: {3}'
+b'DocType: Fee Schedule',b'In Process',b'W\xc3\xa4hrend des Fertigungsprozesses'
+b'DocType: Authorization Rule',b'Itemwise Discount',b'Artikelbezogener Rabatt'
+b'apps/erpnext/erpnext/config/accounts.py +75',b'Tree of financial accounts.',b'Baum der Finanzbuchhaltung.'
+b'DocType: Cash Flow Mapping',b'Cash Flow Mapping',b'Cashflow-Mapping'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364',b'{0} against Sales Order {1}',b'{0} zu Kundenauftrag{1}'
+b'DocType: Account',b'Fixed Asset',b'Anlageverm\xc3\xb6gen'
+b'apps/erpnext/erpnext/config/stock.py +324',b'Serialized Inventory',b'Serialisierter Lagerbestand'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74',b'Email not found in default contact',b'E-Mail nicht im Standardkontakt gefunden'
+b'DocType: Employee Loan',b'Account Info',b'Kontoinformation'
+b'DocType: Activity Type',b'Default Billing Rate',b'Standard-Rechnungspreis'
+b'DocType: Fees',b'Include Payment',b'Zahlung einschlie\xc3\x9fen'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Sch\xc3\xbclergruppen erstellt.'
+b'DocType: Sales Invoice',b'Total Billing Amount',b'Gesamtrechnungsbetrag'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50',b'Program in the Fee Structure and Student Group {0} are different.',b'Das Programm in der Geb\xc3\xbchrenstruktur und die Studentengruppe {0} unterscheiden sich.'
+b'DocType: Fee Schedule',b'Receivable Account',b'Forderungskonto'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +618',b'Row #{0}: Asset {1} is already {2}',b'Row # {0}: Verm\xc3\xb6gens {1} ist bereits {2}'
+b'DocType: Quotation Item',b'Stock Balance',b'Lagerbestand'
+b'apps/erpnext/erpnext/config/selling.py +321',b'Sales Order to Payment',b'Vom Kundenauftrag zum Zahlungseinang'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123',b'CEO',b'CEO'
+b'DocType: Purchase Invoice',b'With Payment of Tax',b'Mit Zahlung der Steuer'
+b'DocType: Expense Claim Detail',b'Expense Claim Detail',b'Aufwandsabrechnungsdetail'
+b'DocType: Purchase Invoice',b'TRIPLICATE FOR SUPPLIER',b'TRIPLICATE F\xc3\x9cR LIEFERANTEN'
+b'DocType: Land Unit',b'Is Container',b'Ist ein Container'
+b'DocType: Crop Cycle',b'This will be day 1 of the crop cycle',b'Dies ist Tag 1 des Erntezyklus'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871',b'Please select correct account',b'Bitte richtiges Konto ausw\xc3\xa4hlen'
+b'DocType: Purchase Invoice Item',b'Weight UOM',b'Gewichts-Ma\xc3\x9feinheit'
+b'apps/erpnext/erpnext/config/accounts.py +466',b'List of available Shareholders with folio numbers',b'Liste der verf\xc3\xbcgbaren Aktion\xc3\xa4re mit Folio-Nummern'
+b'DocType: Salary Structure Employee',b'Salary Structure Employee',b'Gehaltsstruktur Mitarbeiter'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45',b'Show Variant Attributes',b'Zeige Variantenattribute'
+b'DocType: Student',b'Blood Group',b'Blutgruppe'
+b'DocType: Course',b'Course Name',b'Kursname'
+b'DocType: Employee Leave Approver',"b""Users who can approve a specific employee's leave applications""","b'Benutzer, die die Urlaubsantr\xc3\xa4ge eines bestimmten Mitarbeiters genehmigen k\xc3\xb6nnen'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52',b'Office Equipments',b'B\xc3\xbcroausstattung'
+b'DocType: Purchase Invoice Item',b'Qty',b'Menge'
+b'DocType: Fiscal Year',b'Companies',b'Firmen'
+b'DocType: Supplier Scorecard',b'Scoring Setup',b'Scoring Setup'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24',b'Electronics',b'Elektronik'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326',b'Debit ({0})',b'Soll ({0})'
+b'DocType: Stock Settings',b'Raise Material Request when stock reaches re-order level',"b'Materialanfrage erstellen, wenn der Lagerbestand unter einen Wert sinkt'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98',b'Full-time',b'Vollzeit'
+b'DocType: Payroll Entry',b'Employees',b'Mitarbeiter'
+b'DocType: Employee',b'Contact Details',b'Kontakt-Details'
+b'DocType: C-Form',b'Received Date',b'Empfangsdatum'
+b'DocType: Delivery Note',"b'If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.'","b'Wenn eine Standardvorlage unter den Vorlagen ""Steuern und Abgaben beim Verkauf"" erstellt wurde, bitte eine Vorlage ausw\xc3\xa4hlen und auf die Schaltfl\xc3\xa4che unten klicken.'"
+b'DocType: BOM Scrap Item',b'Basic Amount (Company Currency)',b'Grundbetrag (Gesellschaft W\xc3\xa4hrung)'
+b'DocType: Student',b'Guardians',b'W\xc3\xa4chter'
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13',b'Payment Confirmation',b'Zahlungsbest\xc3\xa4tigung'
+b'DocType: Shopping Cart Settings',b'Prices will not be shown if Price List is not set',"b'Die Preise werden nicht angezeigt, wenn Preisliste nicht gesetzt'"
+b'DocType: Stock Entry',b'Total Incoming Value',b'Summe der Einnahmen'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362',b'Debit To is required',b'Debit Um erforderlich'
+b'apps/erpnext/erpnext/utilities/activation.py +109',"b'Timesheets help keep track of time, cost and billing for activites done by your team'","b'Zeiterfassungen helfen den \xc3\x9cberblick \xc3\xbcber Zeit, Kosten und Abrechnung f\xc3\xbcr Aktivit\xc3\xa4ten von Ihrem Team getan'"
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'Purchase Price List',b'Einkaufspreisliste'
+b'apps/erpnext/erpnext/config/buying.py +155',b'Templates of supplier scorecard variables.',b'Vorlagen der Lieferanten-Scorecard-Variablen.'
+b'DocType: Job Offer Term',b'Offer Term',b'Angebotsfrist'
+b'DocType: Asset',b'Quality Manager',b'Qualit\xc3\xa4tsmanager'
+b'DocType: Job Applicant',b'Job Opening',b'Offene Stellen'
+b'DocType: Payment Reconciliation',b'Payment Reconciliation',b'Zahlungsabgleich'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153',"b""Please select Incharge Person's name""",b'Bitte den Namen der verantwortlichen Person ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51',b'Technology',b'Technologie'
+b'DocType: Hub Settings',b'Unregister from Hub',b'Heben Sie die Registrierung von Hub auf'
+b'apps/erpnext/erpnext/public/js/utils.js +108',b'Total Unpaid: {0}',b'Noch nicht bezahlt: {0}'
+b'DocType: BOM Website Operation',b'BOM Website Operation',b'BOM Webseite Vorgang'
+b'DocType: Supplier Scorecard',b'Supplier Score',b'Lieferantenbewertung'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +213',b'Total Invoiced Amt',b'Gesamtrechnungsbetrag'
+b'DocType: Supplier',b'Warn RFQs',b'Warnung Ausschreibungen'
+b'DocType: BOM',b'Conversion Rate',b'Wechselkurs'
+b'apps/erpnext/erpnext/templates/pages/product_search.html +3',b'Product Search',b'Produkt Suche'
+b'DocType: Assessment Plan',b'To Time',b'Bis-Zeit'
+b'DocType: Authorization Rule',b'Approving Role (above authorized value)',b'Genehmigende Rolle (\xc3\xbcber dem autorisierten Wert)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118',b'Credit To account must be a Payable account',b'Habenkonto muss ein Verbindlichkeitenkonto sein'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43',b'Please select Student Admission which is mandatory for the paid student applicant',"b'Bitte w\xc3\xa4hlen Sie den Studenteneintritt aus, der f\xc3\xbcr den bezahlten Studenten obligatorisch ist'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355',b'BOM recursion: {0} cannot be parent or child of {2}',b'St\xc3\xbccklisten-Rekursion: {0} kann nicht \xc3\xbcbergeordnetes Element oder Unterpunkt von {2} sein'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21',b'Please select a Price List to publish pricing',"b'Bitte w\xc3\xa4hlen Sie eine Preisliste aus, um Preise zu ver\xc3\xb6ffentlichen'"
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38',b'Budget List',b'Budgetliste'
+b'DocType: Work Order Operation',b'Completed Qty',b'Gefertigte Menge'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148',"b'For {0}, only debit accounts can be linked against another credit entry'",b'F\xc3\xbcr {0} k\xc3\xb6nnen nur Sollkonten mit einer weiteren Habenbuchung verkn\xc3\xbcpft werden'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27',b'Price List {0} is disabled',b'Preisliste {0} ist deaktiviert'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127',b'Row {0}: Completed Qty cannot be more than {1} for operation {2}',b'Row {0}: Abgeschlossene Menge kann nicht mehr sein als {1} f\xc3\xbcr den Betrieb {2}'
+b'DocType: Manufacturing Settings',b'Allow Overtime',b'\xc3\x9cberstunden zulassen'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'",b'Serialized Item {0} kann nicht mit der Bestandsabstimmung aktualisiert werden. Bitte verwenden Sie den Stock Entry'
+b'DocType: Training Event Employee',b'Training Event Employee',b'Schulungsveranstaltung Mitarbeiter'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031',b'Maximum Samples - {0} can be retained for Batch {1} and Item {2}.',b'Maximum Samples - {0} kann f\xc3\xbcr Batch {1} und Item {2} beibehalten werden.'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7',b'Add Time Slots',b'Zeitfenster hinzuf\xc3\xbcgen'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201',b'{0} Serial Numbers required for Item {1}. You have provided {2}.',b'{0} Seriennummern f\xc3\xbcr Artikel {1} erforderlich. Sie haben {2} zur Verf\xc3\xbcgung gestellt.'
+b'DocType: Stock Reconciliation Item',b'Current Valuation Rate',b'Aktueller Wertansatz'
+b'DocType: Training Event',b'Advance',b'Vorschuss'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'for making recurring again.',b'um wiederkehrend zu sein.'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +13',b'GoCardless payment gateway settings',b'GoCardless-Gateway-Einstellungen'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122',b'Exchange Gain/Loss',b'Exchange-Gewinn / Verlust'
+b'DocType: Opportunity',b'Lost Reason',b'Verlustgrund'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +265',b'Row #{0}: Account {1} does not belong to company {2}',b'Zeile # {0}: Konto {1} geh\xc3\xb6rt nicht zur Firma {2}'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30',b'Unable to find DocType {0}',b'Kann DocType {0} nicht finden'
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +22',b'New Address',b'Neue Adresse'
+b'DocType: Quality Inspection',b'Sample Size',b'Stichprobenumfang'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47',b'Please enter Receipt Document',b'Bitte geben Sie Eingangsbeleg'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369',b'All items have already been invoiced',b'Alle Artikel sind bereits abgerechnet'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49',"b""Please specify a valid 'From Case No.'""","b'Bitte eine eine g\xc3\xbcltige ""Von Fall Nr."" angeben'"
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24',b'Further cost centers can be made under Groups but entries can be made against non-Groups',"b'Weitere Kostenstellen k\xc3\xb6nnen unter Gruppen angelegt werden, aber Buchungen k\xc3\xb6nnen zu nicht-Gruppen erstellt werden'"
+b'apps/erpnext/erpnext/config/setup.py +66',b'Users and Permissions',b'Benutzer und Berechtigungen'
+b'DocType: Vehicle Log',b'VLOG.',b'VLOG.'
+b'DocType: Branch',b'Branch',b'Filiale'
+b'DocType: Soil Analysis',b'Ca/(K+Ca+Mg)',b'Ca / (K + Ca + Mg)'
+b'DocType: Delivery Trip',b'Fulfillment User',b'Benutzungsbenutzer'
+b'apps/erpnext/erpnext/config/setup.py +61',b'Printing and Branding',b'Druck und Branding'
+b'DocType: Company',b'Total Monthly Sales',b'Gesamtmonatsumsatz'
+b'DocType: Agriculture Analysis Criteria',b'Weather',b'Wetter'
+b'DocType: Bin',b'Actual Quantity',b'Tats\xc3\xa4chlicher Bestand'
+b'DocType: Shipping Rule',b'example: Next Day Shipping',b'Beispiel: Versand am n\xc3\xa4chsten Tag'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187',b'Serial No {0} not found',b'Seriennummer {0} wurde nicht gefunden'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291',b'Subscription has been {0}',b'Abonnement wurde {0}'
+b'DocType: Fee Schedule Program',b'Fee Schedule Program',b'Fee Zeitplan Programm'
+b'DocType: Fee Schedule Program',b'Student Batch',b'Student Batch'
+b'apps/erpnext/erpnext/utilities/activation.py +119',b'Make Student',b'Sch\xc3\xbcler anlegen'
+b'DocType: Supplier Scorecard Scoring Standing',b'Min Grade',b'Min'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +218',b'You have been invited to collaborate on the project: {0}',b'Sie wurden zur Zusammenarbeit f\xc3\xbcr das Projekt {0} eingeladen.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157',b'Physician not available on {0}',b'Arzt nicht verf\xc3\xbcgbar auf {0}'
+b'DocType: Leave Block List Date',b'Block Date',b'Datum sperren'
+b'DocType: Crop',b'Crop',b'Ernte'
+b'DocType: Purchase Receipt',b'Supplier Delivery Note',b'Lieferumfang'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70',b'Apply Now',b'Jetzt bewerben'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Tats\xc3\xa4chliche Menge {0} / Wartezeit {1}'
+b'DocType: Purchase Invoice',b'E-commerce GSTIN',b'E-Commerce GSTIN'
+b'DocType: Sales Order',b'Not Delivered',b'Nicht geliefert'
+,b'Bank Clearance Summary',b'Zusammenfassung Bankabwicklungen'
+b'apps/erpnext/erpnext/config/setup.py +106',"b'Create and manage daily, weekly and monthly email digests.'","b'T\xc3\xa4gliche, w\xc3\xb6chentliche und monatliche E-Mail-Berichte erstellen und verwalten'"
+b'DocType: Appraisal Goal',b'Appraisal Goal',b'Bewertungsziel'
+b'DocType: Stock Reconciliation Item',b'Current Amount',b'Aktuelle H\xc3\xb6he'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58',b'Buildings',b'Geb\xc3\xa4ude'
+b'DocType: Fee Schedule',b'Fee Structure',b'Geb\xc3\xbchrenstruktur'
+b'DocType: Timesheet Detail',b'Costing Amount',b'Kalkulationsbetrag'
+b'DocType: Student Admission Program',b'Application Fee',b'Anmeldegeb\xc3\xbchr'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52',b'Submit Salary Slip',b'Gehaltsabrechnung \xc3\xbcbertragen'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +137',b'Maxiumm discount for Item {0} is {1}%',b'Maximaler Rabatt f\xc3\xbcr Artikel {0} betr\xc3\xa4gt {1}%'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16',b'Import in Bulk',b'Mengenimport'
+b'DocType: Sales Partner',b'Address & Contacts',b'Adresse & Kontaktinformationen'
+b'DocType: SMS Log',b'Sender Name',b'Absendername'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Analysis Criteria',b'Landwirtschaft Analysekriterien'
+b'DocType: POS Profile',b'[Select]',b'[Select]'
+b'DocType: Vital Signs',b'Blood Pressure (diastolic)',b'Blutdruck (diastolisch)'
+b'DocType: SMS Log',b'Sent To',b'Gesendet An'
+b'DocType: Agriculture Task',b'Holiday Management',b'Ferienmanagement'
+b'DocType: Payment Request',b'Make Sales Invoice',b'Verkaufsrechnung erstellen'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61',b'Softwares',b'Software'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +53',b'Next Contact Date cannot be in the past',b'N\xc3\xa4chste Kontakt Datum kann nicht in der Vergangenheit liegen'
+b'DocType: Company',b'For Reference Only.',b'Nur zu Referenzzwecken.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112',b'Physician {0} not available on {1}',b'Arzt {0} nicht verf\xc3\xbcgbar auf {1}'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2581',b'Select Batch No',b'W\xc3\xa4hlen Sie Batch No'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61',b'Invalid {0}: {1}',b'Ung\xc3\xbcltige(r/s) {0}: {1}'
+,b'GSTR-1',b'GSTR-1'
+b'DocType: Purchase Invoice',b'PINV-RET-',b'PINV-Ret'
+b'DocType: Fee Validity',b'Reference Inv',b'Referenz ERE'
+b'DocType: Sales Invoice Advance',b'Advance Amount',b'Anzahlungsbetrag'
+b'DocType: Manufacturing Settings',b'Capacity Planning',b'Kapazit\xc3\xa4tsplanung'
+b'DocType: Supplier Quotation',b'Rounding Adjustment (Company Currency',b'Abrundung (Firmenw\xc3\xa4hrung'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43',"b""'From Date' is required""","b'""Von-Datum"" ist erforderlich'"
+b'DocType: Journal Entry',b'Reference Number',b'Referenznummer'
+b'DocType: Employee',b'Employment Details',b'Besch\xc3\xa4ftigungsdetails'
+b'DocType: Employee',b'New Workplace',b'Neuer Arbeitsplatz'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17',b'Set as Closed',"b'Als ""abgeschlossen"" markieren'"
+b'apps/erpnext/erpnext/stock/get_item_details.py +127',b'No Item with Barcode {0}',b'Kein Artikel mit Barcode {0}'
+b'DocType: Normal Test Items',b'Require Result Value',b'Erforderlichen Ergebniswert'
+b'DocType: Item',b'Show a slideshow at the top of the page',b'Diaschau oben auf der Seite anzeigen'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532',b'Boms',b'St\xc3\xbccklisten'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +162',b'Stores',b'Lagerr\xc3\xa4ume'
+b'DocType: Project Type',b'Projects Manager',b'Projektleiter'
+b'DocType: Serial No',b'Delivery Time',b'Zeitpunkt der Lieferung'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33',b'Ageing Based On',b'Alter basierend auf'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61',b'Appointment cancelled',b'Termin abgesagt'
+b'DocType: Item',b'End of Life',b'Ende der Lebensdauer'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +331',b'Travel',b'Reise'
+b'DocType: Student Report Generation Tool',b'Include All Assessment Group',b'Alle Bewertungsgruppe einschlie\xc3\x9fen'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183',b'No active or default Salary Structure found for employee {0} for the given dates',b'Keine aktive oder Standard-Gehaltsstruktur f\xc3\xbcr Mitarbeiter gefunden {0} f\xc3\xbcr die angegebenen Daten'
+b'DocType: Leave Block List',b'Allow Users',b'Benutzer zulassen'
+b'DocType: Purchase Order',b'Customer Mobile No',b'Mobilnummer des Kunden'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1',b'Recurring',b'Wiederkehrend'
+b'DocType: Cash Flow Mapping Template Details',b'Cash Flow Mapping Template Details',b'Details zur Cashflow-Mapping-Vorlage'
+b'DocType: Cost Center',b'Track separate Income and Expense for product verticals or divisions.',b'Einnahmen und Ausgaben f\xc3\xbcr Produktbereiche oder Abteilungen separat verfolgen.'
+b'DocType: Rename Tool',b'Rename Tool',b'Werkzeug zum Umbenennen'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72',b'Update Cost',b'Kosten aktualisieren'
+b'DocType: Item Reorder',b'Item Reorder',b'Artikelnachbestellung'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463',b'Show Salary Slip',b'Anzeigen Gehaltsabrechnung'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849',b'Transfer Material',b'Material \xc3\xbcbergeben'
+b'DocType: Fees',b'Send Payment Request',b'Zahlungsauftrag senden'
+b'DocType: BOM',"b'Specify the operations, operating cost and give a unique Operation no to your operations.'",b'Arbeitsg\xc3\xa4nge und Betriebskosten angeben und eine eindeutige Arbeitsgang-Nr. f\xc3\xbcr diesen Arbeitsgang angeben.'
+b'DocType: Water Analysis',b'Origin',b'Ursprung'
+b'apps/erpnext/erpnext/controllers/status_updater.py +204',b'This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?',b'Dieses Dokument ist \xc3\xbcber dem Limit von {0} {1} f\xc3\xbcr item {4}. Machen Sie eine andere {3} gegen die gleiche {2}?'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1154',b'Please set recurring after saving',b'Bitte setzen Sie wiederkehrende nach dem Speichern'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769',b'Select change amount account',b'W\xc3\xa4hlen Sie \xc3\x84nderungsbetrag Konto'
+b'DocType: Purchase Invoice',b'Price List Currency',b'Preislistenw\xc3\xa4hrung'
+b'DocType: Naming Series',b'User must always select',b'Benutzer muss immer ausw\xc3\xa4hlen'
+b'DocType: Stock Settings',b'Allow Negative Stock',b'Negativen Lagerbestand zulassen'
+b'DocType: Installation Note',b'Installation Note',b'Installationshinweis'
+b'DocType: Soil Texture',b'Clay',b'Lehm'
+b'DocType: Topic',b'Topic',b'Thema'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45',b'Cash Flow from Financing',b'Cashflow aus Finanzierung'
+b'DocType: Budget Account',b'Budget Account',b'Budget Konto'
+b'DocType: Quality Inspection',b'Verified By',b'Gepr\xc3\xbcft durch'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +78',"b""Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.""","b'Die Standardw\xc3\xa4hrung der Firma kann nicht ge\xc3\xa4ndern werden, weil es bestehende Transaktionen gibt. Transaktionen m\xc3\xbcssen abgebrochen werden, um die Standardw\xc3\xa4hrung zu \xc3\xa4ndern.'"
+b'DocType: Cash Flow Mapping',b'Is Income Tax Liability',b'Ist Einkommensteuerpflicht'
+b'DocType: Grading Scale Interval',b'Grade Description',b'Grade Beschreibung'
+b'DocType: Stock Entry',b'Purchase Receipt No',b'Kaufbeleg Nr.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30',b'Earnest Money',b'Anzahlung'
+b'DocType: Sales Invoice',b' Shipping Bill Number',b'Versandscheinnummer'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34',b'Traceability',b'R\xc3\xbcckverfolgbarkeit'
+b'DocType: Asset Maintenance Log',b'Actions performed',b'Aktionen ausgef\xc3\xbchrt'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51',b'Customer &gt; Customer Group &gt; Territory',b'Kunde&gt; Kundengruppe&gt; Gebiet'
+b'DocType: Cash Flow Mapper',b'Section Leader',b'Abteilungsleiter'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137',b'Source of Funds (Liabilities)',b'Mittelherkunft (Verbindlichkeiten)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +431',b'Quantity in row {0} ({1}) must be same as manufactured quantity {2}',b'Menge in Zeile {0} ({1}) muss die gleiche sein wie die hergestellte Menge {2}'
+b'DocType: Supplier Scorecard Scoring Standing',b'Employee',b'Mitarbeiter'
+b'DocType: Asset Repair',b'Failure Date',b'Fehlerdatum'
+b'DocType: Sample Collection',b'Collected Time',b'Gesammelte Zeit'
+b'DocType: Company',b'Sales Monthly History',b'Verk\xc3\xa4ufe Monatliche Geschichte'
+b'DocType: Asset Maintenance Task',b'Next Due Date',b'N\xc3\xa4chstes F\xc3\xa4lligkeitsdatum'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214',b'Select Batch',b'W\xc3\xa4hlen Sie Batch'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244',b'{0} {1} is fully billed',b'{0} {1} wird voll in Rechnung gestellt'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31',b'Vital Signs',b'Vitalfunktionen'
+b'DocType: Training Event',b'End Time',b'Endzeit'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63',b'Active Salary Structure {0} found for employee {1} for the given dates',b'Aktive Gehaltsstruktur {0} f\xc3\xbcr diesen Mitarbeiter gefunden {1} mit den folgenden Daten'
+b'DocType: Payment Entry',b'Payment Deductions or Loss',b'Zahlung Abz\xc3\xbcge oder Verlust'
+b'DocType: Soil Analysis',b'Soil Analysis Criterias',b'Kriterien f\xc3\xbcr die Bodenanalyse'
+b'apps/erpnext/erpnext/config/setup.py +42',b'Standard contract terms for Sales or Purchase.',b'Allgemeine Vertragsbedingungen f\xc3\xbcr den Verkauf und Einkauf'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +112',b'Group by Voucher',b'Gruppieren nach Beleg'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233',b'Are you sure you want to cancel this appointment?',"b'Sind Sie sicher, dass Sie diesen Termin stornieren m\xc3\xb6chten?'"
+b'DocType: Hotel Room Pricing Package',b'Hotel Room Pricing Package',b'Preisangebot f\xc3\xbcr das Hotelzimmer'
+b'apps/erpnext/erpnext/config/crm.py +6',b'Sales Pipeline',b'Vertriebspipeline'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201',b'Please set default account in Salary Component {0}',b'Bitte setzen Sie Standardkonto in Gehaltskomponente {0}'
+b'apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7',b'Required On',b'Ben\xc3\xb6tigt am'
+b'DocType: Rename Tool',b'File to Rename',"b'Datei, die umbenannt werden soll'"
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200',b'Please select BOM for Item in Row {0}',b'Bitte w\xc3\xa4hlen Sie St\xc3\xbcckliste f\xc3\xbcr Artikel in Zeile {0}'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28',b'Account {0} does not match with Company {1} in Mode of Account: {2}',b'Konto {0} stimmt nicht mit der Firma {1} im Rechnungsmodus \xc3\xbcberein: {2}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +464',b'Specified BOM {0} does not exist for Item {1}',b'Angegebene St\xc3\xbcckliste {0} gibt es nicht f\xc3\xbcr Artikel {1}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301',b'Course: ',b'Kurs:'
+b'DocType: Soil Texture',b'Sandy Loam',b'Sandiger Lehm'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232',b'Maintenance Schedule {0} must be cancelled before cancelling this Sales Order',b'Wartungsplan {0} muss vor Stornierung dieses Kundenauftrages aufgehoben werden'
+b'DocType: POS Profile',b'Applicable for Users',b'Anwendbar f\xc3\xbcr Benutzer'
+b'DocType: Notification Control',b'Expense Claim Approved',b'Aufwandsabrechnung genehmigt'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231',b'No Work Orders created',b'Keine Arbeitsauftr\xc3\xa4ge erstellt'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321',b'Salary Slip of employee {0} already created for this period',b'Gehaltsabrechnung der Mitarbeiter {0} f\xc3\xbcr diesen Zeitraum bereits erstellt'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155',b'Pharmaceutical',b'Arzneimittel'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Cost of Purchased Items',b'Aufwendungen f\xc3\xbcr bezogene Artikel'
+b'DocType: Selling Settings',b'Sales Order Required',b'Kundenauftrag erforderlich'
+b'DocType: Purchase Invoice',b'Credit To',b'Gutschreiben auf'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceDate',b'St\xc3\xbcckdatum'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31',b'Active Leads / Customers',b'Aktive Leads / Kunden'
+b'DocType: Employee Education',b'Post Graduate',b'Graduation ver\xc3\xb6ffentlichen'
+b'DocType: Maintenance Schedule Detail',b'Maintenance Schedule Detail',b'Wartungsplandetail'
+b'DocType: Supplier Scorecard',b'Warn for new Purchase Orders',b'Warnung f\xc3\xbcr neue Bestellungen'
+b'DocType: Quality Inspection Reading',b'Reading 9',b'Ablesewert\xc2\xa09'
+b'DocType: Supplier',b'Is Frozen',b'Ist gesperrt'
+b'apps/erpnext/erpnext/stock/utils.py +224',b'Group node warehouse is not allowed to select for transactions',b'Gruppenknoten Lager ist nicht f\xc3\xbcr Transaktionen zu w\xc3\xa4hlen erlaubt'
+b'DocType: Buying Settings',b'Buying Settings',b'Einkaufs-Einstellungen'
+b'DocType: Stock Entry Detail',b'BOM No. for a Finished Good Item',b'St\xc3\xbccklisten-Nr. f\xc3\xbcr einen fertigen Artikel'
+b'DocType: Upload Attendance',b'Attendance To Date',b'Anwesenheit bis Datum'
+b'DocType: Request for Quotation Supplier',b'No Quote',b'Kein Zitat'
+b'DocType: Warranty Claim',b'Raised By',b'Gemeldet durch'
+b'DocType: Payment Gateway Account',b'Payment Account',b'Zahlungskonto'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909',b'Please specify Company to proceed',b'Bitte Firma angeben um fortzufahren'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27',b'Net Change in Accounts Receivable',b'Nettover\xc3\xa4nderung der Forderungen'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88',b'Compensatory Off',b'Ausgleich f\xc3\xbcr'
+b'DocType: Job Offer',b'Accepted',b'Genehmigt'
+b'DocType: Grant Application',b'Organization',b'Firma'
+b'DocType: BOM Update Tool',b'BOM Update Tool',b'BOM Update Tool'
+b'DocType: SG Creation Tool Course',b'Student Group Name',b'Sch\xc3\xbclergruppenname'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17',b'Show exploded view',b'Explosionsansicht anzeigen'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7',b'Creating Fees',b'Geb\xc3\xbchren anlegen'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +91',b'Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.',"b'Bitte sicher stellen, dass wirklich alle Transaktionen f\xc3\xbcr diese Firma gel\xc3\xb6scht werden sollen. Die Stammdaten bleiben bestehen. Diese Aktion kann nicht r\xc3\xbcckg\xc3\xa4ngig gemacht werden.'"
+b'apps/erpnext/erpnext/templates/pages/product_search.html +21',b'Search Results',b'Suchergebnisse'
+b'DocType: Room',b'Room Number',b'Zimmernummer'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +107',b'Invalid reference {0} {1}',b'Ung\xc3\xbcltige Referenz {0} {1}'
+b'DocType: Shipping Rule',b'Shipping Rule Label',b'Bezeichnung der Versandregel'
+b'DocType: Journal Entry Account',b'Payroll Entry',b'Personalabrechnung'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75',b'View Fees Records',b'Geb\xc3\xbchrens\xc3\xa4tze anzeigen'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +35',b'Make Tax Template',b'Steuervorlage erstellen'
+b'apps/erpnext/erpnext/public/js/conf.js +28',b'User Forum',b'Benutzer-Forum'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319',b'Raw Materials cannot be blank.',b'Rohmaterial kann nicht leer sein'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498',"b'Could not update stock, invoice contains drop shipping item.'","b'Lager konnte nicht aktualisiert werden, Rechnung enth\xc3\xa4lt Direktversand-Artikel.'"
+b'DocType: Lab Test Sample',b'Lab Test Sample',b'Labortestprobe'
+b'DocType: Item Variant Settings',b'Allow Rename Attribute Value',b'Zulassen Attributwert umbenennen'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491',b'Quick Journal Entry',b'Schnellbuchung'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200',b'You can not change rate if BOM mentioned agianst any item',"b'Sie k\xc3\xb6nnen den Preis nicht \xc3\xa4ndern, wenn eine St\xc3\xbcckliste f\xc3\xbcr einen Artikel aufgef\xc3\xbchrt ist'"
+b'DocType: Restaurant',b'Invoice Series Prefix',b'Rechnungsserie Pr\xc3\xa4fix'
+b'DocType: Employee',b'Previous Work Experience',b'Vorherige Berufserfahrung'
+b'DocType: Stock Entry',b'For Quantity',b'F\xc3\xbcr Menge'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205',b'Please enter Planned Qty for Item {0} at row {1}',b'Bitte die geplante Menge f\xc3\xbcr Artikel {0} in Zeile {1} eingeben'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93',b'Google Maps integration is not enabled',b'Die Google Maps-Integration ist nicht aktiviert'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241',b'{0} {1} is not submitted',b'{0} {1} wurde nicht \xc3\xbcbertragen'
+b'DocType: Member',b'Membership Expiry Date',b'Ablaufdatum der Mitgliedschaft'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131',b'{0} must be negative in return document',b'{0} muss im Retourenschein negativ sein'
+,b'Minutes to First Response for Issues',b'Minutes to First Response f\xc3\xbcr Probleme'
+b'DocType: Purchase Invoice',b'Terms and Conditions1',b'Allgemeine Gesch\xc3\xa4ftsbedingungen1'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +109',b'The name of the institute for which you are setting up this system.',"b'Der Name des Instituts, f\xc3\xbcr die Sie setzen dieses System.'"
+b'DocType: Accounts Settings',"b'Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.'",b'Buchung wurde bis zu folgendem Zeitpunkt gesperrt. Bearbeiten oder \xc3\xa4ndern kann nur die Person in unten stehender Rolle.'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116',b'Please save the document before generating maintenance schedule',b'Bitte das Dokument vor dem Erstellen eines Wartungsplans abspeichern'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30',b'Latest price updated in all BOMs',b'Aktueller Preis in allen St\xc3\xbccklisten aktualisiert'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28',b'Project Status',b'Projektstatus'
+b'DocType: UOM',b'Check this to disallow fractions. (for Nos)',"b'Hier aktivieren, um keine Bruchteile zuzulassen (f\xc3\xbcr Nr.)'"
+b'DocType: Student Admission Program',b'Naming Series (for Student Applicant)',b'Namens Series (f\xc3\xbcr Studienbewerber)'
+b'DocType: Delivery Note',b'Transporter Name',b'Name des Transportunternehmers'
+b'DocType: Authorization Rule',b'Authorized Value',b'Autorisierter Wert'
+b'DocType: BOM',b'Show Operations',b'zeigen Operationen'
+,b'Minutes to First Response for Opportunity',b'Minuten bis zur ersten Antwort auf Opportunit\xc3\xa4t'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Absent',b'Summe Abwesenheit'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +862',b'Item or Warehouse for row {0} does not match Material Request',b'Artikel oder Lager in Zeile {0} stimmen nicht mit Materialanfrage \xc3\xbcberein'
+b'apps/erpnext/erpnext/config/stock.py +191',b'Unit of Measure',b'Ma\xc3\x9feinheit'
+b'DocType: Fiscal Year',b'Year End Date',b'Enddatum des Gesch\xc3\xa4ftsjahres'
+b'DocType: Task Depends On',b'Task Depends On',b'Vorgang h\xc3\xa4ngt ab von'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026',b'Opportunity',b'Chance'
+b'DocType: Operation',b'Default Workstation',b'Standard-Arbeitsplatz'
+b'DocType: Notification Control',b'Expense Claim Approved Message',b'Benachrichtigung \xc3\xbcber genehmigte Aufwandsabrechnung'
+b'DocType: Payment Entry',b'Deductions or Loss',b'Abz\xc3\xbcge oder Verlust'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247',b'{0} {1} is closed',b'{0} {1} ist geschlossen'
+b'DocType: Email Digest',b'How frequently?',b'Wie h\xc3\xa4ufig?'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55',b'Total Collected: {0}',b'Gesammelt gesammelt: {0}'
+b'DocType: Purchase Receipt',b'Get Current Stock',b'Aktuellen Lagerbestand aufrufen'
+b'DocType: Purchase Invoice',b'ineligible',b'nicht f\xc3\xb6rderf\xc3\xa4hig'
+b'apps/erpnext/erpnext/config/manufacturing.py +46',b'Tree of Bill of Materials',b'St\xc3\xbccklistenstruktur'
+b'DocType: Student',b'Joining Date',b'Beitrittsdatum'
+,b'Employees working on a holiday',b'Die Mitarbeiter an einem Feiertag arbeiten'
+b'DocType: Share Balance',b'Current State',b'Aktuellen Zustand'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152',b'Mark Present',b'Anwesend setzen'
+b'DocType: Share Transfer',b'From Shareholder',b'Vom Aktion\xc3\xa4r'
+b'DocType: Project',b'% Complete Method',b'% abgeschlossene Methode'
+b'apps/erpnext/erpnext/healthcare/setup.py +181',b'Drug',b'Droge'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200',b'Maintenance start date can not be before delivery date for Serial No {0}',b'Startdatum der Wartung kann nicht vor dem Liefertermin f\xc3\xbcr Seriennummer {0} liegen'
+b'DocType: Work Order',b'Actual End Date',b'Tats\xc3\xa4chliches Enddatum'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost Adjustment',b'Ist Finanzkostenanpassung'
+b'DocType: BOM',b'Operating Cost (Company Currency)',b'Betriebskosten (Gesellschaft W\xc3\xa4hrung)'
+b'DocType: Purchase Invoice',b'PINV-',b'PINV-'
+b'DocType: Authorization Rule',b'Applicable To (Role)',b'Anwenden auf (Rolle)'
+b'DocType: BOM Update Tool',b'Replace BOM',b'Erstelle St\xc3\xbcckliste'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110',b'Code {0} already exist',b'Code {0} existiert bereits'
+b'DocType: Employee Advance',b'Purpose',b'Zweck'
+b'DocType: Company',b'Fixed Asset Depreciation Settings',b'Einstellungen Abschreibungen auf Sachanlagen'
+b'DocType: Item',b'Will also apply for variants unless overrridden',"b'Gilt auch f\xc3\xbcr Varianten, sofern nicht au\xc3\x9fer Kraft gesetzt'"
+b'DocType: Purchase Invoice',b'Advances',b'Anzahlungen'
+b'DocType: Work Order',b'Manufacture against Material Request',"b'Herstellen, gegen Material anfordern'"
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14',b'Assessment Group: ',b'Beurteilungsgruppe:'
+b'DocType: Item Reorder',b'Request for',b'Anfrage f\xc3\xbcr'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32',b'Approving User cannot be same as user the rule is Applicable To',"b'Genehmigender Benutzer kann nicht derselbe Benutzer sein wie derjenige, auf den die Regel anzuwenden ist'"
+b'DocType: Stock Entry Detail',b'Basic Rate (as per Stock UOM)',b'Grundbetrag (nach Lagerma\xc3\x9feinheit)'
+b'DocType: SMS Log',b'No of Requested SMS',b'Anzahl angeforderter SMS'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246',b'Leave Without Pay does not match with approved Leave Application records',b'Unbezahlter Urlaub passt nicht zu den best\xc3\xa4tigten Urlaubsantr\xc3\xa4gen.'
+b'DocType: Campaign',b'Campaign-.####',b'Kampagne-.####'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21',b'Next Steps',b'N\xc3\xa4chste Schritte'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796',b'Please supply the specified items at the best possible rates',b'Bitte geben Sie die angegebenen Elemente zu den bestm\xc3\xb6glichen Preisen'
+b'DocType: Membership',b'USD',b'US Dollar'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28',b'Make Invoice',b'Rechnung erstellen'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80',b'Remaining Balance',b'Die verbleibende Summe'
+b'DocType: Selling Settings',b'Auto close Opportunity after 15 days',b'Auto schlie\xc3\x9fen Gelegenheit nach 15 Tagen'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86',b'Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.',b'Kaufauftr\xc3\xa4ge sind f\xc3\xbcr {0} wegen einer Scorecard von {1} nicht erlaubt.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +498',b'Barcode {0} is not a valid {1} code',b'Der Barcode {0} ist kein g\xc3\xbcltiger {1} Code'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +83',b'End Year',b'Ende Jahr'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / Lead%'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +124',b'Contract End Date must be greater than Date of Joining',b'Vertragsende muss weiter in der Zukunft liegen als Eintrittsdatum sein'
+b'DocType: Driver',b'Driver',b'Treiber'
+b'DocType: Vital Signs',b'Nutrition Values',b'Ern\xc3\xa4hrungswerte'
+b'DocType: Lab Test Template',b'Is billable',b'Ist abrechenbar'
+b'DocType: Delivery Note',b'DN-',b'DN-'
+b'DocType: Sales Partner',b'A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.',"b'Ein Drittanbieter/H\xc3\xa4ndler/Kommission\xc3\xa4r/verbundenes Unternehmen/Wiederverk\xc3\xa4ufer, der die Produkte auf Provisionsbasis verkauft.'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376',b'{0} against Purchase Order {1}',b'{0} zu Lieferantenauftrag {1}'
+b'DocType: Patient',b'Patient Demographics',b'Patienten-Demographie'
+b'DocType: Task',b'Actual Start Date (via Time Sheet)',b'Das tats\xc3\xa4chliche Startdatum (durch Zeiterfassung)'
+b'apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15',b'This is an example website auto-generated from ERPNext',"b'Dies ist eine Beispiel-Webseite, von ERPNext automatisch generiert'"
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43',b'Ageing Range 1',b'Alter Bereich 1'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212',b'Total advance amount cannot be greater than total claimed amount',b'Der gesamte Vorauszahlungsbetrag darf nicht h\xc3\xb6her sein als der gesamte beanspruchte Betrag'
+b'DocType: Purchase Taxes and Charges Template',"b'Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.'","b'Standard-Steuer-Vorlage, die f\xc3\xbcr alle Kauftransaktionen angewandt werden kann. Diese Vorlage kann eine Liste der Steuern und auch anderer Kosten wie ""Versand"", ""Versicherung"", ""Handhabung"" usw. enthalten. \n\n #### Hinweis \n\nDer Steuersatz, den sie hier definieren, wird der Standardsteuersatz f\xc3\xbcr alle Artikel. Wenn es Artikel mit davon abweichenden Steuers\xc3\xa4tzen gibt, m\xc3\xbcssen diese in der Tabelle ""Artikelsteuer"" im Artikelstamm hinzugef\xc3\xbcgt werden.\n\n #### Beschreibung der Spalten \n\n1. Berechnungsart: \n- Dies kann sein ""Auf Nettosumme"" (das ist die Summe der Grundbetr\xc3\xa4ge).\n- ""Auf vorherige Zeilensumme/-Betrag"" (f\xc3\xbcr kumulative Steuern oder Abgaben). Wenn diese Option ausgew\xc3\xa4hlt wird, wird die Steuer als Prozentsatz der vorherigen Zeilesumme/des vorherigen Zeilenbetrags (in der Steuertabelle) angewendet.\n- ""Unmittelbar"" (wie bereits erw\xc3\xa4hnt).\n2. Kontobezeichnung: Das Konto, auf das diese Steuer gebucht wird.\n3. Kostenstelle: Ist die Steuer/Geb\xc3\xbchr ein Ertrag (wie Versand) oder ein Aufwand, muss sie gegen eine Kostenstelle gebucht werden.\n4. Beschreibung: Beschreibung der Steuer (wird auf Rechnungen und Angeboten abgedruckt).\n5. Satz: Steuersatz.\n6. Betrag: Steuerbetrag.\n7. Gesamt: Kumulierte Summe bis zu diesem Punkt.\n8. Zeile eingeben: Wenn ""Basierend auf Vorherige Zeile"" eingestellt wurde, kann hier die Zeilennummer ausgew\xc3\xa4hlt werden, die als Basis f\xc3\xbcr diese Berechnung (voreingestellt ist die vorherige Zeile) herangezogen wird.\n9. Steuern oder Geb\xc3\xbchren ber\xc3\xbccksichtigen: In diesem Abschnitt kann festgelegt werden, ob die Steuer/Geb\xc3\xbchr nur f\xc3\xbcr die Bewertung (kein Teil der Gesamtsumme) oder nur f\xc3\xbcr die Gesamtsumme (vermehrt nicht den Wert des Artikels) oder f\xc3\xbcr beides verwendet wird.\n10. Hinzuf\xc3\xbcgen oder abziehen: Gibt an, ob die Steuer/Abgabe hinzugef\xc3\xbcgt oder abgezogen wird.'"
+b'DocType: Homepage',b'Homepage',b'Webseite'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68',b'Select Physician...',b'Arzt ausw\xc3\xa4hlen ...'
+b'DocType: Grant Application',b'Grant Application Details ',b'Gew\xc3\xa4hren Sie Anwendungsdetails'
+b'DocType: Purchase Receipt Item',b'Recd Quantity',b'Erhaltene Menge'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65',b'Fee Records Created - {0}',b'Geb\xc3\xbchren-Aufzeichnungen erstellt - {0}'
+b'DocType: Asset Category Account',b'Asset Category Account',b'Anlagekategorie Konto'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913',b'Row #{0} (Payment Table): Amount must be positive',b'Zeile # {0} (Zahlungstabelle): Betrag muss positiv sein'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteNum',b'CompteNum'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137',b'Cannot produce more Item {0} than Sales Order quantity {1}',"b'Es k\xc3\xb6nnen nicht mehr Artikel {0} produziert werden, als die \xc3\xbcber Kundenauftr\xc3\xa4ge bestellte St\xc3\xbcckzahl {1}'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +391',b'Select Attribute Values',b'W\xc3\xa4hlen Sie Attributwerte'
+b'DocType: Purchase Invoice',b'Reason For Issuing document',b'Grund f\xc3\xbcr das ausstellende Dokument'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539',b'Stock Entry {0} is not submitted',b'Lagerbuchung {0} wurde nicht \xc3\xbcbertragen'
+b'DocType: Payment Reconciliation',b'Bank / Cash Account',b'Bank / Geldkonto'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +47',b'Next Contact By cannot be same as the Lead Email Address',"b'""N\xc3\xa4chster Kontakt durch"" kann nicht identisch mit der Lead E-Mail-Adresse sein'"
+b'DocType: Tax Rule',b'Billing City',b'Stadt laut Rechnungsadresse'
+b'DocType: Asset',b'Manual',b'Handbuch'
+b'DocType: Salary Component Account',b'Salary Component Account',b'Gehaltskomponente Account'
+b'DocType: Global Defaults',b'Hide Currency Symbol',b'W\xc3\xa4hrungssymbol ausblenden'
+b'apps/erpnext/erpnext/config/non_profit.py +58',b'Donor information.',b'Spenderinformationen'
+b'apps/erpnext/erpnext/config/accounts.py +330',"b'e.g. Bank, Cash, Credit Card'","b'z. B. Bank, Bargeld, Kreditkarte'"
+b'DocType: Lead Source',b'Source Name',b'Quellenname'
+b'DocType: Vital Signs',"b'Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""'","b'Normaler Ruhe-Blutdruck bei einem Erwachsenen ist etwa 120 mmHg systolisch und 80 mmHg diastolisch, abgek\xc3\xbcrzt &quot;120/80 mmHg&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +119',"b'Set items shelf life in days, to set expiry based on manufacturing_date plus self life'","b'Legen Sie die Haltbarkeit der Artikel in Tagen fest, um den Verfall basierend auf Herstellungsdatum plus Eigenleben festzulegen'"
+b'DocType: Journal Entry',b'Credit Note',b'Gutschrift'
+b'DocType: Projects Settings',b'Ignore Employee Time Overlap',b'Mitarbeiter\xc3\xbcberschneidungen ignorieren'
+b'DocType: Warranty Claim',b'Service Address',b'Serviceadresse'
+b'DocType: Asset Maintenance Task',b'Calibration',b'Kalibrierung'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97',b'{0} is a company holiday',b'{0} ist ein Firmenurlaub'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49',b'Furnitures and Fixtures',b'Betriebs- und Gesch\xc3\xa4ftsausstattung'
+b'DocType: Item',b'Manufacture',b'Fertigung'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Company',b'Einrichtung Unternehmen'
+,b'Lab Test Report',b'Lab Testbericht'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13',b'Please Delivery Note first',b'Bitte zuerst den Lieferschein'
+b'DocType: Student Applicant',b'Application Date',b'Antragsdatum'
+b'DocType: Salary Detail',b'Amount based on formula',"b'Menge, bezogen auf Formel'"
+b'DocType: Purchase Invoice',b'Currency and Price List',b'W\xc3\xa4hrung und Preisliste'
+b'DocType: Opportunity',b'Customer / Lead Name',b'Kunden- / Lead-Name'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115',b'Clearance Date not mentioned',b'Abrechnungsdatum nicht erw\xc3\xa4hnt'
+b'apps/erpnext/erpnext/config/manufacturing.py +7',b'Production',b'Produktion'
+b'DocType: Guardian',b'Occupation',b'Beruf'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74',b'Row {0}:Start Date must be before End Date',b'Zeile {0}: Startdatum muss vor dem Enddatum liegen'
+b'DocType: Crop',b'Planting Area',b'Pflanzfl\xc3\xa4che'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Qty)',b'Summe (Anzahl)'
+b'DocType: Installation Note Item',b'Installed Qty',b'Installierte Anzahl'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4',b'This could be because of some invalid Email Addresses in the',b'Dies k\xc3\xb6nnte wegen einiger ung\xc3\xbcltiger E-Mail-Adressen in der'
+b'apps/erpnext/erpnext/utilities/user_progress.py +31',b'You added ',b'Du hast hinzugef\xc3\xbcgt'
+b'DocType: Purchase Taxes and Charges',b'Parenttype',b'Typ des \xc3\xbcbergeordneten Elements'
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10',b'Training Result',b'Trainingsergebnis'
+b'DocType: Purchase Invoice',b'Is Paid',b'Ist bezahlt'
+b'DocType: Salary Structure',b'Total Earning',b'Gesamteinnahmen'
+b'DocType: Purchase Receipt',b'Time at which materials were received',"b'Zeitpunkt, zu dem Materialien empfangen wurden'"
+b'DocType: Products Settings',b'Products per Page',b'Produkte pro Seite'
+b'DocType: Stock Ledger Entry',b'Outgoing Rate',b'Verkaufspreis'
+b'apps/erpnext/erpnext/config/hr.py +233',b'Organization branch master.',b'Stammdaten zu Unternehmensfilialen'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +313',b' or ',b'oder'
+b'DocType: Sales Order',b'Billing Status',b'Abrechnungsstatus'
+b'apps/erpnext/erpnext/public/js/conf.js +32',b'Report an Issue',b'Einen Fall melden'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120',b'Utility Expenses',b'Versorgungsaufwendungen'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64',b'90-Above',b'\xc3\x9cber 90'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252',b'Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher',b'Row # {0}: Journal Entry {1} nicht Konto {2} oder bereits abgestimmt gegen einen anderen Gutschein'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Weight',b'Kriterien Gewicht'
+b'DocType: Buying Settings',b'Default Buying Price List',b'Standard-Einkaufspreisliste'
+b'DocType: Payroll Entry',b'Salary Slip Based on Timesheet',b'Gehaltsabrechnung Basierend auf Timesheet'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43',b'Buying Rate',b'Kaufrate'
+b'DocType: Notification Control',b'Sales Order Message',b'Benachrichtigung \xc3\xbcber Kundenauftrag'
+b'apps/erpnext/erpnext/config/setup.py +15',"b'Set Default Values like Company, Currency, Current Fiscal Year, etc.'","b'Standardwerte wie Firma, W\xc3\xa4hrung, aktuelles Gesch\xc3\xa4ftsjahr usw. festlegen'"
+b'DocType: Payment Entry',b'Payment Type',b'Zahlungsart'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',"b'Bitte w\xc3\xa4hlen Sie einen Batch f\xc3\xbcr Item {0}. Es ist nicht m\xc3\xb6glich, eine einzelne Charge zu finden, die diese Anforderung erf\xc3\xbcllt'"
+b'DocType: Hub Category',b'Parent Category',b'\xc3\x9cbergeordnete Kategorie'
+b'DocType: Payroll Entry',b'Select Employees',b'Mitarbeiter ausw\xc3\xa4hlen'
+b'DocType: Opportunity',b'Potential Sales Deal',b'M\xc3\xb6glicher Verkaufsabschluss'
+b'DocType: Complaint',b'Complaints',b'Beschwerden'
+b'DocType: Payment Entry',b'Cheque/Reference Date',b'Scheck-/ Referenzdatum'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges',b'Gesamte Steuern und Geb\xc3\xbchren'
+b'DocType: Employee',b'Emergency Contact',b'Notfallkontakt'
+b'DocType: Bank Reconciliation Detail',b'Payment Entry',b'Zahlung'
+,b'sales-browser',b'Umsatz-Browser'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +79',b'Ledger',b'Hauptbuch'
+b'DocType: Patient Medical Record',b'PMR-',b'PMR-'
+b'DocType: Drug Prescription',b'Drug Code',b'Drug Code'
+b'DocType: Target Detail',b'Target  Amount',b'Zielbetrag'
+b'DocType: POS Profile',b'Print Format for Online',b'Online-Druckformat'
+b'DocType: Shopping Cart Settings',b'Shopping Cart Settings',b'Warenkorb-Einstellungen'
+b'DocType: Journal Entry',b'Accounting Entries',b'Buchungen'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17',"b""If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.""","b'Wenn die ausgew\xc3\xa4hlte Preisregel f\xc3\xbcr &quot;Rate&quot; festgelegt wurde, wird die Preisliste \xc3\xbcberschrieben. Der Preisregelpreis ist der Endpreis, daher sollte kein weiterer Rabatt angewendet werden. Daher wird es in Transaktionen wie Kundenauftrag, Bestellung usw. im Feld &#39;Preis&#39; und nicht im Feld &#39;Preislistenpreis&#39; abgerufen.'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24',b'Duplicate Entry. Please check Authorization Rule {0}',b'Doppelter Eintrag/doppelte Buchung. Bitte \xc3\xbcberpr\xc3\xbcfen Sie Autorisierungsregel {0}'
+b'DocType: Journal Entry Account',b'Reference Due Date',b'Referenz F\xc3\xa4lligkeitsdatum'
+b'DocType: Purchase Order',b'Ref SQ',b'Ref-SQ'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55',b'Receipt document must be submitted',b'Eingangsbeleg muss vorgelegt werden'
+b'DocType: Purchase Invoice Item',b'Received Qty',b'Erhaltene Menge'
+b'DocType: Stock Entry Detail',b'Serial No / Batch',b'Seriennummer / Charge'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340',b'Not Paid and Not Delivered',b'Nicht bezahlt und nicht geliefert'
+b'DocType: Product Bundle',b'Parent Item',b'\xc3\x9cbergeordneter Artikel'
+b'DocType: Account',b'Account Type',b'Kontentyp'
+b'DocType: Delivery Note',b'DN-RET-',b'DN-Ret'
+b'apps/erpnext/erpnext/templates/pages/projects.html +58',b'No time sheets',b'Keine Zeitbl\xc3\xa4tter'
+b'DocType: GoCardless Mandate',b'GoCardless Customer',b'GoCardloser Kunde'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123',b'Leave Type {0} cannot be carry-forwarded',b'Urlaubstyp {0} kann nicht in die Zukunft \xc3\xbcbertragen werden'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215',"b""Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'""","b'Wartungsplan wird nicht f\xc3\xbcr alle Elemente erzeugt. Bitte klicken Sie auf ""Zeitplan generieren""'"
+,b'To Produce',b'Zu produzieren'
+b'apps/erpnext/erpnext/config/hr.py +93',b'Payroll',b'Lohn-und Gehaltsabrechnung'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196',"b'For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included'","b'F\xc3\xbcr Zeile {0} in {1}. Um {2} in die Artikel-Bewertung mit einzubeziehen, muss auch Zeile {3} mit enthalten sein'"
+b'DocType: Patient Service Unit',b'Parent Service Unit',b'\xc3\x9cbergeordnete Serviceeinheit'
+b'apps/erpnext/erpnext/utilities/activation.py +101',b'Make User',b'Benutzer anlegen'
+b'DocType: Packing Slip',b'Identification of the package for the delivery (for print)',b'Kennzeichnung des Paketes f\xc3\xbcr die Lieferung (f\xc3\xbcr den Druck)'
+b'DocType: Bin',b'Reserved Quantity',b'Reservierte Menge'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Bitte geben Sie eine g\xc3\xbcltige Email Adresse an'
+b'DocType: Volunteer Skill',b'Volunteer Skill',b'Freiwillige F\xc3\xa4higkeit'
+b'DocType: Bank Reconciliation',b'Include POS Transactions',b'POS-Transaktionen einschlie\xc3\x9fen'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +784',b'Please select an item in the cart',b'Bitte w\xc3\xa4hlen Sie einen Artikel im Warenkorb'
+b'DocType: Landed Cost Voucher',b'Purchase Receipt Items',b'Kaufbeleg-Artikel'
+b'apps/erpnext/erpnext/config/learn.py +21',b'Customizing Forms',b'Formulare anpassen'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74',b'Arrear',b'R\xc3\xbcckstand'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158',b'Depreciation Amount during the period',b'Abschreibungsbetrag in der Zeit'
+b'apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43',b'Disabled template must not be default template',b'Deaktiviert Vorlage muss nicht Standard-Vorlage sein'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314',b'For row {0}: Enter planned qty',b'F\xc3\xbcr Zeile {0}: Geben Sie die geplante Menge ein'
+b'DocType: Shareholder',b'SH-',b'SCH-'
+b'DocType: Account',b'Income Account',b'Ertragskonto'
+b'DocType: Payment Request',"b""Amount in customer's currency""",b'Betrag in Kundenw\xc3\xa4hrung'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825',b'Delivery',b'Auslieferung'
+b'DocType: Volunteer',b'Weekdays',b'Wochentage'
+b'DocType: Stock Reconciliation Item',b'Current Qty',b'Aktuelle Anzahl'
+b'DocType: Restaurant Menu',b'Restaurant Menu',b'Speisekarte'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +36',b'Prev',b'Vorherige'
+b'DocType: Appraisal Goal',b'Key Responsibility Area',b'Entscheidender Verantwortungsbereich'
+b'apps/erpnext/erpnext/utilities/activation.py +127',"b'Student Batches help you track attendance, assessments and fees for students'","b'Studenten Batches helfen Ihnen die Teilnahme, Einsch\xc3\xa4tzungen und Geb\xc3\xbchren f\xc3\xbcr Studenten verfolgen'"
+b'DocType: Payment Entry',b'Total Allocated Amount',b'Insgesamt zugewiesener Betrag'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +151',b'Set default inventory account for perpetual inventory',b'Inventurkonto f\xc3\xbcr permanente Inventur ausw\xc3\xa4hlen'
+b'DocType: Item Reorder',b'Material Request Type',b'Materialanfragetyp'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252',b'Accural Journal Entry for salaries from {0} to {1}',b'Accural Journaleintrag f\xc3\xbcr die Geh\xc3\xa4lter von {0} bis {1}'
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17',b'Send Grant Review Email',b'Senden Sie Grant Review E-Mail'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +848',"b'LocalStorage is full, did not save'","b'Localstorage voll ist, nicht speichern'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100',b'Row {0}: UOM Conversion Factor is mandatory',b'Zeile {0}: Umrechnungsfaktor f\xc3\xbcr Ma\xc3\x9feinheit ist zwingend erforderlich'
+b'apps/erpnext/erpnext/utilities/user_progress.py +235',b'Room Capacity',b'Raumkapazit\xc3\xa4t'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95',b'Ref',b'Ref.'
+b'DocType: Lab Test',b'LP-',b'LP-'
+b'DocType: Healthcare Settings',b'Registration Fee',b'Registrierungsgeb\xc3\xbchr'
+b'DocType: Budget',b'Cost Center',b'Kostenstelle'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45',b'Voucher #',b'Beleg #'
+b'DocType: Notification Control',b'Purchase Order Message',b'Lieferantenauftrags-Nachricht'
+b'DocType: Tax Rule',b'Shipping Country',b'Zielland der Lieferung'
+b'DocType: Selling Settings',"b""Hide Customer's Tax Id from Sales Transactions""",b'Ausblenden Kundensteuernummer aus Verkaufstransaktionen'
+b'DocType: Upload Attendance',b'Upload HTML',b'HTML hochladen'
+b'DocType: Employee',b'Relieving Date',b'Freistellungsdatum'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14',"b'Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.'",b'Die Preisregel \xc3\xbcberschreibt die Preisliste. Bitte einen Rabattsatz aufgrund bestimmter Kriterien definieren.'
+b'DocType: Serial No',b'Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt',b'Lager kann nur \xc3\xbcber Lagerbuchung / Lieferschein / Kaufbeleg ge\xc3\xa4ndert werden'
+b'DocType: Employee Education',b'Class / Percentage',b'Klasse / Anteil'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134',b'Head of Marketing and Sales',b'Leiter Marketing und Vertrieb'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72',b'Income Tax',b'Einkommensteuer'
+b'apps/erpnext/erpnext/config/selling.py +174',b'Track Leads by Industry Type.',b'Leads nach Branchentyp nachverfolgen'
+b'apps/erpnext/erpnext/utilities/user_progress.py +101',b'Go to Letterheads',b'Gehe zu Briefk\xc3\xb6pfe'
+b'DocType: Item Supplier',b'Item Supplier',b'Artikellieferant'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1255',b'Please enter Item Code to get batch no',b'Bitte die Artikelnummer eingeben um die Chargennummer zu erhalten'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880',b'Please select a value for {0} quotation_to {1}',b'Bitte einen Wert f\xc3\xbcr {0} Angebot an {1} ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419',b'No Items selected for transfer',b'Keine Elemente f\xc3\xbcr die \xc3\x9cbertragung ausgew\xc3\xa4hlt'
+b'apps/erpnext/erpnext/config/selling.py +46',b'All Addresses.',b'Alle Adressen'
+b'DocType: Company',b'Stock Settings',b'Lager-Einstellungen'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +183',"b'Merging is only possible if following properties are same in both records. Is Group, Root Type, Company'","b'Zusammenf\xc3\xbchrung ist nur m\xc3\xb6glich, wenn folgende Eigenschaften in beiden Datens\xc3\xa4tzen identisch sind:  Gruppe, Root-Typ, Firma'"
+b'DocType: Vehicle',b'Electric',b'elektrisch'
+b'DocType: Task',b'% Progress',b'% Fortschritt'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123',b'Gain/Loss on Asset Disposal',b'Gewinn / Verlust aus der Ver\xc3\xa4u\xc3\x9ferung von Verm\xc3\xb6genswerten'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117',b'Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.',b'Kontonummer f\xc3\xbcr Konto {0} ist nicht verf\xc3\xbcgbar. <br> Bitte richten Sie Ihren Kontenplan korrekt ein.'
+b'DocType: Task',b'Depends on Tasks',b'Abh\xc3\xa4ngig von Vorgang'
+b'apps/erpnext/erpnext/config/selling.py +36',b'Manage Customer Group Tree.',b'Baumstruktur der Kundengruppen verwalten'
+b'DocType: Shopping Cart Settings',b'Attachments can be shown without enabling the shopping cart',b'Anh\xc3\xa4nge k\xc3\xb6nnen ohne Erlaubnis des Einkaufswagens angezeigt werden'
+b'DocType: Normal Test Items',b'Result Value',b'Ergebnis Wert'
+b'DocType: Hotel Room',b'Hotels',b'Hotels'
+b'DocType: Supplier Quotation',b'SQTN-',b'SQTN-'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22',b'New Cost Center Name',b'Neuer Kostenstellenname'
+b'DocType: Leave Control Panel',b'Leave Control Panel',b'Urlaubsverwaltung'
+b'DocType: Project',b'Task Completion',b'Aufgabenerledigung'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +22',b'Not in Stock',b'Nicht lagernd'
+b'DocType: Volunteer',b'Volunteer Skills',b'Freiwillige F\xc3\xa4higkeiten'
+b'DocType: Appraisal',b'HR User',b'Nutzer Personalabteilung'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted',b'Steuern und Geb\xc3\xbchren abgezogen'
+b'apps/erpnext/erpnext/hooks.py +142',b'Issues',b'Probleme'
+b'apps/erpnext/erpnext/controllers/status_updater.py +12',b'Status must be one of {0}',b'Status muss einer aus {0} sein'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64',b'Reminder to update GSTIN Sent',b'Erinnerung an GSTIN Sent zu aktualisieren'
+b'DocType: Sales Invoice',b'Debit To',b'Belasten auf'
+b'DocType: Restaurant Menu Item',b'Restaurant Menu Item',b'Restaurant-Men\xc3\xbcpunkt'
+b'DocType: Delivery Note',b'Required only for sample item.',b'Nur erforderlich f\xc3\xbcr Probeartikel.'
+b'DocType: Stock Ledger Entry',b'Actual Qty After Transaction',b'Tats\xc3\xa4chliche Anzahl nach Transaktionen'
+,b'Pending SO Items For Purchase Request',b'Ausstehende Artikel aus Kundenauftr\xc3\xa4gen f\xc3\xbcr Lieferantenanfrage'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35',b'Student Admissions',b'Student Admissions'
+b'apps/erpnext/erpnext/accounts/party.py +388',b'{0} {1} is disabled',b'{0} {1} ist deaktiviert'
+b'DocType: Supplier',b'Billing Currency',b'Abrechnungsw\xc3\xa4hrung'
+b'DocType: Sales Invoice',b'SINV-RET-',b'SINV-Ret'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200',b'Extra Large',b'Besonders gro\xc3\x9f'
+b'DocType: Crop',b'Scientific Name',b'Wissenschaftlicher Name'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Leaves',b'insgesamt Bl\xc3\xa4tter'
+b'DocType: Customer',"b'Reselect, if the chosen contact is edited after save'","b'W\xc3\xa4hlen Sie erneut, wenn der ausgew\xc3\xa4hlte Kontakt nach dem Speichern bearbeitet wird'"
+b'DocType: Consultation',b'In print',b'in Druckbuchstaben'
+,b'Profit and Loss Statement',b'Gewinn- und Verlustrechnung'
+b'DocType: Bank Reconciliation Detail',b'Cheque Number',b'Schecknummer'
+,b'Sales Browser',b'Vertriebs-Browser'
+b'DocType: Journal Entry',b'Total Credit',b'Gesamt-Haben'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542',b'Warning: Another {0} # {1} exists against stock entry {2}',b'Achtung: Zu Lagerbuchung {2} gibt es eine andere Gegenbuchung {0} # {1}'
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +66',b'Local',b'Lokal'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26',b'Loans and Advances (Assets)',b'Darlehen und Anzahlungen (Aktiva)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12',b'Debtors',b'Schuldner'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199',b'Large',b'Gro\xc3\x9f'
+b'DocType: Homepage Featured Product',b'Homepage Featured Product',b'auf Webseite vorgestelltes Produkt'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248',b'All Assessment Groups',b'Alle Bewertungsgruppen'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15',b'New Warehouse Name',b'Neuer Lagername'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +259',b'Total {0} ({1})',b'Insgesamt {0} ({1})'
+b'DocType: C-Form Invoice Detail',b'Territory',b'Region'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151',b'Please mention no of visits required',"b'Bitte bei ""Besuche erforderlich"" NEIN angeben'"
+b'DocType: Stock Settings',b'Default Valuation Method',b'Standard-Bewertungsmethode'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26',b'Fee',b'Geb\xc3\xbchr'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +154',b'Update in progress. It might take a while.',b'Aktualisierung l\xc3\xa4uft. Es kann eine Weile dauern.'
+b'DocType: Production Plan Item',b'Produced Qty',b'Produzierte Menge'
+b'DocType: Vehicle Log',b'Fuel Qty',b'Kraftstoff-Menge'
+b'DocType: Stock Entry',b'Target Warehouse Name',b'Name des Ziellagers'
+b'DocType: Work Order Operation',b'Planned Start Time',b'Geplante Startzeit'
+b'DocType: Course',b'Assessment',b'Beurteilung'
+b'DocType: Payment Entry Reference',b'Allocated',b'Zugewiesen'
+b'apps/erpnext/erpnext/config/accounts.py +267',b'Close Balance Sheet and book Profit or Loss.',b'Bilanz schliessen und in die Gewinn und Verlustrechnung \xc3\xbcbernehmen'
+b'DocType: Student Applicant',b'Application Status',b'Bewerbungsstatus'
+b'DocType: Sensitivity Test Items',b'Sensitivity Test Items',b'Empfindlichkeitstests'
+b'DocType: Project Update',b'Project Update',b'Projektaktualisierung'
+b'DocType: Fees',b'Fees',b'Geb\xc3\xbchren'
+b'DocType: Currency Exchange',b'Specify Exchange Rate to convert one currency into another',b'Wechselkurs zum Umrechnen einer W\xc3\xa4hrung in eine andere angeben'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159',b'Quotation {0} is cancelled',b'Angebot {0} wird storniert'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119',b'Total Outstanding Amount',b'Offener Gesamtbetrag'
+b'DocType: Sales Partner',b'Targets',b'Ziele'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54',b'Please register the SIREN number in the company information file',b'Bitte registrieren Sie die SIREN-Nummer in der Unternehmensinformationsdatei'
+b'DocType: Price List',b'Price List Master',b'Preislisten-Vorlagen'
+b'DocType: GST Account',b'CESS Account',b'CESS-Konto'
+b'DocType: Sales Person',b'All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.',"b'Alle Verkaufstransaktionen k\xc3\xb6nnen f\xc3\xbcr mehrere verschiedene ""Vertriebsmitarbeiter"" markiert werden, so dass Ziele festgelegt und \xc3\xbcberwacht werden k\xc3\xb6nnen.'"
+,b'S.O. No.',b'Nummer der Lieferantenbestellung'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241',b'Please create Customer from Lead {0}',b'Bitte Kunden aus Lead {0} erstellen'
+b'apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3',b'Select Patient',b'W\xc3\xa4hlen Sie Patient aus'
+b'DocType: Price List',b'Applicable for Countries',b'Anwenden f\xc3\xbcr L\xc3\xa4nder'
+b'DocType: Supplier Scorecard Scoring Variable',b'Parameter Name',b'Parametername'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52',b'Student Group Name is mandatory in row {0}',b'Studentengruppenname ist obligatorisch in Zeile {0}'
+b'DocType: Homepage',b'Products to be shown on website homepage',"b'Produkte, die auf der Webseite angezeigt werden'"
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13',b'This is a root customer group and cannot be edited.',b'Dies ist eine Root-Kundengruppe und kann nicht bearbeitet werden.'
+b'DocType: Student',b'AB-',b'AB-'
+b'DocType: POS Profile',b'Ignore Pricing Rule',b'Preisregel ignorieren'
+b'DocType: Employee Education',b'Graduate',b'Akademiker'
+b'DocType: Leave Block List',b'Block Days',b'Tage sperren'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83',"b'Shipping Address does not have country, which is required for this Shipping Rule'","b'Lieferadresse hat kein Land, das f\xc3\xbcr diese Versandregel ben\xc3\xb6tigt wird'"
+b'DocType: Journal Entry',b'Excise Entry',b'Eintrag/Buchung entfernen'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65',"b""Warning: Sales Order {0} already exists against Customer's Purchase Order {1}""",b'Warnung: Kundenauftrag {0} zu Kunden-Bestellung bereits vorhanden {1}'
+b'DocType: Terms and Conditions',"b'Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.'","b'Allgemeine Gesch\xc3\xa4ftsbedingungen, die bei Ver- und Eink\xc3\xa4ufen verwendet werden k\xc3\xb6nnen.\n\n Beispiele: \n\n1. G\xc3\xbcltigkeit des Angebots.\n2. Zahlungsbedingungen (Vorkasse, auf Rechnung, Teilweise Vorkasse usw.)\n3. Was ist eine Extraleistung (oder vom Kunden zu tragen).\n4. Warnhinweise zur Sicherheit/Nutzung.\n5. Garantie, falls vorhanden.\n6. R\xc3\xbcckgabebedingungen.\n7. Lieferbedingungen, falls zutreffend.\n8. Beschwerdemanagement, Schadensersatz, Haftung usw. \n9. Adresse und Kontaktdaten des Unternehmens.'"
+b'DocType: Issue',b'Issue Type',b'Fehlertyp'
+b'DocType: Attendance',b'Leave Type',b'Urlaubstyp'
+b'DocType: Purchase Invoice',b'Supplier Invoice Details',b'Lieferant Rechnungsdetails'
+b'DocType: Agriculture Task',b'Ignore holidays',b'Feiertage ignorieren'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +233',"b""Expense / Difference account ({0}) must be a 'Profit or Loss' account""","b'Aufwands-/Differenz-Konto ({0}) muss ein ""Gewinn oder Verlust""-Konto sein'"
+b'DocType: Project',b'Copied From',b'Kopiert von'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340',b'Invoice already created for all billing hours',b'Die Rechnung wurde bereits f\xc3\xbcr alle Abrechnungsstunden erstellt'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96',b'Name error: {0}',b'Name Fehler: {0}'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost',b'Ist Finanzen Kosten'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18',b'Attendance for employee {0} is already marked',"b'""Anwesenheit von Mitarbeiter"" {0} ist bereits markiert'"
+b'DocType: Packing Slip',b'If more than one package of the same type (for print)',b'Wenn es mehr als ein Paket von der gleichen Art (f\xc3\xbcr den Druck) gibt'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27',b'Please set default customer in Restaurant Settings',b'Bitte setzen Sie den Standardkunden in den Restauranteinstellungen'
+,b'Salary Register',b'Gehalt Register'
+b'DocType: Warehouse',b'Parent Warehouse',b'\xc3\x9cbergeordnetes Lager'
+b'DocType: C-Form Invoice Detail',b'Net Total',b'Nettosumme'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +546',b'Default BOM not found for Item {0} and Project {1}',b'Standard-St\xc3\xbcckliste nicht gefunden f\xc3\xbcr Position {0} und Projekt {1}'
+b'apps/erpnext/erpnext/config/hr.py +168',b'Define various loan types',b'Definieren Sie verschiedene Darlehensarten'
+b'DocType: Bin',b'FCFS Rate',"b'""Wer-zuerst-kommt-mahlt-zuerst""-Anteil (Windhundverfahren)'"
+b'DocType: Opening Invoice Creation Tool Item',b'Outstanding Amount',b'Ausstehender Betrag'
+b'apps/erpnext/erpnext/templates/generators/bom.html +71',b'Time(in mins)',b'Zeit (in Min)'
+b'DocType: Project Task',b'Working',b'In Bearbeitung'
+b'DocType: Stock Ledger Entry',b'Stock Queue (FIFO)',b'Lagerverfahren (FIFO)'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +127',b'Financial Year',b'Gesch\xc3\xa4ftsjahr'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46',b'{0} does not belong to Company {1}',b'{0} geh\xc3\xb6rt nicht zu Firma {1}'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66',b'Could not solve criteria score function for {0}. Make sure the formula is valid.',"b'Konnte die Kriterien-Score-Funktion f\xc3\xbcr {0} nicht l\xc3\xb6sen. Stellen Sie sicher, dass die Formel g\xc3\xbcltig ist.'"
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122',b'Cost as on',"b'Kosten, wie auf'"
+b'DocType: Healthcare Settings',b'Out Patient Settings',b'Einstellungen f\xc3\xbcr ambulante Patienten'
+b'DocType: Account',b'Round Off',b'Abschliessen'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259',b'Quantity must be positive',b'Menge muss gr\xc3\xb6\xc3\x9fer Null sein'
+b'DocType: Material Request Plan Item',b'Requested Qty',b'Angeforderte Menge'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96',b'The fields From Shareholder and To Shareholder cannot be blank',b'Die Felder Von Aktion\xc3\xa4r und An Anteilinhaber d\xc3\xbcrfen nicht leer sein'
+b'DocType: Tax Rule',b'Use for Shopping Cart',b'F\xc3\xbcr den Einkaufswagen verwenden'
+b'apps/erpnext/erpnext/controllers/item_variant.py +101',b'Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}',b'Wert {0} f\xc3\xbcr Attribut {1} existiert nicht in der Liste der g\xc3\xbcltigen Artikelattributwerte f\xc3\xbcr den Posten {2}'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79',b'Select Serial Numbers',b'W\xc3\xa4hlen Sie Seriennummern'
+b'DocType: BOM Item',b'Scrap %',b'Ausschuss %'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46',"b'Charges will be distributed proportionately based on item qty or amount, as per your selection'",b'Die Kosten werden gem\xc3\xa4\xc3\x9f Ihrer Wahl anteilig verteilt basierend auf Artikelmenge oder -preis'
+b'DocType: Maintenance Visit',b'Purposes',b'Zwecke'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112',b'Atleast one item should be entered with negative quantity in return document',b'Mindestens ein Artikel sollte mit negativer Menge in das R\xc3\xbcckgabedokument eingegeben werden'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71',"b'Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations'",b'Arbeitsgang {0} ist l\xc3\xa4nger als alle verf\xc3\xbcgbaren Arbeitszeiten am Arbeitsplatz {1}. Bitte den Vorgang in mehrere Teilarbeitsg\xc3\xa4nge aufteilen.'
+b'DocType: Membership',b'Membership Status',b'Mitgliedsstatus'
+,b'Requested',b'Angefordert'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93',b'No Remarks',b'Keine Anmerkungen'
+b'DocType: Asset',b'In Maintenance',b'In Wartung'
+b'DocType: Purchase Invoice',b'Overdue',b'\xc3\x9cberf\xc3\xa4llig'
+b'DocType: Account',b'Stock Received But Not Billed',"b'Empfangener, aber nicht berechneter Lagerbestand'"
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +84',b'Root Account must be a group',b'Root-Konto muss eine Gruppe sein'
+b'DocType: Drug Prescription',b'Drug Prescription',b'Medikament Rezept'
+b'DocType: Fees',b'FEE.',b'GEB\xc3\x9cHR.'
+b'DocType: Employee Loan',b'Repaid/Closed',b'Vergolten / Geschlossen'
+b'DocType: Item',b'Total Projected Qty',b'Prognostizierte Gesamtmenge'
+b'DocType: Monthly Distribution',b'Distribution Name',b'Bezeichnung der Verteilung'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +477',"b'Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry'","b'Bewertungsrate, die f\xc3\xbcr die Position {0} nicht gefunden wurde, die f\xc3\xbcr die Buchungseintr\xc3\xa4ge f\xc3\xbcr {1} {2} erforderlich ist. Wenn die Position als Nullbewertungssatz in der {1} abgewickelt wird, erw\xc3\xa4hnen Sie bitte in der Tabelle {1}. Andernfalls erstellen Sie bitte eine eingehende Bestandsabwicklung f\xc3\xbcr die Position oder erw\xc3\xa4hnen Sie den Bewertungssatz im Positionsdatensatz und versuchen Sie dann, diesen Eintrag einzureichen'"
+b'DocType: Course',b'Course Code',b'Kursnummer'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +337',b'Quality Inspection required for Item {0}',b'Qualit\xc3\xa4tspr\xc3\xbcfung f\xc3\xbcr den Posten erforderlich {0}'
+b'DocType: POS Settings',b'Use POS in Offline Mode',b'POS im Offline-Modus verwenden'
+b'DocType: Supplier Scorecard',b'Supplier Variables',b'Lieferantenvariablen'
+b'DocType: Quotation',"b""Rate at which customer's currency is converted to company's base currency""","b'Kurs, zu dem die W\xc3\xa4hrung des Kunden in die Basisw\xc3\xa4hrung des Unternehmens umgerechnet wird'"
+b'DocType: Purchase Invoice Item',b'Net Rate (Company Currency)',b'Nettopreis (Firmenw\xc3\xa4hrung)'
+b'DocType: Salary Detail',b'Condition and Formula Help',b'Zustand und Formel-Hilfe'
+b'apps/erpnext/erpnext/config/selling.py +105',b'Manage Territory Tree.',b'Baumstruktur der Regionen verwalten'
+b'DocType: Patient Service Unit',b'Patient Service Unit',b'Patientenservice-Einheit'
+b'DocType: Journal Entry Account',b'Sales Invoice',b'Ausgangsrechnung'
+b'DocType: Journal Entry Account',b'Party Balance',b'Gruppen-Saldo'
+b'DocType: Cash Flow Mapper',b'Section Subtotal',b'Abschnitt Zwischensumme'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +498',b'Please select Apply Discount On',"b'Bitte ""Rabatt anwenden auf"" ausw\xc3\xa4hlen'"
+b'DocType: Stock Settings',b'Sample Retention Warehouse',b'Beispiel Retention Warehouse'
+b'DocType: Company',b'Default Receivable Account',b'Standard-Forderungskonto'
+b'DocType: Physician Schedule',b'Physician Schedule',b'Arzt Zeitplan'
+b'DocType: Purchase Invoice',b'Deemed Export',b'Ausgenommener Export'
+b'DocType: Stock Entry',b'Material Transfer for Manufacture',b'Material\xc3\xbcbertrag f\xc3\xbcr Herstellung'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20',b'Discount Percentage can be applied either against a Price List or for all Price List.',b'Der Rabatt-Prozentsatz kann entweder auf eine Preisliste oder auf alle Preislisten angewandt werden.'
+b'DocType: Subscription',b'Half-yearly',b'Halbj\xc3\xa4hrlich'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407',b'Accounting Entry for Stock',b'Lagerbuchung'
+b'DocType: Lab Test',b'LabTest Approver',b'LabTest Genehmiger'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61',b'You have already assessed for the assessment criteria {}.',b'Sie haben bereits f\xc3\xbcr die Bewertungskriterien beurteilt.'
+b'DocType: Vehicle Service',b'Engine Oil',b'Motor\xc3\xb6l'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1005',b'Work Orders Created: {0}',b'Arbeitsauftr\xc3\xa4ge erstellt: {0}'
+b'DocType: Sales Invoice',b'Sales Team1',b'Verkaufsteam1'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +547',b'Item {0} does not exist',b'Artikel {0} existiert nicht'
+b'DocType: Sales Invoice',b'Customer Address',b'Kundenadresse'
+b'DocType: Employee Loan',b'Loan Details',b'Darlehensdetails'
+b'DocType: Company',b'Default Inventory Account',b'Standard Inventurkonto'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192',b'The folio numbers are not matching',b'Die Folionummern stimmen nicht \xc3\xbcberein'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124',b'Row {0}: Completed Qty must be greater than zero.',b'Row {0}: Abgeschlossen Menge muss gr\xc3\xb6\xc3\x9fer als Null sein.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262',b'Payment Request for {0}',b'Zahlungsanforderung f\xc3\xbcr {0}'
+b'DocType: Item Barcode',b'Barcode Type',b'Barcode-Typ'
+b'DocType: Antibiotic',b'Antibiotic Name',b'Antibiotika-Name'
+b'DocType: Purchase Invoice',b'Apply Additional Discount On',b'Zus\xc3\xa4tzlichen Rabatt gew\xc3\xa4hren auf'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66',b'Select Type...',b'Art ausw\xc3\xa4hlen...'
+b'DocType: Crop Cycle',b'A link to all the Land Units in which the Crop is growing',"b'Eine Verkn\xc3\xbcpfung zu allen Landeinheiten, in denen die Kulturpflanze w\xc3\xa4chst'"
+b'DocType: Account',b'Root Type',b'Root-Typ'
+b'DocType: Item',b'FIFO',b'FIFO'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136',b'Row # {0}: Cannot return more than {1} for Item {2}',b'Zeile # {0}: Es kann nicht mehr als {1} f\xc3\xbcr Artikel {2} zur\xc3\xbcckgegeben werden'
+b'DocType: Item Group',b'Show this slideshow at the top of the page',b'Diese Diaschau oben auf der Seite anzeigen'
+b'DocType: BOM',b'Item UOM',b'Artikelma\xc3\x9feinheit'
+b'DocType: Sales Taxes and Charges',b'Tax Amount After Discount Amount (Company Currency)',b'Steuerbetrag nach Abzug von Rabatt (Firmenw\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177',b'Target warehouse is mandatory for row {0}',b'Eingangslager ist f\xc3\xbcr Zeile {0} zwingend erforderlich'
+b'DocType: Cheque Print Template',b'Primary Settings',b'Prim\xc3\xa4re Einstellungen'
+b'DocType: Purchase Invoice',b'Select Supplier Address',b'Lieferantenadresse ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397',b'Add Employees',b'Mitarbeiter hinzuf\xc3\xbcgen'
+b'DocType: Purchase Invoice Item',b'Quality Inspection',b'Qualit\xc3\xa4tspr\xc3\xbcfung'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196',b'Extra Small',b'Besonders klein'
+b'DocType: Company',b'Standard Template',b'Standard Template'
+b'DocType: Training Event',b'Theory',b'Theorie'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806',b'Warning: Material Requested Qty is less than Minimum Order Qty',b'Achtung : Materialanfragemenge ist geringer als die Mindestbestellmenge'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211',b'Account {0} is frozen',b'Konto {0} ist gesperrt'
+b'DocType: Company',b'Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.',"b'Juristische Person/Niederlassung mit einem separaten Kontenplan, die zum Unternehmen geh\xc3\xb6rt.'"
+b'DocType: Payment Request',b'Mute Email',b'Mute Email'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29',"b'Food, Beverage & Tobacco'","b'Lebensmittel, Getr\xc3\xa4nke und Tabak'"
+b'DocType: Account',b'Account Number',b'Kontonummer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752',b'Can only make payment against unbilled {0}',b'Zahlung kann nur zu einer noch nicht abgerechneten {0} erstellt werden'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +102',b'Commission rate cannot be greater than 100',b'Provisionssatz kann nicht gr\xc3\xb6\xc3\x9fer als 100 sein'
+b'DocType: Volunteer',b'Volunteer',b'Freiwillige'
+b'DocType: Stock Entry',b'Subcontract',b'Zulieferer'
+b'apps/erpnext/erpnext/public/js/utils/party.js +166',b'Please enter {0} first',b'Bitte geben Sie zuerst {0} ein'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104',b'No replies from',b'Keine Antworten'
+b'DocType: Work Order Operation',b'Actual End Time',b'Tats\xc3\xa4chliche Endzeit'
+b'DocType: Item',b'Manufacturer Part Number',b'Herstellernummer'
+b'DocType: Work Order Operation',b'Estimated Time and Cost',b'Gesch\xc3\xa4tzte Zeit und Kosten'
+b'DocType: Bin',b'Bin',b'Lagerfach'
+b'DocType: Crop',b'Crop Name',b'Name der Frucht'
+b'DocType: SMS Log',b'No of Sent SMS',b'Anzahl abgesendeter SMS'
+b'DocType: Antibiotic',b'Healthcare Administrator',b'Gesundheitswesen Administrator'
+b'apps/erpnext/erpnext/utilities/user_progress.py +47',b'Set a Target',b'Ziel setzen'
+b'DocType: Dosage Strength',b'Dosage Strength',b'Dosierungsst\xc3\xa4rke'
+b'DocType: Account',b'Expense Account',b'Aufwandskonto'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49',b'Software',b'Software'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203',b'Colour',b'Farbe'
+b'DocType: Assessment Plan Criteria',b'Assessment Plan Criteria',b'Kriterien des Beurteilungsplans'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +118',b'Expiry date is mandatory for selected item',b'Das Verfallsdatum ist f\xc3\xbcr den ausgew\xc3\xa4hlten Artikel obligatorisch'
+b'DocType: Supplier Scorecard Scoring Standing',b'Prevent Purchase Orders',b'Vermeidung von Bestellungen'
+b'apps/erpnext/erpnext/healthcare/setup.py +258',b'Susceptible',b'Anf\xc3\xa4llig'
+b'DocType: Patient Appointment',b'Scheduled',b'Geplant'
+b'apps/erpnext/erpnext/config/buying.py +18',b'Request for quotation.',b'Angebotsanfrage.'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13',"b'Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle'","b'Bitte einen Artikel ausw\xc3\xa4hlen, bei dem ""Ist Lagerartikel"" mit ""Nein"" und ""Ist Verkaufsartikel"" mit ""Ja"" bezeichnet ist, und es kein anderes Produkt-Bundle gibt'"
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148',b'Select Customer',b'Kunden ausw\xc3\xa4hlen'
+b'DocType: Student Log',b'Academic',b'akademisch'
+b'DocType: Patient',b'Personal and Social History',b'Pers\xc3\xb6nliche und gesellschaftliche Geschichte'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51',b'User {0} created',b'Benutzer {0} erstellt'
+b'DocType: Fee Schedule',b'Fee Breakup for each student',b'Fee Breakup f\xc3\xbcr jeden Sch\xc3\xbcler'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +541',b'Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2})',b'Insgesamt Voraus ({0}) gegen Bestellen {1} kann nicht gr\xc3\xb6\xc3\x9fer sein als die Gesamtsumme ({2})'
+b'DocType: Sales Partner',b'Select Monthly Distribution to unevenly distribute targets across months.',"b'Bitte ""Monatsweise Verteilung"" w\xc3\xa4hlen, um Ziele ungleichm\xc3\xa4\xc3\x9fig \xc3\xbcber Monate zu verteilen.'"
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78',b'Change Code',b'Code \xc3\xa4ndern'
+b'DocType: Purchase Invoice Item',b'Valuation Rate',b'Wertansatz'
+b'DocType: Stock Reconciliation',b'SR/',b'SR /'
+b'DocType: Vehicle',b'Diesel',b'Diesel'
+b'apps/erpnext/erpnext/stock/get_item_details.py +388',b'Price List Currency not selected',b'Preislistenw\xc3\xa4hrung nicht ausgew\xc3\xa4hlt'
+b'DocType: Purchase Invoice',b'Availed ITC Cess',b'Erreichte ITC Cess'
+,b'Student Monthly Attendance Sheet',b'Sch\xc3\xbclermonatsanwesenheits'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96',b'Shipping rule only applicable for Selling',b'Versandregel gilt nur f\xc3\xbcr den Verkauf'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30',b'Project Start Date',b'Startdatum des Projekts'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23',b'Until',b'Bis'
+b'DocType: Rename Tool',b'Rename Log',b'Protokoll umbenennen'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Student Group oder Kursplan ist Pflicht'
+b'DocType: HR Settings',b'Maintain Billing Hours and Working Hours Same on Timesheet',b'Pflegen Abrechnungszeiten und Arbeitszeiten Same auf Stundenzettel'
+b'DocType: Maintenance Visit Purpose',b'Against Document No',b'Zu Dokument Nr.'
+b'DocType: BOM',b'Scrap',b'Abfall / Ausschuss'
+b'apps/erpnext/erpnext/utilities/user_progress.py +217',b'Go to Instructors',b'Gehen Sie zu Instruktoren'
+b'apps/erpnext/erpnext/config/selling.py +110',b'Manage Sales Partners.',b'Vertriebspartner verwalten'
+b'DocType: Quality Inspection',b'Inspection Type',b'Art der Pr\xc3\xbcfung'
+b'DocType: Fee Validity',b'Visited yet',b'Besucht noch'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134',b'Warehouses with existing transaction can not be converted to group.',b'Lagerh\xc3\xa4user mit bestehenden Transaktion nicht zu einer Gruppe umgewandelt werden.'
+b'DocType: Assessment Result Tool',b'Result HTML',b'Ergebnis HTML'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35',b'Expires On',b'Verf\xc3\xa4llt am'
+b'apps/erpnext/erpnext/utilities/activation.py +117',b'Add Students',b'Sch\xc3\xbcler hinzuf\xc3\xbcgen'
+b'apps/erpnext/erpnext/public/js/utils.js +270',b'Please select {0}',b'Bitte {0} ausw\xc3\xa4hlen'
+b'DocType: C-Form',b'C-Form No',b'Kontakt-Formular-Nr.'
+b'DocType: BOM',b'Exploded_items',b'Aufgel\xc3\xb6ste Artikel'
+b'apps/erpnext/erpnext/utilities/user_progress.py +139',b'List your products or services that you buy or sell.',"b'Liste Ihrer Produkte oder Dienstleistungen, die Sie kaufen oder verkaufen.'"
+b'DocType: Water Analysis',b'Storage Temperature',b'Lagertemperatur'
+b'DocType: Employee Attendance Tool',b'Unmarked Attendance',b'Unmarkierte Teilnahme'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137',b'Researcher',b'Wissenschaftler'
+b'DocType: Program Enrollment Tool Student',b'Program Enrollment Tool Student',b'Programm-Enrollment-Tool Studenten'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16',b'Start date should be less than end date for task {0}',b'Startdatum sollte weniger als Enddatum f\xc3\xbcr Aufgabe {0} sein'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25',b'Name or Email is mandatory',b'Name oder E-Mail-Adresse ist zwingend erforderlich'
+b'DocType: Member',b'MEM-',b'MEM-'
+b'DocType: Instructor',b'Instructor Log',b'Kursleiterprotokoll'
+b'DocType: Purchase Order Item',b'Returned Qty',b'Zur\xc3\xbcckgegebene Menge'
+b'DocType: Student',b'Exit',b'Verlassen'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +156',b'Root Type is mandatory',b'Root-Typ ist zwingend erforderlich'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29',b'Failed to install presets',b'Fehler beim Installieren der Voreinstellungen'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44',"b'{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.'","b'{0} hat derzeit eine {1} Supplier Scorecard stehen, und Anfragen an diesen Lieferanten sollten mit Vorsicht ausgegeben werden.'"
+b'DocType: Chapter',b'Non Profit Manager',b'Non-Profit-Manager'
+b'DocType: BOM',b'Total Cost(Company Currency)',b'Gesamtkosten (Gesellschaft W\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315',b'Serial No {0} created',b'Seriennummer {0} erstellt'
+b'DocType: Homepage',b'Company Description for website homepage',b'Firmen-Beschreibung f\xc3\xbcr Internet-Homepage'
+b'DocType: Item Customer Detail',"b'For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes'","b'Zum Vorteil f\xc3\xbcr die Kunden, k\xc3\xb6nnen diese Kodes in Druckformaten wie Rechnungen und Lieferscheinen verwendet werden'"
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18',b'Suplier Name',b'suplier Namen'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +174',b'Could not retrieve information for {0}.',b'Informationen f\xc3\xbcr {0} konnten nicht abgerufen werden.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134',b'Opening Entry Journal',b'Er\xc3\xb6ffnungseintragsjournal'
+b'DocType: Sales Invoice',b'Time Sheet List',b'Zeitblatt Liste'
+b'DocType: Employee',b'You can enter any date manually',b'Sie k\xc3\xb6nnen jedes Datum manuell eingeben'
+b'DocType: Healthcare Settings',b'Result Printed',b'Ergebnis Gedruckt'
+b'DocType: Asset Category Account',b'Depreciation Expense Account',b'Aufwandskonto Abschreibungen'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233',b'Probationary Period',b'Probezeit'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32',b'View {0}',b'Ansicht {0}'
+b'DocType: Customer Group',b'Only leaf nodes are allowed in transaction',b'In dieser Transaktion sind nur Unterknoten erlaubt'
+b'DocType: Project',b'Total Costing Amount (via Timesheets)',b'Gesamtkalkulationsbetrag (\xc3\xbcber Arbeitszeittabellen)'
+b'DocType: Employee Advance',b'Expense Approver',b'Ausgabenbewilliger'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136',b'Row {0}: Advance against Customer must be credit',b'Row {0}: Voraus gegen Kunde muss Kredit'
+b'DocType: Project',b'Hourly',b'St\xc3\xbcndlich'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +89',b'Non-Group to Group',b'Non-Group-Gruppe'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Batch ist obligatorisch in Zeile {0}'
+b'DocType: Purchase Receipt Item Supplied',b'Purchase Receipt Item Supplied',b'Kaufbeleg-Artikel geliefert'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'To Datetime',b'Bis Datum und Uhrzeit'
+b'apps/erpnext/erpnext/config/selling.py +302',b'Logs for maintaining sms delivery status',b'Protokolle \xc3\xbcber den SMS-Versand'
+b'DocType: Accounts Settings',b'Make Payment via Journal Entry',b'Zahlung \xc3\xbcber Journaleintrag'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +223',b'Printed On',b'Gedruckt auf'
+b'DocType: Item',b'Inspection Required before Delivery',b'Inspektion Notwendige vor der Auslieferung'
+b'DocType: Item',b'Inspection Required before Purchase',"b'Inspektion erforderlich, bevor Kauf'"
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93',b'Pending Activities',b'Ausstehende Aktivit\xc3\xa4ten'
+b'DocType: Patient Appointment',b'Reminded',b'Erinnert'
+b'DocType: Patient',b'PID-',b'PID-'
+b'DocType: Chapter Member',b'Chapter Member',b'Gruppen-Mitglied'
+b'DocType: Material Request Plan Item',b'Minimum Order Quantity',b'Mindestbestellmenge'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +106',b'Your Organization',b'Ihre Organisation'
+b'DocType: Fee Component',b'Fees Category',b'Geb\xc3\xbchren Kategorie'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +134',b'Please enter relieving date.',b'Bitte Freistellungsdatum eingeben.'
+b'apps/erpnext/erpnext/controllers/trends.py +149',b'Amt',b'Menge'
+b'DocType: Supplier Scorecard',b'Notify Employee',b'Mitarbeiter benachrichtigen'
+b'DocType: Opportunity',b'Enter name of campaign if source of enquiry is campaign',"b'Namen der Kampagne eingeben, wenn der Ursprung der Anfrage eine Kampagne ist'"
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38',b'Newspaper Publishers',b'Zeitungsverleger'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30',b'Select Fiscal Year',b'Gesch\xc3\xa4ftsjahr ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115',b'Expected Delivery Date should be after Sales Order Date',b'Voraussichtlicher Liefertermin sollte nach Kundenauftragsdatum erfolgen'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42',b'Reorder Level',b'Meldebestand'
+b'DocType: Company',b'Chart Of Accounts Template',b'Kontenvorlage'
+b'DocType: Attendance',b'Attendance Date',b'Anwesenheitsdatum'
+b'apps/erpnext/erpnext/stock/get_item_details.py +352',b'Item Price updated for {0} in Price List {1}',b'Artikel Preis aktualisiert f\xc3\xbcr {0} in der Preisliste {1}'
+b'DocType: Salary Structure',b'Salary breakup based on Earning and Deduction.',b'Gehaltsaufteilung nach Einkommen und Abz\xc3\xbcgen.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +128',b'Account with child nodes cannot be converted to ledger',b'Ein Konto mit Unterknoten kann nicht in ein Kontoblatt umgewandelt werden'
+b'DocType: Purchase Invoice Item',b'Accepted Warehouse',b'Annahmelager'
+b'DocType: Bank Reconciliation Detail',b'Posting Date',b'Buchungsdatum'
+b'DocType: Item',b'Valuation Method',b'Bewertungsmethode'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203',b'Mark Half Day',b'Mark Halbtages'
+b'DocType: Sales Invoice',b'Sales Team',b'Verkaufsteam'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87',b'Duplicate entry',b'Doppelter Eintrag/doppelte Buchung'
+b'DocType: Program Enrollment Tool',b'Get Students',b'Holen Studenten'
+b'DocType: Serial No',b'Under Warranty',b'Innerhalb der Garantie'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516',b'[Error]',b'[Fehler]'
+b'DocType: Sales Order',b'In Words will be visible once you save the Sales Order.',"b'""In Worten"" wird sichtbar, sobald Sie\xc2\xa0den Kundenauftrag speichern.'"
+,b'Employee Birthday',b'Mitarbeiter-Geburtstag'
+b'apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14',b'Please select Completion Date for Completed Repair',b'Bitte w\xc3\xa4hlen Sie das Abschlussdatum f\xc3\xbcr die abgeschlossene Reparatur'
+b'DocType: Student Batch Attendance Tool',b'Student Batch Attendance Tool',b'Studenten Batch Teilnahme Werkzeug'
+b'apps/erpnext/erpnext/controllers/status_updater.py +213',b'Limit Crossed',b'Grenze \xc3\xbcberschritten'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22',b'Scheduled Upto',b'Geplante bis'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55',b'Venture Capital',b'Risikokapital'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40',"b""An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.""","b'Ein Semester mit diesem ""Semesterjahr""\'{0} und ""Semesternamen\' {1} ist bereits vorhanden. Bitte \xc3\xa4ndern Sie diese entsprechend und versuchen Sie es erneut.'"
+b'DocType: UOM',b'Must be Whole Number',b'Muss eine ganze Zahl sein'
+b'DocType: Leave Control Panel',b'New Leaves Allocated (In Days)',b'Neue Urlaubszuordnung\xc2\xa0(in Tagen)'
+b'DocType: Purchase Invoice',b'Invoice Copy',b'Rechnungskopie'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49',b'Serial No {0} does not exist',b'Seriennummer {0} existiert nicht'
+b'DocType: Sales Invoice Item',b'Customer Warehouse (Optional)',b'Kundenlagerkonto (optional)'
+b'DocType: Pricing Rule',b'Discount Percentage',b'Rabatt in Prozent'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51',b'Reserved for sub contracting',b'Reserviert f\xc3\xbcr Unterauftr\xc3\xa4ge'
+b'DocType: Payment Reconciliation Invoice',b'Invoice Number',b'Rechnungsnummer'
+b'DocType: Shopping Cart Settings',b'Orders',b'Bestellungen'
+b'DocType: Employee Leave Approver',b'Leave Approver',b'Urlaubsgenehmiger'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285',b'Please select a batch',b'Bitte w\xc3\xa4hlen Sie eine Charge'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalLib',b'JournalLib'
+b'DocType: Assessment Group',b'Assessment Group Name',b'Name der Beurteilungsgruppe'
+b'DocType: Manufacturing Settings',b'Material Transferred for Manufacture',b'Material zur Herstellung \xc3\xbcbertragen'
+b'DocType: Landed Cost Item',b'Receipt Document Type',b'Receipt Dokumenttyp'
+b'DocType: Daily Work Summary Settings',b'Select Companies',b'W\xc3\xa4hlen Firmen'
+b'DocType: Antibiotic',b'Healthcare',b'Gesundheitswesen'
+b'DocType: Target Detail',b'Target Detail',b'Zieldetail'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +65',b'Single Variant',b'Einzelvariante'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24',b'All Jobs',b'Alle Jobs'
+b'DocType: Sales Order',b'% of materials billed against this Sales Order',b'% der Materialien welche zu diesem Kundenauftrag gebucht wurden'
+b'DocType: Program Enrollment',b'Mode of Transportation',b'Bef\xc3\xb6rderungsart'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49',b'Period Closing Entry',b'Periodenabschlussbuchung'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72',b'Select Department...',b'W\xc3\xa4hlen Sie Abteilung ...'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38',b'Cost Center with existing transactions can not be converted to group',b'Kostenstelle mit bestehenden Transaktionen kann nicht in eine Gruppe umgewandelt werden'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374',b'Amount {0} {1} {2} {3}',b'Menge {0} {1} {2} {3}'
+b'DocType: Account',b'Depreciation',b'Abschreibung'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102',b'The number of shares and the share numbers are inconsistent',b'Die Anzahl der Aktien und die Aktienanzahl sind inkonsistent'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49',b'Supplier(s)',b'Lieferant(en)'
+b'DocType: Employee Attendance Tool',b'Employee Attendance Tool',b'MItarbeiter-Anwesenheits-Werkzeug'
+b'DocType: Guardian Student',b'Guardian Student',b'W\xc3\xa4chter Studenten'
+b'DocType: Supplier',b'Credit Limit',b'Kreditlimit'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Selling Price List Rate',b'Durchschn. Preislistenpreis verkaufen'
+b'DocType: Salary Component',b'Salary Component',b'Gehaltskomponente'
+b'apps/erpnext/erpnext/accounts/utils.py +495',b'Payment Entries {0} are un-linked',b'Zahlungs Eintr\xc3\xa4ge {0} sind un-linked'
+b'DocType: GL Entry',b'Voucher No',b'Belegnr.'
+,b'Lead Owner Efficiency',b'Lead Besitzer Effizienz'
+b'DocType: Leave Allocation',b'Leave Allocation',b'Urlaubszuordnung'
+b'DocType: Payment Request',b'Recipient Message And Payment Details',b'Empf\xc3\xa4nger der Nachricht und Zahlungsdetails'
+b'DocType: Training Event',b'Trainer Email',b'Trainer E-Mail'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550',b'Material Requests {0} created',b'Materialanfrage {0} erstellt'
+b'DocType: Restaurant Reservation',b'No of People',b'Nein von Menschen'
+b'apps/erpnext/erpnext/config/selling.py +164',b'Template of terms or contract.',b'Vorlage f\xc3\xbcr Gesch\xc3\xa4ftsbedingungen oder Vertrag'
+b'DocType: Purchase Invoice',b'Address and Contact',b'Adresse und Kontakt'
+b'DocType: Cheque Print Template',b'Is Account Payable',b'Ist Konto zahlbar'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276',b'Stock cannot be updated against Purchase Receipt {0}',b'Auf nicht gegen Kaufbeleg aktualisiert werden {0}'
+b'DocType: Support Settings',b'Auto close Issue after 7 days',b'Auto schlie\xc3\x9fen Ausgabe nach 7 Tagen'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71',"b'Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Da der Resturlaub bereits in den zuk\xc3\xbcnftigen Datensatz f\xc3\xbcr Urlaube {1} \xc3\xbcbertragen wurde, kann der Urlaub nicht vor {0} zugeteilt werden.'"
+b'apps/erpnext/erpnext/accounts/party.py +317',b'Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)',b'Hinweis: Stichtag \xc3\xbcbersteigt das vereinbarte Zahlungsziel um {0} Tag(e)'
+b'apps/erpnext/erpnext/education/doctype/program/program.js +8',b'Student Applicant',b'Studienbewerber'
+b'DocType: Purchase Invoice',b'ORIGINAL FOR RECIPIENT',b'ORIGINAL F\xc3\x9cR EMPF\xc3\x84NGER'
+b'DocType: Asset Category Account',b'Accumulated Depreciation Account',b'Abschreibungskonto'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11',b'This email is autogenerated',b'Diese E-Mail ist automatisch generiert'
+b'DocType: Stock Settings',b'Freeze Stock Entries',b'Lagerbuchungen sperren'
+b'DocType: Program Enrollment',b'Boarding Student',b'Boarding Student'
+b'DocType: Asset',b'Expected Value After Useful Life',b'Erwartungswert nach der Ausmusterung'
+b'DocType: Item',b'Reorder level based on Warehouse',b'Meldebestand auf Basis des Lagers'
+b'DocType: Activity Cost',b'Billing Rate',b'Abrechnungsbetrag'
+,b'Qty to Deliver',b'Zu liefernde Menge'
+,b'Stock Analytics',b'Bestandsanalyse'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523',b'Operations cannot be left blank',b'Der Betrieb kann nicht leer sein'
+b'DocType: Maintenance Visit Purpose',b'Against Document Detail No',b'Zu Dokumentendetail Nr.'
+b'apps/erpnext/erpnext/regional/__init__.py +11',b'Deletion is not permitted for country {0}',b'Das L\xc3\xb6schen ist f\xc3\xbcr das Land {0} nicht zul\xc3\xa4ssig.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110',b'Party Type is mandatory',b'Party-Typ ist Pflicht'
+b'DocType: Quality Inspection',b'Outgoing',b'Ausgang'
+b'DocType: Material Request',b'Requested For',b'Angefordert f\xc3\xbcr'
+b'DocType: Quotation Item',b'Against Doctype',b'Zu DocType'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +404',b'{0} {1} is cancelled or closed',b'{0} {1} wurde abgebrochen oder geschlossen'
+b'DocType: Asset',b'Calculate Depreciation',b'Abschreibung berechnen'
+b'DocType: Delivery Note',b'Track this Delivery Note against any Project',b'Diesen Lieferschein in jedem Projekt nachverfolgen'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35',b'Net Cash from Investing',b'Nettocashflow aus Investitionen'
+b'DocType: Work Order',b'Work-in-Progress Warehouse',b'Fertigungslager'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111',b'Asset {0} must be submitted',b'Verm\xc3\xb6gen {0} muss eingereicht werden'
+b'DocType: Fee Schedule Program',b'Total Students',b'Insgesamt Studenten'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56',b'Attendance Record {0} exists against Student {1}',b'Besucherrekord {0} existiert gegen Studenten {1}'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354',b'Reference #{0} dated {1}',b'Referenz #{0} vom {1}'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164',b'Depreciation Eliminated due to disposal of assets',b'Die Abschreibungen Ausgeschieden aufgrund der Ver\xc3\xa4u\xc3\x9ferung von Verm\xc3\xb6genswerten'
+b'DocType: Member',b'Member',b'Mitglied'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15',b'Manage Addresses',b'Adressen verwalten'
+b'DocType: Work Order Item',b'Work Order Item',b'Arbeitsauftragsposition'
+b'DocType: Pricing Rule',b'Item Code',b'Artikelabk\xc3\xbcrzung'
+b'DocType: Serial No',b'Warranty / AMC Details',b'Details der Garantie / des j\xc3\xa4hrlichen Wartungsvertrags'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',b'W\xc3\xa4hlen Sie die Sch\xc3\xbcler manuell f\xc3\xbcr die aktivit\xc3\xa4tsbasierte Gruppe aus'
+b'DocType: Journal Entry',b'User Remark',b'Benutzerbemerkung'
+b'DocType: Lead',b'Market Segment',b'Marktsegment'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Manager',b'Landwirtschaftsmanager'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966',b'Paid Amount cannot be greater than total negative outstanding amount {0}',b'Gezahlten Betrag kann nicht gr\xc3\xb6\xc3\x9fer sein als die Gesamt negativ ausstehenden Betrag {0}'
+b'DocType: Supplier Scorecard Period',b'Variables',b'Variablen'
+b'DocType: Employee Internal Work History',b'Employee Internal Work History',b'Interne Berufserfahrung des Mitarbeiters'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249',b'Closing (Dr)',b'Schlu\xc3\x9fstand (Soll)'
+b'DocType: Cheque Print Template',b'Cheque Size',b'Scheck Gr\xc3\xb6\xc3\x9fe'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232',b'Serial No {0} not in stock',b'Seriennummer {0} ist nicht auf Lager'
+b'apps/erpnext/erpnext/config/selling.py +169',b'Tax template for selling transactions.',b'Steuervorlage f\xc3\xbcr Verkaufstransaktionen'
+b'DocType: Sales Invoice',b'Write Off Outstanding Amount',b'Offenen Betrag abschreiben'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27',b'Account {0} does not match with Company {1}',b'Konto {0} stimmt nicht mit der Firma {1} \xc3\xbcberein'
+b'DocType: Education Settings',b'Current Academic Year',b'Laufendes akademisches Jahr'
+b'DocType: Stock Settings',b'Default Stock UOM',b'Standardlagerma\xc3\x9feinheit'
+b'DocType: Asset',b'Number of Depreciations Booked',b'Anzahl der gebuchten Abschreibungen'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +71',b'Qty Total',b'Menge Gesamt'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32',b'Against Employee Loan: {0}',b'Gegen Mitarbeiterdarlehen: {0}'
+b'DocType: Landed Cost Item',b'Receipt Document',b'Eingangsbeleg'
+b'DocType: Employee Education',b'School/University',b'Schule/Universit\xc3\xa4t'
+b'DocType: Payment Request',b'Reference Details',b'Referenzdetails'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +56',b'Expected Value After Useful Life must be less than Gross Purchase Amount',b'Erwartungswert nach der Ausmusterung muss kleiner sein als Bruttokaufbetrag'
+b'DocType: Sales Invoice Item',b'Available Qty at Warehouse',b'Verf\xc3\xbcgbarer Lagerbestand'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Billed Amount',b'Rechnungsbetrag'
+b'DocType: Share Transfer',b'(including)',b'(einschlie\xc3\x9flich)'
+b'DocType: Asset',b'Double Declining Balance',b'Doppelte degressive'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180',b'Closed order cannot be cancelled. Unclose to cancel.',b'Geschlosser Auftrag kann nicht abgebrochen werden. Bitte  wiederer\xc3\xb6ffnen um abzubrechen.'
+b'DocType: Student Guardian',b'Father',b'Vater'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +627',"b""'Update Stock' cannot be checked for fixed asset sale""","b""Beim Verkauf von Anlageverm\xc3\xb6gen darf 'Lagerbestand aktualisieren' nicht ausgew\xc3\xa4hlt sein."""
+b'DocType: Bank Reconciliation',b'Bank Reconciliation',b'Kontenabgleich'
+b'DocType: Attendance',b'On Leave',b'Im Urlaub'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7',b'Get Updates',b'Updates abholen'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96',b'{0} {1}: Account {2} does not belong to Company {3}',b'{0} {1}: Konto {2} geh\xc3\xb6rt nicht zur Firma {3}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +397',b'Select at least one value from each of the attributes.',b'W\xc3\xa4hlen Sie mindestens einen Wert f\xc3\xbcr jedes der Attribute aus.'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166',b'Material Request {0} is cancelled or stopped',b'Materialanfrage {0} wird storniert oder gestoppt'
+b'apps/erpnext/erpnext/config/hr.py +314',b'Leave Management',b'Urlaube verwalten'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +118',b'Group by Account',b'Gruppieren nach Konto'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21',b'Please select Employee',b'Bitte w\xc3\xa4hlen Sie Mitarbeiter'
+b'DocType: Sales Order',b'Fully Delivered',b'Komplett geliefert'
+b'DocType: Lead',b'Lower Income',b'Niedrigeres Einkommen'
+b'DocType: Restaurant Order Entry',b'Current Order',b'Aktueller Auftrag'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196',b'Source and target warehouse cannot be same for row {0}',b'Ausgangs- und Eingangslager k\xc3\xb6nnen nicht gleich sein f\xc3\xbcr die Zeile {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243',"b'Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry'","b'Differenzkonto muss ein Verm\xc3\xb6gens-/Verbindlichkeiten-Konto sein, da dieser Lagerabgleich eine Er\xc3\xb6ffnungsbuchung ist'"
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107',b'Disbursed Amount cannot be greater than Loan Amount {0}',b'Zahlter Betrag kann nicht gr\xc3\xb6\xc3\x9fer sein als Darlehensbetrag {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +176',b'Go to Programs',b'Gehen Sie zu Programme'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205',b'Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}',b'Zeile {0} # Der zugewiesene Betrag {1} darf nicht gr\xc3\xb6\xc3\x9fer sein als der nicht beanspruchte Betrag {2}'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89',b'Purchase Order number required for Item {0}',b'Lieferantenauftragsnummer ist f\xc3\xbcr den Artikel {0} erforderlich'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18',"b""'From Date' must be after 'To Date'""","b'""Von-Datum"" muss nach ""Bis-Datum"" liegen'"
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39',b'Cannot change status as student {0} is linked with student application {1}',b'Kann nicht den Status als Student \xc3\xa4ndern {0} ist mit Studenten Anwendung verkn\xc3\xbcpft {1}'
+b'DocType: Asset',b'Fully Depreciated',b'vollst\xc3\xa4ndig abgeschriebene'
+b'DocType: Item Barcode',b'UPC-A',b'UPC-A'
+,b'Stock Projected Qty',b'Prognostizierte Lagerbestandsmenge'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444',b'Customer {0} does not belong to project {1}',b'Customer {0} geh\xc3\xb6rt nicht zum Projekt {1}'
+b'DocType: Employee Attendance Tool',b'Marked Attendance HTML',b'Marked Teilnahme HTML'
+b'apps/erpnext/erpnext/utilities/activation.py +73',"b'Quotations are proposals, bids you have sent to your customers'",b'Angebote sind Offerten an einen Kunden zur Lieferung von Materialien bzw. zur Erbringung von Leistungen.'
+b'DocType: Sales Invoice',"b""Customer's Purchase Order""",b'Kundenauftrag'
+b'DocType: Consultation',b'Patient',b'Patient'
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47',b'Bypass credit check at Sales Order ',b'Kreditpr\xc3\xbcfung im Kundenauftrag umgehen'
+b'DocType: Land Unit',b'Check if it is a hydroponic unit',"b'\xc3\x9cberpr\xc3\xbcfen Sie, ob es sich um eine hydroponische Einheit handelt'"
+b'apps/erpnext/erpnext/config/stock.py +109',b'Serial No and Batch',b'Seriennummer und Chargen'
+b'DocType: Warranty Claim',b'From Company',b'Von Firma'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52',b'Sum of Scores of Assessment Criteria needs to be {0}.',b'Die Summe der Ergebnisse von Bewertungskriterien muss {0} sein.'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +77',b'Please set Number of Depreciations Booked',b'Bitte setzen Sie Anzahl der Abschreibungen gebucht'
+b'DocType: Supplier Scorecard Period',b'Calculations',b'Berechnungen'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86',b'Value or Qty',b'Wert oder Menge'
+b'DocType: Payment Terms Template',b'Payment Terms',b'Zahlungsbedingungen'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449',b'Productions Orders cannot be raised for:',b'Fertigungsauftr\xc3\xa4ge k\xc3\xb6nnen nicht angehoben werden:'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Minute',b'Minute'
+b'DocType: Purchase Invoice',b'Purchase Taxes and Charges',b'Einkaufsteuern und -abgaben'
+b'DocType: Chapter',b'Meetup Embed HTML',b'Meetup HTML einbetten'
+b'apps/erpnext/erpnext/utilities/user_progress.py +121',b'Go to Suppliers',b'Gehen Sie zu Lieferanten'
+,b'Qty to Receive',b'Anzunehmende Menge'
+b'DocType: Leave Block List',b'Leave Block List Allowed',b'Urlaubssperrenliste zugelassen'
+b'DocType: Grading Scale Interval',b'Grading Scale Interval',b'Notenskala Interval'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49',b'Expense Claim for Vehicle Log {0}',b'Kostenabrechnung f\xc3\xbcr Fahrzeug Log {0}'
+b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Rabatt (%) auf Preisliste Rate mit Margin'
+b'apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59',b'All Warehouses',b'Alle Lagerh\xc3\xa4user'
+b'DocType: Sales Partner',b'Retailer',b'Einzelh\xc3\xa4ndler'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115',b'Credit To account must be a Balance Sheet account',b'Habenkonto muss ein Bilanzkonto sein'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118',b'All Supplier Types',b'Alle Lieferantentypen'
+b'DocType: Donor',b'Donor',b'Spender'
+b'DocType: Global Defaults',b'Disable In Words',"b'""Betrag in Worten"" abschalten'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +60',b'Item Code is mandatory because Item is not automatically numbered',"b'Artikelnummer ist zwingend erforderlich, da der Artikel nicht automatisch nummeriert wird'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98',b'Quotation {0} not of type {1}',b'Angebot {0} nicht vom Typ {1}'
+b'DocType: Maintenance Schedule Item',b'Maintenance Schedule Item',b'Wartungsplanposten'
+b'DocType: Sales Order',b'%  Delivered',b'%  geliefert'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.js +105',b'Please set the Email ID for the Student to send the Payment Request',"b'Bitte legen Sie die E-Mail-ID f\xc3\xbcr den Studenten an, um die Zahlungsanfrage zu senden'"
+b'DocType: Patient',b'Medical History',b'Krankengeschichte'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157',b'Bank Overdraft Account',b'Kontokorrentkredit-Konto'
+b'DocType: Patient',b'Patient ID',b'Patienten-ID'
+b'DocType: Physician Schedule',b'Schedule Name',b'Planungsname'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48',b'Make Salary Slip',b'Gehaltsabrechnung erstellen'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840',b'Add All Suppliers',b'Alle Lieferanten hinzuf\xc3\xbcgen'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94',b'Row #{0}: Allocated Amount cannot be greater than outstanding amount.',b'Zeile # {0}: Zugeordneter Betrag darf nicht gr\xc3\xb6\xc3\x9fer als ausstehender Betrag sein.'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75',b'Browse BOM',b'St\xc3\xbcckliste durchsuchen'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155',b'Secured Loans',b'Gedeckte Kredite'
+b'DocType: Purchase Invoice',b'Edit Posting Date and Time',b'Buchungsdatum und -uhrzeit bearbeiten'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101',b'Please set Depreciation related Accounts in Asset Category {0} or Company {1}',b'Bitte setzen Abschreibungen im Zusammenhang mit Konten in der Anlagekategorie {0} oder Gesellschaft {1}'
+b'DocType: Lab Test Groups',b'Normal Range',b'Normalbereich'
+b'DocType: Academic Term',b'Academic Year',b'Schuljahr'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Available Selling',b'Verf\xc3\xbcgbarer Verkauf'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169',b'Opening Balance Equity',b'Anfangsstand Eigenkapital'
+b'DocType: Lead',b'CRM',b'CRM'
+b'DocType: Purchase Invoice',b'N',b'N'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175',b'Remaining',b'Verbleibend'
+b'DocType: Appraisal',b'Appraisal',b'Bewertung'
+b'DocType: Purchase Invoice',b'GST Details',b'GST Details'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156',b'Email sent to supplier {0}',b'E-Mail an Lieferanten versandt {0}'
+b'DocType: Item',b'Default Sales Unit of Measure',b'Default Sales Ma\xc3\x9feinheit'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9',b'Academic Year: ',b'Akademisches Jahr:'
+b'DocType: Opportunity',b'OPTY-',b'CHNC-'
+b'apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19',b'Date is repeated',b'Ereignis wiederholen'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27',b'Authorized Signatory',b'Zeichnungsberechtigte/-r'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64',b'Create Fees',b'Geb\xc3\xbchren anlegen'
+b'DocType: Project',b'Total Purchase Cost (via Purchase Invoice)',b'Summe Einkaufskosten (\xc3\xbcber Einkaufsrechnung)'
+b'DocType: Training Event',b'Start Time',b'Startzeit'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400',b'Select Quantity',b'Menge w\xc3\xa4hlen'
+b'DocType: Customs Tariff Number',b'Customs Tariff Number',b'Zolltarifnummer'
+b'DocType: Patient Appointment',b'Patient Appointment',b'Patiententermin'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34',b'Approving Role cannot be same as role the rule is Applicable To',"b'Genehmigende Rolle kann nicht dieselbe Rolle sein wie diejenige, auf die die Regel anzuwenden ist'"
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64',b'Unsubscribe from this Email Digest',b'Abmelden von diesem E-Mail-Bericht'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830',b'Get Suppliers By',b'Holen Sie sich Lieferanten durch'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173',b'{0} not found for Item {1}',b'{0} f\xc3\xbcr Artikel {1} nicht gefunden'
+b'apps/erpnext/erpnext/utilities/user_progress.py +197',b'Go to Courses',b'Gehen Sie zu den Kursen'
+b'DocType: Accounts Settings',b'Show Inclusive Tax In Print',b'Inklusivsteuer im Druck anzeigen'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17',"b'Bank Account, From Date and To Date are Mandatory'","b'Bankkonto, Von Datum und Bis sind obligatorisch'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28',b'Message Sent',b'Mitteilung gesendet'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +98',b'Account with child nodes cannot be set as ledger',b'Konto mit untergeordneten Knoten kann nicht als Hauptbuch festgelegt werden'
+b'DocType: C-Form',b'II',b'II'
+b'DocType: Sales Invoice',"b""Rate at which Price list currency is converted to customer's base currency""","b'Kurs, zu dem die W\xc3\xa4hrung der Preisliste in die Basisw\xc3\xa4hrung des Kunden umgerechnet wird'"
+b'DocType: Purchase Invoice Item',b'Net Amount (Company Currency)',b'Nettobetrag (Firmenw\xc3\xa4hrung)'
+b'DocType: Physician',b'Physician Schedules',b'Arzt Termine'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215',b'Total advance amount cannot be greater than total sanctioned amount',b'Der gesamte Vorschussbetrag darf nicht h\xc3\xb6her sein als der Gesamtbetrag der Sanktion'
+b'DocType: Salary Slip',b'Hour Rate',b'Stundensatz'
+b'DocType: Stock Settings',b'Item Naming By',b'Artikelbezeichnung nach'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46',b'Another Period Closing Entry {0} has been made after {1}',b'Eine weitere Periodenabschlussbuchung {0} wurde nach {1} erstellt'
+b'DocType: Work Order',b'Material Transferred for Manufacturing',b'Material zur Herstellung \xc3\xbcbertragen'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41',b'Account {0} does not exists',b'Konto {0} existiert nicht'
+b'DocType: Project',b'Project Type',b'Projekttyp'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +153',b'Child Task exists for this Task. You can not delete this Task.',b'Untergeordnete Aufgabe existiert f\xc3\xbcr diese Aufgabe. Sie k\xc3\xb6nnen diese Aufgabe nicht l\xc3\xb6schen.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'DateLet',b'DateLet'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16',b'Either target qty or target amount is mandatory.',b'Entweder Zielst\xc3\xbcckzahl oder Zielmenge ist zwingend erforderlich.'
+b'apps/erpnext/erpnext/config/projects.py +56',b'Cost of various activities',b'Aufwendungen f\xc3\xbcr verschiedene T\xc3\xa4tigkeiten'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60',"b'Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}'","b'Einstellen Events auf {0}, da die Mitarbeiter auf die beigef\xc3\xbcgten unter Verkaufs Personen keine Benutzer-ID {1}'"
+b'DocType: Timesheet',b'Billing Details',b'Rechnungsdetails'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163',b'Source and target warehouse must be different',b'Quell- und Ziel-Warehouse m\xc3\xbcssen unterschiedlich sein'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140',b'Payment Failed. Please check your GoCardless Account for more details',b'Bezahlung fehlgeschlagen. Bitte \xc3\xbcberpr\xc3\xbcfen Sie Ihr GoCardless Konto f\xc3\xbcr weitere Details'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101',b'Not allowed to update stock transactions older than {0}',b'Aktualisierung von Transaktionen \xc3\xa4lter als {0} nicht erlaubt'
+b'DocType: BOM',b'Inspection Required',b'Pr\xc3\xbcfung erforderlich'
+b'DocType: Purchase Invoice Item',b'PR Detail',b'PR-Detail'
+b'DocType: Driving License Category',b'Class',b'Klasse'
+b'DocType: Sales Order',b'Fully Billed',b'Voll berechnet'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426',b'Work Order cannot be raised against a Item Template',b'Arbeitsauftrag kann nicht gegen eine Artikelbeschreibungsvorlage ausgel\xc3\xb6st werden'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101',b'Shipping rule only applicable for Buying',b'Versandregel gilt nur f\xc3\xbcr den Einkauf'
+b'DocType: Vital Signs',b'BMI',b'BMI'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20',b'Cash In Hand',b'Barmittel'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137',b'Delivery warehouse required for stock item {0}',b'Auslieferungslager f\xc3\xbcr Lagerartikel {0} erforderlich'
+b'DocType: Packing Slip',b'The gross weight of the package. Usually net weight + packaging material weight. (for print)',b'Das Bruttogewicht des Pakets. Normalerweise Nettogewicht +\xc2\xa0Verpackungsgweicht. (F\xc3\xbcr den Ausdruck)'
+b'DocType: Assessment Plan',b'Program',b'Programm'
+b'DocType: Accounts Settings',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts',b'Benutzer mit dieser Rolle sind berechtigt Konten zu sperren und  Buchungen zu gesperrten Konten zu erstellen/ver\xc3\xa4ndern'
+b'DocType: Serial No',b'Is Cancelled',b'Ist storniert'
+b'DocType: Student Group',b'Group Based On',b'Gruppe basiert auf'
+b'DocType: Journal Entry',b'Bill Date',b'Rechnungsdatum'
+b'DocType: Healthcare Settings',b'Laboratory SMS Alerts',b'Labor-SMS-Benachrichtigungen'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20',"b'Service Item,Type,frequency and expense amount are required'","b'Service-Item, Art, H\xc3\xa4ufigkeit und Kosten Betrag erforderlich'"
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45',"b'Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:'","b'Wenn es mehrere Preisregeln mit der h\xc3\xb6chsten Priorit\xc3\xa4t gibt, werden folgende interne Priorit\xc3\xa4ten angewandt:'"
+b'DocType: Plant Analysis Criteria',b'Plant Analysis Criteria',b'Anlagenanalysekriterien'
+b'DocType: Cheque Print Template',b'Cheque Height',b'Scheck H\xc3\xb6he'
+b'DocType: Supplier',b'Supplier Details',b'Lieferantendetails'
+b'DocType: Setup Progress',b'Setup Progress',b'Setup Fortschritt'
+b'DocType: Hub Settings',b'Publish Items to Hub',b'Artikel \xc3\xbcber den Hub ver\xc3\xb6ffentlichen'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35',b'From value must be less than to value in row {0}',b'Von-Wert muss weniger sein als Bis-Wert in Zeile {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182',b'Wire Transfer',b'\xc3\x9cberweisung'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92',b'Check all',b'Alle pr\xc3\xbcfen'
+,b'Issued Items Against Work Order',b'Ausgegebene Artikel gegen Arbeitsauftrag'
+b'DocType: Vehicle Log',b'Invoice Ref',b'Rechnung Ref'
+b'DocType: Company',b'Default Income Account',b'Standard-Ertragskonto'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32',b'Customer Group / Customer',b'Kundengruppe / Kunde'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37',b'Unclosed Fiscal Years Profit / Loss (Credit)',b'Unclosed Gesch\xc3\xa4ftsjahre Gewinn / Verlust (Credit)'
+b'DocType: Sales Invoice',b'Time Sheets',b'Zeitbl\xc3\xa4tter'
+b'DocType: Lab Test Template',b'Change In Item',b'\xc3\x84nderung im Artikel'
+b'DocType: Payment Gateway Account',b'Default Payment Request Message',b'Standard Payment Request Message'
+b'DocType: Item Group',b'Check this if you want to show in website',"b'Aktivieren, wenn der Inhalt auf\xc2\xa0der Webseite angezeigt werden soll'"
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338',b'Balance ({0})',b'Saldo ({0})'
+b'apps/erpnext/erpnext/config/accounts.py +134',b'Banking and Payments',b'Bank- und Zahlungsverkehr'
+,b'Welcome to ERPNext',b'Willkommen bei ERPNext'
+b'apps/erpnext/erpnext/config/learn.py +102',b'Lead to Quotation',b'Vom Lead zum Angebot'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34',b'Email Reminders will be sent to all parties with email contacts',b'E-Mail-Erinnerungen werden an alle Parteien mit E-Mail-Kontakten gesendet'
+b'DocType: Project',b'Twice Daily',b'Zweimal t\xc3\xa4glich'
+b'DocType: Patient',b'A Negative',b'Ein Negativ'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +45',b'Nothing more to show.',b'Nichts mehr zu zeigen.'
+b'DocType: Lead',b'From Customer',b'Von Kunden'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +327',b'Calls',b'Anrufe'
+b'apps/erpnext/erpnext/utilities/user_progress.py +143',b'A Product',b'Ein Produkt'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207',b'Batches',b'Chargen'
+b'apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34',b'Make Fee Schedule',b'Machen Sie Fee Schedule'
+b'DocType: Purchase Order Item Supplied',b'Stock UOM',b'Lagerma\xc3\x9feinheit'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233',b'Purchase Order {0} is not submitted',b'Lieferantenauftrag {0} wurde nicht \xc3\xbcbertragen'
+b'DocType: Vital Signs',b'Normal reference range for an adult is 16\xe2\x80\x9320 breaths/minute (RCP 2012)',b'Normaler Referenzbereich f\xc3\xbcr einen Erwachsenen ist 16-20 Atemz\xc3\xbcge / Minute (RCP 2012)'
+b'DocType: Customs Tariff Number',b'Tariff Number',b'Tarifnummer'
+b'DocType: Work Order Item',b'Available Qty at WIP Warehouse',b'Verf\xc3\xbcgbare Menge bei WIP Warehouse'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +39',b'Projected',b'Geplant'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222',b'Serial No {0} does not belong to Warehouse {1}',b'Seriennummer {0} geh\xc3\xb6rt nicht zu Lager {1}'
+b'apps/erpnext/erpnext/controllers/status_updater.py +177',b'Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0',b'Hinweis: Das System \xc3\xbcberpr\xc3\xbcft \xc3\x9cberlieferungen und \xc3\x9cberbuchungen zu Artikel {0} nicht da St\xc3\xbcckzahl oder Menge 0 sind'
+b'DocType: Notification Control',b'Quotation Message',b'Angebotsmitteilung'
+b'DocType: Employee Loan',b'Employee Loan Application',b'MItarbeiterdarlehensantrag'
+b'DocType: Issue',b'Opening Date',b'Er\xc3\xb6ffnungsdatum'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86',b'Please save the patient first',b'Bitte speichern Sie den Patienten zuerst'
+b'apps/erpnext/erpnext/education/api.py +80',b'Attendance has been marked successfully.',b'Die Teilnahme wurde erfolgreich markiert.'
+b'DocType: Program Enrollment',b'Public Transport',b'\xc3\x96ffentlicher Verkehr'
+b'DocType: Soil Texture',b'Silt Composition (%)',b'Schlammzusammensetzung (%)'
+b'DocType: Journal Entry',b'Remark',b'Bemerkung'
+b'DocType: Healthcare Settings',b'Avoid Confirmation',b'Vermeidung von Best\xc3\xa4tigung'
+b'DocType: Purchase Receipt Item',b'Rate and Amount',b'Preis und Menge'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176',b'Account Type for {0} must be {1}',b'Accounttyp f\xc3\xbcr {0} muss {1} sein'
+b'DocType: Healthcare Settings',b'Default income accounts to be used if not set in Physician to book Consultation charges.',"b'Default-Einkommen Konten verwendet werden, wenn nicht in Arzt eingestellt zu buchen Beratung Geb\xc3\xbchren.'"
+b'apps/erpnext/erpnext/config/hr.py +55',b'Leaves and Holiday',b'Urlaube und Feiertage'
+b'DocType: Education Settings',b'Current Academic Term',b'Laufendes akademische Semester'
+b'DocType: Sales Order',b'Not Billed',b'Nicht abgerechnet'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76',b'Both Warehouse must belong to same Company',b'Beide Lager m\xc3\xbcssen zur gleichen Firma geh\xc3\xb6ren'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +34',b'No contacts added yet.',b'Noch keine Kontakte hinzugef\xc3\xbcgt.'
+b'DocType: Purchase Invoice Item',b'Landed Cost Voucher Amount',b'Einstandskosten'
+,b'Item Balance (Simple)',b'Artikelguthaben (einfach)'
+b'apps/erpnext/erpnext/config/accounts.py +17',b'Bills raised by Suppliers.',b'Rechnungen von Lieferanten'
+b'DocType: POS Profile',b'Write Off Account',b'Abschreibungs-Konto'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Debit Note Amt',b'Debit Note Amt'
+b'apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5',b'Discount Amount',b'Rabattbetrag'
+b'DocType: Purchase Invoice',b'Return Against Purchase Invoice',b'Zur\xc3\xbcck zur Einkaufsrechnung'
+b'DocType: Item',b'Warranty Period (in days)',b'Garantiefrist (in Tagen)'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61',b'Failed to set defaults',b'Fehler beim Festlegen der Standardeinstellungen'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56',b'Relation with Guardian1',b'Beziehung mit Guardian1'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +786',b'Please select BOM against item {0}',b'Bitte w\xc3\xa4hlen Sie St\xc3\xbcckliste gegen Artikel {0}'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18',b'Make Invoices',b'Rechnungen erstellen'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23',b'Net Cash from Operations',b'Nettocashflow aus laufender Gesch\xc3\xa4ftst\xc3\xa4tigkeit'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26',b'Item 4',b'Position 4'
+b'DocType: Student Admission',b'Admission End Date',b'Stichtag f\xc3\xbcr Zulassungsende'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30',b'Sub-contracting',b'Zulieferung'
+b'DocType: Journal Entry Account',b'Journal Entry Account',b'Journalbuchungskonto'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3',b'Student Group',b'Student Group'
+b'DocType: Shopping Cart Settings',b'Quotation Series',b'Nummernkreis f\xc3\xbcr Angebote'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57',"b'An item exists with same name ({0}), please change the item group name or rename the item'",b'Ein Artikel mit dem gleichen Namen existiert bereits ({0}). Bitte den Namen der Artikelgruppe \xc3\xa4ndern oder den Artikel umbenennen'
+b'DocType: Soil Analysis Criteria',b'Soil Analysis Criteria',b'Kriterien f\xc3\xbcr die Bodenanalyse'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2041',b'Please select customer',b'Bitte w\xc3\xa4hlen Sie Kunde'
+b'DocType: C-Form',b'I',b'ich'
+b'DocType: Company',b'Asset Depreciation Cost Center',b'Kostenstelle f\xc3\xbcr Anlagenabschreibung'
+b'DocType: Production Plan Sales Order',b'Sales Order Date',b'Kundenauftrags-Datum'
+b'DocType: Sales Invoice Item',b'Delivered Qty',b'Gelieferte St\xc3\xbcckzahl'
+b'DocType: Assessment Plan',b'Assessment Plan',b'Beurteilungsplan'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90',b'Customer {0} is created.',b'Kunde {0} wird erstellt.'
+b'DocType: Stock Settings',b'Limit Percent',b'Limit-Prozent'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82',b' Currently no stock available in any warehouse',b'Derzeit ist kein Bestand in einem Lager verf\xc3\xbcgbar'
+,b'Payment Period Based On Invoice Date',b'Zahlungszeitraum basierend auf Rechnungsdatum'
+b'DocType: Sample Collection',b'No. of print',b'Anzahl Druck'
+b'DocType: Hotel Room Reservation Item',b'Hotel Room Reservation Item',b'Hotelzimmer-Reservierungselement'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58',b'Missing Currency Exchange Rates for {0}',b'Fehlende Wechselkurse f\xc3\xbcr {0}'
+b'DocType: Health Insurance',b'Health Insurance Name',b'Krankenversicherung Name'
+b'DocType: Assessment Plan',b'Examiner',b'Pr\xc3\xbcfer'
+b'DocType: Student',b'Siblings',b'Geschwister'
+b'DocType: Journal Entry',b'Stock Entry',b'Lagerbuchung'
+b'DocType: Payment Entry',b'Payment References',b'Bezahlung Referenzen'
+b'DocType: C-Form',b'C-FORM-',b'C-FORM-'
+b'DocType: Vehicle',b'Insurance Details',b'Versicherungsdetails'
+b'DocType: Account',b'Payable',b'Zahlbar'
+b'DocType: Share Balance',b'Share Type',b'Art der Freigabe'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113',b'Please enter Repayment Periods',b'Bitte geben Sie Laufzeiten'
+b'apps/erpnext/erpnext/shopping_cart/cart.py +378',b'Debtors ({0})',b'Schuldnern ({0})'
+b'DocType: Pricing Rule',b'Margin',b'Marge'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57',b'New Customers',b'Neue Kunden'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74',b'Gross Profit %',b'Rohgewinn %'
+b'DocType: Appraisal Goal',b'Weightage (%)',b'Gewichtung (%)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +503',b'Change POS Profile',b'\xc3\x84ndern Sie das POS-Profil'
+b'DocType: Bank Reconciliation Detail',b'Clearance Date',b'Abrechnungsdatum'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7',b'Assessment Report',b'Beurteilung'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +59',b'Gross Purchase Amount is mandatory',b'Bruttokaufbetrag ist erforderlich'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +95',b'Company name not same',b'Firmenname nicht gleich'
+b'DocType: Lead',b'Address Desc',b'Adresszusatz'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113',b'Party is mandatory',b'Partei ist obligatorisch'
+b'DocType: Journal Entry',b'JV-',b'JV-'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +712',b'Rows with duplicate due dates in other rows were found: {list}',b'Zeilen mit doppelten F\xc3\xa4lligkeitsdaten in anderen Zeilen wurden gefunden: {list}'
+b'DocType: Topic',b'Topic Name',b'Thema Name'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37',b'Atleast one of the Selling or Buying must be selected',b'Mindestens ein Eintrag aus Vertrieb oder Einkauf muss ausgew\xc3\xa4hlt werden'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290',b'Select an employee to get the employee advance.',"b'W\xc3\xa4hlen Sie einen Mitarbeiter aus, um den Mitarbeiter vorab zu erreichen.'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56',b'Please select a valid Date',b'Bitte w\xc3\xa4hle ein g\xc3\xbcltiges Datum aus'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +36',b'Select the nature of your business.',b'W\xc3\xa4hlen Sie die Art Ihres Unternehmens.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +24',b'Please setup Employee Naming System in Human Resource &gt; HR Settings',b'Bitte richten Sie das Mitarbeiterbenennungssystem in Human Resource&gt; HR Settings ein'
+b'DocType: Lab Test Template',"b'Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.'","b'Single f\xc3\xbcr Ergebnisse, die nur einen einzigen Eingang, Ergebnis UOM und Normalwert erfordern <br> Compound f\xc3\xbcr Ergebnisse, die mehrere Eingabefelder mit entsprechenden Ereignisnamen, Ergebnis-UOMs und Normalwerten erfordern <br> Beschreibend f\xc3\xbcr Tests mit mehreren Ergebniskomponenten und entsprechenden Ergebniserfassungsfeldern. <br> Gruppiert f\xc3\xbcr Testvorlagen, die eine Gruppe von anderen Testvorlagen sind. <br> Kein Ergebnis f\xc3\xbcr Tests ohne Ergebnisse. Au\xc3\x9ferdem wird kein Labortest erstellt. z.B. Sub-Tests f\xc3\xbcr gruppierte Ergebnisse.'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86',b'Row #{0}: Duplicate entry in References {1} {2}',b'Zeile # {0}: Eintrag in Referenzen {1} {2} duplizieren'
+b'apps/erpnext/erpnext/config/manufacturing.py +57',b'Where manufacturing operations are carried.',"b'Ort, an dem Arbeitsg\xc3\xa4nge der Fertigung ablaufen.'"
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18',b'As Examiner',b'Als Pr\xc3\xbcfer'
+b'DocType: Appointment Type',b'Default Duration',b'Standarddauer'
+b'DocType: Asset Movement',b'Source Warehouse',b'Ausgangslager'
+b'DocType: Installation Note',b'Installation Date',b'Datum der Installation'
+b'apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30',b'Share Ledger',b'Aktienbuch'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +606',b'Row #{0}: Asset {1} does not belong to company {2}',b'Row # {0}: Verm\xc3\xb6gens {1} geh\xc3\xb6rt nicht zur Gesellschaft {2}'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206',b'Sales Invoice {0} created',b'Verkaufsrechnung {0} erstellt'
+b'DocType: Employee',b'Confirmation Date',b'Datum best\xc3\xa4tigen'
+b'DocType: C-Form',b'Total Invoiced Amount',b'Gesamtrechnungsbetrag'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50',b'Min Qty can not be greater than Max Qty',b'Mindestmenge kann nicht gr\xc3\xb6\xc3\x9fer als Maximalmenge sein'
+b'DocType: Soil Texture',b'Silty Clay',b'Siltiger Ton'
+b'DocType: Account',b'Accumulated Depreciation',b'Kumulierte Abschreibungen'
+b'DocType: Supplier Scorecard Scoring Standing',b'Standing Name',b'Standing Name'
+b'DocType: Stock Entry',b'Customer or Supplier Details',b'Kunden- oder Lieferanten-Details'
+b'DocType: Employee Loan Application',b'Required by Date',b'Erforderlich by Date'
+b'DocType: Lead',b'Lead Owner',b'Eigent\xc3\xbcmer des Leads'
+b'DocType: Production Plan',b'Sales Orders Detail',b'Kundenauftragsdetails'
+b'DocType: Bin',b'Requested Quantity',b'die angeforderte Menge'
+b'DocType: Patient',b'Marital Status',b'Familienstand'
+b'DocType: Stock Settings',b'Auto Material Request',b'Automatische Materialanfrage'
+b'DocType: Delivery Note Item',b'Available Batch Qty at From Warehouse',b'Verf\xc3\xbcgbare Chargenmenge im Ausgangslager'
+b'DocType: Customer',b'CUST-',b'CUST-'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Idevise',b'Idevis'
+b'DocType: Salary Slip',b'Gross Pay - Total Deduction - Loan Repayment',b'Bruttolohn - Gesamtabzug - Darlehensr\xc3\xbcckzahlung'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29',b'Current BOM and New BOM can not be same',b'Aktuelle St\xc3\xbcckliste und neue St\xc3\xbcckliste k\xc3\xb6nnen nicht identisch sein'
+b'apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47',b'Salary Slip ID',b'Gehaltsabrechnung ID'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +118',b'Date Of Retirement must be greater than Date of Joining',b'Zeitpunkt der Pensionierung muss nach dem Eintrittsdatum liegen'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +68',b'Multiple Variants',b'Mehrere Varianten'
+b'DocType: Sales Invoice',b'Against Income Account',b'Zu Ertragskonto'
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +117',b'{0}% Delivered',b'{0}% geliefert'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107',b'Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).',b'Artikel {0}: Bestellmenge {1} kann nicht weniger als Mindestbestellmenge {2} (im Artikel definiert) sein.'
+b'DocType: Monthly Distribution Percentage',b'Monthly Distribution Percentage',b'Prozentuale Aufteilung der monatsweisen Verteilung'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49',b'Please login as another user.',b'Bitte melden Sie sich als anderer Benutzer an.'
+b'DocType: Daily Work Summary Group User',b'Daily Work Summary Group User',b'T\xc3\xa4gliche Arbeit Zusammenfassung Gruppenbenutzer'
+b'DocType: Territory',b'Territory Targets',b'Ziele f\xc3\xbcr die Region'
+b'DocType: Soil Analysis',b'Ca/Mg',b'Ca / Mg'
+b'DocType: Delivery Note',b'Transporter Info',b'Informationen zum Transportunternehmer'
+b'apps/erpnext/erpnext/accounts/utils.py +502',b'Please set default {0} in Company {1}',b'Bitte setzen Sie default {0} in Gesellschaft {1}'
+b'DocType: Cheque Print Template',b'Starting position from top edge',b'Ausgangsposition von der Oberkante'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33',b'Same supplier has been entered multiple times',b'Same Anbieter wurde mehrmals eingegeben'
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152',b'Gross Profit / Loss',b'Bruttogewinn / Verlust'
+,b'Warehouse wise Item Balance Age and Value',b'Lagerweise Item Balance Alter und Wert'
+b'DocType: Purchase Order Item Supplied',b'Purchase Order Item Supplied',b'Lieferantenauftrags-Artikel geliefert'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +94',b'Company Name cannot be Company',b'Firmenname kann keine Firma sein'
+b'apps/erpnext/erpnext/config/setup.py +27',b'Letter Heads for print templates.',b'Briefk\xc3\xb6pfe f\xc3\xbcr Druckvorlagen'
+b'apps/erpnext/erpnext/config/setup.py +32',b'Titles for print templates e.g. Proforma Invoice.',"b'Bezeichnungen f\xc3\xbcr Druckvorlagen, z. B. Proforma-Rechnung'"
+b'DocType: Program Enrollment',b'Walking',b'Gehen'
+b'DocType: Student Guardian',b'Student Guardian',b'Studenten W\xc3\xa4chter'
+b'DocType: Member',b'Member Name',b'Mitgliedsname'
+b'DocType: Stock Settings',b'Use Naming Series',b'Verwenden Sie die Namensreihen'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218',b'Valuation type charges can not marked as Inclusive',"b'Bewertungsart Geb\xc3\xbchren kann nicht als ""inklusive"" markiert werden'"
+b'DocType: POS Profile',b'Update Stock',b'Lagerbestand\xc2\xa0aktualisieren'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'in the subscription',b'im Abonnement'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100',b'Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.',"b'Unterschiedliche Ma\xc3\x9feinheiten f\xc3\xbcr Artikel f\xc3\xbchren zu falschen Werten f\xc3\xbcr das (Gesamt-)Nettogewicht. Es muss sicher gestellt sein, dass das Nettogewicht jedes einzelnen Artikels in der gleichen Ma\xc3\x9feinheit angegeben ist.'"
+b'DocType: Membership',b'Payment Details',b'Zahlungsdetails'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'BOM Rate',b'St\xc3\xbcckpreis'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225',"b'Stopped Work Order cannot be cancelled, Unstop it first to cancel'","b'Der angehaltene Arbeitsauftrag kann nicht abgebrochen werden. Stoppen Sie ihn zuerst, um ihn abzubrechen'"
+b'DocType: Asset',b'Journal Entry for Scrap',b'Journaleintrag f\xc3\xbcr Ausschuss'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83',b'Please pull items from Delivery Note',b'Bitte Artikel vom Lieferschein nehmen'
+b'apps/erpnext/erpnext/accounts/utils.py +472',b'Journal Entries {0} are un-linked',b'Buchungss\xc3\xa4tze {0} sind nicht verkn\xc3\xbcpft'
+b'apps/erpnext/erpnext/config/crm.py +92',"b'Record of all communications of type email, phone, chat, visit, etc.'","b'Aufzeichnung jeglicher Kommunikation vom Typ Email, Telefon, Chat, Besuch usw.'"
+b'DocType: Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing'
+b'DocType: Manufacturer',b'Manufacturers used in Items',b'Hersteller im Artikel verwendet'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +170',b'Please mention Round Off Cost Center in Company',b'Bitte Abschlusskostenstelle in Firma vermerken'
+b'DocType: Purchase Invoice',b'Terms',b'Gesch\xc3\xa4ftsbedingungen'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10',b'Select Days',b'W\xc3\xa4hlen Sie Tage'
+b'DocType: Academic Term',b'Term Name',b'Semesterbezeichnung'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332',b'Credit ({0})',b'Guthaben ({0})'
+b'DocType: Buying Settings',b'Purchase Order Required',b'Lieferantenauftrag erforderlich'
+,b'Item-wise Sales History',b'Artikelbezogene Verkaufshistorie'
+b'DocType: Expense Claim',b'Total Sanctioned Amount',b'Summe genehmigter Betr\xc3\xa4ge'
+b'DocType: Land Unit',b'Land Unit',b'Landeinheit'
+,b'Purchase Analytics',b'Einkaufsanalyse'
+b'DocType: Sales Invoice Item',b'Delivery Note Item',b'Lieferschein-Artikel'
+b'DocType: Asset Maintenance Log',b'Task',b'Aufgabe'
+b'DocType: Purchase Taxes and Charges',b'Reference Row #',b'Referenz-Zeile #'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76',b'Batch number is mandatory for Item {0}',b'Chargennummer ist zwingend erforderlich f\xc3\xbcr Artikel {0}'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13',b'This is a root sales person and cannot be edited.',b'Dies ist ein Root-Vertriebsmitarbeiter und kann nicht bearbeitet werden.'
+b'DocType: Salary Detail',"b""If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ""","b'Wenn ausgew\xc3\xa4hlt, wird der in dieser Komponente angegebene oder berechnete Wert nicht zu den Ertr\xc3\xa4gen oder Abz\xc3\xbcgen beitragen. Der Wert kann jedoch durch andere Komponenten referenziert werden, die hinzugef\xc3\xbcgt oder abgezogen werden k\xc3\xb6nnen.'"
+b'DocType: Asset Settings',b'Number of Days in Fiscal Year',b'Anzahl der Tage im Gesch\xc3\xa4ftsjahr'
+,b'Stock Ledger',b'Lagerbuch'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29',b'Rate: {0}',b'Preis: {0}'
+b'DocType: Company',b'Exchange Gain / Loss Account',b'Exchange-Gewinn / Verlustrechnung'
+b'apps/erpnext/erpnext/config/hr.py +7',b'Employee and Attendance',b'Mitarbeiter und Teilnahme'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93',b'Purpose must be one of {0}',b'Zweck muss einer von diesen sein: {0}'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100',b'Fill the form and save it',b'Formular ausf\xc3\xbcllen und speichern'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26',b'Community Forum',b'Community-Forum'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Tats\xc3\xa4chliche Menge auf Lager'
+b'DocType: Homepage',"b'URL for ""All Products""'",b'URL f\xc3\xbcr &quot;Alle Produkte&quot;'
+b'DocType: Leave Application',b'Leave Balance Before Application',b'Urlaubstage vor Antrag'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46',b'Send SMS',b'SMS verschicken'
+b'DocType: Supplier Scorecard Criteria',b'Max Score',b'Max. Ergebnis'
+b'DocType: Cheque Print Template',b'Width of amount in word',b'Breite der Menge in Wort'
+b'DocType: Company',b'Default Letter Head',b'Standardbriefkopf'
+b'DocType: Purchase Order',b'Get Items from Open Material Requests',b'Holen Sie Angebote von Material \xc3\xb6ffnen Anfragen'
+b'DocType: Hotel Room Amenity',b'Billable',b'Abrechenbar'
+b'DocType: Lab Test Template',b'Standard Selling Rate',b'Standard-Verkaufspreis'
+b'DocType: Account',b'Rate at which this tax is applied',"b'Kurs, zu dem dieser Steuersatz angewandt wird'"
+b'DocType: Cash Flow Mapper',b'Section Name',b'Abteilungsname'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77',b'Reorder Qty',b'Nachbestellmenge'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28',b'Current Job Openings',b'Laufende Stellenangebote'
+b'DocType: Company',b'Stock Adjustment Account',b'Bestandskorrektur-Konto'
+b'apps/erpnext/erpnext/public/js/payment/pos_payment.html +17',b'Write Off',b'Abschreiben'
+b'DocType: Patient Service Unit',b'Allow Overlap',b'\xc3\x9cberlappung zulassen'
+b'DocType: Timesheet Detail',b'Operation ID',b'Arbeitsgang-ID'
+b'DocType: Employee',"b'System User (login) ID. If set, it will become default for all HR forms.'","b'Systembenutzer-ID (Anmeldung). Wenn gesetzt, wird sie standardm\xc3\xa4\xc3\x9fig f\xc3\xbcr alle HR-Formulare verwendet.'"
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16',b'{0}: From {1}',b'{0}: Von {1}'
+b'DocType: Task',b'depends_on',b'h\xc3\xa4ngt ab von'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60',b'Queued for updating latest price in all Bill of Materials. It may take a few minutes.',b'Warteschlange f\xc3\xbcr die Aktualisierung der neuesten Preis in allen St\xc3\xbcckliste. Es kann einige Minuten dauern.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26',"b""Name of new Account. Note: Please don't create accounts for Customers and Suppliers""",b'Name des neuen Kontos. Hinweis: Bitte keine Konten f\xc3\xbcr Kunden und Lieferanten erstellen'
+b'apps/erpnext/erpnext/config/setup.py +37',b'Country wise default Address Templates',b'Landesspezifische Standard-Adressvorlagen'
+b'DocType: Water Analysis',b'Appearance',b'Aussehen'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Buying Price List Rate',b'Durchschn. Preislistenpreis kaufen'
+b'DocType: Sales Order Item',b'Supplier delivers to Customer',b'Lieferant liefert an Kunden'
+b'apps/erpnext/erpnext/config/non_profit.py +23',b'Member information.',b'Mitgliederinformation.'
+b'apps/erpnext/erpnext/utilities/bot.py +34',b'[{0}](#Form/Item/{0}) is out of stock',b'[{0}] (# Form / Item / {0}) ist ausverkauft'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +58',b'Asset Maintenance',b'Anlagenpflege'
+,b'Sales Payment Summary',b'Zusammenfassung der Verkaufszahlung'
+b'DocType: Restaurant',b'Restaurant',b'Restaurant'
+b'apps/erpnext/erpnext/accounts/party.py +320',b'Due / Reference Date cannot be after {0}',b'F\xc3\xa4lligkeits-/Stichdatum kann nicht nach {0} liegen'
+b'apps/erpnext/erpnext/config/setup.py +51',b'Data Import and Export',b'Daten-Import und -Export'
+b'DocType: Patient',b'Account Details',b'Kontendaten'
+b'DocType: Crop',b'Materials Required',b'Ben\xc3\xb6tigte Materialien'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76',b'No students Found',b'Keine Studenten gefunden'
+b'DocType: Medical Department',b'Medical Department',b'Medizinische Abteilung'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Kriterien'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55',b'Invoice Posting Date',b'Rechnungsbuchungsdatum'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25',b'Sell',b'Verkaufen'
+b'DocType: Purchase Invoice',b'Rounded Total',b'Gerundete Gesamtsumme'
+b'DocType: Product Bundle',b'List items that form the package.',"b'Die Artikel auflisten, die das Paket bilden.'"
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39',b'Not permitted. Please disable the Test Template',b'Nicht gestattet. Bitte deaktivieren Sie die Testvorlage'
+b'apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26',b'Percentage Allocation should be equal to 100%',b'Prozentuale Aufteilung sollte gleich 100% sein'
+b'DocType: Crop Cycle',b'Linked Land Unit',b'Verbundene Landeinheit'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584',b'Please select Posting Date before selecting Party',b'Bitte w\xc3\xa4hlen Sie Buchungsdatum vor dem Party-Auswahl'
+b'DocType: Program Enrollment',b'School House',b'School House'
+b'DocType: Serial No',b'Out of AMC',b'Au\xc3\x9ferhalb des j\xc3\xa4hrlichen Wartungsvertrags'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +82',b'Number of Depreciations Booked cannot be greater than Total Number of Depreciations',b'Anzahl der Abschreibungen gebucht kann nicht gr\xc3\xb6\xc3\x9fer sein als Gesamtzahl der abschreibungen'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47',b'Make Maintenance Visit',b'Wartungsbesuch erstellen'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +215',b'Please contact to the user who have Sales Master Manager {0} role',"b'Bitte den Benutzer kontaktieren, der die Vertriebsleiter {0}-Rolle inne hat'"
+b'DocType: Company',b'Default Cash Account',b'Standardbarkonto'
+b'apps/erpnext/erpnext/config/accounts.py +62',b'Company (not Customer or Supplier) master.',b'Unternehmensstammdaten (nicht Kunde oder Lieferant)'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6',b'This is based on the attendance of this Student',b'Dies h\xc3\xa4ngt von der Anwesenheit dieses Studierenden ab'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178',b'No Students in',b'Keine Studenten in'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179',b'Add more items or open full form',b'Weitere Elemente hinzuf\xc3\xbcgen oder vollst\xc3\xa4ndiges Formular \xc3\xb6ffnen'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212',b'Delivery Notes {0} must be cancelled before cancelling this Sales Order',b'Lieferscheine {0} m\xc3\xbcssen vor L\xc3\xb6schung dieser Kundenauftr\xc3\xa4ge storniert werden'
+b'apps/erpnext/erpnext/utilities/user_progress.py +259',b'Go to Users',b'Gehen Sie zu den Benutzern'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85',b'Paid amount + Write Off Amount can not be greater than Grand Total',b'Summe aus gezahltem Betrag + ausgebuchter Betrag darf nicht gr\xc3\xb6\xc3\x9fer der Gesamtsumme sein'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78',b'{0} is not a valid Batch Number for Item {1}',b'{0} ist keine g\xc3\xbcltige Chargennummer f\xc3\xbcr Artikel {1}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130',b'Note: There is not enough leave balance for Leave Type {0}',b'Hinweis: Es gibt nicht gen\xc3\xbcgend Urlaubsguthaben f\xc3\xbcr Abwesenheitstyp {0}'
+b'apps/erpnext/erpnext/regional/india/utils.py +16',b'Invalid GSTIN or Enter NA for Unregistered',b'Ung\xc3\xbcltiges GSTIN oder NA f\xc3\xbcr unregistriert eingeben'
+b'DocType: Training Event',b'Seminar',b'Seminar'
+b'DocType: Program Enrollment Fee',b'Program Enrollment Fee',b'Programm Einschreibegeb\xc3\xbchr'
+b'DocType: Item',b'Supplier Items',b'Lieferantenartikel'
+b'DocType: Opportunity',b'Opportunity Type',b'Chance-Typ'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16',b'New Company',b'Neue Firma'
+b'apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17',b'Transactions can only be deleted by the creator of the Company',b'Transaktionen k\xc3\xb6nnen nur durch den Ersteller der Firma gel\xc3\xb6scht werden'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +21',b'Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.',b'Falsche Anzahl von Buchungen im Hauptbuch gefunden. M\xc3\xb6glicherweise wurde f\xc3\xbcr die Transaktion ein falsches Konto gew\xc3\xa4hlt.'
+b'DocType: Employee',b'Prefered Contact Email',b'Bevorzugte Kontakt E-Mail'
+b'DocType: Cheque Print Template',b'Cheque Width',b'Scheck Breite'
+b'DocType: Selling Settings',b'Validate Selling Price for Item against Purchase Rate or Valuation Rate',b'Best\xc3\xa4tigen Sie den  Verkaufspreis f\xc3\xbcr den Posten gegen  den Einkaufspreis oder Bewertungskurs'
+b'DocType: Fee Schedule',b'Fee Schedule',b'Geb\xc3\xbchrenordnung'
+b'DocType: Hub Settings',b'Publish Availability',b'Verf\xc3\xbcgbarkeit ver\xc3\xb6ffentlichen'
+b'DocType: Company',b'Create Chart Of Accounts Based On',"b'Kontenplan erstellen, basierend auf'"
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +91',b'Cannot convert it to non-group. Child Tasks exist.',b'Kann es nicht in Nicht-Gruppe konvertieren. Untergeordnete Aufgaben sind vorhanden.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +112',b'Date of Birth cannot be greater than today.',b'Geburtsdatum kann nicht sp\xc3\xa4ter liegen als heute.'
+,b'Stock Ageing',b'Lager-Abschreibungen'
+b'apps/erpnext/erpnext/education/doctype/student/student.py +40',b'Student {0} exist against student applicant {1}',b'Student {0} existiert gegen Studienbewerber {1}'
+b'DocType: Purchase Invoice',b'Rounding Adjustment (Company Currency)',b'Rundungsanpassung (Firmenw\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +39',b'Timesheet',b'Zeiterfassung'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243',b'Batch: ',b'Stapel:'
+b'DocType: Volunteer',b'Afternoon',b'Nachmittag'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +258',"b""{0} '{1}' is disabled""","b""{0} '{1}' ist deaktiviert"""
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13',b'Set as Open',"b'Als ""ge\xc3\xb6ffnet"" markieren'"
+b'DocType: Cheque Print Template',b'Scanned Cheque',b'Gescannte Scheck'
+b'DocType: Notification Control',b'Send automatic emails to Contacts on Submitting transactions.',b'Beim Ausf\xc3\xbchren von Transaktionen automatisch E-Mails an Kontakte senden.'
+b'DocType: Timesheet',b'Total Billable Amount',b'Insgesamt abrechenbare Betrag'
+b'DocType: Customer',b'Credit Limit and Payment Terms',b'Kreditlimit und Zahlungsbedingungen'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20',b'Item 3',b'Position 3'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6',b'Order Entry',b'Auftragserfassung'
+b'DocType: Purchase Order',b'Customer Contact Email',b'Kontakt-E-Mail des Kunden'
+b'DocType: Warranty Claim',b'Item and Warranty Details',b'Einzelheiten Artikel und Garantie'
+b'DocType: Chapter',b'Chapter Members',b'Gruppen-Mitglieder'
+b'DocType: Sales Team',b'Contribution (%)',b'Beitrag (%)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +102',"b""Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified""","b'Hinweis: Zahlungsbuchung wird nicht erstellt, da kein ""Kassen- oder Bankkonto"" angegeben wurde'"
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +70',b'Project {0} already exists',b'Projekt {0} existiert bereits'
+b'DocType: Medical Department',b'Nursing User',b'Krankenpfleger'
+b'DocType: Plant Analysis',b'Plant Analysis Criterias',b'Kriterien f\xc3\xbcr die Pflanzenanalyse'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239',b'Responsibilities',b'Verantwortung'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125',b'Validity period of this quotation has ended.',b'G\xc3\xbcltigkeitszeitraum dieses Angebots ist beendet.'
+b'DocType: Expense Claim Account',b'Expense Claim Account',b'Kostenabrechnung Konto'
+b'DocType: Accounts Settings',b'Allow Stale Exchange Rates',b'feste Wechselkurse erlauben'
+b'DocType: Sales Person',b'Sales Person Name',b'Name des Vertriebsmitarbeiters'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54',b'Please enter atleast 1 invoice in the table',b'Bitte mindestens eine Rechnung in die Tabelle eingeben'
+b'apps/erpnext/erpnext/utilities/user_progress.py +247',b'Add Users',b'Benutzer hinzuf\xc3\xbcgen'
+b'DocType: POS Item Group',b'Item Group',b'Artikelgruppe'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16',b'Student Group: ',b'Studentengruppe:'
+b'DocType: Item',b'Safety Stock',b'Sicherheitsbestand'
+b'DocType: Healthcare Settings',b'Healthcare Settings',b'Gesundheitswesen'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +54',b'Progress % for a task cannot be more than 100.',b'Fortschritt-% eines Vorgangs darf nicht gr\xc3\xb6\xc3\x9fer 100 sein.'
+b'DocType: Stock Reconciliation Item',b'Before reconciliation',b'Vor Ausgleich'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12',b'To {0}',b'An {0}'
+b'DocType: Purchase Invoice',b'Taxes and Charges Added (Company Currency)',b'Steuern und Geb\xc3\xbchren hinzugerechnet\xc2\xa0(Firmenw\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +476',b'Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable',"b'Artikelsteuer Zeile {0} muss ein Konto vom Typ ""Steuer"" oder ""Ertr\xc3\xa4ge"" oder ""Aufwendungen"" oder ""Besteuerbar"" haben'"
+b'DocType: Sales Order',b'Partly Billed',b'Teilweise abgerechnet'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +43',b'Item {0} must be a Fixed Asset Item',b'Artikel {0} muss ein Posten des Anlageverm\xc3\xb6gens sein'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +372',b'Make Variants',b'Stellen Sie Varianten her'
+b'DocType: Item',b'Default BOM',b'Standardst\xc3\xbcckliste'
+b'DocType: Project',b'Total Billed Amount (via Sales Invoices)',b'Gesamtabrechnungsbetrag (\xc3\xbcber Verkaufsrechnungen)'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Debit Note Amount',b'Lastschriftbetrag'
+b'DocType: Project Update',b'Not Updated',b'Nicht aktualisiert'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106',"b'There are inconsistencies between the rate, no of shares and the amount calculated'","b'Es gibt Unstimmigkeiten zwischen dem Kurs, der Anzahl der Aktien und dem berechneten Betrag'"
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +89',b'Please re-type company name to confirm',b'Bitte zum Best\xc3\xa4tigen Firmenname erneut eingeben'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +216',b'Total Outstanding Amt',b'Offener Gesamtbetrag'
+b'DocType: Journal Entry',b'Printing Settings',b'Druckeinstellungen'
+b'DocType: Employee Advance',b'Advance Account',b'Vorauskonto'
+b'DocType: Job Offer',b'Job Offer Terms',b'Stellenangebot Bedingungen'
+b'DocType: Sales Invoice',b'Include Payment (POS)',b'(POS) Zahlung einschlie\xc3\x9fen'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292',b'Total Debit must be equal to Total Credit. The difference is {0}',b'Gesamt-Soll muss gleich Gesamt-Haben sein. Die Differenz ist {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11',b'Automotive',b'Fahrzeugbau'
+b'DocType: Vehicle',b'Insurance Company',b'Versicherungsunternehmen'
+b'DocType: Asset Category Account',b'Fixed Asset Account',b'Feste Asset-Konto'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414',b'Variable',b'Variable'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47',b'From Delivery Note',b'Von Lieferschein'
+b'DocType: Chapter',b'Members',b'Mitglieder'
+b'DocType: Student',b'Student Email Address',b'Studenten E-Mail-Adresse'
+b'DocType: Item',b'Hub Warehouse',b'Hublager'
+b'DocType: Assessment Plan',b'From Time',b'Von-Zeit'
+b'DocType: Hotel Settings',b'Hotel Settings',b'Hoteleinstellungen'
+b'apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12',b'In Stock: ',b'Auf Lager:'
+b'DocType: Notification Control',b'Custom Message',b'Benutzerdefinierte Mitteilung'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33',b'Investment Banking',b'Investment-Banking'
+b'DocType: Purchase Invoice',b'input',b'Eingang'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79',b'Cash or Bank Account is mandatory for making payment entry',b'Kassen- oder Bankkonto ist zwingend notwendig  um eine Zahlungsbuchung zu erstellen'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Sch\xc3\xbcleradresse'
+b'DocType: Purchase Invoice',b'Price List Exchange Rate',b'Preislisten-Wechselkurs'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +251',b'Account Number {0} already used in account {1}',b'Die Kontonummer {0} wurde bereits im Konto {1} verwendet.'
+b'DocType: GoCardless Mandate',b'Mandate',b'Mandat'
+b'DocType: POS Profile',b'POS Profile Name',b'POS-Profilname'
+b'DocType: Hotel Room Reservation',b'Booked',b'Gebucht'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxLib',b'CompAuxLib'
+b'DocType: Purchase Invoice Item',b'Rate',b'Preis'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104',b'Intern',b'Praktikant'
+b'DocType: Delivery Stop',b'Address Name',b'Adress-Name'
+b'DocType: Stock Entry',b'From BOM',b'Von St\xc3\xbcckliste'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639',b'Splitting {0} units of {1}',b'Aufteilen von {0} Einheiten von {1}'
+b'DocType: Assessment Code',b'Assessment Code',b'Beurteilungs-Code'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73',b'Basic',b'Grundeinkommen'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94',b'Stock transactions before {0} are frozen',b'Lagertransaktionen vor {0} werden gesperrt'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219',"b""Please click on 'Generate Schedule'""","b'Bitte auf ""Zeitplan generieren"" klicken'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122',b'Reference No is mandatory if you entered Reference Date',"b'Referenznr. ist zwingend erforderlich, wenn Referenz-Tag eingegeben wurde'"
+b'DocType: Bank Reconciliation Detail',b'Payment Document',b'Zahlungsbeleg'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37',b'Error evaluating the criteria formula',b'Fehler bei der Auswertung der Kriterienformel'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +115',b'Date of Joining must be greater than Date of Birth',b'Eintrittsdatum muss nach dem Geburtsdatum liegen'
+b'DocType: Salary Slip',b'Salary Structure',b'Gehaltsstruktur'
+b'DocType: Account',b'Bank',b'Bank'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9',b'Airline',b'Fluggesellschaft'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853',b'Issue Material',b'Material ausgeben'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'An error occured while creating recurring',b'Beim Erstellen von Wiederholungen ist ein Fehler aufgetreten'
+b'DocType: Material Request Item',b'For Warehouse',b'F\xc3\xbcr Lager'
+b'DocType: Employee',b'Offer Date',b'Angebotsdatum'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33',b'Quotations',b'Angebote'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +735',b'You are in offline mode. You will not be able to reload until you have network.',"b'Sie befinden sich im Offline-Modus. Aktualisieren ist nicht m\xc3\xb6glich, bis Sie wieder online sind.'"
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47',b'No Student Groups created.',b'Keine Studentengruppen erstellt.'
+b'DocType: Purchase Invoice Item',b'Serial No',b'Seriennummer'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119',b'Monthly Repayment Amount cannot be greater than Loan Amount',b'Monatlicher R\xc3\xbcckzahlungsbetrag kann nicht gr\xc3\xb6\xc3\x9fer sein als Darlehensbetrag'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143',b'Please enter Maintaince Details first',b'Bitte zuerst die Einzelheiten zur Wartung eingeben'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56',b'Row #{0}: Expected Delivery Date cannot be before Purchase Order Date',b'Row # {0}: Voraussichtlicher Liefertermin kann nicht vor Bestelldatum sein'
+b'DocType: Purchase Invoice',b'Print Language',b'Drucksprache'
+b'DocType: Salary Slip',b'Total Working Hours',b'Gesamtarbeitszeit'
+b'DocType: Sales Invoice',b'Customer PO Details',b'Kundenauftragsdetails'
+b'DocType: Subscription',b'Next Schedule Date',b'N\xc3\xa4chste Termine Datum'
+b'DocType: Stock Entry',b'Including items for sub assemblies',b'Einschlie\xc3\x9flich der Artikel f\xc3\xbcr Unterbaugruppen'
+b'DocType: Opening Invoice Creation Tool Item',b'Temporary Opening Account',b'Tempor\xc3\xa4res Er\xc3\xb6ffnungskonto'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1964',b'Enter value must be positive',b'Geben Sie Wert muss positiv sein'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446',b'All Territories',b'Alle Regionen'
+b'apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49',b'Add Multiple Tasks',b'F\xc3\xbcgen Sie mehrere Aufgaben hinzu'
+b'DocType: Purchase Invoice',b'Items',b'Artikel'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34',b'Student is already enrolled.',b'Student ist bereits eingetragen sind.'
+b'DocType: Fiscal Year',b'Year Name',b'Name des Jahrs'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241',b'There are more holidays than working days this month.',b'Es gibt mehr Feiertage als Arbeitstage in diesem Monat.'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78',b'PDC/LC Ref',b'PDC / LC Ref.-Nr.'
+b'DocType: Product Bundle Item',b'Product Bundle Item',b'Produkt-Bundle-Artikel'
+b'DocType: Sales Partner',b'Sales Partner Name',b'Name des Vertriebspartners'
+b'apps/erpnext/erpnext/hooks.py +136',b'Request for Quotations',b'Angebostanfrage'
+b'DocType: Payment Reconciliation',b'Maximum Invoice Amount',b'Maximaler Rechnungsbetrag'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Montantdevise',b'Montantdevise'
+b'apps/erpnext/erpnext/healthcare/setup.py +210',b'Haematology',b'H\xc3\xa4matologie'
+b'DocType: Normal Test Items',b'Normal Test Items',b'Normale Testartikel'
+b'DocType: Student Language',b'Student Language',b'Student Sprache'
+b'apps/erpnext/erpnext/config/selling.py +23',b'Customers',b'Kundschaft'
+b'DocType: Cash Flow Mapping',b'Is Working Capital',b'Ist Arbeitskapital'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Bestellung / Quot%'
+b'apps/erpnext/erpnext/config/healthcare.py +25',b'Record Patient Vitals',b'Datensatz Patient Vitals'
+b'DocType: Fee Schedule',b'Institution',b'Institution'
+b'DocType: Asset',b'Partially Depreciated',b'Teilweise abgeschrieben'
+b'DocType: Issue',b'Opening Time',b'\xc3\x96ffnungszeit'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89',b'From and To dates required',b'Von- und Bis-Daten erforderlich'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46',b'Securities & Commodity Exchanges',b'Wertpapier- & Rohstoffb\xc3\xb6rsen'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +689',"b""Default Unit of Measure for Variant '{0}' must be same as in Template '{1}'""","b""Standard-Ma\xc3\x9feinheit f\xc3\xbcr Variante '{0}' muss dieselbe wie in der Vorlage '{1}' sein"""
+b'DocType: Shipping Rule',b'Calculate Based On',b'Berechnen auf Grundlage von'
+b'DocType: Delivery Note Item',b'From Warehouse',b'Ab Lager'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59',b'No employees for the mentioned criteria',b'Keine Mitarbeiter f\xc3\xbcr die genannten Kriterien'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955',b'No Items with Bill of Materials to Manufacture',b'Keine Elemente mit Bill of Materials zu Herstellung'
+b'DocType: Hotel Settings',b'Default Customer',b'Standardkunde'
+b'DocType: Assessment Plan',b'Supervisor Name',b'Name des Vorgesetzten'
+b'DocType: Healthcare Settings',b'Do not confirm if appointment is created for the same day',"b'Best\xc3\xa4tigen Sie nicht, ob der Termin f\xc3\xbcr denselben Tag erstellt wurde'"
+b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Programm Einschreibung Kurs'
+b'DocType: Purchase Taxes and Charges',b'Valuation and Total',b'Bewertung und Summe'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11',b'Scorecards',b'Scorecards'
+b'DocType: Tax Rule',b'Shipping City',b'Zielstadt der Lieferung'
+b'DocType: Notification Control',b'Customize the Notification',b'Mitteilungstext anpassen'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24',b'Cash Flow from Operations',b'Cashflow aus Gesch\xc3\xa4ftst\xc3\xa4tigkeit'
+b'DocType: Purchase Invoice',b'Shipping Rule',b'Versandregel'
+b'DocType: Patient Relation',b'Spouse',b'Ehepartner'
+b'DocType: Lab Test Groups',b'Add Test',b'Test hinzuf\xc3\xbcgen'
+b'DocType: Manufacturer',b'Limited to 12 characters',b'Limitiert auf 12 Zeichen'
+b'DocType: Journal Entry',b'Print Heading',b'Druckkopf'
+b'apps/erpnext/erpnext/config/stock.py +146',b'Delivery Trip service tours to customers.',b'Lieferung Trip-Service-Touren zu Kunden.'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57',b'Total cannot be zero',b'Summe kann nicht Null sein'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16',"b""'Days Since Last Order' must be greater than or equal to zero""","b'""Tage seit dem letzten Auftrag"" muss gr\xc3\xb6\xc3\x9fer oder gleich Null sein'"
+b'DocType: Plant Analysis Criteria',b'Maximum Permissible Value',b'Maximaler zul\xc3\xa4ssiger Wert'
+b'DocType: Journal Entry Account',b'Employee Advance',b'Mitarbeitervorschuss'
+b'DocType: Payroll Entry',b'Payroll Frequency',b'Payroll Frequency'
+b'DocType: Lab Test Template',b'Sensitivity',b'Empfindlichkeit'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941',b'Raw Material',b'Rohmaterial'
+b'DocType: Leave Application',b'Follow via Email',b'Per E-Mail nachverfolgen'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55',b'Plants and Machineries',b'Pflanzen und Maschinen'
+b'DocType: Purchase Taxes and Charges',b'Tax Amount After Discount Amount',b'Steuerbetrag nach Abzug von Rabatt'
+b'DocType: Daily Work Summary Settings',b'Daily Work Summary Settings',b't\xc3\xa4gliche Arbeitszusammenfassung-Einstellungen'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +447',b'Please enter Reqd by Date',b'Bitte geben Sie Requd by Date ein'
+b'DocType: Payment Entry',b'Internal Transfer',b'Interner Transfer'
+b'DocType: Asset Maintenance',b'Maintenance Tasks',b'Wartungsaufgaben'
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.py +19',b'Either target qty or target amount is mandatory',b'Entweder Zielst\xc3\xbcckzahl oder Zielmenge ist zwingend erforderlich'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366',b'Please select Posting Date first',b'Bitte zuerst ein Buchungsdatum ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +209',b'Opening Date should be before Closing Date',b'Er\xc3\xb6ffnungsdatum sollte vor dem Abschlussdatum liegen'
+b'DocType: Leave Control Panel',b'Carry Forward',b'\xc3\x9cbertragen'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30',b'Cost Center with existing transactions can not be converted to ledger',b'Kostenstelle mit bestehenden Transaktionen kann nicht in Sachkonto umgewandelt werden'
+b'DocType: Department',b'Days for which Holidays are blocked for this department.',"b'Tage, an denen eine Urlaubssperre f\xc3\xbcr diese Abteilung gilt.'"
+b'DocType: GoCardless Mandate',b'ERPNext Integrations',b'ERPNext Integrationen'
+b'DocType: Crop Cycle',b'Detected Disease',b'Erkannte Krankheit'
+,b'Produced',b'Produziert'
+b'DocType: Item',b'Item Code for Suppliers',b'Artikelnummer f\xc3\xbcr Lieferanten'
+b'DocType: Issue',b'Raised By (Email)',b'Gemeldet von (E-Mail)'
+b'DocType: Training Event',b'Trainer Name',b'Trainer-Name'
+b'DocType: Mode of Payment',b'General',b'Allgemein'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Letzte Kommunikation'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372',"b""Cannot deduct when category is for 'Valuation' or 'Valuation and Total'""","b'Abzug nicht m\xc3\xb6glich, wenn Kategorie ""Wertbestimmtung"" oder ""Wertbestimmung und Summe"" ist'"
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234',b'Serial Nos Required for Serialized Item {0}',b'Seriennummern sind erforderlich f\xc3\xbcr den Artikel mit Seriennummer {0}'
+b'apps/erpnext/erpnext/config/accounts.py +144',b'Match Payments with Invoices',b'Zahlungen und Rechnungen abgleichen'
+b'DocType: Journal Entry',b'Bank Entry',b'Bankbuchung'
+b'DocType: Authorization Rule',b'Applicable To (Designation)',b'Anwenden auf (Bezeichnung)'
+,b'Profitability Analysis',b'Wirtschaftlichkeitsanalyse'
+b'DocType: Fees',b'Student Email',b'Sch\xc3\xbcler E-Mail'
+b'DocType: Supplier',b'Prevent POs',b'Vermeiden Sie POs'
+b'DocType: Patient',"b'Allergies, Medical and Surgical History'","b'Allergien, medizinische- und chirurgische Vergangenheit'"
+b'apps/erpnext/erpnext/templates/generators/item.html +77',b'Add to Cart',b'In den Warenkorb legen'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28',b'Group By',b'Gruppieren nach'
+b'DocType: Guardian',b'Interests',b'Interessen'
+b'apps/erpnext/erpnext/config/accounts.py +298',b'Enable / disable currencies.',b'Aktivieren / Deaktivieren der W\xc3\xa4hrungen'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105',b'Dr {0} on Half day Leave on {1}',b'Dr {0} am Halbtag Leave am {1}'
+b'DocType: Production Plan',b'Get Material Request',b'Get-Material anfordern'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111',b'Postal Expenses',b'Portoaufwendungen'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Amt)',b'Gesamtsumme'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26',b'Entertainment & Leisure',b'Unterhaltung & Freizeit'
+,b'Item Variant Details',b'Details der Artikelvariante'
+b'DocType: Quality Inspection',b'Item Serial No',b'Artikel-Seriennummer'
+b'apps/erpnext/erpnext/utilities/activation.py +135',b'Create Employee Records',b'Erstellen Sie Mitarbeiterdaten'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Present',b'Summe Anwesend'
+b'apps/erpnext/erpnext/config/accounts.py +105',b'Accounting Statements',b'Buchhaltungsausz\xc3\xbcge'
+b'DocType: Drug Prescription',b'Hour',b'Stunde'
+b'DocType: Restaurant Order Entry',b'Last Sales Invoice',b'Letzte Verkaufsrechnung'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +788',b'Please select Qty against item {0}',b'Bitte w\xc3\xa4hlen Sie Menge f\xc3\xbcr Artikel {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29',b'New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt',"b'""Neue Seriennummer"" kann keine Lagerangabe enthalten. Lagerangaben m\xc3\xbcssen durch eine Lagerbuchung oder einen Kaufbeleg erstellt werden'"
+b'DocType: Lead',b'Lead Type',b'Lead-Typ'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114',b'You are not authorized to approve leaves on Block Dates',"b'Sie sind nicht berechtigt, Urlaube f\xc3\xbcr geblockte Termine zu genehmigen'"
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394',b'All these items have already been invoiced',b'Alle diese Artikel sind bereits in Rechnung gestellt'
+b'DocType: Company',b'Monthly Sales Target',b'Monatliches Verkaufsziel'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37',b'Can be approved by {0}',b'Kann von {0} genehmigt werden'
+b'DocType: Hotel Room',b'Hotel Room Type',b'Hotel Zimmertyp'
+b'DocType: Item',b'Default Material Request Type',b'Standard-Material anfordern Typ'
+b'DocType: Supplier Scorecard',b'Evaluation Period',b'Bewertungszeitraum'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13',b'Unknown',b'Unbekannt'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954',b'Work Order not created',b'Arbeitsauftrag wurde nicht erstellt'
+b'DocType: Shipping Rule',b'Shipping Rule Conditions',b'Versandbedingungen'
+b'DocType: Purchase Invoice',b'Export Type',b'Exporttyp'
+b'DocType: Salary Slip Loan',b'Salary Slip Loan',b'Gehalts-Slip-Darlehen'
+b'DocType: BOM Update Tool',b'The new BOM after replacement',b'Die neue St\xc3\xbcckliste nach dem Austausch'
+,b'Point of Sale',b'Verkaufsstelle'
+b'DocType: Payment Entry',b'Received Amount',b'erhaltenen Betrag'
+b'DocType: Patient',b'Widow',b'Witwe'
+b'DocType: GST Settings',b'GSTIN Email Sent On',b'GSTIN E-Mail gesendet'
+b'DocType: Program Enrollment',b'Pick/Drop by Guardian',b'Pick / Drop von Guardian'
+b'DocType: Crop',b'Planting UOM',b'UOM anlegen'
+b'DocType: Account',b'Tax',b'Steuer'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45',b'Not Marked',b'nicht markiert'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1',b'Opening Invoices Summary',b'Rechnungszusammenfassung \xc3\xb6ffnen'
+b'DocType: Education Settings',b'Education Manager',b'Ausbildungsleiter'
+b'DocType: Crop Cycle',b'The minimum length between each plant in the field for optimum growth',b'Die minimale L\xc3\xa4nge zwischen jeder Pflanze im Feld f\xc3\xbcr optimales Wachstum'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'",b'Chargenartikel {0} kann nicht durch Lagerabgleich aktualisiert werden. Bitte stattdessen einen Lagereintrag verwenden.'
+b'DocType: Quality Inspection',b'Report Date',b'Berichtsdatum'
+b'DocType: Student',b'Middle Name',b'Zweiter Vorname'
+b'DocType: C-Form',b'Invoices',b'Eingangsrechnungen'
+b'DocType: Water Analysis',b'Type of Sample',b'Art der Probe'
+b'DocType: Batch',b'Source Document Name',b'Quelldokumentname'
+b'DocType: Production Plan',b'Get Raw Materials For Production',b'Holen Sie sich Rohstoffe f\xc3\xbcr die Produktion'
+b'DocType: Job Opening',b'Job Title',b'Stellenbezeichnung'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84',"b'{0} indicates that {1} will not provide a quotation, but all items \\\n\t\t\t\t\thave been quoted. Updating the RFQ quote status.'","b'{0} zeigt an, dass {1} kein Angebot anbietet, aber alle Items wurden zitiert. Aktualisieren des RFQ-Zitatstatus.'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026',b'Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.',b'Maximum Samples - {0} wurden bereits f\xc3\xbcr Batch {1} und Artikel {2} in Batch {3} gespeichert.'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125',b'Please Set Supplier Type in Buying Settings.',b'Bitte legen Sie den Liefertyp in den Kaufeinstellungen fest.'
+b'DocType: Manufacturing Settings',b'Update BOM Cost Automatically',b'Aktualisieren Sie die St\xc3\xbccklistenkosten automatisch'
+b'DocType: Lab Test',b'Test Name',b'Testname'
+b'apps/erpnext/erpnext/utilities/activation.py +99',b'Create Users',b'Benutzer erstellen'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Gram',b'Gramm'
+b'DocType: Supplier Scorecard',b'Per Month',b'Pro Monat'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433',b'Quantity to Manufacture must be greater than 0.',b'Menge Herstellung muss gr\xc3\xb6\xc3\x9fer als 0 sein.'
+b'DocType: Asset Settings',b'Calculate Prorated Depreciation Schedule Based on Fiscal Year',b'Berechnen Sie den anteiligen Abschreibungsplan basierend auf dem Gesch\xc3\xa4ftsjahr'
+b'apps/erpnext/erpnext/config/maintenance.py +17',b'Visit report for maintenance call.',b'Besuchsbericht f\xc3\xbcr Wartungsauftrag'
+b'DocType: Stock Entry',b'Update Rate and Availability',b'Preis und Verf\xc3\xbcgbarkeit aktualisieren'
+b'DocType: Stock Settings',b'Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.',"b'Zur bestellten Menge zus\xc3\xa4tzlich zul\xc3\xa4ssiger Prozentsatz, der angenommen oder geliefert werden kann. Beispiel: Wenn 100 Einheiten bestellt wurden, und die erlaubte Spanne 10 % betr\xc3\xa4gt, dann k\xc3\xb6nnen 110 Einheiten angenommen werden.'"
+b'DocType: POS Customer Group',b'Customer Group',b'Kundengruppe'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217',b'Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs',b'Zeilennr. {0}: Vorgang {1} ist f\xc3\xbcr {2} Menge fertiger Waren in Arbeitsauftrag Nr. {3} nicht abgeschlossen. Bitte aktualisieren Sie den Betriebsstatus \xc3\xbcber Zeitprotokolle'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Neue Batch-ID (optional)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201',b'Expense account is mandatory for item {0}',b'Aufwandskonto ist zwingend f\xc3\xbcr Artikel {0}'
+b'DocType: BOM',b'Website Description',b'Webseiten-Beschreibung'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47',b'Net Change in Equity',b'Nettover\xc3\xa4nderung des Eigenkapitals'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +220',b'Please cancel Purchase Invoice {0} first',b'Bitte stornieren Einkaufsrechnung {0} zuerst'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43',"b'Email Address must be unique, already exists for {0}'","b'E-Mail-Adresse muss eindeutig sein, diese wird bereits f\xc3\xbcr {0} verwendet'"
+b'DocType: Serial No',b'AMC Expiry Date',b'Verfalldatum des j\xc3\xa4hrlichen Wartungsvertrags'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880',b'Receipt',b'Kaufbeleg'
+,b'Sales Register',b'\xc3\x9cbersicht \xc3\xbcber den Umsatz'
+b'DocType: Daily Work Summary Group',b'Send Emails At',b'Die E-Mails senden um'
+b'DocType: Quotation',b'Quotation Lost Reason',b'Grund f\xc3\xbcr verlorenes Angebotes'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381',b'Transaction reference no {0} dated {1}',b'Transaktion Referenznummer {0} vom {1}'
+b'apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5',b'There is nothing to edit.',b'Es gibt nichts zu bearbeiten.'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116',b'Summary for this month and pending activities',b'Zusammenfassung f\xc3\xbcr diesen Monat und anstehende Aktivit\xc3\xa4ten'
+b'apps/erpnext/erpnext/utilities/user_progress.py +248',"b'Add users to your organization, other than yourself.'","b'F\xc3\xbcgen Sie, neben Ihnen selbst, weitere Benutzer zu Ihrer Organisation hinzu.'"
+b'DocType: Customer Group',b'Customer Group Name',b'Kundengruppenname'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +109',b'No Customers yet!',b'Noch keine Kunden!'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +56',b'Cash Flow Statement',b'Geldflussrechnung'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473',b'No material request created',b'Es wurde keine Materialanforderung erstellt'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23',b'Loan Amount cannot exceed Maximum Loan Amount of {0}',b'Darlehensbetrag darf nicht h\xc3\xb6her als der Maximalbetrag {0} sein'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22',b'License',b'Lizenz'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491',b'Please remove this Invoice {0} from C-Form {1}',b'Bitte diese Rechnung {0} vom Kontaktformular {1} entfernen'
+b'DocType: Leave Control Panel',"b""Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year""","b'Bitte auf ""\xc3\x9cbertragen"" klicken, wenn auch die Abwesenheitskonten des vorangegangenen Gesch\xc3\xa4ftsjahrs in dieses Gesch\xc3\xa4ftsjahr einbezogen werden sollen'"
+b'DocType: GL Entry',b'Against Voucher Type',b'Gegenbeleg-Art'
+b'DocType: Physician',b'Phone (R)',b'Telefon (R)'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56',b'Time slots added',b'Zeitschlitze hinzugef\xc3\xbcgt'
+b'DocType: Item',b'Attributes',b'Attribute'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31',b'Enable Template',b'Schablone aktivieren'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226',b'Please enter Write Off Account',b'Bitte Abschreibungskonto eingeben'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71',b'Last Order Date',b'Letztes Bestelldatum'
+b'DocType: Patient',b'B Negative',b'B Negativ'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25',b'Maintenance Status has to be Cancelled or Completed to Submit',b'Der Wartungsstatus muss abgebrochen oder zum Senden abgeschlossen werden'
+b'DocType: Hotel Room',b'Hotel Room',b'Hotelzimmer'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47',b'Account {0} does not belongs to company {1}',b'Konto {0} geh\xc3\xb6rt nicht zu Firma {1}'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884',b'Serial Numbers in row {0} does not match with Delivery Note',b'Seriennummern in Zeile {0} stimmt nicht mit der Lieferschein \xc3\xbcberein'
+b'DocType: Student',b'Guardian Details',b'W\xc3\xa4chter-Details'
+b'DocType: C-Form',b'C-Form',b'Kontakt-Formular'
+b'apps/erpnext/erpnext/config/hr.py +18',b'Mark Attendance for multiple employees',b'Anwesenheit f\xc3\xbcr mehrere Mitarbeiter markieren'
+b'DocType: Agriculture Task',b'Start Day',b'Starttag'
+b'DocType: Vehicle',b'Chassis No',b'Fahrwerksnummer'
+b'DocType: Payment Request',b'Initiated',b'Initiiert'
+b'DocType: Production Plan Item',b'Planned Start Date',b'Geplanter Starttermin'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +618',b'Please select a BOM',b'Bitte w\xc3\xa4hlen Sie eine St\xc3\xbcckliste'
+b'DocType: Purchase Invoice',b'Availed ITC Integrated Tax',b'Erhaltene ITC Integrierte Steuer'
+b'DocType: Serial No',b'Creation Document Type',b'Belegerstellungs-Typ'
+b'DocType: Project Task',b'View Timesheet',b'Arbeitszeittabelle anzeigen'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54',b'End date must be greater than start date',b'Enddatum muss gr\xc3\xb6\xc3\x9fer sein als Startdatum'
+b'DocType: Leave Type',b'Is Encash',b'Ist Inkasso'
+b'DocType: Leave Allocation',b'New Leaves Allocated',b'Neue Urlaubszuordnung'
+b'apps/erpnext/erpnext/controllers/trends.py +269',b'Project-wise data is not available for Quotation',b'Projektbezogene Daten sind f\xc3\xbcr das Angebot nicht verf\xc3\xbcgbar'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30',b'End on',b'Endet am'
+b'DocType: Project',b'Expected End Date',b'Voraussichtliches Enddatum'
+b'DocType: Budget Account',b'Budget Amount',b'Budgetbetrag'
+b'DocType: Donor',b'Donor Name',b'Name des Spenders'
+b'DocType: Appraisal Template',b'Appraisal Template Title',b'Bezeichnung der Bewertungsvorlage'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39',"b""From Date {0} for Employee {1} cannot be before employee's joining Date {2}""","b'Mitarbeiter Von Datum {0} f\xc3\xbcr {1} kann nicht sein, bevor Mitarbeiter-Beitritt Datum {2}'"
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +29',b'Commercial',b'Werbung'
+b'DocType: Patient',b'Alcohol Current Use',b'Aktueller Alkoholkonsum'
+b'DocType: Student Admission Program',b'Student Admission Program',b'Studentenzulassungsprogramm'
+b'DocType: Payment Entry',b'Account Paid To',b'Eingangskonto'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24',b'Parent Item {0} must not be a Stock Item',b'\xc3\x9cbergeordneter Artikel {0} darf kein Lagerartikel sein'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466',b'Could not submit any Salary Slip <br>\\\n\t\t\tPossible reasons: <br>\\\n\t\t\t1. Net pay is less than 0. <br>\\\n\t\t\t2. Company Email Address specified in employee master is not valid. <br>',b'Es konnte kein Gehaltschein eingereicht werden <br> \\ M\xc3\xb6gliche Gr\xc3\xbcnde: <br> \\ 1. Nettogehalt ist kleiner als 0. <br> \\ 2. Die im Mitarbeiterstamm angegebene Firmen-E-Mail-Adresse ist nicht g\xc3\xbcltig. <br>'
+b'apps/erpnext/erpnext/config/selling.py +57',b'All Products or Services.',b'Alle Produkte oder Dienstleistungen'
+b'DocType: Expense Claim',b'More Details',b'Weitere Details'
+b'DocType: Supplier Quotation',b'Supplier Address',b'Lieferantenadresse'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128',b'{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}',b'{0} Budget f\xc3\xbcr Konto {1} gegen {2} {3} ist {4}. Es wird durch {5} \xc3\xbcberschritten.'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695',"b""Row {0}# Account must be of type 'Fixed Asset'""","b'Konto in Zeile {0} muss vom Typ ""Anlageverm\xc3\xb6gen"" sein'"
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Out Qty',b'Ausgabe-Menge'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'and unchcked Disabled in the',b'und unchcked Deaktiviert in der'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41',b'Series is mandatory',b'Serie ist zwingend erforderlich'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28',b'Financial Services',b'Finanzdienstleistungen'
+b'DocType: Student Sibling',b'Student ID',b'Studenten ID'
+b'apps/erpnext/erpnext/config/projects.py +51',b'Types of activities for Time Logs',b'Arten von Aktivit\xc3\xa4ten f\xc3\xbcr Time Logs'
+b'DocType: Opening Invoice Creation Tool',b'Sales',b'Vertrieb'
+b'DocType: Stock Entry Detail',b'Basic Amount',b'Grundbetrag'
+b'DocType: Training Event',b'Exam',b'Pr\xc3\xbcfung'
+b'DocType: Complaint',b'Complaint',b'Beschwerde'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462',b'Warehouse required for stock Item {0}',b'Angabe des Lagers ist f\xc3\xbcr den Lagerartikel {0} erforderlich'
+b'DocType: Leave Allocation',b'Unused leaves',b'Ungenutzter Urlaub'
+b'DocType: Patient',b'Alcohol Past Use',b'Vergangener Alkoholkonsum'
+b'DocType: Fertilizer Content',b'Fertilizer Content',b'D\xc3\xbcnger Inhalt'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187',b'Cr',b'Haben'
+b'DocType: Project Update',b'Problematic/Stuck',b'Problematisch / Fest'
+b'DocType: Tax Rule',b'Billing State',b'Verwaltungsbezirk laut Rechnungsadresse'
+b'DocType: Share Transfer',b'Transfer',b'\xc3\x9cbertragung'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252',b'Work Order {0} must be cancelled before cancelling this Sales Order',b'Der Arbeitsauftrag {0} muss vor dem Stornieren dieses Kundenauftrags storniert werden'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917',b'Fetch exploded BOM (including sub-assemblies)',b'Abruf der aufgel\xc3\xb6sten St\xc3\xbcckliste (einschlie\xc3\x9flich der Unterbaugruppen)'
+b'DocType: Authorization Rule',b'Applicable To (Employee)',b'Anwenden auf (Mitarbeiter)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +137',b'Due Date is mandatory',b'F\xc3\xa4lligkeitsdatum wird zwingend vorausgesetzt'
+b'apps/erpnext/erpnext/controllers/item_variant.py +82',b'Increment for Attribute {0} cannot be 0',b'Schrittweite f\xc3\xbcr Attribut {0} kann nicht 0 sein'
+b'apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19',b'Rooms Booked',b'Zimmer gebucht'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +57',b'Ends On date cannot be before Next Contact Date.',b'Das Endedatum kann nicht vor dem n\xc3\xa4chsten Kontaktdatum liegen.'
+b'DocType: Journal Entry',b'Pay To / Recd From',b'Zahlen an/Erhalten von'
+b'DocType: Naming Series',b'Setup Series',b'Serie bearbeiten'
+b'DocType: Payment Reconciliation',b'To Invoice Date',b'Um Datum Rechnung'
+b'DocType: Shareholder',b'Contact HTML',b'Kontakt-HTML'
+b'apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19',b'Registration fee can not be Zero',b'Anmeldegeb\xc3\xbchr kann nicht Null sein'
+b'DocType: Disease',b'Treatment Period',b'Behandlungszeitraum'
+b'apps/erpnext/erpnext/education/api.py +338',b'Result already Submitted',b'Ergebnis bereits \xc3\xbcbergeben'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +169',b'Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied',b'Das reservierte Warehouse ist f\xc3\xbcr das Element {0} in den bereitgestellten Rohmaterialien obligatorisch'
+,b'Inactive Customers',b'Inaktive Kunden'
+b'DocType: Student Admission Program',b'Maximum Age',b'Maximales Alter'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28',b'Please wait 3 days before resending the reminder.',"b'Bitte warten Sie 3 Tage, bevor Sie die Erinnerung erneut senden.'"
+b'DocType: Landed Cost Voucher',b'LCV',b'LCV'
+b'DocType: Landed Cost Voucher',b'Purchase Receipts',b'Kaufbelege'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29',b'How Pricing Rule is applied?',b'Wie wird die Preisregel angewandt?'
+b'DocType: Stock Entry',b'Delivery Note No',b'Lieferschein-Nummer'
+b'DocType: Cheque Print Template',b'Message to show',b'Nachricht anzeigen'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +28',b'Retail',b'Einzelhandel'
+b'DocType: Student Attendance',b'Absent',b'Abwesend'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591',b'Product Bundle',b'Produkt-Bundle'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38',b'Unable to find score starting at {0}. You need to have standing scores covering 0 to 100',b'Der Score konnte nicht gefunden werden bei {0}. Sie m\xc3\xbcssen stehende Noten von 0 bis 100 haben'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212',b'Row {0}: Invalid reference {1}',b'Zeile {0}: Ung\xc3\xbcltige Referenz {1}'
+b'DocType: Purchase Taxes and Charges Template',b'Purchase Taxes and Charges Template',b'Vorlage f\xc3\xbcr Einkaufssteuern und -abgaben'
+b'DocType: Timesheet',b'TS-',b'ZB-'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61',b'{0} {1}: Either debit or credit amount is required for {2}',b'{0} {1}: Debit- oder Kreditbetrag ist f\xc3\xbcr {2} erforderlich'
+b'DocType: GL Entry',b'Remarks',b'Bemerkungen'
+b'DocType: Hotel Room Amenity',b'Hotel Room Amenity',b'Zimmerausstattung'
+b'DocType: Payment Entry',b'Account Paid From',b'Ausgangskonto'
+b'DocType: Purchase Order Item Supplied',b'Raw Material Item Code',b'Rohmaterial-Artikelnummer'
+b'DocType: Task',b'Parent Task',b'\xc3\x9cbergeordnete Aufgabe'
+b'DocType: Journal Entry',b'Write Off Based On',b'Abschreibung basierend auf'
+b'apps/erpnext/erpnext/utilities/activation.py +65',b'Make Lead',b'Lead erstellen'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112',b'Print and Stationery',b'Drucken und Papierwaren'
+b'DocType: Stock Settings',b'Show Barcode Field',b'Anzeigen Barcode-Feld'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809',b'Send Supplier Emails',b'Lieferantenemails senden'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96',"b'Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.'","b'Gehalt bereits verarbeitet f\xc3\xbcr den Zeitraum zwischen {0} und {1}, freiBewerbungsFrist kann nicht zwischen diesem Datum liegen.'"
+b'DocType: Chapter Member',b'Leave Reason',b'Verlasse die Vernunft'
+b'DocType: Guardian Interest',b'Guardian Interest',b'W\xc3\xa4chter Interesse'
+b'DocType: Volunteer',b'Availability',b'Verf\xc3\xbcgbarkeit'
+b'apps/erpnext/erpnext/config/accounts.py +319',b'Setup default values for POS Invoices',b'Standardwerte f\xc3\xbcr POS-Rechnungen einrichten'
+b'apps/erpnext/erpnext/config/hr.py +182',b'Training',b'Ausbildung'
+b'DocType: Project',b'Time to send',b'Zeit zu senden'
+b'DocType: Timesheet',b'Employee Detail',b'Mitarbeiterdetails'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 E-Mail-ID'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68',"b""Next Date's day and Repeat on Day of Month must be equal""",b'N\xc3\xa4chster Termin des Tages und wiederholen Sie auf Tag des Monats m\xc3\xbcssen gleich sein'
+b'DocType: Lab Prescription',b'Test Code',b'Testcode'
+b'apps/erpnext/erpnext/config/website.py +11',b'Settings for website homepage',b'Einstellungen f\xc3\xbcr die Internet-Homepage'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40',b'RFQs are not allowed for {0} due to a scorecard standing of {1}',b'RFQs sind nicht zul\xc3\xa4ssig f\xc3\xbcr {0} aufgrund einer Scorecard von {1}'
+b'DocType: Job Offer',b'Awaiting Response',b'Warte auf Antwort'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60',b'Above',b'\xc3\x9cber'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1466',b'Total Amount {0}',b'Gesamtbetrag {0}'
+b'apps/erpnext/erpnext/controllers/item_variant.py +306',b'Invalid attribute {0} {1}',b'Ung\xc3\xbcltiges Attribut {0} {1}'
+b'DocType: Supplier',b'Mention if non-standard payable account',"b'Erw\xc3\xa4hnen Sie, wenn nicht standardm\xc3\xa4\xc3\x9fig zahlbares Konto'"
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25',"b""Please select the assessment group other than 'All Assessment Groups'""",b'Bitte w\xc3\xa4hlen Sie die Bewertungsgruppe au\xc3\x9fer &quot;All Assessment Groups&quot;'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67',b'Row {0}: Cost center is required for an item {1}',b'Zeile {0}: Kostenstelle ist f\xc3\xbcr einen Eintrag {1} erforderlich'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureDate',b'EcritureDatum'
+b'DocType: Training Event Employee',b'Optional',b'Optional'
+b'DocType: Salary Slip',b'Earning & Deduction',b'Eink\xc3\xbcnfte & Abz\xc3\xbcge'
+b'DocType: Agriculture Analysis Criteria',b'Water Analysis',b'Wasseranalyse'
+b'DocType: Chapter',b'Region',b'Region'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38',b'Optional. This setting will be used to filter in various transactions.',"b'Optional. Diese Einstellung wird verwendet, um in verschiedenen Transaktionen zu filtern.'"
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110',b'Negative Valuation Rate is not allowed',b'Negative Bewertung ist nicht erlaubt'
+b'DocType: Holiday List',b'Weekly Off',b'W\xc3\xb6chentlich frei'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7',b'Reload Linked Analysis',b'Reload verkn\xc3\xbcpfte Analyse'
+b'DocType: Fiscal Year',"b'For e.g. 2012, 2012-13'","b'F\xc3\xbcr z. B. 2012, 2012-13'"
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96',b'Provisional Profit / Loss (Credit)',b'Vorl\xc3\xa4ufiger Gewinn / Verlust (Haben)'
+b'DocType: Sales Invoice',b'Return Against Sales Invoice',b'Zur\xc3\xbcck zur Kundenrechnung'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32',b'Item 5',b'Position 5'
+b'DocType: Serial No',b'Creation Time',b'Zeitpunkt der Erstellung'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62',b'Total Revenue',b'Gesamtumsatz'
+b'DocType: Patient',b'Other Risk Factors',b'Andere Risikofaktoren'
+b'DocType: Sales Invoice',b'Product Bundle Help',b'Produkt-Bundle-Hilfe'
+,b'Monthly Attendance Sheet',b'Monatliche Anwesenheitsliste'
+b'apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15',b'No record found',b'Kein Datensatz gefunden'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140',b'Cost of Scrapped Asset',b'Kosten f\xc3\xbcr Ausschuss-Entsorgung'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +236',b'{0} {1}: Cost Center is mandatory for Item {2}',b'{0} {1}: Kostenstelle ist zwingend erfoderlich f\xc3\xbcr Artikel {2}'
+b'DocType: Vehicle',b'Policy No',b'Politik keine'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686',b'Get Items from Product Bundle',b'Artikel aus dem Produkt-Bundle \xc3\xbcbernehmen'
+b'DocType: Asset',b'Straight Line',b'Gerade Linie'
+b'DocType: Project User',b'Project User',b'Projektarbeit Benutzer'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Teilt'
+b'DocType: GL Entry',b'Is Advance',b'Ist Vorkasse'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21',b'Attendance From Date and Attendance To Date is mandatory',"b'""Anwesenheit ab Datum"" und ""Anwesenheit bis Datum"" sind zwingend'"
+b'apps/erpnext/erpnext/controllers/buying_controller.py +156',"b""Please enter 'Is Subcontracted' as Yes or No""","b'Bitte bei ""Untervergeben"" JA oder NEIN eingeben'"
+b'DocType: Item',b'Default Purchase Unit of Measure',b'Default Purchase Ma\xc3\x9feinheit'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Letztes Kommunikationstag'
+b'DocType: Sales Team',b'Contact No.',b'Kontakt-Nr.'
+b'DocType: Bank Reconciliation',b'Payment Entries',b'Zahlungs Eintr\xc3\xa4ge'
+b'DocType: Land Unit',b'Land Unit Details',b'Landeinheit Details'
+b'DocType: Land Unit',b'Latitude',b'Breite'
+b'DocType: Work Order',b'Scrap Warehouse',b'Ausschusslager'
+b'DocType: Work Order',b'Check if material transfer entry is not required',"b'Pr\xc3\xbcfen Sie, ob keine Material\xc3\xbcbertragung erforderlich ist'"
+b'DocType: Program Enrollment Tool',b'Get Students From',b'Holen Studenten aus'
+b'apps/erpnext/erpnext/config/learn.py +263',b'Publish Items on Website',b'Ver\xc3\xb6ffentlichen Sie Artikel auf der Website'
+b'apps/erpnext/erpnext/utilities/activation.py +126',b'Group your students in batches',b'Gruppieren Sie Ihre Sch\xc3\xbcler in den Reihen'
+b'DocType: Authorization Rule',b'Authorization Rule',b'Autorisierungsregel'
+b'DocType: POS Profile',b'Offline POS Section',b'Offline-POS-Bereich'
+b'DocType: Sales Invoice',b'Terms and Conditions Details',b'Allgemeine Gesch\xc3\xa4ftsbedingungen Details'
+b'apps/erpnext/erpnext/templates/generators/item.html +100',b'Specifications',b'Technische Daten'
+b'DocType: Sales Taxes and Charges Template',b'Sales Taxes and Charges Template',b'Vorlage f\xc3\xbcr Verkaufssteuern und -abgaben'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68',b'Total (Credit)',b'Insgesamt (Credit)'
+b'DocType: Repayment Schedule',b'Payment Date',b'Zahlungsdatum'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Neue Batch-Menge'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10',b'Apparel & Accessories',b'Kleidung & Zubeh\xc3\xb6r'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91',b'Could not solve weighted score function. Make sure the formula is valid.',"b'Die gewichtete Notenfunktion konnte nicht gel\xc3\xb6st werden. Stellen Sie sicher, dass die Formel g\xc3\xbcltig ist.'"
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67',b'Number of Order',b'Nummer der Bestellung'
+b'DocType: Item Group',b'HTML / Banner that will show on the top of product list.',"b'HTML/Banner, das oben auf der Produktliste angezeigt wird.'"
+b'DocType: Shipping Rule',b'Specify conditions to calculate shipping amount',b'Bedingungen zur Berechnung der Versandkosten angeben'
+b'DocType: Program Enrollment',"b""Institute's Bus""",b'Instituts-Bus'
+b'DocType: Accounts Settings',b'Role Allowed to Set Frozen Accounts & Edit Frozen Entries',b'Rolle darf Konten sperren und gesperrte Buchungen bearbeiten'
+b'DocType: Supplier Scorecard Scoring Variable',b'Path',b'Pfad'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28',b'Cannot convert Cost Center to ledger as it has child nodes',"b'Kostenstelle kann nicht in ein Kontenblatt umgewandelt werden, da sie Unterknoten hat'"
+b'DocType: Production Plan',b'Total Planned Qty',b'Geplante Gesamtmenge'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68',b'Opening Value',b'\xc3\x96ffnungswert'
+b'DocType: Salary Detail',b'Formula',b'Formel'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47',b'Serial #',b'Serien #'
+b'DocType: Lab Test Template',b'Lab Test Template',b'Labortestvorlage'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +181',b'Sales Account',b'Verkaufskonto'
+b'DocType: Purchase Invoice Item',b'Total Weight',b'Gesamtgewicht'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94',b'Commission on Sales',b'Provision auf den Umsatz'
+b'DocType: Job Offer Term',b'Value / Description',b'Wert / Beschreibung'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +630',"b'Row #{0}: Asset {1} cannot be submitted, it is already {2}'","b'Row # {0}: Verm\xc3\xb6gens {1} kann nicht vorgelegt werden, es ist bereits {2}'"
+b'DocType: Tax Rule',b'Billing Country',b'Land laut Rechnungsadresse'
+b'DocType: Purchase Order Item',b'Expected Delivery Date',b'Geplanter Liefertermin'
+b'DocType: Restaurant Order Entry',b'Restaurant Order Entry',b'Restaurantbestellung'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +134',b'Debit and Credit not equal for {0} #{1}. Difference is {2}.',b'Soll und Haben nicht gleich f\xc3\xbcr {0} #{1}. Unterschied ist {2}.'
+b'DocType: Asset Maintenance Task',b'Assign To Name',b'Zu Name zuweisen'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98',b'Entertainment Expenses',b'Bewirtungskosten'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98',b'Make Material Request',b'Materialanforderung anlegen'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20',b'Open Item {0}',b'Offene-Posten {0}'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222',b'Sales Invoice {0} must be cancelled before cancelling this Sales Order',b'Ausgangsrechnung {0} muss vor Stornierung dieses Kundenauftrags abgebrochen werden'
+b'DocType: Consultation',b'Age',b'Alter'
+b'DocType: Sales Invoice Timesheet',b'Billing Amount',b'Rechnungsbetrag'
+b'DocType: Cash Flow Mapping',b'Select Maximum Of 1',b'W\xc3\xa4hlen Sie Maximal 1 aus'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84',b'Invalid quantity specified for item {0}. Quantity should be greater than 0.',b'Ung\xc3\xbcltzige Anzahl f\xc3\xbcr Artikel {0} angegeben. Anzahl sollte gr\xc3\xb6\xc3\x9fer als 0 sein.'
+b'DocType: Company',b'Default Employee Advance Account',b'Standard Mitarbeiter Advance Account'
+b'apps/erpnext/erpnext/config/hr.py +60',b'Applications for leave.',b'Urlaubsantr\xc3\xa4ge'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +164',b'Account with existing transaction can not be deleted',b'Ein Konto mit bestehenden Transaktionen kann nicht gel\xc3\xb6scht werden'
+b'DocType: Vehicle',b'Last Carbon Check',b'Last Kohlenstoff pr\xc3\xbcfen'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102',b'Legal Expenses',b'Rechtskosten'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140',b'Please select quantity on row ',b'Bitte w\xc3\xa4hlen Sie die Menge aus'
+b'apps/erpnext/erpnext/config/accounts.py +277',b'Make Opening Sales and Purchase Invoices',b'Machen Sie offene Rechnungen f\xc3\xbcr Verkauf und Kauf'
+b'DocType: Purchase Invoice',b'Posting Time',b'Buchungszeit'
+b'DocType: Timesheet',b'% Amount Billed',b'% des Betrages berechnet'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118',b'Telephone Expenses',b'Telefonkosten'
+b'DocType: Sales Partner',b'Logo',b'Logo'
+b'DocType: Naming Series',b'Check this if you want to force the user to select a series before saving. There will be no default if you check this.',"b'Hier aktivieren, wenn der Benutzer gezwungen sein soll, vor dem Speichern eine Serie auszuw\xc3\xa4hlen. Bei Aktivierung gibt es keine Standardvorgabe.'"
+b'apps/erpnext/erpnext/stock/get_item_details.py +131',b'No Item with Serial No {0}',b'Kein Artikel mit Seriennummer {0}'
+b'DocType: Email Digest',b'Open Notifications',b'Offene Benachrichtigungen'
+b'DocType: Payment Entry',b'Difference Amount (Company Currency)',b'Differenzbetrag (Gesellschaft W\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79',b'Direct Expenses',b'Direkte Aufwendungen'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60',b'New Customer Revenue',b'Neuer Kundenumsatz'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119',b'Travel Expenses',b'Reisekosten'
+b'DocType: Maintenance Visit',b'Breakdown',b'Ausfall'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50',b'Add custom field Subscription in the doctype {0}',b'Benutzerdefiniertes Feld Abonnement im Doctype {0} hinzuf\xc3\xbcgen'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +820',b'Account: {0} with currency: {1} can not be selected',b'Konto: {0} mit W\xc3\xa4hrung: {1} kann nicht ausgew\xc3\xa4hlt werden'
+b'DocType: Purchase Receipt Item',b'Sample Quantity',b'Beispielmenge'
+b'DocType: Manufacturing Settings',"b'Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.'","b'Aktualisieren Sie die St\xc3\xbccklistenkosten automatisch \xc3\xbcber den Scheduler, basierend auf dem aktuellen Bewertungspreis / Preisliste / letzter Kaufpreis der Rohstoffe.'"
+b'DocType: Bank Reconciliation Detail',b'Cheque Date',b'Scheckdatum'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +50',b'Account {0}: Parent account {1} does not belong to company: {2}',b'Konto {0}: \xc3\x9cber-Konto {1} geh\xc3\xb6rt nicht zur Firma: {2}'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +106',b'Successfully deleted all transactions related to this company!',b'Alle Transaktionen dieser Firma wurden erfolgreich gel\xc3\xb6scht!'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27',b'As on Date',b'Zum'
+b'DocType: Appraisal',b'HR',b'HR'
+b'DocType: Program Enrollment',b'Enrollment Date',b'Enrollment Datum'
+b'DocType: Healthcare Settings',b'Out Patient SMS Alerts',b'SMS-Benachrichtungen f\xc3\xbcr ambulante Patienten'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100',b'Probation',b'Probezeit'
+b'apps/erpnext/erpnext/config/hr.py +115',b'Salary Components',b'Gehaltskomponenten'
+b'DocType: Program Enrollment Tool',b'New Academic Year',b'Neues Studienjahr'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811',b'Return / Credit Note',b'Return / Gutschrift'
+b'DocType: Stock Settings',b'Auto insert Price List rate if missing',"b'Preisliste automatisch einf\xc3\xbcgen, wenn sie fehlt'"
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +117',b'Total Paid Amount',b'Summe gezahlte Betr\xc3\xa4ge'
+b'DocType: GST Settings',b'B2C Limit',b'B2C-Grenze'
+b'DocType: Work Order Item',b'Transferred Qty',b'\xc3\x9cbergebene Menge'
+b'apps/erpnext/erpnext/config/learn.py +11',b'Navigating',b'Navigieren'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188',b'Planning',b'Planung'
+b'DocType: Share Balance',b'Issued',b'Ausgestellt'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14',b'Student Activity',b'Studentische T\xc3\xa4tigkeit'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80',b'Supplier Id',b'Lieferanten-ID'
+b'DocType: Payment Request',b'Payment Gateway Details',b'Payment Gateway-Details'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276',b'Quantity should be greater than 0',b'Menge sollte gr\xc3\xb6\xc3\x9fer 0 sein'
+b'DocType: Journal Entry',b'Cash Entry',b'Kassenbuchung'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17',"b""Child nodes can be only created under 'Group' type nodes""",b'Kindknoten k\xc3\xb6nnen nur unter Gruppenknoten erstellt werden.'
+b'DocType: Leave Application',b'Half Day Date',b'Halbtagesdatum'
+b'DocType: Academic Year',b'Academic Year Name',b'Schuljahr-Bezeichnung'
+b'DocType: Sales Partner',b'Contact Desc',b'Kontakt-Beschr.'
+b'apps/erpnext/erpnext/config/hr.py +65',"b'Type of leaves like casual, sick etc.'","b'Grund f\xc3\xbcr Beurlaubung, wie Erholung, krank usw.'"
+b'DocType: Email Digest',b'Send regular summary reports via Email.',b'Regelm\xc3\xa4\xc3\x9fig zusammenfassende Berichte per E-Mail senden.'
+b'DocType: Payment Entry',b'PE-',b'PE-'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282',b'Please set default account in Expense Claim Type {0}',b'Bitte setzen Sie Standardkonto in Kostenabrechnung Typ {0}'
+b'DocType: Assessment Result',b'Student Name',b'Name des Studenten'
+b'DocType: Brand',b'Item Manager',b'Artikel-Manager'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143',b'Payroll Payable',b'Payroll Kreditoren'
+b'DocType: Buying Settings',b'Default Supplier Type',b'Standardlieferantentyp'
+b'DocType: Plant Analysis',b'Collection Datetime',b'Sammlung Datetime'
+b'DocType: Work Order',b'Total Operating Cost',b'Gesamtbetriebskosten'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171',b'Note: Item {0} entered multiple times',b'Hinweis: Artikel {0} mehrfach eingegeben'
+b'apps/erpnext/erpnext/config/selling.py +41',b'All Contacts.',b'Alle Kontakte'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Company Abbreviation',b'Firmenk\xc3\xbcrzel'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47',b'User {0} does not exist',b'Benutzer {0} existiert nicht'
+b'DocType: Payment Term',b'Day(s) after invoice date',b'Tag (e) nach Rechnungsdatum'
+b'DocType: Payment Schedule',b'Payment Schedule',b'Zahlungsplan'
+b'DocType: Subscription',b'SUB-',b'SUB-'
+b'DocType: Item Attribute Value',b'Abbreviation',b'Abk\xc3\xbcrzung'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195',b'Payment Entry already exists',b'Zahlung existiert bereits'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36',b'Not authroized since {0} exceeds limits',b'Keine Berechtigung da {0} die H\xc3\xb6chstgrenzen \xc3\xbcberschreitet'
+b'apps/erpnext/erpnext/config/hr.py +110',b'Salary template master.',b'Stammdaten zur Gehaltsvorlage'
+b'apps/erpnext/erpnext/healthcare/setup.py +241',b'Pathology',b'Pathologie'
+b'DocType: Restaurant Order Entry',b'Restaurant Table',b'Restaurant-Tisch'
+b'DocType: Hotel Room',b'Hotel Manager',b'Hotelmanager'
+b'DocType: Leave Type',b'Max Days Leave Allowed',b'Maximal zul\xc3\xa4ssige Urlaubstage'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63',b'Set Tax Rule for shopping cart',b'Steuerregel f\xc3\xbcr Einkaufswagen einstellen'
+b'DocType: Purchase Invoice',b'Taxes and Charges Added',b'Steuern und Geb\xc3\xbchren hinzugef\xc3\xbcgt'
+,b'Sales Funnel',b'Verkaufstrichter'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +49',b'Abbreviation is mandatory',b'Abk\xc3\xbcrzung ist zwingend erforderlich'
+b'DocType: Project',b'Task Progress',b'Vorgangsentwicklung'
+b'apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7',b'Cart',b'Einkaufswagen'
+,b'Qty to Transfer',b'Zu versendende Menge'
+b'apps/erpnext/erpnext/config/selling.py +13',b'Quotes to Leads or Customers.',b'Angebote an Leads oder Kunden'
+b'DocType: Stock Settings',b'Role Allowed to edit frozen stock',b'Rolle darf gesperrten Bestand bearbeiten'
+,b'Territory Target Variance Item Group-Wise',b'Artikelgruppenbezogene regionale Zielabweichung'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143',b'All Customer Groups',b'Alle Kundengruppen'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114',b'Accumulated Monthly',b'Monatlich akkumuliert'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +781',b'{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.',b'{0} ist zwingend erforderlich. M\xc3\xb6glicherweise wurde der Datensatz f\xc3\xbcr die W\xc3\xa4hrungsumrechung f\xc3\xbcr {1} bis {2} nicht erstellt.'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44',b'Tax Template is mandatory.',b'Steuer-Vorlage ist erforderlich.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +44',b'Account {0}: Parent account {1} does not exist',b'Konto {0}: Hauptkonto {1} existiert nicht'
+b'DocType: Purchase Invoice Item',b'Price List Rate (Company Currency)',b'Preisliste\xc2\xa0(Firmenw\xc3\xa4hrung)'
+b'DocType: Products Settings',b'Products Settings',b'Produkte Einstellungen'
+,b'Item Price Stock',b'Artikel Preis Lagerbestand'
+b'DocType: Lab Prescription',b'Test Created',b'Test erstellt'
+b'DocType: Healthcare Settings',b'Custom Signature in Print',b'Kundenspezifische Unterschrift im Druck'
+b'DocType: Account',b'Temporary',b'Tempor\xc3\xa4r'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +107',b'Customer LPO No.',b'Kunden-LPO-Nr.'
+b'DocType: Program',b'Courses',b'Kurse'
+b'DocType: Monthly Distribution Percentage',b'Percentage Allocation',b'Prozentuale Aufteilung'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128',b'Secretary',b'Sekret\xc3\xa4rin'
+b'DocType: Global Defaults',"b""If disable, 'In Words' field will not be visible in any transaction""","b'Wenn deaktivieren, wird &quot;in den W\xc3\xb6rtern&quot; Feld nicht in einer Transaktion sichtbar sein'"
+b'DocType: Serial No',b'Distinct unit of an Item',b'Eindeutige Einheit eines Artikels'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Name',b'Kriterien Name'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295',b'Please set Company',b'Bitte setzen Unternehmen'
+b'DocType: Pricing Rule',b'Buying',b'Einkauf'
+b'apps/erpnext/erpnext/config/agriculture.py +24',b'Diseases & Fertilizers',b'Krankheiten und D\xc3\xbcnger'
+b'DocType: HR Settings',b'Employee Records to be created by',b'Mitarbeiter-Datens\xc3\xa4tze werden erstellt nach'
+b'DocType: Patient',b'AB Negative',b'AB -'
+b'DocType: Sample Collection',b'SMPL-',b'SMPL-'
+b'DocType: POS Profile',b'Apply Discount On',b'Rabatt anwenden auf'
+b'DocType: Member',b'Membership Type',b'Art der Mitgliedschaft'
+,b'Reqd By Date',b'Ben\xc3\xb6tigt nach Datum'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140',b'Creditors',b'Gl\xc3\xa4ubiger'
+b'DocType: Assessment Plan',b'Assessment Name',b'Name der Beurteilung'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94',b'Show PDC in Print',b'Zeige PDC im Druck'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97',b'Row # {0}: Serial No is mandatory',b'Zeile # {0}: Seriennummer ist zwingend erforderlich'
+b'DocType: Purchase Taxes and Charges',b'Item Wise Tax Detail',b'Artikelbezogene Steuer-Details'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13',b'Job Offer',b'Jobangebot'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Institute Abbreviation',b'Abk\xc3\xbcrzung des Institutes'
+,b'Item-wise Price List Rate',b'Artikelbezogene Preisliste'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082',b'Supplier Quotation',b'Lieferantenangebot'
+b'DocType: Quotation',b'In Words will be visible once you save the Quotation.',"b'""In Worten"" wird sichtbar, sobald Sie das Angebot speichern.'"
+b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Menge ({0}) kann in Zeile {1} keine Teilmenge sein'
+b'DocType: Consultation',b'C-',b'C-'
+b'DocType: Attendance',b'ATT-',b'ATT-'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +492',b'Barcode {0} already used in Item {1}',b'Barcode {0} wird bereits f\xc3\xbcr Artikel {1} verwendet'
+b'apps/erpnext/erpnext/config/selling.py +86',b'Rules for adding shipping costs.',b'Regeln f\xc3\xbcr das Hinzuf\xc3\xbcgen von Versandkosten.'
+b'DocType: Hotel Room',b'Extra Bed Capacity',b'Zusatzbett Kapazit\xc3\xa4t'
+b'DocType: Item',b'Opening Stock',b'Anfangsbestand'
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20',b'Customer is required',b'Kunde ist verpflichtet'
+b'DocType: Lab Test',b'Result Date',b'Ergebnis Datum'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77',b'PDC/LC Date',b'PDC / LC Datum'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20',b'{0} is mandatory for Return',"b'{0} ist zwingend f\xc3\xbcr ""Zur\xc3\xbcck""'"
+b'DocType: Purchase Order',b'To Receive',b'Um zu empfangen'
+b'apps/erpnext/erpnext/utilities/user_progress.py +252',b'user@example.com',b'nutzer@kundendomain.tld'
+b'DocType: Asset',b'Asset Owner',b'Eigent\xc3\xbcmer der Anlage'
+b'DocType: Employee',b'Personal Email',b'Pers\xc3\xb6nliche E-Mail'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57',b'Total Variance',b'Gesamtabweichung'
+b'DocType: Accounts Settings',"b'If enabled, the system will post accounting entries for inventory automatically.'","b'Wenn aktiviert, bucht das System Bestandsbuchungen automatisch.'"
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15',b'Brokerage',b'Maklerprovision'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195',b'Attendance for employee {0} is already marked for this day',b'Die Teilnahme f\xc3\xbcr Mitarbeiter {0} ist bereits f\xc3\xbcr diesen Tag markiert'
+b'DocType: Work Order Operation',"b""in Minutes\nUpdated via 'Time Log'""","b'""In Minuten"" \xc3\xbcber \'Zeitprotokoll\' aktualisiert'"
+b'DocType: Customer',b'From Lead',b'Von Lead'
+b'apps/erpnext/erpnext/config/manufacturing.py +13',b'Orders released for production.',b'F\xc3\xbcr die Produktion freigegebene Bestellungen'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +65',b'Select Fiscal Year...',b'Gesch\xc3\xa4ftsjahr ausw\xc3\xa4hlen ...'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567',b'POS Profile required to make POS Entry',"b'Verkaufsstellen-Profil ben\xc3\xb6tigt, um Verkaufsstellen-Buchung zu erstellen'"
+b'DocType: Program Enrollment Tool',b'Enroll Students',b'einschreiben Studenten'
+b'DocType: Lab Test',b'Approved Date',b'Genehmigter Termin'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21',b'Standard Selling',b'Standard-Vertrieb'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165',b'Atleast one warehouse is mandatory',b'Mindestens ein Lager ist zwingend erforderlich'
+b'DocType: Serial No',b'Out of Warranty',b'Au\xc3\x9ferhalb der Garantie'
+b'DocType: BOM Update Tool',b'Replace',b'Ersetzen'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +42',b'No products found.',b'Keine Produkte gefunden'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360',b'{0} against Sales Invoice {1}',b'{0} zu Verkaufsrechnung {1}'
+b'DocType: Antibiotic',b'Laboratory User',b'Laborbenutzer'
+b'DocType: Sales Invoice',b'SINV-',b'SINV-'
+b'DocType: Request for Quotation Item',b'Project Name',b'Projektname'
+b'DocType: Customer',b'Mention if non-standard receivable account',"b'Vermerken, wenn es sich um kein Standard-Forderungskonto handelt'"
+b'DocType: Journal Entry Account',b'If Income or Expense',b'Wenn Ertrag\xc2\xa0oder Aufwand'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288',b'Select interest income account in employee loan {0}',b'Zinsertragskonto in Mitarbeiterdarlehen ausw\xc3\xa4hlen {0}'
+b'DocType: Work Order',b'Required Items',b'Erforderliche Elemente'
+b'DocType: Stock Ledger Entry',b'Stock Value Difference',b'Lagerwert-Differenz'
+b'apps/erpnext/erpnext/config/learn.py +229',b'Human Resource',b'Personal'
+b'DocType: Payment Reconciliation Payment',b'Payment Reconciliation Payment',b'Zahlung zum Zahlungsabgleich'
+b'DocType: Disease',b'Treatment Task',b'Behandlungsaufgabe'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38',b'Tax Assets',b'Steuerguthaben'
+b'DocType: BOM Item',b'BOM No',b'St\xc3\xbccklisten-Nr.'
+b'DocType: Instructor',b'INS/',b'INS /'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160',b'Journal Entry {0} does not have account {1} or already matched against other voucher',b'Buchungssatz {0} geh\xc3\xb6rt nicht zu Konto {1} oder ist bereits mit einem anderen Beleg abgeglichen'
+b'DocType: Item',b'Moving Average',b'Gleitender Durchschnitt'
+b'DocType: BOM Update Tool',b'The BOM which will be replaced',"b'Die St\xc3\xbcckliste (BOM), wird ersetzt.'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46',b'Electronic Equipments',b'Elektronische Ausr\xc3\xbcstungen'
+b'DocType: Asset',b'Maintenance Required',b'Wartung erforderlich'
+b'DocType: Account',b'Debit',b'Soll'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49',b'Leaves must be allocated in multiples of 0.5',"b'Abwesenheiten m\xc3\xbcssen ein Vielfaches von 0,5 sein'"
+b'DocType: Work Order',b'Operation Cost',b'Kosten eines Arbeitsgangs'
+b'apps/erpnext/erpnext/config/hr.py +29',b'Upload attendance from a .csv file',b'Anwesenheiten aus einer CSV-Datei hochladen'
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45',b'Outstanding Amt',b'Offener Betrag'
+b'DocType: Sales Person',b'Set targets Item Group-wise for this Sales Person.',b'Ziele artikelgruppenbezogen f\xc3\xbcr diesen Vertriebsmitarbeiter festlegen.'
+b'DocType: Stock Settings',b'Freeze Stocks Older Than [Days]',b'Best\xc3\xa4nde \xc3\xa4lter als [Tage] sperren'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +600',b'Row #{0}: Asset is mandatory for fixed asset purchase/sale',b'Row # {0}: Verm\xc3\xb6gens ist obligatorisch f\xc3\xbcr Anlage Kauf / Verkauf'
+b'DocType: Asset Maintenance Team',b'Maintenance Team Name',b'Name des Wartungsteams'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42',"b'If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.'","b'Wenn zwei oder mehrere Preisregeln basierend auf den oben genannten Bedingungen gefunden werden, wird eine Vorrangregelung angewandt. Priorit\xc3\xa4t ist eine Zahl zwischen 0 und 20, wobei der Standardwert Null (leer) ist. Die h\xc3\xb6here Zahl hat  Vorrang, wenn es mehrere Preisregeln zu den gleichen Bedingungen gibt.'"
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197',"b""Customer is mandatory if 'Opportunity From' is selected as Customer""","b'Der Kunde ist obligatorisch, wenn &quot;Verkaufschance&quot; als Kunde ausgew\xc3\xa4hlt wurde'"
+b'apps/erpnext/erpnext/controllers/trends.py +36',b'Fiscal Year: {0} does not exists',b'Gesch\xc3\xa4ftsjahr: {0} existiert nicht'
+b'DocType: Currency Exchange',b'To Currency',b'In W\xc3\xa4hrung'
+b'DocType: Leave Block List',b'Allow the following users to approve Leave Applications for block days.',"b'Zulassen, dass die folgenden Benutzer Urlaubsantr\xc3\xa4ge f\xc3\xbcr Bl\xc3\xb6cke von Tagen genehmigen k\xc3\xb6nnen.'"
+b'apps/erpnext/erpnext/config/hr.py +137',b'Types of Expense Claim.',b'Arten der Aufwandsabrechnung'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'Der Verkaufspreis f\xc3\xbcr Artikel {0} ist niedriger als {1}. Der Verkaufspreis sollte wenigstens {2} sein.'
+b'DocType: Item',b'Taxes',b'Steuern'
+b'DocType: Purchase Invoice',b'capital goods',b'Kapitalg\xc3\xbcter'
+b'DocType: Purchase Invoice Item',b'Weight Per Unit',b'Gewicht pro Einheit'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344',b'Paid and Not Delivered',b'Bezahlt und nicht ausgeliefert'
+b'DocType: Project',b'Default Cost Center',b'Standardkostenstelle'
+b'DocType: Bank Guarantee',b'End Date',b'Enddatum'
+b'apps/erpnext/erpnext/config/stock.py +7',b'Stock Transactions',b'Lagerbuchungen'
+b'DocType: Budget',b'Budget Accounts',b'Budget Konten'
+b'DocType: Employee',b'Internal Work History',b'Interne Arbeits-Historie'
+b'DocType: Depreciation Schedule',b'Accumulated Depreciation Amount',b'Aufgelaufener Abschreibungsbetrag'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42',b'Private Equity',b'Kapitalbeteiligungsgesellschaft'
+b'DocType: Supplier Scorecard Variable',b'Supplier Scorecard Variable',b'Supplier Scorecard Variable'
+b'DocType: Employee Loan',b'Fully Disbursed',b'in voller H\xc3\xb6he ausgezahlt'
+b'DocType: Employee Advance',b'Due Advance Amount',b'F\xc3\xa4lliger Vorschussbetrag'
+b'DocType: Maintenance Visit',b'Customer Feedback',b'Kundenr\xc3\xbcckmeldung'
+b'DocType: Account',b'Expense',b'Kosten'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54',b'Score cannot be greater than Maximum Score',b'Score kann nicht gr\xc3\xb6\xc3\x9fer sein als maximale Punktzahl'
+b'apps/erpnext/erpnext/utilities/user_progress.py +129',b'Customers and Suppliers',b'Kunden und Lieferanten'
+b'DocType: Item Attribute',b'From Range',b'Von-Bereich'
+b'DocType: BOM',b'Set rate of sub-assembly item based on BOM',b'Setzen Sie die Menge der Unterbaugruppe auf der Grundlage der St\xc3\xbcckliste'
+b'DocType: Hotel Room Reservation',b'Invoiced',b'In Rechnung gestellt'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98',b'Syntax error in formula or condition: {0}',b'Syntaxfehler in Formel oder Bedingung: {0}'
+b'DocType: Daily Work Summary Settings Company',b'Daily Work Summary Settings Company',b't\xc3\xa4gliche Arbeitszusammenfassung-Einstellungen Ihrer Firma'
+b'apps/erpnext/erpnext/stock/utils.py +125',b'Item {0} ignored since it is not a stock item',"b'Artikel {0} ignoriert, da es sich nicht um einen Lagerartikel handelt'"
+b'DocType: Appraisal',b'APRSL',b'APRSL'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23',"b'To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.'","b'Um Preisregeln in einer bestimmten Transaktion nicht zu verwenden, sollten alle geltenden Preisregeln deaktiviert sein.'"
+b'DocType: Payment Term',b'Day(s) after the end of the invoice month',b'Tag (e) nach dem Ende des Rechnungsmonats'
+b'DocType: Assessment Group',b'Parent Assessment Group',b'\xc3\x9cbergeordnete Bewertungsgruppe'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27',b'Jobs',b'Arbeitspl\xc3\xa4tze'
+,b'Sales Order Trends',b'Trendanalyse Kundenauftr\xc3\xa4ge'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51',"b""The 'From Package No.' field must neither be empty nor it's value less than 1.""",b'Die &#39;Von Paketnummer&#39; Das Feld darf weder leer sein noch einen Wert kleiner als 1 haben.'
+b'DocType: Employee',b'Held On',b'Festgehalten am'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36',b'Production Item',b'Produktions-Artikel'
+,b'Employee Information',b'Mitarbeiterinformationen'
+b'DocType: Stock Entry Detail',b'Additional Cost',b'Zus\xc3\xa4tzliche Kosten'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48',"b'Can not filter based on Voucher No, if grouped by Voucher'","b'Wenn nach Beleg gruppiert wurde, kann nicht auf Grundlage von Belegen gefiltert werden.'"
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918',b'Make Supplier Quotation',b'Lieferantenangebot erstellen'
+b'DocType: Quality Inspection',b'Incoming',b'Eingehend'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +70',b'Default tax templates for sales and purchase are created.',b'Standardsteuervorlagen f\xc3\xbcr Verkauf und Einkauf werden erstellt.'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57',b'Assessment Result record {0} already exists.',b'Beurteilungsergebnis {0} existiert bereits.'
+b'DocType: BOM',b'Materials Required (Exploded)',b'Ben\xc3\xb6tigte Materialien (erweitert)'
+b'apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60',"b""Please set Company filter blank if Group By is 'Company'""","b'Bitte setzen Sie den Firmenfilter leer, wenn Group By &quot;Company&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66',b'Posting Date cannot be future date',b'Buchungsdatum kann nicht Datum in der Zukunft sein'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102',b'Row # {0}: Serial No {1} does not match with {2} {3}',b'Zeile # {0}: Seriennummer {1} stimmt nicht mit {2} {3} \xc3\xbcberein'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'for generating the recurring',b'zur Erzeugung der wiederkehrenden'
+b'DocType: Stock Entry',b'Target Warehouse Address',b'Ziellageradresse'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86',b'Casual Leave',b'Erholungsurlaub'
+b'DocType: Agriculture Task',b'End Day',b'Ende Tag'
+b'DocType: Batch',b'Batch ID',b'Chargen-ID'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380',b'Note: {0}',b'Hinweis: {0}'
+,b'Delivery Note Trends',b'Entwicklung Lieferscheine'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112',"b""This Week's Summary""",b'Zusammenfassung dieser Woche'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22',b'In Stock Qty',b'Anzahl auf Lager'
+b'DocType: Delivery Trip',b'Calculate Estimated Arrival Times',b'Berechnen Sie die voraussichtliche Ankunftszeit'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +113',b'Account: {0} can only be updated via Stock Transactions',b'Konto: {0} kann nur \xc3\xbcber Lagertransaktionen aktualisiert werden'
+b'DocType: Student Group Creation Tool',b'Get Courses',b'Erhalten Sie Kurse'
+b'DocType: GL Entry',b'Party',b'Gruppe'
+b'DocType: Healthcare Settings',b'Patient Name',b'Patientenname'
+b'DocType: Variant Field',b'Variant Field',b'Variantfeld'
+b'DocType: Sales Order',b'Delivery Date',b'Liefertermin'
+b'DocType: Opportunity',b'Opportunity Date',b'Datum der Chance'
+b'DocType: Employee',b'Health Insurance Provider',b'Krankenversicherer'
+b'DocType: Purchase Receipt',b'Return Against Purchase Receipt',b'Zur\xc3\xbcck zum Kaufbeleg'
+b'DocType: Water Analysis',b'Person Responsible',b'Verantwortliche Person'
+b'DocType: Request for Quotation Item',b'Request for Quotation Item',b'Angebotsanfrage Artikel'
+b'DocType: Purchase Order',b'To Bill',b'Abrechnen'
+b'DocType: Material Request',b'% Ordered',b'% bestellt'
+b'DocType: Education Settings',"b'For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.'",b'F\xc3\xbcr die Kursbasierte Studentengruppe wird der Kurs f\xc3\xbcr jeden Sch\xc3\xbcler aus den eingeschriebenen Kursen in der Programmregistrierung validiert.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103',b'Piecework',b'Akkordarbeit'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70',b'Avg. Buying Rate',b'Durchschnittlicher Einkaufspreis'
+b'DocType: Share Balance',b'From No',b'Von Nr'
+b'DocType: Task',b'Actual Time (in Hours)',b'Tats\xc3\xa4chliche Zeit (in Stunden)'
+b'DocType: Employee',b'History In Company',b'Historie im Unternehmen'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270',b'New Message from {sender}',b'Neue Nachricht von {Absender}'
+b'DocType: Customer',b'Customer Primary Address',b'Hauptadresse des Kunden'
+b'apps/erpnext/erpnext/config/learn.py +107',b'Newsletters',b'Newsletter'
+b'DocType: Drug Prescription',b'Description/Strength',b'Beschreibung / St\xc3\xa4rke'
+b'DocType: Share Balance',b'Is Company',b'Ist die Firma'
+b'DocType: Stock Ledger Entry',b'Stock Ledger Entry',b'Buchung im Lagerbuch'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83',b'Same item has been entered multiple times',b'Das gleiche Einzelteil wurde mehrfach eingegeben'
+b'DocType: Department',b'Leave Block List',b'Urlaubssperrenliste'
+b'DocType: Purchase Invoice',b'Tax ID',b'Steuer ID'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192',b'Item {0} is not setup for Serial Nos. Column must be blank',b'Artikel {0} ist nicht f\xc3\xbcr Seriennummern eingerichtet. Spalte muss leer sein'
+b'DocType: Accounts Settings',b'Accounts Settings',b'Konteneinstellungen'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11',b'Approve',b'Genehmigen'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69',"b'Malformatted address for {0}, please fix to continue.'","b'Malformatierte Adresse f\xc3\xbcr {0}, bitte korrigieren, um fortzufahren.'"
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28',"b'Number of new Account, it will be included in the account name as a prefix'",b'Die Nummer des neuen Kontos wird als Pr\xc3\xa4fix in den Kontonamen aufgenommen'
+b'DocType: Maintenance Team Member',b'Team Member',b'Teammitglied'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151',b'No Result to submit',b'Kein Ergebnis zur Einreichung'
+b'DocType: Customer',b'Sales Partner and Commission',b'Vertriebspartner und Verprovisionierung'
+b'DocType: Employee Loan',b'Rate of Interest (%) / Year',b'Zinssatz (%) / Jahr'
+,b'Project Quantity',b'Projekt Menge'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79',"b""Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'""","b'Insgesamt {0} f\xc3\xbcr alle Elemente gleich Null ist, sein kann, sollten Sie &quot;Verteilen Geb\xc3\xbchren auf der Grundlage&quot; \xc3\xa4ndern'"
+b'DocType: Opportunity',b'To Discuss',b'Infos zur Diskussion'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +377',b'{0} units of {1} needed in {2} to complete this transaction.',b'{0} Einheiten von {1} ben\xc3\xb6tigt in {2} zum Abschluss dieser Transaktion.'
+b'DocType: Loan Type',b'Rate of Interest (%) Yearly',b'Zinssatz (%) Jahres'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71',b'Temporary Accounts',b'Tempor\xc3\xa4re Konten'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207',b'Black',b'Schwarz'
+b'DocType: BOM Explosion Item',b'BOM Explosion Item',b'Position der aufgel\xc3\xb6sten St\xc3\xbcckliste'
+b'DocType: Shareholder',b'Contact List',b'Kontaktliste'
+b'DocType: Account',b'Auditor',b'Pr\xc3\xbcfer'
+b'DocType: Project',b'Frequency To Collect Progress',"b'H\xc3\xa4ufigkeit, um Fortschritte zu sammeln'"
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132',b'{0} items produced',b'{0} Elemente hergestellt'
+b'apps/erpnext/erpnext/utilities/user_progress.py +58',b'Learn More',b'Erfahren Sie mehr'
+b'DocType: Cheque Print Template',b'Distance from top edge',b'Die Entfernung von der Oberkante'
+b'apps/erpnext/erpnext/stock/get_item_details.py +367',b'Price List {0} is disabled or does not exist',b'Preisliste {0} ist deaktiviert oder nicht vorhanden ist'
+b'DocType: Purchase Invoice',b'Return',b'Zur\xc3\xbcck'
+b'DocType: Pricing Rule',b'Disable',b'Deaktivieren'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180',b'Mode of payment is required to make a payment',"b'Modus der Zahlung ist erforderlich, um eine Zahlung zu leisten'"
+b'DocType: Project Task',b'Pending Review',b'Wartet auf \xc3\x9cberpr\xc3\xbcfung'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14',"b'Edit in full page for more options like assets, serial nos, batches etc.'","b'Bearbeiten Sie in Vollansicht f\xc3\xbcr weitere Optionen wie Assets, Seriennummern, Chargen usw.'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10',b'Appointments and Consultations',b'Termine und Konsultationen'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41',b'{0} - {1} is not enrolled in the Batch {2}',b'{0} - {1} ist nicht im Batch {2}'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113',"b'Asset {0} cannot be scrapped, as it is already {1}'",b'Anlagewert-{0} ist bereits entsorgt {1}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77',b'Cheques Required',b'\xc3\x9cberpr\xc3\xbcfungen erforderlich'
+b'DocType: Task',b'Total Expense Claim (via Expense Claim)',b'Gesamtbetrag der Aufwandsabrechnung (\xc3\xbcber Aufwandsabrechnung)'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177',b'Mark Absent',b'Abwesend setzen'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40',b'Failed to setup company',b'Fehler beim Einrichten der Firma'
+b'DocType: Asset Repair',b'Asset Repair',b'Anlagenreparatur'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143',b'Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}',b'Row {0}: W\xc3\xa4hrung der BOM # {1} sollte auf die gew\xc3\xa4hlte W\xc3\xa4hrung gleich {2}'
+b'DocType: Journal Entry Account',b'Exchange Rate',b'Wechselkurs'
+b'DocType: Patient',b'Additional information regarding the patient',b'Zus\xc3\xa4tzliche Informationen zum Patienten'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585',b'Sales Order {0} is not submitted',b'Kundenauftrag {0} wurde nicht \xc3\xbcbertragen'
+b'DocType: Homepage',b'Tag Line',b'Tag-Linie'
+b'DocType: Fee Component',b'Fee Component',b'Fee-Komponente'
+b'apps/erpnext/erpnext/config/hr.py +204',b'Fleet Management',b'Flottenmanagement'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080',b'Add items from',b'Elemente hinzuf\xc3\xbcgen aus'
+b'apps/erpnext/erpnext/config/agriculture.py +7',b'Crops & Lands',b'Kulturen und L\xc3\xa4nder'
+b'DocType: Cheque Print Template',b'Regular',b'Regul\xc3\xa4r'
+b'DocType: Fertilizer',b'Density (if liquid)',b'Dichte (falls fl\xc3\xbcssig)'
+b'apps/erpnext/erpnext/education/doctype/course/course.py +20',b'Total Weightage of all Assessment Criteria must be 100%',b'Insgesamt weightage aller Bewertungskriterien muss 100% betragen'
+b'DocType: Purchase Order Item',b'Last Purchase Rate',b'Letzter Anschaffungspreis'
+b'DocType: Account',b'Asset',b'Verm\xc3\xb6genswert'
+b'DocType: Project Task',b'Task ID',b'Aufgaben-ID'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84',b'Stock cannot exist for Item {0} since has variants',"b'F\xc3\xbcr Artikel {0} kann es kein Lager geben, da es Varianten gibt'"
+b'DocType: Lab Test',b'Mobile',b'Mobile'
+,b'Sales Person-wise Transaction Summary',b'Vertriebsmitarbeiterbezogene Zusammenfassung der Transaktionen'
+b'DocType: Training Event',b'Contact Number',b'Kontaktnummer'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73',b'Warehouse {0} does not exist',b'Lager {0} existiert nicht'
+b'DocType: Monthly Distribution',b'Monthly Distribution Percentages',b'Prozentuale Aufteilungen der monatsweisen Verteilung'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +110',b'The selected item cannot have Batch',b'Der ausgew\xc3\xa4hlte Artikel kann keine Charge haben'
+b'DocType: Delivery Note',b'% of materials delivered against this Delivery Note',b'% dieser Lieferscheinmenge geliefert'
+b'DocType: Asset Maintenance Log',b'Has Certificate',b'Hat Zertifikat'
+b'DocType: Project',b'Customer Details',b'Kundendaten'
+b'DocType: Asset',b'Check if Asset requires Preventive Maintenance or Calibration',"b'\xc3\x9cberpr\xc3\xbcfen Sie, ob das Asset eine vorbeugende Wartung oder Kalibrierung erfordert'"
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +87',b'Company Abbreviation cannot have more than 5 characters',b'Firmenk\xc3\xbcrzel darf nicht mehr als 5 Zeichen haben'
+b'DocType: Employee',b'Reports to',b'Berichte an'
+,b'Unpaid Expense Claim',b'Unbezahlte Kostenabrechnung'
+b'DocType: Payment Entry',b'Paid Amount',b'Gezahlter Betrag'
+b'apps/erpnext/erpnext/utilities/user_progress.py +158',b'Explore Sales Cycle',b'Entdecken Sie den Verkaufszyklus'
+b'DocType: Assessment Plan',b'Supervisor',b'Supervisor'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869',b'Retention Stock Entry',b'Vorratsbestandseintrag'
+,b'Available Stock for Packing Items',b'Verf\xc3\xbcgbarer Bestand f\xc3\xbcr Verpackungsartikel'
+b'DocType: Item Variant',b'Item Variant',b'Artikelvariante'
+,b'Work Order Stock Report',b'Arbeitsauftragsbericht'
+b'DocType: Assessment Result Tool',b'Assessment Result Tool',b'Beurteilungsergebniswerkzeug'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24',b'As Supervisor',b'Als Vorgesetzter'
+b'DocType: BOM Scrap Item',b'BOM Scrap Item',b'BOM Ausschussartikel'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +895',b'Submitted orders can not be deleted',b'\xc3\x9cbermittelt Auftr\xc3\xa4ge k\xc3\xb6nnen nicht gel\xc3\xb6scht werden'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +114',"b""Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'""","b'Konto bereits im Soll, es ist nicht mehr m\xc3\xb6glich das Konto als Habenkonto festzulegen'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118',b'Quality Management',b'Qualit\xc3\xa4tsmanagement'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +41',b'Item {0} has been disabled',b'Artikel {0} wurde deaktiviert'
+b'DocType: Project',b'Total Billable Amount (via Timesheets)',b'Gesamter abrechenbarer Betrag (\xc3\xbcber Arbeitszeittabellen)'
+b'DocType: Agriculture Task',b'Previous Business Day',b'Voriger Gesch\xc3\xa4ftstag'
+b'DocType: Employee Loan',b'Repay Fixed Amount per Period',b'Repay fixen Betrag pro Periode'
+b'DocType: Employee',b'Health Insurance No',b'Krankenversicherung Nr'
+b'apps/erpnext/erpnext/buying/utils.py +47',b'Please enter quantity for Item {0}',b'Bitte die Menge f\xc3\xbcr Artikel {0} eingeben'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Credit Note Amt',b'Kreditnachweis amt'
+b'DocType: Employee External Work History',b'Employee External Work History',b'Externe Berufserfahrung des Mitarbeiters'
+b'DocType: Opening Invoice Creation Tool',b'Purchase',b'Einkauf'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Balance Qty',b'Bilanzmenge'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20',b'Goals cannot be empty',b'Ziele k\xc3\xb6nnen nicht leer sein'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15',b'Enrolling students',b'Einschreibung von Studenten'
+b'DocType: Item Group',b'Parent Item Group',b'\xc3\x9cbergeordnete Artikelgruppe'
+b'DocType: Appointment Type',b'Appointment Type',b'Termintyp'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21',b'{0} for {1}',b'{0} f\xc3\xbcr {1}'
+b'DocType: Healthcare Settings',b'Valid number of days',b'G\xc3\xbcltige Anzahl von Tagen'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +39',b'Cost Centers',b'Kostenstellen'
+b'DocType: Land Unit',b'Linked Plant Analysis',b'Linked-Plant-Analyse'
+b'DocType: Purchase Receipt',"b""Rate at which supplier's currency is converted to company's base currency""","b'Kurs, zu dem die W\xc3\xa4hrung des Lieferanten in die Basisw\xc3\xa4hrung des Unternehmens umgerechnet wird'"
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36',b'Row #{0}: Timings conflicts with row {1}',b'Zeile #{0}: Timing-Konflikte mit Zeile {1}'
+b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Nullbewertung zulassen'
+b'DocType: Training Event Employee',b'Invited',b'Eingeladen'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178',b'Multiple active Salary Structures found for employee {0} for the given dates',b'Mehrere aktive Gehaltsstrukturen f\xc3\xbcr Mitarbeiter gefunden {0} f\xc3\xbcr die angegebenen Daten'
+b'apps/erpnext/erpnext/config/accounts.py +308',b'Setup Gateway accounts.',b'Setup-Gateway-Konten.'
+b'DocType: Employee',b'Employment Type',b'Art der Besch\xc3\xa4ftigung'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42',b'Fixed Assets',b'Anlageverm\xc3\xb6gen'
+b'DocType: Payment Entry',b'Set Exchange Gain / Loss',b'Stellen Sie Exchange-Gewinn / Verlust'
+,b'GST Purchase Register',b'GST Kaufregister'
+,b'Cash Flow',b'Cash Flow'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25',b'Combined invoice portion must equal 100%',b'Der kombinierte Rechnungsanteil muss 100% betragen'
+b'DocType: Item Group',b'Default Expense Account',b'Standardaufwandskonto'
+b'DocType: GST Account',b'CGST Account',b'CGST Konto'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53',b'Student Email ID',b'Studenten E-Mail-ID'
+b'DocType: Employee',b'Notice (days)',b'Meldung(s)(-Tage)'
+b'DocType: Tax Rule',b'Sales Tax Template',b'Umsatzsteuer-Vorlage'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2510',b'Select items to save the invoice',"b'W\xc3\xa4hlen Sie Elemente, um die Rechnung zu speichern'"
+b'DocType: Employee',b'Encashment Date',b'Inkassodatum'
+b'DocType: Training Event',b'Internet',b'Internet'
+b'DocType: Special Test Template',b'Special Test Template',b'Spezielle Testvorlage'
+b'DocType: Account',b'Stock Adjustment',b'Bestandskorrektur'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34',b'Default Activity Cost exists for Activity Type - {0}',b'Es gibt Standard-Aktivit\xc3\xa4tskosten f\xc3\xbcr Aktivit\xc3\xa4tsart - {0}'
+b'DocType: Work Order',b'Planned Operating Cost',b'Geplante Betriebskosten'
+b'DocType: Academic Term',b'Term Start Date',b'Semesteranfang'
+b'apps/erpnext/erpnext/config/accounts.py +471',b'List of all share transactions',b'Liste aller Aktientransaktionen'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'Anzahl der Chancen'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244',b'Please find attached {0} #{1}',b'Bitte Anhang beachten {0} #{1}'
+b'apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52',b'Average Rate',b'Durchschnittsrate'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +728',b'Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total',b'Der gesamte Zahlungsbetrag im Zahlungsplan muss gleich Gro\xc3\x9f / Abgerundet sein'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34',b'Bank Statement balance as per General Ledger',b'Kontoauszug Bilanz nach Hauptbuch'
+b'DocType: Job Applicant',b'Applicant Name',b'Bewerbername'
+b'DocType: Authorization Rule',b'Customer / Item Name',b'Kunde / Artikelname'
+b'DocType: Buying Settings',"b'If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt'","b'Wenn diese Option aktiviert ist, werden die letzten Einkaufsdetails von Artikeln nicht aus fr\xc3\xbcheren Bestellungen oder Kaufquittungen abgerufen'"
+b'DocType: Product Bundle',"b'Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials'","b'Fassen Sie eine Gruppe von Artikeln zu einem neuen Artikel zusammen. Dies ist n\xc3\xbctzlich, wenn Sie bestimmte Artikel zu einem Paket b\xc3\xbcndeln und einen Bestand an Artikel-B\xc3\xbcndeln erhalten und nicht einen Bestand der einzelnen Artikel. Das Artikel-B\xc3\xbcndel erh\xc3\xa4lt f\xc3\xbcr das Attribut ""Ist Lagerartikel"" den Wert ""Nein"" und f\xc3\xbcr das Attribut ""Ist Verkaufsartikel"" den Wert ""Ja"". Beispiel: Wenn Sie Laptops und Tragetaschen getrennt verkaufen und einen bestimmten Preis anbieten, wenn der Kunde beides zusammen kauft, dann wird der Laptop mit der Tasche zusammen ein neuer B\xc3\xbcndel-Artikel. Anmerkung: BOM = St\xc3\xbcckliste'"
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42',b'Serial No is mandatory for Item {0}',b'Seriennummer ist f\xc3\xbcr Artikel {0} zwingend erforderlich'
+b'DocType: Item Variant Attribute',b'Attribute',b'Attribut'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43',b'Please specify from/to range',b'Bitte Von-/Bis-Bereich genau angeben'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28',b'Opening {0} Invoice created',b'Er\xc3\xb6ffnung {0} Rechnung erstellt'
+b'DocType: Serial No',b'Under AMC',b'Innerhalb des j\xc3\xa4hrlichen Wartungsvertrags'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55',b'Item valuation rate is recalculated considering landed cost voucher amount',b'Artikelpreis wird unter Einbezug von Belegen \xc3\xbcber den Einstandspreis neu berechnet'
+b'apps/erpnext/erpnext/config/selling.py +153',b'Default settings for selling transactions.',b'Standardeinstellungen f\xc3\xbcr Vertriebstransaktionen'
+b'DocType: Guardian',b'Guardian Of ',b'W\xc3\xa4chter von'
+b'DocType: Grading Scale Interval',b'Threshold',b'Schwelle'
+b'DocType: BOM Update Tool',b'Current BOM',b'Aktuelle St\xc3\xbcckliste'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32',b'Balance (Dr - Cr)',b'Balance (Dr - Cr)'
+b'apps/erpnext/erpnext/public/js/utils.js +55',b'Add Serial No',b'Seriennummer hinzuf\xc3\xbcgen'
+b'DocType: Work Order Item',b'Available Qty at Source Warehouse',b'Verf\xc3\xbcgbare Menge bei Source Warehouse'
+b'apps/erpnext/erpnext/config/support.py +22',b'Warranty',b'Garantie'
+b'DocType: Purchase Invoice',b'Debit Note Issued',b'Lastschrift ausgestellt am'
+b'DocType: Work Order',b'Warehouses',b'Lager'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18',b'{0} asset cannot be transferred',b'{0} Anlageverm\xc3\xb6gen kann nicht \xc3\xbcbertragen werden'
+b'DocType: Hotel Room Pricing',b'Hotel Room Pricing',b'Hotel Zimmerpreise'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +80',b'This Item is a Variant of {0} (Template).',b'Dieser Artikel ist eine Variante von {0} (Vorlage).'
+b'DocType: Workstation',b'per hour',b'pro Stunde'
+b'apps/erpnext/erpnext/config/buying.py +7',b'Purchasing',b'Einkauf'
+b'DocType: Announcement',b'Announcement',b'Ank\xc3\xbcndigung'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84',b'Customer LPO',b'Kunden LPO'
+b'DocType: Education Settings',"b'For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.'",b'F\xc3\xbcr die Batch-basierte Studentengruppe wird die Student Batch f\xc3\xbcr jeden Sch\xc3\xbcler aus der Programmregistrierung validiert.'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50',b'Warehouse can not be deleted as stock ledger entry exists for this warehouse.',"b'Lager kann nicht gel\xc3\xb6scht werden, da es Buchungen im Lagerbuch gibt.'"
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +25',b'Distribution',b'Gro\xc3\x9fhandel'
+b'DocType: Expense Claim Advance',b'Expense Claim Advance',b'Spesenabrechnung'
+b'DocType: Lab Test',b'Report Preference',b'Berichtsvorgabe'
+b'apps/erpnext/erpnext/config/non_profit.py +43',b'Volunteer information.',b'Freiwillige Informationen.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133',b'Project Manager',b'Projektleiter'
+,b'Quoted Item Comparison',b'Vergleich angebotener Artikel'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34',b'Overlap in scoring between {0} and {1}',b'\xc3\x9cberlappung beim Scoring zwischen {0} und {1}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114',b'Dispatch',b'Versand'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74',b'Max discount allowed for item: {0} is {1}%',b'Maximal erlaubter Rabatt f\xc3\xbcr Artikel: {0} ist {1}%'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176',b'Net Asset value as on',b'Nettoinventarwert als auf'
+b'DocType: Crop',b'Produce',b'Produzieren'
+b'DocType: Hotel Settings',b'Default Taxes and Charges',b'Standard-Steuern und -Abgaben'
+b'DocType: Account',b'Receivable',b'Forderung'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308',b'Row #{0}: Not allowed to change Supplier as Purchase Order already exists',"b'Zeile #{0}: Es ist nicht erlaubt den Lieferanten zu wechseln, da bereits ein Lieferantenauftrag vorhanden ist'"
+b'DocType: Accounts Settings',b'Role that is allowed to submit transactions that exceed credit limits set.',"b'Rolle, welche Transaktionen, die das gesetzte Kreditlimit \xc3\xbcberschreiten, \xc3\xbcbertragen darf.'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +989',b'Select Items to Manufacture',b'W\xc3\xa4hlen Sie die Elemente Herstellung'
+b'DocType: Delivery Stop',b'Delivery Stop',b'Liefer Stopp'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +963',"b'Master data syncing, it might take some time'","b'Stammdaten-Synchronisierung, kann es einige Zeit dauern,'"
+b'DocType: Item',b'Material Issue',b'Materialentnahme'
+b'DocType: Employee Education',b'Qualification',b'Qualifikation'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42',b'View Salary Slips',b'Gehaltsabrechnungen anzeigen'
+b'DocType: Item Price',b'Item Price',b'Artikelpreis'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48',b'Soap & Detergent',b'Reinigungsmittel'
+b'DocType: BOM',b'Show Items',b'Elemente anzeigen'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30',b'From Time cannot be greater than To Time.',"b'Von Zeit sein kann, nicht gr\xc3\xb6\xc3\x9fer ist als auf die Zeit.'"
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92',b'Do you want to notify all the customers by email?',b'M\xc3\xb6chten Sie alle Kunden per E-Mail benachrichtigen?'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36',b'Motion Picture & Video',b'Film & Fernsehen'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5',b'Ordered',b'Bestellt'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51',b'Resume',b'Fortsetzen'
+b'DocType: Salary Detail',b'Component',b'Komponente'
+b'DocType: Assessment Criteria',b'Assessment Criteria Group',b'Beurteilungskriterien Gruppe'
+b'DocType: Healthcare Settings',b'Patient Name By',b'Patientenname Von'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +72',b'Opening Accumulated Depreciation must be less than equal to {0}',b'Kumulierte Abschreibungen \xc3\x96ffnungs muss kleiner sein als gleich {0}'
+b'DocType: Warehouse',b'Warehouse Name',b'Lagername'
+b'DocType: Naming Series',b'Select Transaction',b'Bitte Transaktionen\xc2\xa0ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30',b'Please enter Approving Role or Approving User',b'Bitte genehmigende Rolle oder genehmigenden Nutzer eingeben'
+b'DocType: Journal Entry',b'Write Off Entry',b'Abschreibungsbuchung'
+b'DocType: BOM',b'Rate Of Materials Based On',b'Anteil der zu Grunde liegenden Materialien'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21',b'Support Analtyics',b'Support-Analyse'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102',b'Uncheck all',b'Alle abw\xc3\xa4hlen'
+b'DocType: POS Profile',b'Terms and Conditions',b'Allgemeine Gesch\xc3\xa4ftsbedingungen'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49',b'To Date should be within the Fiscal Year. Assuming To Date = {0}',"b'Bis-Datum sollte im Gesch\xc3\xa4ftsjahr liegen. Unter der Annahme, dass Bis-Datum = {0} ist'"
+b'DocType: Employee',"b'Here you can maintain height, weight, allergies, medical concerns etc'","b'Hier k\xc3\xb6nnen Sie Gr\xc3\xb6\xc3\x9fe, Gewicht, Allergien, medizinische Belange usw. pflegen'"
+b'DocType: Leave Block List',b'Applies to Company',b'Gilt f\xc3\xbcr Firma'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231',b'Cannot cancel because submitted Stock Entry {0} exists',"b'Stornierung nicht m\xc3\xb6glich, weil \xc3\xbcbertragene Lagerbuchung {0} existiert'"
+b'DocType: Employee Loan',b'Disbursement Date',b'Valuta-'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80',"b""'Recipients' not specified""","b'Keine ""Empf\xc3\xa4nger"" angegeben'"
+b'DocType: BOM Update Tool',b'Update latest price in all BOMs',b'Aktualisieren Sie den aktuellen Preis in allen St\xc3\xbccklisten'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23',b'Medical Record',b'Krankenakte'
+b'DocType: Vehicle',b'Vehicle',b'Fahrzeug'
+b'DocType: Purchase Invoice',b'In Words',b'In Worten'
+b'apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15',b'{0} must be submitted',b'{0} muss eingereicht werden'
+b'DocType: POS Profile',b'Item Groups',b'Artikelgruppen'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +221',"b""Today is {0}'s birthday!""",b'Heute hat {0} Geburtstag!'
+b'DocType: Sales Order Item',b'For Production',b'F\xc3\xbcr die Produktion'
+b'DocType: Payment Request',b'payment_url',b'payment_url'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186',b'Please add a Temporary Opening account in Chart of Accounts',b'Bitte f\xc3\xbcgen Sie ein vor\xc3\xbcbergehendes Er\xc3\xb6ffnungskonto im Kontenplan hinzu'
+b'DocType: Customer',b'Customer Primary Contact',b'Hauptkontakt des Kunden'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154',b'Period Closing Journal',b'Periodenabschluss-Journal'
+b'DocType: Project Task',b'View Task',b'Aufgabe anzeigen'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'Chance/ Lead%'
+b'DocType: Material Request',b'MREQ-',b'MREQ-'
+b'DocType: Payment Schedule',b'Invoice Portion',b'Rechnungsteil'
+,b'Asset Depreciations and Balances',b'Anlagenbschreibungen und Balances'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370',b'Amount {0} {1} transferred from {2} to {3}',b'Menge {0} {1} \xc3\xbcbertragen von {2} auf {3}'
+b'DocType: Sales Invoice',b'Get Advances Received',b'Erhaltene Anzahlungen aufrufen'
+b'DocType: Email Digest',b'Add/Remove Recipients',b'Empf\xc3\xa4nger hinzuf\xc3\xbcgen/entfernen'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19',"b""To set this Fiscal Year as Default, click on 'Set as Default'""","b'Um dieses Gesch\xc3\xa4ftsjahr als Standard festzulegen, auf ""Als Standard festlegen"" anklicken'"
+b'DocType: Production Plan',b'Include Subcontracted Items',b'Subkontrahierte Artikel einbeziehen'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +220',b'Join',b'Beitreten'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21',b'Shortage Qty',b'Engpassmenge'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +672',b'Cannot change Variant properties after stock transction. You will have to make a new Item to do this.',b'Nach der Bestands\xc3\xbcbertragung k\xc3\xb6nnen die Varianteneigenschaften nicht ge\xc3\xa4ndert werden. Sie m\xc3\xbcssen daf\xc3\xbcr einen neuen Artikel erstellen.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +714',b'Item variant {0} exists with same attributes',b'Artikelvariante {0} mit denselben Attributen existiert'
+b'DocType: Employee Loan',b'Repay from Salary',b'Repay von Gehalts'
+b'DocType: Leave Application',b'LAP/',b'RUNDE/'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360',b'Requesting payment against {0} {1} for amount {2}',b'Anfordern Zahlung gegen {0} {1} f\xc3\xbcr Menge {2}'
+b'DocType: Salary Slip',b'Salary Slip',b'Gehaltsabrechnung'
+b'DocType: Lead',b'Lost Quotation',b'Verlorene Angebote'
+b'apps/erpnext/erpnext/utilities/user_progress.py +221',b'Student Batches',b'Studentenchargen'
+b'DocType: Pricing Rule',b'Margin Rate or Amount',b'Marge oder Betrag'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48',"b""'To Date' is required""","b'""Bis-Datum"" ist erforderlich,'"
+b'DocType: Packing Slip',"b'Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.'","b'Packzettel f\xc3\xbcr zu liefernde Pakete generieren. Wird verwendet, um Paketnummer, Packungsinhalt und das Gewicht zu dokumentieren.'"
+b'DocType: Sales Invoice Item',b'Sales Order Item',b'Kundenauftrags-Artikel'
+b'DocType: Salary Slip',b'Payment Days',b'Zahlungsziel'
+b'DocType: Stock Settings',b'Convert Item Description to Clean HTML',b'Elementbeschreibung in HTML bereinigen'
+b'DocType: Patient',b'Dormant',b'ruhend'
+b'DocType: Salary Slip',b'Total Interest Amount',b'Gesamtzinsbetrag'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124',b'Warehouses with child nodes cannot be converted to ledger',b'Lagerh\xc3\xa4user mit untergeordneten Knoten kann nicht umgewandelt werden Ledger'
+b'DocType: BOM',b'Manage cost of operations',b'Arbeitsgangkosten verwalten'
+b'DocType: Accounts Settings',b'Stale Days',b'Stale Tage'
+b'DocType: Notification Control',"b'When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.'","b'Wenn eine der ausgew\xc3\xa4hlten Transaktionen den Status ""\xc3\xbcbertragen"" erreicht hat, geht automatisch ein E-Mail-Fenster auf. Damit kann eine E-Mail mit dieser Transaktion als Anhang an die verkn\xc3\xbcpften Kontaktdaten gesendet werden. Der Benutzer kann ausw\xc3\xa4hlen, ob er diese E-Mail absenden will.'"
+b'apps/erpnext/erpnext/config/setup.py +14',b'Global Settings',b'Allgemeine Einstellungen'
+b'DocType: Crop',b'Row Spacing UOM',b'Zeilenabstand UOM'
+b'DocType: Assessment Result Detail',b'Assessment Result Detail',b'Details zum Beurteilungsergebnis'
+b'DocType: Employee Education',b'Employee Education',b'Mitarbeiterschulung'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53',b'Duplicate item group found in the item group table',b'Doppelte Artikelgruppe in der Artikelgruppentabelle gefunden'
+b'DocType: Land Unit',b'Parent Land Unit',b'Elternlandeinheit'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1113',b'It is needed to fetch Item Details.',"b'Wird gebraucht, um Artikeldetails abzurufen'"
+b'DocType: Fertilizer',b'Fertilizer Name',b'D\xc3\xbcnger Name'
+b'DocType: Salary Slip',b'Net Pay',b'Nettolohn'
+b'DocType: Cash Flow Mapping Accounts',b'Account',b'Konto'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217',b'Serial No {0} has already been received',b'Seriennummer {0} bereits erhalten'
+,b'Requested Items To Be Transferred',"b'Angeforderte Artikel, die \xc3\xbcbertragen werden sollen'"
+b'DocType: Expense Claim',b'Vehicle Log',b'Fahrzeug Log'
+b'DocType: Vital Signs',b'Presence of a fever (temp &gt; 38.5 \xc2\xb0C/101.3 \xc2\xb0F or sustained temp &gt; 38 \xc2\xb0C/100.4 \xc2\xb0F)',"b'Vorhandensein eines Fiebers (Temp .: 38,5 \xc2\xb0 C / 101,3 \xc2\xb0 F oder anhaltende Temperatur&gt; 38 \xc2\xb0 C / 100,4 \xc2\xb0 F)'"
+b'DocType: Customer',b'Sales Team Details',b'Verkaufsteamdetails'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1352',b'Delete permanently?',b'Dauerhaft l\xc3\xb6schen?'
+b'DocType: Expense Claim',b'Total Claimed Amount',b'Gesamtforderung'
+b'apps/erpnext/erpnext/config/crm.py +17',b'Potential opportunities for selling.',b'M\xc3\xb6gliche Opportunit\xc3\xa4t f\xc3\xbcr den Vertrieb'
+b'DocType: Shareholder',b'Folio no.',b'Folio Nr.'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246',b'Invalid {0}',b'Ung\xc3\xbcltige(r) {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90',b'Sick Leave',b'Krankheitsbedingte Abwesenheit'
+b'DocType: Email Digest',b'Email Digest',b'E-Mail-Bericht'
+b'DocType: Delivery Note',b'Billing Address Name',b'Name der Rechnungsadresse'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22',b'Department Stores',b'Kaufh\xc3\xa4user'
+,b'Item Delivery Date',b'Artikel Liefertermin'
+b'DocType: Production Plan',b'Material Requested',b'Material angefordert'
+b'DocType: Warehouse',b'PIN',b'STIFT'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116',"b""Error '{0}' occured. Arguments {1}.""",b'Der Fehler &#39;{0}&#39; ist aufgetreten. Argumente {1}'
+b'DocType: Bin',b'Reserved Qty for sub contract',b'Reservierte Menge f\xc3\xbcr Unterauftrag'
+b'DocType: Patient Service Unit',b'Patinet Service Unit',b'Patinet Serviceeinheit'
+b'DocType: Sales Invoice',b'Base Change Amount (Company Currency)',b'Base-\xc3\x84nderungsbetrag (Gesellschaft W\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304',b'No accounting entries for the following warehouses',b'Keine Buchungen f\xc3\xbcr die folgenden Lager'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +95',b'Save the document first.',b'Speichern Sie das Dokument zuerst.'
+b'apps/erpnext/erpnext/shopping_cart/cart.py +74',b'Only {0} in stock for item {1}',b'Nur {0} auf Lager f\xc3\xbcr Artikel {1}'
+b'DocType: Account',b'Chargeable',b'Geb\xc3\xbchrenpflichtig'
+b'DocType: Company',b'Change Abbreviation',b'Abk\xc3\xbcrzung \xc3\xa4ndern'
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66',b'Pay {0} {1}',b'Bezahle {0} {1}'
+b'DocType: Expense Claim Detail',b'Expense Date',b'Datum der Aufwendung'
+b'DocType: Item',b'Max Discount (%)',b'Maximaler Rabatt (%)'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30',b'Credit Days cannot be a negative number',b'Kredit-Tage k\xc3\xb6nnen keine negative Zahl sein'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70',b'Last Order Amount',b'Letzter Bestellbetrag'
+b'DocType: Cash Flow Mapper',b'e.g Adjustments for:',b'zB Anpassungen f\xc3\xbcr:'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +275',"b' {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item'",b'{0} Probe zur\xc3\xbcckhalten basiert auf einer Charge. Bitte setzen Sie Hat Chargennummer um eine Probe des Artikels zu behalten'
+b'DocType: Task',b'Is Milestone',b'Ist Meilenstein'
+b'DocType: Delivery Stop',b'Email Sent To',b'E-Mail versandt an'
+b'DocType: Budget',b'Warn',b'Warnen'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81',b'Are you sure you want to unregister?',b'M\xc3\xb6chten Sie die Registrierung wirklich aufheben?'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +797',b'All items have already been transferred for this Work Order.',b'Alle Positionen wurden bereits f\xc3\xbcr diesen Arbeitsauftrag \xc3\xbcbertragen.'
+b'DocType: Appraisal',"b'Any other remarks, noteworthy effort that should go in the records.'","b'Sonstige wichtige Anmerkungen, die in die Datens\xc3\xa4tze aufgenommen werden sollten.'"
+b'DocType: Asset Maintenance',b'Manufacturing User',b'Nutzer Fertigung'
+b'DocType: Purchase Invoice',b'Raw Materials Supplied',b'Gelieferte Rohmaterialien'
+b'DocType: C-Form',b'Series',b'Nummernkreise'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282',b'Currency of the price list {0} must be {1} or {2}',b'Die W\xc3\xa4hrung der Preisliste {0} muss {1} oder {2}'
+b'DocType: Appraisal',b'Appraisal Template',b'Bewertungsvorlage'
+b'DocType: Soil Texture',b'Ternary Plot',b'Tern\xc3\xa4res Grundst\xc3\xbcck'
+b'DocType: Item Group',b'Item Classification',b'Artikeleinteilung'
+b'DocType: Driver',b'License Number',b'Lizenznummer'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131',b'Business Development Manager',b'Leiter der kaufm\xc3\xa4nnischen Abteilung'
+b'DocType: Maintenance Visit Purpose',b'Maintenance Visit Purpose',b'Zweck des Wartungsbesuchs'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19',b'Invoice Patient Registration',b'Rechnungsempf\xc3\xa4nger'
+b'DocType: Crop',b'Period',b'Periode'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27',b'General Ledger',b'Hauptbuch'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33',b'Employee {0} on Leave on {1}',b'Mitarbeiter {0} am {1} im Urlaub'
+b'apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10',b'View Leads',b'Leads anzeigen'
+b'DocType: Program Enrollment Tool',b'New Program',b'Neues Programm'
+b'DocType: Item Attribute Value',b'Attribute Value',b'Attributwert'
+,b'Itemwise Recommended Reorder Level',b'Empfohlener artikelbezogener Meldebestand'
+b'DocType: Salary Detail',b'Salary Detail',b'Gehalt Details'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070',b'Please select {0} first',b'Bitte zuerst {0} ausw\xc3\xa4hlen'
+b'DocType: Appointment Type',b'Physician',b'Arzt'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +872',b'Batch {0} of Item {1} has expired.',b'Charge {0} von Artikel {1} ist abgelaufen.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11',b'Consultations',b'Konsultationen'
+b'DocType: Sales Invoice',b'Commission',b'Provision'
+b'apps/erpnext/erpnext/config/manufacturing.py +27',b'Time Sheet for manufacturing.',b'Zeitblatt f\xc3\xbcr die Fertigung.'
+b'apps/erpnext/erpnext/templates/pages/cart.html +37',b'Subtotal',b'Zwischensumme'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +18',b'GoCardless SEPA Mandate',b'GoCardless SEPA-Mandat'
+b'DocType: Physician',b'Charges',b'Geb\xc3\xbchren'
+b'DocType: Production Plan',b'Get Items For Work Order',b'Holen Sie sich Artikel zum Arbeitsauftrag'
+b'DocType: Salary Detail',b'Default Amount',b'Standard-Betrag'
+b'DocType: Lab Test Template',b'Descriptive',b'Beschreibend'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95',b'Warehouse not found in the system',b'Lager im System nicht gefunden'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115',"b""This Month's Summary""",b'Zusammenfassung dieses Monats'
+b'DocType: Quality Inspection Reading',b'Quality Inspection Reading',b'Ablesung zur Qualit\xc3\xa4tspr\xc3\xbcfung'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25',b'`Freeze Stocks Older Than` should be smaller than %d days.',"b'""Lagerbest\xc3\xa4nde sperren, wenn \xc3\xa4lter als"" sollte kleiner sein als %d Tage.'"
+b'DocType: Tax Rule',b'Purchase Tax Template',b'Umsatzsteuer-Vorlage'
+b'apps/erpnext/erpnext/utilities/user_progress.py +48',"b""Set a sales goal you'd like to achieve for your company.""","b'Setzen Sie ein Verkaufsziel, das Sie f\xc3\xbcr Ihr Unternehmen erreichen m\xc3\xb6chten.'"
+,b'Project wise Stock Tracking',b'Projektbezogene Lagerbestandsverfolgung'
+b'DocType: GST HSN Code',b'Regional',b'Regional'
+b'apps/erpnext/erpnext/config/healthcare.py +40',b'Laboratory',b'Labor'
+b'DocType: Stock Entry Detail',b'Actual Qty (at source/target)',b'Tats\xc3\xa4chliche Anzahl (am Ursprung/Ziel)'
+b'DocType: Item Customer Detail',b'Ref Code',b'Ref-Code'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75',b'Customer Group is Required in POS Profile',b'Kundengruppe ist im POS-Profil erforderlich'
+b'apps/erpnext/erpnext/config/hr.py +12',b'Employee records.',b'Mitarbeiterdatens\xc3\xa4tze'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +98',b'Please set Next Depreciation Date',b'Bitte setzen Sie Next Abschreibungen Datum'
+b'DocType: HR Settings',b'Payroll Settings',b'Einstellungen zur Gehaltsabrechnung'
+b'apps/erpnext/erpnext/config/accounts.py +146',b'Match non-linked Invoices and Payments.',b'Nicht verkn\xc3\xbcpfte Rechnungen und Zahlungen verkn\xc3\xbcpfen'
+b'DocType: POS Settings',b'POS Settings',b'POS-Einstellungen'
+b'apps/erpnext/erpnext/templates/pages/cart.html +16',b'Place Order',b'Bestellung aufgeben'
+b'DocType: Email Digest',b'New Purchase Orders',b'Neue Bestellungen an Lieferanten'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24',b'Root cannot have a parent cost center',b'Root kann keine \xc3\xbcbergeordnete Kostenstelle haben'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +54',b'Select Brand...',b'Marke ausw\xc3\xa4hlen ...'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +32',b'Non Profit (beta)',b'Non-Profit (Beta)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18',b'Training Events/Results',b'Ausbildungsveranstaltungen / Ergebnisse'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152',b'Accumulated Depreciation as on',b'Kumulierte Abschreibungen auf'
+b'DocType: Sales Invoice',b'C-Form Applicable',b'Anwenden auf Kontakt-Formular'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438',b'Operation Time must be greater than 0 for Operation {0}',b'Betriebszeit muss f\xc3\xbcr die Operation {0} gr\xc3\xb6\xc3\x9fer als 0 sein'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107',b'Warehouse is mandatory',b'Lager ist erforderlich'
+b'DocType: Shareholder',b'Address and Contacts',b'Adresse und Kontaktinformationen'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67',b'Failed to create website',b'Fehler beim Erstellen der Website'
+b'DocType: Soil Analysis',b'Mg/K',b'Mg / K'
+b'DocType: UOM Conversion Detail',b'UOM Conversion Detail',b'Ma\xc3\x9feinheit-Umrechnungs-Detail'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924',b'Retention Stock Entry already created or Sample Quantity not provided',b'Aufbewahrungsbestandseintrag bereits angelegt oder Musterbestand nicht bereitgestellt'
+b'DocType: Program',b'Program Abbreviation',b'Programm Abk\xc3\xbcrzung'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52',b'Charges are updated in Purchase Receipt against each item',b'Kosten werden im Kaufbeleg f\xc3\xbcr jede Position aktualisiert'
+b'DocType: Warranty Claim',b'Resolved By',b'Entschieden von'
+b'DocType: Bank Guarantee',b'Start Date',b'Startdatum'
+b'apps/erpnext/erpnext/config/hr.py +75',b'Allocate leaves for a period.',b'Urlaube f\xc3\xbcr einen Zeitraum zuordnen'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42',b'Cheques and Deposits incorrectly cleared',b'Schecks und Kautionen f\xc3\xa4lschlicherweise gel\xc3\xb6scht'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +46',b'Account {0}: You can not assign itself as parent account',b'Konto {0}: Sie k\xc3\xb6nnen dieses Konto sich selbst nicht als \xc3\x9cber-Konto zuweisen'
+b'DocType: Purchase Invoice Item',b'Price List Rate',b'Preisliste'
+b'apps/erpnext/erpnext/utilities/activation.py +72',b'Create customer quotes',b'Erstellen Sie Angebote'
+b'DocType: Item',"b'Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.'","b'""Auf Lager"" oder ""Nicht auf Lager"" basierend auf dem in diesem Lager enthaltenen Bestand anzeigen'"
+b'apps/erpnext/erpnext/config/manufacturing.py +38',b'Bill of Materials (BOM)',b'St\xc3\xbcckliste'
+b'DocType: Item',b'Average time taken by the supplier to deliver',b'Durchschnittliche Lieferzeit des Lieferanten'
+b'DocType: Sample Collection',b'Collected By',b'Gesammelt von'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35',b'Assessment Result',b'Beurteilungsergebnis'
+b'DocType: Hotel Room Package',b'Hotel Room Package',b'Hotelzimmer-Paket'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13',b'Hours',b'Stunden'
+b'DocType: Project',b'Expected Start Date',b'Voraussichtliches Startdatum'
+b'DocType: Purchase Invoice',b'04-Correction in Invoice',b'04-Korrektur in der Rechnung'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963',b'Work Order already created for all items with BOM',b'Arbeitsauftrag wurde bereits f\xc3\xbcr alle Artikel mit St\xc3\xbcckliste angelegt'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +60',b'Variant Details Report',b'Bericht \xc3\xbcber Variantendetails'
+b'DocType: Setup Progress Action',b'Setup Progress Action',b'Setup Fortschrittsaktion'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36',b'Buying Price List',b'Kauf Preisliste'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49',b'Remove item if charges is not applicable to that item',"b'Artikel entfernen, wenn keine Geb\xc3\xbchren angerechnet werden k\xc3\xb6nnen'"
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21',b'Please select Maintenance Status as Completed or remove Completion Date',b'Bitte w\xc3\xa4hlen Sie Wartungsstatus als erledigt oder entfernen Sie das Abschlussdatum'
+b'DocType: Supplier',b'Default Payment Terms Template',b'Standardvorlage f\xc3\xbcr Zahlungsbedingungen'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34',b'Transaction currency must be same as Payment Gateway currency',b'Transaktionsw\xc3\xa4hrung mu\xc3\x9f gleiche wie Payment Gateway W\xc3\xa4hrung'
+b'DocType: Payment Entry',b'Receive',b'Empfangen'
+b'apps/erpnext/erpnext/templates/pages/rfq.html +75',b'Quotations: ',b'Angebote:'
+b'DocType: Maintenance Visit',b'Fully Completed',b'Vollst\xc3\xa4ndig abgeschlossen'
+b'apps/erpnext/erpnext/projects/doctype/project/project_list.js +6',b'{0}% Complete',b'{0}% abgeschlossen'
+b'DocType: Employee',b'Educational Qualification',b'Schulische Qualifikation'
+b'DocType: Workstation',b'Operating Costs',b'Betriebskosten'
+b'DocType: Budget',b'Action if Accumulated Monthly Budget Exceeded',b'Erw\xc3\xbcnschte Aktion bei \xc3\xbcberschrittenem kumuliertem Monatsbudget'
+b'DocType: Subscription',b'Submit on creation',b'Buchen beim Erstellen'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483',b'Currency for {0} must be {1}',b'W\xc3\xa4hrung f\xc3\xbcr {0} muss {1} sein'
+b'DocType: Asset',b'Disposal Date',b'Verkauf Datum'
+b'DocType: Daily Work Summary Settings',"b'Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.'","b'E-Mails werden an alle aktiven Mitarbeiter des Unternehmens an der angegebenen Stunde gesendet werden, sofern sie nicht im Urlaub sind. Die Zusammenfassung der Antworten wird um Mitternacht versandt werden.'"
+b'DocType: Employee Leave Approver',b'Employee Leave Approver',b'Urlaubsgenehmiger des Mitarbeiters'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +510',b'Row {0}: An Reorder entry already exists for this warehouse {1}',b'Zeile {0}: Es gibt bereits eine Nachbestellungsbuchung f\xc3\xbcr dieses Lager {1}'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99',"b'Cannot declare as lost, because Quotation has been made.'","b'Kann nicht als verloren deklariert werden, da bereits ein Angebot erstellt wurde.'"
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16',b'Training Feedback',b'Training Feedback'
+b'DocType: Supplier Scorecard Criteria',b'Supplier Scorecard Criteria',b'Lieferanten-Scorecard-Kriterien'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149',b'Please select Start Date and End Date for Item {0}',b'Bitte Start -und Enddatum f\xc3\xbcr den Artikel {0} ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55',b'Course is mandatory in row {0}',b'Kurs ist obligatorisch in Zeile {0}'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16',b'To date cannot be before from date',b'Bis-Datum kann nicht vor Von-Datum liegen'
+b'DocType: Supplier Quotation Item',b'Prevdoc DocType',b'Prevdoc DocType'
+b'DocType: Cash Flow Mapper',b'Section Footer',b'Abschnitt Fu\xc3\x9fzeile'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +304',b'Add / Edit Prices',b'Preise hinzuf\xc3\xbcgen / bearbeiten'
+b'DocType: Batch',b'Parent Batch',b'\xc3\x9cbergeordnete Charge'
+b'DocType: Cheque Print Template',b'Cheque Print Template',b'Scheck Druckvorlage'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36',b'Chart of Cost Centers',b'Kostenstellenplan'
+b'DocType: Lab Test Template',b'Sample Collection',b'Beispielsammlung'
+,b'Requested Items To Be Ordered',"b'Angefragte Artikel, die bestellt werden sollen'"
+b'apps/erpnext/erpnext/public/js/hub/hub_page.js +137',b'My Orders',b'Meine Bestellungen'
+b'DocType: Price List',b'Price List Name',b'Preislistenname'
+b'DocType: BOM',b'Manufacturing',b'Fertigung'
+,b'Ordered Items To Be Delivered',"b'Bestellte Artikel, die geliefert werden m\xc3\xbcssen'"
+b'DocType: Account',b'Income',b'Einkommen'
+b'DocType: Industry Type',b'Industry Type',b'Wirtschaftsbranche'
+b'apps/erpnext/erpnext/templates/includes/cart.js +150',b'Something went wrong!',b'Etwas ist schiefgelaufen!'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105',b'Warning: Leave application contains following block dates',b'Achtung: Die Urlaubsverwaltung enth\xc3\xa4lt die folgenden gesperrten Daten'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275',b'Sales Invoice {0} has already been submitted',b'Ausgangsrechnung {0} wurde bereits \xc3\xbcbertragen'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Score',b'Ergebnis'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25',b'Fiscal Year {0} does not exist',b'Das Gesch\xc3\xa4ftsjahr {0} existiert nicht'
+b'DocType: Asset Maintenance Log',b'Completion Date',b'Fertigstellungstermin'
+b'DocType: Purchase Invoice Item',b'Amount (Company Currency)',b'Betrag (Firmenw\xc3\xa4hrung)'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture User',b'Benutzer Landwirtschaft'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38',b'Valid till date cannot be before transaction date',b'G\xc3\xbcltig bis Datum kann nicht vor Transaktionsdatum sein'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +381',b'{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.',"b'Es werden {0} Einheiten von {1} in {2} auf {3} {4} f\xc3\xbcr {5} ben\xc3\xb6tigt, um diesen Vorgang abzuschlie\xc3\x9fen.'"
+b'DocType: Fee Schedule',b'Student Category',b'Studenten-Kategorie'
+b'DocType: Announcement',b'Student',b'Sch\xc3\xbcler'
+b'apps/erpnext/erpnext/config/hr.py +238',b'Organization unit (department) master.',b'Stammdaten der Organisationseinheit (Abteilung)'
+b'DocType: Shipping Rule',b'Shipping Rule Type',b'Versandregeltyp'
+b'apps/erpnext/erpnext/utilities/user_progress.py +239',b'Go to Rooms',b'Geh zu den Zimmern'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75',b'Please enter message before sending',b'Bitte eine Nachricht vor dem Versenden eingeben'
+b'DocType: Purchase Invoice',b'DUPLICATE FOR SUPPLIER',b'DUPLIKAT F\xc3\x9cR LIEFERANTEN'
+b'DocType: Email Digest',b'Pending Quotations',b'Ausstehende Angebote'
+b'apps/erpnext/erpnext/config/accounts.py +318',b'Point-of-Sale Profile',b'Verkaufsstellen-Profil'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25',b'{0} should be a value between 0 and 100',b'{0} sollte ein Wert zwischen 0 und 100 sein'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +94',b'Next Depreciation Date cannot be before Available-for-use Date',b'Das n\xc3\xa4chste Abschreibungsdatum darf nicht vor dem Verf\xc3\xbcgbarkeitsdatum liegen'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156',b'Unsecured Loans',b'Ungesicherte Kredite'
+b'DocType: Cost Center',b'Cost Center Name',b'Kostenstellenbezeichnung'
+b'DocType: Student',b'B+',b'B+'
+b'DocType: HR Settings',b'Max working hours against Timesheet',b'Max Arbeitszeit gegen Stundenzettel'
+b'DocType: Maintenance Schedule Detail',b'Scheduled Date',b'Geplantes Datum'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +214',b'Total Paid Amt',b'Summe gezahlte Betr\xc3\xa4ge'
+b'DocType: SMS Center',b'Messages greater than 160 characters will be split into multiple messages',b'Mitteilungen mit mehr als 160 Zeichen werden in mehrere Nachrichten aufgeteilt'
+b'DocType: Purchase Receipt Item',b'Received and Accepted',b'Erhalten und best\xc3\xa4tigt'
+b'DocType: Hub Settings',b'Company and Seller Profile',b'Firmen- und Verk\xc3\xa4uferprofil'
+,b'GST Itemised Sales Register',b'GST Einzelverkaufsregister'
+b'DocType: Soil Texture',b'Silt Loam',b'Schlamm'
+,b'Serial No Service Contract Expiry',b'Ablaufdatum des Wartungsvertrags zu Seriennummer'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299',b'You cannot credit and debit same account at the same time',b'Sie k\xc3\xb6nnen ein Konto nicht gleichzeitig be- und entlasten'
+b'DocType: Vital Signs',"b""Adults' pulse rate is anywhere between 50 and 80 beats per minute.""",b'Der durchschnittliche Puls eines Erwachsenen liegt zwischen 60 und 80 Schl\xc3\xa4gen pro Minute.'
+b'DocType: Naming Series',b'Help HTML',b'HTML-Hilfe'
+b'DocType: Student Group Creation Tool',b'Student Group Creation Tool',b'Student Group Creation Tool'
+b'DocType: Item',b'Variant Based On',b'Variante basierend auf'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53',b'Total weightage assigned should be 100%. It is {0}',b'Summe der zugeordneten Gewichtungen sollte 100% sein. Sie ist {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +109',b'Your Suppliers',b'Ihre Lieferanten'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'Please correct the',b'Bitte korrigieren Sie die'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80',b'Cannot set as Lost as Sales Order is made.',"b'Kann nicht als verloren gekennzeichnet werden, da ein Kundenauftrag dazu existiert.'"
+b'DocType: Request for Quotation Item',b'Supplier Part No',b'Lieferant Teile-Nr'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382',"b""Cannot deduct when category is for 'Valuation' or 'Vaulation and Total'""","b'Kann nicht abschreiben, wenn die Kategorie ""Bewertung"" oder ""Bewertung und Total \'ist'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377',b'Received From',b'Erhalten von'
+b'DocType: Lead',b'Converted',b'umgewandelt'
+b'DocType: Item',b'Has Serial No',b'Hat Seriennummer'
+b'DocType: Employee',b'Date of Issue',b'Ausstellungsdatum'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222',"b""As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}""","b'Nach den Kaufeinstellungen, wenn Kaufbedarf erforderlich == &#39;JA&#39;, dann f\xc3\xbcr die Erstellung der Kauf-Rechnung, muss der Benutzer die Kaufbeleg zuerst f\xc3\xbcr den Eintrag {0}'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167',b'Row #{0}: Set Supplier for item {1}',b'Zeile #{0}: Lieferanten f\xc3\xbcr Artikel {1} einstellen'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121',b'Row {0}: Hours value must be greater than zero.',b'Row {0}: Stunden-Wert muss gr\xc3\xb6\xc3\x9fer als Null sein.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +195',b'Website Image {0} attached to Item {1} cannot be found',"b'Das Webseiten-Bild {0}, das an Artikel {1} angeh\xc3\xa4ngt wurde, kann nicht gefunden werden'"
+b'DocType: Issue',b'Content Type',b'Inhaltstyp'
+b'DocType: Asset',b'Assets',b'Verm\xc3\xb6genswerte'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17',b'Computer',b'Rechner'
+b'DocType: Item',b'List this Item in multiple groups on the website.',b'Diesen Artikel in mehreren Gruppen auf der Webseite auflisten.'
+b'DocType: Payment Term',b'Due Date Based On',b'F\xc3\xa4lligkeitsdatum basiert auf'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82',b'Please set default customer group and territory in Selling Settings',b'Bitte legen Sie die Standard-Kundengruppe und das Territorium in Selling Settings fest'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214',b'{0} {1} does not exist',b'{0} {1} existiert nicht'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323',b'Please check Multi Currency option to allow accounts with other currency',"b'Bitte die Option ""Unterschiedliche W\xc3\xa4hrungen"" aktivieren um Konten mit anderen W\xc3\xa4hrungen zu erlauben'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88',b'Item: {0} does not exist in the system',b'Artikel: {0} ist nicht im System vorhanden'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +106',b'You are not authorized to set Frozen value',b'Sie haben keine Berechtigung gesperrte Werte zu setzen'
+b'DocType: Payment Reconciliation',b'Get Unreconciled Entries',b'Nicht zugeordnete Buchungen aufrufen'
+b'DocType: Payment Reconciliation',b'From Invoice Date',b'Ab Rechnungsdatum'
+b'DocType: Healthcare Settings',b'Laboratory Settings',b'Laboreinstellungen'
+b'DocType: Patient Appointment',b'Service Unit',b'Serviceeinheit'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97',b'Successfully Set Supplier',b'Setzen Sie den Lieferanten erfolgreich'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75',b'Leave Encashment',b'Einl\xc3\xb6sung gew\xc3\xa4hren'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +114',b'What does it do?',b'Unternehmenszweck'
+b'DocType: Crop',b'Byproducts',b'Nebenprodukte'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +84',b'To Warehouse',b'An Lager'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26',b'All Student Admissions',b'Alle Studenten Admissions'
+,b'Average Commission Rate',b'Durchschnittlicher Provisionssatz'
+b'DocType: Share Balance',b'No of Shares',b'Anzahl der Aktien'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +448',"b""'Has Serial No' can not be 'Yes' for non-stock item""","b'""Hat Seriennummer"" kann bei Nicht-Lagerartikeln nicht ""Ja"" sein'"
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59',b'Select Status',b'W\xc3\xa4hlen Sie Status'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41',b'Attendance can not be marked for future dates',b'Die Anwesenheit kann nicht f\xc3\xbcr zuk\xc3\xbcnftige Termine markiert werden'
+b'DocType: Pricing Rule',b'Pricing Rule Help',b'Hilfe zur Preisregel'
+b'DocType: School House',b'House Name',b'Hausname'
+b'DocType: Fee Schedule',b'Total Amount per Student',b'Gesamtbetrag pro Student'
+b'DocType: Purchase Taxes and Charges',b'Account Head',b'Kontobezeichnung'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153',b'Electrical',b'Elektro'
+b'apps/erpnext/erpnext/utilities/activation.py +100',b'Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts',b'F\xc3\xbcgen Sie den Rest Ihrer Organisation als Nutzer hinzu. Sie k\xc3\xb6nnen auch Kunden zu Ihrem Portal einladen indem Sie sie aus den Kontakten die Einladung senden'
+b'DocType: Stock Entry',b'Total Value Difference (Out - In)',b'Gesamt-Wertdifferenz (Aus - Ein)'
+b'DocType: Grant Application',b'Requested Amount',b'Gew\xc3\xbcnschter Betrag'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348',b'Row {0}: Exchange Rate is mandatory',b'Zeile {0}: Wechselkurs ist erforderlich'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27',b'User ID not set for Employee {0}',b'Benutzer-ID ist f\xc3\xbcr Mitarbeiter {0} nicht eingegeben'
+b'DocType: Vehicle',b'Vehicle Value',b'Fahrzeugwert'
+b'DocType: Crop Cycle',b'Detected Diseases',b'Erkannte Krankheiten'
+b'DocType: Stock Entry',b'Default Source Warehouse',b'Standard-Ausgangslager'
+b'DocType: Item',b'Customer Code',b'Kunden-Nr.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +220',b'Birthday Reminder for {0}',b'Geburtstagserinnerung f\xc3\xbcr {0}'
+b'DocType: Asset Maintenance Task',b'Last Completion Date',b'Letztes Fertigstellungsdatum'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72',b'Days Since Last Order',b'Tage seit dem letzten Auftrag'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365',b'Debit To account must be a Balance Sheet account',b'Sollkonto muss ein Bilanzkonto sein'
+b'DocType: Buying Settings',b'Naming Series',b'Nummernkreis'
+b'DocType: GoCardless Settings',b'GoCardless Settings',b'GoCardlose Einstellungen'
+b'DocType: Leave Block List',b'Leave Block List Name',b'Name der Urlaubssperrenliste'
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14',b'Insurance Start date should be less than Insurance End date',b'Versicherung Startdatum sollte weniger als Versicherung Enddatum'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32',b'Stock Assets',b'Wertpapiere'
+b'DocType: Restaurant',b'Active Menu',b'Aktives Men\xc3\xbc'
+b'DocType: Target Detail',b'Target Qty',b'Zielmenge'
+b'DocType: Shopping Cart Settings',b'Checkout Settings',b'Kasse Einstellungen'
+b'DocType: Student Attendance',b'Present',b'Anwesend'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37',b'Delivery Note {0} must not be submitted',b'Lieferschein {0} darf nicht gebucht werden'
+b'DocType: Notification Control',b'Sales Invoice Message',b'Mitteilung zur Ausgangsrechnung'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27',b'Closing Account {0} must be of type Liability / Equity',b'Abschlu\xc3\x9fkonto {0} muss vom Typ Verbindlichkeiten/Eigenkapital sein'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325',b'Salary Slip of employee {0} already created for time sheet {1}',b'Gehaltsabrechnung der Mitarbeiter {0} bereits f\xc3\xbcr Zeitblatt erstellt {1}'
+b'DocType: Vehicle Log',b'Odometer',b'Tacho'
+b'DocType: Production Plan Item',b'Ordered Qty',b'Bestellte Menge'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +744',b'Item {0} is disabled',b'Artikel {0} ist deaktiviert'
+b'DocType: Stock Settings',b'Stock Frozen Upto',b'Bestand gesperrt bis'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930',b'BOM does not contain any stock item',b'St\xc3\xbcckliste enth\xc3\xa4lt keine Lagerware'
+b'DocType: Chapter',b'Chapter Head',b'Gruppen-Vorstand'
+b'DocType: Payment Term',b'Month(s) after the end of the invoice month',b'Monat (e) nach dem Ende des Rechnungsmonats'
+b'apps/erpnext/erpnext/config/projects.py +24',b'Project activity / task.',b'Projektaktivit\xc3\xa4t/-vorgang.'
+b'DocType: Vehicle Log',b'Refuelling Details',b'Betankungs Einzelheiten'
+b'apps/erpnext/erpnext/config/hr.py +104',b'Generate Salary Slips',b'Gehaltsabrechnungen generieren'
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25',b'Lab result datetime cannot be before testing datetime',b'Lab-Ergebnis datetime kann nicht vor dem Testen von datetime liegen'
+b'DocType: POS Profile',b'Allow user to edit Discount',"b'Erlaube dem Nutzer, den Rabatt zu bearbeiten'"
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55',b'Get customers from',b'Holen Sie Kunden von'
+b'DocType: Purchase Invoice Item',b'Include Exploded Items',b'Explodierte Elemente einschlie\xc3\x9fen'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45',"b'Buying must be checked, if Applicable For is selected as {0}'","b'Einkauf muss ausgew\xc3\xa4hlt sein, wenn ""Anwenden auf"" auf {0} gesetzt wurde'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40',b'Discount must be less than 100',b'Discount muss kleiner als 100 sein'
+b'DocType: Shipping Rule',b'Restrict to Countries',b'Auf L\xc3\xa4nder beschr\xc3\xa4nken'
+b'DocType: Purchase Invoice',b'Write Off Amount (Company Currency)',b'Abschreibungs-Betrag (Firmenw\xc3\xa4hrung)'
+b'DocType: Sales Invoice Timesheet',b'Billing Hours',b'Abgerechnete Stunden'
+b'DocType: Project',b'Total Sales Amount (via Sales Order)',b'Gesamtverkaufsbetrag (\xc3\xbcber Kundenauftrag)'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +548',b'Default BOM for {0} not found',b'Standardst\xc3\xbcckliste f\xc3\xbcr {0} nicht gefunden'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +514',b'Row #{0}: Please set reorder quantity',b'Zeile #{0}: Bitte Nachbestellmenge angeben'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +20',b'Tap items to add them here',"b'Tippen Sie auf Elemente, um sie hier hinzuzuf\xc3\xbcgen'"
+b'DocType: Fees',b'Program Enrollment',b'Programm Einschreibung'
+b'DocType: Share Transfer',b'To Folio No',b'Zu Folio Nein'
+b'DocType: Landed Cost Voucher',b'Landed Cost Voucher',b'Beleg \xc3\xbcber Einstandskosten'
+b'apps/erpnext/erpnext/public/js/queries.js +39',b'Please set {0}',b'Bitte {0} setzen'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} ist ein inaktiver Sch\xc3\xbcler'
+b'DocType: Employee',b'Health Details',b'Gesundheitsdaten'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'Zur Erstellung eines Zahlungsauftrags ist ein Referenzdokument erforderlich'
+b'DocType: Soil Texture',b'Sandy Clay',b'Sandiger Lehm'
+b'DocType: Grant Application',b'Assessment  Manager',b'Bewertungsmanager'
+b'DocType: Payment Entry',b'Allocate Payment Amount',b'Zahlungsbetrag zuweisen'
+b'DocType: Employee External Work History',b'Salary',b'Gehalt'
+b'DocType: Serial No',b'Delivery Document Type',b'Lieferdokumententyp'
+b'DocType: Sales Order',b'Partly Delivered',b'Teilweise geliefert'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48',b'Item Code &gt; Item Group &gt; Brand',b'Artikelcode&gt; Artikelgruppe&gt; Marke'
+b'DocType: Item Variant Settings',b'Do not update variants on save',b'Aktualisieren Sie keine Varianten beim Speichern'
+b'DocType: Email Digest',b'Receivables',b'Forderungen'
+b'DocType: Lead Source',b'Lead Source',b'Lead Ursprung'
+b'DocType: Customer',b'Additional information regarding the customer.',b'Zus\xc3\xa4tzliche Informationen bez\xc3\xbcglich des Kunden.'
+b'DocType: Quality Inspection Reading',b'Reading 5',b'Ablesewert\xc2\xa05'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236',"b'{0} {1} is associated with {2}, but Party Account is {3}'","b'{0} {1} ist mit {2} verbunden, aber das Gegenkonto ist {3}'"
+b'apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7',b'View Lab Tests',b'Lab-Tests anzeigen'
+b'DocType: Purchase Invoice',b'Y',b'Y'
+b'DocType: Maintenance Visit',b'Maintenance Date',b'Wartungsdatum'
+b'DocType: Purchase Invoice Item',b'Rejected Serial No',b'Abgelehnte Seriennummer'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82',b'Year start date or end date is overlapping with {0}. To avoid please set company',b'Jahresbeginn oder Enddatum \xc3\xbcberlappt mit {0}. Um dies zu verhindern setzen Sie eine Firma.'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +122',b'Please mention the Lead Name in Lead {0}',b'Bitte erw\xc3\xa4hnen Sie den Lead Name in Lead {0}'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156',b'Start date should be less than end date for Item {0}',b'Startdatum sollte f\xc3\xbcr den Artikel {0} vor dem Enddatum liegen'
+b'DocType: Item',"b'Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.'","b'Beispiel: ABCD.##### \n Wenn ""Serie"" eingestellt ist und ""Seriennummer"" in den Transaktionen nicht aufgef\xc3\xbchrt ist, dann wird eine Seriennummer automatisch auf der Grundlage dieser Serie erstellt. Wenn immer explizit Seriennummern f\xc3\xbcr diesen Artikel aufgef\xc3\xbchrt werden sollen, muss das Feld leer gelassen werden.'"
+b'DocType: Upload Attendance',b'Upload Attendance',b'Anwesenheit hochladen'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +579',b'BOM and Manufacturing Quantity are required',b'St\xc3\xbcckliste und Fertigungsmenge werden ben\xc3\xb6tigt'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50',b'Ageing Range 2',b'Alter Bereich 2'
+b'DocType: SG Creation Tool Course',b'Max Strength',b'Max Kraft'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28',b'Installing presets',b'Voreinstellungen installieren'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85',b'No Delivery Note selected for Customer {}',b'Kein Lieferschein f\xc3\xbcr den Kunden {} ausgew\xc3\xa4hlt'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25',b'BOM replaced',b'St\xc3\xbcckliste ersetzt'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052',b'Select Items based on Delivery Date',b'W\xc3\xa4hlen Sie die Positionen nach dem Lieferdatum aus'
+b'DocType: Grant Application',b'Has any past Grant Record',b'Hat einen fr\xc3\xbcheren Grant Record'
+,b'Sales Analytics',b'Vertriebsanalyse'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127',b'Available {0}',b'Verf\xc3\xbcgbar {0}'
+,b'Prospects Engaged But Not Converted',"b'Perspektiven engagiert, aber nicht umgewandelt'"
+b'DocType: Manufacturing Settings',b'Manufacturing Settings',b'Fertigungseinstellungen'
+b'apps/erpnext/erpnext/config/setup.py +56',b'Setting up Email',b'E-Mail einrichten'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57',b'Guardian1 Mobile No',b'Guardian1 Mobil Nein'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106',b'Please enter default currency in Company Master',b'Bitte die Standardw\xc3\xa4hrung in die Firmenstammdaten eingeben'
+b'DocType: Stock Entry Detail',b'Stock Entry Detail',b'Lagerbuchungsdetail'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109',b'Daily Reminders',b'T\xc3\xa4gliche Erinnerungen'
+b'DocType: Products Settings',b'Home Page is Products',"b'Startseite ist ""Products""'"
+,b'Asset Depreciation Ledger',b'Anlagenabschreibungensbuch'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91',b'Tax Rule Conflicts with {0}',b'Steuer-Regel steht in Konflikt mit {0}'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25',b'New Account Name',b'Neuer Kontoname'
+b'DocType: Purchase Invoice Item',b'Raw Materials Supplied Cost',b'Kosten gelieferter Rohmaterialien'
+b'DocType: Selling Settings',b'Settings for Selling Module',b'Einstellungen Verkauf'
+b'DocType: Hotel Room Reservation',b'Hotel Room Reservation',b'Hotelzimmer Reservierung'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115',b'Customer Service',b'Kundenservice'
+b'DocType: BOM',b'Thumbnail',b'Thumbnail'
+b'DocType: Item Customer Detail',b'Item Customer Detail',b'kundenspezifisches Artikeldetail'
+b'apps/erpnext/erpnext/config/hr.py +50',b'Offer candidate a Job.',b'Bewerber/-in einen Arbeitsplatz anbieten'
+b'DocType: Notification Control',b'Prompt for Email on Submission of',b'E-Mail anregen bei der \xc3\x9cbertragung von'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88',b'Total allocated leaves are more than days in the period',b'Die Gesamtmenge des beantragten Urlaubs \xc3\xbcbersteigt die Tage in der Periode'
+b'DocType: Land Unit',b'Linked Soil Analysis',b'Verbundene Bodenanalyse'
+b'DocType: Pricing Rule',b'Percentage',b'Prozentsatz'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70',b'Item {0} must be a stock Item',b'Artikel {0} muss ein Lagerartikel sein'
+b'DocType: Manufacturing Settings',b'Default Work In Progress Warehouse',b'Standard-Fertigungslager'
+b'apps/erpnext/erpnext/config/accounts.py +288',b'Default settings for accounting transactions.',b'Standardeinstellungen f\xc3\xbcr Buchhaltungstransaktionen'
+b'DocType: Maintenance Visit',b'MV',b'MV'
+b'DocType: Restaurant',b'Default Tax Template',b'Standardsteuervorlage'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66',b'{0} Students have been enrolled',b'{0} Studenten wurden angemeldet'
+b'DocType: Fees',b'Student Details',b'Studenten Details'
+b'DocType: Purchase Invoice Item',b'Stock Qty',b'Lagermenge'
+b'DocType: Employee Loan',b'Repayment Period in Months',b'R\xc3\xbcckzahlungsfrist in Monaten'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26',b'Error: Not a valid id?',b'Fehler: Keine g\xc3\xbcltige ID?'
+b'DocType: Naming Series',b'Update Series Number',b'Nummernkreis-Wert aktualisieren'
+b'DocType: Account',b'Equity',b'Eigenkapital'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78',"b""{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry""","b'{0} {1}: ""Gewinn und Verlust"" Konto-Art {2} ist nicht in Er\xc3\xb6ffnungs-Buchung erlaubt'"
+b'DocType: Sales Order',b'Printing Details',b'Druckdetails'
+b'DocType: Task',b'Closing Date',b'Abschlussdatum'
+b'DocType: Sales Order Item',b'Produced Quantity',b'Produzierte Menge'
+b'DocType: Timesheet',b'Work Detail',b'Arbeit Detail'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126',b'Engineer',b'Ingenieur'
+b'DocType: Journal Entry',b'Total Amount Currency',b'Insgesamt Betrag W\xc3\xa4hrung'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38',b'Search Sub Assemblies',b'Unterbaugruppen suchen'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171',b'Item Code required at Row No {0}',b'Artikelnummer wird in Zeile {0} ben\xc3\xb6tigt'
+b'DocType: GST Account',b'SGST Account',b'SGST-Konto'
+b'apps/erpnext/erpnext/utilities/user_progress.py +154',b'Go to Items',b'Gehen Sie zu Artikeln'
+b'DocType: Sales Partner',b'Partner Type',b'Partnertyp'
+b'DocType: Purchase Taxes and Charges',b'Actual',b'Tats\xc3\xa4chlich'
+b'DocType: Restaurant Menu',b'Restaurant Manager',b'Restaurantmanager'
+b'DocType: Authorization Rule',b'Customerwise Discount',b'Kundenspezifischer Rabatt'
+b'apps/erpnext/erpnext/config/projects.py +46',b'Timesheet for tasks.',b'Zeitraport f\xc3\xbcr Vorg\xc3\xa4nge.'
+b'DocType: Purchase Invoice',b'Against Expense Account',b'Zu Aufwandskonto'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282',b'Installation Note {0} has already been submitted',b'Installationshinweis {0} wurde bereits \xc3\xbcbertragen'
+b'DocType: Bank Reconciliation',b'Get Payment Entries',b'Get Payment-Eintr\xc3\xa4ge'
+b'DocType: Quotation Item',b'Against Docname',b'Zu Dokumentenname'
+b'DocType: SMS Center',b'All Employee (Active)',b'Alle Mitarbeiter (Aktiv)'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9',b'View Now',b'Jetzt ansehen'
+b'DocType: BOM',b'Raw Material Cost',b'Rohmaterialkosten'
+b'DocType: Item Reorder',b'Re-Order Level',b'Meldebestand'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +54',b'Gantt Chart',b'Gantt-Diagramm'
+b'DocType: Crop Cycle',b'Cycle Type',b'Zyklustyp'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99',b'Part-time',b'Teilzeit'
+b'DocType: Employee',b'Applicable Holiday List',b'Geltende Urlaubsliste'
+b'DocType: Employee',b'Cheque',b'Scheck'
+b'DocType: Training Event',b'Employee Emails',b'Mitarbeiter E-Mails'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60',b'Series Updated',b'Serie aktualisiert'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +159',b'Report Type is mandatory',b'Berichtstyp ist zwingend erforderlich'
+b'DocType: Item',b'Serial Number Series',b'Serie der Seriennummer'
+b'apps/erpnext/erpnext/buying/utils.py +68',b'Warehouse is mandatory for stock Item {0} in row {1}',b'Angabe des Lagers ist f\xc3\xbcr Lagerartikel {0} in Zeile {1} zwingend erfoderlich'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45',b'Retail & Wholesale',b'Einzel- & Gro\xc3\x9fhandel'
+b'DocType: Issue',b'First Responded On',b'Zuerst geantwortet auf'
+b'DocType: Website Item Group',b'Cross Listing of Item in multiple groups',b'Kreuzweise Auflistung des Artikels in mehreren Gruppen'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90',b'Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}',b'Start- und Enddatum des Gesch\xc3\xa4ftsjahres sind f\xc3\xbcr das Gesch\xc3\xa4ftsjahr {0} bereits gesetzt'
+b'DocType: Projects Settings',b'Ignore User Time Overlap',b'Benutzerzeit\xc3\xbcberlappung ignorieren'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113',b'Clearance Date updated',b'Abrechnungsdatum aktualisiert'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Batch'
+b'DocType: Stock Settings',b'Batch Identification',b'Chargenidentifikation'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132',b'Successfully Reconciled',b'Erfolgreich abgestimmt'
+b'DocType: Request for Quotation Supplier',b'Download PDF',b'PDF Herunterladen'
+b'DocType: Work Order',b'Planned End Date',b'Geplantes Enddatum'
+b'DocType: Shareholder',b'Hidden list maintaining the list of contacts linked to Shareholder',"b'Versteckte Liste, die die Liste der mit dem Aktion\xc3\xa4r verkn\xc3\xbcpften Kontakte enth\xc3\xa4lt'"
+b'apps/erpnext/erpnext/config/non_profit.py +63',b'Donor Type information.',b'Informationen zum Spendertyp'
+b'DocType: Request for Quotation',b'Supplier Detail',b'Lieferant Details'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100',b'Error in formula or condition: {0}',b'Fehler in Formel oder Bedingung: {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +99',b'Invoiced Amount',b'Rechnungsbetrag'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47',b'Criteria weights must add up to 100%',b'Kriteriengewichte m\xc3\xbcssen zusammen 100% ergeben.'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7',b'Attendance',b'Anwesenheit'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +115',b'Stock Items',b'Lagerartikel'
+b'DocType: BOM',b'Materials',b'Materialien'
+b'DocType: Leave Block List',"b'If not checked, the list will have to be added to each Department where it has to be applied.'","b'Wenn deaktiviert, muss die Liste zu jeder Abteilung, f\xc3\xbcr die sie gelten soll, hinzugef\xc3\xbcgt werden.'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111',b'Creating {0}',b'Erstellen von {0}'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28',b'Source and Target Warehouse cannot be same',b'Quelle und Ziel-Warehouse kann nicht gleich sein'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586',b'Posting date and posting time is mandatory',b'Buchungsdatum und Buchungszeit sind zwingend erfoderlich'
+b'apps/erpnext/erpnext/config/buying.py +76',b'Tax template for buying transactions.',b'Steuervorlage f\xc3\xbcr Einkaufstransaktionen'
+,b'Item Prices',b'Artikelpreise'
+b'DocType: Purchase Order',b'In Words will be visible once you save the Purchase Order.',"b'""In Worten"" wird sichtbar, sobald Sie\xc2\xa0den Lieferantenauftrag speichern.'"
+b'DocType: Period Closing Voucher',b'Period Closing Voucher',b'Periodenabschlussbeleg'
+b'DocType: Consultation',b'Review Details',b'Bewertung Details'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185',b'The shareholder does not belong to this company',b'Der Aktion\xc3\xa4r geh\xc3\xb6rt nicht zu dieser Gesellschaft'
+b'DocType: Dosage Form',b'Dosage Form',b'Dosierungsform'
+b'apps/erpnext/erpnext/config/selling.py +67',b'Price List master.',b'Preislisten-Vorlagen'
+b'DocType: Task',b'Review Date',b'\xc3\x9cberpr\xc3\xbcfungsdatum'
+b'DocType: Company',b'Series for Asset Depreciation Entry (Journal Entry)',b'Serie f\xc3\xbcr Asset Depreciation Entry (Journal Entry)'
+b'DocType: Membership',b'Member Since',b'Mitglied seit'
+b'DocType: Purchase Invoice',b'Advance Payments',b'Anzahlungen'
+b'DocType: Purchase Taxes and Charges',b'On Net Total',b'Auf Nettosumme'
+b'apps/erpnext/erpnext/controllers/item_variant.py +92',b'Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}',b'Wert f\xc3\xbcr das Attribut {0} muss im Bereich von {1} bis {2} in den Schritten von {3} f\xc3\xbcr Artikel {4}'
+b'DocType: Restaurant Reservation',b'Waitlisted',b'Warteliste'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +124',b'Currency can not be changed after making entries using some other currency',"b'Die W\xc3\xa4hrung kann nicht ge\xc3\xa4ndert werden, wenn Buchungen in einer anderen W\xc3\xa4hrung get\xc3\xa4tigt wurden'"
+b'DocType: Shipping Rule',b'Fixed',b'Fest'
+b'DocType: Vehicle Service',b'Clutch Plate',b'Kupplungsscheibe'
+b'DocType: Company',b'Round Off Account',b'Abschlusskonto'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93',b'Administrative Expenses',b'Verwaltungskosten'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18',b'Consulting',b'Beratung'
+b'DocType: Customer Group',b'Parent Customer Group',b'\xc3\x9cbergeordnete Kundengruppe'
+b'DocType: Journal Entry',b'Subscription',b'Abonnement'
+b'DocType: Purchase Invoice',b'Contact Email',b'Kontakt-E-Mail'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11',b'Fee Creation Pending',b'Geb\xc3\xbchrenermittlung ausstehend'
+b'DocType: Appraisal Goal',b'Score Earned',b'Erreichte Punktzahl'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241',b'Notice Period',b'Mitteilungsfrist'
+b'DocType: Asset Category',b'Asset Category Name',b'Anlagekategorie Name'
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.js +13',b'This is a root territory and cannot be edited.',b'Dies ist ein Root-Gebiet und kann nicht bearbeitet werden.'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5',b'New Sales Person Name',b'Neuer Verkaufspersonenname'
+b'DocType: Packing Slip',b'Gross Weight UOM',b'Bruttogewicht-Ma\xc3\x9feinheit'
+b'DocType: Asset Maintenance Task',b'Preventive Maintenance',b'Vorbeugende Wartung'
+b'DocType: Delivery Note Item',b'Against Sales Invoice',b'Zu Ausgangsrechnung'
+b'DocType: Purchase Invoice',b'07-Others',b'07-Andere'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151',b'Please enter serial numbers for serialized item ',b'Bitte geben Sie Seriennummern f\xc3\xbcr serialisierte Artikel ein'
+b'DocType: Bin',b'Reserved Qty for Production',b'Reserviert Menge f\xc3\xbcr Produktion'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureNum',b'EcritureNum'
+b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. ""","b'Nicht anhaken, wenn Sie keine Stapelverarbeitung beim Anlegen von Kurs basierten Gruppen w\xc3\xbcnschen.'"
+b'DocType: Asset',b'Frequency of Depreciation (Months)',b'Die H\xc3\xa4ufigkeit der Abschreibungen (Monate)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500',b'Credit Account',b'Guthabenkonto'
+b'DocType: Landed Cost Item',b'Landed Cost Item',b'Einstandspreis-Artikel'
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57',b'Show zero values',b'Nullwerte anzeigen'
+b'DocType: BOM',b'Quantity of item obtained after manufacturing / repacking from given quantities of raw materials',b'Menge eines Artikels nach der Herstellung/dem Umpacken auf Basis vorgegebener Mengen von Rohmaterial'
+b'DocType: Lab Test',b'Test Group',b'Testgruppe'
+b'DocType: Payment Reconciliation',b'Receivable / Payable Account',b'Forderungen-/Verbindlichkeiten-Konto'
+b'DocType: Delivery Note Item',b'Against Sales Order Item',b'Zu Kundenauftrags-Position'
+b'DocType: Company',b'Company Logo',b'Firmenlogo'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +709',b'Please specify Attribute Value for attribute {0}',b'Bitte Attributwert f\xc3\xbcr Attribut {0} angeben'
+b'DocType: Item',b'Default Warehouse',b'Standardlager'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45',b'Budget cannot be assigned against Group Account {0}',b'Budget kann nicht einem Gruppenkonto {0} zugeordnet werden'
+b'DocType: Healthcare Settings',b'Patient Registration',b'Patientenregistrierung'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22',b'Please enter parent cost center',b'Bitte \xc3\xbcbergeordnete Kostenstelle eingeben'
+b'DocType: Delivery Note',b'Print Without Amount',b'Drucken ohne Betrag'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57',b'Depreciation Date',b'Abschreibungen Datum'
+,b'Work Orders in Progress',b'Arbeitsauftr\xc3\xa4ge in Bearbeitung'
+b'DocType: Issue',b'Support Team',b'Support-Team'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36',b'Expiry (In Days)',b'Verf\xc3\xa4llt (in Tagen)'
+b'DocType: Appraisal',b'Total Score (Out of 5)',b'Gesamtwertung (max 5)'
+b'DocType: Fee Structure',b'FS.',b'FS.'
+b'DocType: Student Attendance Tool',b'Batch',b'Charge'
+b'DocType: Donor',b'Donor Type',b'Spendertyp'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +27',b'Balance',b'Saldo'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66',b'Please select the Company',b'Bitte w\xc3\xa4hlen Sie das Unternehmen aus'
+b'DocType: Room',b'Seating Capacity',b'Sitzplatzkapazit\xc3\xa4t'
+b'DocType: Issue',b'ISS-',b'ISS-'
+b'DocType: Lab Test Groups',b'Lab Test Groups',b'Labortestgruppen'
+b'DocType: Project',b'Total Expense Claim (via Expense Claims)',b'Gesamtbetrag der Aufwandsabrechnung (\xc3\xbcber Aufwandsabrechnungen)'
+b'DocType: GST Settings',b'GST Summary',b'GST Zusammenfassung'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16',b'Please enable default incoming account before creating Daily Work Summary Group',"b'Bitte aktivieren Sie das standardm\xc3\xa4\xc3\x9fig eingehende Konto, bevor Sie die Daily Work Summary Group erstellen'"
+b'DocType: Assessment Result',b'Total Score',b'Gesamtpunktzahl'
+b'DocType: Journal Entry',b'Debit Note',b'Lastschrift'
+b'DocType: Stock Entry',b'As per Stock UOM',b'Gem\xc3\xa4\xc3\x9f Lagerma\xc3\x9feinheit'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7',b'Not Expired',b'Nicht abgelaufen'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49',b'ValidDate',b'G\xc3\xbcltiges Datum'
+b'DocType: Student Log',b'Achievement',b'Leistung'
+b'DocType: Batch',b'Source Document Type',b'Quelldokumenttyp'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24',b'Following course schedules were created',b'Folgende Kurspl\xc3\xa4ne wurden erstellt'
+b'DocType: Journal Entry',b'Total Debit',b'Gesamt-Soll'
+b'DocType: Manufacturing Settings',b'Default Finished Goods Warehouse',b'Standard-Fertigwarenlager'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108',b'Please select Patient',b'Bitte w\xc3\xa4hlen Sie Patient'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76',b'Sales Person',b'Vertriebsmitarbeiter'
+b'DocType: Hotel Room Package',b'Amenities',b'Ausstattung'
+b'apps/erpnext/erpnext/config/accounts.py +233',b'Budget and Cost Center',b'Budget und Kostenstellen'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65',b'Multiple default mode of payment is not allowed',b'Mehrere Standard-Zahlungsarten sind nicht erlaubt'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',b'for the',b'f\xc3\xbcr die'
+,b'Appointment Analytics',b'Terminanalytik'
+b'DocType: Vehicle Service',b'Half Yearly',b'Halbj\xc3\xa4hrlich'
+b'DocType: Lead',b'Blog Subscriber',b'Blog-Abonnent'
+b'DocType: Guardian',b'Alternate Number',b'Alternative Nummer'
+b'DocType: Healthcare Settings',b'Consultations in valid days',b'Konsultationen in g\xc3\xbcltigen Tagen'
+b'DocType: Assessment Plan Criteria',b'Maximum Score',b'Maximale Punktzahl'
+b'apps/erpnext/erpnext/config/setup.py +83',b'Create rules to restrict transactions based on values.',b'Regeln erstellen um Transaktionen auf Basis von Werten zu beschr\xc3\xa4nken'
+b'DocType: Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts',b'Cash Flow Mapping Konten'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49',b' Group Roll No',b'Gruppenrolle Nr'
+b'DocType: Batch',b'Manufacturing Date',b'Herstellungsdatum'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9',b'Fee Creation Failed',b'Geb\xc3\xbchrenermittlung fehlgeschlagen'
+b'DocType: Opening Invoice Creation Tool',b'Create Missing Party',b'Erstelle fehlende Partei'
+b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',"b'Lassen Sie dies leer, wenn Sie Studentengruppen pro Jahr anlegen.'"
+b'DocType: HR Settings',"b'If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day'","b'Wenn aktiviert, beinhaltet die Gesamtanzahl der Arbeitstage auch Urlaubstage und dies reduziert den Wert des Gehalts pro Tag.'"
+b'DocType: Purchase Invoice',b'Total Advance',b'Summe der Anzahlungen'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27',b'Change Template Code',b'Vorlagencode \xc3\xa4ndern'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23',b'The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.',b'Der Begriff Enddatum kann nicht fr\xc3\xbcher als der Begriff Startdatum. Bitte korrigieren Sie die Daten und versuchen Sie es erneut.'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'Quot Count'
+,b'BOM Stock Report',b'BOM Stock Report'
+b'DocType: Stock Reconciliation Item',b'Quantity Difference',b'Mengendifferenz'
+b'DocType: Employee Advance',b'EA-',b'EA-'
+b'DocType: Opportunity Item',b'Basic Rate',b'Grundpreis'
+b'DocType: GL Entry',b'Credit Amount',b'Guthaben-Summe'
+b'DocType: Cheque Print Template',b'Signatory Position',b'Unterzeichner Position'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173',b'Set as Lost',"b'Als ""verloren"" markieren'"
+b'DocType: Timesheet',b'Total Billable Hours',b'Insgesamt abrechenbare Stunden'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4',b'Payment Receipt Note',b'Zahlungsnachweis'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6',b'This is based on transactions against this Customer. See timeline below for details',b'Dies basiert auf Transaktionen gegen diesen Kunden. Siehe Zeitleiste unten f\xc3\xbcr Details'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162',b'Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2}',b'Zeile {0}: Zugewiesener Betrag {1} muss kleiner oder gleich der Zahlungsmenge {2} sein'
+b'DocType: Program Enrollment Tool',b'New Academic Term',b'Neuer akademischer Begriff'
+,b'Course wise Assessment Report',b'Kursweise Assessment Report'
+b'DocType: Purchase Invoice',b'Availed ITC State/UT Tax',b'Erhaltene ITC-Status- / UT-Steuer'
+b'DocType: Tax Rule',b'Tax Rule',b'Steuer-Regel'
+b'DocType: Selling Settings',b'Maintain Same Rate Throughout Sales Cycle',b'Gleiche Preise w\xc3\xa4hrend des gesamten Verkaufszyklus beibehalten'
+b'DocType: Manufacturing Settings',b'Plan time logs outside Workstation Working Hours.',b'Zeiten au\xc3\x9ferhalb der normalen Arbeitszeiten am Arbeitsplatz zulassen.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115',b'Dr {0} does not have a Physician Schedule. Add it in Physician master',b'Dr {0} hat keinen Arzt-Zeitplan. F\xc3\xbcgen Sie es dem Arzt-Master hinzu'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +98',b'Customers in Queue',b'Kunden in der Warteschlange'
+b'DocType: Driver',b'Issuing Date',b'Ausstellungsdatum'
+b'DocType: Student',b'Nationality',b'Staatsangeh\xc3\xb6rigkeit'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109',b'Submit this Work Order for further processing.',b'Reichen Sie diesen Arbeitsauftrag zur weiteren Bearbeitung ein.'
+,b'Items To Be Requested',b'Anzufragende Artikel'
+b'DocType: Purchase Order',b'Get Last Purchase Rate',b'Letzten Einkaufspreis aufrufen'
+b'DocType: Company',b'Company Info',b'Informationen \xc3\xbcber das Unternehmen'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1385',b'Select or add new customer',b'W\xc3\xa4hlen oder neue Kunden hinzuf\xc3\xbcgen'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173',b'Cost center is required to book an expense claim',"b'Eine Kostenstelle ist erforderlich, um einen Aufwandsanspruch zu buchen.'"
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9',b'Application of Funds (Assets)',b'Mittelverwendung (Aktiva)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6',b'This is based on the attendance of this Employee',b'Dies h\xc3\xa4ngt von der Anwesenheit dieses Mitarbeiters ab'
+b'DocType: Assessment Result',b'Summary',b'Zusammenfassung'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112',b'Mark Attendance',b'Markieren Sie die Anwesenheit'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494',b'Debit Account',b'Sollkonto'
+b'DocType: Fiscal Year',b'Year Start Date',b'Startdatum des Gesch\xc3\xa4ftsjahres'
+b'DocType: Attendance',b'Employee Name',b'Mitarbeitername'
+b'DocType: Restaurant Order Entry Item',b'Restaurant Order Entry Item',b'Restaurantbestellzugangsposten'
+b'DocType: Purchase Invoice',b'Rounded Total (Company Currency)',b'Gerundete Gesamtsumme (Firmenw\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +96',b'Cannot covert to Group because Account Type is selected.',"b'Kann nicht in keine Gruppe umgewandelt werden, weil Kontentyp ausgew\xc3\xa4hlt ist.'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260',b'{0} {1} has been modified. Please refresh.',b'{0} {1} wurde ge\xc3\xa4ndert. Bitte aktualisieren.'
+b'DocType: Leave Block List',b'Stop users from making Leave Applications on following days.',"b'Benutzer davon abhalten, Urlaubsantr\xc3\xa4ge f\xc3\xbcr folgende Tage einzureichen.'"
+b'DocType: Asset Maintenance Team',b'Maintenance Team Members',b'Mitglieder des Wartungsteams'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63',b'Purchase Amount',b'Gesamtbetrag des Einkaufs'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261',b'Supplier Quotation {0} created',b'Lieferant Quotation {0} erstellt'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +103',b'End Year cannot be before Start Year',b'End-Jahr kann nicht gleich oder kleiner dem Start-Jahr sein.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234',b'Employee Benefits',b'Verg\xc3\xbcnstigungen an Mitarbeiter'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264',b'Packed quantity must equal quantity for Item {0} in row {1}',b'Verpackte Menge muss gleich der Menge des Artikel {0} in Zeile {1} sein'
+b'DocType: Work Order',b'Manufactured Qty',b'Produzierte Menge'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78',"b""The shares don't exist with the {0}""",b'Die Freigaben existieren nicht mit der {0}'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64',b'Invoice Created',b'Rechnung erstellt'
+b'DocType: Asset',b'Out of Order',b'Au\xc3\x9fer Betrieb'
+b'DocType: Purchase Receipt Item',b'Accepted Quantity',b'Angenommene Menge'
+b'DocType: Projects Settings',b'Ignore Workstation Time Overlap',b'Arbeitszeit\xc3\xbcberlappung ignorieren'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +242',b'Please set a default Holiday List for Employee {0} or Company {1}',b'Bitte stellen Sie eine Standard-Feiertagsliste f\xc3\xbcr Mitarbeiter {0} oder Gesellschaft {1}'
+b'apps/erpnext/erpnext/accounts/party.py +30',b'{0}: {1} does not exists',b'{0}: {1} existiert nicht'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76',b'Select Batch Numbers',b'W\xc3\xa4hlen Sie Chargennummern aus'
+b'apps/erpnext/erpnext/config/accounts.py +12',b'Bills raised to Customers.',b'Rechnungen an Kunden'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Project Id',b'Projekt-ID'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534',b'Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}',b'Zeile Nr. {0}: Betrag kann nicht gr\xc3\xb6\xc3\x9fer als der ausstehende Betrag zur Aufwandsabrechnung {1} sein. Ausstehender Betrag ist {2}'
+b'DocType: Patient Service Unit',b'Medical Administrator',b'Medizinischer Administrator'
+b'DocType: Assessment Plan',b'Schedule',b'Zeitplan'
+b'DocType: Account',b'Parent Account',b'\xc3\x9cbergeordnetes Konto'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266',b'Available',b'Verf\xc3\xbcgbar'
+b'DocType: Quality Inspection Reading',b'Reading 3',b'Ablesewert\xc2\xa03'
+b'DocType: Stock Entry',b'Source Warehouse Address',b'Adresse des Quelllagers'
+,b'Hub',b'Hub'
+b'DocType: GL Entry',b'Voucher Type',b'Belegtyp'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1717',b'Price List not found or disabled',b'Preisliste nicht gefunden oder deaktiviert'
+b'DocType: Student Applicant',b'Approved',b'Genehmigt'
+b'apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15',b'Price',b'Preis'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267',"b""Employee relieved on {0} must be set as 'Left'""","b'Freigestellter Angestellter {0} muss als ""entlassen"" gekennzeichnet werden'"
+b'DocType: Hub Settings',b'Last Sync On',b'Letzte Synchronisierung an'
+b'DocType: Guardian',b'Guardian',b'W\xc3\xa4chter'
+b'DocType: Opening Invoice Creation Tool',b'Create missing customer or supplier.',b'Erstelle einen fehlenden Kunden oder Lieferanten.'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42',b'Appraisal {0} created for Employee {1} in the given date range',b'Bewertung {0} f\xc3\xbcr Mitarbeiter {1} im angegebenen Datumsbereich erstellt'
+b'DocType: Academic Term',b'Education',b'Bildung'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +89',b'Del',b'Entf'
+b'DocType: Selling Settings',b'Campaign Naming By',b'Benennung der Kampagnen nach'
+b'DocType: Employee',b'Current Address Is',b'Aktuelle Adresse ist'
+b'apps/erpnext/erpnext/utilities/user_progress.py +51',b'Monthly Sales Target (',b'Monatliches Verkaufsziel ('
+b'DocType: Physician Service Unit Schedule',b'Physician Service Unit Schedule',b'Zeitplan f\xc3\xbcr den Arztdienst'
+b'apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9',b'modified',b'ge\xc3\xa4ndert'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43',"b""Optional. Sets company's default currency, if not specified.""","b'Optional. Stellt die Standardw\xc3\xa4hrung des Unternehmens ein, falls nichts angegeben ist.'"
+b'DocType: Sales Invoice',b'Customer GSTIN',b'Kunde GSTIN'
+b'DocType: Crop Cycle',"b""List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ""","b'Liste der erkannten Krankheiten auf dem Feld. Wenn diese Option ausgew\xc3\xa4hlt ist, wird automatisch eine Liste mit Aufgaben zur Behandlung der Krankheit hinzugef\xc3\xbcgt'"
+b'DocType: Asset Repair',b'Repair Status',b'Reparaturstatus'
+b'apps/erpnext/erpnext/config/accounts.py +67',b'Accounting journal entries.',b'Buchungss\xc3\xa4tze'
+b'DocType: Delivery Note Item',b'Available Qty at From Warehouse',b'Verf\xc3\xbcgbare St\xc3\xbcckzahl im Ausgangslager'
+b'DocType: POS Profile',b'Account for Change Amount',b'Konto f\xc3\xbcr \xc3\x84nderungsbetrag'
+b'DocType: Purchase Invoice',b'input service',b'Eingabeservice'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217',b'Row {0}: Party / Account does not match with {1} / {2} in {3} {4}',b'Zeile {0}: Gruppe / Konto stimmt nicht mit {1} / {2} in {3} {4} \xc3\xbcberein'
+b'DocType: Maintenance Team Member',b'Maintenance Team Member',b'Wartungsteammitglied'
+b'DocType: Agriculture Analysis Criteria',b'Soil Analysis',b'Bodenanalyse'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13',b'Course Code: ',b'Kurscode:'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240',b'Please enter Expense Account',b'Bitte das Aufwandskonto angeben'
+b'DocType: Account',b'Stock',b'Lager'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095',"b'Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry'","b'Row # {0}: Referenzdokumenttyp muss eine der Bestellung, Rechnung oder Kaufjournaleintrag sein'"
+b'DocType: Employee',b'Current Address',b'Aktuelle Adresse'
+b'DocType: Item',"b'If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified'","b'Wenn der Artikel eine Variante eines anderen Artikels ist, dann werden Beschreibung, Bild, Preise, Steuern usw. aus der Vorlage \xc3\xbcbernommen, sofern nicht ausdr\xc3\xbccklich etwas angegeben ist.'"
+b'DocType: Serial No',b'Purchase / Manufacture Details',b'Einzelheiten zu Kauf / Herstellung'
+b'DocType: Assessment Group',b'Assessment Group',b'Beurteilungsgruppe'
+b'apps/erpnext/erpnext/config/stock.py +329',b'Batch Inventory',b'Chargenverwaltung'
+b'DocType: Employee',b'Contract End Date',b'Vertragsende'
+b'DocType: Sales Order',b'Track this Sales Order against any Project',b'Diesen Kundenauftrag in jedem Projekt nachverfolgen'
+b'DocType: Sales Invoice Item',b'Discount and Margin',b'Rabatt und Marge'
+b'DocType: Lab Test',b'Prescription',b'Rezept'
+b'DocType: Project',b'Second Email',b'Zweite E-Mail'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111',b'Not Available',b'Nicht verf\xc3\xbcgbar'
+b'DocType: Pricing Rule',b'Min Qty',b'Mindestmenge'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36',b'Disable Template',b'Vorlage deaktivieren'
+b'DocType: GL Entry',b'Transaction Date',b'Transaktionsdatum'
+b'DocType: Production Plan Item',b'Planned Qty',b'Geplante Menge'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121',b'Total Tax',b'Summe Steuern'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204',b'For Quantity (Manufactured Qty) is mandatory',b'F\xc3\xbcr Menge (hergestellte Menge) ist zwingend erforderlich'
+b'DocType: Stock Entry',b'Default Target Warehouse',b'Standard-Eingangslager'
+b'DocType: Purchase Invoice',b'Net Total (Company Currency)',b'Nettosumme (Firmenw\xc3\xa4hrung)'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14',b'The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.',b'Das Jahr Enddatum kann nicht fr\xc3\xbcher als das Jahr Startdatum. Bitte korrigieren Sie die Daten und versuchen Sie es erneut.'
+b'DocType: Notification Control',b'Purchase Receipt Message',b'Kaufbeleg-Nachricht'
+b'DocType: BOM',b'Scrap Items',b'Ausschussartikel'
+b'DocType: Work Order',b'Actual Start Date',b'Tats\xc3\xa4chliches Startdatum'
+b'DocType: Sales Order',b'% of materials delivered against this Sales Order',b'% der f\xc3\xbcr diesen Kundenauftrag gelieferten Materialien'
+b'apps/erpnext/erpnext/config/manufacturing.py +18',b'Generate Material Requests (MRP) and Work Orders.',b'Generieren Sie Materialanforderungen (MRP) und Arbeitsauftr\xc3\xa4ge.'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62',b'Set default mode of payment',b'Legen Sie den Zahlungsmodus fest'
+b'DocType: Grant Application',b'Withdrawn',b'Zur\xc3\xbcckgezogen'
+b'DocType: Hub Settings',b'Hub Settings',b'Hub-Einstellungen'
+b'DocType: Project',b'Gross Margin %',b'Handelsspanne %'
+b'DocType: BOM',b'With Operations',b'Mit Arbeitsg\xc3\xa4ngen'
+b'apps/erpnext/erpnext/accounts/party.py +259',b'Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.',b'Es wurden bereits Buchungen in der W\xc3\xa4hrung {0} f\xc3\xbcr Firma {1} vorgenommen. Bitte ein Forderungs- oder Verbindlichkeiten-Konto mit W\xc3\xa4hrung {0} w\xc3\xa4hlen.'
+b'DocType: Asset',b'Is Existing Asset',b'Ist bereits bestehenden Asset'
+b'DocType: Salary Detail',b'Statistical Component',b'Statistische Komponente'
+b'DocType: Warranty Claim',b'If different than customer address',b'Wenn anders als Kundenadresse'
+b'DocType: Purchase Invoice',b'Without Payment of Tax',b'Ohne Steuerbefreiung'
+b'DocType: BOM Operation',b'BOM Operation',b'St\xc3\xbccklisten-Vorgang'
+b'apps/erpnext/erpnext/config/stock.py +141',b'Fulfilment',b'Erf\xc3\xbcllung'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Amount',b'Auf vorherigen Zeilenbetrag'
+b'DocType: Item',b'Has Expiry Date',b'Hat Ablaufdatum'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +282',b'Transfer Asset',b'Asset \xc3\xbcbertragen'
+b'DocType: POS Profile',b'POS Profile',b'Verkaufsstellen-Profil'
+b'DocType: Training Event',b'Event Name',b'Veranstaltungsname'
+b'DocType: Physician',b'Phone (Office)',b'Telefon (B\xc3\xbcro)'
+b'apps/erpnext/erpnext/hooks.py +151',b'Admission',b'Eintritt'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29',b'Admissions for {0}',b'Zulassung f\xc3\xbcr {0}'
+b'apps/erpnext/erpnext/config/accounts.py +257',"b'Seasonality for setting budgets, targets etc.'","b'Saisonbedingte Besonderheiten zu Budgets, Zielen usw.'"
+b'DocType: Supplier Scorecard Scoring Variable',b'Variable Name',b'Variablennamen'
+b'apps/erpnext/erpnext/stock/get_item_details.py +144',"b'Item {0} is a template, please select one of its variants'","b'Artikel {0} ist eine Vorlage, bitte eine seiner Varianten w\xc3\xa4hlen'"
+b'DocType: Asset',b'Asset Category',b'Anlagekategorie'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31',b'Net pay cannot be negative',b'Nettolohn kann nicht negativ sein'
+b'DocType: Purchase Order',b'Advance Paid',b'Angezahlt'
+b'DocType: Item',b'Item Tax',b'Artikelsteuer'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883',b'Material to Supplier',b'Material an den Lieferanten'
+b'DocType: Soil Texture',b'Loamy Sand',b'Lehmiger Sand'
+b'DocType: Production Plan',b'Material Request Planning',b'Materialanforderungsplanung'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +638',b'Excise Invoice',b'Verbrauch Rechnung'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16',b'Treshold {0}% appears more than once',b'Treshold {0} erscheint% mehr als einmal'
+b'DocType: Expense Claim',b'Employees Email Id',b'E-Mail-ID des Mitarbeiters'
+b'DocType: Employee Attendance Tool',b'Marked Attendance',b'Marked Teilnahme'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138',b'Current Liabilities',b'Laufende Verbindlichkeiten'
+b'apps/erpnext/erpnext/config/selling.py +297',b'Send mass SMS to your contacts',b'Massen-SMS an Kontakte versenden'
+b'DocType: Patient',b'A Positive',b'A +'
+b'DocType: Program',b'Program Name',b'Programmname'
+b'DocType: Purchase Taxes and Charges',b'Consider Tax or Charge for',b'Steuern oder Geb\xc3\xbchren ber\xc3\xbccksichtigen f\xc3\xbcr'
+b'DocType: Driver',b'Driving License Category',b'F\xc3\xbchrerscheinkategorie'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158',b'No Reference',b'Keine Referenz'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57',b'Actual Qty is mandatory',b'Die tats\xc3\xa4chliche Menge ist zwingend erforderlich'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',"b'{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.'","b'{0} hat derzeit eine {1} Supplier Scorecard stehen, und Bestellungen an diesen Lieferanten sollten mit Vorsicht erteilt werden.'"
+b'DocType: Asset Maintenance Team',b'Asset Maintenance Team',b'Asset-Wartungsteam'
+b'DocType: Employee Loan',b'Loan Type',b'Art des Darlehens'
+b'DocType: Scheduling Tool',b'Scheduling Tool',b'Scheduling-Werkzeug'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180',b'Credit Card',b'Kreditkarte'
+b'DocType: BOM',b'Item to be manufactured or repacked',b'Zu fertigender oder umzupackender Artikel'
+b'DocType: Employee Education',b'Major/Optional Subjects',b'Wichtiger/wahlweiser Betreff'
+b'DocType: Sales Invoice Item',b'Drop Ship',b'Streckengesch\xc3\xa4ft'
+b'DocType: Driver',b'Suspended',b'Suspendiert'
+b'DocType: Training Event',b'Attendees',b'Teilnehmer'
+b'DocType: Employee',"b'Here you can maintain family details like name and occupation of parent, spouse and children'","b'Hier k\xc3\xb6nnen Sie Familiendetails wie Namen und Beruf der Eltern, Ehepartner und Kinder pflegen'"
+b'DocType: Academic Term',b'Term End Date',b'Semesterende'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted (Company Currency)',b'Steuern und Geb\xc3\xbchren abgezogen (Firmenw\xc3\xa4hrung)'
+b'DocType: Item Group',b'General Settings',b'Grundeinstellungen'
+b'apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23',b'From Currency and To Currency cannot be same',b'Von-W\xc3\xa4hrung und Bis-W\xc3\xa4hrung k\xc3\xb6nnen nicht gleich sein'
+b'DocType: Stock Entry',b'Repack',b'Umpacken'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6',b'You must Save the form before proceeding',b'Sie m\xc3\xbcssen das Formular speichern um fortzufahren'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113',b'Please select the Company first',b'Bitte w\xc3\xa4hlen Sie zuerst die Firma aus'
+b'DocType: Item Attribute',b'Numeric Values',b'Numerische Werte'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +56',b'Attach Logo',b'Logo anh\xc3\xa4ngen'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +51',b'Stock Levels',b'Lagerbest\xc3\xa4nde'
+b'DocType: Customer',b'Commission Rate',b'Provisionssatz'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187',b'Created {0} scorecards for {1} between: ',b'Erstellte {0} Scorecards f\xc3\xbcr {1} zwischen:'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +505',b'Make Variant',b'Variante anlegen'
+b'apps/erpnext/erpnext/config/hr.py +87',b'Block leave applications by department.',b'Urlaubsantr\xc3\xa4ge pro Abteilung sperren'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155',"b'Payment Type must be one of Receive, Pay and Internal Transfer'","b'Zahlungsart muss eine der Receive sein, Pay und interne \xc3\x9cbertragung'"
+b'apps/erpnext/erpnext/config/selling.py +184',b'Analytics',b'Analysetools'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25',b'Cart is Empty',b'Der Warenkorb ist leer'
+b'DocType: Vehicle',b'Model',b'Modell'
+b'DocType: Work Order',b'Actual Operating Cost',b'Tats\xc3\xa4chliche Betriebskosten'
+b'DocType: Payment Entry',b'Cheque/Reference No',b'Scheck-/ Referenznummer'
+b'DocType: Soil Texture',b'Clay Loam',b'Ton Lehm'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +81',b'Root cannot be edited.',b'Root kann nicht bearbeitet werden.'
+b'DocType: Item',b'Units of Measure',b'Ma\xc3\x9feinheiten'
+b'DocType: Manufacturing Settings',b'Allow Production on Holidays',b'Fertigung im Urlaub zulassen'
+b'DocType: Sales Invoice',"b""Customer's Purchase Order Date""",b'Kundenauftragsdatum'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163',b'Capital Stock',b'Grundkapital'
+b'DocType: Shopping Cart Settings',b'Show Public Attachments',b'\xc3\x96ffentliche Anh\xc3\xa4nge anzeigen'
+b'DocType: Packing Slip',b'Package Weight Details',b'Details\xc2\xa0zum Verpackungsgewicht'
+b'DocType: Restaurant Reservation',b'Reservation Time',b'Reservierungszeit'
+b'DocType: Payment Gateway Account',b'Payment Gateway Account',b'Payment Gateway Konto'
+b'DocType: Shopping Cart Settings',b'After payment completion redirect user to selected page.',"b'Nach Abschluss der Zahlung, Benutzer auf ausgew\xc3\xa4hlte Seite weiterleiten.'"
+b'DocType: Company',b'Existing Company',b'Bestehende Firma'
+b'DocType: Healthcare Settings',b'Result Emailed',b'Ergebnis Emailed'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +87',"b'Tax Category has been changed to ""Total"" because all the Items are non-stock items'","b'Steuer-Kategorie wurde in ""Total"" ge\xc3\xa4ndert, da alle Artikel keine Lagerartikel sind'"
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103',b'Please select a csv file',b'Bitte eine CSV-Datei ausw\xc3\xa4hlen.'
+b'DocType: Student Leave Application',b'Mark as Present',b'Als anwesend markieren'
+b'DocType: Supplier Scorecard',b'Indicator Color',b'Indikatorfarbe'
+b'DocType: Purchase Order',b'To Receive and Bill',b'Um zu empfangen und abzurechnen'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +445',b'Row #{0}: Reqd by Date cannot be before Transaction Date',b'Zeilennr. {0}: Erforderlich nach Datum darf nicht vor dem Transaktionsdatum liegen'
+b'apps/erpnext/erpnext/templates/pages/home.html +14',b'Featured Products',b'Ausgew\xc3\xa4hlte Artikel'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136',b'Designer',b'Konstrukteur'
+b'apps/erpnext/erpnext/config/selling.py +163',b'Terms and Conditions Template',b'Vorlage f\xc3\xbcr Allgemeine Gesch\xc3\xa4ftsbedingungen'
+b'DocType: Serial No',b'Delivery Details',b'Lieferdetails'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495',b'Cost Center is required in row {0} in Taxes table for type {1}',b'Kostenstelle wird in Zeile {0} der Steuertabelle f\xc3\xbcr Typ {1} gebraucht'
+b'DocType: Program',b'Program Code',b'Programmcode'
+b'DocType: Terms and Conditions',b'Terms and Conditions Help',b'Allgemeine Gesch\xc3\xa4ftsbedingungen Hilfe'
+,b'Item-wise Purchase Register',b'Artikelbezogene \xc3\x9cbersicht der Eink\xc3\xa4ufe'
+b'DocType: Driver',b'Expiry Date',b'Verfallsdatum'
+b'DocType: Healthcare Settings',b'Employee name and designation in print',b'Name und Bezeichnung des Mitarbeiters im Druck'
+,b'accounts-browser',b'Konten-Browser'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368',b'Please select Category first',b'Bitte zuerst Kategorie ausw\xc3\xa4hlen'
+b'apps/erpnext/erpnext/config/projects.py +13',b'Project master.',b'Projekt-Stammdaten'
+b'apps/erpnext/erpnext/controllers/status_updater.py +212',"b'To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.'","b'Um eine \xc3\x9cberberechnung oder eine \xc3\x9cberbestellung zu erm\xc3\xb6glichen, muss die Einstellung in den Lagereinstellungen oder im Artikel angepasst werden.'"
+b'DocType: Global Defaults',b'Do not show any symbol like $ etc next to currencies.',b'Kein Symbol wie $ usw. neben W\xc3\xa4hrungen anzeigen.'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431',b' (Half Day)',b'(Halbtags)'
+b'DocType: Payment Term',b'Credit Days',b'Zahlungsziel'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145',b'Please select Patient to get Lab Tests',"b'Bitte w\xc3\xa4hlen Sie Patient, um Labortests zu erhalten'"
+b'apps/erpnext/erpnext/utilities/activation.py +128',b'Make Student Batch',b'Machen Sch\xc3\xbcler Batch'
+b'DocType: Fee Schedule',b'FRQ.',b'FRQ'
+b'DocType: Leave Type',b'Is Carry Forward',b'Ist \xc3\x9cbertrag'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841',b'Get Items from BOM',b'Artikel aus der St\xc3\xbcckliste holen'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Lead Time Days',b'Lieferzeittage'
+b'DocType: Cash Flow Mapping',b'Is Income Tax Expense',b'Ist Einkommensteueraufwand'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +621',b'Row #{0}: Posting Date must be same as purchase date {1} of asset {2}',b'Row # {0}: Datum der Ver\xc3\xb6ffentlichung muss als Kaufdatum gleich sein {1} des Asset {2}'
+b'DocType: Program Enrollment',"b""Check this if the Student is residing at the Institute's Hostel.""","b'\xc3\x9cberpr\xc3\xbcfen Sie dies, wenn der Student im Gasthaus des Instituts wohnt.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125',b'Please enter Sales Orders in the above table',b'Bitte geben Sie Kundenauftr\xc3\xa4ge in der obigen Tabelle'
+,b'Stock Summary',b'Lager-Zusammenfassung'
+b'apps/erpnext/erpnext/config/assets.py +54',b'Transfer an asset from one warehouse to another',b'\xc3\x9cbertragen Sie einen Verm\xc3\xb6genswert von einem Lager zum anderen'
+b'DocType: Vehicle',b'Petrol',b'Benzin'
+b'apps/erpnext/erpnext/config/learn.py +217',b'Bill of Materials',b'St\xc3\xbcckliste'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105',b'Row {0}: Party Type and Party is required for Receivable / Payable account {1}',b'Zeile {0}: Gruppen-Typ und Gruppe sind f\xc3\xbcr Forderungen-/Verbindlichkeiten-Konto {1} zwingend erforderlich'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94',b'Ref Date',b'Ref-Datum'
+b'DocType: Employee',b'Reason for Leaving',b'Grund f\xc3\xbcr den Austritt'
+b'DocType: BOM Operation',b'Operating Cost(Company Currency)',b'Betriebskosten (Gesellschaft W\xc3\xa4hrung)'
+b'DocType: Employee Loan Application',b'Rate of Interest',b'Zinssatz'
+b'DocType: Expense Claim Detail',b'Sanctioned Amount',b'Genehmigter Betrag'
+b'DocType: Item',b'Shelf Life In Days',b'Haltbarkeit in Tagen'
+b'DocType: GL Entry',b'Is Opening',b'Ist Er\xc3\xb6ffnungsbuchung'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196',b'Row {0}: Debit entry can not be linked with a {1}',b'Zeile {0}: Sollbuchung kann nicht mit ein(em) {1} verkn\xc3\xbcpft werden'
+b'DocType: Journal Entry',b'Subscription Section',b'Abonnementbereich'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +177',b'Account {0} does not exist',b'Konto {0} existiert nicht'
+b'DocType: Training Event',b'Training Program',b'Trainingsprogramm'
+b'DocType: Account',b'Cash',b'Bargeld'
+b'DocType: Employee',b'Short biography for website and other publications.',b'Kurzbiographie f\xc3\xbcr die Webseite und andere Publikationen.'
