Salary Mode,Mode Plat,
"Select Monthly Distribution, if you want to track based on seasonality.","Vyberte měsíční výplatou, pokud chcete sledovat na základě sezónnosti."
Divorced,Rozveden$1,
Warning: Same item has been entered multiple times.,Upozornění: Stejné položky byl zadán vícekrát.
Items already synced,Položky již synchronizovat,
"If you have created a standard template in Purchase Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu nákupem daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
Cancel Material Visit {0} before cancelling this Warranty Claim,Materiál Navštivte {0} před zrušením této záruční reklamaci Zrušit,
Consumer Products,Spotřební zbožt,
Please select Party Type first,"Prosím, vyberte typ Party první"
Annealing,Žíhány,
Customer Items,Zákazník položky,
Account {0}: Parent account {1} can not be a ledger,Účet {0}: Nadřazený účet {1} nemůže být hlavní kniha,
Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com,
Email Notifications,E-mailová upozorněny,
Default Unit of Measure,Výchozí Měrná jednotka,
All Sales Partner Contact,Všechny Partneři Kontakt,
Leave Approvers,Nechte schvalovately,
Dealer,Dealer,
Rented,Pronajato,
Get Stock and Rate,Získejte skladem a Rate,
Website,Stránky,
Compaction plus sintering,Zhutňování a spékány,
"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""","Položka, která představuje balíček. Tato položka musí mít ""je skladem"" jako ""No"" a ""Je Sales Item"" jako ""Yes"""
Currency is required for Price List {0},Měna je vyžadováno pro Ceníku {0}
* Will be calculated in the transaction.,* Bude se vypočítá v transakci.
Please enter Employee Id of this sales parson,"Prosím, zadejte ID zaměstnance této kupní farář"
Please set Google Drive access keys in {0},Prosím nastavte klíče pro přístup Google Drive In {0}
From Material Request,Z materiálu Poptávka,
{0} Tree,{0} Strom,
Job Applicant,Job Žadatel,
No more results.,Žádné další výsledky.
Legal,Právn$1,
Actual type tax cannot be included in Item rate in row {0},Aktuální typ daň nemůže být zahrnutý v ceně Položka v řádku {0}
Customer,Zákazník,
Required By,Vyžadováno,
Department,Oddělenk,
% Billed,% Fakturováno,
Customer Name,Jméno zákazníka,
"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Všech oblastech souvisejících vývozní jako měnu, přepočítacího koeficientu, export celkem, export celkovém součtu etc jsou k dispozici v dodací list, POS, citace, prodejní faktury, prodejní objednávky atd"
Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (nebo skupiny), proti nimž účetní zápisy jsou vyrobeny a stav je veden."
Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
Default 10 mins,Výchozí 10 min,
Leave Type Name,Nechte Typ Jméno,
Series Updated Successfully,Řada Aktualizováno Úspěšnn,
Stitching,Šitn,
Apply On,Naneste na,
Multiple Item prices.,Více ceny položku.
Purchase Order Items To Be Received,Položky vydané objednávky k přijett,
All Supplier Contact,Vše Dodavatel Kontakt,
Parameter,Parametr,
Please specify a Price List which is valid for Territory,"Uveďte prosím ceníku, který je platný pro území"
Expected End Date can not be less than Expected Start Date,"Očekávané Datum ukončení nemůže být nižší, než se očekávalo data zahájení"
Do really want to unstop production order:,Opravdu chcete uvolnit výrobní zakázky: 
New Leave Application,New Leave Application,
Bank Draft,Bank Návrh,
1. To maintain the customer wise item code and to make them searchable based on their code use this option,"1.Chcete-li zachovat zákazníkovo produktové číslo a také podle něj vyhledávat, použijte tuto možnost"
Mode of Payment Account,Způsob platby účtu,
Show Variants,Zobrazit Varianty,
Quantity,Množstvu,
Loans (Liabilities),Úvěry (závazky)
Year of Passing,Rok Passing,
Designation,Označeng,
Production Plan Item,Výrobní program Item,
User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
Health Care,Péče o zdrava,
Monthly,Měsíčna,
Invoice,Faktura,
Periodicity,Periodicita,
Email Address,E-mailová adresa,
Defense,Obrana,
Abbr,Zkr,
Score (0-5),Score (0-5)
Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3}
Row # {0}:,Řádek # {0}:
Vehicle No,Vozidle,
Please select Price List,"Prosím, vyberte Ceník"
Woodworking,Zpracování dřeva,
Work In Progress,Work in Progress,
If Monthly Budget Exceeded,Pokud Měsíční rozpočet překročen,
3D printing,3D tisk,
Holiday List,Dovolená Seznam,
Time Log,Time Log,
Accountant,Účetna,
Phone No,Telefon,
"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Log činností vykonávaných uživateli proti úkoly, které mohou být použity pro sledování času, fakturaci."
New {0}: #{1},Nový {0}: # {1}
Sales Partners Commission,Obchodní partneři Komise,
Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znake,
Allow Google Drive Access,Povolit Google disku přístup,
Projects & System,Projekty a System,
Classic,Klasicke,
This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.
Shipping Rules,Přepravní řád,
Operations,Operace,
Cannot set authorization on basis of Discount for {0},Nelze nastavit oprávnění na základě Sleva pro {0}
Quantity Requested for Purchase,Požadovaného množství na nákup,
"Attach .csv file with two columns, one for the old name and one for the new name","Připojit CSV soubor se dvěma sloupci, jeden pro starý název a jeden pro nový název"
Parent Detail docname,Parent Detail docname,
Kg,Kg,
Opening for a Job.,Otevření o zaměstnání.
Advertising,Reklama,
Married,Ženata,
Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
Reconcile,Srovnat,
Grocery,Potraviny,
Reading 1,Čtení 1,
Make Bank Entry,Proveďte Bank Vstup,
Pension Funds,Penzijní fondy,
Warehouse is mandatory if account type is Warehouse,"Sklad je povinné, pokud typ účtu je Warehouse"
All Sales Person,Všichni obchodní zástupci,
Credentials,Pověřovací listiny,
"Check if recurring order, uncheck to stop recurring or put proper End Date","Zkontrolujte, zda je opakující se, zrušte zaškrtnutí políčka zastavit opakované nebo dát správné datum ukončení"
Sales Invoice Item,Prodejní faktuře položka,
Credit,Úvěr,
Please setup Employee Naming System in Human Resource > HR Settings,"Prosím, setup zaměstnanců pojmenování systému v oblasti lidských zdrojů> Nastavení HR"
Write Off Cost Center,Odepsat nákladové středisko,
Warehouse Detail,Sklad Detail,
Credit limit has been crossed for customer {0} {1}/{2},Úvěrový limit byla překročena o zákazníka {0} {1} / {2}
You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
Parent Item {0} must be not Stock Item and must be a Sales Item,Parent Item {0} nesmí být skladem a musí být prodejní položky,
Item Image (if not slideshow),Item Image (ne-li slideshow)
An Customer exists with same name,Zákazník existuje se stejným názvem,
(Hour Rate / 60) * Actual Operation Time,(Hodina Rate / 60) * Skutečná Provozní doba,
SMS Log,SMS Log,
Cost of Delivered Items,Náklady na dodávaných výrobkm,
Guest,Host,
Get Specification Details,Získat Specifikace Podrobnosti,
Interested,Zájemci,
Bill of Material,Bill of materiálu,
From {0} to {1},Od {0} do {1}
Copy From Item Group,Kopírovat z bodu Group,
Opening Entry,Otevření Entry,
{0} is mandatory,{0} je povinnp,
Contact master.,Kontakt master.
Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
Product Enquiry,Dotaz Product,
Owner,Majitel,
Please enter company first,"Prosím, nejprave zadejte společnost"
Please select Company first,"Prosím, vyberte první firma"
Under Graduate,Za absolventa,
Target On,Target On,
Total Cost,Celkové náklady,
Reaming,Vystružována,
Stub,Pahýl,
Activity Log:,Aktivita Log:
Item {0} does not exist in the system or has expired,Bod {0} neexistuje v systému nebo vypršela,
Real Estate,Nemovitost,
Statement of Account,Výpis z účtu,
Pharmaceuticals,Farmaceuticka,
Claim Amount,Nárok Částka,
Mr,Pan,
Client,Klient,
Supplier Type / Supplier,Dodavatel Typ / dovozce,
Prefix,Prefix,
Consumable,Spotřebna,
Import Log,Záznam importu,
Send,Odeslat,
All Contact,Vše Kontakt,
Annual Salary,Roční Plat,
Closing Fiscal Year,Uzavření fiskálního roku,
Stock Expenses,Stock Náklady,
Email Sent?,E-mail odeslán?
Contra Entry,Contra Entry,
Show Time Logs,Show Time Záznamy,
Bank/Cash Balance,Bank / Cash Balance,
Installation Status,Stav instalace,
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
Supply Raw Materials for Purchase,Dodávky suroviny pro nákup,
Item {0} must be a Purchase Item,Bod {0} musí být Nákup položky,
"Download the Template, fill appropriate data and attach the modified file.
All dates and employee combination in the selected period will come in the template, with existing attendance records","Stáhněte si šablony, vyplňte potřebné údaje a přiložte upravený soubor.
 Všechny termíny a zaměstnanec kombinaci ve zvoleném období přijde v šabloně, se stávajícími evidence docházky"
Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
Will be updated after Sales Invoice is Submitted.,Bude aktualizováno po odeslání faktury.
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Chcete-li zahrnout daně na řádku v poměru Položka {0}, daně v řádcích {1} musí být zahrnuty"
Settings for HR Module,Nastavení pro HR modul,
SMS Center,SMS centrum,
Straightening,Rovnacl,
New BOM,New BOM,
There were no updates in the items selected for this digest.,Nebyly zjištěny žádné aktualizace ve vybraných položek pro tento digest.
Countergravity casting,Countergravity lita,
Newsletter has already been sent,Newsletter již byla odeslána,
Request Type,Typ požadavku,
Reason,Důvod,
The rate at which Bill Currency is converted into company's base currency,"Sazba, za kterou je Bill měny převeden do společnosti základní měny"
Broadcasting,Vysílán$1,
Execution,Proveden$1,
The first user will become the System Manager (you can change this later).,První uživatel bude System Manager (lze později změnit).
Details of the operations carried out.,Podrobnosti o prováděných operací.
Maintenance Status,Status Maintenance,
From Date should be within the Fiscal Year. Assuming From Date = {0},"Od data by měla být v rámci fiskálního roku. Za předpokladu, že od data = {0}"
Select the Employee for whom you are creating the Appraisal.,"Vyberte zaměstnance, pro kterého vytváříte hodnocení."
Cost Center {0} does not belong to Company {1},Náklady Center {0} nepatří do společnosti {1}
Individual,Individuáln$1,
Plan for maintenance visits.,Plán pro návštěvy údržby.
Enter url parameter for message,Zadejte url parametr zprávy,
Rules for applying pricing and discount.,Pravidla pro používání cen a slevy.
Price List must be applicable for Buying or Selling,Ceník musí být použitelný pro nákup nebo prodej,
Installation date cannot be before delivery date for Item {0},Datum Instalace nemůže být před datem dodání pro bod {0}
Start,Start,
First Name,Křestní jméno,
Your setup is complete. Refreshing.,Nastavení je dokončeno. Aktualizuji.
Full-mold casting,Lití Full-forma,
Select Terms and Conditions,Vyberte Podmínky,
Payments made during the digest period,Platby provedené v období digest,
Sales Orders,Prodejní objednávky,
Valuation,Oceněna,
Set as Default,Nastavit jako výchoza,
Purchase Order Trends,Nákupní objednávka trendy,
Allocate leaves for the year.,Přidělit listy za rok.
Earning Type,Výdělek Type,
New Sales Orders,Nové Prodejní objednávky,
Bank Account,Bankovní účet,
Allow Negative Balance,Povolit záporný zůstatek,
Receivable / Payable account will be identified based on the field Master Type,Pohledávka / Závazek účet bude určen na základě hlavního pole typu,
Default Territory,Výchozí Territory,
Television,Televize,
Gashing,Rozsekne,
Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
Account {0} does not belong to Company {1},Účet {0} nepatří do společnosti {1}
Series List for this Transaction,Řada seznam pro tuto transakci,
Reserved Warehouse required for stock Item {0} in row {1},Vyhrazeno Warehouse potřebný pro živočišnou item {0} v řadě {1}
Is Opening Entry,Je vstupní otvor,
Mention if non-standard receivable account applicable,Zmínka v případě nestandardní pohledávky účet použitelnr,
For Warehouse is required before Submit,Pro Sklad je povinné před Odesláním,
Reseller,Reseller,
Please enter Company,"Prosím, zadejte společnost"
Against Sales Invoice Item,Proti položce vydané faktury,
Production Orders in Progress,Zakázka na výrobu v Progress,
Auto-raise Material Request if quantity goes below re-order level in default warehouse,"Auto-raise Material žádosti, pokud množství klesne pod úroveň re-pořadí, ve výchozím skladu"
Write Off Amount <=,Napište jednorázová částka <=
Address & Contact,Adresa a kontakt,
Next Recurring {0} will be created on {1},Další Opakující {0} bude vytvořen na {1}
Create Stock Ledger Entries when you submit a Sales Invoice,Vytvořte Stock Ledger záznamy při odeslání prodejní faktuře,
Total Subscribers,Celkem Odběratele,
Contact Name,Kontakt Jméno,
SO Pending Qty,SO Pending Množstve,
Creates salary slip for above mentioned criteria.,Vytvoří výplatní pásku na výše uvedených kritérií.
No description given,No vzhledem k tomu popis,
Request for purchase.,Žádost o koupi.
Double housing,Double bydlen$1,
"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Jednotka měření této položky (např Kg, Unit, No, pár)."
Only the selected Leave Approver can submit this Leave Application,Pouze vybraný Leave schvalovač může podat této dovolené aplikaci,
Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum spojováni,
Leaves per Year,Listy za rok,
Will be updated when batched.,Bude aktualizována při dávkově.
Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
Material Master Manager,Materiál Hlavní manažer,
Message,Zpráva,
Pending Items {0} updated,Nevyřízené položky {0} Aktualizováno,
Item Website Specification,Položka webových stránek Specifikace,
Dropbox Access Key,Dropbox Access Key,
Reference No,Referenční číslo,
Leave Blocked,Nechte Blokováno,
Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1}
Annual,Ročnm,
Stock Reconciliation Item,Reklamní Odsouhlasení Item,
In Words will be visible once you save the Purchase Invoice.,"Ve slovech budou viditelné, jakmile uložíte o nákupu."
Sales Invoice No,Prodejní faktuře e,
Min Order Qty,Min Objednané množstve,
Do Not Contact,Nekontaktujte,
The unique id for tracking all recurring invoices. It is generated on submit.,Unikátní ID pro sledování všech opakující faktury. To je generován na odeslat.
Software Developer,Software Developer,
Minimum Order Qty,Minimální objednávka Množstvr,
Supplier Type,Dodavatel Type,
Publish in Hub,Publikovat v Hub,
Terretory,Terretory,
Item {0} is cancelled,Položka {0} je zrušen,
Material Request,Požadavek na materiál,
Update Clearance Date,Aktualizace Výprodej Datum,
Wire brushing,Wire kartáčovánr,
Relation,Vztah,
Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
Rejected Quantity,Zamítnuto Množstv$1,
"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Pole k dispozici v dodací list, cenovou nabídku, prodejní faktury odběratele"
SMS Sender Name,SMS Sender Name,
Is Primary Contact,Je primárně Kontakt,
Notification Control,Oznámení Control,
Suggestions,Návrhy,
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Položka Skupina-moudrý rozpočty na tomto území. Můžete také sezónnosti nastavením distribuce.
Please enter parent account group for warehouse {0},"Prosím, zadejte mateřskou skupinu účtu pro sklad {0}"
Address HTML,Adresa HTML,
Mobile No.,Mobile No.
Generate Schedule,Generování plán,
Hubbing,Hubbing,
Expense Head,Náklady Head,
Please select Charge Type first,"Prosím, vyberte druh tarifu první"
Latest,Nejnovějše,
Max 5 characters,Max 5 znake,
New Quotations,Nové Citace,
Select Your Language,Zvolit jazyk,
The first Leave Approver in the list will be set as the default Leave Approver,První Leave schvalovač v seznamu bude nastaven jako výchozí Leave schvalujícího,
Settings for Accounts,Nastavení účte,
Manage Sales Person Tree.,Správa obchodník strom.
Synced With Hub,Synchronizovány Hub,
Variant Of,Varianta,
Item {0} must be Service Item,Položka {0} musí být Service Item,
Completed Qty can not be greater than 'Qty to Manufacture',"Dokončené množství nemůže být větší než ""Množství do výroby"""
Administrator,Správce,
Laser drilling,Laserové vrtáne,
New Stock UOM,Nových akcií UOM,
Closing Account Head,Závěrečný účet hlava,
"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Přidat / Upravit </a>"
External Work History,Vnější práce History,
Circular Reference Error,Kruhové Referenční Chyba,
Closed,Zavřeno,
In Words (Export) will be visible once you save the Delivery Note.,"Ve slovech (export) budou viditelné, jakmile uložíte doručení poznámku."
Industry,Průmysl,
Job Profile,Job Profile,
Newsletter,Newsletter,
Hydroforming,Hydroforming,
Necking,Zúženl,
Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka,
Item is updated,Položka je aktualizována,
Global POS Setting {0} already created for company {1},Global POS nastavení {0} již vytvořený pro společnost {1}
System Manager,Správce systému,
Invoice Type,Typ faktury,
Delivery Note,Dodací list,
Allow Dropbox Access,Povolit přístup Dropbox,
Support Manager,Manažer podpory,
Reserved Warehouse,Vyhrazeno Warehouse,
Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu."
{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce,
Rent Cost,Rent Cost,
Please select month and year,Vyberte měsíc a rok,
"Enter email id separated by commas, invoice will be mailed automatically on particular date","Zadejte e-mail id odděleny čárkami, bude faktura bude zaslán automaticky na určité datum"
Company Email,Společnost E-mail,
Refresh,obnovit,
"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Všech souvisejících oblastech, jako je dovozní měně, přepočítací koeficient, dovoz celkem, dovoz celkovém součtu etc jsou k dispozici v dokladu o koupi, dodavatelů nabídky, faktury, objednávky apod"
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,"Tento bod je šablona a nemůže být použit v transakcích. Atributy položky budou zkopírovány do variant, pokud je nastaveno ""No Copy"""
Total Order Considered,Celková objednávka Zvážil,
Discount (%),Sleva (%)
"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
Please enter 'Repeat on Day of Month' field value,"Prosím, zadejte ""Opakujte dne měsíce"" hodnoty pole"
Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je zákazník měny převeden na zákazníka základní měny"
"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","K dispozici v BOM, dodací list, fakturu, výrobní zakázky, objednávky, doklad o koupi, prodejní faktury odběratele, Stock vstupu, časový rozvrh"
Tax Rate,Tax Rate,
Select Item,Select Položka,
{0} {1} status is Stopped,{0} {1} status je zastavena,
"Item: {0} managed batch-wise, can not be reconciled using \
					Stock Reconciliation, instead use Stock Entry","Item: {0} podařilo dávkové, nemůže být v souladu s použitím \
 Stock usmíření, použijte Reklamní Entry"
Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána,
Convert to non-Group,Převést na non-Group,
Purchase Receipt must be submitted,Příjmka musí být odeslána,
Current Stock UOM,Current Reklamní UOM,
Batch (lot) of an Item.,Batch (lot) položky.
Invoice Date,Datum Fakturace,
"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'","Jelikož jsou stávající skladové transakce za tuto položku, nelze změnit hodnoty ""Má pořadové číslo"", ""má Batch ne"", ""Je skladem"" a ""oceňování metoda"""
Your email address,Vaše e-mailová adresa,
Income booked for the digest period,Příjmy žlutou kartu za období digest,
Supplier master.,Dodavatel master.
Please see attachment,"Prosím, viz příloha"
% Received,% Přijatm,
Water jet cutting,Řezání vodním paprskem,
Setup Already Complete!!,Setup již dokončen !!
Finished Goods,Hotové zbože,
Instructions,Instrukce,
Inspected By,Zkontrolován,
Maintenance Type,Typ Maintenance,
Serial No {0} does not belong to Delivery Note {1},Pořadové číslo {0} není součástí dodávky Poznámka: {1}
Item Quality Inspection Parameter,Položka Kontrola jakosti Parametr,
Leave Approver Name,Nechte schvalovač Jméno,
Schedule Date,Plán Datum,
Packed Item,Zabalená položka,
Default settings for buying transactions.,Výchozí nastavení pro nákup transakcí.
Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pro zaměstnance {0} proti Typ aktivity - {1}
Please do NOT create Accounts for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,"Prosím, ne vytvářet účty pro zákazníky a dodavateli. Jsou vytvořeny přímo od zákazníka / dodavatele mistrů."
Currency Exchange,Směnárna,
Item Name,Název položky,
Credit Balance,Credit Balance,
Widowed,Ovdověla,
"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Položky, které je třeba požádat, které jsou ""Není skladem"" s ohledem na veškeré sklady na základě předpokládaného Množství a minimální Objednané množství"
Working Hours,Pracovní doba,
Change the starting / current sequence number of an existing series.,Změnit výchozí / aktuální pořadové číslo existujícího série.
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Je-li více pravidla pro tvorbu cen i nadále přednost, jsou uživatelé vyzváni k nastavení priority pro vyřešení konfliktu."
Purchase Return,Nákup Return,
Purchase Register,Nákup Register,
"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Výběr ""Ano"" umožní tato položka přijít na odběratele, dodací list"
Please enter Purchase Receipt No to proceed,Zadejte prosím doklad o koupi No pokračovat,
Applicable Charges,Použitelné Poplatky,
Consumable Cost,Spotřební Cost,
{0} ({1}) must have role 'Leave Approver',"{0} ({1}), musí mít roli ""Schvalovatel dovolených"""
Medical,Lékařsky,
Reason for losing,Důvod ztráty,
Tube beading,Tube navlékání korálky,
Workstation is closed on the following dates as per Holiday List: {0},Workstation je uzavřena v následujících dnech podle Prázdninový Seznam: {0}
Make Maint. Schedule,Proveďte údržba. Plán,
Single,Jednolůžkovn,
Cost of Goods Sold,Náklady na prodej zbožn,
Yearly,Ročnn,
Please enter Cost Center,"Prosím, zadejte nákladové středisko"
Sales Order,Prodejní objednávky,
Avg. Selling Rate,Avg. Prodej Rate,
Start date of current order's period,Datum období současného objednávky Začátek,
Quantity cannot be a fraction in row {0},Množství nemůže být zlomek na řádku {0}
Quantity and Rate,Množství a cena,
% Installed,% Instalováno,
Please enter company name first,"Prosím, zadejte nejprve název společnosti"
Item Desription,Položka Desription,
Supplier Name,Dodavatel Name,
Is Group,Is Group,
Thermoforming,Tvarovánn,
Slitting,Kotoučovn,
'To Case No.' cannot be less than 'From Case No.',"""DO Případu č ' nesmí být menší než ""Od Případu č '"
Non Profit,Non Profit,
Not Started,Nezahájeno,
Channel Partner,Channel Partner,
Old Parent,Staré nadřazent,
Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Přizpůsobte si úvodní text, který jede jako součást tohoto e-mailu. Každá transakce je samostatný úvodní text."
Sales Master Manager,Sales manažer ve skupině Master,
Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.
Accounts Frozen Upto,Účty Frozen aa,
Sent On,Poslán na,
Not Applicable,Nehodí se,
Holiday master.,Holiday master.
Shell molding,Shell lita,
Required Date,Požadovaná data,
Billing Address,Fakturační adresa,
Please enter Item Code.,"Prosím, zadejte kód položky."
Costing,Rozpočet,
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Je-li zaškrtnuto, bude částka daně považovat za již zahrnuty v tisku Rate / Tisk Částka"
Total Qty,Celkem Množstvy,
Health Concerns,Zdravotní Obavy,
Unpaid,Nezaplaceny,
From Package No.,Od č balíčku,
Securities and Deposits,Cenné papíry a vklady,
Imports,Importy,
Adhesive bonding,Lepeny,
Description of a Job Opening,Popis jednoho volných pozic,
Attendance record.,Účast rekord.
Journal Entries,Zápisy do Deníku,
Used for Production Plan,Používá se pro výrobní plán,
Loading...,Nahrávám...
Password,Heslo,
Fused deposition modeling,Nánosový modelování depozice,
Time Between Operations (in mins),Doba mezi operací (v min)
"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Poznámka: Zálohy a soubory nejsou odstraněny z Disku Google, budete muset odstranit ručně."
Buyer of Goods and Services.,Kupující zboží a služeb.
Accounts Payable,Účty za úplatu,
Add Subscribers,Přidat předplatitelu,
""" does not exists",""" Neexistuje"
Valid Upto,Valid a$1,
List a few of your customers. They could be organizations or individuals.,Seznam několik svých zákazníků. Ty by mohly být organizace nebo jednotlivci.
Open Tickets,Otevřené Vstupenky,
Direct Income,Přímý příjmy,
Total amount of invoices received from suppliers during the digest period,Celková výše přijatých faktur od dodavatelů během období digest,
"Can not filter based on Account, if grouped by Account","Nelze filtrovat na základě účtu, pokud seskupeny podle účtu"
Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,"Dodací lhůta dnech je počet dní, o nichž je tato položka očekává ve skladu. Tento dnech je přitažené za vlasy v hmotné požadavku při výběru této položky."
Administrative Officer,Správní ředitel,
Received Or Paid,Přijaté nebo placenl,
"Select ""Yes"" if this item is used for some internal purpose in your company.","Zvolte ""Ano"", pokud tato položka se používá pro některé interní účely ve vaší firmě."
Difference Account,Rozdíl účtu,
Please enter Warehouse for which Material Request will be raised,"Prosím, zadejte sklad, který bude materiál žádosti předložené"
Additional Operating Cost,Další provozní náklady,
Cosmetics,Kosmetika,
Type,Typ,
"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
Email ids separated by commas.,E-mailové ID oddělené čárkami.
Subject,Předmět,
"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Zvolte ""Ano"", pokud je tato položka představuje nějakou práci, jako je vzdělávání, projektování, konzultace atd."
Net Weight,Hmotnost,
Emergency Phone,Nouzový telefon,
Google Drive Access Allowed,Google Drive Přístup povolen,
Serial No Warranty Expiry,Pořadové č záruční lhůty,
Do you really want to STOP this Material Request?,Opravdu chcete zastavit tento materiál požadavek?
Item,Položka,
Difference (Dr - Cr),Rozdíl (Dr - Cr)
Profit and Loss,Zisky a ztráty,
Upcoming Calendar Events (max 10),Nadcházející Události v kalendáři (max 10)
New UOM must NOT be of type Whole Number,New UOM NESMÍ být typu celé číslo,
Furniture and Fixture,Nábytek,
Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou Ceník měna je převedena na společnosti základní měny"
Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
Default Customer Group,Výchozí Customer Group,
"If disable, 'Rounded Total' field will not be visible in any transaction","Je-li zakázat, ""zaokrouhlí celková"" pole nebude viditelný v jakékoli transakce"
Operating Cost,Provozní náklady,
Gross Profit,Hrubý Zisk,
Material Requirement,Materiál Požadavek,
Delete Company Transactions,Smazat transakcí Company,
Item {0} is not Purchase Item,Položka {0} není Nákup položky,
"{0} is an invalid email address in 'Notification \
					Email Address'","{0} je neplatná e-mailová adresa v ""Oznámení \
 E-mailová adresa"""
Total Billing This Year:,Celkem Billing Tento rok:
Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatk$1,
Supplier Invoice No,Dodavatelské faktury $1,
For reference,Pro srovnán$1,
Closing (Cr),Uzavření (Cr)
Warranty Period (Days),Záruční doba (dny)
Installation Note Item,Poznámka k instalaci bod,
Thread HTML,Thread HTML,
Ignore,Ignorovat,
Enter Verification Code,Zadejte ověřovací kód,
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupend,
Valid From,Platnost od,
Total Commission,Celkem Komise,
Sales Partner,Sales Partner,
Purchase Receipt Required,Příjmka je vyžadována,
"**Monthly Distribution** helps you distribute your budget across months if you have seasonality in your business.

To distribute a budget using this distribution, set this **Monthly Distribution** in the **Cost Center**","** Měsíční rozložení** vám pomůže váš rozpočet distribuovat do více měsíců, pokud Vaše podnikání ovlivňuje sezónnost.

 Chcete-li distribuovat rozpočet pomocí tohoto rozdělení, nastavte toto ** měsíční rozložení ** v ** nákladovém středisku **"
No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy,
Please select Company and Party Type first,Vyberte první společnost a Party Typ,
Financial / accounting year.,Finanční / Účetní rok.
"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
New Supplier Quotations,Nového dodavatele Citace,
Make Sales Order,Ujistěte se prodejní objednávky,
Project Task,Úkol Project,
Lead Id,Olovo Id,
Grand Total,Celkem,
Website Manager,Správce webu,
Fiscal Year Start Date should not be greater than Fiscal Year End Date,Datum zahájení Fiskálního roku by nemělo být větší než datum ukončene,
Resolution,Řešene,
Display all the individual items delivered with the main items,Zobrazit všechny jednotlivé položky dodané s hlavními položkami,
Payable Account,Splatnost účtu,
Repeat Customers,Opakujte zákazníci,
Sync with Google Drive,Synchronizace s Google Disku,
Allocate,Přidělit,
Previous,Předchoze,
Sales Return,Sales Return,
Select Sales Orders from which you want to create Production Orders.,"Vyberte prodejní objednávky, ze kterého chcete vytvořit výrobní zakázky."
Salary components.,Mzdové složky.
Database of potential customers.,Databáze potenciálních zákazníků.
Customer database.,Databáze zákazníků.
Quotation To,Nabídka k,
Middle Income,Středními příjmy,
Opening (Cr),Otvor (Cr)
Allocated amount can not be negative,Přidělená částka nemůže být záporng,
Tumbling,Tumbling,
Billed Amt,Účtovaného Amt,
A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny."
Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
Wednesday,Středa,
Customer's Vendor,Prodejce zákazníka,
Production Order is Mandatory,Výrobní zakázka je povinna,
{0} {1} has a common territory {2},{0} {1} má společný území {2}
Proposal Writing,Návrh Psans,
Masters,Masters,
Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativní Sklad Error ({6}) k bodu {0} ve skladu {1} na {2} {3} v {4} {5}
Fiscal Year Company,Fiskální rok Společnosti,
DN Detail,DN Detail,
Billed,Fakturováno,
Batch Description,Popis Šarže,
Time at which items were delivered from warehouse,"Čas, kdy byly předměty dodány od skladu"
Sales Taxes and Charges,Prodej Daně a poplatky,
Organization Profile,Profil organizace,
Please setup numbering series for Attendance via Setup > Numbering Series,"Prosím, nastavení číslování série pro Účast přes Nastavení> Série číslování"
New Enquiries,Nové Dotazy,
Reason for Resignation,Důvod rezignace,
Template for performance appraisals.,Šablona pro hodnocení výkonu.
Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti,
{0} '{1}' not in Fiscal Year {2},{0} '{1}' není v fiskálním roce {2}
Settings for Buying Module,Nastavení pro nákup modul,
Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení"
Supplier Naming By,Dodavatel Pojmenování By,
Maintenance Schedule,Plán údržby,
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Pak se pravidla pro tvorbu cen jsou odfiltrovány založeny na zákazníka, skupiny zákazníků, území, dodavatel, dodavatel typ, kampaň, obchodní partner atd"
Please install dropbox python module,"Prosím, nainstalujte dropbox python modul"
Passport Number,Číslo pasu,
Manager,Manažer,
From Purchase Receipt,Z příjemky,
Same item has been entered multiple times.,Stejný bod byl zadán vícekrát.
Receiver Parameter,Přijímač parametr$1,
'Based On' and 'Group By' can not be same,"""Založeno Na"" a ""Seskupeno Podle"", nemůže být stejné"
Sales Person Targets,Obchodník cíle,
To,na,
Please enter email address,Zadejte e-mailovou adresu,
End tube forming,Konec trubice tvoříce,
In minutes,V minutách,
Resolution Date,Rozlišení Datum,
Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
Customer Naming By,Zákazník Pojmenování By,
Convert to Group,Převést do skupiny,
Activity Type,Druh činnosti,
Delivered Amount,Dodává Částka,
Packing List,Balení Seznam,
Purchase Orders given to Suppliers.,Nákupní Objednávky odeslané Dodavatelům.
Publishing,Publikováne,
Projects User,Projekty uživatele,
Consumed,Spotřeba,
{0}: {1} not found in Invoice Details table,{0}: {1} nebyla nalezena v tabulce Podrobnosti Faktury,
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Navštivte {0} musí být zrušena před zrušením této prodejní objednávky,
Material Transfer,Přesun materiálu,
Opening (Dr),Opening (Dr)
Posting timestamp must be after {0},Časová značka zadání musí být po {0}
Settings,Nastaveny,
Landed Cost Taxes and Charges,Přistál nákladů daně a poplatky,
Actual Start Time,Skutečný čas začátku,
Operation Time,Provozní doba,
More,Více,
Sales Manager,Manažer prodeje,
Rename,Přejmenovat,
Write Off Amount,Odepsat Částka,
Bending,Ohýbány,
Allow User,Umožňuje uživateli,
Bill No,Bill No,
Quarterly,Čtvrtletny,
Delivery Note Required,Delivery Note Povinny,
Basic Rate (Company Currency),Basic Rate (Company měny)
Please enter item details,"Prosím, zadejte podrobnosti položky"
Other Details,Další podrobnosti,
Accounts,Účty,
Marketing,Marketing,
Straight shearing,Straight stříháni,
To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Chcete-li sledovat položky v oblasti prodeje a nákupu dokumentů na základě jejich sériových čísel. To je možné také použít ke sledování detailů produktu záruční.
Current Stock,Current skladem,
Rejected Warehouse is mandatory against regected item,Zamítnuto Warehouse je povinná proti regected položky,
Expenses Included In Valuation,Náklady ceně oceňovánm,
Provide email id registered in company,Poskytnout e-mail id zapsané ve firmm,
Seller City,Prodejce City,
Next email will be sent on:,Další e-mail bude odeslán dne:
Offer Letter Term,Nabídka Letter Term,
Item {0} not found,Položka {0} nebyl nalezen,
Stock Value,Reklamní Value,
Tree Type,Tree Type,
Qty Consumed Per Unit,Množství spotřebované na jednotku,
Warranty Expiry Date,Záruka Datum vypršení platnosti,
Quantity and Warehouse,Množství a sklad,
Commission Rate (%),Výše provize (%)
"Against Voucher Type must be one of Sales Order, Sales Invoice or Journal Entry","Proti poukazu Type musí být jedním z prodejní objednávky, prodejní faktury nebo Journal Entry"
Biomachining,Biomachining,
Aerospace,Aerospace,
Welcome,Vítejte,
Credit Card Entry,Vstup Kreditní karta,
Task Subject,Úkol Předmět,
Goods received from Suppliers.,Zboží od dodavatelů.
Open,Otevřít,
Campaign Name,Název kampant,
Please enter Delivery Note No or Sales Invoice No to proceed,"Prosím, zadejte dodacího listu nebo prodejní faktury č pokračovat"
Reserved,Rezervováno,
Do you really want to UNSTOP,"Opravdu chcete, aby uvolnit"
Supply Raw Materials,Dodávek surovin,
The date on which next invoice will be generated. It is generated on submit.,"Datum, kdy bude vygenerován příští faktury. To je generován na odeslat."
Current Assets,Oběžná aktiva,
{0} is not a stock Item,{0} není skladová položka,
Default Account,Výchozí účet,
Lead must be set if Opportunity is made from Lead,Vedoucí musí být nastavena pokud Opportunity je vyrobena z olova,
Address Title,Označení adresy,
Please select weekly off day,"Prosím, vyberte týdenní off den"
Planned End Time,Plánované End Time,
Sales Person Target Variance Item Group-Wise,Prodej Osoba Cílová Odchylka Item Group-Wise,
Daily,Denne,
Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu,
Customer's Purchase Order No,Zákazníka Objednávka No,
Cell Number,Číslo buňky,
Lost,Ztracene,
You can not enter current voucher in 'Against Journal Entry' column,"Nelze zadat aktuální poukaz v ""Proti Zápis do deníku"" sloupci"
Energy,Energie,
Opportunity From,Příležitost Z,
Monthly salary statement.,Měsíční plat prohlášení.
"Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. \
						Pending Amount is {2}","Řádek č {0}: Částka nesmí být větší než Až do částky proti Expense nároku {1}. \
 Až Částka je {2}"
Website Specifications,Webových stránek Specifikace,
New Account,Nový účet,
{0}: From {0} of type {1},{0}: Od {0} typu {1}
Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinno,
Please write something,Napište něco,
Accounting Entries can be made against leaf nodes. Entries against Groups are not allowed.,Účetní Přihlášky lze proti koncové uzly. Záznamy proti skupinám nejsou povoleny.
High,Vysok$1,
Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nelze deaktivovat nebo zrušit BOM, jak to souvisí s ostatními kusovníky"
Maintenance,Údržba,
Male,Mua,
Purchase Receipt number required for Item {0},Číslo příjmky je potřeba pro položku {0}
Item Attribute Value,Položka Hodnota atributu,
Sales campaigns.,Prodej kampaně.
"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.","Standardní daň šablona, ​​která může být použita pro všechny prodejních transakcí. Tato šablona může obsahovat seznam daňových hlav a také další náklady / příjmy hlavy jako ""doprava"", ""pojištění"", ""manipulace"" atd. 

 #### Poznámka: 

 daňovou sazbu, vy definovat zde bude základní sazba daně pro všechny ** položky **. Pokud jsou položky ** **, které mají různé ceny, musí být přidány v ** Položka daních ** stůl v ** položky ** mistra.

 #### Popis sloupců 

 1. Výpočet Type: 
 - To může být na ** Čistý Total ** (což je součet základní částky).
 - ** Na předchozí řady Total / Částka ** (pro kumulativní daní a poplatků). Zvolíte-li tuto možnost, bude daň se použije jako procento z předchozí řady (v daňové tabulky) množství nebo celkem.
 - ** Aktuální ** (jak je uvedeno).
 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat 
 3. Nákladové středisko: V případě, že daň / poplatek je příjmem (jako poštovné) nebo nákladů je třeba rezervovat na nákladové středisko.
 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).
 5. Rate: Sazba daně.
 6. Částka: Částka daně.
 7. Celkem: Kumulativní celková k tomuto bodu.
 8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).
 9. Je to poplatek v ceně do základní sazby ?: Pokud se to ověřit, znamená to, že tato daň nebude zobrazen pod tabulkou položky, ale budou zahrnuty do základní sazby v hlavním položce tabulky. To je užitečné, pokud chcete dát paušální cenu (včetně všech poplatků), ceny pro zákazníky."
Purchase Returned,Nákup Vráceno,
Bank A/C No.,"Č, bank. účtu"
Scheduler Failed Events,Plánovač Nepodařilo Events,
Project,Projekt,
Reading 7,Čtení 7,
Personal,Osobns,
Expense Claim Type,Náklady na pojistná Type,
Default settings for Shopping Cart,Výchozí nastavení Košík,
"Journal Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Zápis do deníku {0} je spojen proti řádu {1}, zkontrolujte, zda by měl být tažen za pokrok v této faktuře."
Biotechnology,Biotechnologie,
Office Maintenance Expenses,Náklady Office údržby,
Hemming,Hemming,
Please enter Item first,"Prosím, nejdřív zadejte položku"
Liability,Odpovědnost,
Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionována Částka nemůže být větší než reklamace Částka v řádku {0}.
Default Cost of Goods Sold Account,Výchozí Náklady na prodané zboží účtu,
Price List not selected,Ceník není zvolen,
Family Background,Rodinné poměry,
Send Email,Odeslat email,
No Permission,Nemáte oprávněnu,
Default Bank Account,Výchozí Bankovní účet,
"To filter based on Party, select Party Type first","Chcete-li filtrovat na základě Party, vyberte typ Party první"
Nos,Nos,
Bank Reconciliation Detail,Bank Odsouhlasení Detail,
My Invoices,Moje Faktury,
No employee found,Žádný zaměstnanec nalezeno,
Stopped,Zastaveno,
All Customer Contact,Vše Kontakt Zákazník,
Upload stock balance via csv.,Nahrát nutnosti rovnováhy prostřednictvím CSV.
Send Now,Odeslat nyns,
Support Analytics,Podpora Analytics,
Website Warehouse,Sklad pro web,
"The day of the month on which auto invoice will be generated e.g. 05, 28 etc","Den měsíce, ve kterém auto faktura bude generován například 05, 28 atd"
Score must be less than or equal to 5,Skóre musí být menší než nebo rovna 5,
C-Form records,C-Form záznamy,
Email Digest Settings,Nastavení e-mailu Digest,
Support queries from customers.,Podpora dotazy ze strany zákazníků.
Moving Average Rate,Klouzavý průměr,
Select Items,Vyberte položky,
{0} against Bill {1} dated {2},{0} proti účtu {1} ze dne {2}
Reference Name,Název reference,
Completion Status,Dokončení Status,
"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No","Chcete-li sledovat značku v těchto dokumentech dodacího listu Opportunity, materiál Request, bod, objednávky, nákup poukazu, nakupují stvrzenka, cenovou nabídku, prodejní faktury, Sales BOM, prodejní objednávky, pořadové číslo"
Target Warehouse,Target Warehouse,
Expected Delivery Date cannot be before Sales Order Date,"Očekávané datum dodání, nemůže být před Sales pořadí Datum"
Import Attendance,Importovat Docházku,
All Item Groups,Všechny skupiny položek,
Activity Log,Aktivita Log,
Net Profit / Loss,Čistý zisk / ztráta,
Automatically compose message on submission of transactions.,Automaticky napsat vzkaz na předkládání transakcí.
Item To Manufacture,Bod K výrobm,
Permanent mold casting,Trvalé odlévání forem,
Projected Qty,Předpokládané množstvm,
Payment Due Date,Splatno dne,
Newsletter Manager,Newsletter Manažer,
Delivery Note Message,Delivery Note Message,
Expenses,Výdaje,
Purchase Receipt Trends,Doklad o koupi Trendy,
Select template from which you want to get the Goals,"Vyberte šablonu, ze kterého chcete získat cílů"
Research & Development,Výzkum a vývoj,
Amount to Bill,Částka k Fakturaci,
Registration Details,Registrace Podrobnosti,
Staking,Sázet,
Re-Order Qty,Re-Order Množstvj,
Leave Block List Date,Nechte Block List Datum,
Scheduled to send to {0},Plánované poslat na {0}
Price or Discount,Cena nebo Sleva,
Incentives,Pobídky,
Performance appraisal.,Hodnocení výkonu.
Project Value,Hodnota projektu,
Make Maint. Visit,Proveďte údržba. Návštěva,
Cannot carry forward {0},Nelze převést {0}
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
Balance must be,Zůstatek musí být,
Publish Pricing,Publikovat Ceník,
New Purchase Receipts,Nové Nákup Příjmy,
Expense Claim Rejected Message,Zpráva o zamítnutí úhrady výdajt,
Nailing,Báječnt,
Available Qty,Množství k dispozici,
On Previous Row Total,Na předchozí řady Celkem,
Working Days,Pracovní dny,
Incoming Rate,Příchozí Rate,
Gross Weight,Hrubá hmotnost,
The name of your company for which you are setting up this system.,"Název vaší společnosti, pro kterou nastavení tohoto systému."
Include holidays in Total no. of Working Days,Zahrnout dovolenou v celkovém. pracovních dnt,
Hold,Držet,
Date of Joining,Datum přistoupent,
Update Series,Řada Aktualizace,
Is Subcontracted,Subdodavatelům,
Item Attribute Values,Položka Hodnoty atributt,
View Subscribers,Zobrazit Odběratelt,
Purchase Receipt,Příjemka,
Received Items To Be Billed,"Přijaté položek, které mají být účtovány"
Abrasive blasting,Abrazivní tryskán$1,
Ms,Pan$1,
Currency exchange rate master.,Devizový kurz master.
Unable to find Time Slot in the next {0} days for Operation {1},Nelze najít časový úsek v příštích {0} dní k provozu {1}
Plan material for sub-assemblies,Plán materiál pro podsestavy,
BOM {0} must be active,BOM {0} musí být aktivny,
Set Status as Available,Nastavit stav as k dispozici,
Please select the document type first,Vyberte první typ dokumentu,
Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit Materiál Návštěvy {0} před zrušením tohoto návštěv údržby,
Leave Encashment Amount,Nechte inkasa Částka,
Serial No {0} does not belong to Item {1},Pořadové číslo {0} nepatří k bodu {1}
Make new POS Setting,Proveďte nové nastavení POS,
Required Qty,Požadované množstvS,
Total Amount,Celková částka,
Internet Publishing,Internet Publishing,
Production Orders,Výrobní Objednávky,
Balance Value,Zůstatek Hodnota,
Sales Price List,Sales Ceník,
Publish to sync items,Publikování synchronizovat položky,
Range,Rozsah,
Default Payable Accounts,Výchozí úplatu účty,
Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje,
Item Barcode,Položka Barcode,
Item Variants {0} updated,Bod Varianty {0} aktualizováno,
Reading 6,Čtení 6,
Purchase Invoice Advance,Záloha přijaté faktury,
Shop,Obchod,
Sync Now,Sync teS,
Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Výchozí účet Bank / Cash budou automaticky aktualizovány v POS faktury, pokud je zvolen tento režim."
Permanent Address Is,Trvalé bydliště je,
Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?
The Brand,Brand,
Allowance for over-{0} crossed for Item {1}.,Příspěvek na nadměrné {0} přešel k bodu {1}.
Exit Interview Details,Exit Rozhovor Podrobnosti,
Is Purchase Item,je Nákupní Položka,
Purchase Invoice,Přijatá faktura,
Voucher Detail No,Voucher Detail No,
Total Outgoing Value,Celková hodnota Odchozi,
Request for Information,Žádost o informace,
Paid,Placeni,
Total in words,Celkem slovy,
Lead Time Date,Lead Time data,
Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
Shipments to customers.,Zásilky zákazníkům.
Purchase Order Item,Položka vydané objednávky,
Indirect Income,Nepřímé příjmy,
Address Line 1,Adresní řádek 1,
Variance,Odchylka,
Company Name,Název společnosti,
Total Message(s),Celkem zpráv (y)
Select Item for Transfer,Vybrat položku pro převod,
Select account head of the bank where cheque was deposited.,"Vyberte účet šéf banky, kde byla uložena kontrola."
Allow user to edit Price List Rate in transactions,Povolit uživateli upravovat Ceník Cena při transakcích,
Max Qty,Max Množstvh,
Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Platba na prodejní / nákupní objednávce by měly být vždy označeny jako předem,
Chemical,Chemickh,
All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
Select Payroll Year and Month,Vyberte Payroll rok a měsíc,
"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account (by clicking on Add Child) of type ""Bank""",Přejděte na příslušné skupiny (obvykle využití finančních prostředků&gt; oběžných aktiv&gt; bankovních účtů a vytvořit nový účet (kliknutím na Přidat dítě) typu &quot;Bank&quot;
Electricity Cost,Cena elektřiny,
Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin,
Unsubscribed,Odhlášen z odběru,
Walk In,Vejít,
Inspection Criteria,Inspekční Kritéria,
Tree of finanial Cost Centers.,Strom finanial nákladových středisek.
Upload your letter head and logo. (you can edit them later).,Nahrajte svůj dopis hlavu a logo. (Můžete je upravit později).
White,Bíl$1,
All Lead (Open),Všechny Lead (Otevřeny)
Get Advances Paid,Získejte zaplacené zálohy,
Attach Your Picture,Připojit svůj obrázek,
Total Amount in Words,Celková částka slovy,
Stop,Stop,
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.,"Došlo k chybě. Jedním z důvodů by mohlo být pravděpodobné, že jste uložili formulář. Obraťte se prosím na support@erpnext.com Pokud problém přetrvává."
% of materials billed against this Purchase Order.,% Materiálů fakturovaných proti této objednávce.
Order Type must be one of {0},Typ objednávky musí být jedním z {0}
Next Contact Date,Další Kontakt Datum,
Opening Qty,Otevření POČET,
Holiday List Name,Jméno Holiday Seznam,
Stock Options,Akciové opce,
Expense Claim,Hrazení nákladm,
Qty for {0},Množství pro {0}
Leave Application,Leave Application,
Leave Allocation Tool,Nechte přidělení nástroj,
Leave Block List Dates,Nechte Block List termíny,
Buying & Selling,Nákup a prodej,
Trimming,Ořezávánn,
Net Hour Rate,Net Hour Rate,
Landed Cost Purchase Receipt,Přistál Náklady doklad o koupi,
Packing Slip Item,Balení Slip Item,
Cash/Bank Account,Hotovostní / Bankovní účet,
Removed items with no change in quantity or value.,Odstraněné položky bez změny množství nebo hodnoty.
Delivery To,Doručení do,
Get Sales Orders,Získat Prodejní objednávky,
{0} can not be negative,{0} nemůže být negativno,
"Row {0}: Party / Account does not match with \
							Customer / Debit To in {1}","Row {0}: Party / Account neodpovídá \
 Customer / debetní v {1}"
Filing,Podána,
Discount,Sleva,
Purchase Discounts,Nákup Slevy,
This will override Difference Account in Item,To přepíše Difference účet v položce,
Wages,Mzdy,
Will be updated only if Time Log is 'Billable',"Bude aktualizována pouze v případě, Time Log je &quot;Zúčtovatelná&quot;"
Internal,Intern$1,
Urgent,Naléhav$1,
Please specify a valid Row ID for row {0} in table {1},Zadejte prosím platný řádek ID řádku tabulky {0} {1}
This Time Log conflicts with {0} for {1},To je v rozporu Time Log s {0} na {1}
"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

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

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

Note: BOM = Bill of Materials","Souhrnný skupina ** položek ** do jiné položky ** **. To je užitečné, pokud svazování některé položky ** ** do balíčku a budete udržovat zásoby balených ** položky ** a ne součet ** položky **. 

 Balíček ** položky ** bude mít ""je skladem"" jako ""No"" a ""Je Sales Item"" jako ""Yes"".

 Například: Pokud prodáváte notebooky a batohy odděleně a mají speciální cenu, pokud zákazník koupí oba, pak Laptop + Backpack bude nový Sales BOM položky.

 Poznámka: BOM = Bill of Materials"
Manufacturer,Výrobce,
Purchase Receipt Item,Položka příjemky,
PO Date,PO Datum,
Sales Returned,Sales Vrácene,
Reserved Warehouse in Sales Order / Finished Goods Warehouse,Vyhrazeno Warehouse v prodejní objednávky / hotových výrobků Warehouse,
Selling Amount,Prodejní Částka,
Time Logs,Čas Záznamy,
You are the Expense Approver for this record. Please Update the 'Status' and Save,"Jste Expense schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
Creation Document No,Tvorba dokument m,
Issue,Problém,
"Attributes for Item Variants. e.g Size, Color etc.","Atributy pro položky varianty. například velikost, barva atd."
WIP Warehouse,WIP Warehouse,
Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1}
Operation,Operace,
Organization Name,Název organizace,
POS Setting required to make POS Entry,"POS Nastavení požadováno, aby POS položky"
Item must be added using 'Get Items from Purchase Receipts' button,"Položka musí být přidány pomocí ""získat předměty z kupní příjmy"" tlačítkem"
Sales Expenses,Prodejní náklady,
Standard Buying,Standardní Nakupovány,
Against,Proti,
Default Selling Cost Center,Výchozí Center Prodejní cena,
Implementation Partner,Implementačního partnera,
Contact Info,Kontaktní informace,
Net Weight UOM,Hmotnost UOM,
Make Purchase Receipt,Proveďte doklad o koupi,
Default Supplier,Výchozí Dodavatel,
Shipping Rule Condition,Přepravní Pravidlo Podmínka,
Miscelleneous,Miscelleneous,
Get Weekly Off Dates,Získejte týdenní Off termíny,
End Date can not be less than Start Date,Datum ukončení nesmí být menší než data zahájeny,
Select company name first.,Vyberte název společnosti jako první.
Sales BOM Item,Sales BOM Item,
Dr,Dr,
"Item must be a purchase item, as it is present in one or many Active BOMs","Položka musí být nákup bod, protože je přítomna v jedné nebo mnoha Active kusovníky"
Quotations received from Suppliers.,Nabídka obdržená od Dodavatelů.
Against Purchase Invoice,Proti nákupní faktuře,
To {0} | {1} {2},Chcete-li {0} | {1} {2}
updated via Time Logs,aktualizovat přes čas Záznamy,
Average Age,Průměrný věk,
Go ahead and add something to your cart.,Nyní můžete přidat položky do Vašeho košíku.
Your sales person who will contact the customer in future,"Váš obchodní zástupce, který bude kontaktovat zákazníka v budoucnu"
List a few of your suppliers. They could be organizations or individuals.,Seznam několik svých dodavatelů. Ty by mohly být organizace nebo jednotlivci.
Default Currency,Výchozí měna,
Enter designation of this Contact,Zadejte označení této Kontakt,
Address,Adresa,
From Employee,Od Zaměstnance,
{0} {1} not in any Fiscal Year. For more details check {2}.,{0} {1} v žádném fiskálním roce. Pro více informací klikněte {2}.
Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
Make Difference Entry,Učinit vstup Rozdíl,
Attendance From Date,Účast Datum od,
Key Performance Area,Key Performance Area,
Transportation,Doprava,
{0} {1} must be submitted,{0} {1} musí být odeslanl,
Total Characters,Celkový počet znakl,
Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
C-Form Invoice Detail,C-Form Faktura Detail,
Payment Reconciliation Invoice,Platba Odsouhlasení faktury,
Contribution %,Příspěvek%
website page link,webové stránky odkaz na stránku,
Let's prepare the system for first use.,Pojďme připravit systém pro první použití.
Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd,
Distributor,Distributor,
Shopping Cart Shipping Rule,Nákupní košík Shipping Rule,
Production Order {0} must be cancelled before cancelling this Sales Order,Výrobní zakázka {0} musí být zrušena před zrušením této prodejní objednávky,
Budget cannot be set for Group Cost Centers,Rozpočet není možno nastavit pro středisek Skupina nákladovd,
Ordered Items To Be Billed,Objednané zboží fakturovaných,
Select Time Logs and Submit to create a new Sales Invoice.,Vyberte Time protokolů a předložit k vytvoření nové prodejní faktury.
Global Defaults,Globální Výchozy,
Deductions,Odpočty,
Start date of current invoice's period,Datum období současného faktury je Začátek,
This Time Log Batch has been billed.,To Batch Time Log bylo účtováno.
Create Opportunity,Vytvořit příležitost,
Leave Without Pay,Nechat bez nároku na mzdu,
Communications,Komunikace,
Capacity Planning Error,Plánování kapacit Chyba,
Consultant,Konzultant,
Earnings,Výdělek,
Sales Invoice Advance,Prodejní faktury Advance,
Nothing to request,Nic požadovat,
'Actual Start Date' can not be greater than 'Actual End Date',"""Skutečné datum zahájení"" nemůže být větší než ""Aktuální datum ukončení"""
Management,Řízeny,
Types of activities for Time Sheets,Typy činností pro Time listy,
Investment casting,Investiční lity,
Either debit or credit amount is required for {0},Buď debetní nebo kreditní částka je vyžadována pro {0}
"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""","To bude připojen na položku zákoníku varianty. Například, pokud vaše zkratka je ""SM"", a položka je kód ""T-SHIRT"", položka kód varianty bude ""T-SHIRT-SM"""
Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá Pay (slovy) budou viditelné, jakmile uložíte výplatní pásce."
Active,Aktivn$1,
Blue,Modr$1,
Further nodes can be only created under 'Group' type nodes,"Další uzly mohou být pouze vytvořena v uzlech typu ""skupiny"""
UOMs,UOMs,
{0} valid serial nos for Item {1},{0} platí pořadová čísla pro položky {1}
Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.
UOM Conversion Factor,UOM Conversion Factor,
Default Item Group,Výchozí bod Group,
Laminated object manufacturing,Vrstvené objektu výrobnr,
Supplier database.,Databáze dodavatelů.
Balance Sheet,Rozvaha,
Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
Stretch forming,Stretch tvářen$1,
Your sales person will get a reminder on this date to contact the customer,"Váš obchodní zástupce dostane upomínku na tento den, aby kontaktoval zákazníka"
"Further accounts can be made under Groups, but entries can be made against non-Groups","Další účty mohou být vyrobeny v rámci skupiny, ale údaje lze proti non-skupin"
Tax and other salary deductions.,Daňové a jiné platové srážky.
Lead,Olovo,
Payables,Závazky,
Warehouse,Sklad,
Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci,
Net Rate,Čistá míra,
Database Folder ID,číslo databázového adresára,
Purchase Invoice Item,Položka přijaté faktury,
Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Sériové Ledger Přihlášky a GL položky jsou zveřejňována pro vybrané Nákupní Příjmy,
Holiday,Dovoleno,
Saturday,Sobota,
Leave blank if considered for all branches,"Ponechte prázdné, pokud se to považuje za všechny obory"
Daily Time Log Summary,Denní doba prihlásenia - súhrn,
Label,Popisek,
Unreconciled Payment Details,Smířit platbn,
Current Fiscal Year,Aktuální fiskální rok,
Disable Rounded Total,Zakázat Zaoblený Celkem,
Call,Volánn,
'Entries' cannot be empty,"""Položky"" nemůžou být prázdné"
Duplicate row {0} with same {1},Duplicitní řádek {0} se stejným {1}
Trial Balance,Trial Balance,
"Grid ""","Grid """
Please select prefix first,"Prosím, vyberte první prefix"
Research,Výzkum,
Work Done,Odvedenou práci,
User ID,User ID,
Sent,Odesláno,
View Ledger,View Ledger,
Lft,LFT,
Earliest,Nejstaršm,
"An Item Group exists with same name, please change the item name or rename the item group","Položka Group existuje se stejným názvem, prosím, změnit název položky nebo přejmenovat skupinu položek"
Delivery Status,Delivery Status,
Manufacture against Sales Order,Výroba na odběratele,
Rest Of The World,Zbytek světa,
The Item {0} cannot have Batch,Položka {0} nemůže mít dávku,
Budget Variance Report,Rozpočet Odchylka Report,
Gross Pay,Hrubé mzdy,
Dividends Paid,Dividendy placens,
Difference Amount,Rozdíl Částka,
Retained Earnings,Nerozdělený zisk,
Required raw materials issued to the supplier for producing a sub - contracted item.,Potřebné suroviny vydaných dodavateli pro výrobu sub - smluvně položka.
Item Description,Položka Popis,
Payment Mode,Způsob platby,
Is Recurring,Je Opakujícs,
Direct metal laser sintering,Přímý plechu laserem spékáns,
Supplied Items,Dodávané položky,
Qty To Manufacture,Množství K výrobs,
Maintain same rate throughout purchase cycle,Udržovat stejnou sazbu po celou kupní cyklu,
Opportunity Item,Položka Příležitosti,
Temporary Opening,Dočasné Otevřens,
Cryorolling,Cryorolling,
Employee Leave Balance,Zaměstnanec Leave Balance,
Balance for Account {0} must always be {1},Zůstatek na účtě {0} musí být vždy {1}
More Info,Více informacy,
Address Type,Typ adresy,
Rejected Warehouse,Zamítnuto Warehouse,
Against Voucher,Proti poukazu,
Default Buying Cost Center,Výchozí Center Nákup Cost,
Item {0} must be Sales Item,Položka {0} musí být Sales Item,
Accounts Payable Summary,Splatné účty Shrnuty,
Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0}
Get Outstanding Invoices,Získat neuhrazených faktur,
Sales Order {0} is not valid,Prodejní objednávky {0} není platnr,
New Stock Entries,Nových akcií Příspěvky,
"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
Small,Mal$1,
Employee Number,Počet zaměstnanc$1,
Case No(s) already in use. Try from Case No {0},Případ číslo (čísla) již v provozu. Zkuste se věc č {0}
% Completed,% Dokončeno,
Invoiced Amount (Exculsive Tax),Fakturovaná částka (bez daně)
Account head {0} created,Hlava účtu {0} vytvořil,
Green,Zelenl,
Discount(%),Sleva (%)
Total Achieved,Celkem Dosažena,
Place of Issue,Místo vydána,
Contract,Smlouva,
Disabled,Vypnuto,
UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor potřebný k nerozpuštěných: {0} v bodě: {1}
Indirect Expenses,Nepřímé náklady,
Row {0}: Qty is mandatory,Row {0}: Množství je povinny,
Agriculture,Zemědělstvy,
Your Products or Services,Vaše Produkty nebo Služby,
Mode of Payment,Způsob platby,
This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
Purchase Order,Vydaná objednávka,
Warehouse Contact Info,Sklad Kontaktní informace,
Name is required,Jméno je vyžadováno,
Recurring Type,Opakující se Typ,
City/Town,Město / Město,
Serial No Details,Serial No Podrobnosti,
Item Tax Rate,Sazba daně položky,
"For {0}, only credit accounts can be linked against another debit entry","Pro {0}, tak úvěrové účty mohou být propojeny na jinou položku debetní"
Delivery Note {0} is not submitted,Delivery Note {0} není předložena,
Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item,
Capital Equipments,Kapitálové Vybavena,
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
Seller Website,Prodejce Website,
Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100,
Production Order status is {0},Stav výrobní zakázka je {0}
Goal,Cíl,
For Supplier,Pro Dodavatele,
Setting Account Type helps in selecting this Account in transactions.,Nastavení typu účtu pomáhá při výběru tohoto účtu v transakcích.
Grand Total (Company Currency),Celkový součet (Měna společnosti)
Total Outgoing,Celkem Odchoz$1,
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Tam může být pouze jeden Shipping Rule Podmínka s 0 nebo prázdnou hodnotu pro ""na hodnotu"""
Transaction,Transakce,
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Tento Nákladové středisko je Group. Nelze vytvořit účetní zápisy proti skupinám.
Tools,Nástroje,
Valid For Territories,Platí pro územe,
Website Item Groups,Webové stránky skupiny položek,
Production order number is mandatory for stock entry purpose manufacture,Výrobní číslo objednávky je povinná pro legální vstup účelem výroby,
Total (Company Currency),Total (Company měny)
Applicable Territory,Použitelné Oblasti,
Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou,
Journal Entry,Zápis do deníku,
Workstation Name,Meno pracovnej stanice,
Email Digest:,E-mail Digest:
BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1}
Target Distribution,Target Distribution,
Comments,Komentáře,
Bank Account No.,Bankovní účet č.
This is the number of the last created transaction with this prefix,To je číslo poslední vytvořené transakci s tímto prefixem,
Valuation Rate required for Item {0},Ocenění Rate potřebný k bodu {0}
Reading 8,Čtení 8,
Agent,Agent,
"Total {0} for all items is zero, may you should change 'Distribute Charges Based On'","Celkem {0} pro všechny položky je nula, můžete měli změnit &quot;Distribuovat poplatků na základě&quot;"
Taxes and Charges Calculation,Daně a poplatky výpočet,
Workstation,pracovna stanica,
Hardware,Technické vybavent,
HR Manager,HR Manager,
Privilege Leave,Privilege Leave,
Supplier Invoice Date,Dodavatelské faktury Datum,
You need to enable Shopping Cart,Musíte povolit Nákupní košík,
No Data,No Data,
Appraisal Template Goal,Posouzení Template Goal,
Earning,Získávánt,
Add or Deduct,Přidat nebo Odečíst,
Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:
Against Journal Entry {0} is already adjusted against some other voucher,Proti věstníku Entry {0} je již nastavena proti jiným poukaz,
Files Folder ID,ID složeky souborz,
Total Order Value,Celková hodnota objednávky,
Item Variants {0} deleted,Bod Varianty {0} vypouštz,
Food,Jídlo,
Ageing Range 3,Stárnutí Rozsah 3,
You can make a time log only against a submitted production order,Můžete udělat časový záznam pouze proti předložené výrobní objednávce,
No of Visits,Počet návštěv,
old_parent,old_parent,
"Newsletters to contacts, leads.","Zpravodaje ke kontaktům, vede."
Sum of points for all goals should be 100. It is {0},Součet bodů za všech cílů by mělo být 100. Je {0}
Operations cannot be left blank.,Operace nemůže být prázdné.
Delivered Items To Be Billed,Dodávaných výrobků fakturovaných,
Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.
Status updated to {0},Status aktualizován na {0}
Description,Popis,
Average Discount,Průměrná sleva,
Backup Manager,Správce zálohováns,
Is Default,Je Výchozs,
Utilities,Utilities,
Accounting,Účetnictvs,
Features Setup,Nastavení Funkcs,
View Offer Letter,View Nabídka Dopis,
Sales BOM,Sales BOM,
Communication,Komunikace,
Is Service Item,Je Service Item,
Projects,Projekty,
Please select Fiscal Year,"Prosím, vyberte Fiskální rok"
From {0} | {1} {2},Od {0} | {1} {2}
Operation Description,Operace Popis,
Will also apply to variants,Bude se vztahovat i na varianty,
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nelze měnit Fiskální rok Datum zahájení a fiskální rok datum ukončení, jakmile fiskální rok se uloží."
Shopping Cart,Nákupní vozík,
Avg Daily Outgoing,Avg Daily Odchozk,
Campaign,Kampak,
Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto"""
Sales BOM Help,Sales BOM Help,
Contact Person,Kontaktní osoba,
'Expected Start Date' can not be greater than 'Expected End Date',"""Očekávaný Datum Začátku"" nemůže být větší než ""Očekávanou Datum Konce"""
Holidays,Prázdniny,
Planned Quantity,Plánované Množstvy,
Item Tax Amount,Částka Daně Položky,
Get Terms and Conditions,Získejte Smluvní podmínky,
Leave blank if considered for all designations,"Ponechte prázdné, pokud se to považuje za všechny označení"
Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Obvinění z typu ""Aktuální"" v řádku {0} nemůže být zařazena do položky Rate"
Max: {0},Max: {0}
From Datetime,Od datetime,
For Company,Pro Společnost,
Communication log.,Komunikační protokol.
Buying Amount,Nákup Částka,
Shipping Address Name,Přepravní Adresa Název,
Chart of Accounts,Diagram účta,
Terms and Conditions Content,Podmínky Content,
cannot be greater than 100,nemůže být větší než 100,
Discount  %,Sleva%
Item {0} is not a stock Item,Položka {0} není skladem,
Unscheduled,Neplánovanm,
Owned,Vlastník,
"Higher the number, higher the priority","Vyšší číslo, vyšší priorita"
Purchase Invoice Trends,Trendy přijatách faktur,
Better Prospects,Lepší vyhlídky,
Goals,Cíle,
Warranty / AMC Status,Záruka / AMC Status,
Accounts Browser,Účty Browser,
GL Entry,Vstup GL,
Employee Settings,Nastavení zaměstnancr,
Batch-Wise Balance History,Batch-Wise Balance History,
To Do List,Do List,
Apprentice,Učer,
Negative Quantity is not allowed,Negativní množství není dovoleno,
"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Tax detail tabulka staženy z položky pána jako řetězec a uložené v této oblasti.
 Používá se daní a poplatků"
Lancing,Lancing,
Employee cannot report to himself.,Zaměstnanec nemůže odpovídat sám sobě.
"If the account is frozen, entries are allowed to restricted users.","V případě, že účet je zamrzlý, položky mohou omezeným uživatelům."
"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd."
Account Balance,Zůstatek na účtu,
Type of document to rename.,Typ dokumentu přejmenovat.
We buy this Item,Vykupujeme tuto položku,
Billing,Fakturace,
Flanging,Obrubovánu,
Not Sent,Neodesláno,
Explosive forming,Výbušné tvářenu,
Total Taxes and Charges (Company Currency),Celkem Daně a poplatky (Company Měnové)
Shipping Account,Přepravní účtu,
Scheduled to send to {0} recipients,Plánované poslat na {0} příjemci,
Readings,Čtenu,
Sub Assemblies,Podsestavy,
To Value,Chcete-li hodnota,
Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
Packing Slip,Balení Slip,
Office Rent,Pronájem kanceláře,
Setup SMS gateway settings,Nastavení Nastavení SMS brána,
Import Failed!,Import se nezdařil!
No address added yet.,Žádná adresa přidán dosud.
Workstation Working Hour,Pracovní stanice Pracovní Hour,
Analyst,Analytik,
Row {0}: Allocated amount {1} must be less than or equals to JV amount {2},"Řádek {0}: přidělené množství {1}, musí být menší než nebo se rovná hodnotě JV {2}"
Inventory,Inventái,
Sales Details,Prodejní Podrobnosti,
Pinning,Připne,
With Items,S položkami,
In Qty,V Množstvi,
Expense Claim Rejected,Uhrazení výdajů zamítnuto,
"The date on which next invoice will be generated. It is generated on submit.
","Datum, kdy bude vygenerován příští faktury. To je generován na odeslat."
Item Attribute,Položka Atribut,
Government,Vláda,
Re-order,Re objednávku,
Services,Služby,
Total ({0}),Celkem ({0})
Parent Cost Center,Nadřazené Nákladové středisko,
Source,Zdroj,
Is Leave Without Pay,Je odejít bez Pay,
"If Supplier Part Number exists for given Item, it gets stored here","Pokud dodavatel Kód existuje pro danou položku, dostane uloženy zde"
No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy,
Financial Year Start Date,Finanční rok Datum zahájeny,
Total Experience,Celková zkušenost,
Countersinking,Zahlubovány,
Packing Slip(s) cancelled,Balení Slip (y) zrušeno,
Freight and Forwarding Charges,Nákladní a Spediční Poplatky,
Sales Order No,Prodejní objednávky No,
Item Group Name,Položka Název skupiny,
Taken,Zaujaty,
Transfer Materials for Manufacture,Přenos Materiály pro výrobu,
For Price List,Pro Ceník,
Executive Search,Executive Search,
"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.","Cena při platbě za položku: {0} nebyl nalezen, který je povinen si účetní položka (náklady). Prosím, uveďte zboží Cena podle seznamu kupní cenou."
Schedules,Plány,
Net Amount,Čistá částka,
BOM Detail No,BOM Detail No,
CoA Help,CoA Help,
Error: {0} > {1},Chyba: {0}> {1}
Please create new account from Chart of Accounts.,"Prosím, vytvořte nový účet z grafu účtů."
Maintenance Visit,Maintenance Visit,
Customer > Customer Group > Territory,Zákazník> Zákazník Group> Territory,
Available Batch Qty at Warehouse,K dispozici šarže Množství ve skladu,
Time Log Batch Detail,Time Log Batch Detail,
Tasks,úkoly,
Landed Cost Help,Přistálo Náklady Help,
Tuesday,Útert,
Block Holidays on important days.,Blokové Dovolená na významných dnů.
Accounts Receivable Summary,Pohledávky Shrnute,
Please set User ID field in an Employee record to set Employee Role,Prosím nastavte uživatelské ID pole v záznamu zaměstnanců nastavit role zaměstnance,
UOM Name,UOM Name,
Target,Cíl,
Contribution Amount,Výše příspěvku,
Shipping Address,Shipping Address,
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.,"Tento nástroj vám pomůže aktualizovat nebo opravit množství a ocenění zásob v systému. To se obvykle používá k synchronizaci hodnot systému a to, co ve skutečnosti existuje ve vašich skladech."
In Words will be visible once you save the Delivery Note.,"Ve slovech budou viditelné, jakmile uložíte doručení poznámku."
Brand master.,Master Značky,
Due Date,Datum splatnosti,
Brand Name,Jméno značky,
Box,Krabice,
The Organization,Organizace,
Monthly Distribution,Měsíční Distribution,
Receiver List is empty. Please create Receiver List,Přijímač Seznam je prázdný. Prosím vytvořte přijímače Seznam,
Production Plan Sales Order,Výrobní program prodejní objednávky,
Sales Partner Target,Sales Partner Target,
Pricing Rule,Ceny Pravidlo,
Notching,Vystřihovány,
Reserved warehouse required for stock item {0},Vyhrazeno sklad potřebný pro živočišnou položku {0}
Bank Accounts,Bankovní účty,
Bank Reconciliation Statement,Bank Odsouhlasení prohlášeny,
Lead Name,Olovo Name,
POS,POS,
{0} must appear only once,{0} musí být uvedeny pouze jednou,
Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Není povoleno, aby transfer více {0} než {1} proti Objednávky {2}"
Leaves Allocated Successfully for {0},Listy Přidělené úspěšně za {0}
No Items to pack,Žádné položky k baleny,
From Value,Od hodnoty,
Manufacturing Quantity is mandatory,Výrobní množství je povinny,
Amounts not reflected in bank,Částky nezohledněny v bance,
Reading 4,Čtení 4,
Claims for company expense.,Nároky na náklady firmy.
Centrifugal casting,Odstředivé litm,
Magnetic field-assisted finishing,Magnetické pole-assisted dokončovánm,
Default Holiday List,Výchozí Holiday Seznam,
Task is Mandatory if Time Log is against a project,"Úkol je povinné, pokud Time Log je proti projektu"
Stock Liabilities,Stock Závazky,
Supplier Warehouse,Dodavatel Warehouse,
Contact Mobile No,Kontakt Mobil,
Select Sales Orders,Vyberte Prodejní objednávky,
Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny,
To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Chcete-li sledovat položky pomocí čárového kódu. Budete mít možnost zadat položky dodacího listu a prodejní faktury snímáním čárového kódu položky.
Make Quotation,Značka Citace,
Dependent Task,Závislý Task,
Conversion factor for default Unit of Measure must be 1 in row {0},"Konverzní faktor pro výchozí měrnou jednotku, musí být 1 v řádku {0}"
You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,"Nelze zadat i dodací list č a prodejní faktury č Prosím, zadejte jednu."
Leave of type {0} cannot be longer than {1},Leave typu {0} nemůže být delší než {1}
Try planning operations for X days in advance.,Zkuste plánování operací pro X dní předem.
Stop Birthday Reminders,Zastavit připomenutí narozenin,
Receiver List,Přijímač Seznam,
Payment Amount,Částka platby,
Consumed Amount,Spotřebovaném množstvn,
Salary Structure Deduction,Plat Struktura Odpočet,
Selective laser sintering,Selektivní laserové spékánn,
Unit of Measure {0} has been entered more than once in Conversion Factor Table,Měrná jednotka {0} byl zadán více než jednou v konverzním faktorem tabulce,
Import Successful!,Import byl úspěšný!
Cost of Issued Items,Náklady na vydaných položek,
Expenses Booked,Náklady rezervováno,
Quantity must not be more than {0},Množství nesmí být větší než {0}
Quotation Item,Položka Nabídky,
Account Name,Název účtu,
From Date cannot be greater than To Date,Datum OD nemůže být vetší než datum DO,
Serial No {0} quantity {1} cannot be a fraction,Pořadové číslo {0} {1} množství nemůže být zlomek,
Supplier Type master.,Dodavatel Type master.
Supplier Part Number,Dodavatel Číslo dílu,
Add,Přidat,
Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1,
Credit Controller,Credit Controller,
Vehicle Dispatch Date,Vozidlo Dispatch Datum,
Task is mandatory if Expense Claim is against a Project,"Úkol je povinné, pokud Náklady Reklamace je proti projektu"
Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena,
Default Payable Account,Výchozí Splatnost účtu,
Contacts,Kontakty,
"Settings for online shopping cart such as shipping rules, price list etc.","Nastavení pro on-line nákupního košíku, jako jsou pravidla dopravu, ceník atd"
Setup Complete,Setup Complete,
{0}% Billed,{0}% Účtovane,
Reserved Qty,Reserved Množstve,
Party Account,Party účtu,
Human Resources,Lidské zdroje,
Upper Income,Horní příjme,
My Issues,Moje problémy,
BOM Item,BOM Item,
For Employee,Pro zaměstnance,
Row {0}: Payment amount can not be negative,Row {0}: Částka platby nemůže být záporne,
Total Amount Reimbursed,Celkové částky proplacene,
Press fitting,Tisková kováne,
Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
Default Price List,Výchozí Ceník,
User Remark will be added to Auto Remark,Uživatel Poznámka budou přidány do Auto Poznámka,
Payments,Platby,
Hot isostatic pressing,Izostatické lisovánk,
Medium,Střednk,
Budget Allocated,Přidělený Rozpočet,
Customer Credit Balance,Zákazník Credit Balance,
Customer required for 'Customerwise Discount',"Zákazník požadoval pro 'Customerwise sleva """
Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
Term Details,Termín Podrobnosti,
Capacity Planning For (Days),Plánování kapacit Pro (dny)
Warranty Claim,Záruční reklamace,
Lead Details,Olověné Podrobnosti,
Approving User,Schvalování Uživatel,
Forging,Kováne,
Plating,Pokovováne,
End date of current invoice's period,Datum ukončení doby aktuální faktury je,
Applicable For,Použitelné pro,
From Date,Od data,
Validate,Potvrdit,
Partially Completed,Částečně Dokončeno,
Packed Items,Zabalené položky,
Warranty Claim against Serial No.,Reklamační proti sériového čísla,
"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","Nahradit konkrétní kusovník ve všech ostatních kusovníky, kde se používá. To nahradí původní odkaz kusovníku, aktualizujte náklady a regenerovat ""BOM explozi položku"" tabulku podle nového BOM"
Enable Shopping Cart,Povolit Nákupní košík,
Permanent Address,Trvalé bydlištk,
Item {0} must be a Service Item.,Položka {0} musí být služba položky.
Please select item code,"Prosím, vyberte položku kód"
Reduce Deduction for Leave Without Pay (LWP),Snížit Odpočet o dovolenou bez nároku na odměnu (LWP)
Territory Manager,Oblastní manažer,
Selling Settings,Prodejní Nastavenr,
Item cannot be a variant of a variant,Položka nemůže být varianta varianty,
Online Auctions,Aukce online,
Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množství nebo ocenění Cena, nebo obojí"
"Company, Month and Fiscal Year is mandatory","Společnost, měsíc a fiskální rok je povinný"
Marketing Expenses,Marketingové náklady,
Item Shortage Report,Položka Nedostatek Report,
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedeno, \n uveďte prosím ""váha UOM"" příliš"
Material Request used to make this Stock Entry,Materiál Žádost používá k výrobě této populace Entry,
View Details,Zobrazit podrobnosti,
Single unit of an Item.,Single jednotka položky.
Time Log Batch {0} must be 'Submitted',"Time Log Batch {0} musí být ""Odesláno"""
Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob,
Total Leaves Allocated,Celkem Leaves Přidělenb,
Warehouse required at Row No {0},Warehouse vyžadováno při Row No {0}
Date Of Retirement,Datum odchodu do důchodu,
Get Template,Získat šablonu,
Postal,Poštovnu,
Total amount of invoices sent to the customer during the digest period,Celková částka faktury poslal k zákazníkovi v období digest,
Weightage,Weightage,
Mining,Hornictvu,
Resin casting,Resin litu,
A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Zákaznická Skupina existuje se stejným názvem, prosím změnit název zákazníka nebo přejmenujte skupinu zákazníků"
Parent Territory,Parent Territory,
Reading 2,Čtení 2,
Material Receipt,Příjem materiálu,
Products,Výrobky,
Party Type and Party is required for Receivable / Payable account {0},Zadejte Party Party a je nutné pro pohledávky / závazky na účtu {0}
Next Contact By,Další Kontakt By,
Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství k položce {1}"
Order Type,Typ objednávky,
Notification Email Address,Oznámení e-mailová adresa,
Find Invoices to Match,Najít faktury zápas,
Item-wise Sales Register,Item-moudrý Sales Register,
"e.g. ""XYZ National Bank""","např ""XYZ Národní Banka"""
Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
Total Target,Celkem Target,
Applicant for a Job,Žadatel o zaměstnánt,
No Production Orders created,Žádné výrobní zakázky vytvořent,
Salary Slip of employee {0} already created for this month,Plat Slip of zaměstnance {0} již vytvořili pro tento měsíc,
Reconciliation JSON,Odsouhlasení JSON,
Too many columns. Export the report and print it using a spreadsheet application.,Příliš mnoho sloupců. Export zprávu a vytiskněte jej pomocí aplikace tabulky.
Batch No,Č. šarže,
Main,Hlavne,
Delete,Smazat,
Variant,Varianta,
New {0},Nový: {0}
Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakc$1,
Stopped order cannot be cancelled. Unstop to cancel.,Zastaveno příkaz nelze zrušit. Uvolnit zrušit.
Default BOM ({0}) must be active for this item or its template,Výchozí BOM ({0}) musí být aktivní pro tuto položku nebo jeho šablony,
Leave Encashed?,Ponechte zpeněžení?
Opportunity From field is mandatory,Opportunity Ze hřiště je povinnk,
Considered as an Opening Balance,Považována za počáteční zůstatek,
Variants,Varianty,
Make Purchase Order,Proveďte objednávky,
Send To,Odeslat,
There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0}
Contribution to Net Total,Příspěvek na celkových čistých,
Customer's Item Code,Zákazníka Kód položky,
Stock Reconciliation,Reklamní Odsouhlasenh,
Territory Name,Území Name,
Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat,
Applicant for a Job.,Žadatel o zaměstnání.
Warehouse and Reference,Sklad a reference,
Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel,
Country,Zeme,
Addresses,Adresy,
Received,Přijato,
Against Journal Entry {0} does not have any unmatched {1} entry,Proti věstníku Vstup {0} nemá bezkonkurenční {1} vstupu,
Duplicate Serial No entered for Item {0},Duplicitní Pořadové číslo vstoupil k bodu {0}
A condition for a Shipping Rule,Podmínka pro pravidla dopravy,
"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Název nového účtu. Poznámka: Prosím, vytvářet účty pro zákazníky a dodavatele, které se automaticky vytvoří z zákazníkem a dodavatelem master"
Attach Image,Připojit obrázek,
The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balíčku. (Automaticky vypočítá jako součet čisté váhy položek)
Leave blank if no change,"Ponechte prázdné, pokud žádná změna"
Time Logs for manufacturing.,Čas Protokoly pro výrobu.
Apply Warehouse-wise Reorder Level,Použít Skladovací-moudrý Seřadit sezn Level,
BOM {0} must be submitted,BOM {0} musí být předloženy,
Authorization Control,Autorizace Control,
Time Log for tasks.,Time Log pro úkoly.
Actual Time and Cost,Skutečný Čas a Náklady,
Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materiál Žádost maximálně {0} lze k bodu {1} na odběratele {2}
Salutation,Osloveno,
Rejected,Zamítnuto,
Brand,Značka,
Will also apply for variants,Bude platit i pro varianty,
% Delivered,% Dodáno,
Bundle items at time of sale.,Bundle položky v okamžiku prodeje.
Actual Qty,Skutečné Množstv0,
Reading 10,Čtení 10,
"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Seznam vaše produkty nebo služby, které jste koupit nebo prodat. Ujistěte se, že zkontrolovat položky Group, měrná jednotka a dalších vlastností při spuštění."
Hub Node,Hub Node,
You have entered duplicate items. Please rectify and try again.,"Zadali jste duplicitní položky. Prosím, opravu a zkuste to znovu."
Associate,Spolupracovník,
Item {0} is not a serialized Item,Položka {0} není serializovat položky,
"For 'Sales BOM' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pro ""Sales BOM"" předměty, sklad, bude Serial No a Batch No považují z ""Obsah balení"" tabulky. Pokud Warehouse a Batch No jsou stejné u všech balení předměty pro každého ""Prodej BOM"" položky, tyto hodnoty mohou být zapsány do hlavní tabulky položky, hodnoty se budou zkopírovány do ""Obsah balení"" tabulky."
Create Receiver List,Vytvořit přijímače seznam,
Expired,Vypršela,
To Package No.,Balit No.
System,Systém,
Issue Date,Datum vydánm,
Activity Cost,Náklady Aktivita,
Consumed Qty,Spotřeba Množstvm,
Telecommunications,Telekomunikace,
Indicates that the package is a part of this delivery (Only Draft),"Označuje, že balíček je součástí této dodávky (Pouze návrhu)"
Make Payment Entry,Učinit vstup platby,
Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1}
Never,Nikdy,
Sales Invoice Trends,Prodejní faktury Trendy,
Apply / Approve Leaves,Použít / Schválit listy,
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Se může vztahovat řádku, pouze pokud typ poplatku je ""On předchozí řady Částka"" nebo ""předchozí řady Total"""
Allowance Percent,Allowance Procento,
Message Parameter,Parametr zpráv,
Delivery Document No,Dodávka dokument o,
Get Items From Purchase Receipts,Získat položky z Příjmového listu,
Creation Date,Datum vytvořeno,
Item {0} appears multiple times in Price List {1},Položka {0} se objeví několikrát v Ceníku {1}
"Selling must be checked, if Applicable For is selected as {0}","Prodej musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
Supplier Quotation Item,Dodavatel Nabídka Položka,
Make Salary Structure,Proveďte platovou strukturu,
Shearing,Stříhána,
Has Variants,Má varianty,
Click on 'Make Sales Invoice' button to create a new Sales Invoice.,"Klikněte na tlačítko "", aby se prodej na faktuře"" vytvořit nový prodejní faktury."
Period From and Period To dates mandatory for recurring %s,"Období od a období, na termíny povinných opakujících% s"
Against Expense Claim,Proti Expense nároku,
Packaging and labeling,Balení a označovánu,
Name of the Monthly Distribution,Název měsíční výplatou,
Parent Sales Person,Parent obchodník,
Please specify Default Currency in Company Master and Global Defaults,"Uveďte prosím výchozí měnu, ve společnosti Master and Global výchozí"
"Payment against {0} {1} cannot be greater \
					than Outstanding Amount {2}","Platba na {0} {1} nemůže být větší \
 než dlužná částka {2}"
Dropbox Access Secret,Dropbox Access Secret,
Recurring Invoice,Opakující se faktury,
Net Weight of each Item,Hmotnost každé položky,
Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
Fiscal Year,Fiskální rok,
Budget,Rozpočet,
Achieved,Dosaženk,
Territory / Customer,Territory / Customer,
e.g. 5,např. 5,
Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Přidělená částka {1} musí být menší než nebo se rovná fakturovat dlužné částky {2}
In Words will be visible once you save the Sales Invoice.,"Ve slovech budou viditelné, jakmile uložíte prodejní faktury."
Is Sales Item,Je Sales Item,
Item Group Tree,Položka Group Tree,
Item {0} is not setup for Serial Nos. Check Item master,"Položka {0} není nastavení pro Serial č. Zkontrolujte, zda master položku"
Maintenance Time,Údržba Time,
Amount to Deliver,"Částka, která má dodávat"
A Product or Service,Produkt nebo Služba,
There were errors.,Byly tam chyby.
Tapping,Výčepne,
Current Value,Current Value,
Item Template cannot have stock and varaiants. Please remove stock from warehouses {0},"Položka Šablona nemůže mít zásoby a varaiants. Prosím, odstraňte zásoby ze skladů {0}"
{0} created,{0} vytvořil,
Against Sales Order,Proti přijaté objednávce,
Serial No Status,Serial No Status,
Item table can not be blank,Tabulka Položka nemůže být prázdnl,
"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Řádek {0}: Pro nastavení {1} periodicita, rozdíl mezi z a aktuální \
 musí být větší než nebo rovno {2}"
Selling,Prodejnu,
Salary Information,Vyjednávání o platu,
Name and Employee ID,Jméno a ID zaměstnance,
Due Date cannot be before Posting Date,Datum splatnosti nesmí být před odesláním Datum,
Website Item Group,Website Item Group,
Duties and Taxes,Odvody a danu,
Please enter Reference date,"Prosím, zadejte Referenční den"
Table for Item that will be shown in Web Site,"Tabulka k bodu, který se zobrazí na webových stránkách"
Supplied Qty,Dodávané Množstvd,
Material Request Item,Materiál Žádost o bod,
Tree of Item Groups.,Strom skupiny položek.
Cannot refer row number greater than or equal to current row number for this Charge type,Nelze odkazovat číslo řádku větší nebo rovnou aktuální číslo řádku pro tento typ Charge,
Item-wise Purchase History,Item-moudrý Historie nákupe,
Red,Červene,
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosím, klikněte na ""Generovat Schedule"", aby přinesla Pořadové číslo přidán k bodu {0}"
Frozen,Zmraženy,
Open Production Orders,Otevřené výrobní zakázky,
Installation Time,Instalace Time,
Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost,
Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} není dokončen {2} Množství hotových výrobků ve výrobním procesu objednávky # {3}. Prosím aktualizujte provozní stav přes čas protokoly,
Investments,Investice,
Resolution Details,Rozlišení Podrobnosti,
Change UOM for an Item.,Změna UOM za položku.
Acceptance Criteria,Kritéria přijetu,
Attribute Name,Název atributu,
Item {0} must be Sales or Service Item in {1},Položka {0} musí být prodej či servis položku v {1}
Show In Website,Show pro webové stránky,
Group,Skupina,
Expected Time (in hours),Předpokládaná doba (v hodinách)
Qty to Order,Množství k objednávce,
PO No,PO No,
Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.
For Employee Name,Pro jméno zaměstnance,
Clear Table,Clear Table,
Brands,Značky,
Invoice No,Faktura e,
From Purchase Order,Z vydané objednávky,
Please select company first.,Vyberte společnost jako první.
Costing Rate,Kalkulace Rate,
Against Journal Entry,Proti položka deníku,
Resignation Letter Date,Rezignace Letter Datum,
Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.
Not Set,Není nastaveno,
Date,Datum,
Repeat Customer Revenue,Repeat Customer Příjmy,
Sit tight while your system is being setup. This may take a few moments.,"Drž se, když váš systém je nastavení. To může trvat několik okamžiků."
{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mít roli ""Schvalovatel výdajů"""
Pair,Pár,
Against Account,Proti účet,
Actual Date,Skutečné datum,
Has Batch No,Má číslo šarže,
Excise Page Number,Spotřební Číslo stránky,
Personal Details,Osobní data,
Maintenance Schedules,Plány údržby,
Embossing,Ražba,
Quotation Trends,Uvozovky Trendy,
Item Group not mentioned in item master for item {0},Položka Group není uvedeno v položce mistra na položku {0}
Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
"As Production Order can be made for this item, it must be a stock item.","Jako výrobní objednávce lze provést za tuto položku, musí být skladem."
Shipping Amount,Přepravní Částka,
Joining,Spojována,
Above Value,Výše uvedená hodnota,
Pending Amount,Čeká Částka,
Conversion Factor,Konverzní faktor,
Delivered,Dodáva,
Setup incoming server for jobs email id. (e.g. jobs@example.com),Nastavení příchozí server pro úlohy e-mailovou id. (Např jobs@example.com)
The date on which recurring invoice will be stop,"Datum, kdy opakující se faktura bude zastaví"
Accounts Receivable,Pohledávky,
Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics,
This format is used if country specific format is not found,"Tento formát se používá, když specifický formát země není nalezen"
Custom,Zvyk,
Use Multi-Level BOM,Použijte Multi-Level BOM,
Injection molding,Vstřikovánk,
Include Reconciled Entries,Zahrnout odsouhlasené zápisy,
Tree of finanial accounts.,Strom finanial účtů.
Leave blank if considered for all employee types,"Ponechte prázdné, pokud se to považuje za ubytování ve všech typech zaměstnanců"
Distribute Charges Based On,Distribuovat poplatků na základ$1,
Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,"Účet {0} musí být typu ""dlouhodobého majetku"", protože položka {1} je majetková položka"
HR Settings,Nastavení HR,
Printing,Tisk,
Expense Claim is pending approval. Only the Expense Approver can update status.,Úhrada výdajů čeká na schválení. Pouze schalovatel výdajů může aktualizovat stav.
The day(s) on which you are applying for leave are holiday. You need not apply for leave.,"Den (y), na které žádáte o dovolené jsou dovolenou. Potřebujete nevztahuje na dovolenou."
and,a,
Leave Block List Allow,Nechte Block List Povolit,
Sports,Sportovna,
Total Actual,Celkem Aktuálna,
"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Získejte rychlost oceňování a dostupných zásob u zdroje / cílové skladu na uvedeném Datum zveřejnění čase. Pokud se na pokračování položku, stiskněte toto tlačítko po zadání sériového čísla."
Something went wrong.,Něco se pokazilo.
Unit,Jednotka,
Please set Dropbox access keys in your site config,"Prosím, nastavení přístupových klíčů Dropbox ve vašem webu config"
Please specify Company,"Uveďte prosím, firmu"
Customer Acquisition and Loyalty,Zákazník Akvizice a loajality,
From Time cannot be greater than To Time,"Čas od nemůže být větší, než čas do"
Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
Your financial year ends on,Váš finanční rok končk,
Price List,Ceník,
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je nyní výchozí fiskální rok. Prosím aktualizujte svůj prohlížeč aby se změny projevily.
Expense Claims,Nákladové Pohledávky,
Support,Podpora,
Approving Role,Schvalování roli,
Please specify currency in Company,"Uveďte prosím měnu, ve společnosti"
Wages per hour,Mzda za hodinu,
Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
"Show / Hide features like Serial Nos, POS etc.","Zobrazit / skrýt funkce, jako pořadová čísla, POS atd"
LR No,LR No,
UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0}
Clearance date cannot be before check date in row {0},Datum vůle nemůže být před přihlášením dnem v řadě {0}
Deduction,Dedukce,
Address Template,Šablona adresy,
Classification of Customers by region,Rozdělení zákazníků podle kraje,
% Tasks Completed,% splněných úkole,
Gross Margin,Hrubá marže,
Please enter Production Item first,"Prosím, zadejte první výrobní položku"
disabled user,zakázané uživatelska,
Quotation,Nabídka,
Total Deduction,Celkem Odpočet,
Hey! Go ahead and add an address,Hey! Jděte do toho a přidejte adresu,
Maintenance User,Údržba uživatele,
Cost Updated,Náklady Aktualizováno,
Are you sure you want to UNSTOP,"Jste si jisti, že chcete ODZASTAVIT"
Date of Birth,Datum narozene,
Salary Manager,Plat Správce,
Item {0} has already been returned,Bod {0} již byla vrácena,
**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiskální rok ** představuje finanční rok. Veškeré účetní záznamy a další významné transakce jsou sledovány proti ** fiskální rok **.
Customer / Lead Address,Zákazník / Lead Address,
Actual Operation Time,Aktuální Provozní doba,
Applicable To (User),Vztahující se na (Uživatel)
Deduct,Odečíst,
Job Description,Popis Práce,
Qty as per Stock UOM,Množství podle Stock nerozpuštěných,
Please select a valid csv file with data,Vyberte prosím platný CSV soubor s daty,
To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Chcete-li sledovat položky v oblasti prodeje a nákupu dokumenty šarže nos <br> <b> Preferovaná Industry: Chemikálie etc </ b>
Coating,Nátěr,
"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Speciální znaky kromě ""-"". """", ""#"", a ""/"" není povoleno v pojmenování řady"
"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Mějte přehled o prodejních kampaní. Mějte přehled o Leads, citace, prodejní objednávky atd z kampaně, aby zjistily, návratnost investic. "
Approver,Schvalovatel,
SO Qty,SO Množstvl,
"Stock entries exist against warehouse {0}, hence you cannot re-assign or modify Warehouse","Přírůstky zásob existují proti skladu {0}, a proto není možné přeřadit nebo upravit Warehouse"
Calculate Total Score,Vypočítat Celková skóre,
Depends on LWP,Závisí na LWP,
Manufacturing Manager,Výrobní ředitel,
Serial No {0} is under warranty upto {1},Pořadové číslo {0} je v záruce aľ {1}
Split Delivery Note into packages.,Rozdělit dodací list do balíčků.
Shipments,Zásilky,
Dip molding,Dip lity,
Time Log Status must be Submitted.,Time Log Status musí být předloženy.
Setting Up,Nastavenu,
Make Debit Note,Proveďte dluhu,
In Words (Company Currency),Slovy (měna společnosti)
Supplier,Dodavatel,
Quarter,Čtvrtletl,
Miscellaneous Expenses,Různé výdaje,
Default Company,Výchozí Company,
Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob,
"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Chcete-li povolit nadfakturace, prosím nastavte na skladě Nastavení"
Bank Name,Název banky,
-Above,-Nad,
User {0} is disabled,Uživatel {0} je zakázána,
Total Leave Days,Celkový počet dnů dovoleny,
Note: Email will not be sent to disabled users,Poznámka: E-mail se nepodařilo odeslat pro zdravotně postižené uživatele,
Select Company...,Vyberte společnost ...
Leave blank if considered for all departments,"Ponechte prázdné, pokud se to považuje za všechna oddělení"
"Types of employment (permanent, contract, intern etc.).","Druhy pracovního poměru (trvalý, smluv, stážista atd.)"
{0} is mandatory for Item {1},{0} je povinná k položce {1}
From Currency,Od Měny,
Name,Jméno,
"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosím, vyberte alokovaná částka, typ faktury a číslo faktury v aspoň jedné řadě"
Last Sales Order Date,Poslední prodejní objednávky Datum,
Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0}
Amounts not reflected in system,Částky nejsou zohledněny v systému,
Rate (Company Currency),Cena (Měna Společnosti)
Others,Ostatn$1,
Production might not be able to finish by the Expected Delivery Date.,Výroba nemusí být schopen dokončit očekávanou Termín dodání.
Set as Stopped,Nastavit jako Zastaveno,
Taxes and Charges,Daně a poplatky,
"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje."
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
Completed,Dokončeno,
Select DocType,Zvolte DocType,
Broaching,Protahováno,
Banking,Bankovnictvo,
Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán"
New Cost Center,Nové Nákladové Středisko,
Ordered Quantity,Objednané množstvo,
"e.g. ""Build tools for builders""","např ""Stavět nástroje pro stavitele """
In Process,V procesu,
Itemwise Discount,Itemwise Sleva,
Detailed Breakup of the totals,Podrobný rozpadu součty,
{0} against Sales Order {1},{0} proti Prodejní Objednávce {1}
Fixed Asset,Základní Jměne,
Total Billing Amount,Celková částka fakturace,
Receivable Account,Pohledávky účtu,
No Updates For,Žádné aktualizace pro,
Stock Balance,Reklamní Balance,
Expense Claim Detail,Detail úhrady výdaje,
Time Logs created:,Čas Záznamy vytvořil:
If Yearly Budget Exceeded,Pokud Roční rozpočet překročen,
Weight UOM,Hmotnostní jedn.
Blood Group,Krevní Skupina,
Page Break,Zalomení stránky,
Pending,Až do,
Users who can approve a specific employee's leave applications,"Uživatelé, kteří si vyhoví žádosti konkrétního zaměstnance volno"
Office Equipments,Kancelářské Vybaveni,
Qty,Množstvi,
Companies,Společnosti,
Electronics,Elektronika,
"Balances of Accounts of type ""Bank"" or ""Cash""","Zůstatky na účtech typu ""banka"" nebo ""Cash"""
"Specify a list of Territories, for which, this Shipping Rule is valid","Zadejte seznam území, pro které tato Shipping pravidlo platí"
Raise Material Request when stock reaches re-order level,Zvýšit Materiál vyžádání při stock dosáhne úrovně re-order,
From Maintenance Schedule,Z plánu údržby,
Full-time,Na plný úvazek,
Country Settings,Nastavení Zemr,
Contact Details,Kontaktní údaje,
Received Date,Datum přijetr,
"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu v prodeji daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
Upload Backups to Google Drive,Nahrát zálohy na Disk Google,
Total Incoming Value,Celková hodnota Příchoze,
Purchase Price List,Nákupní Ceník,
Offer Term,Nabídka Term,
Quality Manager,Manažer kvality,
Job Opening,Job Zahájene,
Payment Reconciliation,Platba Odsouhlasene,
Please select Incharge Person's name,"Prosím, vyberte incharge jméno osoby"
Date on which lorry started from your warehouse,"Datum, kdy nákladní automobil začal ze svého skladu"
Technology,Technologie,
Supplier (vendor) name as entered in supplier master,"Dodavatel (prodávající), název, jak je uvedena v dodavatelských master"
Offer Letter,Nabídka Letter,
Generate Material Requests (MRP) and Production Orders.,Generování materiálu Požadavky (MRP) a výrobní zakázky.
Total Invoiced Amt,Celkové fakturované Amt,
To Time,Chcete-li čas,
"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Chcete-li přidat podřízené uzly, prozkoumat stromu a klepněte na položku, pod kterou chcete přidat více uzlů."
Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet,
BOM recursion: {0} cannot be parent or child of {2},BOM rekurze: {0} nemůže být rodič nebo dítě {2}
Completed Qty,Dokončené Množstv$1,
"For {0}, only debit accounts can be linked against another credit entry","Pro {0}, tak debetní účty mohou být spojeny proti jinému připsání"
Price List {0} is disabled,Ceník {0} je zakázána,
Allow Overtime,Povolit Přesčasy,
Sales Order {0} is stopped,Prodejní objednávky {0} je zastaven,
New Leads,Nové vede,
Current Valuation Rate,Aktuální ocenění Rate,
"Advance paid against {0} {1} cannot be greater \
					than Grand Total {2}","Vyplacena záloha na {0} {1} nemůže být větší \
 než Celkový součet {2}"
Lost Reason,Ztracené Důvod,
Create Payment Entries against Orders or Invoices.,Vytvořte Platební záznamy proti objednávky nebo faktury.
Welding,SvařovánM,
New Stock UOM is required,Je zapotřebí nové Reklamní UOM,
Sample Size,Velikost vzorku,
All items have already been invoiced,Všechny položky již byly fakturovány,
Please specify a valid 'From Case No.',"Uveďte prosím platný ""Od věci č '"
Further cost centers can be made under Groups but entries can be made against non-Groups,"Další nákladová střediska mohou být vyrobeny v rámci skupiny, ale položky mohou být provedeny proti non-skupin"
External,Externl,
Item Serial Nos,Položka sériových čísel,
Not Received,Neobdržel,
Branch,Větev,
Customer (Receivable) Account,Customer (pohledávka) Account,
Actual Quantity,Skutečné Množstvl,
example: Next Day Shipping,Příklad: Next Day Shipping,
Serial No {0} not found,Pořadové číslo {0} nebyl nalezen,
Price Lists,Ceníky,
Considered as Opening Balance,Považován za počáteční zůstatek,
Your Customers,Vaši Zákazníci,
Compression molding,Lisovánl,
Block Date,Block Datum,
Not Delivered,Ne vyhlášeno,
Bank Clearance Summary,Souhrn bankovního zúčtovánl,
"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest."
Item Code > Item Group > Brand,Kód položky> Položka Group> Brand,
Appraisal Goal,Posouzení Goal,
Friday,Pátek,
Costing Amount,Kalkulace Částka,
Submit Salary Slip,Odeslat výplatní pásce,
Monthly Earning & Deduction,Měsíčního výdělku a dedukce,
Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
Address & Contacts,Adresa a kontakty,
Sender Name,Jméno odesílatele,
Title,Titulek,
Customize,Přizpůsobit,
[Select],[Vybrat]
Make Sales Invoice,Proveďte prodejní faktuře,
For Reference Only.,Pouze orientační.
Invalid {0}: {1},Neplatný {0}: {1}
Advance Amount,Záloha ve výši,
Capacity Planning,Plánování kapacit,
'From Date' is required,"""Datum od"" je povinné"
Reference Number,Referenční číslo,
Employment Details,Informace o zaměstnáno,
New Workplace,Nové pracovišto,
Set as Closed,Nastavit jako Zavřeno,
No Item with Barcode {0},No Položka s čárovým kódem {0}
Case No. cannot be 0,Případ č nemůže být 0,
If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,"Máte-li prodejní tým a prodej Partners (obchodních partnerů), které mohou být označeny a udržovat svůj příspěvek v prodejní činnosti"
Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky,
Stores,Obchody,
Projects Manager,Správce projekty,
Delivery Time,Dodací lhůta,
Ageing Based On,Stárnutí dle,
End of Life,Konec životnosti,
Travel,Cestovány,
Allow Users,Povolit uživatele,
Operation is Mandatory,Provoz je Povinny,
Recurring,Opakující se,
Track separate Income and Expense for product verticals or divisions.,Sledovat samostatné výnosy a náklady pro vertikál produktu nebo divizí.
Rename Tool,Přejmenovánt,
Update Cost,Aktualizace Cost,
Item Reorder,Položka Reorder,
Check to make primary address,Zaškrtněte pro vytvoření primární adresy,
Transfer Material,Přenos materiálu,
"Specify the operations, operating cost and give a unique Operation no to your operations.","Zadejte operací, provozní náklady a dávají jedinečnou operaci ne své operace."
Price List Currency,Ceník Měna,
User must always select,Uživatel musí vždy vybrat,
Allow Negative Stock,Povolit Negativní Sklad,
Installation Note,Poznámka k instalaci,
Add Taxes,Přidejte dana,
Financial Analytics,Finanční Analýza,
Verified By,Verified By,
Subsidiary,Dceřina,
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nelze změnit výchozí měně společnosti, protože tam jsou stávající transakce. Transakce musí být zrušena, aby změnit výchozí měnu."
Purchase Receipt No,Číslo příjmky,
Earnest Money,Earnest Money,
Create Salary Slip,Vytvořit výplatní pásce,
Expected balance as per bank,Očekávaný zůstatek podle banky,
Buffing,Leštěny,
Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
Employee,Zaměstnanec,
Import Email From,Importovat e-maily z,
After Sale Installations,Po prodeji instalacc,
{0} {1} is fully billed,{0} {1} je plně fakturováno,
End Time,End Time,
Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.
Group by Voucher,Seskupit podle Poukazu,
Required On,Povinné On,
Mass Mailing,Hromadné emaily,
Standard,Standard,
File to Rename,Soubor přejmenovat,
Purchse Order number required for Item {0},Purchse Objednací číslo potřebný k bodu {0}
Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušena před zrušením této prodejní objednávky,
Payments Received,Přijaté platby,
"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Definovat rozpočtu na tento nákladového střediska. Chcete-li nastavit rozpočtu akce, viz <a href = ""#!List / Company ""> Společnost Mistr </a>"
Size,Velikost,
Expense Claim Approved,Uhrazení výdajů schváleno,
Calendar Events,Kalendář akct,
Pharmaceutical,Farmaceutickt,
Cost of Purchased Items,Náklady na zakoupené zbožt,
Sales Order Required,Prodejní objednávky Povinnt,
Create Customer,Vytvořit zákazníka,
Credit To,Kredit:
Post Graduate,Postgraduáln$1,
"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Poznámka: Zálohy a soubory nejsou odstraněny z Dropbox, budete muset odstranit ručně."
Maintenance Schedule Detail,Plán údržby Detail,
Reading 9,Čtení 9,
Buying Settings,Nákup Nastavenl,
Mass finishing,Mass dokončovacl,
BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce,
Attendance To Date,Účast na data,
Setup incoming server for sales email id. (e.g. sales@example.com),Nastavení příchozí server pro prodej e-mailovou id. (Např sales@example.com)
Raised By,Vznesent,
Payment Account,Platební účet,
Please specify Company to proceed,Uveďte prosím společnost pokračovat,
Google Drive,Google Drive,
Draft,Návrh,
Compensatory Off,Vyrovnávací Off,
Accepted,Přijato,
Female,Žena,
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.,"Ujistěte se, že opravdu chcete vymazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou, jak to je. Tuto akci nelze vrátit zpět."
Modern,Moderno,
Replied,Odpovězeno,
Total Payment Amount,Celková Částka platby,
{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemůže být větší, než Plánované Množství ({2}), ve Výrobní Objednávce {3}"
Shipping Rule Label,Přepravní Pravidlo Label,
Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
Test,Test,
You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit sazbu, kdyby BOM zmínil agianst libovolné položky"
Previous Work Experience,Předchozí pracovní zkušenosti,
For Quantity,Pro Množstvi,
Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}"
{0} {1} is not submitted,{0} {1} není odesláno,
Requests for items.,Žádosti o položky.
Separate production order will be created for each finished good item.,Samostatná výroba objednávka bude vytvořena pro každého hotového dobrou položku.
New Communications,Nová komunikace,
Terms and Conditions1,Podmínky a podmínek1,
Complete Setup,Kompletní nastavene,
"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účetní záznam zmrazeny až do tohoto data, nikdo nemůže dělat / upravit položku kromě role uvedeno níže."
Please save the document before generating maintenance schedule,"Prosím, uložit dokument před generováním plán údržby"
Project Status,Stav projektu,
Check this to disallow fractions. (for Nos),"Zkontrolujte, zda to zakázat frakce. (U č)"
Newsletter Mailing List,Newsletter adresáv,
Transporter Name,Přepravce Název,
Enter department to which this Contact belongs,"Zadejte útvar, který tento kontaktní patří"
Total Absent,Celkem Absent,
Item or Warehouse for row {0} does not match Material Request,Položka nebo Warehouse na řádku {0} neodpovídá Materiál Poptávka,
Unit of Measure,Měrná jednotka,
Year End Date,Datum Konce Roku,
Task Depends On,Úkol je závislá na,
Opportunity,Příležitost,
Salary Structure Earning,Plat Struktura Zisk,
Completed Production Orders,Dokončené Výrobní zakázky,
Default Workstation,Výchozí Workstation,
Inventory & Support,Zásoby a podpora,
Expense Claim Approved Message,Zpráva o schválení úhrady výdajt,
How frequently?,Jak často?
Get Current Stock,Získejte aktuální stav,
Make Installation Note,Proveďte Instalace Poznámka,
Maintenance start date can not be before delivery date for Serial No {0},Datum zahájení údržby nemůže být před datem dodání pro pořadové číslo {0}
Actual End Date,Skutečné datum ukončen$1,
Applicable To (Role),Vztahující se na (Role)
Purpose,Účel,
Will also apply for variants unless overrridden,"Bude platit i pro varianty, pokud nebude přepsáno"
Advances,Zálohy,
Approving User cannot be same as user the rule is Applicable To,Schválení Uživatel nemůže být stejná jako uživatel pravidlo se vztahuje na,
No of Requested SMS,Počet žádaným SMS,
Campaign-.####,Kampaň-.####
Make Invoice,Proveďte faktury,
Piercing,Pronikavy,
Your Customer's TAX registration numbers (if applicable) or any general information,DIČ Vašeho zákazníka (pokud má) nebo jakékoli obecné informace,
Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojovány,
A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributor / dealer / jednatel / partner / prodejce, který prodává produkty společnosti za provizi."
Has Child Node,Má děti Node,
{0} against Purchase Order {1},{0} proti Nákupní Objednávce {1}
"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Zadejte statické parametry url zde (Např odesílatel = ERPNext, username = ERPNext, password. = 1234 atd.),"
This is an example website auto-generated from ERPNext,To je příklad webové stránky automaticky generované z ERPNext,
Ageing Range 1,Stárnutí Rozsah 1,
Photochemical machining,Fotochemický obráběnt,
"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.","Standardní daň šablona, ​​která může být použita pro všechny nákupních transakcí. Tato šablona může obsahovat seznam daňových hlav a také ostatní náklady hlavy jako ""doprava"", ""pojištění"", ""manipulace"" atd. 

 #### Poznámka: 

 daňovou sazbu, můžete definovat zde bude základní sazba daně pro všechny ** položky **. Pokud jsou položky ** **, které mají různé ceny, musí být přidány v ** Položka daních ** stůl v ** položky ** mistra.

 #### Popis sloupců 

 1. Výpočet Type: 
 - To může být na ** Čistý Total ** (což je součet základní částky).
 - ** Na předchozí řady Total / Částka ** (pro kumulativní daní a poplatků). Zvolíte-li tuto možnost, bude daň se použije jako procento z předchozí řady (v daňové tabulky) množství nebo celkem.
 - ** Aktuální ** (jak je uvedeno).
 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat 
 3. Nákladové středisko: V případě, že daň / poplatek je příjmem (jako poštovné) nebo nákladů je třeba rezervovat na nákladové středisko.
 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).
 5. Rate: Sazba daně.
 6. Částka: Částka daně.
 7. Celkem: Kumulativní celková k tomuto bodu.
 8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).
 9. Zvažte daň či poplatek za: V této části můžete nastavit, zda daň / poplatek je pouze pro ocenění (není součástí celkem), nebo pouze pro celkem (není přidanou hodnotu do položky), nebo pro obojí.
 10. Přidat nebo odečítat: Ať už chcete přidat nebo odečíst daň."
Note,Poznámka,
New Material Requests,Nové žádosti Materiál,
Recd Quantity,Recd Množstva,
Email Ids,Email IDS,
Cannot produce more Item {0} than Sales Order quantity {1},Nelze produkují více položku {0} než prodejní objednávky množství {1}
Set as Unstopped,Nastavit jako nezastavěnou,
Stock Entry {0} is not submitted,Sklad Entry {0} není předložena,
Bank / Cash Account,Bank / Peněžní účet,
This Leave Application is pending approval. Only the Leave Approver can update status.,To Leave Aplikace je čeká na schválení. Pouze Leave schvalovač aktualizovat stav.
Hide Currency Symbol,Skrýt symbol měny,
"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty"
Credit Note,Dobropis,
Completed Qty cannot be more than {0} for operation {1},Dokončené množství nemůže být více než {0} pro provoz {1}
Quality,Kvalita,
Introduction,Úvod,
Service Address,Servisní adresy,
Max 100 rows for Stock Reconciliation.,Max 100 řádky pro Stock smíření.
Manufacture,Výroba,
Please Delivery Note first,Dodávka Vezměte prosím na vědomí prvna,
Tax Master,Tax Mistr,
Customer / Lead Name,Zákazník / Lead Name,
Clearance Date not mentioned,Výprodej Datum není uvedeno,
Production,Výroba,
Allow Production Order,Povolit výrobní objednávky,
Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum"
Total(Qty),Total (ks)
Installed Qty,Instalované množstvx,
Fax,Fax,
Parenttype,Parenttype,
Submitted,Vloženo,
Total Earning,Celkem Zisk,
Time at which materials were received,"Čas, kdy bylo přijato materiály"
Organization branch master.,Organizace větev master.
Will be calculated automatically when you enter the details,"Bude vypočtena automaticky, když zadáte detaily"
Transporter lorry number,Transporter číslo nákladní auto,
Billing Status,Status Fakturace,
Backup Right Now,Zálohovat hned,
Utility Expenses,Utility Náklady,
90-Above,90 Nad,
Default Buying Price List,Výchozí Nákup Ceník,
Sales Order Message,Prodejní objednávky Message,
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Nastavit jako výchozí hodnoty, jako je společnost, měna, aktuálním fiskálním roce, atd"
Payment Type,Typ platby,
Select Employees,Vybrat Zaměstnanci,
To Date,To Date,
Potential Sales Deal,Potenciální prodej,
Details,Podrobnosti,
Total Taxes and Charges,Celkem Daně a poplatky,
Payments Made,Platby provedeny,
Emergency Contact,Kontakt v nouzi,
Quality Parameters,Parametry kvality,
Target  Amount,Cílová částka,
Shopping Cart Settings,Nákupní košík Nastaveny,
Accounting Entries,Účetní záznamy,
Duplicate Entry. Please check Authorization Rule {0},Duplicitní záznam. Zkontrolujte autorizační pravidlo {0}
Ref SQ,Ref SQ,
Replace Item / BOM in all BOMs,Nahradit položky / kusovníky ve všech kusovníkQ,
Received Qty,Přijaté MnožstvQ,
Serial No / Batch,Výrobní číslo / Batch,
Parent Item,Nadřazená položka,
Account Type,Typ účtu,
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plán údržby není generován pro všechny položky. Prosím, klikněte na ""Generovat Schedule"""
To Produce,K výrob$1,
"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pro řádek {0} v {1}. Chcete-li v rychlosti položku jsou {2}, řádky {3} musí být také zahrnuty"
Identification of the package for the delivery (for print),Identifikace balíčku pro dodávky (pro tisk)
Reserved Quantity,Vyhrazeno Množstvy,
Purchase Receipt Items,Položky příjemky,
Parent Party Type,Parent Type Party,
Cutting,Výstřižek,
Flattening,Zploštěny,
Backups will be uploaded to,Zálohy budou nahrány na,
Income Account,Účet příjmy,
Molding,Lity,
Current Qty,Aktuální Množstvy,
"See ""Rate Of Materials Based On"" in Costing Section","Viz ""Hodnotit materiálů na bázi"" v kapitole Costing"
Key Responsibility Area,Key Odpovědnost Area,
Material Request Type,Materiál Typ požadavku,
Documents,Dokumenty,
Ref,Ref,
Cost Center,Nákladové středisko,
Voucher #,Voucher #
Purchase Order Message,Zprávy vydané objenávky,
Upload HTML,Nahrát HTML,
"Total advance ({0}) against Order {1} cannot be greater \
				than the Grand Total ({2})","Celkem předem ({0}) na objednávku {1} nemůže být větší než \
 celkovém součtu ({2})"
Relieving Date,Uvolnění Datum,
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Ceny Pravidlo je vyrobena přepsat Ceník / definovat slevy procenta, na základě určitých kritérií."
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sklad je možné provést pouze prostřednictvím Burzy Entry / dodací list / doklad o zakoupeno,
Class / Percentage,Třída / Procento,
Head of Marketing and Sales,Vedoucí marketingu a prodeje,
Income Tax,Daň z příjmo,
Laser engineered net shaping,Laser technicky čisté tvarováno,
"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Je-li zvolena Ceny pravidlo je určen pro ""Cena"", přepíše ceníku. Ceny Pravidlo cena je konečná cena, a proto by měla být použita žádná další sleva. Proto, v transakcích, jako odběratele, objednávky atd, bude stažen v oboru ""sazbou"", spíše než poli ""Ceník sazby""."
Track Leads by Industry Type.,Trasa vede od průmyslu typu.
Item Supplier,Položka Dodavatel,
Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no"
Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
For automatic exchange rates go to jsonrates.com and signup for an API key,U automatických směnných kurzů jít do jsonrates.com a zaregistrovat pro klíč API,
All Addresses.,Všechny adresy.
Stock Settings,Stock Nastavene,
Bio,Biografie,
"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company"
Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
New Cost Center Name,Jméno Nového Nákladového Střediska,
Leave Control Panel,Nechte Ovládací panely,
No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,"No default šablony adresy nalezeno. Prosím, vytvořte nový z Nastavení> Tisk a značky> Adresa šablonu."
HR User,HR User,
Taxes and Charges Deducted,Daně a odečtenr,
Issues,Problémy,
Status must be one of {0},Stav musí být jedním z {0}
Debit To,Debetní K,
Required only for sample item.,Požadováno pouze pro položku vzorku.
Actual Qty After Transaction,Skutečné Množství Po transakci,
Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka"
Extra Large,Extra Velkt,
Profit and Loss Statement,Výkaz zisků a ztrát,
Cheque Number,Šek číslo,
Pressing,Stisknutt,
Payment Tool Detail,Detail platební nástroj,
Sales Browser,Sales Browser,
Total Credit,Celkový Credit,
Warning: Another {0} # {1} exists against stock entry {2},Upozornění: Dalším {0} # {1} existuje proti akciové vstupu {2}
Local,Místn$1,
Loans and Advances (Assets),Úvěrů a půjček (aktiva)
Debtors,Dlužníci,
Large,Velki,
No employee found!,Žádný zaměstnanec našel!
Territory,Územ$1,
Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
Default Valuation Method,Výchozí metoda oceněne,
Polishing,Leštěne,
Planned Start Time,Plánované Start Time,
Allocated,Přidělene,
Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
Specify Exchange Rate to convert one currency into another,Zadejte Exchange Rate převést jednu měnu na jinou,
Row{0}: Party Type and Party is only applicable against Receivable / Payable account,Row {0}: Type Party Party a je použitelná pouze na pohledávky / závazky účet,
Quotation {0} is cancelled,Nabídka {0} je zrušena,
Total Outstanding Amount,Celková dlužná částka,
Employee {0} was on leave on {1}. Cannot mark attendance.,Zaměstnanec {0} byl na dovolené na {1}. Nelze označit účast.
Targets,Cíle,
Price List Master,Ceník Master,
All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všechny prodejní transakce mohou být označeny proti více ** prodejcům **, takže si můžete nastavit a sledovat cíle."
S.O. No.,SO Ne.
Make Time Log,Udělejte si čas Přihlásit,
Please create Customer from Lead {0},Prosím vytvořte Zákazník z olova {0}
Computers,Počítače,
Electro-chemical grinding,Electro-chemické broušene,
This is a root customer group and cannot be edited.,"To je kořen skupiny zákazníků, a nelze upravovat."
Please setup your chart of accounts before you start Accounting Entries,"Prosím, nastavit svůj účtový rozvrh, než začnete účetních zápisů"
Ignore Pricing Rule,Ignorovat Ceny pravidlo,
Cancelled,Zrušeno,
Graduate,Absolvent,
Block Days,Blokové dny,
Excise Entry,Spotřební Entry,
"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.","Všeobecné obchodní podmínky, které mohou být přidány do prodejů a nákupů.

 Příklady: 

 1. Platnost nabídky.
 1. Platební podmínky (v předstihu, na úvěr, část zálohy atd.)
 1. Co je to další (nebo zaplatit zákazníkem).
 1. Bezpečnost / varování využití.
 1. Záruka, pokud existuje.
 1. Vrátí zásady.
 1. Podmínky přepravy, v případě potřeby.
 1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd 
 1. Adresa a kontakt na vaši společnost."
Leave Type,Leave Type,
Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
Accounts User,Uživatel Účt$1,
"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Zkontrolujte, zda je opakující se faktury, zrušte zaškrtnutí zastavit opakované nebo dát správné datum ukončení"
Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen,
If more than one package of the same type (for print),Pokud je více než jeden balík stejného typu (pro tisk)
Maximum {0} rows allowed,Maximálně {0} řádků povoleno,
Net Total,Net Total,
FCFS Rate,FCFS Rate,
Billing (Sales Invoice),Fakturace (Prodejní Faktura)
Outstanding Amount,Dlužné částky,
Working,Pracovny,
Stock Queue (FIFO),Sklad fronty (FIFO)
Please select Time Logs.,Vyberte Time Protokoly.
{0} does not belong to Company {1},{0} nepatří do Společnosti {1}
Requested Qty,Požadované množstv$1,
Scrap %,Scrap%
"Charges will be distributed proportionately based on item qty or amount, as per your selection","Poplatky budou rozděleny úměrně na základě položky Množství nebo částkou, dle Vašeho výběru"
Purposes,Cíle,
"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Provoz {0} déle, než všech dostupných pracovních hodin v pracovní stanici {1}, rozložit provoz do několika operací"
Electrochemical machining,Elektrochemické obráběny,
Requested,Požadovany,
No Remarks,Žádné poznámky,
Overdue,Zpožděny,
Stock Received But Not Billed,Sklad nepřijali Účtovany,
Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Gross Pay + nedoplatek Částka + Inkaso Částka - Total Odpočet,
Distribution Name,Distribuce Name,
Sales and Purchase,Prodej a nákup,
Price / Discount,Cena / Sleva,
Material Request No,Materiál Poptávka No,
Quality Inspection required for Item {0},Kontrola kvality potřebný k bodu {0}
Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou zákazník měny je převeden na společnosti základní měny"
Discount Amount (Company Currency),Částka slevy (Company Měna)
{0} has been successfully unsubscribed from this list.,{0} byl úspěšně odhlášen z tohoto seznamu.
Net Rate (Company Currency),Čistý Rate (Company měny)
Manage Territory Tree.,Správa Territory strom.
Sales Invoice,Prodejní faktury,
Party Balance,Balance Party,
Time Log Batch,Time Log Batch,
Please select Apply Discount On,"Prosím, vyberte Použít Sleva na"
Default Receivable Account,Výchozí pohledávek účtu,
Create Bank Entry for the total salary paid for the above selected criteria,Vytvoření bankovní položka pro celkové vyplacené mzdy za výše zvolených kritériu,
Item will be saved by this name in the data base.,Bod budou uloženy pod tímto jménem v databázi.
Material Transfer for Manufacture,Materiál Přenos: Výroba,
Discount Percentage can be applied either against a Price List or for all Price List.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.
Half-yearly,Pololetn$1,
Fiscal Year {0} not found.,Fiskální rok {0} nebyl nalezen.
Get Relevant Entries,Získat příslušné zápisy,
Accounting Entry for Stock,Účetní položka na sklady,
Coining,Raženy,
Sales Team1,Sales Team1,
Item {0} does not exist,Bod {0} neexistuje,
"Selecting ""Yes"" will allow you to make a Production Order for this item.","Výběrem ""Yes"" vám umožní, aby se výrobní zakázku pro tuto položku."
Customer Address,Zákazník Address,
Total,Celkem,
System for managing Backups,Systém pro správu zálohováns,
Root Type,Root Type,
Plot,Spiknuts,
Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky,
Item UOM,Položka UOM,
Tax Amount After Discount Amount (Company Currency),Částka daně po slevě Částka (Company měny)
Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
Quality Inspection,Kontrola kvality,
Extra Small,Extra Maly,
Spray forming,Spray tvářeny,
Warning: Material Requested Qty is less than Minimum Order Qty,Upozornění: Materiál Požadované množství je menší než minimální objednávka Množstvy,
Account {0} is frozen,Účet {0} je zmrazen,
Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Právní subjekt / dceřiná společnost s oddělenou Graf účtů, které patří do organizace."
Address master.,Adresa master.
"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
PL or BS,PL nebo BS,
Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100,
Minimum Inventory Level,Minimální úroveň zásob,
Subcontract,Subdodávka,
Get Items From Sales Orders,Získat položky z Prodejní Objednávky,
Actual End Time,Aktuální End Time,
Download Materials Required,Ke stažení potřebné materiály:
Manufacturer Part Number,Typové označeny,
Estimated Time and Cost,Odhadovná doba a náklady,
Bin,Popelnice,
Nosing,Zaoblená hrana,
No of Sent SMS,Počet odeslaných SMS,
Company,Společnost,
Expense Account,Účtet náklady,
Software,Software,
Colour,Barevny,
Scheduled,Plánovany,
Select Monthly Distribution to unevenly distribute targets across months.,Vyberte měsíční výplatou na nerovnoměrně distribuovat cílů napříč měsíců.
Valuation Rate,Ocenění Rate,
Check to make Shipping Address,Zaškrtněte pro vytvoření doručovací adresy,
Price List Currency not selected,Ceníková Měna není zvolena,
Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,"Bod Row {0}: doklad o koupi, {1} neexistuje v tabulce ""kupní příjmy"""
Applicability,Použitelnost,
Employee {0} has already applied for {1} between {2} and {3},Zaměstnanec {0} již požádal o {1} mezi {2} a {3}
Project Start Date,Datum zahájení projektu,
Until,Dokud,
Rename Log,Přejmenovat Přihlásit,
Against Document No,Proti dokumentu u,
Manage Sales Partners.,Správa prodejních partnerů.
Inspection Type,Kontrola Type,
Please select {0},"Prosím, vyberte {0}"
C-Form No,C-Form No,
Exploded_items,Exploded_items,
Researcher,Výzkumník,
Update,Aktualizovat,
Please save the Newsletter before sending,Uložte Newsletter před odesláním,
Name or Email is mandatory,Jméno nebo e-mail je povinno,
Incoming quality inspection.,Vstupní kontrola jakosti.
Exit,Východ,
Root Type is mandatory,Root Type je povinnd,
Serial No {0} created,Pořadové číslo {0} vytvořil,
Vibratory finishing,Vibrační dokončovacd,
"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pro pohodlí zákazníků, tyto kódy mohou být použity v tiskových formátech, jako na fakturách a dodacích listech"
Against Purchase Order,Proti vydané objednávce,
You can enter any date manually,Můžete zadat datum ručne,
Advertisement,Reklama,
Probationary Period,Zkušební doba,
Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci,
Expense Approver,Schvalovatel výdaje,
Purchase Receipt Item Supplied,Doklad o koupi Item Dodávane,
Pay,Platit,
To Datetime,Chcete-li datetime,
SMS Gateway URL,SMS brána URL,
Grinding,Broušene,
Shrink wrapping,Zmenšit balene,
Supplier > Supplier Type,Dodavatel> Dodavatel Type,
Please enter relieving date.,Zadejte zmírnění datum.
Amt,Amt,
Serial No {0} status must be 'Available' to Deliver,"Pořadové číslo {0} status musí být ""k dispozici"" doručovat"
Only Leave Applications with status 'Approved' can be submitted,"Nechte pouze aplikace s status ""schváleno"" může být předloženy"
Address Title is mandatory.,Adresa Název je povinný.
Enter name of campaign if source of enquiry is campaign,"Zadejte název kampaně, pokud zdroj šetření je kampaň"
Newspaper Publishers,Vydavatelé novin,
Select Fiscal Year,Vyberte Fiskální rok,
Smelting,Tavba rudy,
You are the Leave Approver for this record. Please Update the 'Status' and Save,"Jste Leave schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
Reorder Level,Změna pořadí Level,
Attendance Date,Účast Datum,
Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.
Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu,
Preferred Shipping Address,Preferovaná dodací adresa,
Accepted Warehouse,Schválené Sklad,
Posting Date,Datum zveřejněnu,
Valuation Method,Ocenění Method,
Sales Team,Prodejní tým,
Duplicate entry,Duplicitní záznam,
Under Warranty,V rámci záruky,
[Error],[Chyba]
In Words will be visible once you save the Sales Order.,"Ve slovech budou viditelné, jakmile uložíte prodejní objednávky."
Employee Birthday,Narozeniny zaměstnance,
Debit Amt,Debetní Amt,
Venture Capital,Venture Capital,
Must be Whole Number,Musí být celé číslo,
New Leaves Allocated (In Days),Nové Listy Přidělené (ve dnech)
Serial No {0} does not exist,Pořadové číslo {0} neexistuje,
Discount Percentage,Sleva v procentech,
Invoice Number,Číslo faktury,
Orders,Objednávky,
Employee Type,Type zaměstnance,
Leave Approver,Nechte schvalovae,
Swaging,Zužováne,
"A user with ""Expense Approver"" role","Uživatel s rolí ""Schvalovatel výdajů"""
Issued Items Against Production Order,Vydané předmětů proti výrobní zakázky,
Purchase Manager,Vedoucí nákupu,
Payment Tool,Platebního nástroje,
Target Detail,Target Detail,
% of materials billed against this Sales Order,% Materiálů fakturovaných proti tomuto odběrateli,
Period Closing Entry,Období Uzávěrka Entry,
Cost Center with existing transactions can not be converted to group,Nákladové středisko se stávajícími transakcemi nelze převést do skupiny,
Depreciation,Znehodnoceny,
Supplier(s),Dodavatel (é)
Payments received during the digest period,Platby přijaté během období digest,
Credit Limit,Úvěrový limit,
To enable <b>Point of Sale</b> features,Chcete-li povolit <b> Point of Sale </ b> funkce,
LR Date,LR Datum,
Select type of transaction,Vyberte typ transakce,
Voucher No,Voucher No,
Leave Allocation,Nechte Allocation,
'Update Stock' for Sales Invoice {0} must be set,"Musí být nastavena ""Aktualizace Skladu"" pro prodejní faktury {0}"
Material Requests {0} created,Materiál Žádosti {0} vytvořen$1,
Template of terms or contract.,Šablona podmínek nebo smlouvy.
Feedback,Zpětná vazba,
Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Z důvodu / Referenční datum překračuje povolené zákazníků úvěrové dní od {0} den (s)
Abrasive jet machining,Brusné jet obráběny,
Freeze Stock Entries,Freeze Stock Příspěvky,
Website Settings,Nastavení www stránky,
Billing Rate,Fakturace Rate,
Qty to Deliver,Množství k dodány,
Month,Měsíc,
Stock Analytics,Stock Analytics,
Against Document Detail No,Proti Detail dokumentu y,
Outgoing,Vycházejícy,
Requested For,Požadovaných pro,
Against Doctype,Proti DOCTYPE,
Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu,
Root account can not be deleted,Root účet nemůže být smazán,
Credit Amt,Credit Amt,
Show Stock Entries,Zobrazit Stock Příspěvky,
Work-in-Progress Warehouse,Work-in-Progress sklad,
Reference #{0} dated {1},Reference # {0} ze dne {1}
Item Code,Kód položky,
Material Manager,Materiál Správce,
Create Production Orders,Vytvoření výrobní zakázky,
Costing Rate (per hour),Kalkulace Rate (za hodinu)
Warranty / AMC Details,Záruka / AMC Podrobnosti,
User Remark,Uživatel Poznámka,
Point-of-Sale Setting,Nastavení Místa Prodeje,
Market Segment,Segment trhu,
Phone,Telefon,
Supplier (Payable) Account,Dodavatel (za poplatek) Account,
Employee Internal Work History,Interní historie práce zaměstnance,
Closing (Dr),Uzavření (Dr)
Passive,Pasivnm,
Serial No {0} not in stock,Pořadové číslo {0} není skladem,
Tax template for selling transactions.,Daňové šablona na prodej transakce.
Write Off Outstanding Amount,Odepsat dlužné částky,
"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Zkontrolujte, zda potřebujete automatické opakující faktury. Po odeslání jakékoliv prodejní fakturu, opakující se část bude viditelný."
Accounts Manager,Accounts Manager,
Time Log {0} must be 'Submitted',"Time Log {0} musí být ""Odesláno"""
Default Stock UOM,Výchozí Skladem UOM,
Create Material Requests,Vytvořit Žádosti materiálu,
School/University,Škola / University,
Available Qty at Warehouse,Množství k dispozici na skladu,
Billed Amount,Fakturovaná částka,
Bank Reconciliation,Bank OdsouhlasenM,
Total Amount To Pay,Celková částka k Zaplatit,
Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena,
Groups,Skupiny,
Group by Account,Seskupit podle účtu,
Fully Delivered,Plně Dodáno,
Lower Income,S nižšími příjmy,
"The account head under Liability, in which Profit/Loss will be booked","Účet hlavu pod odpovědnosti, ve kterém se bude Zisk / ztráta rezervovali"
Against Vouchers,Proti Poukázky,
Quick Help,Rychlá pomoc,
Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
Sales Extras,Prodejní Extras,
{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} rozpočt na účet {1} proti nákladovému středisku {2} bude vyšší o {3}
Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0}
Carry Forwarded Leaves,Carry Předáno listy,
'From Date' must be after 'To Date',"""Datum DO"" musí být po ""Datum OD"""
Stock Projected Qty,Reklamní Plánovaná POČET,
Customer {0} does not belong to project {1},Zákazník {0} nepatří k projektu {1}
From Company,Od Společnosti,
Value or Qty,Hodnota nebo Množstvi,
Minute,Minuta,
Purchase Taxes and Charges,Nákup Daně a poplatky,
Upload Backups to Dropbox,Nahrát zálohy na Dropbox,
Qty to Receive,Množství pro příjem,
Leave Block List Allowed,Nechte Block List povolena,
Conversion factor cannot be in fractions,Konverzní faktor nemůže být ve zlomcích,
You will use it to Login,Budete ho používat k přihlášeni,
Retailer,Maloobchodník,
All Supplier Types,Všechny typy Dodavatele,
Item Code is mandatory because Item is not automatically numbered,"Kód položky je povinné, protože položka není automaticky číslovány"
Quotation {0} not of type {1},Nabídka {0} není typu {1}
Maintenance Schedule Item,Plán údržby Item,
%  Delivered,% Dodáno,
Bank Overdraft Account,Kontokorentní úvěr na účtu,
Make Salary Slip,Proveďte výplatní pásce,
Unstop,Uvolnit,
Secured Loans,Zajištěné úvěry,
Ignored:,Ignorovat: 
{0} cannot be purchased using Shopping Cart,{0} není možné zakoupit pomocí Nákupní košík,
Awesome Products,Skvělé produkty,
Opening Balance Equity,Počáteční stav Equity,
Cannot approve leave as you are not authorized to approve leaves on Block Dates,Nelze schválit dovolenou si nejste oprávněna schvalovat listy na blok Termíny,
Appraisal,Oceněnk,
Lost-foam casting,Lost-pěna litk,
Drawing,Výkres,
Date is repeated,Datum se opakuje,
Leave approver must be one of {0},Nechte Schvalující musí být jedním z {0}
Seller Email,Prodávající E-mail,
Total Purchase Cost (via Purchase Invoice),Celkové pořizovací náklady (přes nákupní faktury)
Start Time,Start Time,
Select Quantity,Zvolte množstve,
"Specify a list of Territories, for which, this Taxes Master is valid","Zadejte seznam území, pro které tato Daně Master je platný"
Approving Role cannot be same as role the rule is Applicable To,Schválení role nemůže být stejná jako role pravidlo se vztahuje na,
Message Sent,Zpráva byla odeslána,
SO Date,SO Datum,
Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny"
Net Amount (Company Currency),Čistá částka (Company Měna)
Hour Rate,Hour Rate,
Item Naming By,Položka Pojmenování By,
From Quotation,Z nabídky,
Another Period Closing Entry {0} has been made after {1},Další období Uzávěrka Entry {0} byla podána po {1}
Material Transferred for Manufacturing,Materiál Přenesená pro výrobu,
Account {0} does not exists,Účet {0} neexistuje,
Purchase Order Item No,Číslo položky vydané objednávky,
System Settings,Nastavení systému,
Project Type,Typ projektu,
Either target qty or target amount is mandatory.,Buď cílové množství nebo cílová částka je povinná.
Cost of various activities,Náklady na různých aktivit,
Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0}
Inspection Required,Kontrola Povinnl,
PR Detail,PR Detail,
Fully Billed,Plně Fakturovanl,
Cash In Hand,Pokladní hotovost,
The gross weight of the package. Usually net weight + packaging material weight. (for print),Celková hmotnost balení. Obvykle se čistá hmotnost + obalového materiálu hmotnosti. (Pro tisk)
Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uživatelé s touto rolí se mohou nastavit na zmrazené účty a vytvořit / upravit účetní zápisy proti zmrazených účto,
Is Cancelled,Je Zrušeno,
My Shipments,Moje dodávky,
Bill Date,Bill Datum,
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:"
Supplier Details,Dodavatele Podrobnosti,
Recipients,Příjemci,
Screwing,Šroubováni,
Knurling,Vroubkováni,
Approval Status,Stav schváleni,
Publish Items to Hub,Publikování položky do Hub,
From value must be less than to value in row {0},Z hodnota musí být menší než hodnota v řadě {0}
Wire Transfer,Bankovní převod,
Please select Bank Account,"Prosím, vyberte bankovní účet"
Create and Send Newsletters,Vytvoření a odeslání Zpravodaje,
From Date must be before To Date,Datum od musí být dříve než datum do,
Recurring Order,Opakující se objednávky,
Default Income Account,Účet Default příjme,
Customer Group / Customer,Zákazník Group / Customer,
Check this if you want to show in website,"Zaškrtněte, pokud chcete zobrazit v webové stránky"
Welcome to ERPNext,Vítejte na ERPNext,
Voucher Detail Number,Voucher Detail Počet,
From Customer,Od Zákazníka,
Calls,Volt,
Total Costing Amount (via Time Logs),Celková kalkulace Částka (přes Time Záznamy)
Stock UOM,Reklamní UOM,
Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána,
{0} {1} is entered more than once in Item Variants table,{0} {1} je vloženo více než jednou v  tabulce Varianty  Položky,
Projected,PlánovanM,
Serial No {0} does not belong to Warehouse {1},Pořadové číslo {0} nepatří do skladu {1}
Note: Reference Date exceeds allowed credit days by {0} days for {1} {2},Poznámka: Odkaz Datum překračuje povolené úvěrové dnů od {0} dní na {1} {2}
Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Poznámka: Systém nebude kontrolovat přes dobírku a over-rezervace pro item {0} jako množství nebo částka je 0,
Quotation Message,Zpráva Nabídky,
Opening Date,Datum otevřen0,
POS Setting {0} already created for user: {1} and company {2},POS nastavení {0} již vytvořili pro uživatele: {1} a společnost {2}
Remark,Poznámka,
Rate and Amount,Tempo a rozsah,
Boring,Nudna,
From Sales Order,Z přijaté objednávky,
Parent Website Route,nadřazená cesta internetové stránky,
Not Billed,Ne Účtovana,
Both Warehouse must belong to same Company,Oba Sklady musí patřit do stejné společnosti,
No contacts added yet.,Žádné kontakty přidán dosud.
Not active,Neaktivna,
Against Invoice Posting Date,Proti faktury Datum zveřejněna,
Landed Cost Voucher Amount,Přistál Náklady Voucher Částka,
Batched for Billing,Zarazeno pro fakturaci,
Bills raised by Suppliers.,Směnky vznesené dodavately,
Write Off Account,Odepsat účet,
Discount Amount,Částka slevy,
Warranty Period (in days),Záruční doba (ve dnech)
Expenses booked for the digest period,Náklady rezervované pro období digest,
e.g. VAT,např. DPH,
Journal Entry Account,Zápis do deníku Účet,
Quotation Series,Číselná řada nabídek,
"An item exists with same name ({0}), please change the item group name or rename the item","Položka existuje se stejným názvem ({0}), prosím, změnit název skupiny položky nebo přejmenovat položku"
Hot metal gas forming,Tváření Hot metal plyn,
Sales Order Date,Prodejní objednávky Datum,
Delivered Qty,Dodává Množstvn,
Warehouse {0}: Company is mandatory,Sklad {0}: Společnost je povinnn,
Percentage variation in quantity to be allowed while receiving or delivering this item.,"Procentuální změna v množství, aby mohla při přijímání nebo poskytování této položky."
Shopping Cart Taxes and Charges Master,Nákupní košík daně a poplatky Mistr,
"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",Přejděte na příslušné skupiny (obvykle zdrojem finančních prostředků&gt; krátkodobých závazků&gt; daní a poplatků a vytvořit nový účet (kliknutím na Přidat dítě) typu &quot;daně&quot; a to nemluvím o daňovou sazbu.
Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury,
Missing Currency Exchange Rates for {0},Chybí Směnárna Kurzy pro {0}
Laser cutting,Laserové řezány,
Monday,Ponděly,
Stock Entry,Reklamní Entry,
Payable,Splatny,
Arrear Amount,Nedoplatek Částka,
New Customers,Noví zákazníci,
Gross Profit %,Hrubý Zisk %
Weightage (%),Weightage (%)
Clearance Date,Výprodej Datum,
Newsletter List,Newsletter Seznam,
Check if you want to send salary slip in mail to each employee while submitting salary slip,"Zkontrolujte, zda chcete poslat výplatní pásku za poštou na každého zaměstnance při předkládání výplatní pásku"
Address Desc,Popis adresy,
Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena,
"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Rozdíl účet musí být ""Odpovědnost"" typ účtu, protože tento Reklamní Usmíření je Entry Otevření"
"Variants can not be created manually, add item attributes in the template item","Varianty nelze vytvořit ručně, přidejte atributy položku v položce šablony"
Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny."
All,Vše,
Source Warehouse,Zdroj Warehouse,
Installation Date,Datum instalace,
Confirmation Date,Potvrzení Datum,
Total Invoiced Amount,Celkem Fakturovaná částka,
Sales User,Uživatel prodeje,
Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množstve,
Set,Nastavit,
Warehouse-wise Reorder Levels,Změna Úrovně dle skladu,
Lead Owner,Olovo Majitel,
Warehouse is required,Je zapotřebí Warehouse,
Marital Status,Rodinný stav,
Auto Material Request,Auto materiálu Poptávka,
Will be updated when billed.,Bude aktualizována při účtovány.
Current BOM and New BOM can not be same,Aktuální BOM a New BOM nemůže být stejn$1,
Date Of Retirement must be greater than Date of Joining,"Datum odchodu do důchodu, musí být větší než Datum spojování"
Against Income Account,Proti účet příjmo,
{0}% Delivered,{0}% vyhlášeno,
Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množství {1} nemůže být nižší než minimální Objednané množství {2} (definované v bodu).
Monthly Distribution Percentage,Měsíční Distribution Procento,
Territory Targets,Území Cíle,
Transporter Info,Transporter Info,
Purchase Order Item Supplied,Dodané položky vydané objednávky,
Letter Heads for print templates.,Dopis hlavy na tiskových šablon.
Titles for print templates e.g. Proforma Invoice.,"Tituly na tiskových šablon, např zálohové faktury."
Valuation type charges can not marked as Inclusive,Poplatky typu ocenění může není označen jako Inclusive,
Update Stock,Aktualizace skladem,
Superfinishing,Superfinišováne,
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.,"Různé UOM položky povede k nesprávné (celkem) Čistá hmotnost hodnoty. Ujistěte se, že čistá hmotnost každé položky je ve stejném nerozpuštěných."
BOM Rate,BOM Rate,
"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Přidat / Upravit </a>"
Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojeny,
Terms,Podmínky,
Create New,Vytvořit novy,
Purchase Order Required,Vydaná objednávka je vyžadována,
Item-wise Sales History,Item-moudrý Sales History,
Total Sanctioned Amount,Celková částka potrestána,
Purchase Analytics,Nákup Analytika,
Delivery Note Item,Delivery Note Item,
Task,Úkol,
Shaving,Holeny,
Reference Row #,Referenční Row #
Batch number is mandatory for Item {0},Číslo šarže je povinné pro položku {0}
This is a root sales person and cannot be edited.,To je kořen prodejní člověk a nelze upravovat.
Stock Ledger,Reklamní Ledger,
Salary Slip Deduction,Plat Slip Odpočet,
"To set reorder level, item must be a Purchase Item","Chcete-li nastavit úroveň Objednací, položka musí být Nákup položky"
Notes,Poznámky,
From,Od,
Select a group node first.,Vyberte první uzel skupinu.
Purpose must be one of {0},Cíl musí být jedním z {0}
Fill the form and save it,Vyplňte formulář a uložte jej,
Download a report containing all raw materials with their latest inventory status,"Stáhněte si zprávu, která obsahuje všechny suroviny s jejich aktuální stav zásob"
Facing,ObloženS,
Leave Balance Before Application,Nechte zůstatek před aplikacS,
Send SMS,Pošlete SMS,
Default Letter Head,Výchozí hlavičkovS,
Billable,ZúčtovatelnS,
This will be used for setting rule in HR module,Tato adresa bude použita pro nastavení pravidlo HR modul,
Rate at which this tax is applied,"Rychlost, při které se používá tato daň"
Reorder Qty,Změna pořadí Množstvu,
Stock Adjustment Account,Reklamní Nastavení účtu,
Write Off,Odepsat,
Operation ID,Provoz ID,
"System User (login) ID. If set, it will become default for all HR forms.","System User (login) ID. Pokud je nastaveno, stane se výchozí pro všechny formy HR."
{0}: From {1},{0}: Z {1}
depends_on,záleží na,
Opportunity Lost,Příležitost Ztracena,
"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Sleva Pole bude k dispozici v objednávce, doklad o koupi, nákupní faktury"
Report Type,Typ výpisu,
Loading,Nahrávám,
BOM Replace Tool,BOM Nahradit Tool,
Country wise default Address Templates,Země moudrý výchozí adresa Templates,
Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
If you involve in manufacturing activity. Enables Item 'Is Manufactured',"Pokud se zapojit do výrobní činnosti. Umožňuje Položka ""se vyrábí"""
Rounded Total,Zaoblený Total,
List items that form the package.,"Seznam položek, které tvoří balíček."
Percentage Allocation should be equal to 100%,Podíl alokace by měla být ve výši 100%
Out of AMC,Out of AMC,
Material Request Detail No,Materiál Poptávka Detail No,
Hard turning,Hard soustruženC,
Make Maintenance Visit,Proveďte návštěv údržby,
Please contact to the user who have Sales Master Manager {0} role,"Prosím, kontaktujte pro uživatele, kteří mají obchodní manažer ve skupině Master {0} roli"
Default Cash Account,Výchozí Peněžní účet,
Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
Please enter 'Expected Delivery Date',"Prosím, zadejte ""Očekávaná Datum dodání"""
"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Seznam své daňové hlavy (např DPH, spotřební daň, měli by mít jedinečné názvy) a jejich standardní sazby. Tím se vytvoří standardní šablonu, kterou si můžete upravit a přidat další později."
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dodací listy {0} musí být zrušena před zrušením této prodejní objednávky,
Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total,
{0} is not a valid Batch Number for Item {1},{0} není platná Šarže pro Položku {1}
Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
"Note: If payment is not made against any reference, make Journal Entry manually.","Poznámka: Není-li platba provedena proti jakémukoli rozhodnutí, jak položka deníku ručně."
Supplier Items,Dodavatele položky,
Please enter atleast one attribute row in Item Variants table,Zadejte prosím aspoň jeden atribut řádek položky Varianty tabulku,
Opportunity Type,Typ Příležitosti,
New Company,Nová společnost,
Cost Center is required for 'Profit and Loss' account {0},"Nákladové středisko je vyžadováno pro účet ""výkaz zisku a ztrát"" {0}"
Transactions can only be deleted by the creator of the Company,Transakce mohou být vymazány pouze tvůrce Společnosti,
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nesprávný počet hlavní knihy záznamů nalezen. Pravděpodobně jste zvolili nesprávný účet v transakci.
To create a Bank Account,Chcete-li vytvořit si účet v bance,
Publish Availability,Publikování Dostupnost,
Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.
Stock Ageing,Reklamní Stárnuty,
Automatically updated from BOM table,Automaticky aktualizována z BOM tabulky,
{0} '{1}' is disabled, {0} '{1}' je zakázána,
Set as Open,Nastavit jako Otevřít,
Send automatic emails to Contacts on Submitting transactions.,Posílat automatické e-maily na Kontakty na předložení transakcí.
"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
					Available Qty: {4}, Transfer Qty: {5}","Row {0}: Množství nejsou dostupné iv skladu {1} na {2} {3}.
 Dispozici Množství: {4}, transfer Množství: {5}"
Sync with Dropbox,Synchronizace s Dropbox,
Sunday,Neděle,
Contribution (%),Příspěvek (%)
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Položka Platba nebude vytvořili, protože ""v hotovosti nebo bankovním účtu"" nebyl zadán"
Responsibilities,Odpovědnost,
Template,Šablona,
Sales Person Name,Prodej Osoba Name,
Please enter atleast 1 invoice in the table,Zadejte prosím aspoň 1 fakturu v tabulce,
Item Group,Položka Group,
Actual Start Date (via Time Logs),Skutečné datum Start (přes Time Záznamy)
Before reconciliation,Před smířen$1,
To {0},Chcete-li {0}
Taxes and Charges Added (Company Currency),Daně a poplatky Přidal (Company měna)
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Položka Tax Row {0} musí mít účet typu daní či výnosů nebo nákladů, nebo Vyměřovací"
Partly Billed,Částečně ÚčtovanM,
Default BOM,Výchozí BOM,
Decambering,Decambering,
Please re-type company name to confirm,Prosím re-typ název společnosti na potvrzenM,
Total Outstanding Amt,Celkem Vynikající Amt,
Total Hours,Celkem hodin,
Total Debit must be equal to Total Credit. The difference is {0},Celkové inkaso musí rovnat do celkového kreditu. Rozdíl je {0}
Automotive,Automobilov$1,
Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Listy typu {0} již přidělené pro zaměstnance {1} pro fiskální rok {0}
Item is required,Položka je povinnu,
Metal injection molding,Kovové vstřikovánu,
From Delivery Note,Z Dodacího Listu,
From Time,Času od,
Custom Message,Custom Message,
Investment Banking,Investiční bankovnictvu,
"Select your Country, Time Zone and Currency","Vyberte svou zemi, časové pásmo a měnu"
Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního,
{0} {1} status is Unstopped,{0} {1} status je OdZastaveno,
Price List Exchange Rate,Katalogová cena Exchange Rate,
Pickling,Mořeno,
Sand casting,Lití do písku,
Electroplating,Electroplating,
Rate,Rychlost,
Intern,Internovat,
A Lead with this email id should exist,Lead s touto e-mailovou id by měla již existovat,
From BOM,Od BOM,
Billing Rate (per hour),Účtování Rate (za hodinu)
Basic,Základny,
Stock transactions before {0} are frozen,Fotky transakce před {0} jsou zmrazeny,
Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule"""
To Date should be same as From Date for Half Day leave,Chcete-li data by měla být stejná jako u Datum od půl dne volno,
"e.g. Kg, Unit, Nos, m","např Kg, ks, č, m"
Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni"
Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narozena,
Salary Structure,Plat struktura,
"Multiple Price Rule exists with same criteria, please resolve \
			conflict by assigning priority. Price Rules: {0}","Multiple Cena existuje pravidlo se stejnými kritérii, prosím vyřešit \
 konflikt přiřazením prioritu. Cena Pravidla: {0}"
Bank,Banka,
Airline,Letecká linka,
Issue Material,Vydání Material,
For Warehouse,Pro Sklad,
Offer Date,Nabídka Date,
Access Token,Přístupový Token,
Serial No,Výrobní číslo,
Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti"
Is Fixed Asset Item,Je dlouhodobého majetku Item,
Including items for sub assemblies,Včetně položek pro podsestav,
"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Máte-li dlouhé formáty tisku, tato funkce může být použita k rozdělení stránku se bude tisknout na více stránek se všemi záhlaví a zápatí na každé straně"
Hobbing,Odvalovace,
All Territories,Všechny územe,
Party Type Name,Typ Party Name,
Items,Položky,
Year Name,Jméno roku,
Process Payroll,Proces Payroll,
There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
Sales Partner Name,Sales Partner Name,
Image View,Image View,
Finishing & industrial finishing,Povrchová úprava a průmyslového zpracováne,
Opening Time,Otevírací doba,
From and To dates required,Data OD a DO jsou vyžadována,
Securities & Commodity Exchanges,Cenné papíry a komoditních burzách,
Calculate Based On,Vypočítat založené na,
Drilling,Vrtáne,
Blow molding,Vyfukováne,
Valuation and Total,Oceňování a Total,
This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,"Tento bod je varianta {0} (šablony). Atributy budou zkopírovány z šablony, pokud je nastaveno ""No Copy"""
Purchase User,Nákup Uživatel,
Customer's Purchase Order Number,Zákazníka Objednávka číslo,
Customize the Notification,Přizpůsobit oznámenl,
Hammering,Vyklepánl,
Slideshow,Promítání obrázkl,
Default Address Template cannot be deleted,Výchozí šablony adresy nemůže být smazán,
Shipping Rule,Přepravní Pravidlo,
Print Heading,Tisk záhlavl,
Maintenance Manager,Správce údržby,
Search,Hledat,
Total cannot be zero,Celkem nemůže být nula,
'Days Since Last Order' must be greater than or equal to zero,"""Dny od posledního Objednávky"" musí být větší nebo rovny nule"
Brazing,Pájena,
Amended From,Platném zněna,
Raw Material,Surovina,
Follow via Email,Sledovat e-mailem,
Tax Amount After Discount Amount,Částka daně po slevě Částka,
Child account exists for this account. You can not delete this account.,Dětské konto existuje pro tento účet. Nemůžete smazat tento účet.
Either target qty or target amount is mandatory,Buď cílové množství nebo cílová částka je povinn$1,
No default BOM exists for Item {0},No default BOM existuje pro bod {0}
Carry Forward,Převádět,
Cost Center with existing transactions can not be converted to ledger,Nákladové středisko se stávajícími transakcemi nelze převést na hlavní účetní knihy,
Days for which Holidays are blocked for this department.,"Dnů, po které Prázdniny jsou blokovány pro toto oddělení."
Produced,Produkoval,
Raised By (Email),Vznesené (e-mail)
General,Obecn$1,
Attach Letterhead,Připojit Hlavičkov$1,
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
Bank Entry,Bank Entry,
Applicable To (Designation),Vztahující se na (označení)
Blog Post,Příspěvek blogu,
Add to Cart,Přidat do košíku,
Group By,Seskupit podle,
Enable / disable currencies.,Povolit / zakázat měny.
Postal Expenses,Poštovní náklady,
Total(Amt),Total (Amt)
Entertainment & Leisure,Entertainment & Leisure,
The date on which recurring order will be stop,"Datum, ke kterému se opakující objednávka bude zastaví"
Item Serial No,Položka Výrobní číslo,
{0} must be reduced by {1} or you should increase overflow tolerance,{0} musí být sníženy o {1} nebo byste měli zvýšit toleranci přesahu,
Total Present,Celkem Present,
Hour,Hodina,
"Serialized Item {0} cannot be updated \
					using Stock Reconciliation","Serialized Položka {0} nelze aktualizovat \
 pomocí Reklamní Odsouhlasení"
Transfer Material to Supplier,Přeneste materiál Dodavateli,
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,"New Pořadové číslo nemůže mít Warehouse. Warehouse musí být nastaveny Stock vstupním nebo doklad o koupi,"
Lead Type,Lead Type,
Create Quotation,Vytvořit Citace,
All these items have already been invoiced,Všechny tyto položky již byly fakturovány,
Can be approved by {0},Může být schválena {0}
Shipping Rule Conditions,Přepravní Článek Podmínky,
The new BOM after replacement,Nový BOM po výměny,
Point of Sale,Místo Prodeje,
Curling,Metany,
Tax,Day,
Row {0}: {1} is not a valid {2},Řádek {0}: {1} není platný {2}
Refining,Rafinace,
Production Planning Tool,Plánování výroby Tool,
Report Date,Datum Reportu,
Routing,Směrováne,
Invoices,Faktury,
Job Title,Název pozice,
{0} Recipients,{0} příjemci,
Item Groups in Details,Položka skupiny v detailech,
Expense Account is mandatory,Účtet nákladů je povinne,
Start Point-of-Sale (POS),Start Point-of-Sale (POS)
A new variant (Item) will be created for each attribute value combination,Nová varianta (položka) se vytvoří pro každou kombinaci hodnoty atributu,
Visit report for maintenance call.,Navštivte zprávu pro volání údržby.
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.,"Procento máte možnost přijímat nebo dodávat více proti objednaného množství. Například: Pokud jste si objednali 100 kusů. a váš příspěvek je 10%, pak máte možnost získat 110 jednotek."
Customer Group,Zákazník Group,
Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
Website Description,Popis webu,
AMC Expiry Date,AMC Datum vypršení platnosti,
Sales Register,Sales Register,
Quotation Lost Reason,Důvod ztráty nabídky,
Plant,Rostlina,
Setup,Nastavenu,
There is nothing to edit.,Není nic upravovat.
Cold rolling,Válcování za studena,
Customer Group Name,Zákazník Group Name,
Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1}
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Prosím, vyberte převádět pokud chcete také zahrnout uplynulý fiskální rok bilance listy tohoto fiskálního roku"
Against Voucher Type,Proti poukazu typu,
POS Setting,POS Nastavenu,
Get Items,Získat položky,
Please enter Write Off Account,"Prosím, zadejte odepsat účet"
Image,Obrázek,
Make Excise Invoice,Proveďte Spotřební faktury,
Make Packing Slip,Proveďte dodacím listem,
Other,Ostatnk,
C-Form,C-Form,
Operation ID not set,Provoz ID není nastaveno,
Planned Start Date,Plánované datum zahájenk,
Creation Document Type,Tvorba Typ dokumentu,
Is Encash,Je inkasovat,
Mobile No,Mobile No,
Make Journal Entry,Proveďte položka deníku,
New Leaves Allocated,Nové Listy Přidělenk,
Project-wise data is not available for Quotation,Data dle projektu nejsou k dispozici pro nabídku,
Expected End Date,Očekávané datum ukončenk,
Appraisal Template Title,Posouzení Template Název,
Commercial,Obchodnk,
Distribution Id,Distribuce Id,
Awesome Services,Skvělé služby,
All Products or Services.,Všechny výrobky nebo služby.
Supplier Address,Dodavatel Address,
Address Line 2,Adresní řádek 2,
Reference,reference,
Perforating,Perforujícs,
Out Qty,Out Množstvs,
Rules to calculate shipping amount for a sale,Pravidla pro výpočet výše přepravní na prodej,
Series is mandatory,Série je povinns,
Financial Services,Finanční služby,
Sales,Prodej,
Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0}
Cr,Cr,
Default Receivable Accounts,Výchozí pohledávka účty,
Sawing,Řezánr,
Laminating,Laminovánr,
Transfer,Převod,
Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin)
Applicable To (Employee),Vztahující se na (Employee)
Sintering,SpékánZ,
Pay To / Recd From,Platit K / Recd Z,
Setup Series,Řada Setup,
Contact HTML,Kontakt HTML,
Purchase Receipts,Příjmky,
Maximum Amount,Maximální částka,
How Pricing Rule is applied?,Jak Ceny pravidlo platí?
Delivery Note No,Dodacího listu,
Retail,Maloobchodnu,
Customer {0} does not exist,Zákazník {0} neexistuje,
Absent,Nepřítomnu,
Crushing,Zdrcujícu,
Purchase Taxes and Charges Template,Kupte Daně a poplatky šablony,
Download Template,Stáhnout šablonu,
Remarks,Poznámky,
Raw Material Item Code,Surovina Kód položky,
Write Off Based On,Odepsat založené na,
POS View,Zobrazení POS,
Installation record for a Serial No.,Instalace rekord pro sériové číslo,
Continuous casting,Kontinuální litu,
Please specify a,Uveďte prosím,
Make Purchase Invoice,Proveďte nákupní faktury,
Awaiting Response,Čeká odpověu,
Cold sizing,Cold velikosti,
Earning & Deduction,Výdělek a dedukce,
Account {0} cannot be a Group,Účet {0} nemůže být skupina,
Region,Kraj,
Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.
Negative Valuation Rate is not allowed,Negativní ocenění Rate není povoleno,
Weekly Off,Týdenní Off,
"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
Dropbox,Dropbox,
Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit)
Please set default value {0} in Company {1},Prosím nastavte výchozí hodnotu {0} ve společnosti {1}
Creation Time,Čas vytvořenm,
Total Revenue,Celkový příjem,
Monthly Attendance Sheet,Měsíční Účast Sheet,
No record found,Nebyl nalezen žádný záznam,
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové středisko je povinná k položce {2}
Account {0} is inactive,Účet {0} je neaktivn$1,
Is Advance,Je Zálohov$1,
Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinn$1,
Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
Contact No.,Kontakt Číslo,
'Profit and Loss' type account {0} not allowed in Opening Entry,"""Výkaz zisku a ztráty"" typ účtu {0} není povoleno pro Vstupní Údaj"
Time,Čas,
Sales Discounts,Prodejní Slevy,
Seller Country,Prodejce Country,
Authorization Rule,Autorizační pravidlo,
Terms and Conditions Details,Podmínky podrobnosti,
Specifications,Specifikace,
Sales Taxes and Charges Template,Prodej Daně a poplatky šablony,
Apparel & Accessories,Oblečení a doplňky,
"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Povinný, pokud skladem, je ""Ano"". Také výchozí sklad, kde je vyhrazeno množství nastavena od odběratele."
Number of Order,Číslo objednávky,
HTML / Banner that will show on the top of product list.,"HTML / Banner, které se zobrazí na první místo v seznamu výrobků."
Specify conditions to calculate shipping amount,Stanovení podmínek pro vypočítat výši poštovného,
Add Child,Přidat díto,
Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky,
Cannot convert Cost Center to ledger as it has child nodes,"Nelze převést nákladového střediska na knihy, protože má podřízené uzly"
Conversion Factor is required,Je nutná konverzní faktor,
Serial #,Serial #
Commission on Sales,Provize z prodeje,
Value / Description,Hodnota / Popis,
Customers Not Buying Since Long Time,Zákazníci nekupujete Po dlouhou dobu,
Expected Delivery Date,Očekávané datum dodáne,
Bulging,Vyboulene,
Evaporative-pattern casting,Lití Evaporative-pattern,
Entertainment Expenses,Výdaje na reprezentaci,
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktury {0} musí být zrušena před zrušením této prodejní objednávky,
Age,Věk,
Billing Amount,Fakturace Částka,
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Neplatný množství uvedené na položku {0}. Množství by mělo být větší než 0.
Applications for leave.,Žádosti o dovolenou.
Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán,
Legal Expenses,Výdaje na právní služby,
"The day of the month on which auto order will be generated e.g. 05, 28 etc","Den měsíce, ve kterém auto objednávka bude generován například 05, 28 atd"
Posting Time,Čas zadány,
% Amount Billed,% Fakturované částky,
Telephone Expenses,Telefonní Náklady,
Logo,Logo,
{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} sériová čísla potřebné k položce {0}. Pouze {0} vyplněno.
Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Zaškrtněte, pokud chcete, aby uživateli vybrat sérii před uložením. Tam bude žádná výchozí nastavení, pokud jste zkontrolovat."
No Item with Serial No {0},No Položka s Serial č {0}
Direct Expenses,Přímé náklady,
Do you really want to UNSTOP this Material Request?,Opravdu chcete uvolnit tento materiál požadavek?
New Customer Revenue,Nový zákazník Příjmy,
Travel Expenses,Cestovní výdaje,
Breakdown,Rozbor,
Cheque Date,Šek Datum,
Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
Successfully deleted all transactions related to this company!,Úspěšně vypouští všechny transakce související s tímto společnosti!
Honing,Honován$1,
"Only Serial Nos with status ""Available"" can be delivered.","Serial pouze Nos se statusem ""K dispozici"" může být dodán."
Probation,Zkouška,
Default Warehouse is mandatory for stock Item.,Výchozí Sklad je povinný pro živočišnou položky.
Full Name,Celé jméno/název,
Clinching,Clinching,
Payment of salary for the month {0} and year {1},Platba platu za měsíc {0} a rok {1}
Total Paid Amount,Celkem uhrazené částky,
Debit and Credit not equal for this voucher. Difference is {0}.,Debetní a kreditní nerovná této voucheru. Rozdíl je {0}.
Transferred Qty,Přenesená Množstvh,
Planning,Plánovánh,
Make Time Log Batch,Udělejte si čas Log Batch,
Total Billing Amount (via Time Logs),Celkem Billing Částka (přes Time Záznamy)
We sell this Item,Nabízíme k prodeji tuto položku,
Supplier Id,Dodavatel Id,
Cash Entry,Cash Entry,
Contact Desc,Kontakt Popis,
Item Variants {0} created,Bod Varianty {0} vytvořil,
"Type of leaves like casual, sick etc.","Typ ponechává jako neformální, nevolnosti atd."
Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.
Add rows to set annual budgets on Accounts.,Přidat řádky stanovit roční rozpočty na účtech.
Default Supplier Type,Výchozí typ Dodavatel,
Quarrying,Těžba,
Total Operating Cost,Celkové provozní náklady,
Note: Item {0} entered multiple times,Poznámka: Položka {0} vstoupil vícekrát,
All Contacts.,Všechny kontakty.
Test Email Id,Testovací Email Id,
Company Abbreviation,Zkratka Company,
If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,"Pokud se budete řídit kontroly jakosti. Umožňuje položky QA požadovány, a QA No v dokladu o koupi"
Party Type,Typ Party,
Raw material cannot be same as main Item,Surovina nemůže být stejný jako hlavní bod,
Abbreviation,Zkratka,
Not authroized since {0} exceeds limits,Není authroized od {0} překročí limity,
Rotational molding,Rotační tvářeny,
Salary template master.,Plat master šablona.
Max Days Leave Allowed,Max Days Leave povolena,
Set Matching Amounts,Nastavit Odpovídající Částky,
Taxes and Charges Added,Daně a poplatky přidana,
Sales Funnel,Prodej Nálevka,
Cart,Vozík,
Qty to Transfer,Množství pro přenos,
Quotes to Leads or Customers.,Nabídka pro Lead nebo pro Zákazníka,
Role Allowed to edit frozen stock,Role povoleno upravovat zmrazené zásoby,
Territory Target Variance Item Group-Wise,Území Cílová Odchylka Item Group-Wise,
All Customer Groups,Všechny skupiny zákazníka,
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen Měnový Směnný záznam pro {1} až {2}.
Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje,
Price List Rate (Company Currency),Ceník Rate (Company měny)
{0} {1} status is 'Stopped',"{0} {1} status je ""Zastaveno"""
Temporary,Dočasna,
Preferred Billing Address,Preferovaná Fakturační Adresa,
Percentage Allocation,Procento přidělena,
Secretary,Sekretářka,
Distinct unit of an Item,Samostatnou jednotku z položky,
Item master.,Master Item.
Buying,Nákupy,
Employee Records to be created by,"Zaměstnanec Záznamy, které vytvořil"
This Time Log Batch has been cancelled.,To Batch Time Log byla zrušena.
Apply Discount On,Použít Sleva na,
Salary Slip Earning,Plat Slip Zisk,
Creditors,Věřitela,
Item Wise Tax Detail,Položka Wise Tax Detail,
Item-wise Price List Rate,Item-moudrý Ceník Rate,
Supplier Quotation,Dodavatel Nabídka,
In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
Ironing,Žehlenn,
{0} {1} is stopped,{0} {1} je zastaven,
Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
Add to calendar on this date,Přidat do kalendáře k tomuto datu,
Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
Customer is required,Je nutná zákazník,
Letter Head,Záhlavk,
Shrink fitting,Zmenšit kovánk,
Income / Expense,Výnosy / náklady,
Personal Email,Osobní e-mail,
Total Variance,Celkový rozptyl,
"If enabled, the system will post accounting entries for inventory automatically.","Pokud je povoleno, bude systém odesílat účetní položky k zásobám automaticky."
Brokerage,Makléřsks,
"in Minutes,
Updated via 'Time Log'","v minutách 
 aktualizovat přes ""Time Log"""
From Lead,Od Leadu,
Orders released for production.,Objednávky uvolněna pro výrobu.
Select Fiscal Year...,Vyberte fiskálního roku ...
Name Token,Jméno Token,
Planing,Hoblovánn,
Standard Selling,Standardní prodejnn,
Atleast one warehouse is mandatory,Alespoň jeden sklad je povinnn,
Out of Warranty,Out of záruky,
Replace,Vyměnit,
{0} against Sales Invoice {1},{0} na Prodejní Faktuře {1}
Please enter default Unit of Measure,"Prosím, zadejte výchozí měrnou jednotku"
Project Name,Název projektu,
Edit,Upravit,
If Income or Expense,Pokud je výnos nebo náklad,
New Support Tickets,Nová podpora Vstupenky,
Item Batch Nos,Položka Batch Nos,
Stock Value Difference,Reklamní Value Rozdíl,
Payment Reconciliation Payment,Platba Odsouhlasení Platba,
Tax Assets,Daňové Aktiva,
BOM No,BOM No,
Pincode,PSu,
Journal Entry {0} does not have account {1} or already matched against other voucher,Zápis do deníku {0} nemá účet {1} nebo již uzavřeno proti ostatním poukaz,
Moving Average,Klouzavý průměr,
The BOM which will be replaced,"BOM, který bude nahrazen"
New Stock UOM must be different from current stock UOM,New Sklad UOM musí být odlišný od běžného akciové nerozpuštěných,
Debit,Debet,
Leaves must be allocated in multiples of 0.5,"Listy musí být přiděleny v násobcích 0,5"
Operation Cost,Provozní náklady,
Upload attendance from a .csv file,Nahrajte účast ze souboru CSV,
Outstanding Amt,Vynikající Amt,
Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.
"To assign this issue, use the ""Assign"" button in the sidebar.","Chcete-li přiřadit tento problém vyřešit, použijte tlačítko ""Přiřadit"" v postranním panelu."
Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny]
"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.","Pokud dva nebo více pravidla pro tvorbu cen se nacházejí na základě výše uvedených podmínek, priorita je aplikována. Priorita je číslo od 0 do 20, zatímco výchozí hodnota je nula (prázdný). Vyšší číslo znamená, že bude mít přednost, pokud existuje více pravidla pro tvorbu cen se za stejných podmínek."
Against Invoice,Na základě faktury,
Fiscal Year: {0} does not exists,Fiskální rok: {0} neexistuje,
To Currency,Chcete-li měny,
Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.
Types of Expense Claim.,Druhy výdajů nároku.
Taxes,Dany,
Default Cost Center,Výchozí Center Náklady,
End Date,Datum ukončeny,
Internal Work History,Vnitřní práce History,
Column Break,Zalomení sloupce,
Thursday,Čtvrtek,
Private Equity,Private Equity,
Turning,Turning,
Customer Feedback,Zpětná vazba od zákazníky,
Expense,Výdaj,
Exhibition,Výstava,
Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
Submit this Production Order for further processing.,Odeslat tento výrobní zakázka pro další zpracování.
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Nechcete-li použít Ceník článek v dané transakce, by měly být všechny platné pravidla pro tvorbu cen zakázáno."
Domain,Doména,
Sales Order Trends,Prodejní objednávky Trendy,
Held On,Které se konalo dne,
Production Item,Výrobní položka,
Employee Information,Informace o zaměstnanci,
Rate (%),Rate (%)
Financial Year End Date,Finanční rok Datum ukončen$1,
"Can not filter based on Voucher No, if grouped by Voucher","Nelze filtrovat na základě poukazu ne, pokud seskupeny podle poukazu"
Make Supplier Quotation,Vytvořit nabídku dodavatele,
Incoming,Přicházejíce,
Name and Description,Jméno a popis,
"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.","Výchozí Měrná jednotka nelze změnit, přímo, protože jste již nějaké transakce (y) s jiným nerozpuštěných. Chcete-li změnit výchozí UOM, použijte ""UOM Nahradit Utility"" nástroj pod Stock modulu."
Materials Required (Exploded),Potřebný materiál (Rozložený)
Reduce Earning for Leave Without Pay (LWP),Snížit Zisk na vstup bez nároku na mzdu (LWP)
Casual Leave,Casual Leave,
Credit To account must be a liability account,Připsat na účet musí být účet závazek,
Batch ID,Šarže ID,
Note: {0},Poznámka: {0}
Delivery Note Trends,Dodací list Trendy,
{0} must be a Purchased or Sub-Contracted Item in row {1},"{0} musí být Zakoupená, nebo Subdodavatelská položka v řádku {1}"
Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakca,
Party,Strana,
Delivery Date,Dodávka Datum,
Currency,Měna,
Opportunity Date,Příležitost Datum,
To Bill,Billa,
Piecework,Úkolová práce,
Avg. Buying Rate,Avg. Nákup Rate,
Actual Time (in Hours),Skutečná doba (v hodinách)
History In Company,Historie ve Společnosti,
Shipping,Lodni,
Stock Ledger Entry,Reklamní Ledger Entry,
Leave Block List,Nechte Block List,
Item {0} is not setup for Serial Nos. Column must be blank,Položka {0} není nastavení pro Serial č. Sloupec musí být prázdni,
Accounts Settings,Nastavení účtu,
Plant and Machinery,Továrna a strojní zařízeni,
You can enter the minimum quantity of this item to be ordered.,Můžete zadat minimální množství této položky do objednávky.
Partner's Website,Partnera Website,
To Discuss,K projednáne,
SMS Settings,Nastavení SMS,
Temporary Accounts,Dočasné Účty,
Column Break 1,Zalomení sloupce 1,
Black,Černe,
BOM Explosion Item,BOM Explosion Item,
Auditor,Auditor,
End date of current order's period,Datum ukončení doby aktuální objednávky,
Make Offer Letter,Vytvořte nabídku Letter,
Fold,Fold,
Production Order Operation,Výrobní zakázka Operace,
Disable,Zakázat,
Pending Review,Čeká Review,
Please specify,Prosím specifikujte,
Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
Customer Id,Zákazník Id,
Page Name,Název stránky,
Exchange Rate,Exchange Rate,
Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena,
Warehouse {0}: Parent account {1} does not bolong to the company {2},Sklad {0}: Nadřazený účet {1} napatří společnosti {2}
Spindle finishing,Úprava vřetena,
% of materials ordered against this Material Request,% Materiálů objednáno proti tomuto požadavku Materiál,
Last Purchase Rate,Last Cena při platba,
Asset,Majetek,
Task ID,Task ID,
"e.g. ""MC""","např ""MC """
Stock cannot exist for Item {0} since has variants,"Sklad nemůže existovat k bodu {0}, protože má varianty"
Sales Person-wise Transaction Summary,Prodej Person-moudrý Shrnutí transakce,
Time Zone,Časové pásmo,
Warehouse {0} does not exist,Sklad {0} neexistuje,
Register For ERPNext Hub,Registrace pro ERPNext Hub,
Monthly Distribution Percentages,Měsíční Distribuční Procenta,
The selected item cannot have Batch,Vybraná položka nemůže mít dávku,
% of materials delivered against this Delivery Note,% Materiálů doručeno proti tomuto dodacímu listu,
Stapling,Sešíváne,
Customer Details,Podrobnosti zákazníke,
Shaping,Tvarováne,
Reports to,Zprávy,
Enter url parameter for receiver nos,Zadejte url parametr pro přijímače nos,
Paid Amount,Uhrazené částky,
Closing Account {0} must be of type 'Liability',"Závěrečný účet {0} musí být typu ""odpovědnosti"""
Available Stock for Packing Items,K dispozici skladem pro balení položek,
Reserved Warehouse is missing in Sales Order,Reserved Warehouse chybí odběratele,
Item Variant,Položka Variant,
Setting this Address Template as default as there is no other default,"Nastavení Tato adresa šablonu jako výchozí, protože není jiná výchozí"
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
Quality Management,Řízení kvality,
Filter based on customer,Filtr dle zákazníka,
Against Voucher No,Proti poukaz y,
Please enter quantity for Item {0},"Zadejte prosím množství produktů, bod {0}"
Warning: Sales Order {0} already exists against same Purchase Order number,Upozornění: prodejní objednávky {0} již existuje proti stejnému číslo objednávky,
Employee External Work History,Zaměstnanec vnější práce History,
Purchase,Nákup,
Status of {0} {1} is now {2},Stav {0} {1} je nyní {2}
Balance Qty,Zůstatek Množstvp,
Parent Item Group,Parent Item Group,
{0} for {1},{0} na {1}
Cost Centers,Nákladové středisko,
Warehouses.,Sklady.
Rate at which supplier's currency is converted to company's base currency,"Sazba, za kterou dodavatel měny je převeden na společnosti základní měny"
Row #{0}: Timings conflicts with row {1},Row # {0}: časování v rozporu s řadou {1}
Employment Type,Typ zaměstnánk,
Fixed Assets,Dlouhodobý majetek,
Default Expense Account,Výchozí výdajového účtu,
Notice (days),Oznámení (dny)
Yes,Ano,
Material User,Materiál Uživatel,
Encashment Date,Inkaso Datum,
Electroforming,Electroforming,
"Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Proti poukazu Type musí být jedním z objednávky, faktury nebo Journal Entry"
Stock Adjustment,Reklamní Nastaveny,
Planned Operating Cost,Plánované provozní náklady,
New {0} Name,Nový {0} Název,
Please find attached {0} #{1},V příloze naleznete {0} # {1}
jsonrates.com API Key,jsonrates.com API Key,
Applicant Name,Žadatel Název,
Customer / Item Name,Zákazník / Název zbožy,
Serial No is mandatory for Item {0},Pořadové číslo je povinná k bodu {0}
Created By,Vytvořeno (kým)
Under AMC,Podle AMC,
Item valuation rate is recalculated considering landed cost voucher amount,Bod míra ocenění je přepočítána zvažuje přistál nákladů částku poukazu,
Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
Current BOM,Aktuální BOM,
Add Serial No,Přidat Sériové číslo,
Warehouses,Sklady,
Print and Stationary,Print a StacionárnM,
Group Node,Group Node,
Minimum Amount,Minimální částka,
Update Finished Goods,Dokončení aktualizace zbožM,
"Automatically set. If this item has variants, then it cannot be selected in sales orders etc.","Automatické nastavení. Pokud je tato položka má varianty, pak to nemůže být zvolen do prodejních objednávek atd"
per hour,za hodinu,
Series {0} already used in {1},Série {0} jsou již použity v {1}
Account for the warehouse (Perpetual Inventory) will be created under this Account.,"Účet pro skladu (průběžné inventarizace), bude vytvořena v rámci tohoto účtu."
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad."
Distribution,Distribuce,
Project Manager,Project Manager,
Dispatch,Odesláne,
Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
Receivable,Pohledávky,
Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity."
Supplier Reference,Dodavatel Označen$1,
"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Je-li zaškrtnuto, bude BOM pro sub-montážní položky považují pro získání surovin. V opačném případě budou všechny sub-montážní položky být zacházeno jako surovinu."
Material Issue,Material Issue,
Seller Description,Prodejce Popis,
Is Stock Item,Je skladem,
Shopping Cart Price List,Nákupní košík Ceník,
Qualification,Kvalifikace,
Item Price,Položka Cena,
Soap & Detergent,Soap & Detergent,
Motion Picture & Video,Motion Picture & Video,
Ordered,Objednáno,
Default Settings,Výchozí nastavene,
Warehouse Name,Název Skladu,
Select Transaction,Vybrat Transaction,
Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel,
Write Off Entry,Odepsat Vstup,
Rate Of Materials Based On,Hodnotit materiálů na bázi,
Support Analtyics,Podpora Analtyics,
eg. Cheque Number,např. číslo šeku,
Company is missing in warehouses {0},Společnost chybí ve skladech {0}
Stock UOM Replace Utility,Sklad UOM Nahradit Utility,
Terms and Conditions,Podmínky,
To Date should be within the Fiscal Year. Assuming To Date = {0},"Chcete-li data by měla být v rámci fiskálního roku. Za předpokladu, že To Date = {0}"
"Here you can maintain height, weight, allergies, medical concerns etc","Zde si můžete udržet výšku, váhu, alergie, zdravotní problémy atd"
Applies to Company,Platí pro firmy,
Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože předložena Reklamní Entry {0} existuje"
In Words,Slovy,
Today is {0}'s birthday!,Dnes je {0} 's narozeniny!
Material Request For Warehouse,Materiál Request For Warehouse,
For Production,Pro Výrobu,
Please enter sales order in the above table,"Prosím, zadejte prodejní objednávky v tabulce výše"
View Task,Zobrazit Task,
Your financial year begins on,Váš finanční rok začínk,
Please enter Purchase Receipts,"Prosím, zadejte Nákup Příjmy"
Get Advances Received,Získat přijaté zálohy,
Add/Remove Recipients,Přidat / Odebrat příjemce,
Transaction not allowed against stopped Production Order {0},Transakce není povoleno proti zastavila výrobu Objednat {0}
"To set this Fiscal Year as Default, click on 'Set as Default'","Chcete-li nastavit tento fiskální rok jako výchozí, klikněte na tlačítko ""Nastavit jako výchozí"""
Setup incoming server for support email id. (e.g. support@example.com),Nastavení příchozí server pro podporu e-mailovou id. (Např support@example.com)
Shortage Qty,Nedostatek Množstv$1,
Row{0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Type Party Party a je nutné pro pohledávky / závazky na účtu {1}
Salary Slip,Plat Slip,
Burnishing,Leštěnp,
To enable <b>Point of Sale</b> view,Chcete-li povolit <b> Point of Sale </ b> Zobrazit,
'To Date' is required,"""Datum DO"" je povinné"
"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generování balení pásky pro obaly mají být dodány. Používá se k oznámit číslo balíku, obsah balení a jeho hmotnost."
Sales Order Item,Prodejní objednávky Item,
Payment Days,Platební dny,
Manage cost of operations,Správa nákladů na provoz,
Make Credit Note,Proveďte dobropis,
Item Advanced,Položka Advanced,
Hot rolling,Válcovánm,
"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.","Když některý z kontrolovaných operací je ""Odesláno"", email pop-up automaticky otevřeny poslat e-mail na přidružené ""Kontakt"" v této transakci, s transakcí jako přílohu. Uživatel může, ale nemusí odeslat e-mail."
Customer master.,Master zákazníků.
Global Settings,Globální nastaveny,
Employee Education,Vzdělávání zaměstnancy,
Net Pay,Net Pay,
Account,Účet,
Serial No {0} has already been received,Pořadové číslo {0} již obdržel,
Requested Items To Be Transferred,Požadované položky mají být převedeny,
Recurring Id,Opakující se Id,
Sales Team Details,Podrobnosti prodejní tým,
Total Claimed Amount,Celkem žalované částky,
Potential opportunities for selling.,Potenciální příležitosti pro prodej.
Sick Leave,Zdravotní dovolent,
Email Digest,Email Digest,
Billing Address Name,Jméno Fakturační adresy,
Department Stores,Obchodní domy,
System Balance,System Balance,
Is Active,Je Aktivnt,
No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady,
Save the document first.,Uložte dokument jako první.
Chargeable,Vyměřovacg,
Linishing,Linishing,
Change Abbreviation,Změna Zkratky,
Primary,Primárng,
Expense Date,Datum výdaje,
Max Discount (%),Max sleva (%)
Last Order Amount,Poslední částka objednávky,
Blasting,Odstřel,
Warn,Varovat,
Item valuation updated,Ocenění Item aktualizováno,
"Any other remarks, noteworthy effort that should go in the records.","Jakékoli jiné poznámky, pozoruhodné úsilí, které by měly jít v záznamech."
Manufacturing User,Výroba Uživatel,
Raw Materials Supplied,Dodává suroviny,
Total valuation ({0}) for manufactured or repacked item(s) can not be less than total valuation of raw materials ({1}),Ocenění Total ({0}) pro vyrobené nebo zabalil položku (y) nesmí být menší než celková ocenění surovin ({1})
New Projects,Nové projekty,
Series,Série,
Expected Delivery Date cannot be before Purchase Order Date,"Očekávané datum dodání, nemůže být před zakoupením pořadí Datum"
Appraisal Template,Posouzení Template,
Email,Email,
Item Classification,Položka Klasifikace,
Business Development Manager,Business Development Manager,
Maintenance Visit Purpose,Maintenance Visit Účel,
Period,Obdobe,
General Ledger,Hlavní Účetní Kniha,
View Leads,Zobrazit Vodítka,
Attribute Value,Hodnota atributu,
"Email id must be unique, already exists for {0}","E-mail id musí být jedinečný, již existuje {0}"
Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level,
Please select {0} first,"Prosím, nejprve vyberte {0} "
To get Item Group in details table,Chcete-li získat položku Group v tabulce Rozpis,
Redrawing,Překreslens,
Etching,Lept,
Commission,Provize,
You are not allowed to reply to this ticket.,Nejste oprávnění odpovědět na tento lístek.
"<h4>Default Template</h4>
<p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p>
<pre><code>{{ address_line1 }}&lt;br&gt;
{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}
{{ city }}&lt;br&gt;
{% if state %}{{ state }}&lt;br&gt;{% endif -%}
{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}
{{ country }}&lt;br&gt;
{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}
{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}
{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}
</code></pre>","<H4> Default Template </ h4> 
 <p> <a Používá href=""http://jinja.pocoo.org/docs/templates/""> Jinja šablon </a> a všechna pole Adresa ( včetně Custom Fields-li nějaké) budou k dispozici </ p> 
 <pre> <code> {{address_line1}} & lt; br & gt; 
 {%, pokud address_line2%} {{address_line2}} & lt; br & gt; { % endif -%} {
 {}} city & lt; br & gt; 
 {%, pokud stav%} {{}} state & lt; br & gt; {% endif -%} {
% v případě, PSC%} PIN: {{PSC}} & lt; br & gt; {% endif -%} 
 {{country}} & lt; br & gt; 
 {%, pokud telefon%} Telefon: {{tel}} & lt; br & gt; { % endif -%} 
 {% v případě, fax%} Fax: {{fax}} & lt; br & gt; {% endif -%} 
 {%, pokud email_id%} E-mail: {{email_id}} & lt; br & gt ; {% endif -%} 
 </ code> </ pre>"
Default Amount,Výchozí částka,
Warehouse not found in the system,Sklad nebyl nalezen v systému,
Quality Inspection Reading,Kvalita Kontrola Reading,
col_break1,col_break1,
`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazit Zásoby Starší Vic jak` by měla být menší než %d dnů.
Project wise Stock Tracking,Sledování zboží dle projektu,
Maintenance Schedule {0} exists against {0},Plán údržby {0} existuje na {0}
Actual Qty (at source/target),Skutečné množství (u zdroje/cíle)
Ref Code,Ref Code,
Employee records.,Zaměstnanecké záznamy.
Payroll Settings,Nastavení Mzdov$1,
Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
New Purchase Orders,Nové vydané objednávky,
Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko,
C-Form Applicable,C-Form Použitelny,
UOM Conversion Detail,UOM konverze Detail,
Keep it web friendly 900px (w) by 100px (h),Keep It webové přátelské 900px (w) o 100px (h)
Charges are updated in Purchase Receipt against each item,Poplatky jsou aktualizovány v dokladu o koupi na každou položku,
Get Outstanding Vouchers,Získejte Vynikající poukazy,
Resolved By,Vyřešena,
Start Date,Datum zahájenu,
Value,Hodnota,
Allocate leaves for a period.,Přidělit listy dobu.
Account {0}: You can not assign itself as parent account,Účet {0}: nelze přiřadit sebe jako nadřazený účet,
Price List Rate,Ceník Rate,
Delivered Serial No {0} cannot be deleted,Dodává Pořadové číslo {0} nemůže být smazán,
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Zobrazit ""Skladem"" nebo ""Není skladem"" na základě skladem k dispozici v tomto skladu."
Bill of Materials (BOM),Bill of Materials (BOM)
Hours,Hodiny,
Expected Start Date,Očekávané datum zahájeny,
Rolling,Rolling,
Priority,Priorita,
"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Nelze smazat sériové číslo {0} na skladě. Nejprve odstraňte ze skladu, a pak smažte."
Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku,
Dropbox Access Allowed,Dropbox Přístup povolen,
Weekly,Týdennu,
Eg. smsgateway.com/api/send_sms.cgi,Např. smsgateway.com/api/send-sms.cgi,
Fully Completed,Plně Dokončeno,
"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Produkty budou rozděleny dle hmotnosti věku ve výchozím vyhledávání. Více váha věku, bude vyšší výrobek objeví v seznamu."
{0}% Complete,{0}% Hotovo,
Educational Qualification,Vzdělávací Kvalifikace,
Operating Costs,Provozní náklady,
Employee Leave Approver,Zaměstnanec Leave schvalovao,
Stay Updated,Zůstaňte Aktualizováno,
Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Položka Změna pořadí již pro tento sklad existuje {1}
"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
Electron beam machining,Paprsek obrábění Electron,
Purchase Master Manager,Nákup Hlavní manažer,
Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy,
Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}"
Main Reports,Hlavní zprávy,
Stock Ledger entries balances updated,Sklad Ledger položky bilancí aktualizováno,
To date cannot be before from date,K dnešnímu dni nemůže být dříve od data,
Prevdoc DocType,Prevdoc DOCTYPE,
Add / Edit Prices,Přidat / Upravit ceny,
Chart of Cost Centers,Diagram nákladových středisek,
Requested Items To Be Ordered,Požadované položky je třeba objednat,
My Orders,Moje objednávky,
Price List Name,Ceník Jméno,
For Manufacturing,Pro výrobu,
Manufacturing,Výroba,
Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány"
Income,Příjem,
Setup Wizard,Průvodce nastavením,
Industry Type,Typ Průmyslu,
Something went wrong!,Něco se pokazilo!
Warning: Leave application contains following block dates,Upozornění: Nechte Aplikace obsahuje následující data bloku,
Sales Invoice {0} has already been submitted,Prodejní faktury {0} již byla odeslána,
Completion Date,Dokončení Datum,
Amount (Company Currency),Částka (Měna Společnosti)
Die casting,Die lita,
Reference Date,Referenční data,
Organization unit (department) master.,Organizace jednotka (departement) master.
Please enter valid mobile nos,Zadejte platné mobilní nos,
User Specific,Uživatel Specificks,
Budget Detail,Detail Rozpočtu,
Please enter message before sending,"Prosím, zadejte zprávu před odesláním"
Status,Stav,
Stock UOM updated for Item {0},Sklad UOM aktualizovaný k bodu {0}
Year,Rok,
Please Update SMS Settings,Aktualizujte prosím nastavení SMS,
Time Log {0} already billed,Time Log {0} již účtoval,
Unsecured Loans,Nezajištěných úvěrk,
Cost Center Name,Jméno nákladového střediska,
Item {0} with Serial No {1} is already installed,Položka {0} s Serial č {1} je již nainstalován,
You can start by selecting backup frequency and granting access for sync,Můžete začít výběrem frekvence zálohování a poskytnutím přístupu pro synchronizaci,
Scheduled Date,Plánované datum,
Total Paid Amt,Celkem uhrazeno Amt,
Messages greater than 160 characters will be split into multiple messages,Zprávy větší než 160 znaků bude rozdělena do více zpráv,
Received and Accepted,Přijaté a Přijato,
"Lower the number, higher the priority in the Item Code suffix that will be created for this Item Attribute for the Item Variant","Nižší číslo, vyšší prioritu v položce kódu příponu, který bude vytvořen pro tuto položku atribut výtisku Variant"
Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti,
Employee can not be changed,Zaměstnanec nemůže být změněn,
You cannot credit and debit same account at the same time,Nemůžete dělat kreditní a debetní záznam na stejný účet ve stejnou dobu.
Help HTML,Nápověda HTML,
Total weightage assigned should be 100%. It is {0},Celková weightage přiřazen by měla být 100%. Je {0}
Allowance for over-{0} crossed for Item {1},Příspěvek na nadměrné {0} přešel k bodu {1}
Name of person or organization that this address belongs to.,"Jméno osoby nebo organizace, která tato adresa patří."
Your Suppliers,Vaši Dodavatel$1,
Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka."
Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,"Další platovou strukturu {0} je aktivní pro zaměstnance {1}. Prosím, aby jeho stav ""neaktivní"" pokračovat."
Contact,Kontakt,
Exports,Vývoz,
Converted,Převedent,
Has Serial No,Má Sériové číslo,
Date of Issue,Datum vydánt,
{0}: From {0} for {1},{0}: Od {0} do {1}
Content Type,Typ obsahu,
Computer,Počítau,
List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.
Item: {0} does not exist in the system,Položka: {0} neexistuje v systému,
You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmraženu,
Get Unreconciled Entries,Získat smířit záznamu,
Date on which lorry started from supplier warehouse,"Ode dne, kdy začal nákladního vozidla od dodavatele skladu"
Budgets,Rozpočty,
Updated,Aktualizováno,
Emergency Contact Details,Nouzové kontaktní údaje,
What does it do?,Co to dělá?
To Warehouse,Do skladu,
Account {0} has been entered more than once for fiscal year {1},Účet {0} byl zadán více než jednou za fiskální rok {1}
Average Commission Rate,Průměrná cena Komise,
'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemůže být ""ano"" pro neskladové zboží"
Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data,
Pricing Rule Help,Ceny Pravidlo Help,
Account Head,Účet Head,
"Specify a list of Territories, for which, this Price List is valid","Zadejte seznam území, pro které tato Ceník je platný"
Update additional costs to calculate landed cost of items,Aktualizace dodatečné náklady pro výpočet vyložené náklady položek,
Electrical,Elektrickk,
Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In)
Difference Account mandatory for purpose '{0}',Rozdíl Účet povinné pro účely &#39;{0}&#39;
User ID not set for Employee {0},User ID není nastavena pro zaměstnance {0}
Peening,Peening,
From Warranty Claim,Od reklamačnímu,
Default Source Warehouse,Výchozí zdroj Warehouse,
Customer Code,Code zákazníkg,
Birthday Reminder for {0},Narozeninová připomínka pro {0}
Default Purchase Account in which cost of the item will be debited.,"Default Nákup účet, na němž se bude zatížen náklady na položky."
Lapping,Zabrušovacy,
Days Since Last Order,Počet dnů od poslední objednávky,
Naming Series,Číselné řady,
Leave Block List Name,Nechte Jméno Block List,
Enabled,Zapnuto,
Stock Assets,Stock Aktiva,
Do you really want to Submit all Salary Slip for month {0} and year {1},"Opravdu chcete, aby předložila všechny výplatní pásce za měsíc {0} a rok {1}"
Import Subscribers,Importovat Odběratelt,
Target Qty,Target Množstvt,
Present,Současnost,
Delivery Note {0} must not be submitted,Delivery Note {0} nesmí být předloženy,
Sales Invoice Message,Prodejní faktury Message,
Income Booked,Rezervováno příjmt,
Based On,Založeno na,
Ordered Qty,Objednáno Množstvt,
Stock Frozen Upto,Reklamní Frozen at,
Project activity / task.,Projektová činnost / úkol.
Generate Salary Slips,Generování výplatních páskách,
{0} is not a valid email id,{0} není platné id emailu,
"Buying must be checked, if Applicable For is selected as {0}","Nákup musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
Discount must be less than 100,Sleva musí být menší než 100,
Low,Nízk0,
Spinning,Spinning,
Landed Cost Voucher,Přistálo Náklady Voucher,
Please set {0},Prosím nastavte {0}
Repeat on Day of Month,Opakujte na den v měsíci,
Health Details,Zdravotní Podrobnosti,
Offer Letter Terms,Nabídka Letter Podmínky,
To track any installation or commissioning related work after sales,Chcete-li sledovat jakékoli zařízení nebo uvedení do provozu souvisejících s prací po prodeji,
Estimated Costing,Odhadovaná kalkulace,
Journal Entry Detail No,Zápis do deníku Detail No,
Salary,Plat,
Delivery Document Type,Dodávka Typ dokumentu,
Submit all salary slips for the above selected criteria,Odeslat všechny výplatní pásky pro výše zvolených kritérii,
{0} Items synced,{0} položky synchronizovány,
Partly Delivered,Částečně vyhlášeno,
Existing Customer,Stávající zákazník,
Receivables,Pohledávky,
Reading 5,Čtení 5,
"Enter email id separated by commas, order will be mailed automatically on particular date","Zadejte e-mail id odděleny čárkami, bude objednávka bude zaslán automaticky na určité datum"
Campaign Name is required,Je zapotřebí Název kampano,
Rounded Off,Zaokrouhleno,
Maintenance Date,Datum údržby,
Rejected Serial No,Zamítnuto Serial No,
Deep drawing,Hluboké taženo,
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Prosím, vyberte položku, kde ""je skladem"", je ""Ne"" a ""Je Sales Item"" ""Ano"" a není tam žádný jiný Sales BOM"
New Newsletter,New Newsletter,
Start date should be less than end date for Item {0},Datum zahájení by měla být menší než konečné datum pro bod {0}
Show Balance,Show Balance,
"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.","Příklad:. ABCD ##### 
 Je-li série nastavuje a pořadové číslo není uvedeno v transakcích, bude vytvořen poté automaticky sériové číslo na základě této série. Pokud chcete vždy výslovně uvést pořadová čísla pro tuto položku. ponechte prázdné."
Upload Attendance,Nahrát Návštěvnost,
BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinnt,
Ageing Range 2,Stárnutí rozsah 2,
Amount,Částka,
Riveting,Nýtovánt,
BOM replaced,BOM nahradil,
Sales Analytics,Prodejní Analytics,
Manufacturing Settings,Výrobní nastavent,
Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr,
Stock Entry Detail,Reklamní Entry Detail,
You need to be logged in to view your cart.,Musíte být přihlášen k zobrazení košíku.
New Account Name,Nový název účtu,
Raw Materials Supplied Cost,Dodává se nákladů na suroviny,
Settings for Selling Module,Nastavení pro prodej Module,
Customer Service,Služby zákazníkům,
Item Customer Detail,Položka Detail Zákazník,
Offer candidate a Job.,Nabídka kandidát Job.
Prompt for Email on Submission of,Výzva pro e-mail na předkládánm,
Item {0} must be a stock Item,Položka {0} musí být skladem,
Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
{0} is required,{0} je vyžadováno,
Vacuum molding,Vakuové tvářeno,
Expected Date cannot be before Material Request Date,Očekávané datum nemůže být před Materiál Poptávka Datum,
City,Město,
Ultrasonic machining,Ultrazvukové obráběno,
Item {0} must be a Sales Item,Bod {0} musí být prodejní položky,
Update Series Number,Aktualizace Series Number,
Equity,Hodnota majetku,
Closing Date,Uzávěrka Datum,
Produced Quantity,Produkoval Množstvo,
Engineer,Inženýr,
Item Code required at Row No {0},Kód položky třeba na řádku č {0}
Partner Type,Partner Type,
Actual,Aktuálne,
% of materials received against this Purchase Order,% materiálů přijatých proti této objednávce,
Customerwise Discount,Sleva podle zákazníka,
Against Expense Account,Proti výdajového účtu,
Production Order,Výrobní Objednávka,
Installation Note {0} has already been submitted,Poznámka k instalaci {0} již byla odeslána,
Against Docname,Proti Docname,
All Employee (Active),Všichni zaměstnanci (Aktivní)
View Now,Zobrazit nyn$1,
Select the period when the invoice will be generated automatically,"Vyberte období, kdy faktura budou generovány automaticky"
Raw Material Cost,Cena surovin,
Re-Order Level,Re-Order Level,
Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,"Zadejte položky a plánované ks, pro které chcete získat zakázky na výrobu, nebo stáhnout suroviny pro analýzu."
Gantt Chart,Pruhový diagram,
Part-time,Part-time,
Applicable Holiday List,Použitelný Seznam Svátkm,
Cheque,Šek,
Series Updated,Řada Aktualizováno,
Report Type is mandatory,Report Type je povinnm,
Serial Number Series,Sériové číslo Series,
Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro skladovou položku {0} na řádku {1}
Retail & Wholesale,Maloobchod a velkoobchod,
First Responded On,Prvně odpovězeno dne,
Cross Listing of Item in multiple groups,Cross Výpis zboží v několika skupinách,
The First User: You,První Uživatel: Vy,
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Datum zahájení a  Datum ukončení Fiskálního roku jsou již stanoveny ve fiskálním roce {0}
Successfully Reconciled,Úspěšně smířeni,
Planned End Date,Plánované datum ukončeni,
Where items are stored.,"Tam, kde jsou uloženy předměty."
Invoiced Amount,Fakturovaná částka,
Attendance,Účast,
No,Ne,
Materials,Materiály,
"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit."
Make Delivery,Proveďte Dodávka,
Posting date and posting time is mandatory,Datum a čas zadání je povinna,
Tax template for buying transactions.,Daňové šablona pro nákup transakcí.
Item Prices,Ceny Položek,
In Words will be visible once you save the Purchase Order.,"Ve slovech budou viditelné, jakmile uložíte objednávce."
Period Closing Voucher,Období Uzávěrka Voucher,
Price List master.,Ceník master.
Review Date,Review Datum,
Level,Úrovem,
On Net Total,On Net Celkem,
Target warehouse in row {0} must be same as Production Order,Target sklad v řádku {0} musí být stejná jako výrobní zakázky,
No permission to use Payment Tool,Nemáte oprávnění k použití platební nástroj,
'Notification Email Addresses' not specified for recurring %s,"""E-mailové adresy pro Oznámení"", které nejsou uvedeny na opakující se %s"
Milling,Frézovány,
Nibbling,Okusovány,
Administrative Expenses,Administrativní náklady,
Consulting,Consulting,
Parent Customer Group,Parent Customer Group,
Change,Změna,
Contact Email,Kontaktní e-mail,
Purchase Order {0} is 'Stopped',Vydaná objednávka {0} je 'Zastavena'
Score Earned,Skóre Zasloužen$1,
"e.g. ""My Company LLC""","např ""My Company LLC """
Notice Period,Výpovědní Lhůta,
Voucher ID,Voucher ID,
This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.
Gross Weight UOM,Hrubá Hmotnost UOM,
Receivables / Payables,Pohledávky / Závazky,
Against Sales Invoice,Proti prodejní faktuře,
Stamping,LisovánM,
Landed Cost Item,Přistálo nákladovou položkou,
Show zero values,Ukázat nulové hodnoty,
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Množství položky získané po výrobě / přebalení z daných množství surovin,
Receivable / Payable Account,Pohledávky / závazky účet,
Against Sales Order Item,Proti položce přijaté objednávky,
Default Warehouse,Výchozí Warehouse,
Actual End Date (via Time Logs),Skutečné Datum ukončení (přes Time Záznamy)
Please enter parent cost center,"Prosím, zadejte nákladové středisko mateřský"
Print Without Amount,Tisknout bez Částka,
Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Daň z kategorie nemůže být ""Ocenění"" nebo ""Ocenění a celkový"", protože všechny položky jsou běžně skladem"
Last Name,Příjmeno,
Left,Vlevo,
All Day,Celý den,
Support Team,Tým podpory,
Total Score (Out of 5),Celkové skóre (Out of 5)
State,Stav,
Batch,Šarže,
Balance,Zůstatek,
Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nároků)
Gender,Pohlave,
Debit Note,Debit Note,
As per Stock UOM,Podle Stock nerozpuštěných,
Not Expired,Neuplynula,
Total Debit,Celkem Debit,
Sales Person,Prodej Osoba,
Unstop Purchase Order,Uvolnit Objednávka,
Cold Calling,Cold Calling,
SMS Parameter,SMS parametre,
Half Yearly,Pololetne,
Blog Subscriber,Blog Subscriber,
Income Year to Date,Rok příjmů do dneška,
Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.
"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Pokud je zaškrtnuto, Total no. pracovních dnů bude zahrnovat dovolenou, a to sníží hodnotu platu za každý den"
Total Advance,Total Advance,
Unstop Material Request,Uvolnit materiálu Poptávka,
User,Uživatel,
Basic Rate,Basic Rate,
Set as Lost,Nastavit jako Lost,
Stock balances updated,Stock zůstatky aktualizováno,
Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu,
Cannot return more than {0} for Item {1},Nelze vrátit více než {0} položky {1}
Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovních hodin.
{0} {1} has already been submitted,{0} {1} již byla odeslána,
Items To Be Requested,Položky se budou vyžadovat,
Get Last Purchase Rate,Získejte posledního nákupu Cena,
Company Info,Společnost info,
Seaming,Sešívána,
"Company Email ID not found, hence mail not sent","Společnost E-mail ID nebyl nalezen, proto pošta neodeslána"
Application of Funds (Assets),Aplikace fondů (aktiv)
Filter based on item,Filtr dle položek,
Year Start Date,Datum Zahájení Roku,
Employee Name,Jméno zaměstnance,
Debit To account must be a liability account,"Debetní Chcete-li v úvahu, musí být účet závazek"
Rounded Total (Company Currency),Zaoblený Total (Company Měna)
Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
Purchase Common,Nákup Common,
{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. Prosím aktualizujte.
Stop users from making Leave Applications on following days.,Přestaňte uživatelům provádět Nechat aplikací v následujících dnech.
From Opportunity,Od Opportunity,
Blanking,Zacloněny,
Employee Benefits,Zaměstnanecké benefity,
Is POS,Je POS,
Packed quantity must equal quantity for Item {0} in row {1},Balíčky množství se musí rovnat množství pro položku {0} v řadě {1}
Manufactured Qty,Vyrobeno Množstv$1,
Accepted Quantity,Schválené Množstv$1,
Bills raised to Customers.,Směnky vznesené zákazníkům.
Default,Výchozu,
Project Id,ID projektu,
"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Výběrem ""Yes"" umožní tato položka se objeví v objednávce, a doklad o zaplacení."
{0} subscribers added,{0} odběratelé z přidann,
Schedule,Plán,
Parent Account,Nadřazený účet,
Available,K dispozici,
Reading 3,Čtení 3,
Hub,Hub,
Voucher Type,Voucher Type,
Approved,Schválenn,
Price,Cena,
Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left"""
"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Výběrem ""Yes"" dá jedinečnou identitu každého subjektu této položky, které lze zobrazit v sériové číslo mistra."
Appraisal {0} created for Employee {1} in the given date range,Posouzení {0} vytvořil pro zaměstnance {1} v daném časovém obdoby,
Education,Vzdělány,
Campaign Naming By,Kampaň Pojmenování By,
Current Address Is,Aktuální adresa je,
Office,Kanceláy,
Standard Reports,Standardní výpisy,
Accounting journal entries.,Zápisy v účetním deníku.
Please select Employee Record first.,"Prosím, vyberte zaměstnance záznam první."
To create a Tax Account,Chcete-li vytvořit daňovém účtu,
Please enter Expense Account,"Prosím, zadejte výdajového účtu"
Stock,Sklad,
Current Address,Aktuální adresa,
"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Je-li položka je varianta další položku pak popis, obraz, oceňování, daní atd bude stanoven ze šablony, pokud není výslovně uvedeno"
Purchase / Manufacture Details,Nákup / Výroba Podrobnosti,
Contract End Date,Smlouva Datum ukončeni,
Track this Sales Order against any Project,Sledovat tento prodejní objednávky na jakýkoli projekt,
Price List not configured.,Ceník není nakonfigurován.
Pull sales orders (pending to deliver) based on the above criteria,"Prodejní Pull zakázky (čeká dodat), na základě výše uvedených kritérií"
Document Type,Typ dokumentu,
From Supplier Quotation,Z nabídky dodavatele,
Deduction Type,Odpočet Type,
Half Day,Půl den,
Not Available,Není k dispozici,
Min Qty,Min Množstvu,
Transaction Date,Transakce Datum,
Planned Qty,Plánované Množstvu,
Total Tax,Total Tax,
Default Target Warehouse,Výchozí Target Warehouse,
Net Total (Company Currency),Net Total (Company Měna)
Purchase Receipt Message,Zpráva příjemky,
Actual Start Date,Skutečné datum zahájeny,
% of materials delivered against this Sales Order,% Materiálů doručeno proti tomuto odběrateli,
Record item movement.,Záznam pohybu položka.
Newsletter List Subscriber,Newsletter seznamu účastníky,
Morticing,Dlabačky,
Service,Služba,
Hub Settings,Nastavení Hub,
Gross Margin %,Hrubá Marže %
With Operations,S operacemi,
Monthly Salary Register,Měsíční plat Register,
Next,Dalši,
If different than customer address,Pokud se liší od adresy zákazníka,
BOM Operation,BOM Operation,
Electropolishing,Elektrolyticki,
On Previous Row Amount,Na předchozí řady Částka,
New Delivery Notes,Nové dodací listy,
Please enter Payment Amount in atleast one row,"Prosím, zadejte částku platby aspoň jedné řadě"
Please write something in subject and message!,"Prosím, napište něco do předmětu zprávy a poselství!"
"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
Row {0}: Payment Amount cannot be greater than Outstanding Amount,Row {0}: Platba Částka nesmí být vyšší než dlužná částka,
Time Log is not billable,Time Log není zúčtovatelna,
"Item {0} is a template, please select one of its variants","Položka {0} je šablona, ​​prosím vyberte jednu z jeho variant"
Localization,Lokalizace,
Net pay cannot be negative,Net plat nemůže být záporne,
Please enter the Against Vouchers manually,Zadejte prosím podle dokladů ručne,
Static Parameters,Statické parametry,
Advance Paid,Vyplacené zálohy,
Item Tax,Daň Položky,
Employees Email Id,Zaměstnanci Email Id,
Current Liabilities,Krátkodobé závazky,
Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům,
Consider Tax or Charge for,Zvažte daň či poplatek za,
Actual Qty is mandatory,Skutečné Množství je povinne,
"Select ""Yes"" if you are maintaining stock of this item in your Inventory.","Zvolte ""Ano"", pokud se udržuje zásoby této položky ve vašem inventáři."
Item {0} does not exist in {1} {2},Bod {0} neexistuje v {1} {2}
Cross-rolling,Cross-válcována,
Credit Card,Kreditní karta,
Item to be manufactured or repacked,Položka být vyráběn nebo znovu zabalena,
Default settings for stock transactions.,Výchozí nastavení pro akciových transakcí.
Next Date,Další data,
Major/Optional Subjects,Hlavní / Volitelné předměty,
Please enter Taxes and Charges,"Prosím, zadejte Daně a poplatky"
Machining,Obráběn$1,
"Here you can maintain family details like name and occupation of parent, spouse and children","Zde si můžete udržovat rodinné detailů, jako jsou jméno a povolání rodičem, manželem a dětmi"
Seller Name,Prodejce Name,
Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna)
General Settings,Obecné nastavent,
From Currency and To Currency cannot be same,Z měny a měny nemůže být stejnt,
Repack,Přebalit,
You must Save the form before proceeding,Musíte Uložte formulář před pokračováním,
Attach Logo,Připojit Logo,
Commission Rate,Výše provize,
Block leave applications by department.,Aplikace Block dovolené podle oddělení.
Actual Operating Cost,Skutečné provozní náklady,
Root cannot be edited.,Root nelze upravovat.
Allocated amount can not greater than unadusted amount,Přidělená částka nemůže vyšší než částka unadusted,
Allow Production on Holidays,Povolit Výrobu při dovolend,
Customer's Purchase Order Date,Zákazníka Objednávka Datum,
Capital Stock,Základní kapitál,
Package Weight Details,Hmotnost balení Podrobnosti,
Please select a csv file,Vyberte soubor csv,
Designer,Návrhád,
Terms and Conditions Template,Podmínky Template,
Delivery Details,Zasílánd,
Allow Children,Povolit děti,
Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je nutné v řadě {0} na daních tabulka typu {1}
Discount %,Sleva%
Item-wise Purchase Register,Item-moudrý Nákup Register,
Expiry Date,Datum vypršení platnosti,
Supplier Addresses and Contacts,Dodavatel Adresy a kontakty,
Please select Category first,Nejdřív vyberte kategorii,
Project master.,Master Project.
Do not show any symbol like $ etc next to currencies.,Nevykazují žádný symbol jako $ atd vedle měnám.
Credit Days,Úvěrové dny,
Is Carry Forward,Je převádět,
Get Items from BOM,Získat předměty z BOM,
Lead Time Days,Dodací lhůta dny,
Send Notifications To,Odeslat upozorněny,
Ref Date,Ref Datum,
Reason for Leaving,Důvod Leaving,
Sanctioned Amount,Sankcionována Částka,
Is Opening,Se otevíry,
Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1}
Account {0} does not exist,Účet {0} neexistuje,
Cash,V hotovosti,
Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.
Please create Salary Structure for employee {0},Prosím vytvořte platovou strukturu pro zaměstnance {0}
