"""Customer Provided Item"" cannot be Purchase Item also",„Položka poskytovaná zákazníkem“ nemůže být rovněž nákupem,
"""Customer Provided Item"" cannot have Valuation Rate",„Položka poskytovaná zákazníkem“ nemůže mít sazbu ocenění,
"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Je dlouhodobý majetek"" nemůže být nezaškrtnutý protože existuje zápis aktiva oproti této položce",
'Based On' and 'Group By' can not be same,"""Založeno na"" a ""Seskupeno podle"", nemůže být stejné",
'Days Since Last Order' must be greater than or equal to zero,"""Dnů od poslední objednávky"" musí být větší nebo rovno nule",
'Entries' cannot be empty,"""Záznamy"" nemohou být prázdné",
'From Date' is required,"""Datum od"" je povinné",
'From Date' must be after 'To Date',"""Datum DO"" musí být po ""Datum OD""",
'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemůže být ""Ano"" pro neskladové zboží",
'Opening',"""Otevírací""",
'To Case No.' cannot be less than 'From Case No.',"""DO Případu č.' nesmí být menší než ""Od Případu č.'",
'To Date' is required,"""Datum DO"" je povinné",
'Total',&#39;Celkový&#39;,
'Update Stock' can not be checked because items are not delivered via {0},"""Aktualizovat sklad' nemůže být zaškrtnuto, protože položky nejsou dodány přes {0}",
'Update Stock' cannot be checked for fixed asset sale,"""Aktualizace Sklad"" nemohou být zaškrtnuty na prodej dlouhodobého majetku",
) for {0},) pro {0},
1 exact match.,1 přesná shoda.,
90-Above,90 Nad,
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ěňte název zákazníka nebo přejmenujte skupinu zákazníků",
A Default Service Level Agreement already exists.,Výchozí dohoda o úrovni služeb již existuje.,
A Lead requires either a person's name or an organization's name,Vedoucí vyžaduje jméno osoby nebo jméno organizace,
A customer with the same name already exists,Zákazník se stejným jménem již existuje,
A question must have more than one options,Otázka musí mít více než jednu možnost,
A qustion must have at least one correct options,Spalování musí mít alespoň jednu správnou možnost,
A {0} exists between {1} and {2} (,A {0} existuje mezi {1} a {2} (,
A4,A4,
API Endpoint,Koncový bod rozhraní API,
API Key,klíč API,
Abbr can not be blank or space,Zkratka nemůže být prázdný znak nebo mezera,
Abbreviation already used for another company,Zkratka již byla použita pro jinou společnost,
Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znaků,
Abbreviation is mandatory,Zkratka je povinná,
About the Company,O společnosti,
About your company,O vaší společnosti,
Above,Výše,
Absent,Nepřítomný,
Academic Term,Akademický Term,
Academic Term: ,Akademické označení:,
Academic Year,Akademický rok,
Academic Year: ,Akademický rok:,
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},
Access Token,Přístupový Token,
Accessable Value,Přístupná hodnota,
Account,Účet,
Account Number,Číslo účtu,
Account Number {0} already used in account {1},Číslo účtu {0} již použito v účtu {1},
Account Pay Only,Účet Pay Pouze,
Account Type,Typ účtu,
Account Type for {0} must be {1},Typ účtu pro {0} musí být {1},
"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""",
"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""",
Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,"Číslo účtu pro účet {0} není k dispozici. <br> Prosím, nastavte účetní řád správně.",
Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu,
Account with child nodes cannot be set as ledger,Účet s podřízené uzly nelze nastavit jako hlavní knihy,
Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.,
Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán,
Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu,
Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1},
Account {0} does not belongs to company {1},Účet {0} nepatří společnosti {1},
Account {0} does not exist,Účet {0} neexistuje,
Account {0} does not exists,Účet {0} neexistuje,
Account {0} does not match with Company {1} in Mode of Account: {2},Účet {0} neodpovídá společnosti {1} v účtu účtu: {2},
Account {0} has been entered multiple times,Účet {0} byl zadán vícekrát,
Account {0} is added in the child company {1},Účet {0} je přidán do podřízené společnosti {1},
Account {0} is frozen,Účet {0} je zmrazen,
Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatný. Měna účtu musí být {1},
Account {0}: Parent account {1} can not be a ledger,Účet {0}: Nadřazený účet {1} nemůže být hlavní kniha,
Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2},
Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje,
Account {0}: You can not assign itself as parent account,Účet {0}: nelze přiřadit sebe jako nadřazený účet,
Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakcí,
Account: {0} with currency: {1} can not be selected,Účet: {0} s měnou: {1} nelze vybrat,
Accountant,Účetní,
Accounting,Účetnictví,
Accounting Entry for Asset,Účet evidence majetku,
Accounting Entry for Stock,Účetní položka na skladě,
Accounting Entry for {0}: {1} can only be made in currency: {2},Účetní záznam pro {0}: {1} mohou být prováděny pouze v měně: {2},
Accounting Ledger,Účetní Statistika,
Accounting journal entries.,Zápisy v účetním deníku.,
Accounts,Účty,
Accounts Manager,Accounts Manager,
Accounts Payable,Účty za úplatu,
Accounts Payable Summary,Splatné účty Shrnutí,
Accounts Receivable,Pohledávky,
Accounts Receivable Summary,Pohledávky Shrnutí,
Accounts User,Uživatel Účtů,
Accounts table cannot be blank.,Účty tabulka nemůže být prázdné.,
Accrual Journal Entry for salaries from {0} to {1},Záznam o akruálním deníku pro platy od {0} do {1},
Accumulated Depreciation,oprávky,
Accumulated Depreciation Amount,Oprávky Částka,
Accumulated Depreciation as on,Oprávky i na,
Accumulated Monthly,nahromaděné za měsíc,
Accumulated Values,Neuhrazená Hodnoty,
Accumulated Values in Group Company,Akumulované hodnoty ve skupině společnosti,
Achieved ({}),Dosažené ({}),
Action,Akce,
Action Initialised,Inicializovaná akce,
Actions,Akce,
Active,Aktivní,
Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pro zaměstnance {0} proti Typ aktivity - {1},
Activity Cost per Employee,Náklady na činnost na jednoho zaměstnance,
Activity Type,Druh činnosti,
Actual Cost,Aktuální cena,
Actual Delivery Date,Skutečné datum dodání,
Actual Qty,Skutečné množství,
Actual Qty is mandatory,Skutečné Množství je povinné,
Actual Qty {0} / Waiting Qty {1},Aktuální počet {0} / Čekací počet {1},
Actual Qty: Quantity available in the warehouse.,Skutečné množ.: Množství k dispozici ve skladu.,
Actual qty in stock,Aktuální množství na skladě,
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},
Add,Přidat,
Add / Edit Prices,Přidat / Upravit ceny,
Add All Suppliers,Přidat všechny dodavatele,
Add Comment,Přidat komentář,
Add Customers,Přidat zákazníky,
Add Employees,Přidejte Zaměstnanci,
Add Item,Přidat položku,
Add Items,Přidat položky,
Add Leads,Přidat předlohy,
Add Multiple Tasks,Přidat více úkolů,
Add Row,Přidat řádek,
Add Sales Partners,Přidat obchodní partnery,
Add Serial No,Přidat sériové číslo,
Add Students,Přidejte studenty,
Add Suppliers,Přidat dodavatele,
Add Time Slots,Přidat časové úseky,
Add Timesheets,Přidat Timesheets,
Add Timeslots,Přidat Timeslots,
Add Users to Marketplace,Přidejte uživatele do Marketplace,
Add a new address,přidat novou adresu,
Add cards or custom sections on homepage,Přidejte karty nebo vlastní sekce na domovskou stránku,
Add more items or open full form,Přidat další položky nebo otevřené plné formě,
Add notes,Přidejte poznámky,
Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,"Přidejte zbytek vaší organizace jako uživatele. Můžete také přidat pozvat zákazníky na portálu tím, že přidáním z Kontaktů",
Add to Details,Přidat do Podrobnosti,
Add/Remove Recipients,Přidat / Odebrat příjemce,
Added,Přidáno,
Added to details,Přidáno do podrobností,
Added {0} users,Přidali jsme {0} uživatele,
Additional Salary Component Exists.,Další platová složka existuje.,
Address,Adresa,
Address Line 2,Adresní řádek 2,
Address Name,adresa Jméno,
Address Title,Označení adresy,
Address Type,Typ adresy,
Administrative Expenses,Administrativní náklady,
Administrative Officer,Správní ředitel,
Administrator,Správce,
Admission,Přijetí,
Admission and Enrollment,Vstup a zápis,
Admissions for {0},Přijímací řízení pro {0},
Admit,Připustit,
Admitted,"připustil,",
Advance Amount,Záloha ve výši,
Advance Payments,Zálohové platby,
Advance account currency should be same as company currency {0},Advance měna účtu by měla být stejná jako měna společnosti {0},
Advance amount cannot be greater than {0} {1},Množství předem nemůže být větší než {0} {1},
Advertising,Reklama,
Aerospace,Aerospace,
Against,Proti,
Against Account,Proti účet,
Against Journal Entry {0} does not have any unmatched {1} entry,Proti věstníku Vstup {0} nemá bezkonkurenční {1} vstupu,
Against Journal Entry {0} is already adjusted against some other voucher,Proti věstníku Entry {0} je již nastavena proti jiným poukaz,
Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1},
Against Voucher,Proti poukazu,
Against Voucher Type,Proti poukazu typu,
Age,Věk,
Age (Days),Stáří (dny),
Ageing Based On,Stárnutí dle,
Ageing Range 1,Stárnutí Rozsah 1,
Ageing Range 2,Stárnutí rozsah 2,
Ageing Range 3,Stárnutí Rozsah 3,
Agriculture,Zemědělství,
Agriculture (beta),Zemědělství (beta),
Airline,Letecká linka,
All Accounts,Všechny účty,
All Addresses.,Všechny adresy.,
All Assessment Groups,Všechny skupiny Assessment,
All BOMs,Všechny kusovníky,
All Contacts.,Všechny kontakty.,
All Customer Groups,Všechny skupiny zákazníků,
All Day,Celý den,
All Departments,Všechny oddělení,
All Healthcare Service Units,Všechny jednotky zdravotnických služeb,
All Item Groups,Všechny skupiny položek,
All Jobs,Všechny Jobs,
All Products,Všechny produkty,
All Products or Services.,Všechny výrobky nebo služby.,
All Student Admissions,Všechny Student Přijímací,
All Supplier Groups,Všechny skupiny dodavatelů,
All Supplier scorecards.,Všechna hodnocení dodavatelů.,
All Territories,Všechny území,
All Warehouses,Celý sklad,
All communications including and above this shall be moved into the new Issue,Veškerá komunikace včetně a nad tímto se přesouvají do nového vydání,
All items have already been transferred for this Work Order.,Všechny položky byly již převedeny pro tuto pracovní objednávku.,
All other ITC,Všechny ostatní ITC,
All the mandatory Task for employee creation hasn't been done yet.,Veškerá povinná úloha pro tvorbu zaměstnanců dosud nebyla dokončena.,
Allocate Payment Amount,Přidělit částku platby,
Allocated Amount,Přidělené sumy,
Allocated Leaves,Přidělené listy,
Allocating leaves...,Přidělení listů ...,
Already record exists for the item {0},Již existuje záznam pro položku {0},
"Already set default in pos profile {0} for user {1}, kindly disabled default",Již nastavený výchozí profil {0} pro uživatele {1} je laskavě vypnut výchozí,
Alternate Item,Alternativní položka,
Alternative item must not be same as item code,Alternativní položka nesmí být stejná jako kód položky,
Amended From,Platném znění,
Amount,Částka,
Amount After Depreciation,Částka po odpisech,
Amount of Integrated Tax,Výše integrované daně,
Amount of TDS Deducted,Částka odečtená z TDS,
Amount should not be less than zero.,Částka by neměla být menší než nula.,
Amount to Bill,Částka k Fakturaci,
Amount {0} {1} against {2} {3},Množství {0} {1} na {2} {3},
Amount {0} {1} deducted against {2},Množství {0} {1} odečíst proti {2},
Amount {0} {1} transferred from {2} to {3},Množství {0} {1} převedena z {2} na {3},
Amount {0} {1} {2} {3},Množství {0} {1} {2} {3},
Amt,Amt,
"An Item Group exists with same name, please change the item name or rename the item group","Skupina položek již existuje. Prosím, změňte název položky nebo přejmenujte skupinu položek",
An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademický termín s tímto &quot;akademický rok &#39;{0} a&quot; Jméno Termín&#39; {1} již existuje. Upravte tyto položky a zkuste to znovu.,
An error occurred during the update process,Během procesu aktualizace došlo k chybě,
"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",
Analyst,Analytik,
Analytics,analytika,
Annual Billing: {0},Roční Zúčtování: {0},
Annual Salary,Roční plat,
Anonymous,Anonymní,
Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Další rozpočtový záznam &#39;{0}&#39; již existuje proti {1} &#39;{2}&#39; a účet &#39;{3}&#39; za fiskální rok {4},
Another Period Closing Entry {0} has been made after {1},Další období Uzávěrka Entry {0} byla podána po {1},
Another Sales Person {0} exists with the same Employee id,Další prodeje osoba {0} existuje se stejným id zaměstnance,
Antibiotic,Antibiotikum,
Apparel & Accessories,Oblečení a doplňky,
Applicable For,Použitelné pro,
"Applicable if the company is SpA, SApA or SRL","Platí, pokud je společností SpA, SApA nebo SRL",
Applicable if the company is a limited liability company,"Platí, pokud je společnost společností s ručením omezeným",
Applicable if the company is an Individual or a Proprietorship,"Platí, pokud je společnost jednotlivec nebo vlastník",
Applicant,Žadatel,
Applicant Type,Typ žadatele,
Application of Funds (Assets),Aplikace fondů (aktiv),
Application period cannot be across two allocation records,Období žádosti nesmí být v rámci dvou alokačních záznamů,
Application period cannot be outside leave allocation period,Období pro podávání žádostí nemůže být alokační období venku volno,
Applied,Aplikovaný,
Apply Now,Použít teď,
Appointment Confirmation,Potvrzení jmenování,
Appointment Duration (mins),Délka schůzky (min),
Appointment Type,Typ schůzky,
Appointment {0} and Sales Invoice {1} cancelled,Přihláška {0} a prodejní faktura {1} byla zrušena,
Appointments and Encounters,Setkání a setkání,
Appointments and Patient Encounters,Setkání a setkání s pacienty,
Appraisal {0} created for Employee {1} in the given date range,Posouzení {0} vytvořil pro zaměstnance {1} v daném časovém období,
Apprentice,Učeň,
Approval Status,Stav schválení,
Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto""",
Approve,Schvalovat,
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,
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,
"Apps using current key won't be able to access, are you sure?","Aplikace s použitím aktuálního klíče nebudou mít přístup, jste si jisti?",
Are you sure you want to cancel this appointment?,Opravdu chcete tuto schůzku zrušit?,
Arrear,nedoplatek,
As Examiner,Jako zkoušející,
As On Date,Stejně jako u Date,
As Supervisor,Jako školitel,
As per rules 42 & 43 of CGST Rules,Podle pravidel 42 a 43 pravidel CGST,
As per section 17(5),Podle oddílu 17 (5),
As per your assigned Salary Structure you cannot apply for benefits,Podle vaší přiřazené struktury platu nemůžete žádat o výhody,
Assessment,Posouzení,
Assessment Criteria,Kritéria hodnocení,
Assessment Group,Skupina Assessment,
Assessment Group: ,Skupina hodnocení:,
Assessment Plan,Plan Assessment,
Assessment Plan Name,Název plánu hodnocení,
Assessment Report,Zpráva o hodnocení,
Assessment Reports,Zprávy o hodnocení,
Assessment Result,Hodnocení výsledků,
Assessment Result record {0} already exists.,Výsledky hodnocení {0} již existuje.,
Asset,Majetek,
Asset Category,Asset Kategorie,
Asset Category is mandatory for Fixed Asset item,Asset kategorie je povinný pro položku dlouhodobých aktiv,
Asset Maintenance,Údržba majetku,
Asset Movement,Asset Movement,
Asset Movement record {0} created,Záznam Asset Pohyb {0} vytvořil,
Asset Name,Asset Name,
Asset Received But Not Billed,"Aktivum bylo přijato, ale nebylo účtováno",
Asset Value Adjustment,Úprava hodnoty aktiv,
"Asset cannot be cancelled, as it is already {0}","Asset nelze zrušit, protože je již {0}",
Asset scrapped via Journal Entry {0},Asset vyhozen přes položka deníku {0},
"Asset {0} cannot be scrapped, as it is already {1}","Aktiva {0} nemůže být vyhozen, jak je tomu již {1}",
Asset {0} does not belong to company {1},Aktiva {0} nepatří do společnosti {1},
Asset {0} must be submitted,Asset {0} musí být předloženy,
Assets,Aktiva,
Assign,Přiřadit,
Assign Salary Structure,Přiřaďte strukturu platu,
Assign To,Přiřadit (komu),
Assign to Employees,Přiřadit zaměstnancům,
Assigning Structures...,Přiřazení struktur ...,
Associate,Spolupracovník,
At least one mode of payment is required for POS invoice.,pro POS fakturu je nutná alespoň jeden způsob platby.,
Atleast one item should be entered with negative quantity in return document,Aspoň jedna položka by měla být zadána s negativním množství ve vratném dokumentu,
Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena,
Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný,
Attach Logo,Připojit Logo,
Attachment,Příloha,
Attachments,Přílohy,
Attendance,Účast,
Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinná,
Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data,
Attendance date can not be less than employee's joining date,Datum návštěvnost nemůže být nižší než spojovací data zaměstnance,
Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen,
Attendance for employee {0} is already marked for this day,Účast na zaměstnance {0} je již označen pro tento den,
Attendance has been marked successfully.,Účast byla úspěšně označena.,
Attendance not submitted for {0} as it is a Holiday.,"Ústřednost nebyla předložena za {0}, protože je prázdnina.",
Attendance not submitted for {0} as {1} on leave.,Ústředna nebyla odeslána do {0} jako {1}.,
Attribute table is mandatory,Atribut tabulka je povinné,
Attribute {0} selected multiple times in Attributes Table,Atribut {0} vybraný několikrát v atributech tabulce,
Author,Autor,
Authorized Signatory,Prokurista,
Auto Material Requests Generated,Žádosti Auto materiál vygenerovaný,
Auto Repeat,Auto opakování,
Auto repeat document updated,Dokument byl aktualizován automaticky,
Automotive,Automobilový,
Available,K dispozici,
Available Leaves,Dostupné listy,
Available Qty,Množství k dispozici,
Available Selling,Dostupné prodeje,
Available for use date is required,K dispozici je datum k dispozici pro použití,
Available slots,Dostupné sloty,
Available {0},K dispozici {0},
Available-for-use Date should be after purchase date,Data k dispozici k použití by měla být po datu nákupu,
Average Age,Průměrný věk,
Average Rate,Průměrné hodnocení,
Avg Daily Outgoing,Avg Daily Odchozí,
Avg. Buying Price List Rate,Průměrné Nákupní cena ceníku,
Avg. Selling Price List Rate,Průměrné Míra prodejních cen,
Avg. Selling Rate,Avg. Prodej Rate,
BOM,BOM,
BOM Browser,Prohlížeč kusovníku,
BOM No,Číslo kusovníku,
BOM Rate,BOM Rate,
BOM Stock Report,BOM Sklad Zpráva,
BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinné,
BOM does not contain any stock item,BOM neobsahuje žádnou skladovou položku,
BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1},
BOM {0} must be active,BOM {0} musí být aktivní,
BOM {0} must be submitted,BOM {0} musí být předloženy,
Balance,Zůstatek,
Balance (Dr - Cr),Bilance (Dr - Cr),
Balance ({0}),Zůstatek ({0}),
Balance Qty,Zůstatek Množství,
Balance Sheet,Rozvaha,
Balance Value,Zůstatek Hodnota,
Balance for Account {0} must always be {1},Zůstatek na účtě {0} musí být vždy {1},
Bank,banka,
Bank Account,Bankovní účet,
Bank Accounts,Bankovní účty,
Bank Draft,Bank Návrh,
Bank Entries,bankovní Příspěvky,
Bank Name,Název banky,
Bank Overdraft Account,Kontokorentní úvěr na účtu,
Bank Reconciliation,Bank Odsouhlasení,
Bank Reconciliation Statement,Bank Odsouhlasení prohlášení,
Bank Statement,Výpis z bankovního účtu,
Bank Statement Settings,Nastavení bankovního výpisu,
Bank Statement balance as per General Ledger,Výpis z bankovního účtu zůstatek podle hlavní knihy,
Bank account cannot be named as {0},Bankovní účet nemůže být jmenován jako {0},
Bank/Cash transactions against party or for internal transfer,Banka / Hotovostní operace proti osobě nebo pro interní převod,
Banking,Bankovnictví,
Banking and Payments,Bankovnictví a platby,
Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1},
Barcode {0} is not a valid {1} code,Čárový kód {0} není platný kód {1},
Base,Báze,
Base URL,Základní URL,
Based On,Založeno na,
Based On Payment Terms,Na základě platebních podmínek,
Basic,Základní,
Batch,Šarže,
Batch Entries,Dávkové položky,
Batch ID is mandatory,Číslo šarže je povinné,
Batch Inventory,Batch Zásoby,
Batch Name,Batch Name,
Batch No,Č. šarže,
Batch number is mandatory for Item {0},Číslo šarže je povinné pro položku {0},
Batch {0} of Item {1} has expired.,Šarže {0} položky {1} vypršela.,
Batch {0} of Item {1} is disabled.,Dávka {0} položky {1} je zakázána.,
Batch: ,Dávka:,
Batches,Dávky,
Become a Seller,Staňte se prodejcem,
Beginner,Začátečník,
Bill,Účet,
Bill Date,Datum účtu,
Bill No,Bill No,
Bill of Materials,Kusovník,
Bill of Materials (BOM),Bill of Materials (BOM),
Billable Hours,Fakturovatelné hodiny,
Billed,Fakturováno,
Billed Amount,Fakturovaná částka,
Billing,Fakturace,
Billing Address,fakturační adresa,
Billing Address is same as Shipping Address,Fakturační adresa je stejná jako dodací adresa,
Billing Amount,Fakturace Částka,
Billing Status,Status Fakturace,
Billing currency must be equal to either default company's currency or party account currency,Měna fakturace se musí rovnat buď měně výchozí měny nebo měně stran účtu,
Bills raised by Suppliers.,Směnky vznesené dodavately,
Bills raised to Customers.,Směnky vznesené zákazníkům.,
Biotechnology,Biotechnologie,
Birthday Reminder,Připomenutí narozenin,
Black,Černá,
Blanket Orders from Costumers.,Přikládané objednávky od zákazníků.,
Block Invoice,Blokovat fakturu,
Boms,kusovníky,
Bonus Payment Date cannot be a past date,Datum splatnosti bonusu nemůže být poslední datum,
Both Trial Period Start Date and Trial Period End Date must be set,Musí být nastaven datum zahájení zkušebního období a datum ukončení zkušebního období,
Both Warehouse must belong to same Company,Oba Sklady musí patřit do stejné společnosti,
Branch,Větev,
Broadcasting,Vysílání,
Brokerage,Makléřská,
Browse BOM,Procházet kusovník,
Budget Against,Rozpočet proti,
Budget List,Rozpočtový seznam,
Budget Variance Report,Rozpočet Odchylka Report,
Budget cannot be assigned against Group Account {0},Rozpočet nemůže být přiřazena na skupinový účet {0},
"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Rozpočet nelze přiřadit proti {0}, protože to není výnos nebo náklad účet",
Buildings,Budovy,
Bundle items at time of sale.,Bundle položky v okamžiku prodeje.,
Business Development Manager,Business Development Manager,
Buy,Koupit,
Buying,Nákupy,
Buying Amount,Nákup částka,
Buying Price List,Nákupní ceník,
Buying Rate,Rychlost nákupu,
"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}",
By {0},Do {0},
Bypass credit check at Sales Order ,Objednávka kreditu bypassu na objednávce,
C-Form records,C-Form záznamy,
C-form is not applicable for Invoice: {0},C-forma se nevztahuje na faktuře: {0},
CEO,výkonný ředitel,
CESS Amount,Částka CESS,
CGST Amount,CGST částka,
CRM,CRM,
CWIP Account,CWIP účet,
Calculated Bank Statement balance,Vypočtená výpis z bankovního účtu zůstatek,
Calls,Volá,
Campaign,Kampaň,
Can be approved by {0},Může být schválena {0},
"Can not filter based on Account, if grouped by Account","Nelze filtrovat na základě účtu, pokud seskupeny podle účtu",
"Can not filter based on Voucher No, if grouped by Voucher","Nelze filtrovat na základě poukazu ne, pokud seskupeny podle poukazu",
"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Nelze označit Vyprázdněný záznam pacienta, existují nevyfakturované faktury {0}",
Can only make payment against unbilled {0},Lze provést pouze platbu proti nevyfakturované {0},
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""",
"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Metoda oceňování nelze změnit, neboť existují transakce proti některým položkám, které nemají vlastní metodu oceňování",
Can't create standard criteria. Please rename the criteria,Nelze vytvořit standardní kritéria. Kritéria přejmenujte,
Cancel,Zrušit,
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,
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,
Cancel Subscription,Zrušit předplatné,
Cancel the journal entry {0} first,Nejprve zrušte záznam žurnálu {0},
Canceled,Zrušeno,
"Cannot Submit, Employees left to mark attendance","Nelze odeslat, Zaměstnanci odešli, aby označili účast",
Cannot be a fixed asset item as Stock Ledger is created.,"Nemůže být položka fixního aktiva, protože je vytvořena účetní kniha akcií.",
Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože existuje skladový záznam {0}",
Cannot cancel transaction for Completed Work Order.,Nelze zrušit transakci pro dokončenou pracovní objednávku.,
Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},"Nelze zrušit {0} {1}, protože sériové číslo {2} nepatří do skladu {3}",
Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Atributy nelze změnit po transakci akcií. Vytvořte novou položku a přeneste materiál do nové položky,
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ží.",
Cannot change Service Stop Date for item in row {0},Nelze změnit datum ukončení služby pro položku v řádku {0},
Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Vlastnosti Variantu nelze změnit po transakci akcií. Budete muset vytvořit novou položku, abyste to udělali.",
"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.",
Cannot change status as student {0} is linked with student application {1},Nemůže změnit statut studenta {0} je propojen s aplikací studentské {1},
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",
Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu.",
Cannot create Retention Bonus for left Employees,Nelze vytvořit retenční bonus pro levé zaměstnance,
Cannot create a Delivery Trip from Draft documents.,Z koncepčních dokumentů nelze vytvořit výjezd.,
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",
"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena.",
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ý""",
Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nemůže odečíst, pokud kategorie je pro &quot;ocenění&quot; nebo &quot;Vaulation a Total&quot;",
"Cannot delete Serial No {0}, as it is used in stock transactions","Nelze odstranit Pořadové číslo {0}, který se používá na skladě transakcích",
Cannot enroll more than {0} students for this student group.,Nemůže přihlásit více než {0} studentů na této studentské skupiny.,
Cannot find Item with this barcode,Nelze najít položku s tímto čárovým kódem,
Cannot find active Leave Period,Nelze najít aktivní období dovolené,
Cannot produce more Item {0} than Sales Order quantity {1},Nelze produkují více položku {0} než prodejní objednávky množství {1},
Cannot promote Employee with status Left,Zaměstnanec se stavem vlevo nelze podpořit,
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,
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",
Cannot set a received RFQ to No Quote,Nelze nastavit přijatou RFQ na Žádnou nabídku,
Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka.",
Cannot set authorization on basis of Discount for {0},Nelze nastavit oprávnění na základě Sleva pro {0},
Cannot set multiple Item Defaults for a company.,Nelze nastavit více položek Výchozí pro společnost.,
Cannot set quantity less than delivered quantity,Nelze nastavit množství menší než dodané množství,
Cannot set quantity less than received quantity,Nelze nastavit množství menší než přijaté množství,
Cannot set the field <b>{0}</b> for copying in variants,Nelze nastavit pole <b>{0}</b> pro kopírování ve variantách,
Cannot transfer Employee with status Left,Nelze přenést zaměstnance se stavem doleva,
Cannot {0} {1} {2} without any negative outstanding invoice,Nelze {0} {1} {2} bez negativních vynikající faktura,
Capital Equipments,Kapitálové vybavení,
Capital Stock,Základní kapitál,
Capital Work in Progress,Kapitálová práce probíhá,
Cart,Vozík,
Cart is Empty,Košík je prázdný,
Case No(s) already in use. Try from Case No {0},Případ číslo (čísla) již v provozu. Zkuste se věc č {0},
Cash,V hotovosti,
Cash Flow Statement,Přehled o peněžních tocích,
Cash Flow from Financing,Peněžní tok z finanční,
Cash Flow from Investing,Peněžní tok z investičních,
Cash Flow from Operations,Cash flow z provozních činností,
Cash In Hand,Pokladní hotovost,
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,
Cashier Closing,Pokladní pokladna,
Casual Leave,Casual Leave,
Category,Kategorie,
Category Name,Název kategorie,
Caution,Pozor,
Central Tax,Centrální daň,
Certification,Osvědčení,
Cess,Cess,
Change Amount,změna Částka,
Change Item Code,Změnit kód položky,
Change Release Date,Změnit datum vydání,
Change Template Code,Změnit kód šablony,
Changing Customer Group for the selected Customer is not allowed.,Změna skupiny zákazníků pro vybraného zákazníka není povolena.,
Chapter,Kapitola,
Chapter information.,Informace o kapitole.,
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",
Chargeble,Chargeble,
Charges are updated in Purchase Receipt against each item,Poplatky jsou aktualizovány v dokladu o koupi na každou položku,
"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",
Chart Of Accounts,Diagram účtů,
Chart of Cost Centers,Diagram nákladových středisek,
Check all,Zkontrolovat vše,
Checkout,Odhlásit se,
Chemical,Chemický,
Cheque,Šek,
Cheque/Reference No,Šek / Referenční číslo,
Cheques Required,Potřebné kontroly,
Cheques and Deposits incorrectly cleared,Šeky a Vklady nesprávně vymazány,
Child Task exists for this Task. You can not delete this Task.,Dětská úloha existuje pro tuto úlohu. Tuto úlohu nelze odstranit.,
Child nodes can be only created under 'Group' type nodes,Podřízené uzly mohou být vytvořeny pouze na základě typu uzly &quot;skupina&quot;,
Child warehouse exists for this warehouse. You can not delete this warehouse.,Dítě sklad existuje pro tento sklad. Nemůžete odstranit tento sklad.,
Circular Reference Error,Kruhové Referenční Chyba,
City,Město,
City/Town,Město / Město,
Claimed Amount,Požadovaná částka,
Clay,Jíl,
Clear filters,Vymazat filtry,
Clear values,Vymazat hodnoty,
Clearance Date,Výprodej Datum,
Clearance Date not mentioned,Výprodej Datum není uvedeno,
Clearance Date updated,Světlá Datum aktualizováno,
Client,Klient,
Client ID,ID klienta,
Client Secret,Klientské tajemství,
Clinical Procedure,Klinický postup,
Clinical Procedure Template,Šablona klinického postupu,
Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.,
Close Loan,Zavřít půjčku,
Close the POS,Zavřete POS,
Closed,Zavřeno,
Closed order cannot be cancelled. Unclose to cancel.,Uzavřená objednávka nemůže být zrušen. Otevřít zrušit.,
Closing (Cr),Uzavření (Cr),
Closing (Dr),Uzavření (Dr),
Closing (Opening + Total),Uzavření (otevření + celkem),
Closing Account {0} must be of type Liability / Equity,Závěrečný účet {0} musí být typu odpovědnosti / Equity,
Closing Balance,Konečný zůstatek,
Code,Kód,
Collapse All,Sbalit vše,
Color,Barva,
Colour,Barevné,
Combined invoice portion must equal 100%,Kombinovaná část faktury se musí rovnat 100%,
Commercial,Obchodní,
Commission,Provize,
Commission Rate %,Míra Komise%,
Commission on Sales,Provize z prodeje,
Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100,
Community Forum,Forum Community,
Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.,
Company Abbreviation,Zkratka Company,
Company Abbreviation cannot have more than 5 characters,Společnost Zkratka nesmí mít více než 5 znaků,
Company Name,Název společnosti,
Company Name cannot be Company,Název společnosti nemůže být Company,
Company currencies of both the companies should match for Inter Company Transactions.,Společné měny obou společností by měly odpovídat mezipodnikovým transakcím.,
Company is manadatory for company account,Společnost je řídící na účet společnosti,
Company name not same,Název společnosti není stejný,
Company {0} does not exist,Společnost {0} neexistuje,
Compensatory Off,Vyrovnávací Off,
Compensatory leave request days not in valid holidays,Kompenzační prázdniny nejsou v platných prázdninách,
Complaint,Stížnost,
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""",
Completion Date,Dokončení Datum,
Computer,Počítač,
Condition,Podmínka,
Configure,Konfigurovat,
Configure {0},Konfigurovat {0},
Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.,
Connect Amazon with ERPNext,Spojte Amazon s ERPNext,
Connect Shopify with ERPNext,Connect Shopify s ERPNext,
Connect to Quickbooks,Připojte k Quickbookům,
Connected to QuickBooks,Připojeno k QuickBooks,
Connecting to QuickBooks,Připojení ke službě QuickBooks,
Consultation,Konzultace,
Consultations,Konzultace,
Consulting,Consulting,
Consumable,Spotřební,
Consumed,Spotřeba,
Consumed Amount,Spotřebovaném množství,
Consumed Qty,Spotřeba Množství,
Consumer Products,Spotřební zboží,
Contact,Kontakt,
Contact Details,Kontaktní údaje,
Contact Number,Kontaktní číslo,
Contact Us,Kontaktujte nás,
Content,Obsah,
Content Masters,Obsahové mastery,
Content Type,Typ obsahu,
Continue Configuration,Pokračujte v konfiguraci,
Contract,Smlouva,
Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování,
Contribution %,Příspěvek%,
Contribution Amount,Výše příspěvku,
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}",
Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1,
Convert to Group,Převést do skupiny,
Convert to Non-Group,Převést na Non-Group,
Cosmetics,Kosmetika,
Cost Center,Nákladové středisko,
Cost Center Number,Číslo nákladového střediska,
Cost Center and Budgeting,Nákladové středisko a rozpočtování,
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},
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,
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,
Cost Centers,Nákladové středisko,
Cost Updated,Náklady Aktualizováno,
Cost as on,Stát jak na,
Cost of Delivered Items,Náklady na dodávaných výrobků,
Cost of Goods Sold,Náklady na prodej zboží,
Cost of Issued Items,Náklady na vydaných položek,
Cost of New Purchase,Náklady na nový nákup,
Cost of Purchased Items,Náklady na zakoupené zboží,
Cost of Scrapped Asset,Náklady na sešrotována aktiv,
Cost of Sold Asset,Náklady prodaných aktiv,
Cost of various activities,Náklady na různých aktivit,
"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Automaticky se nepodařilo vytvořit kreditní poznámku, zrušte zaškrtnutí políčka Vyměnit kreditní poznámku a odešlete ji znovu",
Could not generate Secret,Nelze generovat tajemství,
Could not retrieve information for {0}.,Nelze načíst informace pro {0}.,
Could not solve criteria score function for {0}. Make sure the formula is valid.,"Nelze vyřešit funkci skóre kritérií pro {0}. Zkontrolujte, zda je vzorec platný.",
Could not solve weighted score function. Make sure the formula is valid.,"Nelze vyřešit funkci váženého skóre. Zkontrolujte, zda je vzorec platný.",
Could not submit some Salary Slips,Nelze odeslat některé výplatní pásky,
"Could not update stock, invoice contains drop shipping item.","Nelze aktualizovat zásob, faktura obsahuje pokles lodní dopravy zboží.",
Country wise default Address Templates,Země moudrý výchozí adresa Templates,
Course,Chod,
Course Code: ,Kód předmětu:,
Course Enrollment {0} does not exists,Zápis do kurzu {0} neexistuje,
Course Schedule,rozvrh,
Course: ,Chod:,
Cr,Cr,
Create,Vytvořit,
Create BOM,Vytvořte kusovník,
Create Delivery Trip,Vytvořit doručovací cestu,
Create Disbursement Entry,Vytvořit záznam o výplatě,
Create Employee,Vytvořit zaměstnance,
Create Employee Records,Vytvořit Zaměstnanecké záznamů,
"Create Employee records to manage leaves, expense claims and payroll","Vytvořit Zaměstnanecké záznamy pro správu listy, prohlášení o výdajích a mezd",
Create Fee Schedule,Vytvořte plán poplatků,
Create Fees,Vytvořte poplatky,
Create Inter Company Journal Entry,Vytvořte položku inter firemního deníku,
Create Invoice,Vytvořit fakturu,
Create Invoices,Vytvářejte faktury,
Create Job Card,Vytvořit pracovní kartu,
Create Journal Entry,Vytvořit zápis do deníku,
Create Lead,Vytvořit potenciálního zákazníka,
Create Leads,vytvoření vede,
Create Maintenance Visit,Vytvořte návštěvu údržby,
Create Material Request,Vytvořit požadavek na materiál,
Create Multiple,Vytvořit více,
Create Opening Sales and Purchase Invoices,Vytvořte otevírací prodejní a nákupní faktury,
Create Payment Entries,Vytvořit platební záznamy,
Create Payment Entry,Vytvořit platební záznam,
Create Print Format,Vytvořit formát tisku,
Create Purchase Order,Vytvořit objednávku,
Create Purchase Orders,Vytvoření objednávek,
Create Quotation,Vytvořit Citace,
Create Salary Slip,Vytvořit výplatní pásce,
Create Salary Slips,Vytvoření platebních karet,
Create Sales Invoice,Vytvořit prodejní fakturu,
Create Sales Order,Vytvoření objednávky prodeje,
Create Sales Orders to help you plan your work and deliver on-time,"Vytvořte prodejní objednávky, které vám pomohou naplánovat práci a doručit včas",
Create Sample Retention Stock Entry,Vytvořte položku Vzorek retenčních zásob,
Create Student,Vytvořit studenta,
Create Student Batch,Vytvořit studentskou dávku,
Create Student Groups,Vytvoření skupiny studentů,
Create Supplier Quotation,Vytvořit nabídku dodavatele,
Create Tax Template,Vytvořte šablonu daně,
Create Timesheet,Vytvoření časového rozvrhu,
Create User,Vytvořit uživatele,
Create Users,Vytvořit uživatele,
Create Variant,Vytvořte variantu,
Create Variants,Vytvoření variant,
"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest.",
Create customer quotes,Vytvořit citace zákazníků,
Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.,
Created By,Vytvořeno (kým),
Created {0} scorecards for {1} between: ,Vytvořili {0} skóre pro {1} mezi:,
Creating Company and Importing Chart of Accounts,Vytváření firemních a importních účtů,
Creating Fees,Vytváření poplatků,
Creating Payment Entries......,Vytváření položek platby ......,
Creating Salary Slips...,Vytváření salicích ...,
Creating student groups,Vytváření studentských skupin,
Creating {0} Invoice,Vytvoření faktury {0},
Credit,Úvěr,
Credit ({0}),Úvěr ({0}),
Credit Account,Úvěrový účet,
Credit Balance,Credit Balance,
Credit Card,Kreditní karta,
Credit Days cannot be a negative number,Dny úvěrů nemohou být záporné číslo,
Credit Limit,Úvěrový limit,
Credit Note,Dobropis,
Credit Note Amount,Částka kreditní poznámky,
Credit Note Issued,Dobropisu vystaveného,
Credit Note {0} has been created automatically,Kreditní poznámka {0} byla vytvořena automaticky,
Credit limit has been crossed for customer {0} ({1}/{2}),Kreditní limit byl překročen pro zákazníka {0} ({1} / {2}),
Creditors,Věřitelé,
Criteria weights must add up to 100%,Kritéria váhy musí obsahovat až 100%,
Crop Cycle,Crop Cycle,
Crops & Lands,Plodiny a půdy,
Currency Exchange must be applicable for Buying or for Selling.,Směnárna musí být platná pro nákup nebo pro prodej.,
Currency can not be changed after making entries using some other currency,Měna nemůže být změněn po provedení položky pomocí jiné měně,
Currency exchange rate master.,Devizový kurz master.,
Currency for {0} must be {1},Měna pro {0} musí být {1},
Currency is required for Price List {0},Měna je vyžadováno pro Ceníku {0},
Currency of the Closing Account must be {0},"Měna závěrečného účtu, musí být {0}",
Currency of the price list {0} must be {1} or {2},Měna ceníku {0} musí být {1} nebo {2},
Currency should be same as Price List Currency: {0},Měna by měla být stejná jako měna Ceníku: {0},
Current,Aktuální,
Current Assets,Oběžná aktiva,
Current BOM and New BOM can not be same,Aktuální BOM a nový BOM nemůže být stejný,
Current Job Openings,Aktuální pracovní příležitosti,
Current Liabilities,Krátkodobé závazky,
Current Qty,Aktuální množství,
Current invoice {0} is missing,Aktuální faktura {0} chybí,
Custom HTML,Vlastní HTML,
Custom?,Přizpůsobit?,
Customer,Zákazník,
Customer Addresses And Contacts,Adresy zákazníků a kontakty,
Customer Contact,Kontakt se zákazníky,
Customer Database.,Databáze zákazníků.,
Customer Group,Zákazník Group,
Customer LPO,Zákazník LPO,
Customer LPO No.,Zákaznické číslo LPO,
Customer Name,Jméno zákazníka,
Customer POS Id,Identifikační číslo zákazníka,
Customer Service,Služby zákazníkům,
Customer and Supplier,Zákazník a dodavatel,
Customer is required,Je nutná zákazník,
Customer isn't enrolled in any Loyalty Program,Zákazník není zapsán do žádného loajálního programu,
Customer required for 'Customerwise Discount',"Zákazník požadoval pro 'Customerwise sleva """,
Customer {0} does not belong to project {1},Zákazník {0} nepatří k projektu {1},
Customer {0} is created.,Zákazník {0} je vytvořen.,
Customers in Queue,Zákazníci ve frontě,
Customize Homepage Sections,Přizpůsobte sekce domovské stránky,
Customizing Forms,Přizpůsobení Formuláře,
Daily Project Summary for {0},Souhrn denního projektu za {0},
Daily Reminders,Denní Upomínky,
Daily Work Summary,Denní práce Souhrn,
Daily Work Summary Group,Denní shrnutí skupiny práce,
Data Import and Export,Import dat a export,
Data Import and Settings,Import a nastavení dat,
Database of potential customers.,Databáze potenciálních zákazníků.,
Date Format,Formát data,
Date Of Retirement must be greater than Date of Joining,"Datum odchodu do důchodu, musí být větší než Datum spojování",
Date is repeated,Datum se opakuje,
Date of Birth,Datum narození,
Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.,
Date of Commencement should be greater than Date of Incorporation,Datum zahájení by mělo být větší než datum založení,
Date of Joining,Datum přistoupení,
Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narození,
Date of Transaction,Datum transakce,
Datetime,Datum a čas,
Day,Den,
Debit,Debet,
Debit ({0}),Debet ({0}),
Debit A/C Number,Číslo debetní platby,
Debit Account,Debetní účet,
Debit Note,Debit Note,
Debit Note Amount,Částka pro debetní poznámku,
Debit Note Issued,Vydání dluhopisu,
Debit To is required,Debetní K je vyžadováno,
Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetní a kreditní nerovná za {0} # {1}. Rozdíl je v tom {2}.,
Debtors,Dlužníci,
Debtors ({0}),Dlužníci ({0}),
Declare Lost,Prohlásit prohry,
Deduction,Dedukce,
Default Activity Cost exists for Activity Type - {0},Existuje Náklady Výchozí aktivity pro Typ aktivity - {0},
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,
Default BOM for {0} not found,Výchozí BOM pro {0} nebyl nalezen,
Default BOM not found for Item {0} and Project {1},Výchozí kusovník nebyl nalezen pro položku {0} a projekt {1},
Default Letter Head,Výchozí hlavičkový,
Default Tax Template,Výchozí daňová šablona,
Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Výchozí měrná jednotka bodu {0} nemůže být změněna přímo, protože jste už nějaké transakce (y) s jiným nerozpuštěných. Budete muset vytvořit novou položku použít jiný výchozí UOM.",
Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Výchozí měrná jednotka varianty &#39;{0}&#39; musí být stejný jako v Template &#39;{1}&#39;,
Default settings for buying transactions.,Výchozí nastavení pro nákup transakcí.,
Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.,
Default tax templates for sales and purchase are created.,Výchozí daňové šablony pro prodej a nákup jsou vytvořeny.,
Defaults,Výchozí,
Defense,Obrana,
Define Project type.,Definujte typ projektu.,
Define budget for a financial year.,Definovat rozpočet pro finanční rok.,
Define various loan types,Definovat různé typy půjček,
Del,Del,
Delay in payment (Days),Zpoždění s platbou (dny),
Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost,
Deletion is not permitted for country {0},Smazání není povoleno pro zemi {0},
Delivered,Dodává,
Delivered Amount,Dodává Částka,
Delivered Qty,Dodává Množství,
Delivered: {0},Dodává: {0},
Delivery,dodávka,
Delivery Date,Dodávka Datum,
Delivery Note,Dodací list,
Delivery Note {0} is not submitted,Delivery Note {0} není předložena,
Delivery Note {0} must not be submitted,Delivery Note {0} nesmí být předloženy,
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,
Delivery Notes {0} updated,Dodací poznámky {0} byly aktualizovány,
Delivery Status,Delivery Status,
Delivery Trip,Výlet za doručení,
Delivery warehouse required for stock item {0},Dodávka sklad potřebný pro živočišnou položku {0},
Department,Oddělení,
Department Stores,Obchodní domy,
Depreciation,Znehodnocení,
Depreciation Amount,odpisy Částka,
Depreciation Amount during the period,Odpisy hodnoty v průběhu období,
Depreciation Date,odpisy Datum,
Depreciation Eliminated due to disposal of assets,Odpisy vypadl v důsledku nakládání s majetkem,
Depreciation Entry,odpisy Entry,
Depreciation Method,odpisy Metoda,
Depreciation Row {0}: Depreciation Start Date is entered as past date,Odpisový řádek {0}: Datum zahájení odpisování je zadáno jako poslední datum,
Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Odpisová řada {0}: Očekávaná hodnota po uplynutí životnosti musí být větší nebo rovna {1},
Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Odpisový řádek {0}: Další datum odpisování nemůže být před datem k dispozici,
Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Odpisový řádek {0}: Další datum odpisu nemůže být před datem nákupu,
Designer,Návrhář,
Detailed Reason,Podrobný důvod,
Details,Podrobnosti,
Details of Outward Supplies and inward supplies liable to reverse charge,Podrobnosti o vnějších dodávkách a vnitřních dodávkách podléhajících zpětnému poplatku,
Details of the operations carried out.,Podrobnosti o prováděných operací.,
Diagnosis,Diagnóza,
Did not find any item called {0},Nenalezl žádnou položku s názvem {0},
Diff Qty,Rozdílové množství,
Difference Account,Rozdíl účtu,
"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Rozdíl účet musí být typu aktiv / Odpovědnost účet, protože to Reklamní Smíření je Entry Otevření",
Difference Amount,Rozdíl Částka,
Difference Amount must be zero,Rozdíl Částka musí být nula,
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.",
Direct Expenses,Přímé náklady,
Direct Income,Přímý příjmů,
Disable,Zakázat,
Disabled template must not be default template,Bezbariérový šablona nesmí být výchozí šablonu,
Disburse Loan,Výplata půjčky,
Disbursed,Vyčerpáno,
Disc,Disk,
Discharge,Vybít,
Discount,Sleva,
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.,
Discount must be less than 100,Sleva musí být menší než 100,
Diseases & Fertilizers,Nemoci a hnojiva,
Dispatch,Odeslání,
Dispatch Notification,Oznámení o odeslání,
Dispatch State,Stav odeslání,
Distance,Vzdálenost,
Distribution,Distribuce,
Distributor,Distributor,
Dividends Paid,Dividendy placené,
Do you really want to restore this scrapped asset?,Opravdu chcete obnovit tento vyřazen aktivum?,
Do you really want to scrap this asset?,Opravdu chcete zrušit tuto pohledávku?,
Do you want to notify all the customers by email?,Chcete upozornit všechny zákazníky e-mailem?,
Doc Date,Datum dokumentu,
Doc Name,Doc Name,
Doc Type,Doc Type,
Docs Search,Vyhledávání dokumentů,
Document Name,Název dokumentu,
Document Status,Stav dokumentu,
Document Type,Typ dokumentu,
Domain,Doména,
Domains,Domény,
Done,Hotový,
Donor,Dárce,
Donor Type information.,Informace o typu dárce.,
Donor information.,Informace dárce.,
Download JSON,Stáhněte si JSON,
Draft,Návrh,
Drop Ship,Drop Loď,
Drug,Lék,
Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0},
Due Date cannot be before Posting / Supplier Invoice Date,Datum splatnosti nesmí být před datem odeslání / fakturace dodavatele,
Due Date is mandatory,Datum splatnosti je povinné,
Duplicate Entry. Please check Authorization Rule {0},Duplicitní záznam. Zkontrolujte autorizační pravidlo {0},
Duplicate Serial No entered for Item {0},Duplicitní Pořadové číslo vstoupil k bodu {0},
Duplicate customer group found in the cutomer group table,Duplicitní skupinu zákazníků uvedeny v tabulce na knihy zákazníků skupiny,
Duplicate entry,duplicitní záznam,
Duplicate item group found in the item group table,Duplicitní skupinu položek uvedeny v tabulce na položku ve skupině,
Duplicate roll number for student {0},Duplicitní číslo role pro studenty {0},
Duplicate row {0} with same {1},Duplicitní řádek {0} se stejným {1},
Duplicate {0} found in the table,V tabulce byl nalezen duplikát {0},
Duration in Days,Trvání ve dnech,
Duties and Taxes,Odvody a daně,
E-Invoicing Information Missing,Chybí informace o elektronické fakturaci,
ERPNext Demo,ERPNext Demo,
ERPNext Settings,ERPDalší nastavení,
Earliest,Nejstarší,
Earnest Money,Earnest Money,
Earning,Získávání,
Edit,Upravit,
Edit Publishing Details,Upravit podrobnosti publikování,
"Edit in full page for more options like assets, serial nos, batches etc.","Upravte celou stránku pro další možnosti, jako jsou majetek, sériový nos, šarže atd.",
Education,Vzdělání,
Either location or employee must be required,Musí být požadováno umístění nebo zaměstnanec,
Either target qty or target amount is mandatory,Buď cílové množství nebo cílová částka je povinná,
Either target qty or target amount is mandatory.,Buď cílové množství nebo cílová částka je povinná.,
Electrical,Elektrický,
Electronic Equipments,Elektronická zařízení,
Electronics,Elektronika,
Eligible ITC,Způsobilé ITC,
Email Account,E-mailový účet,
Email Address,Emailová adresa,
"Email Address must be unique, already exists for {0}","E-mailová adresa musí být jedinečná, již existuje pro {0}",
Email Digest: ,E-mail Digest:,
Email Reminders will be sent to all parties with email contacts,E-mailové připomenutí budou zasílány všem stranám s e-mailovými kontakty,
Email Sent,Email odeslán,
Email Template,Šablona e-mailu,
Email not found in default contact,E-mail nebyl nalezen ve výchozím kontaktu,
Email sent to {0},Email odeslán (komu) {0},
Employee,Zaměstnanec,
Employee A/C Number,Číslo A / C zaměstnance,
Employee Advances,Zaměstnanecké zálohy,
Employee Benefits,Zaměstnanecké benefity,
Employee Grade,Pracovní zařazení,
Employee ID,ID zaměstnance,
Employee Lifecycle,Životní cyklus zaměstnanců,
Employee Name,jméno zaměstnance,
Employee Promotion cannot be submitted before Promotion Date ,Propagace zaměstnanců nelze předložit před datem propagace,
Employee Referral,Doporučení zaměstnance,
Employee Transfer cannot be submitted before Transfer Date ,Převod zaměstnanců nelze předložit před datem převodu,
Employee cannot report to himself.,Zaměstnanec nemůže odpovídat sám sobě.,
Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left""",
Employee status cannot be set to 'Left' as following employees are currently reporting to this employee:&nbsp;,"Stav zaměstnance nelze nastavit na „Vlevo“, protože následující zaměstnanci v současné době hlásí tomuto zaměstnanci:",
Employee {0} already submited an apllication {1} for the payroll period {2},Zaměstnanec {0} již podal žádost o platbu {2} {1},
Employee {0} has already applied for {1} between {2} and {3} : ,Zaměstnanec {0} již požádal {1} mezi {2} a {3}:,
Employee {0} has no maximum benefit amount,Zaměstnanec {0} nemá maximální částku prospěchu,
Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje,
Employee {0} is on Leave on {1},Zaměstnanec {0} je zapnut Nechat na {1},
Employee {0} of grade {1} have no default leave policy,Zaměstnanec {0} z platové třídy {1} nemá žádnou výchozí politiku dovolené,
Employee {0} on Half day on {1},Zaměstnanec {0} na půl dne na {1},
Enable,Zapnout,
Enable / disable currencies.,Povolit / zakázat měny.,
Enabled,Zapnuto,
"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Povolení &quot;použití pro nákupního košíku&quot;, jak je povoleno Nákupní košík a tam by měla být alespoň jedna daňová pravidla pro Košík",
End Date,Datum ukončení,
End Date can not be less than Start Date,Datum ukončení nesmí být menší než datum zahájení,
End Date cannot be before Start Date.,Datum ukončení nemůže být před datem zahájení.,
End Year,Konec roku,
End Year cannot be before Start Year,Konec roku nemůže být před uvedením do provozu roku,
End on,Ukončete,
End time cannot be before start time,Čas ukončení nemůže být před časem zahájení,
Ends On date cannot be before Next Contact Date.,Datum ukončení nemůže být před datem dalšího kontaktu.,
Energy,Energie,
Engineer,Inženýr,
Enough Parts to Build,Dost Části vybudovat,
Enroll,Zapsat,
Enrolling student,učící studenta,
Enrolling students,Přijímání studentů,
Enter depreciation details,Zadejte podrobnosti o odpisu,
Enter the Bank Guarantee Number before submittting.,Zadejte číslo bankovní záruky před odesláním.,
Enter the name of the Beneficiary before submittting.,Před odesláním zadejte jméno příjemce.,
Enter the name of the bank or lending institution before submittting.,Před zasláním zadejte název banky nebo instituce poskytující úvěr.,
Enter value betweeen {0} and {1},Zadejte hodnotu mezi {0} a {1},
Entertainment & Leisure,Entertainment & Leisure,
Entertainment Expenses,Výdaje na reprezentaci,
Equity,Hodnota majetku,
Error Log,Error Log,
Error evaluating the criteria formula,Chyba při vyhodnocování vzorce kritéria,
Error in formula or condition: {0},Chyba ve vzorci nebo stavu: {0},
Error: Not a valid id?,Chyba: Není platný id?,
Estimated Cost,Odhadované náklady,
Evaluation,ohodnocení,
"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:",
Event,Událost,
Event Location,Umístění události,
Event Name,Název události,
Exchange Gain/Loss,Exchange zisk / ztráta,
Exchange Rate Revaluation master.,Velitel přehodnocení směnného kurzu.,
Exchange Rate must be same as {0} {1} ({2}),Exchange Rate musí být stejná jako {0} {1} ({2}),
Excise Invoice,Spotřební Faktura,
Execution,Provedení,
Executive Search,Executive Search,
Expand All,Rozšířit vše,
Expected Delivery Date,Očekávané datum dodání,
Expected Delivery Date should be after Sales Order Date,Očekávaný termín dodání by měl být po datu objednávky,
Expected End Date,Očekávané datum ukončení,
Expected Hrs,Očekávané hodiny,
Expected Start Date,Očekávané datum zahájení,
Expense,Výdaj,
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",
Expense Account,Účtet nákladů,
Expense Claim,Hrazení nákladů,
Expense Claim for Vehicle Log {0},Náklady Nárok na Vehicle Log {0},
Expense Claim {0} already exists for the Vehicle Log,Náklady na pojistná {0} již existuje pro jízd,
Expense Claims,Nákladové Pohledávky,
Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0},
Expenses,Výdaje,
Expenses Included In Asset Valuation,Náklady zahrnuté do ocenění majetku,
Expenses Included In Valuation,Náklady ceně oceňování,
Expired Batches,Zaniklé dávky,
Expires On,vyprší dne,
Expiring On,Vypnuto Zapnuto,
Expiry (In Days),Doba použitelnosti (ve dnech),
Explore,Prozkoumat,
Export E-Invoices,Export elektronických faktur,
Extra Large,Extra velké,
Extra Small,Extra Malé,
Fail,Selhat,
Failed,Nepodařilo,
Failed to create website,Nepodařilo se vytvořit webové stránky,
Failed to install presets,Instalace předvoleb se nezdařila,
Failed to login,Přihlášení selhalo,
Failed to setup company,Nepodařilo se nastavit firmu,
Failed to setup defaults,Výchozí nastavení se nezdařilo,
Failed to setup post company fixtures,Nepodařilo se nastavit příslušenství společnosti,
Fax,Fax,
Fee,Poplatek,
Fee Created,Poplatek byl vytvořen,
Fee Creation Failed,Vytvoření poplatku se nezdařilo,
Fee Creation Pending,Vytváření poplatků čeká,
Fee Records Created - {0},Fee Records Vytvořil - {0},
Feedback,Zpětná vazba,
Fees,Poplatky,
Female,Žena,
Fetch Data,Načíst data,
Fetch Subscription Updates,Načíst aktualizace předplatného,
Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin),
Fetching records......,Načítání záznamů ......,
Field Name,Název pole,
Fieldname,Název pole,
Fields,Pole,
Fill the form and save it,Vyplňte formulář a uložte jej,
Filter Employees By (Optional),Filtrovat zaměstnance podle (volitelné),
"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Řádek č. Filtru: {0}: Název pole <b>{1}</b> musí být typu &quot;Link&quot; nebo &quot;Table MultiSelect&quot;,
Filter Total Zero Qty,Filtr Celkový počet nula,
Finance Book,Finanční kniha,
Financial / accounting year.,Finanční / účetní rok.,
Financial Services,Finanční služby,
Financial Statements,Finanční výkazy,
Financial Year,Finanční rok,
Finish,Dokončit,
Finished Good,Hotovo dobrá,
Finished Good Item Code,Kód dokončeného zboží,
Finished Goods,Hotové zboží,
Finished Item {0} must be entered for Manufacture type entry,Dokončeno Položka {0} musí být zadán pro vstup typu Výroba,
Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Množství hotového produktu <b>{0}</b> a Pro množství <b>{1}</b> se nemohou lišit,
First Name,Křestní jméno,
"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiskální režim je povinný, laskavě nastavte fiskální režim ve společnosti {0}",
Fiscal Year,Fiskální rok,
Fiscal Year End Date should be one year after Fiscal Year Start Date,Datum ukončení fiskálního roku by mělo být jeden rok po datu zahájení fiskálního roku,
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},
Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Datum zahájení fiskálního roku by mělo být o jeden rok dříve než datum ukončení fiskálního roku,
Fiscal Year {0} does not exist,Fiskální rok {0} neexistuje,
Fiscal Year {0} is required,Fiskální rok {0} je vyžadována,
Fiscal Year {0} not found,Fiskální rok {0} nebyl nalezen,
Fixed Asset,Základní Jmění,
Fixed Asset Item must be a non-stock item.,Fixed Asset položky musí být non-skladová položka.,
Fixed Assets,Dlouhodobý majetek,
Following Material Requests have been raised automatically based on Item's re-order level,Následující materiál žádosti byly automaticky zvýšena na základě úrovni re-pořadí položky,
Following accounts might be selected in GST Settings:,V nastavení GST lze vybrat následující účty:,
Following course schedules were created,Byly vytvořeny následující kurzy,
Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Následující položka {0} není označena jako {1} položka. Můžete je povolit jako {1} položku z jeho položky Master,
Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Následující položky {0} nejsou označeny jako položka {1}. Můžete je povolit jako {1} položku z jeho položky Master,
Food,Jídlo,
"Food, Beverage & Tobacco","Potraviny, nápoje a tabák",
For,Pro,
"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pro &quot;produktem Bundle předměty, sklad, sériové číslo a dávkové No bude považována ze&quot; Balení seznam &#39;tabulky. Pokud Warehouse a Batch No jsou stejné pro všechny balení položky pro jakoukoli &quot;Výrobek balík&quot; položky, tyto hodnoty mohou být zapsány do hlavní tabulky položky, budou hodnoty zkopírovány do &quot;Balení seznam&quot; tabulku.",
For Employee,Pro zaměstnance,
For Quantity (Manufactured Qty) is mandatory,Pro Množství (Vyrobeno ks) je povinné,
For Supplier,Pro dodavatele,
For Warehouse,Pro sklad,
For Warehouse is required before Submit,Pro Sklad je povinné před Odesláním,
"For an item {0}, quantity must be negative number",U položky {0} musí být množství záporné číslo,
"For an item {0}, quantity must be positive number",U položky {0} musí být množství kladné číslo,
"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",U karty zaměstnání {0} můžete provést pouze záznam typu „Převod materiálu pro výrobu“,
"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",
For row {0}: Enter Planned Qty,Pro řádek {0}: Zadejte plánované množství,
"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í",
"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í",
Form View,Zobrazení formuláře,
Forum Activity,Aktivita fóra,
Free item code is not selected,Volný kód položky není vybrán,
Freight and Forwarding Charges,Nákladní a Spediční Poplatky,
Frequency,Frekvence,
Friday,Pátek,
From,Od,
From Address 1,Z adresy 1,
From Address 2,Z adresy 2,
From Currency and To Currency cannot be same,Z měny a měny nemůže být stejné,
From Date and To Date lie in different Fiscal Year,Od data a do data leží v různých fiskálních letech,
From Date cannot be greater than To Date,Datum OD nemůže být vetší než datum DO,
From Date must be before To Date,Datum od musí být dříve než datum do,
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}",
From Date {0} cannot be after employee's relieving Date {1},Od data {0} nemůže být po uvolnění zaměstnance Datum {1},
From Date {0} cannot be before employee's joining Date {1},Od data {0} nemůže být před datem vstupu do pracovního poměru {1},
From Datetime,Od Datetime,
From Delivery Note,Z Dodacího Listu,
From Fiscal Year,Od fiskálního roku,
From GSTIN,Od GSTINu,
From Party Name,Od názvu strany,
From Pin Code,Z kódu PIN,
From Place,Z místa,
From Range has to be less than To Range,"Z rozsahu, musí být nižší než na Range",
From State,Z státu,
From Time,Času od,
From Time Should Be Less Than To Time,Od času by mělo být méně než čas,
From Time cannot be greater than To Time.,Od doby nemůže být větší než na čas.,
"From a supplier under composition scheme, Exempt and Nil rated",Od dodavatele v rámci skladebního schématu je společnost Vyjímka a Nil hodnocena,
From and To dates required,Data OD a DO jsou vyžadována,
From date can not be less than employee's joining date,"Od data nemůže být menší, než je datum spojení",
From value must be less than to value in row {0},Z hodnota musí být menší než hodnota v řadě {0},
From {0} | {1} {2},Od {0} | {1} {2},
Fuel Price,palivo Cena,
Fuel Qty,palivo Množství,
Fulfillment,Splnění,
Full,Plný,
Full Name,Celé jméno/název,
Full-time,Na plný úvazek,
Fully Depreciated,plně odepsán,
Furnitures and Fixtures,Nábytek a svítidla,
"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",
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",
Further nodes can be only created under 'Group' type nodes,"Další uzly mohou být pouze vytvořena v uzlech typu ""skupiny""",
Future dates not allowed,Budoucí data nejsou povolena,
GSTIN,GSTIN,
GSTR3B-Form,GSTR3B-Form,
Gain/Loss on Asset Disposal,Zisk / ztráta z aktiv likvidaci,
Gantt Chart,Pruhový diagram,
Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.,
Gender,Pohlaví,
General,Obecný,
General Ledger,Hlavní Účetní Kniha,
Generate Material Requests (MRP) and Work Orders.,Generování žádostí o materiál (MRP) a pracovních příkazů.,
Generate Secret,Generovat tajemství,
Get Details From Declaration,Získejte podrobnosti z prohlášení,
Get Employees,Získejte zaměstnance,
Get Invocies,Získejte Faktury,
Get Invoices,Získejte faktury,
Get Invoices based on Filters,Získejte faktury na základě filtrů,
Get Items from BOM,Položka získaná z BOM,
Get Items from Healthcare Services,Získejte položky od zdravotnických služeb,
Get Items from Prescriptions,Získejte položky z předpisu,
Get Items from Product Bundle,Položka získaná ze souboru výrobků,
Get Suppliers,Získejte dodavatele,
Get Suppliers By,Získejte Dodavatelé,
Get Updates,Získat aktualizace,
Get customers from,Získejte zákazníky z,
Get from Patient Encounter,Získejte z setkání pacienta,
Getting Started,Začínáme,
GitHub Sync ID,ID synchronizace GitHub,
Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.,
Go to the Desktop and start using ERPNext,Přejděte na plochu a začít používat ERPNext,
GoCardless SEPA Mandate,GoCardless SEPA Mandát,
GoCardless payment gateway settings,Nastavení platební brány GoCardless,
Goal and Procedure,Cíl a postup,
Goals cannot be empty,Cíle nemůže být prázdný,
Goods In Transit,Zboží v tranzitu,
Goods Transferred,Převedené zboží,
Goods and Services Tax (GST India),Daň z zboží a služeb (GST India),
Goods are already received against the outward entry {0},Zboží je již přijato proti vnějšímu vstupu {0},
Government,Vláda,
Grand Total,Celkem,
Grant,Grant,
Grant Application,Žádost o grant,
Grant Leaves,Grantové listy,
Grant information.,Poskytněte informace.,
Grocery,Potraviny,
Gross Pay,Hrubé mzdy,
Gross Profit,Hrubý zisk,
Gross Profit %,Hrubý zisk %,
Gross Profit / Loss,Hrubý zisk / ztráta,
Gross Purchase Amount,Gross Částka nákupu,
Gross Purchase Amount is mandatory,Gross Částka nákupu je povinná,
Group by Account,Seskupit podle účtu,
Group by Party,Seskupit podle strany,
Group by Voucher,Seskupit podle Poukazu,
Group by Voucher (Consolidated),Seskupit podle poukázky (konsolidované),
Group node warehouse is not allowed to select for transactions,Uzel skupina sklad není dovoleno vybrat pro transakce,
Group to Non-Group,Skupina na Non-Group,
Group your students in batches,Skupina vaši studenti v dávkách,
Groups,Skupiny,
Guardian1 Email ID,ID e-mailu Guardian1,
Guardian1 Mobile No,Guardian1 Mobile Žádné,
Guardian1 Name,Jméno Guardian1,
Guardian2 Email ID,ID e-mailu Guardian2,
Guardian2 Mobile No,Guardian2 Mobile Žádné,
Guardian2 Name,Jméno Guardian2,
Guest,Host,
HR Manager,HR Manager,
HSN,HSN,
HSN/SAC,HSN / SAC,
Half Day,Půl den,
Half Day Date is mandatory,Poloviční den je povinný,
Half Day Date should be between From Date and To Date,Half Day Date by měla být v rozmezí Datum od a do dnešního dne,
Half Day Date should be in between Work From Date and Work End Date,Den poločasu by měl být mezi dnem práce a datem ukončení práce,
Half Yearly,Pololetní,
Half day date should be in between from date and to date,Denní datum by mělo být mezi dnem a dnem,
Half-Yearly,Pololetní,
Hardware,Technické vybavení,
Head of Marketing and Sales,Vedoucí marketingu a prodeje,
Health Care,Péče o zdraví,
Healthcare,Zdravotní péče,
Healthcare (beta),Zdravotnictví (beta),
Healthcare Practitioner,Zdravotnický praktik,
Healthcare Practitioner not available on {0},Lékař není k dispozici na {0},
Healthcare Practitioner {0} not available on {1},Lékařský lékař {0} není dostupný v {1},
Healthcare Service Unit,Jednotka zdravotnických služeb,
Healthcare Service Unit Tree,Strom jednotky zdravotnických služeb,
Healthcare Service Unit Type,Typ jednotky zdravotnické služby,
Healthcare Services,Zdravotnické služby,
Healthcare Settings,Nastavení zdravotní péče,
Hello,Ahoj,
Help Results for,Výsledky nápovědy pro,
High,Vysoké,
High Sensitivity,Vysoká citlivost,
Hold,Držet,
Hold Invoice,Podržte fakturu,
Holiday,Dovolená,
Holiday List,Seznam dovolené,
Hotel Rooms of type {0} are unavailable on {1},Hotel Pokoje typu {0} nejsou k dispozici v {1},
Hotels,Hotely,
Hourly,Hodinově,
Hours,Hodiny,
House rent paid days overlapping with {0},Nájemné za zaplacené dny se překrývá s {0},
House rented dates required for exemption calculation,"Dny pronajaté v domě, které jsou zapotřebí k výpočtu výjimky",
House rented dates should be atleast 15 days apart,Domovní pronajaté data by měly být nejméně 15 dnů od sebe,
How Pricing Rule is applied?,Jak je pravidlo platby aplikováno?,
Hub Category,Kategorie Hubu,
Hub Sync ID,ID synchronizace Hubu,
Human Resource,Lidské zdroje,
Human Resources,Lidské zdroje,
IFSC Code,Kód IFSC,
IGST Amount,IGST částka,
IP Address,IP adresa,
ITC Available (whether in full op part),ITC k dispozici (ať už v plné op části),
ITC Reversed,ITC obrácené,
Identifying Decision Makers,Identifikace rozhodovacích orgánů,
"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Pokud je zaškrtnuto políčko Auto Opt In, zákazníci budou automaticky propojeni s daným věrným programem (při uložení)",
"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.",
"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Je-li vybráno pravidlo pro stanovení cen, provede se přepínání ceníku. Cenová sazba Pravidlo je konečná sazba, takže by neměla být použita žádná další sleva. Proto v transakcích, jako je Prodejní objednávka, Objednávka apod., Bude vybírána v poli &#39;Cena&#39; namísto &#39;Pole cenových listů&#39;.",
"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.",
"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",Při neomezeném uplynutí platnosti věrnostních bodů nechte dobu trvání platnosti prázdné nebo 0.,
"If you have any questions, please get back to us.","Pokud máte jakékoliv dotazy, prosím, dostat zpátky k nám.",
Ignore Existing Ordered Qty,Ignorovat existující objednané množství,
Image,Obrázek,
Image View,Image View,
Import Data,Import dat,
Import Day Book Data,Importovat údaje o denní knize,
Import Log,Záznam importu,
Import Master Data,Import kmenových dat,
Import in Bulk,Dovoz hromadnou,
Import of goods,Dovoz zboží,
Import of services,Dovoz služeb,
Importing Items and UOMs,Import položek a UOM,
Importing Parties and Addresses,Dovážející strany a adresy,
In Maintenance,V Údržbě,
In Production,Ve výrobě,
In Qty,V množství,
In Stock Qty,Na skladě Množství,
In Stock: ,Na skladě:,
In Value,v Hodnota,
"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent",V případě víceúrovňového programu budou zákazníci automaticky přiděleni danému vrstvě podle svých vynaložených nákladů,
Inactive,Neaktivní,
Incentives,Pobídky,
Include Default Book Entries,Zahrnout výchozí položky knihy,
Include Exploded Items,Zahrnout výbušné položky,
Include POS Transactions,Zahrnout POS transakce,
Include UOM,Zahrnout UOM,
Included in Gross Profit,Zahrnuto do hrubého zisku,
Income,Příjem,
Income Account,Účet příjmů,
Income Tax,Daň z příjmu,
Incoming,Přicházející,
Incoming Rate,Příchozí Rate,
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.,
Increment cannot be 0,Přírůstek nemůže být 0,
Increment for Attribute {0} cannot be 0,Přírůstek pro atribut {0} nemůže být 0,
Indirect Expenses,Nepřímé náklady,
Indirect Income,Nepřímé příjmy,
Individual,Individuální,
Ineligible ITC,Nezpůsobilé ITC,
Initiated,Zahájil,
Inpatient Record,Ústavní záznam,
Insert,Vložit,
Installation Note,Poznámka k instalaci,
Installation Note {0} has already been submitted,Poznámka k instalaci {0} již byla odeslána,
Installation date cannot be before delivery date for Item {0},Datum Instalace nemůže být před datem dodání pro bod {0},
Installing presets,Instalace předvoleb,
Institute Abbreviation,institut Zkratka,
Institute Name,Jméno Institute,
Instructor,Instruktor,
Insufficient Stock,nedostatečná Sklad,
Insurance Start date should be less than Insurance End date,Datum pojištění startu by měla být menší než pojištění koncovým datem,
Integrated Tax,Integrovaná daň,
Inter-State Supplies,Mezistátní dodávky,
Interest Amount,Zájem Částka,
Interests,zájmy,
Intern,Internovat,
Internet Publishing,Internet Publishing,
Intra-State Supplies,Vnitrostátní zásoby,
Introduction,Úvod,
Invalid Attribute,Neplatný atribut,
Invalid Blanket Order for the selected Customer and Item,Neplatná objednávka prázdné objednávky pro vybraného zákazníka a položku,
Invalid Company for Inter Company Transaction.,Neplatná společnost pro mezipodnikovou transakci.,
Invalid GSTIN! A GSTIN must have 15 characters.,Neplatný GSTIN! GSTIN musí mít 15 znaků.,
Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Neplatný GSTIN! První 2 číslice GSTIN by měly odpovídat číslu státu {0}.,
Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Neplatný GSTIN! Zadaný vstup neodpovídá formátu GSTIN.,
Invalid Posting Time,Neplatný čas přidávání,
Invalid attribute {0} {1},Neplatný atribut {0} {1},
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.,
Invalid reference {0} {1},Neplatná reference {0} {1},
Invalid {0},Neplatný {0},
Invalid {0} for Inter Company Transaction.,Neplatné pro transakci mezi společnostmi {0}.,
Invalid {0}: {1},Neplatný {0}: {1},
Inventory,Inventář,
Investment Banking,Investiční bankovnictví,
Investments,Investice,
Invoice,Faktura,
Invoice Created,Faktura byla vytvořena,
Invoice Discounting,Diskontování faktur,
Invoice Patient Registration,Fakturační registrace pacienta,
Invoice Posting Date,Faktura Datum zveřejnění,
Invoice Type,Typ faktury,
Invoice already created for all billing hours,Faktura již vytvořená pro všechny fakturační hodiny,
Invoice can't be made for zero billing hour,Fakturu nelze provést za nulovou fakturační hodinu,
Invoice {0} no longer exists,Faktura {0} již neexistuje,
Invoiced,Fakturováno,
Invoiced Amount,Fakturovaná částka,
Invoices,Faktury,
Invoices for Costumers.,Faktury pro zákazníky.,
Inward supplies from ISD,Spotřební materiál od ISD,
Inward supplies liable to reverse charge (other than 1 & 2 above),Dočasné dodávky podléhající zpětnému poplatku (jiné než výše uvedené výše 1 a 2),
Is Active,Je Aktivní,
Is Default,Je Výchozí,
Is Existing Asset,Je existujícímu aktivu,
Is Frozen,Je Frozen,
Is Group,Is Group,
Issue,Problém,
Issue Material,Vydání Material,
Issued,Vydáno,
Issues,Problémy,
It is needed to fetch Item Details.,"Je třeba, aby přinesla Detaily položky.",
Item,Položka,
Item 1,Položka 1,
Item 2,Položka 2,
Item 3,Položka 3,
Item 4,Bod 4,
Item 5,Bod 5,
Item Cart,Item košík,
Item Code,Kód položky,
Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.,
Item Code required at Row No {0},Kód položky třeba na řádku č {0},
Item Description,Položka Popis,
Item Group,Skupina položek,
Item Group Tree,Strom skupin položek,
Item Group not mentioned in item master for item {0},Položka Group není uvedeno v položce mistra na položku {0},
Item Name,Název položky,
Item Price added for {0} in Price List {1},Položka Cena přidán pro {0} v Ceníku {1},
"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Položka Cena se objeví několikrát na základě Ceníku, Dodavatele / Zákazníka, Měny, Položky, UOM, Množství a Dat.",
Item Price updated for {0} in Price List {1},Položka Cena aktualizován pro {0} v Ceníku {1},
Item Row {0}: {1} {2} does not exist in above '{1}' table,Položka Řádek {0}: {1} {2} neexistuje nad tabulkou {1},
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í",
Item Template,Šablona položky,
Item Variant Settings,Nastavení varianty položky,
Item Variant {0} already exists with same attributes,Bod Variant {0} již existuje se stejnými vlastnostmi,
Item Variants,Položka Varianty,
Item Variants updated,Varianty položek byly aktualizovány,
Item has variants.,Položka má varianty.,
Item must be added using 'Get Items from Purchase Receipts' button,"Položka musí být přidána pomocí tlačítka""položka získaná z dodacího listu""",
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,
Item variant {0} exists with same attributes,Bod varianta {0} existuje s stejné atributy,
Item {0} does not exist,Bod {0} neexistuje,
Item {0} does not exist in the system or has expired,Bod {0} neexistuje v systému nebo vypršela,
Item {0} has already been returned,Bod {0} již byla vrácena,
Item {0} has been disabled,Item {0} byl zakázán,
Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1},
Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem",
"Item {0} is a template, please select one of its variants","Položka {0} je šablona, prosím vyberte jednu z jeho variant",
Item {0} is cancelled,Položka {0} je zrušen,
Item {0} is disabled,Položka {0} je zakázána,
Item {0} is not a serialized Item,Položka {0} není serializovat položky,
Item {0} is not a stock Item,Položka {0} není skladem,
Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života",
Item {0} is not setup for Serial Nos. Check Item master,"Položka {0} není nastavení pro Serial č. Zkontrolujte, zda master položku",
Item {0} is not setup for Serial Nos. Column must be blank,Položka {0} není nastavení pro Serial č. Sloupec musí být prázdný,
Item {0} must be a Fixed Asset Item,Item {0} musí být dlouhodobá aktiva položka,
Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item,
Item {0} must be a non-stock item,Item {0} musí být non-skladová položka,
Item {0} must be a stock Item,Položka {0} musí být skladem,
Item {0} not found,Položka {0} nebyl nalezen,
Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebyl nalezen v &quot;suroviny dodané&quot; tabulky v objednávce {1},
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).,
Item: {0} does not exist in the system,Položka: {0} neexistuje v systému,
Items,Položky,
Items Filter,Položka Filtr,
Items and Pricing,Položky a ceny,
Items for Raw Material Request,Položky pro požadavek na suroviny,
Job Card,Pracovní karta,
Job Description,Popis práce,
Job Offer,Nabídka práce,
Job card {0} created,Byla vytvořena karta {0},
Jobs,Jobs,
Join,Připojit,
Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený,
Journal Entry,Zápis do deníku,
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,
Kanban Board,Kanban Board,
Key Reports,Klíčové zprávy,
LMS Activity,Aktivita LMS,
Lab Test,Laboratorní test,
Lab Test Report,Zkušební protokol,
Lab Test Sample,Laboratorní testovací vzorek,
Lab Test Template,Šablona zkušebního laboratoře,
Lab Test UOM,Laboratorní test UOM,
Lab Tests and Vital Signs,Laboratorní testy a vitální znaky,
Lab result datetime cannot be before testing datetime,Výsledek datového laboratoře nemůže být před datem testování,
Lab testing datetime cannot be before collection datetime,Laboratoř data testování nemůže být před datem sběru,
Label,Popisek,
Laboratory,Laboratoř,
Language Name,Název jazyka,
Large,Velký,
Last Communication,Poslední komunikace,
Last Communication Date,Poslední datum komunikace,
Last Name,Příjmení,
Last Order Amount,Částka poslední objednávky,
Last Order Date,Datum poslední objednávky,
Last Purchase Price,Poslední kupní cena,
Last Purchase Rate,Poslední nákupní sazba,
Latest,Nejnovější,
Latest price updated in all BOMs,Poslední cena byla aktualizována ve všech kusovnících,
Lead,Lead,
Lead Count,Počet vedoucích,
Lead Owner,Majitel leadu,
Lead Owner cannot be same as the Lead,Olovo Majitel nemůže být stejný jako olovo,
Lead Time Days,Dodací lhůta dny,
Lead to Quotation,Lead na nabídku,
"Leads help you get business, add all your contacts and more as your leads","Vede vám pomohou podnikání, přidejte všechny své kontakty a více jak svých potenciálních zákazníků",
Learn,Učit se,
Leave Approval Notification,Zanechat oznámení o schválení,
Leave Blocked,Absence blokována,
Leave Encashment,Nechat inkasa,
Leave Management,Správa absencí,
Leave Status Notification,Odešlete oznámení o stavu,
Leave Type,Typ absence,
Leave Type is madatory,Typ dovolené je špatný,
Leave Type {0} cannot be allocated since it is leave without pay,"Nechat Typ {0} nemůže být přidělena, neboť se odejít bez zaplacení",
Leave Type {0} cannot be carry-forwarded,Nechte typ {0} nelze provádět předávány,
Leave Type {0} is not encashable,Opustit typ {0} není vyměnitelný,
Leave Without Pay,Volno bez nároku na mzdu,
Leave and Attendance,Nechat docházky,
Leave application {0} already exists against the student {1},Ponechat aplikaci {0} již proti studentovi {1},
"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Dovolená nemůže být přiděleny před {0}, protože rovnováha dovolené již bylo carry-předávány v budoucí přidělení dovolenou záznamu {1}",
"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Nechte nelze aplikovat / zrušena před {0}, protože rovnováha dovolené již bylo carry-předávány v budoucí přidělení dovolenou záznamu {1}",
Leave of type {0} cannot be longer than {1},Absence typu {0} nemůže být delší než {1},
Leave the field empty to make purchase orders for all suppliers,"Ponechte prázdné pole, abyste mohli objednávat všechny dodavatele",
Leaves,Listy,
Leaves Allocated Successfully for {0},Dovolená úspěšně přidělena {0},
Leaves has been granted sucessfully,List byl úspěšně udělen,
Leaves must be allocated in multiples of 0.5,"Dovolené musí být přiděleny v násobcích 0,5",
Leaves per Year,Dovolených za rok,
Ledger,účetní kniha,
Legal,Právní,
Legal Expenses,Výdaje na právní služby,
Letter Head,Záhlaví,
Letter Heads for print templates.,Hlavičkové listy pro tisk šablon.,
Level,Úroveň,
Liability,Odpovědnost,
License,Licence,
Lifecycle,Životní cyklus,
Limit,Omezit,
Limit Crossed,Limit zkříženými,
Link to Material Request,Odkaz na materiálovou žádost,
List of all share transactions,Seznam všech transakcí s akciemi,
List of available Shareholders with folio numbers,Seznam dostupných akcionářů s čísly folií,
Loading Payment System,Načítání platebního systému,
Loan,Půjčka,
Loan Amount cannot exceed Maximum Loan Amount of {0},Výše úvěru nesmí být vyšší než Maximální výše úvěru částku {0},
Loan Application,Žádost o půjčku,
Loan Management,Správa úvěrů,
Loan Repayment,Splácení úvěru,
Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Datum zahájení výpůjčky a období výpůjčky jsou povinné pro uložení diskontování faktury,
Loans (Liabilities),Úvěry (závazky),
Loans and Advances (Assets),Úvěry a zálohy (aktiva),
Local,Místní,
Log,Log,
Logs for maintaining sms delivery status,Protokoly pro udržení stavu doručení sms,
Lost,Ztracený,
Lost Reasons,Ztracené důvody,
Low,Nízké,
Low Sensitivity,Nízká citlivost,
Lower Income,S nižšími příjmy,
Loyalty Amount,Loajální částka,
Loyalty Point Entry,Zadání věrnostního bodu,
Loyalty Points,Věrnostní body,
"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Věrnostní body budou vypočteny z vynaložených výdajů (prostřednictvím faktury k prodeji) na základě zmíněného faktoru sběru.,
Loyalty Points: {0},Věrnostní body: {0},
Loyalty Program,Věrnostní program,
Main,Hlavní,
Maintenance,Údržba,
Maintenance Log,Protokol údržby,
Maintenance Manager,Správce údržby,
Maintenance Schedule,Plán údržby,
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""",
Maintenance Schedule {0} exists against {1},Plán údržby {0} existuje proti {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,
Maintenance Status has to be Cancelled or Completed to Submit,Stav údržby musí být zrušen nebo dokončen k odeslání,
Maintenance User,Údržba uživatele,
Maintenance Visit,Maintenance Visit,
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,
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},
Make,Dělat,
Make Payment,Zaplatit,
Make project from a template.,Vytvořte projekt ze šablony.,
Making Stock Entries,Tvorba přírůstků zásob,
Male,Muž,
Manage Customer Group Tree.,Správa zákazníků skupiny Tree.,
Manage Sales Partners.,Správa prodejních partnerů.,
Manage Sales Person Tree.,Správa obchodník strom.,
Manage Territory Tree.,Správa Territory strom.,
Manage your orders,Správa objednávek,
Management,Řízení,
Manager,Manažer,
Managing Projects,Správa projektů,
Managing Subcontracting,Správa Subdodávky,
Mandatory,Povinné,
Mandatory field - Academic Year,Povinná oblast - Akademický rok,
Mandatory field - Get Students From,Povinná pole - Získajte studenty z,
Mandatory field - Program,Povinná oblast - Program,
Manufacture,Výroba,
Manufacturer,Výrobce,
Manufacturer Part Number,Typové označení,
Manufacturing,Výroba,
Manufacturing Quantity is mandatory,Výrobní množství je povinné,
Mapping,Mapování,
Mapping Type,Typ mapování,
Mark Absent,Mark Absent,
Mark Attendance,Označit Účast,
Mark Half Day,Mark Půldenní,
Mark Present,Mark Současnost,
Marketing,Marketing,
Marketing Expenses,Marketingové náklady,
Marketplace,Trh,
Marketplace Error,Chyba trhu,
Masters,Masters,
Match Payments with Invoices,Zápas platby fakturami,
Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.,
Material,Materiál,
Material Consumption,Spotřeba materiálu,
Material Consumption is not set in Manufacturing Settings.,Spotřeba materiálu není nastavena v nastavení výroby.,
Material Receipt,Příjem materiálu,
Material Request,Požadavek na materiál,
Material Request Date,Materiál Request Date,
Material Request No,Materiál Poptávka No,
"Material Request not created, as quantity for Raw Materials already available.","Žádost o materiál nebyla vytvořena, protože množství již dostupných surovin.",
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},
Material Request to Purchase Order,Materiál Žádost o příkazu k nákupu,
Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena,
Material Request {0} submitted.,Žádost o materiál {0} byla odeslána.,
Material Transfer,Přesun materiálu,
Material Transferred,Převedený materiál,
Material to Supplier,Materiál Dodavateli,
Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Maximální částka osvobození nemůže být vyšší než maximální částka osvobození {0} kategorie osvobození od daně {1},
Max benefits should be greater than zero to dispense benefits,"Maximální přínosy by měly být větší než nula, aby byly dávky vypláceny",
Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%,
Max: {0},Max: {0},
Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximální počet vzorků - {0} lze zadat pro dávky {1} a položku {2}.,
Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximální vzorky - {0} již byly zadány v dávce {1} a položce {2} v dávce {3}.,
Maximum amount eligible for the component {0} exceeds {1},Maximální částka způsobilá pro komponentu {0} přesahuje {1},
Maximum benefit amount of component {0} exceeds {1},Maximální částka prospěchu součásti {0} přesahuje {1},
Maximum benefit amount of employee {0} exceeds {1},Maximální výše příspěvku zaměstnance {0} přesahuje {1},
Maximum discount for Item {0} is {1}%,Maximální sleva pro položku {0} je {1}%,
Maximum leave allowed in the leave type {0} is {1},Maximální povolená dovolená v typu dovolené {0} je {1},
Medical,Lékařský,
Medical Code,Lékařský zákoník,
Medical Code Standard,Standardní zdravotnický kód,
Medical Department,Lékařské oddělení,
Medical Record,Zdravotní záznam,
Medium,Střední,
Meeting,Setkání,
Member Activity,Členská aktivita,
Member ID,Členské ID,
Member Name,Jméno člena,
Member information.,Členové informace.,
Membership,Členství,
Membership Details,Podrobnosti o členství,
Membership ID,Členství ID,
Membership Type,Typ členství,
Memebership Details,Podrobnosti o členství,
Memebership Type Details,Podrobnosti o typu člena,
Merge,Spojit,
Merge Account,Sloučit účet,
Merge with Existing Account,Sloučit se stávajícím účtem,
"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",
Message Examples,Příklady Zpráv,
Message Sent,Zpráva byla odeslána,
Method,Metoda,
Middle Income,Středními příjmy,
Middle Name,Prostřední jméno,
Middle Name (Optional),Druhé jméno (volitelné),
Min Amt can not be greater than Max Amt,Min Amt nesmí být větší než Max Amt,
Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množství,
Minimum Lead Age (Days),Minimální doba plnění (dny),
Miscellaneous Expenses,Různé výdaje,
Missing Currency Exchange Rates for {0},Chybí Směnárna Kurzy pro {0},
Missing email template for dispatch. Please set one in Delivery Settings.,Chybí šablona e-mailu pro odeslání. Nastavte prosím jednu z možností Nastavení doručení.,
"Missing value for Password, API Key or Shopify URL","Chybějící hodnota pro heslo, klíč API nebo URL obchodu",
Mode of Payment,Režim platby,
Mode of Payments,Způsob platby,
Mode of Transport,Způsob dopravy,
Mode of Transportation,Způsob dopravy,
Mode of payment is required to make a payment,Způsob platby je povinen provést platbu,
Model,Model,
Moderate Sensitivity,Mírná citlivost,
Monday,Pondělí,
Monthly,Měsíčně,
Monthly Distribution,Měsíční Distribution,
Monthly Repayment Amount cannot be greater than Loan Amount,Měsíční splátka částka nemůže být větší než Výše úvěru,
More,Více,
More Information,Víc informací,
More than one selection for {0} not allowed,Více než jeden výběr pro {0} není povolen,
More...,Více...,
Motion Picture & Video,Motion Picture & Video,
Move,Stěhovat,
Move Item,Přemístit položku,
Multi Currency,Více měn,
Multiple Item prices.,Více ceny položku.,
Multiple Loyalty Program found for the Customer. Please select manually.,Pro zákazníka byl nalezen vícenásobný věrnostní program. Zvolte prosím ručně.,
"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Více Cena pravidla existuje u stejných kritérií, prosím vyřešit konflikt tím, že přiřadí prioritu. Cena Pravidla: {0}",
Multiple Variants,Více variant,
Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Několik fiskálních let existují pro data {0}. Prosím nastavte společnost ve fiskálním roce,
Music,Hudba,
My Account,Můj Účet,
Name error: {0},Název chyba: {0},
Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Název nového účtu. Poznámka: Prosím, vytvářet účty pro zákazníky a dodavateli",
Name or Email is mandatory,Jméno nebo e-mail je povinné,
Nature Of Supplies,Příroda Dodávky,
Navigating,Navigace,
Needs Analysis,Analýza potřeb,
Negative Quantity is not allowed,Negativní množství není dovoleno,
Negative Valuation Rate is not allowed,Negativní ocenění není povoleno,
Negotiation/Review,Vyjednávání / Přezkum,
Net Asset value as on,Čistá hodnota aktiv i na,
Net Cash from Financing,Čistý peněžní tok z financování,
Net Cash from Investing,Čistý peněžní tok z investiční,
Net Cash from Operations,Čistý peněžní tok z provozní,
Net Change in Accounts Payable,Čistá Změna účty závazků,
Net Change in Accounts Receivable,Čistá změna objemu pohledávek,
Net Change in Cash,Čistá změna v hotovosti,
Net Change in Equity,Čistá změna ve vlastním kapitálu,
Net Change in Fixed Asset,Čistá změna ve stálých aktiv,
Net Change in Inventory,Čistá Změna stavu zásob,
Net ITC Available(A) - (B),Dostupné ITC (A) - (B),
Net Pay,Net Pay,
Net Pay cannot be less than 0,Čistý Pay nemůže být nižší než 0,
Net Profit,Čistý zisk,
Net Salary Amount,Čistá mzda,
Net Total,Net Total,
Net pay cannot be negative,Net plat nemůže být záporný,
New Account Name,Nový název účtu,
New Address,Nová adresa,
New BOM,Nový BOM,
New Batch ID (Optional),Nové číslo dávky (volitelné),
New Batch Qty,Nové dávkové množství,
New Company,Nová společnost,
New Cost Center Name,Jméno Nového Nákladového Střediska,
New Customer Revenue,Nový zákazník Příjmy,
New Customers,noví zákazníci,
New Department,Nové oddělení,
New Employee,Nový zaměstnanec,
New Location,Nová poloha,
New Quality Procedure,Nový postup kvality,
New Sales Invoice,Nová prodejní faktura,
New Sales Person Name,Jméno Nová Sales Osoba,
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nové seriové číslo nemůže mít záznam skladu. Sklad musí být nastaven přes skladovou kartu nebo nákupní doklad,
New Warehouse Name,Název nového skladu,
New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nový úvěrový limit je nižší než aktuální dlužné částky za zákazníka. Úvěrový limit musí být aspoň {0},
New task,Nová úloha,
New {0} pricing rules are created,Vytvoří se nová {0} pravidla pro tvorbu cen,
Newsletters,Zpravodaje,
Newspaper Publishers,Vydavatelé novin,
Next,Další,
Next Contact By cannot be same as the Lead Email Address,Následující Kontakt Tím nemůže být stejný jako hlavní e-mailovou adresu,
Next Contact Date cannot be in the past,Následující Kontakt datum nemůže být v minulosti,
Next Steps,Další kroky,
No Action,Žádná akce,
No Customers yet!,Zatím žádné zákazníky!,
No Data,No Data,
No Delivery Note selected for Customer {},Pro zákazníka nebyl vybrán žádný zákazník {},
No Employee Found,Nebyl nalezen žádný zaměstnanec,
No Item with Barcode {0},No Položka s čárovým kódem {0},
No Item with Serial No {0},No Položka s Serial č {0},
No Items available for transfer,K přenosu nejsou k dispozici žádné položky,
No Items selected for transfer,Nebyly vybrány žádné položky pro přenos,
No Items to pack,Žádné položky k balení,
No Items with Bill of Materials to Manufacture,Žádné položky s Billem materiálů k výrobě,
No Items with Bill of Materials.,Žádné položky s kusovníkem.,
No Permission,Nemáte oprávnění,
No Quote,Žádná citace,
No Remarks,Žádné poznámky,
No Result to submit,Žádný výsledek k odeslání,
No Salary Structure assigned for Employee {0} on given date {1},Žádná struktura výdělku pro zaměstnance {0} v daný den {1},
No Staffing Plans found for this Designation,Pro toto označení nebyly nalezeny plány personálního zabezpečení,
No Student Groups created.,Žádné studentské skupiny vytvořen.,
No Students in,Žádné studenty v,
No Tax Withholding data found for the current Fiscal Year.,Pro daný fiskální rok nebyly zjištěny žádné údaje o zadržení daně.,
No Work Orders created,Nebyly vytvořeny žádné pracovní příkazy,
No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady,
No active or default Salary Structure found for employee {0} for the given dates,Žádný aktivní nebo implicitní Plat Struktura nalezených pro zaměstnance {0} pro dané termíny,
No contacts with email IDs found.,Nebyly nalezeny žádné kontakty s identifikátory e-mailu.,
No data for this period,Pro toto období nejsou k dispozici žádná data,
No description given,No vzhledem k tomu popis,
No employees for the mentioned criteria,Žádní zaměstnanci nesplnili uvedená kritéria,
No gain or loss in the exchange rate,Žádné zisky nebo ztráty ve směnném kurzu,
No items listed,Žádné položky nejsou uvedeny,
No items to be received are overdue,"Žádné položky, které mají být přijaty, nejsou opožděné",
No material request created,Žádná materiálová žádost nebyla vytvořena,
No more updates,Žádné další aktualizace,
No of Interactions,Počet interakcí,
No of Shares,Počet akcií,
No pending Material Requests found to link for the given items.,Žádná nevyřízená žádost o materiál nebyla nalezena k odkazu na dané položky.,
No products found,Nebyly nalezeny žádné produkty,
No products found.,Nenašli se žádné produkty.,
No record found,Nebyl nalezen žádný záznam,
No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy,
No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy,
No replies from,Žádné odpovědi od,
No salary slip found to submit for the above selected criteria OR salary slip already submitted,Žádný výplatní list nebyl předložen za výše uvedené kritéria NEBO platový výpis již předložen,
No tasks,Žádné úkoly,
No time sheets,Žádné pracovní výkazy,
No values,Žádné hodnoty,
No {0} found for Inter Company Transactions.,Nebylo nalezeno {0} pro interní transakce společnosti.,
Non GST Inward Supplies,Spotřební materiály jiné než GST,
Non Profit,Non Profit,
Non Profit (beta),Neziskové (beta),
Non-GST outward supplies,Externí spotřební materiál mimo GST,
Non-Group to Group,Non-skupiny ke skupině,
None,Žádný,
None of the items have any change in quantity or value.,Žádný z těchto položek má žádnou změnu v množství nebo hodnotě.,
Nos,Nos,
Not Available,Není k dispozici,
Not Marked,neoznačený,
Not Paid and Not Delivered,Nezaplatil a není doručení,
Not Permitted,Není povoleno,
Not Started,Nezahájeno,
Not active,Neaktivní,
Not allow to set alternative item for the item {0},Neumožňuje nastavit alternativní položku pro položku {0},
Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0},
Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0},
Not authroized since {0} exceeds limits,Není authroized od {0} překročí limity,
Not permitted for {0},Není dovoleno {0},
"Not permitted, configure Lab Test Template as required","Není povoleno, podle potřeby nastavte šablonu testování laboratoře",
Not permitted. Please disable the Service Unit Type,Nepovoleno. Zakažte typ servisní jednotky,
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),
Note: Item {0} entered multiple times,Poznámka: Položka {0} vstoupil vícekrát,
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",
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,
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: 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.,
Note: {0},Poznámka: {0},
Notes,Poznámky,
Nothing is included in gross,V hrubé hodnotě není zahrnuto nic,
Nothing more to show.,Nic víc ukázat.,
Nothing to change,Nic se nemění,
Notice Period,Výpovědní lhůta,
Notify Customers via Email,Informujte zákazníky e-mailem,
Number,Číslo,
Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervováno nemůže být větší než celkový počet Odpisy,
Number of Interaction,Počet interakcí,
Number of Order,Číslo objednávky,
"Number of new Account, it will be included in the account name as a prefix",Číslo nového účtu bude do názvu účtu zahrnuto jako předčíslí,
"Number of new Cost Center, it will be included in the cost center name as a prefix","Počet nových nákladových center, bude zahrnuto do názvu nákladového střediska jako předpona",
Number of root accounts cannot be less than 4,Počet kořenových účtů nesmí být menší než 4,
Odometer,Počítadlo ujetých kilometrů,
Office Equipments,Kancelářské vybavení,
Office Maintenance Expenses,Náklady Office údržby,
Office Rent,Pronájem kanceláře,
On Hold,Pozastaveno,
On Net Total,On Net Celkem,
One customer can be part of only single Loyalty Program.,Jeden zákazník může být součástí pouze jednoho loajálního programu.,
Online Auctions,Aukce online,
Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,"Nechte pouze aplikace, které mají status &quot;schváleno&quot; i &quot;Zamítnuto&quot; může být předložena",
"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Do následující tabulky bude vybrán pouze žadatel o studium se statusem &quot;Schváleno&quot;.,
Only users with {0} role can register on Marketplace,Pouze uživatelé s rolí {0} se mohou zaregistrovat na trhu,
Open BOM {0},Otevřená BOM {0},
Open Item {0},Otevřít položku {0},
Open Notifications,Otevřené Oznámení,
Open Orders,Otevřené objednávky,
Open a new ticket,Otevřete novou lístek,
Opening,Otvor,
Opening (Cr),Otvor (Cr),
Opening (Dr),Opening (Dr),
Opening Accounting Balance,Otevření účetnictví Balance,
Opening Accumulated Depreciation,Otevření Oprávky,
Opening Accumulated Depreciation must be less than equal to {0},Otevření Oprávky musí být menší než rovná {0},
Opening Balance,Počáteční zůstatek,
Opening Balance Equity,Počáteční stav Equity,
Opening Date and Closing Date should be within same Fiscal Year,Datum zahájení a datem ukončení by mělo být v rámci stejného fiskální rok,
Opening Date should be before Closing Date,Datum zahájení by měla být před uzávěrky,
Opening Entry Journal,Otevření deníku zápisu,
Opening Invoice Creation Tool,Otevření nástroje pro vytváření faktur,
Opening Invoice Item,Otevření položky faktury,
Opening Invoices,Otevření faktur,
Opening Invoices Summary,Otevření souhrnu faktur,
Opening Qty,Otevření POČET,
Opening Stock,Počáteční stav zásob,
Opening Stock Balance,Počáteční cena zásob,
Opening Value,otevření Value,
Opening {0} Invoice created,Otevření {0} Fakturu vytvořena,
Operation,Operace,
Operation Time must be greater than 0 for Operation {0},Čas operace musí být větší než 0 pro operaci {0},
"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í",
Operations,Operace,
Operations cannot be left blank,Operace nemůže být prázdné,
Opp Count,Opp Count,
Opp/Lead %,Opp / Olovo%,
Opportunities,Příležitosti,
Opportunities by lead source,Možnosti podle zdroje olova,
Opportunity,Příležitost,
Opportunity Amount,Částka příležitosti,
Optional Holiday List not set for leave period {0},Volitelný prázdninový seznam není nastaven na období dovolené {0},
"Optional. Sets company's default currency, if not specified.","Volitelné. Nastaví výchozí měně společnosti, není-li uvedeno.",
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í.,
Options,Možnosti,
Order Count,Pořadí objednávek,
Order Entry,Zadání objednávky,
Order Value,Hodnota objednávky,
Order rescheduled for sync,Objednávka byla přepracována pro synchronizaci,
Order/Quot %,Objednávka / kvóta%,
Ordered,Objednáno,
Ordered Qty,Objednáno Množství,
"Ordered Qty: Quantity ordered for purchase, but not received.","Objednáno Množství: Objednané množství pro nákup, ale nedostali.",
Orders,Objednávky,
Orders released for production.,Objednávky uvolněna pro výrobu.,
Organization,Organizace,
Organization Name,Název organizace,
Other,Ostatní,
Other Reports,Ostatní zprávy,
"Other outward supplies(Nil rated,Exempted)","Ostatní pasivní dodávky (bez hodnocení, osvobozeno)",
Others,Ostatní,
Out Qty,Out Množství,
Out Value,limitu,
Out of Order,Mimo provoz,
Outgoing,Vycházející,
Outstanding,Vynikající,
Outstanding Amount,Dlužné částky,
Outstanding Amt,Vynikající Amt,
Outstanding Cheques and Deposits to clear,Vynikající Šeky a vklady s jasnými,
Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1}),
Outward taxable supplies(zero rated),Dodávky podléhající zdanění (s nulovým hodnocením),
Overdue,Zpožděný,
Overlap in scoring between {0} and {1},Překrývající bodování mezi {0} a {1},
Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:,
Owner,Majitel,
PAN,PÁNEV,
PO already created for all sales order items,PO již vytvořeno pro všechny položky prodejní objednávky,
POS,POS,
POS Profile,POS Profile,
POS Profile is required to use Point-of-Sale,Profil POS je vyžadován pro použití prodejního místa,
POS Profile required to make POS Entry,"POS Profile požadováno, aby POS Vstup",
POS Settings,Nastavení 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},
Packing Slip,Balící list,
Packing Slip(s) cancelled,Balící list(y) stornován(y),
Paid,Placený,
Paid Amount,Uhrazené částky,
Paid Amount cannot be greater than total negative outstanding amount {0},Zaplacená částka nemůže být vyšší než celkový negativní dlužné částky {0},
Paid amount + Write Off Amount can not be greater than Grand Total,Uhrazená částka + odepsaná částka nesmí být větší než celková částka,
Paid and Not Delivered,Uhrazené a nedoručené,
Parameter,Parametr,
Parent Item {0} must not be a Stock Item,Parent Item {0} nesmí být skladem,
Parents Teacher Meeting Attendance,Konference účastníků rodičů,
Part-time,Part-time,
Partially Depreciated,částečně odepisována,
Partially Received,Částečně přijato,
Party,Strana,
Party Name,Jméno Party,
Party Type,Typ Party,
Party Type and Party is mandatory for {0} account,Typ strany a strana je povinný pro účet {0},
Party Type is mandatory,Typ strana je povinná,
Party is mandatory,Party je povinná,
Password,Heslo,
Password policy for Salary Slips is not set,Zásady hesla pro platové lístky nejsou nastaveny,
Past Due Date,Datum splatnosti,
Patient,Pacient,
Patient Appointment,Setkání pacienta,
Patient Encounter,Setkání pacienta,
Patient not found,Pacient nebyl nalezen,
Pay Remaining,Zbývající platba,
Pay {0} {1},Platit {0} {1},
Payable,Splatný,
Payable Account,Splatnost účtu,
Payable Amount,Splatná částka,
Payment,Platba,
Payment Cancelled. Please check your GoCardless Account for more details,Platba byla zrušena. Zkontrolujte svůj účet GoCardless pro více informací,
Payment Confirmation,Potvrzení platby,
Payment Date,Datum splatnosti,
Payment Days,Platební dny,
Payment Document,platba Document,
Payment Due Date,Splatno dne,
Payment Entries {0} are un-linked,Platební Příspěvky {0} jsou un-spojený,
Payment Entry,platba Entry,
Payment Entry already exists,Platba Entry již existuje,
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.",
Payment Entry is already created,Vstup Platba je již vytvořili,
Payment Failed. Please check your GoCardless Account for more details,Platba selhala. Zkontrolujte svůj účet GoCardless pro více informací,
Payment Gateway,Platební brána,
"Payment Gateway Account not created, please create one manually.","Platební brána účet nevytvořili, prosím, vytvořte ručně.",
Payment Gateway Name,Název platební brány,
Payment Mode,Způsob platby,
Payment Receipt Note,Doklad o zaplacení Note,
Payment Request,Platba Poptávka,
Payment Request for {0},Žádost o platbu za {0},
Payment Tems,Platební Tems,
Payment Term,Platební termín,
Payment Terms,Platební podmínky,
Payment Terms Template,Šablona platebních podmínek,
Payment Terms based on conditions,Platební podmínky na základě podmínek,
Payment Type,Typ platby,
"Payment Type must be one of Receive, Pay and Internal Transfer",Typ platby musí být jedním z příjem Pay a interní převod,
Payment against {0} {1} cannot be greater than Outstanding Amount {2},Platba proti {0} {1} nemůže být větší než dlužné částky {2},
Payment of {0} from {1} to {2},Platba {0} od {1} do {2},
Payment request {0} created,Byla vytvořena žádost o platbu {0},
Payments,Platby,
Payroll,Mzdy,
Payroll Number,Mzdové číslo,
Payroll Payable,Mzdové Splatné,
Payslip,výplatní páska,
Pending Activities,Nevyřízené Aktivity,
Pending Amount,Čeká Částka,
Pending Leaves,Nevyřízené listy,
Pending Qty,Čekající množství,
Pending Quantity,Čekající množství,
Pending Review,Čeká Review,
Pending activities for today,Nevyřízené aktivity pro dnešek,
Pension Funds,Penzijní fondy,
Percentage Allocation should be equal to 100%,Podíl alokace by měla být ve výši 100%,
Perception Analysis,Analýza vnímání,
Period,Období,
Period Closing Entry,Období Uzávěrka Entry,
Period Closing Voucher,Období Uzávěrka Voucher,
Periodicity,Periodicita,
Personal Details,Osobní data,
Pharmaceutical,Farmaceutické,
Pharmaceuticals,Farmaceutické,
Physician,Lékař,
Piecework,Úkolová práce,
Pincode,PSČ,
Place Of Supply (State/UT),Místo dodávky (stát / UT),
Place Order,Objednat,
Plan Name,Název plánu,
Plan for maintenance visits.,Plán pro návštěvy údržby.,
Planned Qty,Plánované množství,
"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Plánované množství: Množství, pro které byla zvýšena pracovní objednávka, ale čeká na výrobu.",
Planning,Plánování,
Plants and Machineries,Rostliny a strojní vybavení,
Please Set Supplier Group in Buying Settings.,Nastavte skupinu dodavatelů v Nastavení nákupu.,
Please add a Temporary Opening account in Chart of Accounts,Přidejte účet dočasného otevírání do Účtovacího plánu,
Please add the account to root level Company - ,Přidejte účet do kořenové úrovně společnosti -,
Please add the remaining benefits {0} to any of the existing component,Přidejte zbývající výhody {0} do kterékoli existující komponenty,
Please check Multi Currency option to allow accounts with other currency,"Prosím, zkontrolujte více měn možnost povolit účty s jinou měnu",
Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule""",
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}",
Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán",
Please confirm once you have completed your training,Potvrďte prosím po dokončení školení,
Please create purchase receipt or purchase invoice for the item {0},Pro položku {0} vytvořte potvrzení o nákupu nebo nákupní fakturu.,
Please define grade for Threshold 0%,Zadejte prosím stupeň pro Threshold 0%,
Please enable Applicable on Booking Actual Expenses,Uveďte prosím platný údaj o skutečných výdajích za rezervaci,
Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Uveďte prosím platné objednávky a platí pro skutečné výdaje za rezervaci,
Please enable default incoming account before creating Daily Work Summary Group,Před vytvořením Denní shrnutí skupiny práce povolte výchozí příchozí účet,
Please enable pop-ups,Prosím povolte vyskakovací okna,
Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne",
Please enter API Consumer Key,Zadejte prosím klíč API pro spotřebitele,
Please enter API Consumer Secret,Zadejte zákaznické tajemství API,
Please enter Account for Change Amount,"Prosím, zadejte účet pro změnu Částka",
Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel,
Please enter Cost Center,"Prosím, zadejte nákladové středisko",
Please enter Delivery Date,Zadejte prosím datum doručení,
Please enter Employee Id of this sales person,"Prosím, zadejte ID zaměstnance z tohoto prodeje osoby",
Please enter Expense Account,"Prosím, zadejte výdajového účtu",
Please enter Item Code to get Batch Number,"Prosím, zadejte kód položky se dostat číslo šarže",
Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no",
Please enter Item first,"Prosím, nejdřív zadejte položku",
Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti",
Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}",
Please enter Preferred Contact Email,"Prosím, zadejte Preferred Kontakt e-mail",
Please enter Production Item first,"Prosím, zadejte první výrobní položku",
Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení",
Please enter Receipt Document,"Prosím, zadejte převzetí dokumentu",
Please enter Reference date,"Prosím, zadejte Referenční den",
Please enter Repayment Periods,"Prosím, zadejte dobu splácení",
Please enter Reqd by Date,Zadejte Reqd podle data,
Please enter Woocommerce Server URL,Zadejte adresu URL serveru Woocommerce,
Please enter Write Off Account,"Prosím, zadejte odepsat účet",
Please enter atleast 1 invoice in the table,Zadejte prosím aspoň 1 fakturu v tabulce,
Please enter company first,"Prosím, nejprave zadejte společnost",
Please enter company name first,"Prosím, zadejte nejprve název společnosti",
Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr,
Please enter message before sending,"Prosím, zadejte zprávu před odesláním",
Please enter parent cost center,"Prosím, zadejte nákladové středisko mateřský",
Please enter quantity for Item {0},"Zadejte prosím množství produktů, bod {0}",
Please enter relieving date.,Zadejte zmírnění datum.,
Please enter repayment Amount,"Prosím, zadejte splácení Částka",
Please enter valid Financial Year Start and End Dates,Zadejte prosím platnou finanční rok datum zahájení a ukončení,
Please enter valid email address,Zadejte platnou e-mailovou adresu,
Please enter {0} first,"Prosím, zadejte {0} jako první",
Please fill in all the details to generate Assessment Result.,"Vyplňte prosím všechny podrobnosti, abyste vygenerovali výsledek hodnocení.",
Please identify/create Account (Group) for type - {0},Určete / vytvořte účet (skupinu) pro typ - {0},
Please identify/create Account (Ledger) for type - {0},Určete / vytvořte účet (účetní kniha) pro typ - {0},
Please login as another user to register on Marketplace,"Přihlaste se jako další uživatel, který se zaregistruje na trhu",
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.",
Please mention Basic and HRA component in Company,Uveďte prosím součást Basic a HRA ve společnosti,
Please mention Round Off Account in Company,"Prosím, uveďte zaokrouhlit účet v společnosti",
Please mention Round Off Cost Center in Company,"Prosím, uveďte zaokrouhlit nákladové středisko ve společnosti",
Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv",
Please mention the Lead Name in Lead {0},Uvedete prosím vedoucí jméno ve vedoucím {0},
Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list",
Please register the SIREN number in the company information file,Zaregistrujte prosím číslo SIREN v informačním souboru společnosti,
Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1},
Please save the patient first,Nejprve uložit pacienta,
Please save the report again to rebuild or update,"Sestavu znovu uložte, abyste ji mohli znovu vytvořit nebo aktualizovat",
"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ě",
Please select Apply Discount On,"Prosím, vyberte Použít Sleva na",
Please select BOM against item {0},Vyberte prosím kusovníku podle položky {0},
Please select BOM for Item in Row {0},"Prosím, vyberte BOM pro položku v řádku {0}",
Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0},
Please select Category first,Nejdřív vyberte kategorii,
Please select Charge Type first,"Prosím, vyberte druh tarifu první",
Please select Company,"Prosím, vyberte Company",
Please select Company and Designation,Vyberte prosím společnost a označení,
Please select Company and Party Type first,Vyberte první společnost a Party Typ,
Please select Company and Posting Date to getting entries,Zvolte prosím datum společnosti a datum odevzdání,
Please select Company first,"Prosím, vyberte první firma",
Please select Completion Date for Completed Asset Maintenance Log,Zvolte datum dokončení dokončeného protokolu údržby aktiv,
Please select Completion Date for Completed Repair,Zvolte datum dokončení dokončené opravy,
Please select Course,Vyberte možnost Kurz,
Please select Drug,Vyberte prosím lék,
Please select Employee,Vyberte prosím zaměstnance,
Please select Existing Company for creating Chart of Accounts,Vyberte existující společnosti pro vytváření účtový rozvrh,
Please select Healthcare Service,Vyberte prosím službu zdravotní péče,
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Prosím, vyberte položku, kde &quot;Je skladem,&quot; je &quot;Ne&quot; a &quot;je Sales Item&quot; &quot;Ano&quot; a není tam žádný jiný produkt Bundle",
Please select Maintenance Status as Completed or remove Completion Date,Zvolte Stav údržby jako Dokončené nebo odeberte datum dokončení,
Please select Party Type first,"Prosím, vyberte typ Party první",
Please select Patient,Vyberte pacienta,
Please select Patient to get Lab Tests,Vyberte pacienta pro získání laboratorních testů,
Please select Posting Date before selecting Party,"Prosím, vyberte Datum zveřejnění před výběrem Party",
Please select Posting Date first,"Prosím, vyberte nejprve Datum zveřejnění",
Please select Price List,"Prosím, vyberte Ceník",
Please select Program,Vyberte prosím Program,
Please select Qty against item {0},Zvolte prosím množství v položce {0},
Please select Sample Retention Warehouse in Stock Settings first,Zvolte prosím nejprve Sample Retention Warehouse in Stock Stock,
Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}",
Please select Student Admission which is mandatory for the paid student applicant,"Vyberte studentský vstup, který je povinný pro žáka placeného studenta",
Please select a BOM,Vyberte kusovníku,
Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Vyberte položku Dávka pro položku {0}. Nelze najít jednu dávku, která splňuje tento požadavek",
Please select a Company,Vyberte společnost,
Please select a batch,Vyberte dávku,
Please select a csv file,Vyberte soubor csv,
Please select a field to edit from numpad,"Vyberte pole, které chcete upravit z čísla",
Please select a table,Vyberte prosím tabulku,
Please select a valid Date,Vyberte prosím platný datum,
Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1},
Please select a warehouse,Vyberte prosím sklad,
Please select at least one domain.,Vyberte alespoň jednu doménu.,
Please select correct account,"Prosím, vyberte správný účet",
Please select date,"Prosím, vyberte datum",
Please select item code,"Prosím, vyberte položku kód",
Please select month and year,Vyberte měsíc a rok,
Please select prefix first,"Prosím, vyberte první prefix",
Please select the Company,Vyberte prosím společnost,
Please select the Multiple Tier Program type for more than one collection rules.,Zvolte typ víceúrovňového programu pro více než jednu pravidla kolekce.,
Please select the assessment group other than 'All Assessment Groups',Vyberte jinou skupinu hodnocení než skupinu Všechny skupiny,
Please select the document type first,Vyberte první typ dokumentu,
Please select weekly off day,"Prosím, vyberte týdenní off den",
Please select {0},"Prosím, vyberte {0}",
Please select {0} first,"Prosím, nejprve vyberte {0}",
Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použít dodatečnou slevu On&quot;,
Please set 'Asset Depreciation Cost Center' in Company {0},Prosím nastavte &quot;odpisy majetku nákladové středisko&quot; ve firmě {0},
Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prosím nastavte &quot;/ ZTRÁTY zisk z aktiv odstraňováním&quot; ve firmě {0},
Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Nastavte účet ve skladu {0} nebo ve výchozím inventářním účtu ve firmě {1},
Please set B2C Limit in GST Settings.,Nastavte prosím B2C Limit v nastavení GST.,
Please set Company,Nastavte společnost,
Please set Company filter blank if Group By is 'Company',"Nastavte filtr společnosti prázdný, pokud je Skupina By je &#39;Company&#39;",
Please set Default Payroll Payable Account in Company {0},"Prosím nastavit výchozí mzdy, splatnou účet ve firmě {0}",
Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosím, amortizace účty s ním souvisejících v kategorii Asset {0} nebo {1} Company",
Please set Email Address,Prosím nastavte e-mailovou adresu,
Please set GST Accounts in GST Settings,Nastavte prosím účet GST v Nastavení GST,
Please set Hotel Room Rate on {},"Prosím, nastavte Hotel Room Rate na {}",
Please set Number of Depreciations Booked,Prosím nastavte Počet Odpisy rezervováno,
Please set Unrealized Exchange Gain/Loss Account in Company {0},Prosím nastavte Unrealized Exchange Gain / Loss účet ve společnosti {0},
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,
Please set a default Holiday List for Employee {0} or Company {1},Prosím nastavit výchozí Holiday List pro zaměstnance {0} nebo {1} Company,
Please set account in Warehouse {0},Nastavte prosím účet ve skladu {0},
Please set an active menu for Restaurant {0},Nastavte prosím aktivní nabídku Restaurant {0},
Please set associated account in Tax Withholding Category {0} against Company {1},Nastavte přidružený účet v kategorii odmítnutí daní {0} proti společnosti {1},
Please set at least one row in the Taxes and Charges Table,Nastavte prosím alespoň jeden řádek v tabulce daní a poplatků,
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},
Please set default account in Salary Component {0},Prosím nastavit výchozí účet platu Component {0},
Please set default customer in Restaurant Settings,Nastavte výchozího zákazníka v nastavení restaurace,
Please set default template for Leave Approval Notification in HR Settings.,Prosím nastavte výchozí šablonu pro Notification Notification při nastavení HR.,
Please set default template for Leave Status Notification in HR Settings.,Prosím nastavte výchozí šablonu pro ohlášení stavu o stavu v HR nastaveních.,
Please set default {0} in Company {1},Prosím nastavit výchozí {0} ve firmě {1},
Please set filter based on Item or Warehouse,Prosím nastavit filtr na základě výtisku nebo ve skladu,
Please set leave policy for employee {0} in Employee / Grade record,Pro zaměstnance {0} nastavte v kalendáři zaměstnance / plat,
Please set recurring after saving,Prosím nastavte opakující se po uložení,
Please set the Company,Nastavte společnost,
Please set the Customer Address,Nastavte prosím zákaznickou adresu,
Please set the Date Of Joining for employee {0},Nastavte prosím datum zapojení pro zaměstnance {0},
Please set the Default Cost Center in {0} company.,Nastavte výchozí cenové centrum ve společnosti {0}.,
Please set the Email ID for the Student to send the Payment Request,"Prosím, nastavte ID e-mailu, aby Student odeslal Žádost o platbu",
Please set the Item Code first,Nejprve nastavte kód položky,
Please set the Payment Schedule,Nastavte prosím časový rozvrh plateb,
Please set the series to be used.,"Nastavte prosím řadu, kterou chcete použít.",
Please set {0} for address {1},Zadejte prosím {0} pro adresu {1},
Please setup Students under Student Groups,"Prosím, nastavte studenty pod studentskými skupinami",
Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Podělte se o své připomínky k tréninku kliknutím na &quot;Tréninkové připomínky&quot; a poté na &quot;Nové&quot;,
Please specify Company,"Uveďte prosím, firmu",
Please specify Company to proceed,Uveďte prosím společnost pokračovat,
Please specify a valid 'From Case No.',"Uveďte prosím platný ""Od věci č '",
Please specify a valid Row ID for row {0} in table {1},Zadejte prosím platný řádek ID řádku tabulky {0} {1},
Please specify at least one attribute in the Attributes table,Uveďte prosím alespoň jeden atribut v tabulce atributy,
Please specify currency in Company,"Uveďte prosím měnu, ve společnosti",
Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množství nebo ocenění Cena, nebo obojí",
Please specify from/to range,Uveďte prosím z / do rozmezí,
Please supply the specified items at the best possible rates,Prosím dodávat uvedené položky na nejlepší možné ceny,
Please update your status for this training event,Aktualizujte svůj stav pro tuto tréninkovou akci,
Please wait 3 days before resending the reminder.,Počkejte 3 dny před odesláním připomínek.,
Point of Sale,Místo Prodeje,
Point-of-Sale,Místě prodeje,
Point-of-Sale Profile,Point-of-Sale Profil,
Portal,Portál,
Portal Settings,Portál Nastavení,
Possible Supplier,možné Dodavatel,
Postal Expenses,Poštovní náklady,
Posting Date,Datum zveřejnění,
Posting Date cannot be future date,Vysílání datum nemůže být budoucí datum,
Posting Time,Čas zadání,
Posting date and posting time is mandatory,Datum a čas zadání je povinný,
Posting timestamp must be after {0},Časová značka zadání musí být po {0},
Potential opportunities for selling.,Potenciální příležitosti pro prodej.,
Practitioner Schedule,Pracovní plán,
Pre Sales,Předprodej,
Preference,Přednost,
Prescribed Procedures,Předepsané postupy,
Prescription,Předpis,
Prescription Dosage,Dávkování na předpis,
Prescription Duration,Doba trvání předpisu,
Prescriptions,Předpisy,
Present,Současnost,
Prev,Předch,
Preview,Preview,
Preview Salary Slip,Preview výplatní pásce,
Previous Financial Year is not closed,Předchozí finanční rok není uzavřen,
Price,Cena,
Price List,Ceník,
Price List Currency not selected,Ceníková Měna není zvolena,
Price List Rate,Ceník Rate,
Price List master.,Ceník master.,
Price List must be applicable for Buying or Selling,Ceník musí být použitelný pro nákup nebo prodej,
Price List {0} is disabled or does not exist,Ceníková cena {0} je zakázáno nebo neexistuje,
Price or product discount slabs are required,Vyžadovány jsou desky s cenou nebo cenou produktu,
Pricing,Stanovení ceny,
Pricing Rule,Ceny Pravidlo,
"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.",
"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í.",
Pricing Rule {0} is updated,Pravidlo pro stanovení cen {0} je aktualizováno,
Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.,
Primary Address Details,Údaje o primární adrese,
Primary Contact Details,Primární kontaktní údaje,
Principal Amount,jistina,
Print Format,Formát tisku,
Print IRS 1099 Forms,Tisk IRS 1099 formulářů,
Print Report Card,Tiskněte kartu přehledů,
Print Settings,Nastavení tisku,
Print and Stationery,Tisk a papírnictví,
Print settings updated in respective print format,Nastavení tisku aktualizovány v příslušném formátu tisku,
Print taxes with zero amount,Vytiskněte daně s nulovou částkou,
Printing and Branding,Tisk a identita,
Private Equity,Private Equity,
Privilege Leave,Privilege Leave,
Probation,Zkouška,
Probationary Period,Zkušební doba,
Procedure,Postup,
Process Day Book Data,Zpracovat data denní knihy,
Process Master Data,Zpracování kmenových dat,
Processing Chart of Accounts and Parties,Tabulka zpracování účtů a stran,
Processing Items and UOMs,Zpracování položek a UOM,
Processing Party Addresses,Adresy zpracovatelských stran,
Processing Vouchers,Zpracování poukázek,
Procurement,Procurement,
Produced Qty,Vyrobeno Množství,
Product,Produkt,
Product Bundle,Bundle Product,
Product Search,Hledat výrobek,
Production,Výroba,
Production Item,Výrobní položka,
Products,Výrobky,
Profit and Loss,Zisky a ztráty,
Profit for the year,Zisk za rok,
Program,Program,
Program in the Fee Structure and Student Group {0} are different.,Program ve struktuře poplatků a studentské skupině {0} jsou různé.,
Program {0} does not exist.,Program {0} neexistuje.,
Program: ,Program:,
Progress % for a task cannot be more than 100.,Pokrok% za úkol nemůže být více než 100.,
Project Collaboration Invitation,Projekt spolupráce Pozvánka,
Project Id,Id projektu,
Project Manager,Project Manager,
Project Name,název projektu,
Project Start Date,Datum zahájení projektu,
Project Status,Stav projektu,
Project Summary for {0},Shrnutí projektu pro {0},
Project Update.,Aktualizace projektu.,
Project Value,Hodnota projektu,
Project activity / task.,Projektová činnost / úkol.,
Project master.,Master Project.,
Project-wise data is not available for Quotation,Data dle projektu nejsou k dispozici pro nabídku,
Projected,Plánovaná,
Projected Qty,Promítané množství,
Projected Quantity Formula,Předpokládané množství,
Projects,Projekty,
Property,Vlastnost,
Property already added,Vlastnictví již bylo přidáno,
Proposal Writing,Návrh Psaní,
Proposal/Price Quote,Návrh / cenová nabídka,
Prospecting,Prospektování,
Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit),
Publications,Publikace,
Publish Items on Website,Publikovat položky na webových stránkách,
Published,Publikováno,
Publishing,Publikování,
Purchase,Nákup,
Purchase Amount,Částka nákupu,
Purchase Date,Datum nákupu,
Purchase Invoice,Přijatá faktura,
Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána,
Purchase Manager,Vedoucí nákupu,
Purchase Master Manager,Nákup Hlavní manažer,
Purchase Order,Vydaná objednávka,
Purchase Order Amount,Částka objednávky,
Purchase Order Amount(Company Currency),Částka objednávky (měna společnosti),
Purchase Order Date,Datum objednávky,
Purchase Order Items not received on time,Položky objednávky nebyly přijaty včas,
Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0},
Purchase Order to Payment,Objednávka na platební,
Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána,
Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Příkazy na nákup nejsou pro {0} povoleny kvůli postavení skóre {1}.,
Purchase Orders given to Suppliers.,Nákupní Objednávky odeslané Dodavatelům.,
Purchase Price List,Nákupní Ceník,
Purchase Receipt,Příjemka,
Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena,
Purchase Tax Template,Spotřební daň šablony,
Purchase User,Nákup Uživatel,
Purchase orders help you plan and follow up on your purchases,Objednávky pomohou při plánování a navázat na vašich nákupech,
Purchasing,Nákup,
Purpose must be one of {0},Cíl musí být jedním z {0},
Qty,Množství,
Qty To Manufacture,Množství k výrobě,
Qty Total,Množství celkem,
Qty for {0},Množství pro {0},
Qualification,Kvalifikace,
Quality,Kvalita,
Quality Action,Kvalitní akce,
Quality Goal.,Kvalitní cíl.,
Quality Inspection,Kontrola kvality,
Quality Inspection: {0} is not submitted for the item: {1} in row {2},Kontrola kvality: {0} není zadán pro položku: {1} v řádku {2},
Quality Management,Řízení kvality,
Quality Meeting,Kvalitní setkání,
Quality Procedure,Postup kvality,
Quality Procedure.,Postup kvality.,
Quality Review,Kontrola kvality,
Quantity,Množství,
Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1},
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}",
Quantity must be less than or equal to {0},Množství musí být menší než nebo rovno {0},
Quantity must not be more than {0},Množství nesmí být větší než {0},
Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1},
Quantity should be greater than 0,Množství by měla být větší než 0,
Quantity to Make,"Množství, které chcete vyrobit",
Quantity to Manufacture must be greater than 0.,"Množství, které má výroba musí být větší než 0 ° C.",
Quantity to Produce,Množství k výrobě,
Quantity to Produce can not be less than Zero,Množství na výrobu nesmí být menší než nula,
Query Options,Možnosti dotazu,
Queued for replacing the BOM. It may take a few minutes.,Naléhá na výměnu kusovníku. Může to trvat několik minut.,
Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Naladil se na aktualizaci nejnovější ceny ve všech kusovnících. Může to trvat několik minut.,
Quick Journal Entry,Rychlý vstup Journal,
Quot Count,Počet kvotů,
Quot/Lead %,Quot / Lead%,
Quotation,Nabídka,
Quotation {0} is cancelled,Nabídka {0} je zrušena,
Quotation {0} not of type {1},Nabídka {0} není typu {1},
Quotations,Citace,
"Quotations are proposals, bids you have sent to your customers","Citace jsou návrhy, nabídky jste svým zákazníkům odeslané",
Quotations received from Suppliers.,Nabídka obdržená od Dodavatelů.,
Quotations: ,citace:,
Quotes to Leads or Customers.,Nabídka pro Lead nebo pro Zákazníka,
RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs nejsou povoleny pro {0} kvůli stavu scorecard {1},
Range,Rozsah,
Rate,Cena,
Rate:,Hodnotit:,
Rating,Rating,
Raw Material,Surovina,
Raw Materials,Suroviny,
Raw Materials cannot be blank.,Suroviny nemůže být prázdný.,
Re-open,Znovu otevřít,
Read blog,Přečtěte si blog,
Read the ERPNext Manual,Přečtěte si ERPNext Manuál,
Reading Uploaded File,Čtení nahraného souboru,
Real Estate,Nemovitost,
Reason For Putting On Hold,Důvod pro pozdržení,
Reason for Hold,Důvod pozastavení,
Reason for hold: ,Důvod pozastavení:,
Receipt,Příjem,
Receipt document must be submitted,Příjem dokument musí být předložen,
Receivable,Pohledávky,
Receivable Account,Účet pohledávky,
Received,Přijato,
Received On,Přijaté On,
Received Quantity,Přijaté množství,
Received Stock Entries,Přijaté položky zásob,
Receiver List is empty. Please create Receiver List,Přijímač Seznam je prázdný. Prosím vytvořte přijímače Seznam,
Recipients,Příjemci,
Reconcile,Srovnat,
"Record of all communications of type email, phone, chat, visit, etc.","Záznam všech sdělení typu e-mail, telefon, chat, návštěvy, atd",
Records,Evidence,
Redirect URL,přesměrování URL,
Ref,Ref,
Ref Date,Ref Datum,
Reference,reference,
Reference #{0} dated {1},Reference # {0} ze dne {1},
Reference Date,Referenční datum,
Reference Doctype must be one of {0},Referenční Doctype musí být jedním z {0},
Reference Document,referenční dokument,
Reference Document Type,Referenční Typ dokumentu,
Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0},
Reference No and Reference Date is mandatory for Bank transaction,Referenční číslo a referenční datum je povinný pro bankovní transakce,
Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni",
Reference No.,Referenční číslo,
Reference Number,Referenční číslo,
Reference Owner,referenční Vlastník,
Reference Type,Typ reference,
"Reference: {0}, Item Code: {1} and Customer: {2}","Odkaz: {0}, Kód položky: {1} a zákazník: {2}",
References,Reference,
Refresh Token,Obnovit Token,
Region,Kraj,
Register,Registrovat,
Reject,Odmítnout,
Rejected,Zamítnuto,
Related,Příbuzný,
Relation with Guardian1,Souvislost s Guardian1,
Relation with Guardian2,Souvislost s Guardian2,
Release Date,Datum vydání,
Reload Linked Analysis,Znovu načtení propojené analýzy,
Remaining,Zbývající,
Remaining Balance,Zůstatek účtu,
Remarks,Poznámky,
Reminder to update GSTIN Sent,Připomenutí k aktualizaci zprávy GSTIN Sent,
Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku,
Removed items with no change in quantity or value.,Odstraněné položky bez změny množství nebo hodnoty.,
Reopen,Znovu otevřít,
Reorder Level,Změna pořadí Level,
Reorder Qty,Změna pořadí Množství,
Repeat Customer Revenue,Repeat Customer Příjmy,
Repeat Customers,Opakujte zákazníci,
Replace BOM and update latest price in all BOMs,Nahraďte kusovníku a aktualizujte nejnovější cenu ve všech kusovnících,
Replied,Odpovězeno,
Replies,Odpovědi,
Report,Report,
Report Builder,Konfigurátor Reportu,
Report Type,Typ výpisu,
Report Type is mandatory,Report Type je povinné,
Reports,zprávy,
Reqd By Date,Př p Podle data,
Reqd Qty,Požadovaný počet,
Request for Quotation,Žádost o cenovou nabídku,
Request for Quotations,Žádost o citátů,
Request for Raw Materials,Žádost o suroviny,
Request for purchase.,Žádost o koupi.,
Request for quotation.,Žádost o cenovou nabídku.,
Requested Qty,Požadované množství,
"Requested Qty: Quantity requested for purchase, but not ordered.","Požadované množství: Množství požádalo o koupi, ale nenařídil.",
Requesting Site,Žádající web,
Requesting payment against {0} {1} for amount {2},Požadovala vyplacení proti {0} {1} na částku {2},
Requestor,Žadatel,
Required On,Povinné On,
Required Qty,Požadované množství,
Required Quantity,Požadované množství,
Reschedule,Změna plánu,
Research,Výzkum,
Research & Development,výzkum a vývoj,
Researcher,Výzkumník,
Resend Payment Email,Znovu poslat e-mail Payment,
Reserve Warehouse,Rezervní sklad,
Reserved Qty,Reserved Množství,
Reserved Qty for Production,Vyhrazeno Množství pro výrobu,
Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Vyhrazeno Množství pro výrobu: Množství surovin pro výrobu výrobních položek.,
"Reserved Qty: Quantity ordered for sale, but not delivered.","Reserved Množství: Množství objednal k prodeji, ale není doručena.",
Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervovaný sklad je povinný pro položku {0} v dodávaných surovinách,
Reserved for manufacturing,Vyhrazeno pro výrobu,
Reserved for sale,Vyhrazeno pro prodej,
Reserved for sub contracting,Vyhrazeno pro uzavření smlouvy,
Resistant,Odolný,
Resolve error and upload again.,Vyřešte chybu a nahrajte znovu.,
Responsibilities,Odpovědnost,
Rest Of The World,Zbytek světa,
Restart Subscription,Restartujte předplatné,
Restaurant,Restaurace,
Result Date,Datum výsledku,
Result already Submitted,Výsledek již byl odeslán,
Resume,Životopis,
Retail,Maloobchodní,
Retail & Wholesale,Maloobchod a velkoobchod,
Retail Operations,Maloobchodní operace,
Retained Earnings,Nerozdělený zisk,
Retention Stock Entry,Retention Stock Entry,
Retention Stock Entry already created or Sample Quantity not provided,Záznam již vytvořeného záznamu o skladování nebo neposkytnuté množství vzorku,
Return,Zpáteční,
Return / Credit Note,Return / dobropis,
Return / Debit Note,Return / vrubopis,
Returns,výnos,
Reverse Journal Entry,Zadání reverzního deníku,
Review Invitation Sent,Prohlížení pozvánky odesláno,
Review and Action,Přezkum a akce,
Role,Role,
Rooms Booked,Pokoje objednané,
Root Company,Root Company,
Root Type,Root Type,
Root Type is mandatory,Root Type je povinné,
Root cannot be edited.,Root nelze upravovat.,
Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko,
Round Off,Zaokrouhlit,
Rounded Total,Celkem zaokrouhleno,
Route,Trasa,
Row # {0}: ,Řádek č. {0}:,
Row # {0}: Batch No must be same as {1} {2},"Row # {0}: Batch No musí být stejné, jako {1} {2}",
Row # {0}: Cannot return more than {1} for Item {2},Řádek # {0}: Nelze vrátit více než {1} pro bodu {2},
Row # {0}: Rate cannot be greater than the rate used in {1} {2},Řádek # {0}: Míra nemůže být větší než rychlost použitá v {1} {2},
Row # {0}: Serial No is mandatory,Řádek # {0}: Výrobní číslo je povinné,
Row # {0}: Serial No {1} does not match with {2} {3},Řádek # {0}: Výrobní číslo {1} neodpovídá {2} {3},
Row #{0} (Payment Table): Amount must be negative,Řádek # {0} (platební tabulka): Částka musí být záporná,
Row #{0} (Payment Table): Amount must be positive,Řádek # {0} (Platební tabulka): Částka musí být kladná,
Row #{0}: Account {1} does not belong to company {2},Řádek # {0}: Účet {1} nepatří společnosti {2},
Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Řádek # {0}: Přidělená částka nesmí být vyšší než zůstatek.,
"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Řádek # {0}: Asset {1} nemůže být předložen, je již {2}",
Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Řádek # {0}: Nelze nastavit hodnotu, pokud je částka vyšší než částka fakturovaná pro položku {1}.",
Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Řádek # {0}: datum Světlá {1} nemůže být před Cheque Datum {2},
Row #{0}: Duplicate entry in References {1} {2},Řádek # {0}: Duplicitní záznam v odkazu {1} {2},
Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Řádek # {0}: Očekávaný datum dodání nemůže být před datem objednávky,
Row #{0}: Item added,Řádek # {0}: Položka byla přidána,
Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Řádek # {0}: Journal Entry {1} nemá účet {2} nebo již uzavřeno proti jinému poukazu,
Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Řádek # {0}: Není povoleno měnit dodavatele, objednávky již existuje",
Row #{0}: Please set reorder quantity,Řádek # {0}: Prosím nastavte množství objednací,
Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1},
Row #{0}: Qty increased by 1,Řádek # {0}: Množství se zvýšilo o 1,
Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Řádek # {0}: Cena musí být stejné, jako {1}: {2} ({3} / {4})",
Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Řádek # {0}: Referenční typ dokumentu musí být jedním z nákladového tvrzení nebo záznamu v deníku,
"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Řádek # {0}: Reference Document Type musí být jedním z objednávky, faktury nebo Journal Entry",
Row #{0}: Rejected Qty can not be entered in Purchase Return,Řádek # {0}: Zamítnutí Množství nemůže být zapsán do kupní Návrat,
Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Řádek # {0}: Zamítnutí Warehouse je povinná proti zamítnuté bodu {1},
Row #{0}: Reqd by Date cannot be before Transaction Date,Řádek # {0}: Reqd by Date nemůže být před datem transakce,
Row #{0}: Set Supplier for item {1},Řádek # {0}: Nastavte Dodavatel pro položku {1},
Row #{0}: Status must be {1} for Invoice Discounting {2},Řádek # {0}: Stav musí být {1} pro Invoice Discounting {2},
"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Řádek # {0}: Dávka {1} má pouze {2} qty. Vyberte prosím jinou dávku, která má k dispozici {3} qty nebo rozdělit řádek do více řádků, doručit / vydávat z více dávek",
Row #{0}: Timings conflicts with row {1},Row # {0}: časování v rozporu s řadou {1},
Row #{0}: {1} can not be negative for item {2},Řádek # {0}: {1} nemůže být negativní na položku {2},
Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},"Řádek č {0}: Částka nemůže být větší než Čekající Částka proti Expense nároku {1}. Do doby, než množství je {2}",
Row {0} : Operation is required against the raw material item {1},Řádek {0}: vyžaduje se operace proti položce suroviny {1},
Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},"Řádek {0} # Přidělená částka {1} nemůže být vyšší než částka, která nebyla požadována. {2}",
Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Řádek {0} # Položka {1} nelze převést více než {2} na objednávku {3},
Row {0}# Paid Amount cannot be greater than requested advance amount,Řádek {0} # Placená částka nesmí být vyšší než požadovaná částka,
Row {0}: Activity Type is mandatory.,Řádek {0}: typ činnosti je povinná.,
Row {0}: Advance against Customer must be credit,Řádek {0}: Advance proti zákazník musí být úvěr,
Row {0}: Advance against Supplier must be debit,Řádek {0}: Advance proti dodavatelem musí být odepsat,
Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Řádek {0}: Přidělená částka {1} musí být menší než nebo se rovná částce zaplacení výstavního {2},
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},
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},
Row {0}: Bill of Materials not found for the Item {1},Řádek {0}: Kusovník nebyl nalezen pro výtisku {1},
Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné,
Row {0}: Cost center is required for an item {1},Řádek {0}: pro položku {1} je požadováno nákladové středisko.,
Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1},
Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Řádek {0}: Měna BOM # {1} by se měla rovnat vybrané měně {2},
Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1},
Row {0}: Depreciation Start Date is required,Řádek {0}: Je vyžadován počáteční datum odpisování,
Row {0}: Enter location for the asset item {1},Řádek {0}: Zadejte umístění položky aktiv {1},
Row {0}: Exchange Rate is mandatory,Řádek {0}: Exchange Rate je povinné,
Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Řádek {0}: Očekávaná hodnota po uplynutí životnosti musí být nižší než částka hrubého nákupu,
Row {0}: From Time and To Time is mandatory.,Řádek {0}: From Time a na čas je povinná.,
Row {0}: From Time and To Time of {1} is overlapping with {2},Řádek {0}: čas od času i na čas z {1} se překrývá s {2},
Row {0}: From time must be less than to time,Řádek {0}: Čas od času musí být kratší než čas,
Row {0}: Hours value must be greater than zero.,Řádek {0}: doba hodnota musí být větší než nula.,
Row {0}: Invalid reference {1},Řádek {0}: Neplatná reference {1},
Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Řádek {0}: Party / Account neshoduje s {1} / {2} do {3} {4},
Row {0}: Party Type and Party is required for Receivable / Payable account {1},Řádek {0}: Typ Party Party a je nutné pro pohledávky / závazky na účtu {1},
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,
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.",
Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Řádek {0}: Nastavte prosím na důvod osvobození od daně v daních z prodeje a poplatcích,
Row {0}: Please set the Mode of Payment in Payment Schedule,Řádek {0}: Nastavte prosím platební režim v plánu plateb,
Row {0}: Please set the correct code on Mode of Payment {1},Řádek {0}: Nastavte prosím správný kód v platebním režimu {1},
Row {0}: Qty is mandatory,Row {0}: Množství je povinný,
Row {0}: Quality Inspection rejected for item {1},Řádek {0}: Inspekce kvality zamítnuta pro položku {1},
Row {0}: UOM Conversion Factor is mandatory,Řádek {0}: UOM Konverzní faktor je povinné,
Row {0}: select the workstation against the operation {1},Řádek {0}: vyberte pracovní stanici proti operaci {1},
Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Řádek {0}: {1} Sériová čísla vyžadovaná pro položku {2}. Poskytli jste {3}.,
Row {0}: {1} is required to create the Opening {2} Invoices,Řádek {0}: {1} je zapotřebí pro vytvoření faktur otevření {2},
Row {0}: {1} must be greater than 0,Řádek {0}: {1} musí být větší než 0,
Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3},
Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum",
Rows with duplicate due dates in other rows were found: {0},Řádky s duplicitními daty v jiných řádcích byly nalezeny: {0},
Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.,
Rules for applying pricing and discount.,Pravidla pro používání cen a slevy.,
S.O. No.,SO Ne.,
SGST Amount,Částka SGST,
SO Qty,SO Množství,
Safety Stock,Bezpečné skladové množství,
Salary,Plat,
Salary Slip ID,Plat Slip ID,
Salary Slip of employee {0} already created for this period,Výplatní pásce zaměstnance {0} již vytvořili pro toto období,
Salary Slip of employee {0} already created for time sheet {1},Výplatní pásce zaměstnance {0} již vytvořili pro časové list {1},
Salary Slip submitted for period from {0} to {1},Zápis o platu odeslán na období od {0} do {1},
Salary Structure Assignment for Employee already exists,Přiřazení struktury platu pro zaměstnance již existuje,
Salary Structure Missing,Plat Struktura Chybějící,
Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura mezd musí být předložena před podáním daňového přiznání,
Salary Structure not found for employee {0} and date {1},Struktura platu nebyla nalezena pro zaměstnance {0} a datum {1},
Salary Structure should have flexible benefit component(s) to dispense benefit amount,Struktura odměňování by měla mít flexibilní složku (výhody) pro vyplácení dávky,
"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plat již zpracovány pro období mezi {0} a {1}, ponechte dobu použitelnosti nemůže být mezi tomto časovém období.",
Sales,Prodej,
Sales Account,Prodejní účet,
Sales Expenses,Prodejní náklady,
Sales Funnel,Prodej Nálevka,
Sales Invoice,Prodejní faktury,
Sales Invoice {0} has already been submitted,Prodejní faktury {0} již byla odeslána,
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,
Sales Manager,Manažer prodeje,
Sales Master Manager,Sales manažer ve skupině Master,
Sales Order,Prodejní objednávky,
Sales Order Item,Prodejní objednávky Item,
Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0},
Sales Order to Payment,Prodejní objednávky na platby,
Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena,
Sales Order {0} is not valid,Prodejní objednávky {0} není platný,
Sales Order {0} is {1},Prodejní objednávky {0} {1},
Sales Orders,Prodejní objednávky,
Sales Partner,Sales Partner,
Sales Pipeline,prodejní Pipeline,
Sales Price List,Prodejní ceník,
Sales Return,Sales Return,
Sales Summary,Přehled o prodeji,
Sales Tax Template,Daň z prodeje Template,
Sales Team,Prodejní tým,
Sales User,Uživatel prodeje,
Sales and Returns,Prodej a výnosy,
Sales campaigns.,Prodej kampaně.,
Sales orders are not available for production,Prodejní objednávky nejsou k dispozici pro výrobu,
Salutation,Oslovení,
Same Company is entered more than once,Stejný Společnost je zapsána více než jednou,
Same item cannot be entered multiple times.,Stejnou položku nelze zadat vícekrát.,
Same supplier has been entered multiple times,Stejný dodavatel byl zadán vícekrát,
Sample,Vzorek,
Sample Collection,Kolekce vzorků,
Sample quantity {0} cannot be more than received quantity {1},Množství vzorku {0} nemůže být větší než přijaté množství {1},
Sanctioned,schválený,
Sanctioned Amount,Sankcionována Částka,
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}.,
Sand,Písek,
Saturday,Sobota,
Saved,Uloženo,
Saving {0},Uložení {0},
Scan Barcode,Naskenujte čárový kód,
Schedule,Plán,
Schedule Admission,Naplánovat přijetí,
Schedule Course,rozvrh,
Schedule Date,Plán Datum,
Schedule Discharge,Plán výtoku,
Scheduled,Plánované,
Scheduled Upto,Naplánováno až,
"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Plán pro překrytí {0}, chcete pokračovat po přeskočení přesahovaných slotů?",
Score cannot be greater than Maximum Score,Skóre nemůže být větší než maximum bodů,
Score must be less than or equal to 5,Skóre musí být menší než nebo rovna 5,
Scorecards,Scorecards,
Scrapped,sešrotován,
Search,Hledat,
Search Results,Výsledky vyhledávání,
Search Sub Assemblies,Vyhledávání Sub Assemblies,
"Search by item code, serial number, batch no or barcode","Vyhledávání podle kódu položky, sériového čísla, šarže nebo čárového kódu",
"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd.",
Secret Key,Tajný klíč,
Secretary,Sekretářka,
Section Code,Kód oddílu,
Secured Loans,Zajištěné úvěry,
Securities & Commodity Exchanges,Cenné papíry a komoditních burzách,
Securities and Deposits,Cenné papíry a vklady,
See All Articles,Zobrazit všechny články,
See all open tickets,Podívejte se na všechny vstupenky,
See past orders,Zobrazit minulé objednávky,
See past quotations,Zobrazit minulé nabídky,
Select,Vybrat,
Select Alternate Item,Vyberte Alternativní položku,
Select Attribute Values,Vyberte hodnoty atributu,
Select BOM,Vybrat BOM,
Select BOM and Qty for Production,Vyberte BOM a Množství pro výrobu,
"Select BOM, Qty and For Warehouse","Vyberte kusovník, množství a pro sklad",
Select Batch,Vyberte možnost Dávka,
Select Batch Numbers,Zvolte čísla šarží,
Select Brand...,Select Brand ...,
Select Company,Vyberte společnost,
Select Company...,Vyberte společnost ...,
Select Customer,Vyberte zákazníka,
Select Days,Vyberte dny,
Select Default Supplier,Vybrat Výchozí Dodavatel,
Select DocType,Zvolte DocType,
Select Fiscal Year...,Vyberte fiskálního roku ...,
Select Item (optional),Vyberte položku (volitelné),
Select Items based on Delivery Date,Vyberte položky podle data doručení,
Select Items to Manufacture,Vyberte položky do Výroba,
Select Loyalty Program,Vyberte Věrnostní program,
Select Patient,Vyberte pacienta,
Select Possible Supplier,Vyberte Možné dodavatele,
Select Property,Vyberte vlastnost,
Select Quantity,Zvolte množství,
Select Serial Numbers,Zvolte sériová čísla,
Select Target Warehouse,Vyberte objekt Target Warehouse,
Select Warehouse...,Vyberte sklad ...,
Select an account to print in account currency,"Vyberte účet, který chcete vytisknout v měně účtu",
Select an employee to get the employee advance.,"Vyberte zaměstnance, chcete-li zaměstnance předem.",
Select at least one value from each of the attributes.,Vyberte alespoň jednu hodnotu z každého atributu.,
Select change amount account,Vybrat změna výše účet,
Select company first,Nejprve vyberte společnost,
Select students manually for the Activity based Group,Vyberte studenty ručně pro skupinu založenou na aktivitách,
Select the customer or supplier.,Vyberte zákazníka nebo dodavatele.,
Select the nature of your business.,Vyberte podstatu svého podnikání.,
Select the program first,Nejprve vyberte program,
Select to add Serial Number.,Vyberte pro přidání sériového čísla.,
Select your Domains,Vyberte své domény,
Selected Price List should have buying and selling fields checked.,Vybraný ceník by měl kontrolovat nákupní a prodejní pole.,
Sell,Prodat,
Selling,Prodej,
Selling Amount,Prodejní částka,
Selling Price List,Prodejní ceník,
Selling Rate,Prodejní sazba,
"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}",
Send Grant Review Email,Odeslání e-mailu o revizi grantu,
Send Now,Odeslat nyní,
Send SMS,Pošlete SMS,
Send Supplier Emails,Poslat Dodavatel e-maily,
Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům,
Sensitivity,Citlivost,
Sent,Odesláno,
Serial #,Serial #,
Serial No and Batch,Pořadové číslo a Batch,
Serial No is mandatory for Item {0},Pořadové číslo je povinná k bodu {0},
Serial No {0} does not belong to Batch {1},Sériové číslo {0} nepatří do skupiny Batch {1},
Serial No {0} does not belong to Delivery Note {1},Pořadové číslo {0} není součástí dodávky Poznámka: {1},
Serial No {0} does not belong to Item {1},Pořadové číslo {0} nepatří k bodu {1},
Serial No {0} does not belong to Warehouse {1},Pořadové číslo {0} nepatří do skladu {1},
Serial No {0} does not belong to any Warehouse,"Pořadové číslo {0} nepatří do skladu,",
Serial No {0} does not exist,Pořadové číslo {0} neexistuje,
Serial No {0} has already been received,Pořadové číslo {0} již obdržel,
Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1},
Serial No {0} is under warranty upto {1},Pořadové číslo {0} je v záruce aľ {1},
Serial No {0} not found,Pořadové číslo {0} nebyl nalezen,
Serial No {0} not in stock,Pořadové číslo {0} není skladem,
Serial No {0} quantity {1} cannot be a fraction,Pořadové číslo {0} {1} množství nemůže být zlomek,
Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0},
Serial Number: {0} is already referenced in Sales Invoice: {1},Sériové číslo: {0} je již uvedeno v prodejní faktuře: {1},
Serial Numbers,Sériová čísla,
Serial Numbers in row {0} does not match with Delivery Note,Sériová čísla v řádku {0} neodpovídají poznámce k doručení,
Serial no {0} has been already returned,Sériové číslo {0} již bylo vráceno,
Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou,
Serialized Inventory,Serialized Zásoby,
Series Updated,Řada Aktualizováno,
Series Updated Successfully,Řada Aktualizováno Úspěšně,
Series is mandatory,Série je povinné,
Series {0} already used in {1},Série {0} jsou již použity v {1},
Service,Služba,
Service Expense,Service Expense,
Service Level Agreement,Dohoda o úrovni služeb,
Service Level Agreement.,Dohoda o úrovni služeb.,
Service Level.,Úroveň služby.,
Service Stop Date cannot be after Service End Date,Datum ukončení služby nemůže být po datu ukončení služby,
Service Stop Date cannot be before Service Start Date,Datum ukončení servisu nemůže být před datem zahájení servisu,
Services,Služby,
"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",
Set Details,Nastavte Podrobnosti,
Set New Release Date,Nastavte nový datum vydání,
Set Project and all Tasks to status {0}?,Nastavit projekt a všechny úkoly do stavu {0}?,
Set Status,Nastavit stav,
Set Tax Rule for shopping cart,Sada Daňové Pravidlo pro nákupního košíku,
Set as Closed,Nastavit jako Zavřeno,
Set as Completed,Nastavit jako dokončeno,
Set as Default,Nastavit jako výchozí,
Set as Lost,Nastavit jako Lost,
Set as Open,Nastavit jako Otevřít,
Set default inventory account for perpetual inventory,Nastavte výchozí inventář pro trvalý inventář,
Set this if the customer is a Public Administration company.,"Nastavte, pokud je zákazníkem společnost veřejné správy.",
Set {0} in asset category {1} or company {2},Nastavte {0} v kategorii aktiv {1} nebo ve firmě {2},
"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Nastavení událostí do {0}, protože zaměstnanec připojena k níže prodejcům nemá ID uživatele {1}",
Setting defaults,Nastavení výchozích hodnot,
Setting up Email,Nastavení e-mail,
Setting up Email Account,Nastavení e-mailový účet,
Setting up Employees,Nastavení Zaměstnanci,
Setting up Taxes,Nastavení Daně,
Setting up company,Založení společnosti,
Settings,Nastavení,
"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",
Settings for website homepage,Nastavení titulní stránce webu,
Settings for website product listing,Nastavení pro seznam produktů na webu,
Settled,Usadil se,
Setup Gateway accounts.,Nastavení brány účty.,
Setup SMS gateway settings,Nastavení SMS brány,
Setup cheque dimensions for printing,Zkontrolujte nastavení rozměry pro tisk,
Setup default values for POS Invoices,Nastavení výchozích hodnot pro POS faktury,
Setup mode of POS (Online / Offline),Režim nastavení POS (Online / Offline),
Setup your Institute in ERPNext,Nastavte svůj institut v ERPNext,
Share Balance,Sázení podílů,
Share Ledger,Sdílet knihu,
Share Management,Správa sdílených položek,
Share Transfer,Sdílet přenos,
Share Type,Typ sdílení,
Shareholder,Akcionář,
Ship To State,Loď do státu,
Shipments,Zásilky,
Shipping,Doprava,
Shipping Address,Dodací adresa,
"Shipping Address does not have country, which is required for this Shipping Rule","Odeslání adresy nemá zemi, která je požadována pro toto Pravidlo plavby",
Shipping rule only applicable for Buying,Pravidlo plavby platí pouze pro nákup,
Shipping rule only applicable for Selling,Pravidlo plavby platí pouze pro prodej,
Shopify Supplier,Nakupujte dodavatele,
Shopping Cart,Nákupní vozík,
Shopping Cart Settings,Nákupní košík Nastavení,
Short Name,Zkrácené jméno,
Shortage Qty,Nedostatek Množství,
Show Completed,Zobrazit dokončeno,
Show Cumulative Amount,Zobrazit kumulativní částku,
Show Employee,Zobrazit zaměstnance,
Show Open,Ukázat otevřené,
Show Opening Entries,Zobrazit otevírací položky,
Show Payment Details,Zobrazit údaje o platbě,
Show Return Entries,Zobrazit položky návratu,
Show Salary Slip,Show výplatní pásce,
Show Variant Attributes,Zobrazit atributy variantu,
Show Variants,Zobrazit varianty,
Show closed,Show uzavřen,
Show exploded view,Zobrazit rozložený pohled,
Show only POS,Zobrazit pouze POS,
Show unclosed fiscal year's P&L balances,Ukázat P &amp; L zůstatky neuzavřený fiskální rok je,
Show zero values,Ukázat nulové hodnoty,
Sick Leave,Zdravotní dovolená,
Silt,Silt,
Single Variant,Jediný variant,
Single unit of an Item.,Single jednotka položky.,
"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Přeskočit přidělení alokace pro následující zaměstnance, jelikož proti nim existují záznamy o přidělení alokace. {0}",
"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Přeskočení přiřazení struktury mezd pro následující zaměstnance, protože záznamy o přiřazení struktury mezd již proti nim existují. {0}",
Slideshow,Promítání obrázků,
Slots for {0} are not added to the schedule,Sloty pro {0} nejsou přidány do plánu,
Small,Malý,
Soap & Detergent,Soap & Detergent,
Software,Software,
Software Developer,Software Developer,
Softwares,Programy,
Soil compositions do not add up to 100,Půdní kompozice nedosahují 100,
Sold,Prodáno,
Some emails are invalid,Některé e-maily jsou neplatné,
Some information is missing,Některé informace chybí,
Something went wrong!,Něco se pokazilo!,
"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit",
Source,Zdroj,
Source Name,Název zdroje,
Source Warehouse,Zdroj Warehouse,
Source and Target Location cannot be same,Umístění zdroje a cíle nemohou být stejné,
Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0},
Source and target warehouse must be different,Zdrojové a cílové sklad se musí lišit,
Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků),
Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0},
Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1},
Split,Rozdělit,
Split Batch,Split Batch,
Split Issue,Split Issue,
Sports,Sportovní,
Staffing Plan {0} already exist for designation {1},Personální plán {0} již existuje pro označení {1},
Standard,Standard,
Standard Buying,Standardní Nakupování,
Standard Selling,Standardní prodejní,
Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.,
Start Date,Datum zahájení,
Start Date of Agreement can't be greater than or equal to End Date.,Datum zahájení dohody nesmí být větší nebo rovno Datum ukončení.,
Start Year,Začátek Rok,
"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Počáteční a koncová data, která nejsou v platném výplatním období, nelze vypočítat {0}",
"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Počáteční a koncové datum, které nejsou v platném mzdovém období, nelze vypočítat {0}.",
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},
Start date should be less than end date for task {0},Datum zahájení by mělo být menší než datum ukončení úkolu {0},
Start day is greater than end day in task '{0}',Den začátku je větší než koncový den v úloze &#39;{0}&#39;,
Start on,Začněte dál,
State,Stát,
State/UT Tax,Daň státu / UT,
Statement of Account,Výpis z účtu,
Status must be one of {0},Stav musí být jedním z {0},
Stock,Sklad,
Stock Adjustment,Reklamní Nastavení,
Stock Analytics,Stock Analytics,
Stock Assets,Stock Aktiva,
Stock Available,Skladem k dispozici,
Stock Balance,Reklamní Balance,
Stock Entries already created for Work Order ,Zápisy již vytvořené pro pracovní objednávku,
Stock Entry,Skladový pohyb,
Stock Entry {0} created,Skladovou pohyb {0} vytvořil,
Stock Entry {0} is not submitted,Skladový pohyb {0} není založen,
Stock Expenses,Stock Náklady,
Stock In Hand,Skladem v ruce,
Stock Items,sklade,
Stock Ledger,Reklamní Ledger,
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,
Stock Levels,Sklad Úrovně,
Stock Liabilities,Stock Závazky,
Stock Options,Akciové opce,
Stock Qty,Množství zásob,
Stock Received But Not Billed,Sklad nepřijali Účtovaný,
Stock Reports,Stock Reports,
Stock Summary,Sklad Souhrn,
Stock Transactions,Sklad Transakce,
Stock UOM,Reklamní UOM,
Stock Value,Reklamní Value,
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},
Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0},
Stock cannot be updated against Purchase Receipt {0},Sklad nelze aktualizovat proti dokladu o koupi {0},
Stock cannot exist for Item {0} since has variants,"Sklad nemůže existovat k bodu {0}, protože má varianty",
Stock transactions before {0} are frozen,Fotky transakce před {0} jsou zmrazeny,
Stop,Stop,
Stopped,Zastaveno,
"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zastavená pracovní objednávka nemůže být zrušena, zrušte její zrušení",
Stores,Zásoba,
Structures have been assigned successfully,Struktury byly úspěšně přiřazeny,
Student,Student,
Student Activity,Studentská aktivita,
Student Address,Studentská adresa,
Student Admissions,Student Přijímací,
Student Attendance,Student Účast,
"Student Batches help you track attendance, assessments and fees for students","Student Šarže pomůže sledovat docházku, posudky a poplatků pro studenty",
Student Email Address,Student E-mailová adresa,
Student Email ID,Student ID e-mailu,
Student Group,Student Group,
Student Group Strength,Síla skupiny studentů,
Student Group is already updated.,Studentská skupina je již aktualizována.,
Student Group: ,Studentská skupina:,
Student ID,Student ID,
Student ID: ,Student ID:,
Student LMS Activity,Aktivita studentského LMS,
Student Mobile No.,Student Mobile No.,
Student Name,Jméno studenta,
Student Name: ,Jméno studenta:,
Student Report Card,Studentská karta,
Student is already enrolled.,Student je již zapsáno.,
Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} objeví vícekrát za sebou {2} {3},
Student {0} does not belong to group {1},Student {0} nepatří do skupiny {1},
Student {0} exist against student applicant {1},Existují Student {0} proti uchazeč student {1},
"Students are at the heart of the system, add all your students","Studenti jsou jádrem systému, přidejte všechny své studenty",
Sub Assemblies,Podsestavy,
Sub Type,Sub Type,
Sub-contracting,Subdodávky,
Subcontract,Subdodávka,
Subject,Předmět,
Submit,Odeslat,
Submit Proof,Odeslat důkaz,
Submit Salary Slip,Odeslat výplatní pásce,
Submit this Work Order for further processing.,Předložit tuto pracovní objednávku k dalšímu zpracování.,
Submit this to create the Employee record,"Chcete-li vytvořit záznam zaměstnance, odešlete jej",
Submitting Salary Slips...,Odeslání platebních karet ...,
Subscription,Předplatné,
Subscription Management,Řízení předplatného,
Subscriptions,Předplatné,
Subtotal,Mezisoučet,
Successful,Úspěšný,
Successfully Reconciled,Úspěšně smířeni,
Successfully Set Supplier,Úspěšně Nastavit Dodavatele,
Successfully created payment entries,Úspěšné vytvoření platebních položek,
Successfully deleted all transactions related to this company!,Úspěšně vypouští všechny transakce související s tímto společnosti!,
Sum of Scores of Assessment Criteria needs to be {0}.,Součet skóre hodnotících kritérií musí být {0}.,
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},
Summary,souhrn,
Summary for this month and pending activities,Shrnutí pro tento měsíc a probíhajícím činnostem,
Summary for this week and pending activities,Shrnutí pro tento týden a probíhajícím činnostem,
Sunday,Neděle,
Suplier,Suplier,
Supplier,Dodavatel,
Supplier Group,Skupina dodavatelů,
Supplier Group master.,Hlavní dodavatel skupiny.,
Supplier Id,Dodavatel Id,
Supplier Invoice Date cannot be greater than Posting Date,Dodavatel Datum faktury nemůže být větší než Datum zveřejnění,
Supplier Invoice No,Dodavatelské faktury č,
Supplier Invoice No exists in Purchase Invoice {0},Dodavatelské faktury No existuje ve faktuře {0},
Supplier Name,Dodavatel Name,
Supplier Part No,Žádný dodavatel Part,
Supplier Quotation,Dodavatel Nabídka,
Supplier Scorecard,Hodnotící karta dodavatele,
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení,
Supplier database.,Databáze dodavatelů.,
Supplier {0} not found in {1},Dodavatel {0} nebyl nalezen v {1},
Supplier(s),Dodavatel (é),
Supplies made to UIN holders,Spotřební materiál pro držitele UIN,
Supplies made to Unregistered Persons,Dodávky poskytované neregistrovaným osobám,
Suppliies made to Composition Taxable Persons,Doplňky pro osoby povinné k dani ze složení,
Supply Type,Druh napájení,
Support,Podpora,
Support Analytics,Podpora Analytics,
Support Settings,Nastavení podpůrných,
Support Tickets,Vstupenky na podporu,
Support queries from customers.,Podpora dotazy ze strany zákazníků.,
Susceptible,Citlivý,
Sync has been temporarily disabled because maximum retries have been exceeded,"Synchronizace byla dočasně deaktivována, protože byly překročeny maximální počet opakování",
Syntax error in condition: {0},Chyba syntaxe ve stavu: {0},
Syntax error in formula or condition: {0},syntaktická chyba ve vzorci nebo stavu: {0},
System Manager,Správce systému,
TDS Rate %,Míra TDS%,
Tap items to add them here,Klepnutím na položky je můžete přidat zde,
Target,Cíl,
Target ({}),Cílová ({}),
Target On,Target On,
Target Warehouse,Target Warehouse,
Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0},
Task,Úkol,
Tasks,Úkoly,
Tasks have been created for managing the {0} disease (on row {1}),Byly vytvořeny úkoly pro správu nemoci {0} (na řádku {1}),
Tax,Daň,
Tax Assets,Daňové Aktiva,
Tax Category,Daňová kategorie,
Tax Category for overriding tax rates.,Daňová kategorie pro převažující daňové sazby.,
"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Daňová kategorie byla změněna na &quot;Celkem&quot;, protože všechny položky jsou položky, které nejsou skladem",
Tax ID,DIČ,
Tax Id: ,DIČ:,
Tax Rate,Tax Rate,
Tax Rule Conflicts with {0},Daňové Pravidlo Konflikty s {0},
Tax Rule for transactions.,Daňové pravidlo pro transakce.,
Tax Template is mandatory.,Daňová šablona je povinné.,
Tax Withholding rates to be applied on transactions.,"Sazby daně ze zadržených daní, které se použijí na transakce.",
Tax template for buying transactions.,Daňové šablona pro nákup transakcí.,
Tax template for item tax rates.,Šablona daně pro sazby daně z zboží.,
Tax template for selling transactions.,Daňové šablona na prodej transakce.,
Taxable Amount,Zdanitelná částka,
Taxes,Daně,
Team Updates,tým Aktualizace,
Technology,Technologie,
Telecommunications,Telekomunikace,
Telephone Expenses,Telefonní náklady,
Television,Televize,
Template Name,Název šablony,
Template of terms or contract.,Šablona podmínek nebo smlouvy.,
Templates of supplier scorecard criteria.,Šablony kritérií kritérií pro dodavatele.,
Templates of supplier scorecard variables.,Šablony proměnných tabulky dodavatelů dodavatelů.,
Templates of supplier standings.,Šablony dodavatelů.,
Temporarily on Hold,Dočasně pozdrženo,
Temporary,Dočasný,
Temporary Accounts,Dočasné účty,
Temporary Opening,Dočasné otevření,
Terms and Conditions,Podmínky,
Terms and Conditions Template,Podmínky Template,
Territory,Území,
Test,Test,
Thank you,Děkujeme Vám,
Thank you for your business!,Děkuji za Váš obchod!,
The 'From Package No.' field must neither be empty nor it's value less than 1.,&quot;Z balíčku č.&quot; pole nesmí být prázdné ani jeho hodnota menší než 1.,
The Brand,Brand,
The Item {0} cannot have Batch,Položka {0} nemůže mít dávku,
The Loyalty Program isn't valid for the selected company,Věrnostní program není platný pro vybranou firmu,
The Payment Term at row {0} is possibly a duplicate.,Platba v řádku {0} je možná duplikát.,
The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Termínovaný Datum ukončení nesmí být starší než Počáteční datum doby platnosti. Opravte data a zkuste to znovu.,
The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termínovaný Datum ukončení nemůže být později než v roce Datum ukončení akademického roku, ke kterému termín je spojena (akademický rok {}). Opravte data a zkuste to znovu.",
The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termínovaný Datum zahájení nemůže být dříve než v roce datum zahájení akademického roku, ke kterému termín je spojena (akademický rok {}). Opravte data a zkuste to znovu.",
The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Rok Datum ukončení nesmí být starší než datum Rok Start. Opravte data a zkuste to znovu.,
The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,"Část {0} nastavená v této žádosti o platbu se liší od vypočtené částky všech platebních plánů: {1}. Před odesláním dokumentu se ujistěte, že je to správné.",
The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"V den, kdy (y), na které žádáte o povolení jsou prázdniny. Nemusíte požádat o volno.",
The field From Shareholder cannot be blank,Pole Od akcionáře nesmí být prázdné,
The field To Shareholder cannot be blank,Pole Akcionář nemůže být prázdné,
The fields From Shareholder and To Shareholder cannot be blank,Políčka Od Akcionáře a Akcionáře nesmí být prázdná,
The folio numbers are not matching,Čísla fólií se neodpovídají,
The holiday on {0} is not between From Date and To Date,Dovolená na {0} není mezi Datum od a do dnešního dne,
The name of the institute for which you are setting up this system.,Název institutu pro který nastavujete tento systém.,
The name of your company for which you are setting up this system.,"Název vaší společnosti, pro kterou nastavení tohoto systému.",
The number of shares and the share numbers are inconsistent,Počet akcií a čísla akcií je nekonzistentní,
The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Účet platební brány v plánu {0} se liší od účtu platební brány v této žádosti o platbu,
The request for quotation can be accessed by clicking on the following link,Žádost o cenovou nabídku lze přistupovat kliknutím na následující odkaz,
The selected BOMs are not for the same item,Vybrané kusovníky nejsou stejné položky,
The selected item cannot have Batch,Vybraná položka nemůže mít dávku,
The seller and the buyer cannot be the same,Prodávající a kupující nemohou být stejní,
The shareholder does not belong to this company,Akcionář nepatří k této společnosti,
The shares already exist,Akcie již existují,
The shares don't exist with the {0},Akcie neexistují s {0},
"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",Úkol byl označen jako úloha na pozadí. V případě jakéhokoli problému se zpracováním na pozadí přidá systém komentář k chybě v tomto smíření zásob a vrátí se do fáze konceptu.,
"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",
"There are inconsistencies between the rate, no of shares and the amount calculated","Existují nesrovnalosti mezi sazbou, počtem akcií a vypočítanou částkou",
There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.,
There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,V závislosti na celkovém vynaloženém množství může být více stupňů sběru. Přepočítací koeficient pro vykoupení bude vždy stejný pro všechny úrovně.,
There can only be 1 Account per Company in {0} {1},Tam může být pouze 1 účet na společnosti v {0} {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""",
There is no leave period in between {0} and {1},"Mezi {0} a {1} není žádná doba dovolené,",
There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0},
There is nothing to edit.,Není nic upravovat.,
There isn't any item variant for the selected item,Pro zvolenou položku není k dispozici žádná varianta položky,
"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Zdá se, že existuje problém se konfigurací serveru GoCardless. Nebojte se, v případě selhání bude částka vrácena na váš účet.",
There were errors creating Course Schedule,Došlo k chybám při vytváření plánu rozvrhů,
There were errors.,Byly tam chyby.,
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""",
This Item is a Variant of {0} (Template).,Tato položka je variantou {0} (šablony).,
This Month's Summary,Tento měsíc je shrnutí,
This Week's Summary,Tento týden Shrnutí,
This action will stop future billing. Are you sure you want to cancel this subscription?,Tato akce zastaví budoucí fakturaci. Opravdu chcete zrušit tento odběr?,
This covers all scorecards tied to this Setup,"Toto pokrývá všechny body, které jsou spojeny s tímto nastavením",
This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Tento dokument je nad hranicí {0} {1} pro položku {4}. Děláte si jiný {3} proti stejné {2}?,
This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.,
This is a root customer group and cannot be edited.,"To je kořen skupiny zákazníků, a nelze upravovat.",
This is a root department and cannot be edited.,Toto je kořenové oddělení a nemůže být editováno.,
This is a root healthcare service unit and cannot be edited.,Jedná se o základní službu zdravotnické služby a nelze ji editovat.,
This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.,
This is a root sales person and cannot be edited.,To je kořen prodejní člověk a nelze upravovat.,
This is a root supplier group and cannot be edited.,Toto je kořenová skupina dodavatelů a nemůže být editována.,
This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.,
This is an example website auto-generated from ERPNext,To je příklad webové stránky automaticky generované z ERPNext,
This is based on logs against this Vehicle. See timeline below for details,To je založeno na protokolech proti tomuto vozidlu. Viz časovou osu níže podrobnosti,
This is based on stock movement. See {0} for details,To je založeno na akciovém pohybu. Viz {0} Podrobnosti,
This is based on the Time Sheets created against this project,To je založeno na časových výkazů vytvořených proti tomuto projektu,
This is based on the attendance of this Employee,To je založeno na účasti základu tohoto zaměstnance,
This is based on the attendance of this Student,To je založeno na účasti tohoto studenta,
This is based on transactions against this Customer. See timeline below for details,Přehled aktivity zákazníka.,
This is based on transactions against this Healthcare Practitioner.,To je založeno na transakcích proti tomuto zdravotnickému lékaři.,
This is based on transactions against this Patient. See timeline below for details,To je založeno na transakcích proti tomuto pacientovi. Podrobnosti viz časová osa níže,
This is based on transactions against this Sales Person. See timeline below for details,Toto je založeno na transakcích proti této prodejní osobě. Podrobnosti viz časová osa níže,
This is based on transactions against this Supplier. See timeline below for details,To je založeno na transakcích proti tomuto dodavateli. Viz časovou osu níže podrobnosti,
This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Tím bude předkládán výplatní pásky a vytvářet záznamy časového rozvrhu. Chcete pokračovat?,
This {0} conflicts with {1} for {2} {3},Tato {0} je v rozporu s {1} o {2} {3},
Time Sheet for manufacturing.,Čas list pro výrobu.,
Time Tracking,Time Tracking,
"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Časový interval přeskočil, slot {0} až {1} překrýval existující slot {2} na {3}",
Time slots added,Byly přidány časové úseky,
Time(in mins),Čas (v min),
Timer,Časovač,
Timer exceeded the given hours.,Časovač překročil danou dobu.,
Timesheet,Rozvrh hodin,
Timesheet for tasks.,Časového rozvrhu pro úkoly.,
Timesheet {0} is already completed or cancelled,Časového rozvrhu {0} je již dokončena nebo zrušena,
Timesheets,Timesheets,
"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomůže udržet přehled o času, nákladů a účtování pro aktivit hotový svého týmu",
Titles for print templates e.g. Proforma Invoice.,"Tituly na tiskových šablon, např zálohové faktury.",
To,Na,
To Address 1,Adresa 1,
To Address 2,Na adresu 2,
To Bill,Billa,
To Date,To Date,
To Date cannot be before From Date,K dnešnímu dni nemůže být dříve od data,
To Date cannot be less than From Date,Datum k datu nemůže být menší než od data,
To Date must be greater than From Date,Datum musí být větší než od data,
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}",
To Datetime,Chcete-li datetime,
To Deliver,Dodat,
To Deliver and Bill,Dodat a Bill,
To Fiscal Year,Do fiskálního roku,
To GSTIN,Na GSTIN,
To Party Name,Název strany,
To Pin Code,K označení kódu,
To Place,Na místo,
To Receive,Obdržet,
To Receive and Bill,Přijímat a Bill,
To State,Do stavu,
To Warehouse,Do skladu,
To create a Payment Request reference document is required,"Chcete-li vytvořit referenční dokument žádosti o platbu, je třeba",
To date can not be equal or less than from date,K dnešnímu dni nemůže být stejná nebo menší než od data,
To date can not be less than from date,K dnešnímu dni nemůže být méně než od data,
To date can not greater than employee's relieving date,K dnešnímu dni nemůže být větší než datum uvolnění zaměstnance,
"To filter based on Party, select Party Type first","Chcete-li filtrovat na základě Party, vyberte typ Party první",
"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Chcete-li získat to nejlepší z ERPNext, doporučujeme vám nějaký čas trvat, a sledovat tyto nápovědy videa.",
"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",
To make Customer based incentive schemes.,Vytvoření pobídkových schémat založených na zákazníkovi.,
"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky",
"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.",
"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í""",
To view logs of Loyalty Points assigned to a Customer.,Zobrazení logů věrnostních bodů přidělených zákazníkovi.,
To {0},Chcete-li {0},
To {0} | {1} {2},Chcete-li {0} | {1} {2},
Toggle Filters,Přepnout filtry,
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.,
Tools,Nástroje,
Total (Credit),Celkový (Credit),
Total (Without Tax),Celkem (bez daně),
Total Absent,Celkem Absent,
Total Achieved,Celkem Dosažená,
Total Actual,Celkem Aktuální,
Total Allocated Leaves,Celkové přidělené listy,
Total Amount,Celková částka,
Total Amount Credited,Celková částka připsána,
Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,"Celkový počet použitelných poplatcích v dokladu o koupi zboží, které tabulky musí být stejná jako celkem daní a poplatků",
Total Budget,Celkový rozpočet,
Total Collected: {0},Celkové shromáždění: {0},
Total Commission,Celkem Komise,
Total Contribution Amount: {0},Celková částka příspěvku: {0},
Total Credit/ Debit Amount should be same as linked Journal Entry,Celková částka Úvěr / Debit by měla být stejná jako propojený deník,
Total Debit must be equal to Total Credit. The difference is {0},Celkové inkaso musí rovnat do celkového kreditu. Rozdíl je {0},
Total Deduction,Celkem Odpočet,
Total Invoiced Amount,Celkem Fakturovaná částka,
Total Leaves,Celkem Listy,
Total Order Considered,Celková objednávka Zvážil,
Total Order Value,Celková hodnota objednávky,
Total Outgoing,Celkem Odchozí,
Total Outstanding,Naprosto vynikající,
Total Outstanding Amount,Celková dlužná částka,
Total Outstanding: {0},Celková nevyřízená hodnota: {0},
Total Paid Amount,Celkem uhrazené částky,
Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Celková částka platby v rozpisu plateb se musí rovnat hodnotě Grand / Rounded Total,
Total Payments,Celkové platby,
Total Present,Celkem Present,
Total Qty,Celkem Množství,
Total Quantity,Celkové množství,
Total Revenue,Celkový příjem,
Total Student,Celkový počet studentů,
Total Target,Celkem Target,
Total Tax,Total Tax,
Total Taxable Amount,Celková zdanitelná částka,
Total Taxable Value,Celková zdanitelná hodnota,
Total Unpaid: {0},Celkem nezaplaceno: {0},
Total Variance,Celkový rozptyl,
Total Weightage of all Assessment Criteria must be 100%,Celková weightage všech hodnotících kritérií musí být 100%,
Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celková záloha ({0}) na objednávku {1} nemůže být větší než celkový součet ({2}),
Total advance amount cannot be greater than total claimed amount,Celková výše zálohy nesmí být vyšší než celková nároková částka,
Total advance amount cannot be greater than total sanctioned amount,Celková výše zálohy nesmí být vyšší než celková částka sankce,
Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Celkové přidělené listy jsou dny více než maximální přidělení {0} typu dovolené pro zaměstnance {1} v daném období,
Total allocated leaves are more than days in the period,Celkové přidělené listy jsou více než dnů v období,
Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100,
Total cannot be zero,Celkem nemůže být nula,
Total contribution percentage should be equal to 100,Celkové procento příspěvku by se mělo rovnat 100,
Total flexible benefit component amount {0} should not be less than max benefits {1},Celková částka pružné výhody {0} by neměla být menší než maximální dávka {1},
Total hours: {0},Celkem hodin: {0},
Total leaves allocated is mandatory for Leave Type {0},Celkový počet přidělených listů je povinný pro typ dovolené {0},
Total weightage assigned should be 100%. It is {0},Celková weightage přiřazen by měla být 100%. Je {0},
Total working hours should not be greater than max working hours {0},Celkem pracovní doba by neměla být větší než maximální pracovní doby {0},
Total {0} ({1}),Celkem {0} ({1}),
"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Celkem {0} pro všechny položky je nula, může být byste měli změnit &quot;Rozdělte poplatků založený na&quot;",
Total(Amt),Total (Amt),
Total(Qty),Total (ks),
Traceability,Sledovatelnost,
Traceback,Vystopovat,
Track Leads by Lead Source.,Track Leads by Lead Source.,
Training,Výcvik,
Training Event,Training Event,
Training Events,Školení,
Training Feedback,Trénink Feedback,
Training Result,Trénink Výsledek,
Transaction,Transakce,
Transaction Date,Transakce Datum,
Transaction Type,typ transakce,
Transaction currency must be same as Payment Gateway currency,Měna transakce musí být stejná jako platební brána měnu,
Transaction not allowed against stopped Work Order {0},Transakce není povolena proti zastavenému pracovnímu příkazu {0},
Transaction reference no {0} dated {1},Referenční transakce no {0} ze dne {1},
Transactions,Transakce,
Transactions can only be deleted by the creator of the Company,Transakce mohou být vymazány pouze tvůrce Společnosti,
Transfer,Převod,
Transfer Material,Přenos materiálu,
Transfer Type,Typ přenosu,
Transfer an asset from one warehouse to another,Převést aktiva z jednoho skladu do druhého,
Transfered,Převedené,
Transferred Quantity,Převedené množství,
Transport Receipt Date,Datum přijetí dopravy,
Transport Receipt No,Doklad o přepravě č,
Transportation,Doprava,
Transporter ID,ID přepravce,
Transporter Name,Přepravce Název,
Travel,Cestování,
Travel Expenses,Cestovní výdaje,
Tree Type,Tree Type,
Tree of Bill of Materials,Strom Bill materiálů,
Tree of Item Groups.,Strom skupiny položek.,
Tree of Procedures,Strom procedur,
Tree of Quality Procedures.,Postupy stromové kvality.,
Tree of financial Cost Centers.,Strom Nákl.střediska finančních.,
Tree of financial accounts.,Strom finančních účtů.,
Treshold {0}% appears more than once,Práh {0}% objeví více než jednou,
Trial Period End Date Cannot be before Trial Period Start Date,Datum ukončení zkušebního období nemůže být před datem zahájení zkušebního období,
Trialling,Testování,
Type of Business,Typ podnikání,
Types of activities for Time Logs,Typy činností pro Time Záznamy,
UOM,UOM,
UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0},
UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor potřebný k nerozpuštěných: {0} v bodě: {1},
URL,URL,
Unable to find DocType {0},Nelze najít DocType {0},
Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nelze najít kurz {0} až {1} pro klíčový den {2}. Ručně vytvořte záznam o směnném kurzu,
Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nelze najít skóre začínající na {0}. Musíte mít stojící skóre pokrývající 0 až 100,
Unable to find variable: ,Nelze najít proměnnou:,
Unblock Invoice,Odblokovat fakturu,
Uncheck all,Zrušte všechny,
Unclosed Fiscal Years Profit / Loss (Credit),Neuzavřený fiskálních let Zisk / ztráta (Credit),
Unit,Jednotka,
Unit of Measure,Měrná jednotka,
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,
Unknown,Neznámý,
Unpaid,Nezaplacený,
Unsecured Loans,Nezajištěných úvěrů,
Unsubscribe from this Email Digest,Odhlásit se z tohoto Email Digest,
Unsubscribed,Odhlášen z odběru,
Until,Dokud,
Unverified Webhook Data,Neověřené data Webhook,
Update Account Name / Number,Aktualizovat název účtu / číslo,
Update Account Number / Name,Aktualizovat číslo účtu / název,
Update Cost,Aktualizace nákladů,
Update Items,Aktualizovat položky,
Update Print Format,Aktualizace Print Format,
Update Response,Aktualizace odpovědi,
Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů.",
Update in progress. It might take a while.,Aktualizace probíhá. Může chvíli trvat.,
Update rate as per last purchase,Míra aktualizace podle posledního nákupu,
Update stock must be enable for the purchase invoice {0},Aktualizace akcií musí být povolena pro nákupní fakturu {0},
Updating Variants...,Aktualizace variant ...,
Upload your letter head and logo. (you can edit them later).,Nahrajte svůj dopis hlavu a logo. (Můžete je upravit později).,
Upper Income,Horní příjmů,
Use Sandbox,použití Sandbox,
Used Leaves,Použité listy,
User,Uživatel,
User ID,User ID,
User ID not set for Employee {0},User ID není nastavena pro zaměstnance {0},
User Remark,Uživatel Poznámka,
User has not applied rule on the invoice {0},Uživatel na fakturu neuplatnil pravidlo {0},
User {0} already exists,Uživatel {0} již existuje,
User {0} created,Uživatel {0} byl vytvořen,
User {0} does not exist,Uživatel: {0} neexistuje,
User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Uživatel {0} nemá žádný výchozí POS profil. Zaškrtněte Výchozí v řádku {1} pro tohoto uživatele.,
User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1},
User {0} is already assigned to Healthcare Practitioner {1},Uživatel {0} je již přiřazen zdravotnickému lékaři {1},
Users,Uživatelé,
Utility Expenses,Utility Náklady,
Valid From Date must be lesser than Valid Upto Date.,Platné od data musí být menší než Platné do data.,
Valid Till,Platný do,
Valid from and valid upto fields are mandatory for the cumulative,Kumulativní jsou povinná a platná až pole,
Valid from date must be less than valid upto date,Platné od data musí být kratší než platné datum,
Valid till date cannot be before transaction date,Platné do data nemůže být před datem transakce,
Validity,Doba platnosti,
Validity period of this quotation has ended.,Platnost této nabídky skončila.,
Valuation Rate,Ocenění,
Valuation Rate is mandatory if Opening Stock entered,"Cena je povinná, pokud je zadán počáteční stav zásob",
Valuation type charges can not marked as Inclusive,Poplatky typu ocenění může není označen jako Inclusive,
Value Or Qty,Hodnota nebo množství,
Value Proposition,Návrh hodnoty,
Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Hodnota atributu {0} musí být v rozmezí od {1} až {2} v krocích po {3} pro item {4},
Value missing,Hodnota chybí,
Value must be between {0} and {1},Hodnota musí být mezi {0} a {1},
"Values of exempt, nil rated and non-GST inward supplies","Hodnoty osvobozených, nulových a nemateriálních vstupních dodávek",
Variable,Proměnná,
Variance,Odchylka,
Variance ({}),Variance ({}),
Variant,Varianta,
Variant Attributes,Variant atributy,
Variant Based On cannot be changed,Variant Based On nelze změnit,
Variant Details Report,Zpráva Variant Podrobnosti,
Variant creation has been queued.,Tvorba variantu byla zařazena do fronty.,
Vehicle Expenses,Náklady pro auta,
Vehicle No,Vozidle,
Vehicle Type,Typ vozidla,
Vehicle/Bus Number,Číslo vozidla / autobusu,
Venture Capital,Venture Capital,
View Chart of Accounts,Zobrazit přehled účtů,
View Fees Records,Zobrazení záznamů o poplatcích,
View Form,Zobrazit formulář,
View Lab Tests,Zobrazit laboratorní testy,
View Leads,Zobrazit Vodítka,
View Ledger,View Ledger,
View Now,Zobrazit nyní,
View a list of all the help videos,Zobrazit seznam všech nápovědy videí,
View in Cart,Zobrazit Košík,
Visit report for maintenance call.,Navštivte zprávu pro volání údržby.,
Visit the forums,Navštivte fóra,
Vital Signs,Známky života,
Volunteer,Dobrovolník,
Volunteer Type information.,Informace o typu dobrovolníka.,
Volunteer information.,Informace o dobrovolnictví.,
Voucher #,Voucher #,
Voucher No,Voucher No,
Voucher Type,Voucher Type,
WIP Warehouse,WIP Warehouse,
Walk In,Vejít,
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad.",
Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.,
Warehouse is mandatory,Sklad je povinné,
Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro skladovou položku {0} na řádku {1},
Warehouse not found in the system,Sklad nebyl nalezen v systému,
"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Chcete-li požadovat sklad v řádku č. {0}, nastavte výchozí sklad pro položku {1} pro firmu {2}",
Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0},
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}",
Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1},
Warehouse {0} does not exist,Sklad {0} neexistuje,
"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Warehouse {0} není propojen s žádným účtem, uveďte prosím účet v záznamu skladu nebo nastavte výchozí inventární účet ve firmě {1}.",
Warehouses with child nodes cannot be converted to ledger,Sklady s podřízené uzly nelze převést do hlavní účetní knihy,
Warehouses with existing transaction can not be converted to group.,Sklady se stávajícími transakce nelze převést na skupinu.,
Warehouses with existing transaction can not be converted to ledger.,Sklady se stávajícími transakce nelze převést na knihy.,
Warning,Upozornění,
Warning: Another {0} # {1} exists against stock entry {2},Upozornění: dalším {0} č. {1} existuje proti pohybu skladu {2},
Warning: Invalid SSL certificate on attachment {0},Varování: Neplatný certifikát SSL na přílohu {0},
Warning: Invalid attachment {0},Varování: Neplatná Příloha {0},
Warning: Leave application contains following block dates,Upozornění: Nechte Aplikace obsahuje následující data bloku,
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žství,
Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornění: prodejní objednávky {0} již existuje proti Zákazníka Objednávky {1},
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}",
Warranty,Záruka,
Warranty Claim,Záruční reklamace,
Warranty Claim against Serial No.,Reklamační proti sériového čísla,
Website,Stránky,
Website Image should be a public file or website URL,Webové stránky Image by měla být veřejná souboru nebo webové stránky URL,
Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} připojuje k bodu {1} nelze nalézt,
Website Listing,Seznam webových stránek,
Website Manager,Správce webu,
Website Settings,Nastavení www stránky,
Wednesday,Středa,
Week,Týden,
Weekdays,V pracovní dny,
Weekly,Týdenní,
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedeno, \n uveďte prosím ""váha UOM"" příliš",
Welcome email sent,Uvítací email odeslán,
Welcome to ERPNext,Vítejte na ERPNext,
What do you need help with?,S čím potřebuješ pomoci?,
What does it do?,Co to dělá?,
Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny.",
"While creating account for child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA",Při vytváření účtu pro podřízenou společnost {0} nebyl nadřazený účet {1} nalezen. Vytvořte prosím nadřazený účet v odpovídající COA,
White,Bílá,
Wire Transfer,Bankovní převod,
WooCommerce Products,Produkty WooCommerce,
Work In Progress,Na cestě,
Work Order,Zakázka,
Work Order already created for all items with BOM,Pracovní zakázka již vytvořena pro všechny položky s kusovníkem,
Work Order cannot be raised against a Item Template,Pracovní příkaz nelze vznést proti šabloně položky,
Work Order has been {0},Pracovní příkaz byl {0},
Work Order not created,Pracovní příkaz nebyl vytvořen,
Work Order {0} must be cancelled before cancelling this Sales Order,Objednávka práce {0} musí být zrušena před zrušením této objednávky,
Work Order {0} must be submitted,Objednávka práce {0} musí být odeslána,
Work Orders Created: {0},Vytvořené zakázky: {0},
Work Summary for {0},Souhrn práce pro {0},
Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat,
Workflow,Toky (workflow),
Working,Pracovní,
Working Hours,Pracovní doba,
Workstation,Pracovní stanice,
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},
Wrapping up,Obalte se,
Wrong Password,Špatné heslo,
Year start date or end date is overlapping with {0}. To avoid please set company,Rok datum zahájení nebo ukončení se překrývá s {0}. Aby se zabránilo nastavte firmu,
You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0},
You are not authorized to approve leaves on Block Dates,Nejste oprávněni schvalovat listí na bloku Termíny,
You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení,
You are not present all day(s) between compensatory leave request days,Nejste přítomni celý den (dní) mezi dny žádosti o náhradní dovolenou,
You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit sazbu, kdyby BOM zmínil agianst libovolné položky",
You can not enter current voucher in 'Against Journal Entry' column,"Nelze zadat aktuální poukaz v ""Proti Zápis do deníku"" sloupci",
You can only have Plans with the same billing cycle in a Subscription,V předplatném můžete mít pouze plány se stejným fakturačním cyklem,
You can only redeem max {0} points in this order.,V tomto pořadí můžete uplatnit max. {0} body.,
You can only renew if your membership expires within 30 days,"Můžete obnovit pouze tehdy, pokud vaše členství vyprší během 30 dnů",
You can only select a maximum of one option from the list of check boxes.,Ze seznamu zaškrtávacích políček můžete vybrat pouze jednu možnost.,
You can only submit Leave Encashment for a valid encashment amount,"Chcete-li platnou částku inkasa, můžete odeslat příkaz Opustit zapsání",
You can't redeem Loyalty Points having more value than the Grand Total.,"Nemůžete vykoupit věrnostní body, které mají větší hodnotu než celkový součet.",
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.,
You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Nelze odstranit fiskální rok {0}. Fiskální rok {0} je nastaven jako výchozí v globálním nastavení,
You cannot delete Project Type 'External',Nelze odstranit typ projektu &quot;Externí&quot;,
You cannot edit root node.,Nelze upravit kořenový uzel.,
You cannot restart a Subscription that is not cancelled.,"Nelze znovu spustit odběr, který není zrušen.",
You don't have enought Loyalty Points to redeem,Nemáte dostatečné věrnostní body k uplatnění,
You have already assessed for the assessment criteria {}.,Již jste hodnotili kritéria hodnocení {}.,
You have already selected items from {0} {1},Již jste vybrané položky z {0} {1},
You have been invited to collaborate on the project: {0},Byli jste pozváni ke spolupráci na projektu: {0},
You have entered duplicate items. Please rectify and try again.,"Zadali jste duplicitní položky. Prosím, opravu a zkuste to znovu.",
You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,"Musíte být jiným uživatelem než správcem s rolí Správce systému a Správce položek, který se má zaregistrovat na webu Marketplace.",
You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Musíte být uživateli s rolí Správce systému a Správce položek pro přidání uživatelů do služby Marketplace.,
You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Musíte být uživatelem s rolí Správce systému a Správce položek, který se má zaregistrovat na webu Marketplace.",
You need to be logged in to access this page,Musíte být přihlášen k přístupu na tuto stránku,
You need to enable Shopping Cart,Musíte povolit Nákupní košík,
You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Ztratíte záznamy o dříve vygenerovaných fakturách. Opravdu chcete tento odběr restartovat?,
Your Organization,Vaše organizace,
Your cart is Empty,Tvůj vozík je prázdný,
Your email address...,Vaše emailová adresa...,
Your order is out for delivery!,Vaše objednávka je k dodání!,
Your tickets,Vaše lístky,
ZIP Code,PSČ,
[Error],[Chyba],
[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Položka / {0}) není na skladě,
`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazit zásoby starší než` by mělo být nižší než %d dnů.,
based_on,na základě,
cannot be greater than 100,nemůže být větší než 100,
disabled user,zakázané uživatelské,
"e.g. ""Build tools for builders""","např ""Stavět nástroje pro stavitele """,
"e.g. ""Primary School"" or ""University""",například &quot;Základní škola&quot; nebo &quot;univerzita&quot;,
"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty",
hidden,skrytý,
modified,Upravené,
old_parent,old_parent,
on,Kdy,
{0} '{1}' is disabled,{0} '{1}' je vypnuté,
{0} '{1}' not in Fiscal Year {2},{0} '{1}' není v fiskálním roce {2},
{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nemůže být větší než plánované množství ({2}) v pracovní objednávce {3},
{0} - {1} is inactive student,{0} - {1} je neaktivní student,
{0} - {1} is not enrolled in the Batch {2},{0} - {1} není zapsána v dávce {2},
{0} - {1} is not enrolled in the Course {2},{0} - {1} není zařazen do kurzu {2},
{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Rozpočet na účet {1} proti {2} {3} je {4}. To bude přesahovat o {5},
{0} Digest,{0} Digest,
{0} Request for {1},{0} Žádost o {1},
{0} Result submittted,{0} Výsledek byl předložen,
{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Sériová čísla požadované pro položky {1}. Poskytli jste {2}.,
{0} Student Groups created.,{0} Studentské skupiny byly vytvořeny.,
{0} Students have been enrolled,{0} Studenti byli zapsáni,
{0} against Bill {1} dated {2},{0} proti účtence {1} ze dne {2},
{0} against Purchase Order {1},{0} proti nákupní objednávce {1},
{0} against Sales Invoice {1},{0} proti vystavené faktuře {1},
{0} against Sales Order {1},{0} proti Prodejní objednávce {1},
{0} already allocated for Employee {1} for period {2} to {3},{0} již přidělené pro zaměstnance {1} na dobu {2} až {3},
{0} applicable after {1} working days,{0} platí po {1} pracovních dnech,
{0} asset cannot be transferred,{0} aktivum nemůže být převedeno,
{0} can not be negative,{0} nemůže být negativní,
{0} created,{0} vytvořil,
"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} v současné době disponuje {1} hodnotící tabulkou dodavatelů a objednávky na nákup tohoto dodavatele by měly být vydány s opatrností.,
"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} v současné době disponuje {1} hodnotící tabulkou dodavatelů a RFQ tohoto dodavatele by měla být vydána s opatrností.,
{0} does not belong to Company {1},{0} nepatří do Společnosti {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nemá plán zdravotnických pracovníků. Přidejte jej do programu Master of Health Practitioner,
{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce,
{0} for {1},{0} pro {1},
{0} has been submitted successfully,{0} byla úspěšně odeslána,
{0} has fee validity till {1},{0} má platnost až do {1},
{0} hours,{0} hodin,
{0} in row {1},{0} v řádku {1},
{0} is blocked so this transaction cannot proceed,"{0} je zablokována, aby tato transakce nemohla pokračovat",
{0} is mandatory,{0} je povinné,
{0} is mandatory for Item {1},{0} je povinná k položce {1},
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen záznam směnného kurzu pro {1} na {2}.,
{0} is not a stock Item,{0} není skladová položka,
{0} is not a valid Batch Number for Item {1},{0} není platná Šarže pro Položku {1},
{0} is not added in the table,{0} není přidáno do tabulky,
{0} is not in Optional Holiday List,{0} není v seznamu volitelných prázdnin,
{0} is not in a valid Payroll Period,{0} není v platném mzdovém období,
{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.,
{0} is on hold till {1},{0} je podržen do {1},
{0} item found.,Byla nalezena položka {0}.,
{0} items found.,Bylo nalezeno {0} položek.,
{0} items in progress,{0} položky v probíhající,
{0} items produced,{0} předměty vyrobené,
{0} must appear only once,{0} musí být uvedeny pouze jednou,
{0} must be negative in return document,{0} musí být negativní ve vratném dokumentu,
{0} must be submitted,{0} musí být odesláno,
{0} not allowed to transact with {1}. Please change the Company.,{0} není povoleno transakce s {1}. Změňte prosím společnost.,
{0} not found for item {1},{0} nebyl nalezen pro položku {1},
{0} parameter is invalid,{0} parametr je neplatný,
{0} payment entries can not be filtered by {1},{0} platební položky nelze filtrovat přes {1},
{0} should be a value between 0 and 100,{0} by měla být hodnota mezi 0 a 100,
{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednotek [{1}] (# Form / bodu / {1}) byla nalezena v [{2}] (# Form / sklad / {2}),
{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jednotek {1} zapotřebí {2} o {3} {4} na {5} pro dokončení této transakce.,
{0} units of {1} needed in {2} to complete this transaction.,{0} jednotek {1} zapotřebí {2} pro dokončení této transakce.,
{0} valid serial nos for Item {1},{0} platí pořadová čísla pro položky {1},
{0} variants created.,Vytvořeny varianty {0}.,
{0} {1} created,{0} {1} vytvořil,
{0} {1} does not exist,{0} {1} neexistuje,
{0} {1} does not exist.,{0} {1} neexistuje.,
{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. Prosím aktualizujte.,
{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nebyla odeslána, takže akce nemůže být dokončena",
"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je přidružena k {2}, ale účet stran je {3}",
{0} {1} is cancelled or closed,{0} {1} je zrušen nebo zavřené,
{0} {1} is cancelled or stopped,{0} {1} je zrušena nebo zastavena,
{0} {1} is cancelled so the action cannot be completed,"{0} {1} je zrušena, takže akce nemůže být dokončena",
{0} {1} is closed,{0} {1} je uzavřen,
{0} {1} is disabled,{0} {1} je zakázán,
{0} {1} is frozen,{0} {1} je zmrazený,
{0} {1} is fully billed,{0} {1} je plně fakturováno,
{0} {1} is not active,{0} {1} není aktivní,
{0} {1} is not associated with {2} {3},{0} {1} není přidružen k {2} {3},
{0} {1} is not present in the parent company,{0} {1} není v mateřské společnosti,
{0} {1} is not submitted,{0} {1} není odesláno,
{0} {1} is {2},{0} {1} je {2},
{0} {1} must be submitted,{0} {1} musí být odeslaný,
{0} {1} not in any active Fiscal Year.,{0} {1} není v žádném aktivním fiskální rok.,
{0} {1} status is {2},{0} {1} je stav {2},
{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: ""výkaz zisků a ztrát"" typ účtu {2} není povolen do Otevírací vstup",
{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Účet {2} nepatří do společnosti {3},
{0} {1}: Account {2} is inactive,{0} {1}: Účet {2} je neaktivní,
{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Účetní Vstup pro {2} mohou být prováděny pouze v měně: {3},
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové středisko je povinný údaj pro položku {2},
{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,"{0} {1}: Je vyžadováno nákladové středisko pro 'zisk a ztráta ""účtu {2}. Prosím nastavte výchozí nákladové středisko pro společnost.",
{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: náklady Center {2} nepatří do společnosti {3},
{0} {1}: Customer is required against Receivable account {2},{0} {1}: Zákazník je vyžadován oproti účtu pohledávek {2},
{0} {1}: Either debit or credit amount is required for {2},{0} {1}: buď debetní nebo kreditní částku je nutné pro {2},
{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dodavatel je vyžadován oproti splatnému účtu {2},
{0}% Billed,{0}% účtovano,
{0}% Delivered,{0}% dodáno,
"{0}: Employee email not found, hence email not sent","{0}: e-mail zaměstnanec nebyl nalezen, a proto je pošta neposlal",
{0}: From {0} of type {1},{0}: Od {0} typu {1},
{0}: From {1},{0}: Z {1},
{0}: {1} does not exists,{0}: {1} neexistuje,
{0}: {1} not found in Invoice Details table,{0}: {1} nebyla nalezena v tabulce Podrobnosti Faktury,
{} of {},{} z {},
Chat,Chat,
Completed By,Dokončeno,
Conditions,Podmínky,
County,Hrabství,
Day of Week,Den v týdnu,
"Dear System Manager,","Vážení System Manager,",
Default Value,Výchozí hodnota,
Email Group,Email Group,
Email Settings,Nastavení emailu,
Email not sent to {0} (unsubscribed / disabled),Email není poslán do {0} (odhlásili / vypnuto),
Error Message,Chybové hlášení,
Fieldtype,Typ pole,
Help Articles,Články nápovědy,
ID,ID,
Images,snímky,
Import,Importovat,
Language,Jazyk,
Likes,Záliby,
Merge with existing,Sloučit s existujícím,
Office,Kancelář,
Orientation,Orientace,
Passive,Pasivní,
Percent,Procento,
Permanent,Trvalý,
Personal,Osobní,
Plant,Rostlina,
Post,Příspěvek,
Postal,Poštovní,
Postal Code,PSČ,
Previous,Předchozí,
Provider,Poskytovatel,
Read Only,Pouze pro čtení,
Recipient,Příjemce,
Reviews,Recenze,
Sender,Odesilatel,
Shop,Obchod,
Sign Up,Přihlásit se,
Subsidiary,Dceřiný,
There is some problem with the file url: {0},Tam je nějaký problém s URL souboru: {0},
There were errors while sending email. Please try again.,Narazili jsme na problémy při odesílání emailu. Prosím zkuste to znovu.,
Values Changed,hodnoty Změnil,
or,nebo,
Ageing Range 4,Rozsah stárnutí 4,
Allocated amount cannot be greater than unadjusted amount,Přidělená částka nemůže být větší než neupravená částka,
Allocated amount cannot be negative,Přidělené množství nemůže být záporné,
"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Rozdílový účet musí být účtem typu Asset / Liability, protože tato položka je počáteční položka",
Error in some rows,Chyba v některých řádcích,
Import Successful,Import byl úspěšný,
Please save first,Nejprve prosím uložte,
Price not found for item {0} in price list {1},Cena nenalezena pro položku {0} v ceníku {1},
Warehouse Type,Typ skladu,
'Date' is required,Je požadováno „datum“,
Benefit,Výhoda,
Budgets,Rozpočty,
Bundle Qty,Balíček Množství,
Company GSTIN,Společnost GSTIN,
Company field is required,Pole společnosti je povinné,
Creating Dimensions...,Vytváření dimenzí ...,
Duplicate entry against the item code {0} and manufacturer {1},Duplicitní zadání oproti kódu položky {0} a výrobci {1},
Import Chart Of Accounts from CSV / Excel files,Importujte graf účtů ze souborů CSV / Excel,
Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Neplatný GSTIN! Zadaný vstup neodpovídá formátu GSTIN pro držitele UIN nebo nerezidentní poskytovatele služeb OIDAR,
Invoice Grand Total,Faktura celkem celkem,
Last carbon check date cannot be a future date,Datum poslední kontroly uhlíku nemůže být budoucí,
Make Stock Entry,Proveďte zadávání zásob,
Quality Feedback,Zpětná vazba kvality,
Quality Feedback Template,Šablona zpětné vazby kvality,
Rules for applying different promotional schemes.,Pravidla pro uplatňování různých propagačních programů.,
Shift,Posun,
Show {0},Zobrazit {0},
"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Zvláštní znaky kromě &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; A &quot;}&quot; nejsou v názvových řadách povoleny",
Target Details,Podrobnosti o cíli,
API,API,
Annual,Roční,
Approved,Schválený,
Change,Změna,
Contact Email,Kontaktní e-mail,
Export Type,Typ exportu,
From Date,Od data,
Group By,Skupina vytvořená,
Importing {0} of {1},Importuje se {0} z {1},
Invalid URL,neplatná URL,
Landscape,Krajina,
Last Sync On,Poslední synchronizace je zapnutá,
Naming Series,Číselné řady,
No data to export,Žádné údaje k exportu,
Portrait,Portrét,
Print Heading,Tisk záhlaví,
Show Document,Zobrazit dokument,
Show Traceback,Zobrazit Traceback,
Video,Video,
Webhook Secret,Webhook Secret,
% Of Grand Total,% Z celkového součtu,
'employee_field_value' and 'timestamp' are required.,jsou vyžadovány &#39;customer_field_value&#39; a &#39;timestamp&#39;.,
<b>Company</b> is a mandatory filter.,<b>Společnost</b> je povinný filtr.,
<b>From Date</b> is a mandatory filter.,<b>Od data</b> je povinný filtr.,
<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>Od času</b> nemůže být později než <b>Do času</b> pro {0},
<b>To Date</b> is a mandatory filter.,<b>Do dneška</b> je povinný filtr.,
A new appointment has been created for you with {0},Byla pro vás vytvořena nová schůzka s {0},
Account Value,Hodnota účtu,
Account is mandatory to get payment entries,Účet je povinný pro získání platebních záznamů,
Account is not set for the dashboard chart {0},Účet není nastaven pro graf dashboardu {0},
Account {0} does not belong to company {1},Účet {0} nepatří do společnosti {1},
Account {0} does not exists in the dashboard chart {1},Účet {0} neexistuje v grafu dashboardu {1},
Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Účet: <b>{0}</b> je kapitál Probíhá zpracování a nelze jej aktualizovat zápisem do deníku,
Account: {0} is not permitted under Payment Entry,Účet: {0} není povolen v rámci zadání platby,
Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Účetní dimenze <b>{0}</b> je vyžadována pro účet &#39;Rozvaha&#39; {1}.,
Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Účetní dimenze <b>{0}</b> je vyžadována pro účet &#39;Zisk a ztráta&#39; {1}.,
Accounting Masters,Účetnictví Masters,
Accounting Period overlaps with {0},Účetní období se překrývá s {0},
Activity,Činnost,
Add / Manage Email Accounts.,Přidat / Správa e-mailových účtů.,
Add Child,Přidat dítě,
Add Loan Security,Přidejte zabezpečení půjčky,
Add Multiple,Přidat více,
Add Participants,Přidat účastníky,
Add to Featured Item,Přidat k vybrané položce,
Add your review,Přidejte svůj názor,
Add/Edit Coupon Conditions,Přidat / upravit podmínky kupónu,
Added to Featured Items,Přidáno k doporučeným položkám,
Added {0} ({1}),Přidáno: {0} ({1}),
Address Line 1,Adresní řádek 1,
Addresses,Adresy,
Admission End Date should be greater than Admission Start Date.,Datum ukončení vstupu by mělo být vyšší než datum zahájení vstupu.,
Against Loan,Proti půjčce,
Against Loan:,Proti úvěru:,
All,Všechno,
All bank transactions have been created,Byly vytvořeny všechny bankovní transakce,
All the depreciations has been booked,Všechny odpisy byly zaúčtovány,
Allocation Expired!,Platnost přidělení vypršela!,
Allow Resetting Service Level Agreement from Support Settings.,Povolit resetování dohody o úrovni služeb z nastavení podpory.,
Amount of {0} is required for Loan closure,Pro uzavření úvěru je požadována částka {0},
Amount paid cannot be zero,Zaplacená částka nesmí být nulová,
Applied Coupon Code,Kód použitého kupónu,
Apply Coupon Code,Použijte kód kupónu,
Appointment Booking,Rezervace schůzek,
"As there are existing transactions against item {0}, you can not change the value of {1}",Stejně jako existují nějaké transakce proti položce {0} nelze změnit hodnotu {1},
Asset Id,ID majetku,
Asset Value,Hodnota aktiva,
Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Úprava hodnoty aktiv nemůže být zaúčtována před datem nákupu aktiv <b>{0}</b> .,
Asset {0} does not belongs to the custodian {1},Aktivum {0} nepatří do úschovy {1},
Asset {0} does not belongs to the location {1},Aktiva {0} nepatří do umístění {1},
At least one of the Applicable Modules should be selected,Měl by být vybrán alespoň jeden z příslušných modulů,
Atleast one asset has to be selected.,Musí být vybráno alespoň jedno dílo.,
Attendance Marked,Účast označena,
Attendance has been marked as per employee check-ins,Docházka byla označena podle odbavení zaměstnanců,
Authentication Failed,Ověření se nezdařilo,
Automatic Reconciliation,Automatické smíření,
Available For Use Date,K dispozici pro datum použití,
Available Stock,Dostupné skladem,
"Available quantity is {0}, you need {1}","Dostupné množství je {0}, potřebujete {1}",
BOM 1,Kus 1,
BOM 2,Kus 2,
BOM Comparison Tool,Nástroj pro porovnání kusovníků,
BOM recursion: {0} cannot be child of {1},Rekurze kusovníku: {0} nemůže být dítě {1},
BOM recursion: {0} cannot be parent or child of {1},Rekurze kusovníku: {0} nemůže být rodič nebo dítě {1},
Back to Home,Zpátky domů,
Back to Messages,Zpět na Zprávy,
Bank Data mapper doesn't exist,Mapovač bankovních dat neexistuje,
Bank Details,Bankovní detaily,
Bank account '{0}' has been synchronized,Bankovní účet &#39;{0}&#39; byl synchronizován,
Bank account {0} already exists and could not be created again,Bankovní účet {0} již existuje a nelze jej znovu vytvořit,
Bank accounts added,Bankovní účty přidány,
Batch no is required for batched item {0},Šarže č. Je vyžadována pro dávkovou položku {0},
Billing Date,Datum fakturace,
Billing Interval Count cannot be less than 1,Fakturační interval nesmí být menší než 1,
Blue,Modrý,
Book,kniha,
Book Appointment,Kniha schůzky,
Brand,Značka,
Browse,Prohlížet,
Call Connected,Hovor připojen,
Call Disconnected,Hovor byl odpojen,
Call Missed,Volání zmeškané,
Call Summary,Přehled hovorů,
Call Summary Saved,Souhrn hovorů byl uložen,
Cancelled,Zrušeno,
Cannot Calculate Arrival Time as Driver Address is Missing.,"Nelze vypočítat čas příjezdu, protože chybí adresa řidiče.",
Cannot Optimize Route as Driver Address is Missing.,"Nelze optimalizovat trasu, protože chybí adresa ovladače.",
Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,"Nelze dokončit úkol {0}, protože jeho závislá úloha {1} není dokončena / zrušena.",
Cannot create loan until application is approved,"Dokud nebude žádost schválena, nelze vytvořit půjčku",
Cannot find a matching Item. Please select some other value for {0}.,Nelze najít odpovídající položku. Vyberte nějakou jinou hodnotu pro {0}.,
"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nelze přeplatit za položku {0} v řádku {1} více než {2}. Chcete-li povolit nadměrnou fakturaci, nastavte v Nastavení účtu povolenky",
"Capacity Planning Error, planned start time can not be same as end time","Chyba plánování kapacity, plánovaný čas zahájení nemůže být stejný jako čas ukončení",
Categories,Kategorie,
Changes in {0},Změny v {0},
Chart,Schéma,
Choose a corresponding payment,Vyberte odpovídající platbu,
Click on the link below to verify your email and confirm the appointment,Kliknutím na odkaz níže ověřte svůj e-mail a potvrďte schůzku,
Close,Zavřít,
Communication,Komunikace,
Compact Item Print,Kompaktní Položka Print,
Company,Společnost,
Company of asset {0} and purchase document {1} doesn't matches.,Společnost s aktivem {0} a nákupní doklad {1} se neshodují.,
Compare BOMs for changes in Raw Materials and Operations,Porovnejte kusovníky pro změny surovin a operací,
Compare List function takes on list arguments,Funkce Porovnání seznamu přebírá argumenty seznamu,
Complete,Kompletní,
Completed,Dokončeno,
Completed Quantity,Dokončené množství,
Connect your Exotel Account to ERPNext and track call logs,Připojte svůj účet Exotel k ERPDext a sledujte protokoly hovorů,
Connect your bank accounts to ERPNext,Propojte své bankovní účty s ERPNext,
Contact Seller,Kontaktovat prodejce,
Continue,Pokračovat,
Cost Center: {0} does not exist,Nákladové středisko: {0} neexistuje,
Couldn't Set Service Level Agreement {0}.,Smlouvu o úrovni služeb nelze nastavit {0}.,
Country,Země,
Country Code in File does not match with country code set up in the system,Kód země v souboru neodpovídá kódu země nastavenému v systému,
Create New Contact,Vytvořit nový kontakt,
Create New Lead,Vytvořit nového potenciálního zákazníka,
Create Pick List,Vytvořit výběrový seznam,
Create Quality Inspection for Item {0},Vytvořit kontrolu kvality pro položku {0},
Creating Accounts...,Vytváření účtů ...,
Creating bank entries...,Vytváření bankovních záznamů ...,
Creating {0},Vytváření {0},
Credit limit is already defined for the Company {0},Úvěrový limit je již pro společnost definován {0},
Ctrl + Enter to submit,Ctrl + Enter k odeslání,
Ctrl+Enter to submit,Ctrl + Enter pro odeslání,
Currency,Měna,
Current Status,Aktuální stav,
Customer PO,Zákaznická PO,
Customize,Přizpůsobit,
Daily,Denně,
Date,Datum,
Date Range,Časové období,
Date of Birth cannot be greater than Joining Date.,Datum narození nemůže být větší než datum připojení.,
Dear,Vážený (á),
Default,Výchozí,
Define coupon codes.,Definujte kódy kupónů.,
Delayed Days,Zpožděné dny,
Delete,Smazat,
Delivered Quantity,Dodané množství,
Delivery Notes,Dodací listy,
Depreciated Amount,Odepsaná částka,
Description,Popis,
Designation,Označení,
Difference Value,Hodnota rozdílu,
Dimension Filter,Filtr rozměrů,
Disabled,Vypnuto,
Disbursement and Repayment,Vyplacení a vrácení,
Distance cannot be greater than 4000 kms,Vzdálenost nesmí být větší než 4000 km,
Do you want to submit the material request,Chcete odeslat materiální žádost,
Doctype,Doctype,
Document {0} successfully uncleared,Dokument {0} byl úspěšně nejasný,
Download Template,Stáhnout šablonu,
Dr,Dr,
Due Date,Datum splatnosti,
Duplicate,Duplikát,
Duplicate Project with Tasks,Duplikovat projekt s úkoly,
Duplicate project has been created,Byl vytvořen duplicitní projekt,
E-Way Bill JSON can only be generated from a submitted document,Účet E-Way Bill JSON lze vygenerovat pouze z předloženého dokumentu,
E-Way Bill JSON can only be generated from submitted document,Účet E-Way Bill JSON lze generovat pouze z předloženého dokumentu,
E-Way Bill JSON cannot be generated for Sales Return as of now,Účet e-Way Bill JSON již nelze vygenerovat pro vrácení prodeje,
ERPNext could not find any matching payment entry,ERPNext nemohl najít žádnou odpovídající platební položku,
Earliest Age,Nejstarší věk,
Edit Details,Upravit detaily,
Edit Profile,Editovat profil,
Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Je-li způsob dopravy silniční, vyžaduje se ID dopravce GST nebo číslo vozidla",
Email,E-mailem,
Email Campaigns,E-mailové kampaně,
Employee ID is linked with another instructor,ID zaměstnance je spojeno s jiným instruktorem,
Employee Tax and Benefits,Daň a dávky zaměstnanců,
Employee is required while issuing Asset {0},Při vydávání aktiv {0} je vyžadován zaměstnanec,
Employee {0} does not belongs to the company {1},Zaměstnanec {0} nepatří do společnosti {1},
Enable Auto Re-Order,Povolit automatické opětovné objednání,
End Date of Agreement can't be less than today.,Datum ukončení dohody nemůže být kratší než dnes.,
End Time,End Time,
Energy Point Leaderboard,Energy Point Leaderboard,
Enter API key in Google Settings.,Zadejte klíč API v Nastavení Google.,
Enter Supplier,Zadejte dodavatele,
Enter Value,Zadejte hodnotu,
Entity Type,Typ entity,
Error,Chyba,
Error in Exotel incoming call,Chyba při příchozím hovoru Exotel,
Error: {0} is mandatory field,Chyba: {0} je povinné pole,
Event Link,Odkaz na událost,
Exception occurred while reconciling {0},Při sladění došlo k výjimce {0},
Expected and Discharge dates cannot be less than Admission Schedule date,Očekávané a propuštěné datum nesmí být kratší než datum přijetí,
Expire Allocation,Vyprší přidělení,
Expired,Vypršela,
Export,Exportovat,
Export not allowed. You need {0} role to export.,Export není povolen. Potřebujete roli {0} pro exportování.,
Failed to add Domain,Nepodařilo se přidat doménu,
Fetch Items from Warehouse,Načíst položky ze skladu,
Fetching...,Okouzlující...,
Field,Pole,
File Manager,Správce souborů,
Filters,Filtry,
Finding linked payments,Nalezení propojených plateb,
Fleet Management,Fleet management,
Following fields are mandatory to create address:,K vytvoření adresy jsou povinná následující pole:,
For Month,Za měsíc,
"For item {0} at row {1}, count of serial numbers does not match with the picked quantity",U položky {0} v řádku {1} se počet sériových čísel neshoduje s vybraným množstvím,
For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Pro operaci {0}: Množství ({1}) nemůže být větší než čekající množství ({2}),
For quantity {0} should not be greater than work order quantity {1},Pro množství {0} by nemělo být větší než množství pro pracovní objednávku {1},
Free item not set in the pricing rule {0},Bezplatná položka není nastavena v cenovém pravidle {0},
From Date and To Date are Mandatory,Od data do dne jsou povinné,
From employee is required while receiving Asset {0} to a target location,Od zaměstnance je vyžadováno při přijímání díla {0} na cílové místo,
Fuel Expense,Náklady na palivo,
Future Payment Amount,Částka budoucí platby,
Future Payment Ref,Budoucí platba Ref,
Future Payments,Budoucí platby,
GST HSN Code does not exist for one or more items,Kód GST HSN neexistuje pro jednu nebo více položek,
Generate E-Way Bill JSON,Vygenerujte E-Way Bill JSON,
Get Items,Získat položky,
Get Outstanding Documents,Získejte vynikající dokumenty,
Goal,Cíl,
Greater Than Amount,Větší než částka,
Green,Zelená,
Group,Skupina,
Group By Customer,Seskupit podle zákazníka,
Group By Supplier,Skupina podle dodavatele,
Group Node,Group Node,
Group Warehouses cannot be used in transactions. Please change the value of {0},Skupinové sklady nelze použít v transakcích. Změňte prosím hodnotu {0},
Help,Nápověda,
Help Article,Článek nápovědy,
"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomáhá vám sledovat smlouvy na základě dodavatele, zákazníka a zaměstnance",
Helps you manage appointments with your leads,Pomáhá spravovat schůzky s vašimi potenciálními zákazníky,
Home,Domácí,
IBAN is not valid,IBAN není platný,
Import Data from CSV / Excel files.,Import dat z souborů CSV / Excel.,
In Progress,Pokrok,
Incoming call from {0},Příchozí hovor od {0},
Incorrect Warehouse,Nesprávný sklad,
Intermediate,přechodný,
Invalid Barcode. There is no Item attached to this barcode.,Neplatný čárový kód. K tomuto čárovému kódu není připojena žádná položka.,
Invalid credentials,Neplatné přihlašovací údaje,
Invite as User,Pozvat jako Uživatel,
Issue Priority.,Priorita vydání.,
Issue Type.,Typ problému.,
"It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Zdá se, že je problém s konfigurací proužku serveru. V případě selhání bude částka vrácena na váš účet.",
Item Reported,Hlášená položka,
Item listing removed,Seznam položek byl odstraněn,
Item quantity can not be zero,Množství položky nemůže být nula,
Item taxes updated,Daň z položek byla aktualizována,
Item {0}: {1} qty produced. ,Položka {0}: {1} vyrobeno množství.,
Joining Date can not be greater than Leaving Date,Datum připojení nesmí být větší než datum opuštění,
Lab Test Item {0} already exist,Testovací položka laboratoře {0} již existuje,
Last Issue,Poslední vydání,
Latest Age,Pozdní fáze,
Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Opustit aplikaci je spojena s alokacemi dovolené {0}. Žádost o dovolenou nelze nastavit jako dovolenou bez odměny,
Leaves Taken,Listy odebrány,
Less Than Amount,Méně než částka,
Liabilities,Pasiva,
Loading...,Nahrávám...,
Loan Amount exceeds maximum loan amount of {0} as per proposed securities,Částka půjčky překračuje maximální částku půjčky {0} podle navrhovaných cenných papírů,
Loan Applications from customers and employees.,Žádosti o půjčku od zákazníků a zaměstnanců.,
Loan Disbursement,Vyplacení půjčky,
Loan Processes,Úvěrové procesy,
Loan Security,Zabezpečení půjčky,
Loan Security Pledge,Úvěrový příslib,
Loan Security Pledge Created : {0},Vytvořen záložní úvěr: {0},
Loan Security Price,Cena za půjčku,
Loan Security Price overlapping with {0},Cena půjčky se překrývá s {0},
Loan Security Unpledge,Zabezpečení úvěru Unpledge,
Loan Security Value,Hodnota zabezpečení úvěru,
Loan Type for interest and penalty rates,Typ půjčky za úroky a penále,
Loan amount cannot be greater than {0},Výše půjčky nesmí být větší než {0},
Loan is mandatory,Půjčka je povinná,
Loans,Půjčky,
Loans provided to customers and employees.,Půjčky poskytnuté zákazníkům a zaměstnancům.,
Location,Místo,
Log Type is required for check-ins falling in the shift: {0}.,Pro přihlášení spadající do směny je vyžadován typ protokolu: {0}.,
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,"Vypadá to, že vám někdo zaslal neúplnémý URL. Požádejte ho, aby to zkontroloval.",
Make Journal Entry,Proveďte položka deníku,
Make Purchase Invoice,Proveďte nákupní faktury,
Manufactured,Vyrobeno,
Mark Work From Home,Označte práci z domova,
Master,Hlavní,
Max strength cannot be less than zero.,Maximální síla nesmí být menší než nula.,
Maximum attempts for this quiz reached!,Bylo dosaženo maximálních pokusů o tento kvíz!,
Message,Zpráva,
Missing Values Required,Chybějící hodnoty vyžadovány,
Mobile No,Mobile No,
Mobile Number,Telefonní číslo,
Month,Měsíc,
Name,Jméno,
Near you,Ve vašem okolí,
Net Profit/Loss,Čistý zisk / ztráta,
New Expense,Nové výdaje,
New Invoice,Nová faktura,
New Payment,Nová platba,
New release date should be in the future,Nové datum vydání by mělo být v budoucnosti,
Newsletter,Newsletter,
No Account matched these filters: {},Žádný účet neodpovídal těmto filtrům: {},
No Employee found for the given employee field value. '{}': {},Pro danou hodnotu pole zaměstnance nebyl nalezen žádný zaměstnanec. &#39;{}&#39;: {},
No Leaves Allocated to Employee: {0} for Leave Type: {1},Zaměstnancům nejsou přiděleny žádné listy: {0} pro typ dovolené: {1},
No communication found.,Nebyla nalezena žádná komunikace.,
No correct answer is set for {0},Pro {0} není nastavena žádná správná odpověď,
No description,Bez popisu,
No issue has been raised by the caller.,Volající nenastolil žádný problém.,
No items to publish,Žádné položky k publikování,
No outstanding invoices found,Nebyly nalezeny žádné nezaplacené faktury,
No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,"Za {0} {1} nebyly nalezeny žádné nezaplacené faktury, které by odpovídaly zadaným filtrům.",
No outstanding invoices require exchange rate revaluation,Žádné nevyfakturované faktury nevyžadují přehodnocení směnného kurzu,
No reviews yet,Zatím žádné recenze,
No views yet,Zatím žádné pohledy,
Non stock items,Není skladem,
Not Allowed,Není povoleno,
Not allowed to create accounting dimension for {0},Není dovoleno vytvářet účetní dimenzi pro {0},
Not permitted. Please disable the Lab Test Template,Nepovoleno. Zakažte prosím šablonu pro testování laboratoře,
Note,Poznámka,
Notes: ,Poznámky:,
On Converting Opportunity,O převodu příležitostí,
On Purchase Order Submission,Při zadávání objednávky,
On Sales Order Submission,Při zadávání prodejní objednávky,
On Task Completion,Při dokončení úkolu,
On {0} Creation,Na {0} stvoření,
Only .csv and .xlsx files are supported currently,Aktuálně jsou podporovány pouze soubory CSV a XLSX,
Only expired allocation can be cancelled,"Zrušit lze pouze přidělení, jehož platnost skončila",
Only users with the {0} role can create backdated leave applications,Pouze uživatelé s rolí {0} mohou vytvářet zastaralé dovolenky,
Open,Otevřít,
Open Contact,Otevřete kontakt,
Open Lead,Otevřete vedoucí,
Opening and Closing,Otevření a zavření,
Operating Cost as per Work Order / BOM,Provozní náklady podle objednávky / kusovníku,
Order Amount,Částka objednávky,
Page {0} of {1},Strana {0} z {1},
Paid amount cannot be less than {0},Zaplacená částka nesmí být menší než {0},
Parent Company must be a group company,Mateřská společnost musí být společností ve skupině,
Passing Score value should be between 0 and 100,Hodnota úspěšného skóre by měla být mezi 0 a 100,
Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Zásady hesla nemohou obsahovat mezery ani souběžné spojovníky. Formát bude automaticky restrukturalizován,
Patient History,Historie pacientů,
Pause,pause,
Pay,Zaplatit,
Payment Document Type,Typ platebního dokladu,
Payment Name,Název platby,
Penalty Amount,Trestná částka,
Pending,Až do,
Performance,Výkon,
Period based On,Období založené na,
Perpetual inventory required for the company {0} to view this report.,Pro zobrazení této zprávy je pro společnost vyžadován trvalý inventář {0}.,
Phone,Telefon,
Pick List,Vyberte seznam,
Plaid authentication error,Chyba plaid autentizace,
Plaid public token error,Plaid public token error,
Plaid transactions sync error,Chyba synchronizace plaidních transakcí,
Please check the error log for details about the import errors,Podrobnosti o chybách importu naleznete v protokolu chyb,
Please click on the following link to set your new password,"Prosím klikněte na následující odkaz, pro nastavení nového hesla",
Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Vytvořte prosím <b>nastavení DATEV</b> pro společnost <b>{}</b> .,
Please create adjustment Journal Entry for amount {0} ,Vytvořte prosím opravný zápis do deníku o částku {0},
Please do not create more than 500 items at a time,Nevytvářejte více než 500 položek najednou,
Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Zadejte <b>rozdílový účet</b> nebo nastavte výchozí <b>účet</b> pro <b>úpravu zásob</b> společnosti {0},
Please enter GSTIN and state for the Company Address {0},Zadejte GSTIN a uveďte adresu společnosti {0},
Please enter Item Code to get item taxes,"Zadejte kód položky, abyste získali daně z zboží",
Please enter Warehouse and Date,Zadejte prosím sklad a datum,
Please enter the designation,Zadejte označení,
Please login as a Marketplace User to edit this item.,"Chcete-li tuto položku upravit, přihlaste se jako uživatel Marketplace.",
Please login as a Marketplace User to report this item.,"Chcete-li tuto položku nahlásit, přihlaste se jako uživatel Marketplace.",
Please select <b>Template Type</b> to download template,Vyberte <b>šablonu</b> pro stažení šablony,
Please select Applicant Type first,Nejprve vyberte typ žadatele,
Please select Customer first,Nejprve prosím vyberte Zákazníka,
Please select Item Code first,Nejprve vyberte kód položky,
Please select Loan Type for company {0},Vyberte typ půjčky pro společnost {0},
Please select a Delivery Note,Vyberte dodací list,
Please select a Sales Person for item: {0},Vyberte obchodní osobu pro položku: {0},
Please select another payment method. Stripe does not support transactions in currency '{0}',Vyberte prosím jinou platební metodu. Stripe nepodporuje transakce v měně {0} &#39;,
Please select the customer.,Vyberte prosím zákazníka.,
Please set a Supplier against the Items to be considered in the Purchase Order.,"Nastavte prosím dodavatele na položky, které mají být zohledněny v objednávce.",
Please set account heads in GST Settings for Compnay {0},Nastavte prosím hlavičky účtu v Nastavení GST pro Compnay {0},
Please set an email id for the Lead {0},Zadejte prosím e-mailové ID pro potenciálního zákazníka {0},
Please set default UOM in Stock Settings,"Prosím, nastavte výchozí UOM v Nastavení skladu",
Please set filter based on Item or Warehouse due to a large amount of entries.,Nastavte filtr na základě položky nebo skladu z důvodu velkého počtu položek.,
Please set up the Campaign Schedule in the Campaign {0},Nastavte prosím v kampani rozvrh kampaně {0},
Please set valid GSTIN No. in Company Address for company {0},Zadejte prosím platné číslo GSTIN do firemní adresy společnosti {0},
Please set {0},Nastavte prosím {0},customer
Please setup a default bank account for company {0},Nastavte prosím výchozí bankovní účet společnosti {0},
Please specify,Prosím specifikujte,
Please specify a {0},Zadejte prosím {0},lead
Pledge Status,Stav zástavy,
Pledge Time,Pledge Time,
Printing,Tisk,
Priority,Priorita,
Priority has been changed to {0}.,Priorita byla změněna na {0}.,
Priority {0} has been repeated.,Priorita {0} byla opakována.,
Processing XML Files,Zpracování souborů XML,
Profitability,Ziskovost,
Project,Zakázka,
Proposed Pledges are mandatory for secured Loans,Navrhované zástavy jsou povinné pro zajištěné půjčky,
Provide the academic year and set the starting and ending date.,Uveďte akademický rok a stanovte počáteční a konečné datum.,
Public token is missing for this bank,Pro tuto banku chybí veřejný token,
Publish,Publikovat,
Publish 1 Item,Publikovat 1 položku,
Publish Items,Publikovat položky,
Publish More Items,Publikovat více položek,
Publish Your First Items,Zveřejněte své první položky,
Publish {0} Items,Publikovat {0} položek,
Published Items,Publikované položky,
Purchase Invoice cannot be made against an existing asset {0},Nákupní fakturu nelze provést proti existujícímu dílu {0},
Purchase Invoices,Nákup faktur,
Purchase Orders,Objednávky,
Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,"Potvrzení o nákupu neobsahuje žádnou položku, pro kterou je povolen Retain Sample.",
Purchase Return,Nákup Return,
Qty of Finished Goods Item,Množství hotového zboží,
Qty or Amount is mandatroy for loan security,Množství nebo částka je mandatroy pro zajištění půjčky,
Quality Inspection required for Item {0} to submit,Pro odeslání položky {0} je vyžadována kontrola kvality,
Quantity to Manufacture,Množství k výrobě,
Quantity to Manufacture can not be zero for the operation {0},Množství na výrobu nemůže být pro operaci nulové {0},
Quarterly,Čtvrtletně,
Queued,Ve frontě,
Quick Entry,Rychlý vstup,
Quiz {0} does not exist,Kvíz {0} neexistuje,
Quotation Amount,Částka nabídky,
Rate or Discount is required for the price discount.,Pro slevu z ceny je požadována sazba nebo sleva.,
Reason,Důvod,
Reconcile Entries,Smíření položek,
Reconcile this account,Odsouhlaste tento účet,
Reconciled,Smířeno,
Recruitment,Nábor,
Red,Červená,
Refreshing,Osvěžující,
Release date must be in the future,Datum vydání musí být v budoucnosti,
Relieving Date must be greater than or equal to Date of Joining,Datum vydání musí být větší nebo rovno Datum připojení,
Rename,Přejmenovat,
Repayment Method is mandatory for term loans,Způsob splácení je povinný pro termínované půjčky,
Repayment Start Date is mandatory for term loans,Datum zahájení splácení je povinné pro termínované půjčky,
Report Item,Položka sestavy,
Report this Item,Nahlásit tuto položku,
Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Vyhrazeno Množství pro subdodávky: Množství surovin pro výrobu subdodávek.,
Reset,resetovat,
Reset Service Level Agreement,Obnovit dohodu o úrovni služeb,
Resetting Service Level Agreement.,Obnovení dohody o úrovni služeb.,
Return amount cannot be greater unclaimed amount,Vrácená částka nemůže být větší nevyžádaná částka,
Review,Posouzení,
Room,Pokoj,
Room Type,Typ pokoje,
Row # ,Řádek č.,
Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Řádek # {0}: Přijatý sklad a dodavatelský sklad nemůže být stejný,
Row #{0}: Cannot delete item {1} which has already been billed.,"Řádek # {0}: Nelze odstranit položku {1}, která již byla fakturována.",
Row #{0}: Cannot delete item {1} which has already been delivered,"Řádek # {0}: Nelze odstranit položku {1}, která již byla doručena",
Row #{0}: Cannot delete item {1} which has already been received,"Řádek # {0}: Nelze odstranit položku {1}, která již byla přijata",
Row #{0}: Cannot delete item {1} which has work order assigned to it.,"Řádek # {0}: Nelze odstranit položku {1}, která má přiřazen pracovní příkaz.",
Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,"Řádek # {0}: Nelze odstranit položku {1}, která je přiřazena k objednávce zákazníka.",
Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,Řádek # {0}: Nelze vybrat Dodavatelský sklad při doplňování surovin subdodavateli,
Row #{0}: Cost Center {1} does not belong to company {2},Řádek # {0}: Nákladové středisko {1} nepatří společnosti {2},
Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Řádek # {0}: Operace {1} není dokončena pro {2} množství hotového zboží v objednávce {3}. Aktualizujte prosím provozní stav pomocí Job Card {4}.,
Row #{0}: Payment document is required to complete the transaction,Řádek # {0}: K dokončení transakce je vyžadován platební doklad,
Row #{0}: Serial No {1} does not belong to Batch {2},Řádek # {0}: Sériové číslo {1} nepatří do dávky {2},
Row #{0}: Service End Date cannot be before Invoice Posting Date,Řádek # {0}: Datum ukončení služby nesmí být před datem účtování faktury,
Row #{0}: Service Start Date cannot be greater than Service End Date,Řádek # {0}: Datum zahájení služby nesmí být větší než datum ukončení služby,
Row #{0}: Service Start and End Date is required for deferred accounting,Řádek # {0}: Pro odložené účtování je vyžadováno datum zahájení a ukončení služby,
Row {0}: Invalid Item Tax Template for item {1},Řádek {0}: Neplatná šablona daně z položky pro položku {1},
Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Řádek {0}: Množství není k dispozici pro {4} ve skladu {1} v době zveřejnění záznamu ({2} {3}),
Row {0}: user has not applied the rule {1} on the item {2},Řádek {0}: uživatel na položku {2} neuplatnil pravidlo {1},
Row {0}:Sibling Date of Birth cannot be greater than today.,Řádek {0}: Datum sourození nemůže být větší než dnes.,
Row({0}): {1} is already discounted in {2},Řádek ({0}): {1} je již zlevněn v {2},
Rows Added in {0},Řádky přidané v {0},
Rows Removed in {0},Řádky odebrány za {0},
Sanctioned Amount limit crossed for {0} {1},Překročení limitu sankce za {0} {1},
Sanctioned Loan Amount already exists for {0} against company {1},Částka schváleného úvěru již existuje pro {0} proti společnosti {1},
Save,Uložit,
Save Item,Uložit položku,
Saved Items,Uložené položky,
Search Items ...,Prohledat položky ...,
Search for a payment,Vyhledejte platbu,
Search for anything ...,Hledat cokoli ...,
Search results for,Výsledky hledání pro,
Select All,Vybrat vše,
Select Difference Account,Vyberte rozdílový účet,
Select a Default Priority.,Vyberte výchozí prioritu.,
Select a Supplier from the Default Supplier List of the items below.,Vyberte dodavatele z výchozího seznamu dodavatelů níže uvedených položek.,
Select a company,Vyberte společnost,
Select finance book for the item {0} at row {1},Vyberte finanční knihu pro položku {0} v řádku {1},
Select only one Priority as Default.,Jako výchozí vyberte pouze jednu prioritu.,
Seller Information,Informace o prodávajícím,
Send,Odeslat,
Send a message,Poslat zprávu,
Sending,Odeslání,
Sends Mails to lead or contact based on a Campaign schedule,Odešle e-maily na vedení nebo kontakt na základě plánu kampaně,
Serial Number Created,Sériové číslo vytvořeno,
Serial Numbers Created,Sériová čísla byla vytvořena,
Serial no(s) required for serialized item {0},Sériové číslo požadované pro sériovou položku {0},
Series,Série,
Server Error,Chyba serveru,
Service Level Agreement has been changed to {0}.,Smlouva o úrovni služeb byla změněna na {0}.,
Service Level Agreement was reset.,Dohoda o úrovni služeb byla resetována.,
Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Dohoda o úrovni služeb s typem entity {0} a entitou {1} již existuje.,
Set,Nastavit,
Set Meta Tags,Nastavte značky meta,
Set {0} in company {1},Set {0} ve společnosti {1},
Setup,Nastavení,
Setup Wizard,Průvodce nastavením,
Shift Management,Shift Management,
Show Future Payments,Zobrazit budoucí platby,
Show Linked Delivery Notes,Zobrazit propojené dodací listy,
Show Sales Person,Zobrazit prodejní osobu,
Show Stock Ageing Data,Zobrazit údaje o stárnutí populace,
Show Warehouse-wise Stock,Zobrazit skladové zásoby,
Size,Velikost,
Something went wrong while evaluating the quiz.,Při vyhodnocování kvízu se něco pokazilo.,
Sr,Řádek,
Start,Start,
Start Date cannot be before the current date,Datum zahájení nemůže být před aktuálním datem,
Start Time,Start Time,
Status,Stav,
Status must be Cancelled or Completed,Stav musí být zrušen nebo dokončen,
Stock Balance Report,Zpráva o stavu zásob,
Stock Entry has been already created against this Pick List,Položka Zásoby již byla vytvořena na základě tohoto výběrového seznamu,
Stock Ledger ID,ID hlavní knihy,
Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Hodnota akcií ({0}) a zůstatek na účtu ({1}) nejsou synchronizovány pro účet {2} a je to propojené sklady.,
Stores - {0},Obchody - {0},
Student with email {0} does not exist,Student s e-mailem {0} neexistuje,
Submit Review,Odeslat recenzi,
Submitted,Vloženo,
Supplier Addresses And Contacts,Dodavatel Adresy a kontakty,
Synchronize this account,Synchronizujte tento účet,
Tag,Štítek,
Target Location is required while receiving Asset {0} from an employee,Cílová poloha je vyžadována při příjmu aktiva {0} od zaměstnance,
Target Location is required while transferring Asset {0},Při převodu aktiva je vyžadováno cílové umístění {0},
Target Location or To Employee is required while receiving Asset {0},Cílová lokalita nebo pro zaměstnance jsou vyžadovány při přijímání aktiv {0},
Task's {0} End Date cannot be after Project's End Date.,Datum ukončení {0} úkolu nemůže být po datu ukončení projektu.,
Task's {0} Start Date cannot be after Project's End Date.,Datum zahájení {0} úkolu nemůže být po datu ukončení projektu.,
Tax Account not specified for Shopify Tax {0},Daňový účet není určen pro službu Shopify Tax {0},
Tax Total,Daň celkem,
Template,Šablona,
The Campaign '{0}' already exists for the {1} '{2}',Kampaň &#39;{0}&#39; již existuje pro {1} &#39;{2}&#39;,
The difference between from time and To Time must be a multiple of Appointment,Rozdíl mezi časem a časem musí být násobkem schůzky,
The field Asset Account cannot be blank,Pole Účet aktiv nesmí být prázdné,
The field Equity/Liability Account cannot be blank,Pole Účet vlastního kapitálu / odpovědnosti nemůže být prázdné,
The following serial numbers were created: <br><br> {0},Byly vytvořeny následující sériová čísla: <br><br> {0},
The parent account {0} does not exists in the uploaded template,Nadřízený účet {0} v nahrané šabloně neexistuje,
The question cannot be duplicate,Otázka nemůže být duplicitní,
The selected payment entry should be linked with a creditor bank transaction,Vybraný platební záznam by měl být spojen s transakcí věřitelské banky,
The selected payment entry should be linked with a debtor bank transaction,Vybraný platební záznam by měl být spojen s transakcí s dlužníkem,
The total allocated amount ({0}) is greated than the paid amount ({1}).,Celková přidělená částka ({0}) je převedena na zaplacenou částku ({1}).,
There are no vacancies under staffing plan {0},V rámci personálního plánu nejsou žádná volná místa {0},
This Service Level Agreement is specific to Customer {0},Tato smlouva o úrovni služeb je specifická pro zákazníka {0},
This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Tato akce odpojí tento účet od jakékoli externí služby integrující ERPNext s vašimi bankovními účty. Nelze jej vrátit zpět. Jsi si jistý ?,
This bank account is already synchronized,Tento bankovní účet je již synchronizován,
This bank transaction is already fully reconciled,Tato bankovní transakce je již plně sladěna,
This employee already has a log with the same timestamp.{0},Tento zaměstnanec již má záznam se stejným časovým razítkem. {0},
This page keeps track of items you want to buy from sellers.,"Tato stránka sleduje položky, které chcete koupit od prodejců.",
This page keeps track of your items in which buyers have showed some interest.,"Tato stránka sleduje vaše položky, o které kupující projevili určitý zájem.",
Thursday,Čtvrtek,
Timing,Načasování,
Title,Titulek,
"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Chcete-li povolit přeúčtování, aktualizujte položku „Příplatek za fakturaci“ v Nastavení účtů nebo v položce.",
"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Chcete-li povolit příjem / doručení, aktualizujte položku „Příjem / příjem“ v Nastavení skladu nebo v položce.",
To date needs to be before from date,K dnešnímu dni musí být před datem,
Total,Celkem,
Total Early Exits,Celkový předčasný odchod,
Total Late Entries,Celkem pozdních záznamů,
Total Payment Request amount cannot be greater than {0} amount,Celková částka žádosti o platbu nesmí být vyšší než {0} částka,
Total payments amount can't be greater than {},Celková částka plateb nemůže být vyšší než {},
Totals,Součty,
Training Event:,Školení:,
Transactions already retreived from the statement,Transakce již byly z výkazu odebrány,
Transfer Material to Supplier,Přeneste materiál Dodavateli,
Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Číslo a datum dopravy jsou pro zvolený druh dopravy povinné,
Tuesday,Úterý,
Type,Typ,
Unable to find Salary Component {0},Nelze najít komponentu platu {0},
Unable to find the time slot in the next {0} days for the operation {1}.,V následujících {0} dnech operace nebylo možné najít časový úsek {1}.,
Unable to update remote activity,Nelze aktualizovat vzdálenou aktivitu,
Unknown Caller,Neznámý volající,
Unlink external integrations,Odpojte externí integrace,
Unmarked Attendance for days,Neoznačená účast na několik dní,
Unpublish Item,Zrušit publikování položky,
Unreconciled,Bez smíření,
Unsupported GST Category for E-Way Bill JSON generation,Nepodporovaná kategorie GST pro generaci E-Way Bill JSON,
Update,Aktualizovat,
Update Details,Aktualizujte podrobnosti,
Update Taxes for Items,Aktualizace daní za položky,
"Upload a bank statement, link or reconcile a bank account","Nahrajte bankovní výpis, propojte nebo sjednejte bankovní účet",
Upload a statement,Nahrajte prohlášení,
Use a name that is different from previous project name,"Použijte název, který se liší od předchozího názvu projektu",
User {0} is disabled,Uživatel {0} je zakázána,
Users and Permissions,Uživatelé a oprávnění,
Vacancies cannot be lower than the current openings,Volná pracovní místa nemohou být nižší než stávající otvory,
Valid From Time must be lesser than Valid Upto Time.,Platný od času musí být menší než platný až do doby.,
Valuation Rate required for Item {0} at row {1},Míra ocenění požadovaná pro položku {0} v řádku {1},
Values Out Of Sync,Hodnoty ze synchronizace,
Vehicle Type is required if Mode of Transport is Road,"Typ vozidla je vyžadován, pokud je způsob dopravy silniční",
Vendor Name,Jméno prodejce,
Verify Email,ověřovací email,
View,Pohled,
View all issues from {0},Zobrazit všechna čísla od {0},
View call log,Zobrazit protokol hovorů,
Warehouse,Sklad,
Warehouse not found against the account {0},Sklad nebyl nalezen proti účtu {0},
Welcome to {0},Vítejte v {0},
Why do think this Item should be removed?,"Proč si myslíte, že by tato položka měla být odstraněna?",
Work Order {0}: Job Card not found for the operation {1},Pracovní objednávka {0}: pracovní list nebyl nalezen pro operaci {1},
Workday {0} has been repeated.,Pracovní den {0} byl opakován.,
XML Files Processed,Soubory XML byly zpracovány,
Year,Rok,
Yearly,Ročně,
You,Vy,
You are not allowed to enroll for this course,Do tohoto kurzu se nemůžete přihlásit,
You are not enrolled in program {0},Nejste přihlášeni do programu {0},
You can Feature upto 8 items.,Můžete zadat až 8 položek.,
You can also copy-paste this link in your browser,Můžete také kopírovat - vložit tento odkaz do Vašeho prohlížeče,
You can publish upto 200 items.,Můžete publikovat až 200 položek.,
You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Chcete-li zachovat úrovně opětovného objednání, musíte povolit automatickou změnu pořadí v Nastavení skladu.",
You must be a registered supplier to generate e-Way Bill,"Chcete-li vygenerovat e-Way Bill, musíte být registrovaným dodavatelem",
You need to login as a Marketplace User before you can add any reviews.,"Než budete moci přidat recenze, musíte se přihlásit jako uživatel Marketplace.",
Your Featured Items,Vaše doporučené položky,
Your Items,Vaše položky,
Your Profile,Tvůj profil,
Your rating:,Vase hodnoceni:,
and,a,
e-Way Bill already exists for this document,Pro tento dokument již existuje e-Way Bill,
woocommerce - {0},woocommerce - {0},
{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Použitý kupón je {1}. Povolené množství je vyčerpáno,
{0} Name,{0} Name,
{0} Operations: {1},{0} Operace: {1},
{0} bank transaction(s) created,Bylo vytvořeno {0} bankovních transakcí,
{0} bank transaction(s) created and {1} errors,Bylo vytvořeno {0} bankovních transakcí a {1} chyb,
{0} can not be greater than {1},{0} nemůže být větší než {1},
{0} conversations,{0} konverzací,
{0} is not a company bank account,{0} není firemní bankovní účet,
{0} is not a group node. Please select a group node as parent cost center,{0} není skupinový uzel. Vyberte skupinový uzel jako nadřazené nákladové středisko,
{0} is not the default supplier for any items.,{0} není výchozím dodavatelem pro žádné položky.,
{0} is required,{0} je vyžadováno,
{0}: {1} must be less than {2},{0}: {1} musí být menší než {2},
{} is an invalid Attendance Status.,{} je neplatný stav účasti.,
{} is required to generate E-Way Bill JSON,{} je vyžadován pro vygenerování E-Way Bill JSON,
"Invalid lost reason {0}, please create a new lost reason","Neplatný ztracený důvod {0}, vytvořte prosím nový ztracený důvod",
Profit This Year,Zisk letos,
Total Expense,Celkové výdaje,
Total Expense This Year,Celkové výdaje v tomto roce,
Total Income,Celkový příjem,
Total Income This Year,Celkový příjem v tomto roce,
Barcode,čárový kód,
Bold,tučně,
Center,Střed,
Clear,Průhledná,
Comment,Komentář,
Comments,Komentáře,
DocType,DocType,
Download,Stažení,
Left,Zbývá,
Link,Odkaz,
New,Nový,
Not Found,Nenalezeno,
Print,Tisk,
Reference Name,Referenční název,
Refresh,Obnovit,
Success,Úspěch,
Time,Čas,
Value,Hodnota,
Actual,Aktuální,
Add to Cart,Přidat do košíku,
Days Since Last Order,Dny od poslední objednávky,
In Stock,Na skladě,
Loan Amount is mandatory,Částka půjčky je povinná,
Mode Of Payment,Způsob platby,
No students Found,Nebyli nalezeni žádní studenti,
Not in Stock,Není skladem,
Please select a Customer,Vyberte zákazníka,
Printed On,Vytištěno na,
Received From,Přijaté Od,
Sales Person,Prodavač,
To date cannot be before From date,K dnešnímu dni nemůže být dříve od data,
Write Off,Odepsat,
{0} Created,{0} vytvořil,
Email Id,Email Id,
No,Ne,
Reference Doctype,Reference DocType,
User Id,Uživatelské ID,
Yes,Ano,
Actual ,Aktuální,
Add to cart,Přidat do košíku,
Budget,Rozpočet,
Chart Of Accounts Importer,Dovozce grafů účtů,
Chart of Accounts,Graf účtů,
Customer database.,Databáze zákazníků.,
Days Since Last order,Počet dnů od poslední objednávky,
Download as JSON,Stáhnout jako JSON,
End date can not be less than start date,Datum ukončení nesmí být menší než datum zahájení,
For Default Supplier (Optional),Výchozí dodavatel (volitelné),
From date cannot be greater than To date,Od Datum nemůže být větší než Datum,
Get items from,Položka získaná z,
Group by,Seskupit podle,
In stock,Na skladě,
Item name,Název položky,
Loan amount is mandatory,Částka půjčky je povinná,
Minimum Qty,Minimální počet,
More details,Další podrobnosti,
Nature of Supplies,Příroda Dodávky,
No Items found.,Žádné předměty nenalezeny.,
No employee found,Žádný zaměstnanec nalezeno,
No students found,Žádní studenti Nalezené,
Not in stock,Není skladem,
Not permitted,Nepovoleno,
Open Issues ,Otevřené problémy,
Open Projects ,Otevřené projekty,
Open To Do ,Otevřená dělat,
Operation Id,Provoz ID,
Partially ordered,částečně uspořádané,
Please select company first,"Prosím, vyberte první firma",
Please select patient,Vyberte možnost Pacient,
Printed On ,Vytištěno,
Projected qty,Promítané množství,
Sales person,Prodej Osoba,
Serial No {0} Created,Pořadové číslo {0} vytvořil,
Source Location is required for the Asset {0},Místo zdroje je požadováno pro daný účet {0},
Tax Id,DIČ,
To Time,Chcete-li čas,
To date cannot be before from date,To Date nemůže být před From Date,
Total Taxable value,Celková zdanitelná hodnota,
Upcoming Calendar Events ,Nadcházející Události v kalendáři,
Value or Qty,Hodnota nebo množství,
Variance ,Odchylka,
Variant of,Varianta,
Write off,Odepsat,
hours,Hodiny,
received from,Přijaté Od,
to,na,
Cards,Karty,
Percentage,Procento,
Failed to setup defaults for country {0}. Please contact support@erpnext.com,Nepodařilo se nastavit výchozí hodnoty pro zemi {0}. Obraťte se prosím na support@erpnext.com,
Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Řádek # {0}: Položka {1} není sériová / dávková položka. Nemůže mít proti sobě sériové číslo / číslo šarže.,
Please set {0},Prosím nastavte {0},
Please set {0},Nastavte prosím {0},supplier
Draft,Návrh,"docstatus,=,0"
Cancelled,Zrušeno,"docstatus,=,2"
Please setup Instructor Naming System in Education > Education Settings,Nastavte prosím Pojmenovací systém instruktorů v sekci Vzdělávání&gt; Nastavení vzdělávání,
Please set Naming Series for {0} via Setup > Settings > Naming Series,Nastavte Naming Series pro {0} prostřednictvím Nastavení&gt; Nastavení&gt; Naming Series,
UOM Conversion factor ({0} -> {1}) not found for item: {2},UOM konverzní faktor ({0} -&gt; {1}) nebyl nalezen pro položku: {2},
Item Code > Item Group > Brand,Kód položky&gt; Skupina položek&gt; Značka,
Customer > Customer Group > Territory,Zákazník&gt; Skupina zákazníků&gt; Území,
Supplier > Supplier Type,Dodavatel&gt; Typ dodavatele,
Please setup Employee Naming System in Human Resource > HR Settings,Nastavte prosím systém názvů zaměstnanců v části Lidské zdroje&gt; Nastavení lidských zdrojů,
Please setup numbering series for Attendance via Setup > Numbering Series,Nastavte číslovací řady pro Docházku prostřednictvím Nastavení&gt; Číslovací řady,
The value of {0} differs between Items {1} and {2},Hodnota {0} se mezi položkami {1} a {2} liší.,
Auto Fetch,Auto Fetch,
Fetch Serial Numbers based on FIFO,Načíst sériová čísla na základě FIFO,
"Outward taxable supplies(other than zero rated, nil rated and exempted)","Dodávky podléhající zdanění (jiné než nulové, nulové a osvobozené od daně)",
"To allow different rates, disable the {0} checkbox in {1}.","Chcete-li povolit různé sazby, deaktivujte {0} zaškrtávací políčko v {1}.",
Current Odometer Value should be greater than Last Odometer Value {0},Aktuální hodnota počítadla kilometrů by měla být větší než hodnota posledního počítadla kilometrů {0},
No additional expenses has been added,Nebyly přidány žádné další výdaje,
Asset{} {assets_link} created for {},Prostředek {} {assets_link} vytvořen pro {},
Row {}: Asset Naming Series is mandatory for the auto creation for item {},Řádek {}: Série pojmenování děl je povinná pro automatické vytváření položky {},
Assets not created for {0}. You will have to create asset manually.,Podklady nebyly vytvořeny pro {0}. Aktivitu budete muset vytvořit ručně.,
{0} {1} has accounting entries in currency {2} for company {3}. Please select a receivable or payable account with currency {2}.,{0} {1} má účetní záznamy v měně {2} pro společnost {3}. Vyberte pohledávku nebo závazek s měnou {2}.,
Invalid Account,Neplatný účet,
Purchase Order Required,Vydaná objednávka je vyžadována,
Purchase Receipt Required,Příjmka je vyžadována,
Account Missing,Účet chybí,
Requested,Požadované,
Partially Paid,Částečně zaplaceno,
Invalid Account Currency,Neplatná měna účtu,
"Row {0}: The item {1}, quantity must be positive number","Řádek {0}: Položka {1}, množství musí být kladné číslo",
"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Nastavte {0} pro dávkovou položku {1}, která se používá k nastavení {2} při odeslání.",
Expiry Date Mandatory,Datum ukončení platnosti je povinné,
Variant Item,Varianta položky,
BOM 1 {0} and BOM 2 {1} should not be same,Kusovník 1 {0} a kusovník 2 {1} by neměly být stejné,
Note: Item {0} added multiple times,Poznámka: Položka {0} byla přidána několikrát,
YouTube,Youtube,
Vimeo,Vimeo,
Publish Date,Datum publikování,
Duration,Doba trvání,
Advanced Settings,Pokročilé nastavení,
Path,Cesta,
Components,Komponenty,
Verified By,Verified By,
Invalid naming series (. missing) for {0},Neplatná pojmenovací řada (. Chybí) pro {0},
Filter Based On,Filtr založený na,
Reqd by date,Dotaz podle data,
Manufacturer Part Number <b>{0}</b> is invalid,Číslo dílu výrobce <b>{0}</b> je neplatné,
Invalid Part Number,Neplatné číslo dílu,
Select atleast one Social Media from Share on.,Vyberte alespoň jedno sociální médium ze složky Sdílet na.,
Invalid Scheduled Time,Neplatný naplánovaný čas,
Length Must be less than 280.,Délka musí být menší než 280.,
Error while POSTING {0},Chyba při odesílání {0},
"Session not valid, Do you want to login?","Relace není platná, chcete se přihlásit?",
Session Active,Aktivní relace,
Session Not Active. Save doc to login.,Relace není aktivní. Uložit dokument pro přihlášení.,
Error! Failed to get request token.,Chyba! Získání tokenu požadavku se nezdařilo.,
Invalid {0} or {1},Neplatné {0} nebo {1},
Error! Failed to get access token.,Chyba! Získání přístupového tokenu se nezdařilo.,
Invalid Consumer Key or Consumer Secret Key,Neplatný klíč zákazníka nebo tajný klíč zákazníka,
Your Session will be expire in ,Vaše relace vyprší za,
 days.,dnů.,
Session is expired. Save doc to login.,Platnost relace vypršela. Uložit dokument pro přihlášení.,
Error While Uploading Image,Chyba při nahrávání obrázku,
You Didn't have permission to access this API,Neměli jste oprávnění k přístupu k tomuto API,
Valid Upto date cannot be before Valid From date,Platné aktuální datum nemůže být dříve než platné od data,
Valid From date not in Fiscal Year {0},"Platné od data, které není ve fiskálním roce {0}",
Valid Upto date not in Fiscal Year {0},Platné aktuální datum není ve fiskálním roce {0},
Group Roll No,Skupinová role č,
Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu,
"Row {1}: Quantity ({0}) cannot be a fraction. To allow this, disable '{2}' in UOM {3}.","Řádek {1}: Množství ({0}) nemůže být zlomek. Chcete-li to povolit, deaktivujte „{2}“ v MOM {3}.",
Must be Whole Number,Musí být celé číslo,
Please setup Razorpay Plan ID,Nastavte ID plánu Razorpay,
Contact Creation Failed,Vytvoření kontaktu se nezdařilo,
{0} already exists for employee {1} and period {2},{0} již pro zaměstnance {1} a období {2} existuje,
Leaves Allocated,Listy přidělené,
Leaves Expired,Listy vypršely,
Leave Without Pay does not match with approved {} records,Leave Without Pay neodpovídá schváleným {} záznamům,
Income Tax Slab not set in Salary Structure Assignment: {0},V přiřazení struktury platu není nastavena deska daně z příjmu: {0},
Income Tax Slab: {0} is disabled,Deska daně z příjmu: {0} je deaktivována,
Income Tax Slab must be effective on or before Payroll Period Start Date: {0},Deska daně z příjmu musí být účinná k datu zahájení mezd: {0},
No leave record found for employee {0} on {1},Nebyl nalezen záznam o dovolené zaměstnance {0} dne {1},
Row {0}: {1} is required in the expenses table to book an expense claim.,Řádek {0}: {1} je v tabulce výdajů vyžadován k zaúčtování nároku na výdaj.,
Set the default account for the {0} {1},Nastavit výchozí účet pro {0} {1},
(Half Day),(Půldenní),
Income Tax Slab,Deska daně z příjmu,
Row #{0}: Cannot set amount or formula for Salary Component {1} with Variable Based On Taxable Salary,Řádek č. {0}: Nelze nastavit částku nebo vzorec pro složku mzdy {1} s proměnnou založenou na zdanitelném platu,
Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Řádek č. {}: {} Z {} by měl být {}. Upravte účet nebo vyberte jiný účet.,
Row #{}: Please asign task to a member.,Řádek # {}: Přiřaďte úkol členovi.,
Process Failed,Proces se nezdařil,
Tally Migration Error,Chyba migrace Tally,
Please set Warehouse in Woocommerce Settings,Nastavte Warehouse v nastavení Woocommerce,
Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Řádek {0}: Dodací sklad ({1}) a Zákaznický sklad ({2}) nemohou být stejné,
Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Řádek {0}: Datum splatnosti v tabulce Platební podmínky nemůže být před datem zaúčtování,
Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,Nelze najít {} pro položku {}. Totéž prosím nastavte v Předloze položky nebo Nastavení skladu.,
Row #{0}: The batch {1} has already expired.,Řádek č. {0}: Dávce {1} již vypršela platnost.,
Start Year and End Year are mandatory,Začátek a konec roku jsou povinné,
GL Entry,Vstup GL,
Cannot allocate more than {0} against payment term {1},Nelze přidělit více než {0} proti platebnímu termínu {1},
The root account {0} must be a group,Kořenový účet {0} musí být skupina,
Shipping rule not applicable for country {0} in Shipping Address,Pravidlo pro přepravu se nevztahuje na zemi {0} uvedenou v dodací adrese,
Get Payments from,Získejte platby od,
Set Shipping Address or Billing Address,Nastavte dodací adresu nebo fakturační adresu,
Consultation Setup,Nastavení konzultace,
Fee Validity,Platnost poplatku,
Laboratory Setup,Laboratorní nastavení,
Dosage Form,Dávkovací forma,
Records and History,Záznamy a historie,
Patient Medical Record,Záznam pacienta,
Rehabilitation,Rehabilitace,
Exercise Type,Typ cvičení,
Exercise Difficulty Level,Úroveň obtížnosti cvičení,
Therapy Type,Typ terapie,
Therapy Plan,Terapeutický plán,
Therapy Session,Terapeutické sezení,
Motor Assessment Scale,Stupnice hodnocení motoru,
[Important] [ERPNext] Auto Reorder Errors,[Důležité] [ERPNext] Chyby automatického řazení,
"Regards,","Pozdravy,",
The following {0} were created: {1},Byly vytvořeny následující {0}: {1},
Work Orders,Pracovní příkazy,
The {0} {1} created sucessfully,{0} {1} vytvořil úspěšně,
Work Order cannot be created for following reason: <br> {0},Pracovní příkaz nelze vytvořit z následujícího důvodu:<br> {0},
Add items in the Item Locations table,Přidejte položky do tabulky Umístění položek,
Update Current Stock,Aktualizujte aktuální sklad,
"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Ponechat vzorek je založen na dávce. Chcete-li uchovat vzorek položky, zaškrtněte políčko Má dávka č",
Empty,Prázdný,
Currently no stock available in any warehouse,Momentálně nejsou v žádném skladu k dispozici žádné zásoby,
BOM Qty,Počet kusů,
Time logs are required for {0} {1},Pro {0} {1} jsou vyžadovány časové protokoly,
Total Completed Qty,Celkem dokončeno Množství,
Qty to Manufacture,Množství K výrobě,
Repay From Salary can be selected only for term loans,Výplatu z platu lze vybrat pouze u termínovaných půjček,
No valid Loan Security Price found for {0},Nebyla nalezena platná cena zabezpečení půjčky pro {0},
Loan Account and Payment Account cannot be same,Úvěrový účet a platební účet nemohou být stejné,
Loan Security Pledge can only be created for secured loans,Slib zajištění půjčky lze vytvořit pouze pro zajištěné půjčky,
Social Media Campaigns,Kampaně na sociálních médiích,
From Date can not be greater than To Date,Od data nemůže být větší než od data,
Please set a Customer linked to the Patient,Nastavte prosím zákazníka spojeného s pacientem,
Customer Not Found,Zákazník nebyl nalezen,
Please Configure Clinical Procedure Consumable Item in ,Nakonfigurujte prosím spotřební položku klinického postupu ve Windows,
Missing Configuration,Chybějící konfigurace,
Out Patient Consulting Charge Item,Položka pro poplatek za konzultaci s pacientem,
Inpatient Visit Charge Item,Poplatek za návštěvu pacienta,
OP Consulting Charge,Konzultační poplatek OP,
Inpatient Visit Charge,Poplatek za návštěvu v nemocnici,
Appointment Status,Stav schůzky,
Test: ,Test:,
Collection Details: ,Podrobnosti o kolekci:,
{0} out of {1},{0} z {1},
Select Therapy Type,Vyberte typ terapie,
{0} sessions completed,Dokončené relace: {0},
{0} session completed,{0} relace dokončena,
 out of {0},z {0},
Therapy Sessions,Terapeutická sezení,
Add Exercise Step,Přidejte krok cvičení,
Edit Exercise Step,Upravit krok cvičení,
Patient Appointments,Jmenování pacientů,
Item with Item Code {0} already exists,Položka s kódem položky {0} již existuje,
Registration Fee cannot be negative or zero,Registrační poplatek nesmí být záporný ani nulový,
Configure a service Item for {0},Nakonfigurujte položku služby pro {0},
Temperature: ,Teplota:,
Pulse: ,Puls:,
Respiratory Rate: ,Dechová frekvence:,
BP: ,BP:,
BMI: ,BMI:,
Note: ,Poznámka:,
Check Availability,Zkontrolujte dostupnost,
Please select Patient first,Nejprve vyberte pacienta,
Please select a Mode of Payment first,Nejprve prosím vyberte způsob platby,
Please set the Paid Amount first,Nejprve prosím nastavte zaplacenou částku,
Not Therapies Prescribed,Nejsou předepsané terapie,
There are no Therapies prescribed for Patient {0},Pacientovi nejsou předepsány žádné terapie {0},
Appointment date and Healthcare Practitioner are Mandatory,Datum schůzky a lékař jsou povinní,
No Prescribed Procedures found for the selected Patient,U vybraného pacienta nebyly nalezeny žádné předepsané postupy,
Please select a Patient first,Nejprve vyberte pacienta,
There are no procedure prescribed for ,Není stanoven žádný postup,
Prescribed Therapies,Předepsané terapie,
Appointment overlaps with ,Schůzka se překrývá s,
{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,{0} má naplánovanou schůzku s {1} na {2} s trváním {3} minut.,
Appointments Overlapping,Překrývání schůzek,
Consulting Charges: {0},Poplatky za konzultaci: {0},
Appointment Cancelled. Please review and cancel the invoice {0},Schůzka byla zrušena. Zkontrolujte a zrušte fakturu {0},
Appointment Cancelled.,Schůzka byla zrušena.,
Fee Validity {0} updated.,Platnost poplatku {0} aktualizována.,
Practitioner Schedule Not Found,Rozvrh lékaře nebyl nalezen,
{0} is on a Half day Leave on {1},{0} je na půldenní dovolenou dne {1},
{0} is on Leave on {1},{0} je na dovolené dne {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner,{0} nemá harmonogram praktického lékaře. Přidejte jej do Healthcare Practitioner,
Healthcare Service Units,Jednotky zdravotní péče,
Complete and Consume,Vyplňte a spotřebujte,
Complete {0} and Consume Stock?,Dokončit {0} a spotřebovat zásoby?,
Complete {0}?,Dokončit {0}?,
Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Skladové množství pro zahájení postupu není ve skladu k dispozici {0}. Chcete zaznamenat skladovou položku?,
{0} as on {1},{0} jako dne {1},
Clinical Procedure ({0}):,Klinický postup ({0}):,
Please set Customer in Patient {0},Nastavte prosím zákazníka v pacientovi {0},
Item {0} is not active,Položka {0} není aktivní,
Therapy Plan {0} created successfully.,Terapeutický plán {0} byl úspěšně vytvořen.,
Symptoms: ,Příznaky:,
No Symptoms,Žádné příznaky,
Diagnosis: ,Diagnóza:,
No Diagnosis,Žádná diagnóza,
Drug(s) Prescribed.,Předepsané léky.,
Test(s) Prescribed.,Předepsané testy.,
Procedure(s) Prescribed.,Předepsaný postup.,
Counts Completed: {0},Počty dokončeny: {0},
Patient Assessment,Hodnocení pacienta,
Assessments,Hodnocení,
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.",
Account Name,Název účtu,
Inter Company Account,Inter podnikový účet,
Parent Account,Nadřazený účet,
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.,
Chargeable,Vyměřovací,
Rate at which this tax is applied,"Sazba, při které se používá tato daň",
Frozen,Zmražený,
"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.",
Balance must be,Zůstatek musí být,
Lft,Lft,
Rgt,Rgt,
Old Parent,Staré nadřazené,
Include in gross,Zahrňte do hrubého,
Auditor,Auditor,
Accounting Dimension,Účetní dimenze,
Dimension Name,Název dimenze,
Dimension Defaults,Výchozí hodnoty dimenze,
Accounting Dimension Detail,Detail účetní dimenze,
Default Dimension,Výchozí dimenze,
Mandatory For Balance Sheet,Povinná pro rozvahu,
Mandatory For Profit and Loss Account,Povinné pro účet zisků a ztrát,
Accounting Period,Účetní období,
Period Name,Název období,
Closed Documents,Uzavřené dokumenty,
Accounts Settings,Nastavení účtu,
Settings for Accounts,Nastavení účtů,
Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob,
"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.",
Accounts Frozen Upto,Účty Frozen aľ,
"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.",
Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky,
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 účtů,
Determine Address Tax Category From,Určete kategorii daně z adresy od,
Address used to determine Tax Category in transactions.,Adresa použitá k určení daňové kategorie v transakcích.,
Over Billing Allowance (%),Příplatek za fakturaci (%),
Percentage you are allowed to bill more against the amount ordered. For example: If the order value is $100 for an item and tolerance is set as 10% then you are allowed to bill for $110.,"Procento, které máte možnost vyúčtovat více oproti objednané částce. Například: Pokud je hodnota objednávky 100 $ pro položku a tolerance je nastavena na 10%, pak máte možnost vyúčtovat za 110 $.",
Credit Controller,Credit Controller,
Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity.",
Check Supplier Invoice Number Uniqueness,"Zkontrolujte, zda dodavatelské faktury Počet Jedinečnost",
Make Payment via Journal Entry,Provést platbu přes Journal Entry,
Unlink Payment on Cancellation of Invoice,Odpojit Platba o zrušení faktury,
Unlink Advance Payment on Cancelation of Order,Odpojte zálohy na zrušení objednávky,
Book Asset Depreciation Entry Automatically,Zúčtování odpisu majetku na účet automaticky,
Automatically Add Taxes and Charges from Item Tax Template,Automaticky přidávat daně a poplatky ze šablony položky daně,
Automatically Fetch Payment Terms,Automaticky načíst platební podmínky,
Show Inclusive Tax In Print,Zobrazit inkluzivní daň v tisku,
Show Payment Schedule in Print,Zobrazit plán placení v tisku,
Currency Exchange Settings,Nastavení směnného kurzu,
Allow Stale Exchange Rates,Povolit stávající kurzy měn,
Stale Days,Stale Days,
Report Settings,Nastavení přehledů,
Use Custom Cash Flow Format,Použijte formát vlastní peněžní toky,
Only select if you have setup Cash Flow Mapper documents,"Zvolte pouze, pokud máte nastavené dokumenty pro mapování cash flow",
Allowed To Transact With,Povoleno k transakci s,
SWIFT number,Číslo SWIFT,
Branch Code,Kód pobočky,
Address and Contact,Adresa a Kontakt,
Address HTML,Adresa HTML,
Contact HTML,Kontakt HTML,
Data Import Configuration,Konfigurace importu dat,
Bank Transaction Mapping,Mapování bankovních transakcí,
Plaid Access Token,Plaid Access Token,
Company Account,Firemní účet,
Account Subtype,Podtyp účtu,
Is Default Account,Je výchozí účet,
Is Company Account,Je účet společnosti,
Party Details,Party Podrobnosti,
Account Details,Údaje o účtu,
IBAN,IBAN,
Bank Account No,Bankovní účet č,
Integration Details,Podrobnosti o integraci,
Integration ID,ID integrace,
Last Integration Date,Datum poslední integrace,
Change this date manually to setup the next synchronization start date,Toto datum změňte ručně a nastavte další datum zahájení synchronizace,
Mask,Maska,
Bank Account Subtype,Podtyp bankovního účtu,
Bank Account Type,Typ bankovního účtu,
Bank Guarantee,Bankovní záruka,
Bank Guarantee Type,Typ bankovní záruky,
Receiving,Příjem,
Providing,Poskytování,
Reference Document Name,Název referenčního dokumentu,
Validity in Days,Platnost ve dnech,
Bank Account Info,Informace o bankovním účtu,
Clauses and Conditions,Doložky a podmínky,
Other Details,Další detaily,
Bank Guarantee Number,Číslo bankovní záruky,
Name of Beneficiary,Název příjemce,
Margin Money,Margin Money,
Charges Incurred,Poplatky vznikly,
Fixed Deposit Number,Číslo pevného vkladu,
Account Currency,Měna účtu,
Select the Bank Account to reconcile.,"Vyberte bankovní účet, který chcete smířit.",
Include Reconciled Entries,Zahrnout odsouhlasené zápisy,
Get Payment Entries,Získat Platební položky,
Payment Entries,Platební Příspěvky,
Update Clearance Date,Aktualizace Výprodej Datum,
Bank Reconciliation Detail,Bank Odsouhlasení Detail,
Cheque Number,Šek číslo,
Cheque Date,Šek Datum,
Statement Header Mapping,Mapování hlaviček výpisu,
Statement Headers,Záhlaví prohlášení,
Transaction Data Mapping,Mapování dat transakcí,
Mapped Items,Mapované položky,
Bank Statement Settings Item,Položka nastavení bankovního výpisu,
Mapped Header,Mapované záhlaví,
Bank Header,Záhlaví banky,
Bank Statement Transaction Entry,Příkaz transakce bankovního výpisu,
Bank Transaction Entries,Položky bankovních transakcí,
New Transactions,Nové transakce,
Match Transaction to Invoices,Shoda transakce na faktury,
Create New Payment/Journal Entry,Vytvořit novou položku platby / deník,
Submit/Reconcile Payments,Odeslání / odsouhlasení plateb,
Matching Invoices,Shoda faktur,
Payment Invoice Items,Položky platební faktury,
Reconciled Transactions,Zkombinované transakce,
Bank Statement Transaction Invoice Item,Položka faktury bankovního výpisu,
Payment Description,Popis platby,
Invoice Date,Datum Fakturace,
invoice,faktura,
Bank Statement Transaction Payment Item,Položka platební transakce bankovního účtu,
outstanding_amount,nesplacená částka,
Payment Reference,Odkaz na platby,
Bank Statement Transaction Settings Item,Položka položek transakce bankovního výpisu,
Bank Data,Bankovní údaje,
Mapped Data Type,Mapovaný typ dat,
Mapped Data,Mapované údaje,
Bank Transaction,Bankovní transakce,
ACC-BTN-.YYYY.-,ACC-BTN-.RRRR.-,
Transaction ID,ID transakce,
Unallocated Amount,nepřidělené Částka,
Field in Bank Transaction,Pole v bankovní transakci,
Column in Bank File,Sloupec v bankovním souboru,
Bank Transaction Payments,Platby bankovními transakcemi,
Control Action,Kontrolní akce,
Applicable on Material Request,Použitelné na žádosti o materiál,
Action if Annual Budget Exceeded on MR,Opatření v případě překročení ročního rozpočtu na MR,
Warn,Varovat,
Ignore,Ignorovat,
Action if Accumulated Monthly Budget Exceeded on MR,Akce při překročení akumulovaného měsíčního rozpočtu na MR,
Applicable on Purchase Order,Platí pro objednávku,
Action if Annual Budget Exceeded on PO,Opatření v případě překročení ročního rozpočtu na OP,
Action if Accumulated Monthly Budget Exceeded on PO,Akce při překročení akumulovaného měsíčního rozpočtu v PO,
Applicable on booking actual expenses,Platí pro rezervaci skutečných nákladů,
Action if Annual Budget Exceeded on Actual,"Akce, pokud je roční rozpočet překročen na skutečné",
Action if Accumulated Monthly Budget Exceeded on Actual,Akce při překročení akumulovaného měsíčního rozpočtu na skutečné,
Budget Accounts,rozpočtové účty,
Budget Account,rozpočet účtu,
Budget Amount,rozpočet Částka,
C-Form,C-Form,
ACC-CF-.YYYY.-,ACC-CF-.YYYY.-,
C-Form No,C-Form No,
Received Date,Datum přijetí,
Quarter,Čtvrtletí,
I,já,
II,II,
III,III,
IV,IV,
C-Form Invoice Detail,C-Form Faktura Detail,
Invoice No,Faktura č,
Cash Flow Mapper,Mapovač hotovostních toků,
Section Name,Název oddílu,
Section Header,Záhlaví sekce,
Section Leader,Vedoucí sekce,
e.g Adjustments for:,např. Úpravy pro:,
Section Subtotal,Sekce Mezisoučet,
Section Footer,Zápatí sekce,
Position,Pozice,
Cash Flow Mapping,Mapování peněžních toků,
Select Maximum Of 1,Vyberte možnost Maximálně 1,
Is Finance Cost,Jsou finanční náklady,
Is Working Capital,Je pracovní kapitál,
Is Finance Cost Adjustment,Je úprava nákladů na finance,
Is Income Tax Liability,Je odpovědnost za dani z příjmu,
Is Income Tax Expense,Jsou náklady na daň z příjmů,
Cash Flow Mapping Accounts,Účty mapování peněžních toků,
account,Účet,
Cash Flow Mapping Template,Šablona mapování peněžních toků,
Cash Flow Mapping Template Details,Podrobné informace o šabloně mapování peněžních toků,
POS-CLO-,POS-CLO-,
Custody,Péče,
Net Amount,Čistá částka,
Cashier Closing Payments,Pokladní hotovostní platby,
Chart of Accounts Importer,Dovozní tabulka účtů,
Import Chart of Accounts from a csv file,Importujte graf účtů ze souboru csv,
Attach custom Chart of Accounts file,Připojte vlastní soubor účtových účtů,
Chart Preview,Náhled grafu,
Chart Tree,Strom grafu,
Cheque Print Template,Šek šablony tisku,
Has Print Format,Má formát tisku,
Primary Settings,primární Nastavení,
Cheque Size,Šek Velikost,
Regular,Pravidelný,
Starting position from top edge,Výchozí poloha od horního okraje,
Cheque Width,Šek Šířka,
Cheque Height,Šek Výška,
Scanned Cheque,skenovaných Šek,
Is Account Payable,Je účtu splatný,
Distance from top edge,Vzdálenost od horního okraje,
Distance from left edge,Vzdálenost od levého okraje,
Message to show,Zpráva ukázat,
Date Settings,Datum Nastavení,
Starting location from left edge,Počínaje umístění od levého okraje,
Payer Settings,Nastavení plátce,
Width of amount in word,Šířka částky ve slově,
Line spacing for amount in words,řádkování za částku ve slovech,
Amount In Figure,Na obrázku výše,
Signatory Position,Signatář Position,
Closed Document,Uzavřený dokument,
Track separate Income and Expense for product verticals or divisions.,Sledovat samostatné výnosy a náklady pro vertikál produktu nebo divizí.,
Cost Center Name,Jméno nákladového střediska,
Parent Cost Center,Nadřazené Nákladové středisko,
lft,LFT,
rgt,Rgt,
Coupon Code,Kód kupónu,
Coupon Name,Název kupónu,
"e.g. ""Summer Holiday 2019 Offer 20""","např. „Letní dovolená 2019, nabídka 20“",
Coupon Type,Typ kupónu,
Promotional,Propagační,
Gift Card,Dárková poukázka,
unique e.g. SAVE20  To be used to get discount,jedinečný např. SAVE20 Slouží k získání slevy,
Validity and Usage,Platnost a použití,
Valid From,Platnost od,
Valid Upto,Platí až,
Maximum Use,Maximální využití,
Used,Použitý,
Coupon Description,Popis kupónu,
Discounted Invoice,Zvýhodněná faktura,
Debit to,Debet na,
Exchange Rate Revaluation,Přehodnocení směnného kurzu,
Get Entries,Získejte položky,
Exchange Rate Revaluation Account,Účet z přecenění směnného kurzu,
Total Gain/Loss,Celkový zisk / ztráta,
Balance In Account Currency,Zůstatek v měně účtu,
Current Exchange Rate,Aktuální směnný kurz,
Balance In Base Currency,Zůstatek v základní měně,
New Exchange Rate,Nový směnný kurz,
New Balance In Base Currency,Nový zůstatek v základní měně,
Gain/Loss,Zisk / ztráta,
**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 **.,
Year Name,Jméno roku,
"For e.g. 2012, 2012-13","Pro např 2012, 2012-13",
Year Start Date,Datum Zahájení Roku,
Year End Date,Datum Konce Roku,
Companies,Společnosti,
Auto Created,Automaticky vytvořeno,
Stock User,Sklad Uživatel,
Fiscal Year Company,Fiskální rok Společnosti,
Debit Amount,Debetní Částka,
Credit Amount,Výše úvěru,
Debit Amount in Account Currency,Debetní Částka v měně účtu,
Credit Amount in Account Currency,Kreditní Částka v měně účtu,
Voucher Detail No,Voucher Detail No,
Is Opening,Se otevírá,
Is Advance,Je Zálohová,
To Rename,Přejmenovat,
GST Account,Účet GST,
CGST Account,CGST účet,
SGST Account,Účet SGST,
IGST Account,Účet IGST,
CESS Account,Účet CESS,
Loan Start Date,Datum zahájení půjčky,
Loan Period (Days),Výpůjční doba (dny),
Loan End Date,Datum ukončení úvěru,
Bank Charges,Bankovní poplatky,
Short Term Loan Account,Krátkodobý úvěrový účet,
Bank Charges Account,Účet bankovních poplatků,
Accounts Receivable Credit Account,Kreditní účet účtů pohledávek,
Accounts Receivable Discounted Account,Účty pohledávek se slevou,
Accounts Receivable Unpaid Account,Účet nesplacených účtů,
Item Tax Template,Šablona daně z položky,
Tax Rates,Daňová sazba,
Item Tax Template Detail,Detail šablony položky daně,
Entry Type,Entry Type,
Inter Company Journal Entry,Inter Company Entry Journal,
Bank Entry,Bank Entry,
Cash Entry,Cash Entry,
Credit Card Entry,Vstup Kreditní karta,
Contra Entry,Contra Entry,
Excise Entry,Spotřební Entry,
Write Off Entry,Odepsat Vstup,
Opening Entry,Otevření Entry,
ACC-JV-.YYYY.-,ACC-JV-.YYYY.-,
Accounting Entries,Účetní záznamy,
Total Debit,Celkem Debit,
Total Credit,Celkový Credit,
Difference (Dr - Cr),Rozdíl (Dr - Cr),
Make Difference Entry,Učinit vstup Rozdíl,
Total Amount Currency,Celková částka Měna,
Total Amount in Words,Celková částka slovy,
Remark,Poznámka,
Paid Loan,Placený úvěr,
Inter Company Journal Entry Reference,Referenční položka Inter Company Journal Entry,
Write Off Based On,Odepsat založené na,
Get Outstanding Invoices,Získat neuhrazených faktur,
Write Off Amount,Odepsaná částka,
Printing Settings,Tisk Nastavení,
Pay To / Recd From,Platit K / Recd Z,
Payment Order,Platební příkaz,
Subscription Section,Sekce odběru,
Journal Entry Account,Zápis do deníku Účet,
Account Balance,Zůstatek na účtu,
Party Balance,Balance Party,
Accounting Dimensions,Účetní dimenze,
If Income or Expense,Pokud je výnos nebo náklad,
Exchange Rate,Exchange Rate,
Debit in Company Currency,Debetní ve společnosti Měna,
Credit in Company Currency,Úvěrové společnosti v měně,
Payroll Entry,Příspěvek mzdy,
Employee Advance,Zaměstnanec Advance,
Reference Due Date,Referenční datum splatnosti,
Loyalty Program Tier,Věrnostní program Tier,
Redeem Against,Vykoupit proti,
Expiry Date,Datum vypršení platnosti,
Loyalty Point Entry Redemption,Vrácení bodů vkladů,
Redemption Date,Datum vykoupení,
Redeemed Points,Vyčerpané body,
Loyalty Program Name,Název věrnostního programu,
Loyalty Program Type,Typ věrnostního programu,
Single Tier Program,Jednoduchý program,
Multiple Tier Program,Vícevrstvý program,
Customer Territory,Zákaznické území,
Auto Opt In (For all customers),Automatická registrace (pro všechny zákazníky),
Collection Tier,Kolekce Tier,
Collection Rules,Pravidla výběru,
Redemption,Vykoupení,
Conversion Factor,Konverzní faktor,
1 Loyalty Points = How much base currency?,1 Věrnostní body = Kolik základní měny?,
Expiry Duration (in days),Doba platnosti (v dnech),
Help Section,Část nápovědy,
Loyalty Program Help,Nápověda věrnostního programu,
Loyalty Program Collection,Věrnostní program,
Tier Name,Název úrovně,
Minimum Total Spent,Minimální celková vynaložená částka,
Collection Factor (=1 LP),Faktor sbírky (= 1 LP),
For how much spent = 1 Loyalty Point,Kolik stráceno = 1 věrnostní bod,
Mode of Payment Account,Způsob platby účtu,
Default Account,Výchozí účet,
Default account will be automatically updated in POS Invoice when this mode is selected.,Výchozí účet bude automaticky aktualizován v POS faktuře při výběru tohoto režimu.,
**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Měsíční Distribuce ** umožňuje distribuovat Rozpočet / Target celé měsíce, pokud máte sezónnosti ve vaší firmě.",
Distribution Name,Distribuce Name,
Name of the Monthly Distribution,Název měsíční výplatou,
Monthly Distribution Percentages,Měsíční Distribuční Procenta,
Monthly Distribution Percentage,Měsíční Distribution Procento,
Percentage Allocation,Procento přidělení,
Create Missing Party,Vytvořit chybějící stranu,
Create missing customer or supplier.,Vytvořte chybějícího zákazníka nebo dodavatele.,
Opening Invoice Creation Tool Item,Otevření položky nástroje pro vytváření faktur,
Temporary Opening Account,Účet dočasného zahájení,
Party Account,Party účtu,
Type of Payment,Typ platby,
ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
Receive,Příjem,
Internal Transfer,vnitřní Převod,
Payment Order Status,Stav platebního příkazu,
Payment Ordered,Objednané platby,
Payment From / To,Platba z / do,
Company Bank Account,Firemní bankovní účet,
Party Bank Account,Bankovní účet strany,
Account Paid From,Účet jsou placeni z prostředků,
Account Paid To,Účet Věnována,
Paid Amount (Company Currency),Uhrazená částka (firemní měna),
Received Amount,přijaté Částka,
Received Amount (Company Currency),Přijaté Částka (Company měna),
Get Outstanding Invoice,Získejte vynikající fakturu,
Payment References,Platební Reference,
Writeoff,Odepsat,
Total Allocated Amount,Celková alokovaná částka,
Total Allocated Amount (Company Currency),Celková alokovaná částka (Company měna),
Set Exchange Gain / Loss,Set Exchange zisk / ztráta,
Difference Amount (Company Currency),Rozdíl Částka (Company měna),
Write Off Difference Amount,Odepsat Difference Částka,
Deductions or Loss,Odpočty nebo ztráta,
Payment Deductions or Loss,Platební srážky nebo ztráta,
Cheque/Reference Date,Šek / Referenční datum,
Payment Entry Deduction,Platba Vstup dedukce,
Payment Entry Reference,Platba Vstup reference,
Allocated,Přidělené,
Payment Gateway Account,Platební brána účet,
Payment Account,Platební účet,
Default Payment Request Message,Výchozí Platba Request Message,
PMO-,PMO-,
Payment Order Type,Typ platebního příkazu,
Payment Order Reference,Odkaz na platební příkaz,
Bank Account Details,Detaily bankovního účtu,
Payment Reconciliation,Platba Odsouhlasení,
Receivable / Payable Account,Pohledávky / závazky účet,
Bank / Cash Account,Bank / Peněžní účet,
From Invoice Date,Z faktury Datum,
To Invoice Date,Chcete-li data vystavení faktury,
Minimum Invoice Amount,Minimální částka faktury,
Maximum Invoice Amount,Maximální částka faktury,
System will fetch all the entries if limit value is zero.,"Systém načte všechny záznamy, pokud je limitní hodnota nula.",
Get Unreconciled Entries,Získat smířit záznamů,
Unreconciled Payment Details,Smířit platbě,
Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti,
Payment Reconciliation Invoice,Platba Odsouhlasení faktury,
Invoice Number,Číslo faktury,
Payment Reconciliation Payment,Platba Odsouhlasení Platba,
Reference Row,referenční Row,
Allocated amount,Přidělené sumy,
Payment Request Type,Typ žádosti o platbu,
Outward,Vnější,
Inward,Vnitřní,
ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-,
Transaction Details,Detaily transakce,
Amount in customer's currency,Částka v měně zákazníka,
Is a Subscription,Je předplatné,
Transaction Currency,Transakční měna,
Subscription Plans,Předplatné,
SWIFT Number,Číslo SWIFT,
Recipient Message And Payment Details,Příjemce zprávy a platebních informací,
Make Sales Invoice,Proveďte prodejní faktuře,
Mute Email,Mute Email,
payment_url,payment_url,
Payment Gateway Details,Platební brána Podrobnosti,
Payment Schedule,Platební kalendář,
Invoice Portion,Fakturační část,
Payment Amount,Částka platby,
Payment Term Name,Název platebního termínu,
Due Date Based On,Datum splatnosti založeno na,
Day(s) after invoice date,Den (dní) po datu faktury,
Day(s) after the end of the invoice month,Den (den) po skončení měsíce faktury,
Month(s) after the end of the invoice month,Měsíc (měsíce) po skončení měsíce faktury,
Credit Days,Úvěrové dny,
Credit Months,Kreditní měsíce,
Allocate Payment Based On Payment Terms,Přiřaďte platbu na základě platebních podmínek,
"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Pokud je toto políčko zaškrtnuto, bude vyplacená částka rozdělena a přidělena podle částek v rozvrhu plateb proti každému platebnímu období",
Payment Terms Template Detail,Platební podmínky,
Closing Fiscal Year,Uzavření fiskálního roku,
Closing Account Head,Závěrečný účet hlava,
"The account head under Liability or Equity, in which Profit/Loss will be booked","Účet hlavu pod závazkem nebo vlastním kapitálem, ve kterém budou Zisk / ztráta rezervovat",
POS Customer Group,POS Customer Group,
POS Field,Pole POS,
POS Item Group,POS položky Group,
[Select],[Vybrat],
Company Address,adresa společnosti,
Update Stock,Aktualizace skladem,
Ignore Pricing Rule,Ignorovat Ceny pravidlo,
Applicable for Users,Platí pro uživatele,
Sales Invoice Payment,Prodejní faktury Platba,
Item Groups,Položka Skupiny,
Only show Items from these Item Groups,Zobrazovat pouze položky z těchto skupin položek,
Customer Groups,Skupiny zákazníků,
Only show Customer of these Customer Groups,Zobrazovat pouze Zákazníka těchto skupin zákazníků,
Write Off Account,Odepsat účet,
Write Off Cost Center,Odepsat nákladové středisko,
Account for Change Amount,Účet pro změnu Částka,
Taxes and Charges,Daně a poplatky,
Apply Discount On,Použít Sleva na,
POS Profile User,Uživatel profilu POS,
Apply On,Naneste na,
Price or Product Discount,Cena nebo sleva produktu,
Apply Rule On Item Code,Použít pravidlo na kód položky,
Apply Rule On Item Group,Použít pravidlo na skupinu položek,
Apply Rule On Brand,Použít pravidlo na značku,
Mixed Conditions,Smíšené podmínky,
Conditions will be applied on all the selected items combined. ,Na všechny vybrané položky budou použity podmínky společně.,
Is Cumulative,Je kumulativní,
Coupon Code Based,Kód založený na kupónu,
Discount on Other Item,Sleva na další položku,
Apply Rule On Other,Použít pravidlo na jiné,
Party Information,Informace o večírku,
Quantity and Amount,Množství a částka,
Min Qty,Min Množství,
Max Qty,Max Množství,
Min Amt,Min Amt,
Max Amt,Max Amt,
Period Settings,Nastavení období,
Margin,Marže,
Margin Type,Typ Marže,
Margin Rate or Amount,Margin sazbou nebo pevnou částkou,
Price Discount Scheme,Schéma slevy,
Rate or Discount,Cena nebo sleva,
Discount Percentage,Sleva v procentech,
Discount Amount,Částka slevy,
For Price List,Pro Ceník,
Product Discount Scheme,Schéma slevy produktu,
Same Item,Stejná položka,
Free Item,Zdarma položka,
Threshold for Suggestion,Prahová hodnota pro návrh,
System will notify to increase or decrease quantity or amount ,Systém vás upozorní na zvýšení nebo snížení množství nebo množství,
"Higher the number, higher the priority","Vyšší číslo, vyšší priorita",
Apply Multiple Pricing Rules,Použijte pravidla pro více cen,
Apply Discount on Rate,Použijte slevu na sazbu,
Validate Applied Rule,Ověřte použité pravidlo,
Rule Description,Popis pravidla,
Pricing Rule Help,Ceny Pravidlo Help,
Promotional Scheme Id,ID propagačního schématu,
Promotional Scheme,Propagační program,
Pricing Rule Brand,Značka pravidla cen,
Pricing Rule Detail,Detail pravidla stanovení cen,
Child Docname,Název dítěte,
Rule Applied,Platí pravidlo,
Pricing Rule Item Code,Kód položky pravidla pravidla,
Pricing Rule Item Group,Skupina položek cenových pravidel,
Price Discount Slabs,Cenové slevové desky,
Promotional Scheme Price Discount,Sleva na cenu propagačního schématu,
Product Discount Slabs,Desky slev produktu,
Promotional Scheme Product Discount,Sleva produktu na propagační schéma,
Min Amount,Min. Částka,
Max Amount,Maximální částka,
Discount Type,Typ slevy,
ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-,
Tax Withholding Category,Daňové zadržení kategorie,
Edit Posting Date and Time,Úpravy účtování Datum a čas,
Is Paid,se vyplácí,
Is Return (Debit Note),Je Return (Debit Note),
Apply Tax Withholding Amount,Použijte částku s odečtením daně,
Accounting Dimensions ,Účetní dimenze,
Supplier Invoice Details,Dodavatel fakturační údaje,
Supplier Invoice Date,Dodavatelské faktury Datum,
Return Against Purchase Invoice,Návrat proti nákupní faktury,
Select Supplier Address,Vybrat Dodavatel Address,
Contact Person,Kontaktní osoba,
Select Shipping Address,Zvolit adresu pro dodání,
Currency and Price List,Měna a ceník,
Price List Currency,Ceník Měna,
Price List Exchange Rate,Katalogová cena Exchange Rate,
Set Accepted Warehouse,Nastavit přijímaný sklad,
Rejected Warehouse,Zamítnuto Warehouse,
Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek",
Raw Materials Supplied,Dodává suroviny,
Supplier Warehouse,Dodavatel Warehouse,
Pricing Rules,Pravidla tvorby cen,
Supplied Items,Dodávané položky,
Total (Company Currency),Total (Company měny),
Net Total (Company Currency),Net Total (Company Měna),
Total Net Weight,Celková čistá hmotnost,
Shipping Rule,Pravidlo dopravy,
Purchase Taxes and Charges Template,Kupte Daně a poplatky šablony,
Purchase Taxes and Charges,Nákup Daně a poplatky,
Tax Breakup,Rozdělení daní,
Taxes and Charges Calculation,Daně a poplatky výpočet,
Taxes and Charges Added (Company Currency),Daně a poplatky Přidal (Company měna),
Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna),
Total Taxes and Charges (Company Currency),Celkem Daně a poplatky (Company Měnové),
Taxes and Charges Added,Daně a poplatky přidané,
Taxes and Charges Deducted,Daně a odečtené,
Total Taxes and Charges,Celkem Daně a poplatky,
Additional Discount,Další slevy,
Apply Additional Discount On,Použít dodatečné Sleva na,
Additional Discount Amount (Company Currency),Dodatečná sleva Částka (Měna Company),
Additional Discount Percentage,Další procento slevy,
Additional Discount Amount,Dodatečná částka slevy,
Grand Total (Company Currency),Celkový součet (Měna společnosti),
Rounding Adjustment (Company Currency),Úprava zaokrouhlení (měna společnosti),
Rounded Total (Company Currency),Celkem zaokrouhleno (měna solečnosti),
In Words (Company Currency),Slovy (měna společnosti),
Rounding Adjustment,Nastavení zaoblení,
In Words,Slovy,
Total Advance,Total Advance,
Disable Rounded Total,Zakázat Zaoblený Celkem,
Cash/Bank Account,Hotovostní / Bankovní účet,
Write Off Amount (Company Currency),Odepsat Částka (Company měny),
Set Advances and Allocate (FIFO),Nastavit zálohy a přidělit (FIFO),
Get Advances Paid,Získejte zaplacené zálohy,
Advances,Zálohy,
Terms,Podmínky,
Terms and Conditions1,Podmínky a podmínek1,
Group same items,Skupina stejné položky,
Print Language,Tisk Language,
"Once set, this invoice will be on hold till the set date","Jakmile bude tato faktura zadána, bude tato faktura podržena až do stanoveného data",
Credit To,Kredit:,
Party Account Currency,Party Měna účtu,
Against Expense Account,Proti výdajového účtu,
Inter Company Invoice Reference,Interní reference faktury společnosti,
Is Internal Supplier,Je interní dodavatel,
Start date of current invoice's period,Datum období současného faktury je Začátek,
End date of current invoice's period,Datum ukončení doby aktuální faktury je,
Update Auto Repeat Reference,Aktualizovat referenci automatického opakování,
Purchase Invoice Advance,Záloha přijaté faktury,
Purchase Invoice Item,Položka přijaté faktury,
Quantity and Rate,Množství a cena,
Received Qty,Přijaté Množství,
Accepted Qty,Přijato Množství,
Rejected Qty,zamítnuta Množství,
UOM Conversion Factor,UOM Conversion Factor,
Discount on Price List Rate (%),Sleva na Ceník Rate (%),
Price List Rate (Company Currency),Ceník Rate (Company měny),
Rate ,Cena,
Rate (Company Currency),Cena (Měna Společnosti),
Amount (Company Currency),Částka (Měna Společnosti),
Is Free Item,Je položka zdarma,
Net Rate,Čistá míra,
Net Rate (Company Currency),Čistý Rate (Company měny),
Net Amount (Company Currency),Čistá částka (Company Měna),
Item Tax Amount Included in Value,Částka daně z položky zahrnutá v hodnotě,
Landed Cost Voucher Amount,Přistál Náklady Voucher Částka,
Raw Materials Supplied Cost,Dodává se nákladů na suroviny,
Accepted Warehouse,Schválený sklad,
Serial No,Výrobní číslo,
Rejected Serial No,Odmítnuté sériové číslo,
Expense Head,Náklady Head,
Is Fixed Asset,Je dlouhodobý majetek,
Asset Location,Umístění majetku,
Deferred Expense,Odložený výdaj,
Deferred Expense Account,Odložený nákladový účet,
Service Stop Date,Datum ukončení služby,
Enable Deferred Expense,Aktivovat odložený náklad,
Service Start Date,Datum zahájení služby,
Service End Date,Datum ukončení služby,
Allow Zero Valuation Rate,Povolit nulovou míru oceňování,
Item Tax Rate,Sazba daně položky,
Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Tax detail tabulka staženy z položky pána jako řetězec a uložené v této oblasti.\n Používá se daní a poplatků,
Purchase Order Item,Položka vydané objednávky,
Purchase Receipt Detail,Detail dokladu o nákupu,
Item Weight Details,Položka podrobnosti o hmotnosti,
Weight Per Unit,Hmotnost na jednotku,
Total Weight,Celková váha,
Weight UOM,Hmotnostní jedn.,
Page Break,Zalomení stránky,
Consider Tax or Charge for,Zvažte daň či poplatek za,
Valuation and Total,Oceňování a Total,
Valuation,Ocenění,
Add or Deduct,Přidat nebo Odečíst,
Deduct,Odečíst,
On Previous Row Amount,Na předchozí řady Částka,
On Previous Row Total,Na předchozí řady Celkem,
On Item Quantity,Množství položky,
Reference Row #,Referenční Row #,
Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?,
"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",
Account Head,Účet Head,
Tax Amount After Discount Amount,Částka daně po slevě Částka,
Item Wise Tax Detail ,Položka Wise Tax Detail,
"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.","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. \n\n #### Poznámka: \n\n 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.\n\n #### Popis sloupců \n\n 1. Výpočet Type: \n - To může být na ** Čistý Total ** (což je součet základní částky).\n - ** 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.\n - ** Aktuální ** (jak je uvedeno).\n 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat \n 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.\n 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).\n 5. Rate: Sazba daně.\n 6. Částka: Částka daně.\n 7. Celkem: Kumulativní celková k tomuto bodu.\n 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).\n 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í.\n 10. Přidat nebo odečítat: Ať už chcete přidat nebo odečíst daň.",
Salary Component Account,Účet plat Component,
Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Výchozí banka / Peněžní účet budou automaticky aktualizovány v plat položka deníku je-li zvolen tento režim.,
ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-,
Include Payment (POS),Zahrnují platby (POS),
Offline POS Name,Offline POS Name,
Is Return (Credit Note),Je návrat (kreditní poznámka),
Return Against Sales Invoice,Návrat proti prodejní faktuře,
Update Billed Amount in Sales Order,Aktualizovat fakturovanou částku v objednávce prodeje,
Customer PO Details,Podrobnosti PO zákazníka,
Customer's Purchase Order,Zákazníka Objednávka,
Customer's Purchase Order Date,Zákazníka Objednávka Datum,
Customer Address,Zákazník Address,
Shipping Address Name,Název dodací adresy,
Company Address Name,Název adresy společnosti,
Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je měna zákazníka převedena na základní měnu zákazníka",
Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou je ceníková měna převedena na základní měnu zákazníka",
Set Source Warehouse,Nastavit zdrojový sklad,
Packing List,Balící list,
Packed Items,Zabalené položky,
Product Bundle Help,Product Bundle Help,
Time Sheet List,Doba Seznam Sheet,
Time Sheets,čas listy,
Total Billing Amount,Celková částka fakturace,
Sales Taxes and Charges Template,Prodej Daně a poplatky šablony,
Sales Taxes and Charges,Prodej Daně a poplatky,
Loyalty Points Redemption,Věrnostní body Vykoupení,
Redeem Loyalty Points,Uplatnit věrnostní body,
Redemption Account,Účet zpětného odkupu,
Redemption Cost Center,Centrum nákupních nákladů,
In Words will be visible once you save the Sales Invoice.,"Ve slovech budou viditelné, jakmile uložíte prodejní faktury.",
Allocate Advances Automatically (FIFO),Automaticky přidělit předdavky (FIFO),
Get Advances Received,Získat přijaté zálohy,
Base Change Amount (Company Currency),Základna Změna Částka (Company měna),
Write Off Outstanding Amount,Odepsat dlužné částky,
Terms and Conditions Details,Podmínky podrobnosti,
Is Internal Customer,Je interní zákazník,
Is Discounted,Je sleva,
Unpaid and Discounted,Neplacené a zlevněné,
Overdue and Discounted,Po lhůtě splatnosti a se slevou,
Accounting Details,Účetní detaily,
Debit To,Debetní K,
Is Opening Entry,Je vstupní otvor,
C-Form Applicable,C-Form Použitelné,
Commission Rate (%),Výše provize (%),
Sales Team1,Sales Team1,
Against Income Account,Proti účet příjmů,
Sales Invoice Advance,Prodejní faktury Advance,
Advance amount,Záloha ve výši,
Sales Invoice Item,Položka prodejní faktury,
Customer's Item Code,Zákazníka Kód položky,
Brand Name,Jméno značky,
Qty as per Stock UOM,Množství podle Stock nerozpuštěných,
Discount and Margin,Sleva a Margin,
Rate With Margin,Míra s marží,
Discount (%) on Price List Rate with Margin,Sleva (%) na cenovou nabídku s marží,
Rate With Margin (Company Currency),Sazba s marží (měna společnosti),
Delivered By Supplier,Dodává se podle dodavatele,
Deferred Revenue,Odložené výnosy,
Deferred Revenue Account,Účet odloženého výnosu,
Enable Deferred Revenue,Aktivovat odložené výnosy,
Stock Details,Sklad Podrobnosti,
Customer Warehouse (Optional),Zákaznický sklad (volitelně),
Available Batch Qty at Warehouse,K dispozici šarže Množství ve skladu,
Available Qty at Warehouse,Množství k dispozici na skladu,
Delivery Note Item,Delivery Note Item,
Base Amount (Company Currency),Základna Částka (Company měna),
Sales Invoice Timesheet,Prodejní faktury časový rozvrh,
Time Sheet,Rozvrh hodin,
Billing Hours,Billing Hodiny,
Timesheet Detail,časového rozvrhu Detail,
Tax Amount After Discount Amount (Company Currency),Částka daně po slevě Částka (Company měny),
Item Wise Tax Detail,Položka Wise Tax Detail,
Parenttype,Parenttype,
"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","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. \n\n #### Poznámka: \n\n 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.\n\n #### Popis sloupců \n\n 1. Výpočet Type: \n - To může být na ** Čistý Total ** (což je součet základní částky).\n - ** 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.\n - ** Aktuální ** (jak je uvedeno).\n 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat \n 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.\n 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).\n 5. Rate: Sazba daně.\n 6. Částka: Částka daně.\n 7. Celkem: Kumulativní celková k tomuto bodu.\n 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).\n 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.",
* Will be calculated in the transaction.,* Bude se vypočítá v transakci.,
From No,Od č,
To No,Ne,
Is Company,Je společnost,
Current State,Aktuální stav,
Purchased,Zakoupeno,
From Shareholder,Od akcionáře,
From Folio No,Z folia č,
To Shareholder,Akcionáři,
To Folio No,Do složky Folio č,
Equity/Liability Account,Účet vlastního kapitálu / odpovědnosti,
Asset Account,Účet aktiv,
(including),(včetně),
ACC-SH-.YYYY.-,ACC-SH-.YYYY.-,
Folio no.,Číslo folia,
Address and Contacts,Adresa a kontakty,
Contact List,Seznam kontaktů,
Hidden list maintaining the list of contacts linked to Shareholder,Skrytý seznam udržující seznam kontaktů spojených s Akcionářem,
Specify conditions to calculate shipping amount,Stanovení podmínek pro vypočítat výši poštovného,
Shipping Rule Label,Přepravní Pravidlo Label,
example: Next Day Shipping,Příklad: Next Day Shipping,
Shipping Rule Type,Typ pravidla přepravy,
Shipping Account,Přepravní účtu,
Calculate Based On,Vypočítat založené na,
Fixed,Pevný,
Net Weight,Hmotnost,
Shipping Amount,Částka - doprava,
Shipping Rule Conditions,Přepravní Článek Podmínky,
Restrict to Countries,Omezte na země,
Valid for Countries,"Platí pro země,",
Shipping Rule Condition,Přepravní Pravidlo Podmínka,
A condition for a Shipping Rule,Podmínka pro pravidla dopravy,
From Value,Od hodnoty,
To Value,Chcete-li hodnota,
Shipping Rule Country,Přepravní Pravidlo Země,
Subscription Period,Období předplatného,
Subscription Start Date,Datum zahájení předplatného,
Cancelation Date,Datum zrušení,
Trial Period Start Date,Datum zahájení zkušebního období,
Trial Period End Date,Datum ukončení zkušebního období,
Current Invoice Start Date,Aktuální datum zahájení faktury,
Current Invoice End Date,Aktuální datum ukončení faktury,
Days Until Due,Dny do splatnosti,
Number of days that the subscriber has to pay invoices generated by this subscription,"Počet dní, které musí účastník platit faktury generované tímto odběrem",
Cancel At End Of Period,Zrušit na konci období,
Generate Invoice At Beginning Of Period,Generovat fakturu na začátku období,
Plans,Plány,
Discounts,Slevy,
Additional DIscount Percentage,Další slevy Procento,
Additional DIscount Amount,Dodatečná sleva Částka,
Subscription Invoice,Předplatné faktura,
Subscription Plan,Plán předplatného,
Cost,Náklady,
Billing Interval,Interval fakturace,
Billing Interval Count,Počet fakturačních intervalů,
"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Počet intervalů pro intervalové pole, např. Pokud je interval &quot;Dny&quot; a počet fakturačních intervalů je 3, budou faktury generovány každých 3 dny",
Payment Plan,Platebni plan,
Subscription Plan Detail,Detail plánu předplatného,
Plan,Plán,
Subscription Settings,Nastavení předplatného,
Grace Period,Doba odkladu,
Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Počet dní po uplynutí data fakturace před zrušením předplatného nebo označením předplatného jako nezaplaceného,
Prorate,Prorate,
Tax Rule,Daňové Pravidlo,
Tax Type,Daňové Type,
Use for Shopping Cart,Použití pro Košík,
Billing City,Fakturace City,
Billing County,fakturace County,
Billing State,Fakturace State,
Billing Zipcode,Fakturační PSČ,
Billing Country,Fakturace Země,
Shipping City,Dodací město,
Shipping County,vodní doprava County,
Shipping State,Přepravní State,
Shipping Zipcode,Poštovní směrovací číslo,
Shipping Country,Země dodání,
Tax Withholding Account,Účet pro zadržení daně,
Tax Withholding Rates,Srážkové daně,
Rates,Ceny,
Tax Withholding Rate,Úroková sazba,
Single Transaction Threshold,Jednoduchá transakční prahová hodnota,
Cumulative Transaction Threshold,Limit kumulativní transakce,
Agriculture Analysis Criteria,Kritéria analýzy zemědělství,
Linked Doctype,Linked Doctype,
Water Analysis,Analýza vody,
Soil Analysis,Analýza půd,
Plant Analysis,Analýza rostlin,
Fertilizer,Hnojivo,
Soil Texture,Půdní textury,
Weather,Počasí,
Agriculture Manager,Zemědělský manažer,
Agriculture User,Zemědělský uživatel,
Agriculture Task,Zemědělské úkoly,
Task Name,Jméno Task,
Start Day,Den zahájení,
End Day,Den konce,
Holiday Management,Správa prázdnin,
Ignore holidays,Ignorovat svátky,
Previous Business Day,Předchozí pracovní den,
Next Business Day,Následující pracovní den,
Urgent,Naléhavý,
Crop,Oříznutí,
Crop Name,Název plodiny,
Scientific Name,Odborný název,
"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Můžete definovat všechny úkoly, které je třeba provést pro tuto plodinu zde. Denní pole se používá k uvedení den, kdy má být úkol proveden, 1 je 1. den atd.",
Crop Spacing,Rozdělení oříznutí,
Crop Spacing UOM,Rozdělení výsevních ploch UOM,
Row Spacing,Rozteč řádků,
Row Spacing UOM,Rozložení řádků UOM,
Perennial,Trvalka,
Biennial,Dvouletý,
Planting UOM,Výsadba UOM,
Planting Area,Plocha pro výsadbu,
Yield UOM,Výnos UOM,
Materials Required,Potřebné materiály,
Produced Items,Vyrobené položky,
Produce,Vyrobit,
Byproducts,Vedlejší produkty,
Linked Location,Linked Location,
A link to all the Locations in which the Crop is growing,"Odkaz na všechna místa, ve kterých rostou rostliny",
This will be day 1 of the crop cycle,Bude to první den cyklu plodin,
ISO 8601 standard,Norma ISO 8601,
Cycle Type,Typ cyklu,
Less than a year,Méně než rok,
The minimum length between each plant in the field for optimum growth,Minimální délka mezi jednotlivými rostlinami v terénu pro optimální růst,
The minimum distance between rows of plants for optimum growth,Minimální vzdálenost mezi řadami rostlin pro optimální růst,
Detected Diseases,Zjištěné nemoci,
List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Seznam onemocnění zjištěných v terénu. Když je vybráno, automaticky přidá seznam úkolů, které se mají vypořádat s tímto onemocněním",
Detected Disease,Zjištěná nemoc,
LInked Analysis,Llnked Analysis,
Disease,Choroba,
Tasks Created,Úkoly byly vytvořeny,
Common Name,Běžné jméno,
Treatment Task,Úloha léčby,
Treatment Period,Doba léčby,
Fertilizer Name,Jméno hnojiva,
Density (if liquid),Hustota (pokud je kapalina),
Fertilizer Contents,Obsah hnojiv,
Fertilizer Content,Obsah hnojiv,
Linked Plant Analysis,Analýza propojených rostlin,
Linked Soil Analysis,Analýza propojené půdy,
Linked Soil Texture,Spojená půdní struktura,
Collection Datetime,Čas odběru,
Laboratory Testing Datetime,Laboratorní testování Datetime,
Result Datetime,Výsledek Datetime,
Plant Analysis Criterias,Kritéria analýzy rostlin,
Plant Analysis Criteria,Kritéria analýzy rostlin,
Minimum Permissible Value,Minimální přípustná hodnota,
Maximum Permissible Value,Maximální přípustná hodnota,
Ca/K,Ca / K,
Ca/Mg,Ca / Mg,
Mg/K,Mg / K,
(Ca+Mg)/K,(Ca + Mg) / K,
Ca/(K+Ca+Mg),Ca / (K + Ca + Mg),
Soil Analysis Criterias,Kritéria analýzy půdy,
Soil Analysis Criteria,Kritéria analýzy půdy,
Soil Type,Typ půdy,
Loamy Sand,Loamy Sand,
Sandy Loam,Sandy Loam,
Loam,Hlína,
Silt Loam,Silt Loam,
Sandy Clay Loam,Sandy Clay Loam,
Clay Loam,Clay Loam,
Silty Clay Loam,Silty Clay Loam,
Sandy Clay,Sandy Clay,
Silty Clay,Silty Clay,
Clay Composition (%),Složení jílů (%),
Sand Composition (%),Složení písku (%),
Silt Composition (%),Složené složení (%),
Ternary Plot,Ternary Plot,
Soil Texture Criteria,Kritéria textury půdy,
Type of Sample,Typ vzorku,
Container,Kontejner,
Origin,Původ,
Collection Temperature ,Teplota sběru,
Storage Temperature,Skladovací teplota,
Appearance,Vzhled,
Person Responsible,Zodpovědná osoba,
Water Analysis Criteria,Kritéria analýzy vody,
Weather Parameter,Parametr počasí,
ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
Asset Owner,Majitel majetku,
Asset Owner Company,Společnost vlastníků aktiv,
Custodian,Depozitář,
Disposal Date,Likvidace Datum,
Journal Entry for Scrap,Zápis do deníku do šrotu,
Available-for-use Date,Datum k dispozici,
Calculate Depreciation,Vypočítat odpisy,
Allow Monthly Depreciation,Povolit měsíční odpisy,
Number of Depreciations Booked,Počet Odpisy rezervováno,
Finance Books,Finanční knihy,
Straight Line,Přímka,
Double Declining Balance,Double degresivní,
Manual,Manuál,
Value After Depreciation,Hodnota po odpisech,
Total Number of Depreciations,Celkový počet Odpisy,
Frequency of Depreciation (Months),Frekvence odpisy (měsíce),
Next Depreciation Date,Vedle Odpisy Datum,
Depreciation Schedule,Plán odpisy,
Depreciation Schedules,odpisy Plány,
Insurance details,Podrobnosti o pojištění,
Policy number,Číslo politiky,
Insurer,Pojišťovatel,
Insured value,Pojistná hodnota,
Insurance Start Date,Datum zahájení pojištění,
Insurance End Date,Datum ukončení pojištění,
Comprehensive Insurance,Komplexní pojištění,
Maintenance Required,Nutná údržba,
Check if Asset requires Preventive Maintenance or Calibration,"Zkontrolujte, zda majetek vyžaduje preventivní údržbu nebo kalibraci",
Booked Fixed Asset,Rezervovaný majetek,
Purchase Receipt Amount,Částka k nákupu,
Default Finance Book,Výchozí finanční kniha,
Quality Manager,Manažer kvality,
Asset Category Name,Asset název kategorie,
Depreciation Options,Možnosti odpisů,
Enable Capital Work in Progress Accounting,Povolit kapitálové práce v účetnictví,
Finance Book Detail,Detail knihy financí,
Asset Category Account,Asset Kategorie Account,
Fixed Asset Account,Fixed Asset Account,
Accumulated Depreciation Account,Účet oprávek,
Depreciation Expense Account,Odpisy Náklady účtu,
Capital Work In Progress Account,Pokročilý účet kapitálové práce,
Asset Finance Book,Finanční kniha majetku,
Written Down Value,Psaná hodnota dolů,
Expected Value After Useful Life,Očekávaná hodnota po celou dobu životnosti,
Rate of Depreciation,Míra odpisování,
In Percentage,V procentech,
Maintenance Team,Tým údržby,
Maintenance Manager Name,Název správce údržby,
Maintenance Tasks,Úkoly údržby,
Manufacturing User,Výroba Uživatel,
Asset Maintenance Log,Protokol o údržbě aktiv,
ACC-AML-.YYYY.-,ACC-AML-.RRRR.-,
Maintenance Type,Typ Maintenance,
Maintenance Status,Status Maintenance,
Planned,Plánováno,
Has Certificate ,Má certifikát,
Certificate,Osvědčení,
Actions performed,Akce byly provedeny,
Asset Maintenance Task,Úloha údržby aktiv,
Maintenance Task,Úloha údržby,
Preventive Maintenance,Preventivní údržba,
Calibration,Kalibrace,
2 Yearly,2 Každoročně,
Certificate Required,Potřebný certifikát,
Assign to Name,Přiřadit ke jménu,
Next Due Date,Další datum splatnosti,
Last Completion Date,Poslední datum dokončení,
Asset Maintenance Team,Tým pro údržbu aktiv,
Maintenance Team Name,Název týmu údržby,
Maintenance Team Members,Členové týmu údržby,
Purpose,Účel,
Stock Manager,Reklamní manažer,
Asset Movement Item,Pohyb položky,
Source Location,Umístění zdroje,
From Employee,Od Zaměstnance,
Target Location,Cílová lokace,
To Employee,Zaměstnanci,
Asset Repair,Opravy aktiv,
ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
Failure Date,Datum selhání,
Assign To Name,Přiřaďte k názvu,
Repair Status,Stav opravy,
Error Description,Popis chyby,
Downtime,Nefunkčnost,
Repair Cost,náklady na opravu,
Manufacturing Manager,Výrobní ředitel,
Current Asset Value,Aktuální hodnota aktiv,
New Asset Value,Nová hodnota aktiv,
Make Depreciation Entry,Udělat Odpisy Entry,
Finance Book Id,Identifikační číslo finanční knihy,
Location Name,Název umístění,
Parent Location,Umístění rodiče,
Is Container,Je kontejner,
Check if it is a hydroponic unit,"Zkontrolujte, zda jde o hydroponickou jednotku",
Location Details,Podrobnosti o poloze,
Latitude,Zeměpisná šířka,
Longitude,Zeměpisná délka,
Area,Plocha,
Area UOM,Oblast UOM,
Tree Details,Tree Podrobnosti,
Maintenance Team Member,Člen týmu údržby,
Team Member,Člen týmu,
Maintenance Role,Úloha údržby,
Buying Settings,Nákup Nastavení,
Settings for Buying Module,Nastavení pro nákup modul,
Supplier Naming By,Dodavatel Pojmenování By,
Default Supplier Group,Výchozí skupina dodavatelů,
Default Buying Price List,Výchozí Nákup Ceník,
Maintain same rate throughout purchase cycle,Udržovat stejnou sazbu po celou kupní cyklu,
Allow Item to be added multiple times in a transaction,"Povolit položky, které se přidávají vícekrát v transakci",
Backflush Raw Materials of Subcontract Based On,Backflush Suroviny subdodávky založené na,
Material Transferred for Subcontract,Materiál převedený na subdodávky,
Over Transfer Allowance (%),Příspěvek na převody (%),
Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Procento, které můžete převést více oproti objednanému množství. Například: Pokud jste si objednali 100 kusů. a vaše povolenka je 10%, pak můžete převést 110 jednotek.",
PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
Get Items from Open Material Requests,Položka získaná z žádostí Otevřít Materiál,
Fetch items based on Default Supplier.,Načíst položky na základě výchozího dodavatele.,
Required By,Vyžadováno,
Order Confirmation No,Potvrzení objednávky č,
Order Confirmation Date,Datum potvrzení objednávky,
Customer Mobile No,Zákazník Mobile Žádné,
Customer Contact Email,Zákazník Kontaktní e-mail,
Set Target Warehouse,Nastavit cílový sklad,
Sets 'Warehouse' in each row of the Items table.,Nastaví „Sklad“ v každém řádku tabulky Položky.,
Supply Raw Materials,Dodávek surovin,
Purchase Order Pricing Rule,Pravidlo pro stanovení ceny objednávky,
Set Reserve Warehouse,Nastavit rezervní sklad,
In Words will be visible once you save the Purchase Order.,"Ve slovech budou viditelné, jakmile uložíte objednávce.",
Advance Paid,Vyplacené zálohy,
Tracking,Sledování,
% Billed,% Fakturováno,
% Received,% Přijaté,
Ref SQ,Ref SQ,
Inter Company Order Reference,Inter Company Reference reference,
Supplier Part Number,Dodavatel Číslo dílu,
Billed Amt,Účtovaného Amt,
Warehouse and Reference,Sklad a reference,
To be delivered to customer,Chcete-li být doručeno zákazníkovi,
Material Request Item,Materiál Žádost o bod,
Supplier Quotation Item,Dodavatel Nabídka Položka,
Against Blanket Order,Proti paušální objednávce,
Blanket Order,Dekorační objednávka,
Blanket Order Rate,Dekorační objednávka,
Returned Qty,Vrácené Množství,
Purchase Order Item Supplied,Dodané položky vydané objednávky,
BOM Detail No,BOM Detail No,
Stock Uom,Reklamní UOM,
Raw Material Item Code,Surovina Kód položky,
Supplied Qty,Dodávané Množství,
Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané,
Current Stock,Current skladem,
PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
For individual supplier,Pro jednotlivé dodavatele,
Supplier Detail,dodavatel Detail,
Link to Material Requests,Odkaz na materiálové požadavky,
Message for Supplier,Zpráva pro dodavatele,
Request for Quotation Item,Žádost o cenovou nabídku výtisku,
Required Date,Požadovaná data,
Request for Quotation Supplier,Žádost o cenovou nabídku dodavatele,
Send Email,Odeslat email,
Quote Status,Citace Stav,
Download PDF,Stáhnout PDF,
Supplier of Goods or Services.,Dodavatel zboží nebo služeb.,
Name and Type,Název a typ,
SUP-.YYYY.-,SUP-.YYYY.-,
Default Bank Account,Výchozí Bankovní účet,
Is Transporter,Je Transporter,
Represents Company,Zastupuje společnost,
Supplier Type,Dodavatel Type,
Allow Purchase Invoice Creation Without Purchase Order,Povolit vytvoření nákupní faktury bez nákupní objednávky,
Allow Purchase Invoice Creation Without Purchase Receipt,Povolit vytvoření faktury za nákup bez dokladu o nákupu,
Warn RFQs,Upozornění na RFQ,
Warn POs,Varujte PO,
Prevent RFQs,Zabraňte RFQ,
Prevent POs,Zabránit organizacím výrobců,
Billing Currency,Fakturace Měna,
Default Payment Terms Template,Výchozí šablony platebních podmínek,
Block Supplier,Zablokujte dodavatele,
Hold Type,Typ zadržení,
Leave blank if the Supplier is blocked indefinitely,"Nechte prázdné, pokud je dodavatel blokován neomezeně",
Default Payable Accounts,Výchozí úplatu účty,
Mention if non-standard payable account,Uvedete-li neštandardní splatný účet,
Default Tax Withholding Config,Výchozí nastavení zadržení daně,
Supplier Details,Dodavatele Podrobnosti,
Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel,
PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-,
Supplier Address,Dodavatel Address,
Link to material requests,Odkaz na materiálních požadavků,
Rounding Adjustment (Company Currency,Úprava zaokrouhlení (měna společnosti,
Auto Repeat Section,Sekce automatického opakování,
Is Subcontracted,Subdodavatelům,
Lead Time in days,Čas leadu ve dnech,
Supplier Score,Skóre dodavatele,
Indicator Color,Barva indikátoru,
Evaluation Period,Hodnocené období,
Per Week,Za týden,
Per Month,Za měsíc,
Per Year,Za rok,
Scoring Setup,Nastavení bodování,
Weighting Function,Funkce vážení,
"Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n","Můžete použít proměnné Scorecard, stejně jako: {total_score} (celkové skóre z tohoto období), {period_number} (počet období do současnosti)",
Scoring Standings,Hodnocení bodů,
Criteria Setup,Nastavení kritérií,
Load All Criteria,Načíst všechna kritéria,
Scoring Criteria,Kritéria hodnocení,
Scorecard Actions,Akční body Scorecard,
Warn for new Request for Quotations,Upozornit na novou žádost o nabídky,
Warn for new Purchase Orders,Upozornit na nové nákupní objednávky,
Notify Supplier,Informujte dodavatele,
Notify Employee,Upozornit zaměstnance,
Supplier Scorecard Criteria,Kritéria dodavatele skóre karty,
Criteria Name,Název kritéria,
Max Score,Maximální skóre,
Criteria Formula,Kritéria vzorce,
Criteria Weight,Kritéria Váha,
Supplier Scorecard Period,Období dodavatele skóre karty,
PU-SSP-.YYYY.-,PU-SSP-.YYYY.-,
Period Score,Skóre období,
Calculations,Výpočty,
Criteria,Kritéria,
Variables,Proměnné,
Supplier Scorecard Setup,Nastavení tabulky dodavatelů,
Supplier Scorecard Scoring Criteria,Kritéria hodnocení skóre dodavatele skóre,
Score,Skóre,
Supplier Scorecard Scoring Standing,Hodnocení skóre dodavatele skóre,
Standing Name,Stálé jméno,
Purple,Nachový,
Yellow,Žlutá,
Orange,oranžový,
Min Grade,Min Grade,
Max Grade,Max stupeň,
Warn Purchase Orders,Upozornění na nákupní objednávky,
Prevent Purchase Orders,Zabránit nákupním objednávkám,
Employee ,Zaměstnanec,
Supplier Scorecard Scoring Variable,Variabilní skóre skóre dodavatele skóre,
Variable Name,Název proměnné,
Parameter Name,Název parametru,
Supplier Scorecard Standing,Dodávka tabulky dodavatelů,
Notify Other,Upozornit ostatní,
Supplier Scorecard Variable,Variabilní ukazatel ukazatele dodavatele,
Call Log,Telefonní záznam,
Received By,Přijato,
Caller Information,Informace o volajícím,
Contact Name,Kontakt Jméno,
Lead ,Vést,
Lead Name,Jméno leadu,
Ringing,Zvoní,
Missed,Zmeškal,
Call Duration in seconds,Délka hovoru v sekundách,
Recording URL,Záznam URL,
Communication Medium,Komunikační médium,
Communication Medium Type,Typ komunikačního média,
Voice,Hlas,
Catch All,Chytit vše,
"If there is no assigned timeslot, then communication will be handled by this group","Pokud není přiřazen žádný časový interval, bude komunikace probíhat touto skupinou",
Timeslots,Timeslots,
Communication Medium Timeslot,Komunikační střední Timeslot,
Employee Group,Skupina zaměstnanců,
Appointment,Jmenování,
Scheduled Time,Naplánovaný čas,
Unverified,Neověřeno,
Customer Details,Podrobnosti zákazníků,
Phone Number,Telefonní číslo,
Skype ID,Skype ID,
Linked Documents,Propojené dokumenty,
Appointment With,Schůzka s,
Calendar Event,Událost kalendáře,
Appointment Booking Settings,Nastavení rezervace schůzek,
Enable Appointment Scheduling,Povolit plánování schůzek,
Agent Details,Podrobnosti o agentovi,
Availability Of Slots,Dostupnost slotů,
Number of Concurrent Appointments,Počet souběžných schůzek,
Agents,Agenti,
Appointment Details,Podrobnosti schůzky,
Appointment Duration (In Minutes),Trvání schůzky (v minutách),
Notify Via Email,Upozornit e-mailem,
Notify customer and agent via email on the day of the appointment.,V den schůzky informujte zákazníka a agenta e-mailem.,
Number of days appointments can be booked in advance,Počet dní schůzek si můžete rezervovat předem,
Success Settings,Nastavení úspěchu,
Success Redirect URL,Adresa URL přesměrování úspěchu,
"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Nechte prázdné pro domov. Toto je relativní k adrese URL webu, například „about“ přesměruje na „https://yoursitename.com/about“",
Appointment Booking Slots,Výherní automaty pro jmenování,
Day Of Week,Den v týdnu,
From Time ,Času od,
Campaign Email Schedule,Plán e-mailu kampaně,
Send After (days),Odeslat po (dny),
Signed,Podepsaný,
Party User,Party Uživatel,
Unsigned,Nepodepsaný,
Fulfilment Status,Stav plnění,
N/A,N / A,
Unfulfilled,Nesplněno,
Partially Fulfilled,Částečně splněno,
Fulfilled,Splnil,
Lapsed,Zrušeno,
Contract Period,Období smlouvy,
Signee Details,Signee Podrobnosti,
Signee,Signee,
Signed On,Přihlášeno,
Contract Details,Detaily smlouvy,
Contract Template,Šablona smlouvy,
Contract Terms,Smluvní podmínky,
Fulfilment Details,Úplné podrobnosti,
Requires Fulfilment,Vyžaduje plnění,
Fulfilment Deadline,Termín splnění,
Fulfilment Terms,Podmínky plnění,
Contract Fulfilment Checklist,Kontrolní seznam plnění smlouvy,
Requirement,Požadavek,
Contract Terms and Conditions,Smluvní podmínky,
Fulfilment Terms and Conditions,Smluvní podmínky,
Contract Template Fulfilment Terms,Podmínky splnění šablony smlouvy,
Email Campaign,E-mailová kampaň,
Email Campaign For ,E-mailová kampaň pro,
Lead is an Organization,Vedoucí je organizace,
CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-,
Person Name,Osoba Jméno,
Lost Quotation,ztratil Citace,
Interested,Zájemci,
Converted,Převedené,
Do Not Contact,Nekontaktujte,
From Customer,Od Zákazníka,
Campaign Name,Název kampaně,
Follow Up,Následovat,
Next Contact By,Další Kontakt By,
Next Contact Date,Další Kontakt Datum,
Ends On,Končí,
Address & Contact,Adresa a kontakt,
Mobile No.,Mobile No.,
Lead Type,Typ leadu,
Channel Partner,Channel Partner,
Consultant,Konzultant,
Market Segment,Segment trhu,
Industry,Průmysl,
Request Type,Typ požadavku,
Product Enquiry,Dotaz Product,
Request for Information,Žádost o informace,
Suggestions,Návrhy,
Blog Subscriber,Blog Subscriber,
LinkedIn Settings,Nastavení LinkedIn,
Company ID,ID společnosti,
OAuth Credentials,Pověření OAuth,
Consumer Key,Klíč spotřebitele,
Consumer Secret,Spotřebitelské tajemství,
User Details,Detaily uživatele,
Person URN,Osoba URN,
Session Status,Stav relace,
Lost Reason Detail,Detail ztraceného důvodu,
Opportunity Lost Reason,Příležitost Ztracený důvod,
Potential Sales Deal,Potenciální prodej,
CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-,
Opportunity From,Příležitost Z,
Customer / Lead Name,Zákazník / Lead Name,
Opportunity Type,Typ Příležitosti,
Converted By,Převedeno,
Sales Stage,Prodejní fáze,
Lost Reason,Důvod ztráty,
Expected Closing Date,Očekávané datum uzávěrky,
To Discuss,K projednání,
With Items,S položkami,
Probability (%),Pravděpodobnost (%),
Contact Info,Kontaktní informace,
Customer / Lead Address,Zákazník / Lead Address,
Contact Mobile No,Kontakt Mobil,
Enter name of campaign if source of enquiry is campaign,"Zadejte název kampaně, pokud zdroj šetření je kampaň",
Opportunity Date,Příležitost Datum,
Opportunity Item,Položka Příležitosti,
Basic Rate,Basic Rate,
Stage Name,Pseudonym,
Social Media Post,Sociální média příspěvek,
Post Status,Post status,
Posted,Vyslán,
Share On,Sdílet na,
Twitter,Cvrlikání,
LinkedIn,LinkedIn,
Twitter Post Id,ID příspěvku na Twitteru,
LinkedIn Post Id,LinkedIn Post Id,
Tweet,tweet,
Twitter Settings,Nastavení Twitteru,
API Secret Key,Tajný klíč API,
Term Name,termín Name,
Term Start Date,Termín Datum zahájení,
Term End Date,Termín Datum ukončení,
Academics User,akademici Uživatel,
Academic Year Name,Akademický rok Jméno,
Article,Článek,
LMS User,Uživatel LMS,
Assessment Criteria Group,Hodnotící kritéria Group,
Assessment Group Name,Název skupiny Assessment,
Parent Assessment Group,Mateřská skupina Assessment,
Assessment Name,Název Assessment,
Grading Scale,Klasifikační stupnice,
Examiner,Zkoušející,
Examiner Name,Jméno Examiner,
Supervisor,Dozorce,
Supervisor Name,Jméno Supervisor,
Evaluate,Vyhodnoťte,
Maximum Assessment Score,Maximální skóre Assessment,
Assessment Plan Criteria,Plan Assessment Criteria,
Maximum Score,Maximální skóre,
Result,Výsledek,
Total Score,Celkové skóre,
Grade,Školní známka,
Assessment Result Detail,Posuzování Detail Výsledek,
Assessment Result Tool,Assessment Tool Výsledek,
Result HTML,výsledek HTML,
Content Activity,Obsahová aktivita,
Last Activity ,poslední aktivita,
Content Question,Obsahová otázka,
Question Link,Odkaz na dotaz,
Course Name,Název kurzu,
Topics,Témata,
Hero Image,Obrázek hrdiny,
Default Grading Scale,Výchozí Klasifikační stupnice,
Education Manager,Správce vzdělávání,
Course Activity,Aktivita kurzu,
Course Enrollment,Zápis do kurzu,
Activity Date,Datum aktivity,
Course Assessment Criteria,Hodnotící kritéria hřiště,
Weightage,Weightage,
Course Content,Obsah kurzu,
Quiz,Kviz,
Program Enrollment,Registrace do programu,
Enrollment Date,zápis Datum,
Instructor Name,instruktor Name,
EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-,
Course Scheduling Tool,Samozřejmě Plánování Tool,
Course Start Date,Začátek Samozřejmě Datum,
To TIme,Chcete-li čas,
Course End Date,Konec Samozřejmě Datum,
Course Topic,Téma kurzu,
Topic,Téma,
Topic Name,Název tématu,
Education Settings,Nastavení vzdělávání,
Current Academic Year,Aktuální akademický rok,
Current Academic Term,Aktuální akademické označení,
Attendance Freeze Date,Datum ukončení účasti,
Validate Batch for Students in Student Group,Ověřit dávku pro studenty ve skupině studentů,
"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Pro dávkovou studentskou skupinu bude studentská dávka ověřena pro každého studenta ze zápisu do programu.,
Validate Enrolled Course for Students in Student Group,Ověřte zapsaný kurz pro studenty ve skupině studentů,
"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Pro kurzovou studentskou skupinu bude kurz pro každého studenta ověřen z přihlášených kurzů při zápisu do programu.,
Make Academic Term Mandatory,Uveďte povinnost akademického termínu,
"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Je-li zapnuto, pole Akademický termín bude povinné v nástroji pro zápis programu.",
Skip User creation for new Student,Přeskočit vytváření uživatelů pro nového studenta,
"By default, a new User is created for every new Student. If enabled, no new User will be created when a new Student is created.","Ve výchozím nastavení je pro každého nového studenta vytvořen nový uživatel. Pokud je povoleno, při vytváření nového studenta nebude vytvořen žádný nový uživatel.",
Instructor Records to be created by,"Záznamy instruktorů, které mají být vytvořeny",
Employee Number,Počet zaměstnanců,
Fee Category,poplatek Kategorie,
Fee Component,poplatek Component,
Fees Category,Kategorie poplatky,
Fee Schedule,poplatek Plán,
Fee Structure,Struktura poplatků,
EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
Fee Creation Status,Stav tvorby poplatků,
In Process,V procesu,
Send Payment Request Email,Odeslat e-mail s žádostí o platbu,
Student Category,Student Kategorie,
Fee Breakup for each student,Rozdělení poplatků za každého studenta,
Total Amount per Student,Celková částka na jednoho studenta,
Institution,Instituce,
Fee Schedule Program,Program rozpisu poplatků,
Student Batch,Student Batch,
Total Students,Celkem studentů,
Fee Schedule Student Group,Poplatek za studentskou skupinu,
EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
EDU-FEE-.YYYY.-,EDU-FEE-.RRRR.-,
Include Payment,Zahrnout platbu,
Send Payment Request,Odeslat žádost o platbu,
Student Details,Podrobnosti studenta,
Student Email,Studentský e-mail,
Grading Scale Name,Klasifikační stupnice Name,
Grading Scale Intervals,Třídění dílků,
Intervals,intervaly,
Grading Scale Interval,Klasifikační stupnice Interval,
Grade Code,Grade Code,
Threshold,Práh,
Grade Description,Grade Popis,
Guardian,poručník,
Guardian Name,Jméno Guardian,
Alternate Number,Alternativní Number,
Occupation,Povolání,
Work Address,pracovní adresa,
Guardian Of ,strážce,
Students,studenti,
Guardian Interests,Guardian Zájmy,
Guardian Interest,Guardian Zájem,
Interest,Zajímat,
Guardian Student,Guardian Student,
EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
Instructor Log,Příručka instruktora,
Other details,Další podrobnosti,
Option,Volba,
Is Correct,Je správně,
Program Name,Název programu,
Program Abbreviation,Program Zkratka,
Courses,předměty,
Is Published,Je publikováno,
Allow Self Enroll,Povolit vlastní registraci,
Is Featured,Je doporučeno,
Intro Video,Úvodní video,
Program Course,Program kurzu,
School House,School House,
Boarding Student,Stravující student,
Check this if the Student is residing at the Institute's Hostel.,"Zkontrolujte, zda student bydlí v Hostelu ústavu.",
Walking,Chůze,
Institute's Bus,Autobus ústavu,
Public Transport,Veřejná doprava,
Self-Driving Vehicle,Samohybné vozidlo,
Pick/Drop by Guardian,Pick / Drop od Guardian,
Enrolled courses,Zapsané kurzy,
Program Enrollment Course,Program pro zápis do programu,
Program Enrollment Fee,Program zápisné,
Program Enrollment Tool,Program Tool zápis,
Get Students From,Získat studenty z,
Student Applicant,Student Žadatel,
Get Students,Získat studenty,
Enrollment Details,Podrobnosti o zápisu,
New Program,nový program,
New Student Batch,Nová studentská dávka,
Enroll Students,zapsat studenti,
New Academic Year,Nový akademický rok,
New Academic Term,Nový akademický termín,
Program Enrollment Tool Student,Registrace do programu Student Tool,
Student Batch Name,Student Batch Name,
Program Fee,Program Fee,
Question,Otázka,
Single Correct Answer,Jedna správná odpověď,
Multiple Correct Answer,Více správných odpovědí,
Quiz Configuration,Konfigurace kvízu,
Passing Score,Úspěšné skóre,
Score out of 100,Skóre ze 100,
Max Attempts,Max Pokusy,
Enter 0 to waive limit,"Chcete-li se vzdát limitu, zadejte 0",
Grading Basis,Základ klasifikace,
Latest Highest Score,Nejnovější nejvyšší skóre,
Latest Attempt,Poslední pokus,
Quiz Activity,Kvízová aktivita,
Enrollment,Zápis,
Pass,Složit,
Quiz Question,Kvízová otázka,
Quiz Result,Výsledek testu,
Selected Option,Vybraná možnost,
Correct,Opravit,
Wrong,Špatně,
Room Name,Room Jméno,
Room Number,Číslo pokoje,
Seating Capacity,Počet míst k sezení,
House Name,Jméno dům,
EDU-STU-.YYYY.-,EDU-STU-.YYYY.-,
Student Mobile Number,Student Číslo mobilního telefonu,
Joining Date,Datum připojení,
Blood Group,Krevní Skupina,
A+,A+,
A-,A-,
B+,B +,
B-,B-,
O+,O +,
O-,Ó-,
AB+,AB+,
AB-,AB-,
Nationality,Národnost,
Home Address,Domácí adresa,
Guardian Details,Guardian Podrobnosti,
Guardians,Guardians,
Sibling Details,sourozenec Podrobnosti,
Siblings,sourozenci,
Exit,Východ,
Date of Leaving,Datem odchodu,
Leaving Certificate Number,Vysvědčení číslo,
Reason For Leaving,Důvod k odchodu,
Student Admission,Student Vstupné,
Admission Start Date,Vstupné Datum zahájení,
Admission End Date,Vstupné Datum ukončení,
Publish on website,Publikovat na webových stránkách,
Eligibility and Details,Způsobilost a podrobnosti,
Student Admission Program,Studentský přijímací program,
Minimum Age,Minimální věk,
Maximum Age,Maximální věk,
Application Fee,poplatek za podání žádosti,
Naming Series (for Student Applicant),Pojmenování Series (pro studentské přihlašovatel),
LMS Only,Pouze LMS,
EDU-APP-.YYYY.-,EDU-APP-.YYYY.-,
Application Status,Stav aplikace,
Application Date,aplikace Datum,
Student Attendance Tool,Student Účast Tool,
Group Based On,Skupina založená na,
Students HTML,studenti HTML,
Group Based on,Skupina založená na,
Student Group Name,Jméno Student Group,
Max Strength,Max Síla,
Set 0 for no limit,Nastavte 0 pro žádný limit,
Instructors,instruktoři,
Student Group Creation Tool,Student Group Tool Creation,
Leave blank if you make students groups per year,"Nechte prázdné, pokud rodíte studentské skupiny ročně",
Get Courses,Získat kurzy,
Separate course based Group for every Batch,Samostatná skupina založená na kurzu pro každou dávku,
Leave unchecked if you don't want to consider batch while making course based groups. ,"Ponechte nekontrolované, pokud nechcete dávat pozor na dávku při sestavování kurzových skupin.",
Student Group Creation Tool Course,Student Group Creation Tool hřiště,
Course Code,Kód předmětu,
Student Group Instructor,Instruktor skupiny studentů,
Student Group Student,Student Skupina Student,
Group Roll Number,Číslo role skupiny,
Student Guardian,Student Guardian,
Relation,Vztah,
Mother,Matka,
Father,Otec,
Student Language,Student Language,
Student Leave Application,Student nechat aplikaci,
Mark as Present,Označit jako dárek,
Student Log,Student Log,
Academic,Akademický,
Achievement,Úspěch,
Student Report Generation Tool,Nástroj pro generování zpráv studentů,
Include All Assessment Group,Zahrnout celou skupinu hodnocení,
Show Marks,Zobrazit značky,
Add letterhead,Přidat hlavičkový papír,
Print Section,Sekce tisku,
Total Parents Teacher Meeting,Celkové setkání učitelů rodičů,
Attended by Parents,Zúčastnili se rodiče,
Assessment Terms,Podmínky hodnocení,
Student Sibling,Student Sourozenec,
Studying in Same Institute,Studium se ve stejném ústavu,
NO,NE,
YES,ANO,
Student Siblings,Studentské Sourozenci,
Topic Content,Obsah tématu,
Amazon MWS Settings,Amazon MWS Nastavení,
ERPNext Integrations,ERPNext Integrace,
Enable Amazon,Povolit službu Amazon,
MWS Credentials,MWS pověření,
Seller ID,ID prodávajícího,
AWS Access Key ID,Identifikátor přístupového klíče AWS,
MWS Auth Token,MWS Auth Token,
Market Place ID,ID místa na trhu,
AE,AE,
AU,AU,
BR,BR,
CA,CA,
CN,CN,
DE,DE,
ES,ES,
FR,FR,
IN,V,
JP,JP,
IT,TO,
MX,MX,
UK,Spojené království,
US,NÁS,
Customer Type,Typ zákazníka,
Market Place Account Group,Skupina účtů na trhu,
After Date,Po datu,
Amazon will synch data updated after this date,Amazon bude synchronizovat data aktualizovaná po tomto datu,
Sync Taxes and Charges,Synchronizujte daně a poplatky,
Get financial breakup of Taxes and charges data by Amazon ,Získejte finanční rozdělení údajů o daních a poplatcích od společnosti Amazon,
Sync Products,Synchronizovat produkty,
Always sync your products from Amazon MWS before synching the Orders details,Před synchronizací podrobností objednávek vždy synchronizujte své produkty z Amazon MWS,
Sync Orders,Synchronizovat objednávky,
Click this button to pull your Sales Order data from Amazon MWS.,Kliknutím na toto tlačítko vygenerujete údaje o prodejní objednávce z Amazon MWS.,
Enable Scheduled Sync,Povolit naplánovanou synchronizaci,
Check this to enable a scheduled Daily synchronization routine via scheduler,"Zaškrtněte toto, chcete-li zapnout naplánovaný program Denní synchronizace prostřednictvím plánovače",
Max Retry Limit,Maximální limit opakování,
Exotel Settings,Nastavení Exotelu,
Account SID,SID účtu,
API Token,API Token,
GoCardless Mandate,GoCardless Mandate,
Mandate,Mandát,
GoCardless Customer,Zákazník GoCardless,
GoCardless Settings,Nastavení GoCardless,
Webhooks Secret,Webhooks Secret,
Plaid Settings,Plaid Settings,
Synchronize all accounts every hour,Synchronizujte všechny účty každou hodinu,
Plaid Client ID,Plaid Client ID,
Plaid Secret,Plaid Secret,
Plaid Environment,Plaid Environment,
sandbox,pískoviště,
development,rozvoj,
production,Výroba,
QuickBooks Migrator,Migrace QuickBooks,
Application Settings,Nastavení aplikace,
Token Endpoint,Koncový bod tokenu,
Scope,Rozsah,
Authorization Settings,Nastavení oprávnění,
Authorization Endpoint,Autorizační koncový bod,
Authorization URL,Autorizační adresa URL,
Quickbooks Company ID,Identifikační čísla společnosti Quickbooks,
Company Settings,Nastavení firmy,
Default Shipping Account,Výchozí poštovní účet,
Default Warehouse,Výchozí sklad,
Default Cost Center,Výchozí Center Náklady,
Undeposited Funds Account,Účet neukladaných prostředků,
Shopify Log,Shopify Přihlásit,
Request Data,Žádost o údaje,
Shopify Settings,Shopify Nastavení,
status html,status html,
Enable Shopify,Povolit funkci Shopify,
App Type,Typ aplikace,
Last Sync Datetime,Poslední datum synchronizace,
Shop URL,Adresa URL obchodu,
eg: frappe.myshopify.com,např .: frappe.myshopify.com,
Shared secret,Sdílené tajemství,
Webhooks Details,Webhooks Podrobnosti,
Webhooks,Webhooks,
Customer Settings,Nastavení zákazníka,
Default Customer,Výchozí zákazník,
Customer Group will set to selected group while syncing customers from Shopify,Zákaznická skupina nastaví vybranou skupinu při synchronizaci zákazníků se službou Shopify,
For Company,Pro Společnost,
Cash Account will used for Sales Invoice creation,Hotovostní účet bude použit pro vytvoření faktury,
Update Price from Shopify To ERPNext Price List,Aktualizovat cenu z Shopify do ERPNext Ceník,
Default Warehouse to to create Sales Order and Delivery Note,Výchozí skladiště pro vytvoření objednávky prodeje a doručení,
Sales Order Series,Série objednávek,
Import Delivery Notes from Shopify on Shipment,Importovat doručovací poznámky z Shopify při odeslání,
Delivery Note Series,Série dodacích poznámek,
Import Sales Invoice from Shopify if Payment is marked,"Import faktury z Shopify, pokud je platba označena",
Sales Invoice Series,Série faktur,
Shopify Tax Account,Nakupujte daňový účet,
Shopify Tax/Shipping Title,Nakupujte daňový / lodní titul,
ERPNext Account,ERPN další účet,
Shopify Webhook Detail,Nakupujte podrobnosti o Webhooku,
Webhook ID,Webhook ID,
Tally Migration,Tally Migration,
Master Data,Hlavní data,
"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Data exportovaná z Tally, která se skládá z účtové osnovy, zákazníků, dodavatelů, adres, položek a MJ",
Is Master Data Processed,Zpracovává se kmenová data,
Is Master Data Imported,Jsou importována kmenová data,
Tally Creditors Account,Účet věřitelů,
Creditors Account set in Tally,Účet věřitelů nastavený v Tally,
Tally Debtors Account,Účet Tally dlužníků,
Debtors Account set in Tally,Účet dlužníků nastavený v Tally,
Tally Company,Společnost Tally,
Company Name as per Imported Tally Data,Název společnosti podle importovaných údajů o shodě,
Default UOM,Výchozí MOM,
UOM in case unspecified in imported data,MJ v případě nespecifikovaných v importovaných datech,
ERPNext Company,ERPDext Company,
Your Company set in ERPNext,Vaše společnost nastavena v ERPNext,
Processed Files,Zpracované soubory,
Parties,Strany,
UOMs,UOMs,
Vouchers,Poukazy,
Round Off Account,Zaokrouhlovací účet,
Day Book Data,Údaje o denní knize,
Day Book Data exported from Tally that consists of all historic transactions,"Data denní knihy exportovaná z Tally, která se skládají ze všech historických transakcí",
Is Day Book Data Processed,Zpracovávají se údaje o denní knize,
Is Day Book Data Imported,Jsou importována data denní knihy,
Woocommerce Settings,Nastavení Woocommerce,
Enable Sync,Povolit synchronizaci,
Woocommerce Server URL,Woocommerce URL serveru,
Secret,Tajný,
API consumer key,API spotřebitelský klíč,
API consumer secret,API spotřebitelské tajemství,
Tax Account,Daňový účet,
Freight and Forwarding Account,Účet přepravy a zasílání,
Creation User,Uživatel stvoření,
"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Uživatel, který bude použit k vytvoření zákazníků, položek a prodejních objednávek. Tento uživatel by měl mít příslušná oprávnění.",
"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Tento sklad bude použit k vytvoření prodejních objednávek. Rezervní sklad je „Obchody“.,
"The fallback series is ""SO-WOO-"".",Záložní řada je „SO-WOO-“.,
This company will be used to create Sales Orders.,Tato společnost bude použita k vytváření prodejních objednávek.,
Delivery After (Days),Dodávka po (dny),
This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Toto je výchozí offset (dny) pro datum dodání v prodejních objednávkách. Náhradní kompenzace je 7 dní od data zadání objednávky.,
"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Toto je výchozí UOM používané pro položky a prodejní objednávky. Záložní UOM je „Nos“.,
Endpoints,Koncové body,
Endpoint,Konečný bod,
Antibiotic Name,Název antibiotika,
Healthcare Administrator,Správce zdravotní péče,
Laboratory User,Laboratorní uživatel,
Is Inpatient,Je hospitalizován,
Default Duration (In Minutes),Výchozí doba trvání (v minutách),
Body Part,Část těla,
Body Part Link,Odkaz na část těla,
HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-,
Procedure Template,Šablona postupu,
Procedure Prescription,Předepsaný postup,
Service Unit,Servisní jednotka,
Consumables,Spotřební materiál,
Consume Stock,Spotřeba zásob,
Invoice Consumables Separately,Spotřební materiál na fakturu zvlášť,
Consumption Invoiced,Spotřeba fakturována,
Consumable Total Amount,Celková spotřební částka,
Consumption Details,Údaje o spotřebě,
Nursing User,Ošetřujícího uživatele,
Clinical Procedure Item,Položka klinické procedury,
Invoice Separately as Consumables,Faktury samostatně jako spotřební materiál,
Transfer Qty,Množství přenosu,
Actual Qty (at source/target),Skutečné množství (u zdroje/cíle),
Is Billable,Je fakturován,
Allow Stock Consumption,Povolit skladovou spotřebu,
Sample UOM,Ukázka MOM,
Collection Details,Podrobnosti o kolekci,
Change In Item,Změna v položce,
Codification Table,Kodifikační tabulka,
Complaints,Stížnosti,
Dosage Strength,Síla dávkování,
Strength,Síla,
Drug Prescription,Předepisování léků,
Drug Name / Description,Název / popis léčiva,
Dosage,Dávkování,
Dosage by Time Interval,Dávkování podle časového intervalu,
Interval,Interval,
Interval UOM,Interval UOM,
Hour,Hodina,
Update Schedule,Aktualizovat plán,
Exercise,Cvičení,
Difficulty Level,Stupeň obtížnosti,
Counts Target,Počítá cíl,
Counts Completed,Počty byly dokončeny,
Assistance Level,Úroveň pomoci,
Active Assist,Aktivní asistence,
Exercise Name,Název cvičení,
Body Parts,Části těla,
Exercise Instructions,Pokyny ke cvičení,
Exercise Video,Cvičební video,
Exercise Steps,Cvičení,
Steps,Kroky,
Steps Table,Tabulka kroků,
Exercise Type Step,Krok typu cvičení,
Max number of visit,Maximální počet návštěv,
Visited yet,Ještě navštěvováno,
Reference Appointments,Referenční schůzky,
Valid till,Platný do,
Fee Validity Reference,Odkaz na platnost poplatku,
Basic Details,Základní podrobnosti,
HLC-PRAC-.YYYY.-,HLC-PRAC-.RRRR.-,
Mobile,"mobilní, pohybliví",
Phone (R),Telefon (R),
Phone (Office),Telefon (kancelář),
Employee and User Details,Podrobnosti o zaměstnanci a uživateli,
Hospital,NEMOCNICE,
Appointments,Setkání,
Practitioner Schedules,Pracovník plánuje,
Charges,Poplatky,
Out Patient Consulting Charge,Poplatek za konzultaci s pacientem,
Default Currency,Výchozí měna,
Healthcare Schedule Time Slot,Časový plán časového plánu pro zdravotní péči,
Parent Service Unit,Rodičovská služba,
Service Unit Type,Typ servisní jednotky,
Allow Appointments,Povolit schůzky,
Allow Overlap,Povolit překrytí,
Inpatient Occupancy,Lůžková obsazenost,
Occupancy Status,Stav obsazení,
Vacant,Volný,
Occupied,Obsazený,
Item Details,Položka Podrobnosti,
UOM Conversion in Hours,Převod UOM v hodinách,
Rate / UOM,Rate / UOM,
Change in Item,Změna položky,
Out Patient Settings,Out Nastavení pacienta,
Patient Name By,Jméno pacienta,
Patient Name,Jméno pacienta,
Link Customer to Patient,Propojte zákazníka s pacientem,
"If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Pokud je zaškrtnuto, vytvoří se zákazník, mapovaný na pacienta. Faktury pacientů budou vytvořeny proti tomuto zákazníkovi. Při vytváření pacienta můžete také vybrat existujícího zákazníka.",
Default Medical Code Standard,Výchozí standard zdravotnického kódu,
Collect Fee for Patient Registration,Vybírat poplatek za registraci pacienta,
Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,Zaškrtnutí tohoto políčka ve výchozím nastavení vytvoří nové pacienty se zdravotním stavem a bude povoleno až po fakturaci registračního poplatku.,
Registration Fee,Registrační poplatek,
Automate Appointment Invoicing,Automatizujte fakturaci schůzky,
Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Správa faktury při odeslání a automatické zrušení faktury pro setkání pacienta,
Enable Free Follow-ups,Povolit bezplatná následná opatření,
Number of Patient Encounters in Valid Days,Počet setkání pacientů v platné dny,
The number of free follow ups (Patient Encounters in valid days) allowed,Počet povolených bezplatných následných sledování (setkání pacientů v platných dnech),
Valid Number of Days,Platný počet dnů,
Time period (Valid number of days) for free consultations,Časové období (platný počet dní) pro bezplatné konzultace,
Default Healthcare Service Items,Výchozí položky zdravotní péče,
"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Můžete nakonfigurovat výchozí položky pro poplatky za fakturaci za konzultace, položky spotřeby procedur a návštěvy hospitalizovaných pacientů",
Clinical Procedure Consumable Item,Klinický postup Spotřební materiál,
Default Accounts,Výchozí účty,
Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Standardní účty příjmů, které se použijí, pokud nejsou stanoveny ve zdravotnickém lékaři ke vyúčtování poplatků za schůzku.",
Default receivable accounts to be used to book Appointment charges.,"Výchozí účty pohledávek, které se mají použít k účtování poplatků za schůzku.",
Out Patient SMS Alerts,Upozornění na upozornění pacienta,
Patient Registration,Registrace pacienta,
Registration Message,Registrační zpráva,
Confirmation Message,Potvrzovací zpráva,
Avoid Confirmation,Vyhněte se potvrzení,
Do not confirm if appointment is created for the same day,"Nepotvrzujte, zda je událost vytvořena ve stejný den",
Appointment Reminder,Připomenutí pro jmenování,
Reminder Message,Připomenutí zprávy,
Remind Before,Připomenout dříve,
Laboratory Settings,Laboratorní nastavení,
Create Lab Test(s) on Sales Invoice Submission,Vytvořte laboratorní testy pro odeslání prodejní faktury,
Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,Zaškrtnutím této položky se při odeslání vytvoří laboratorní testy uvedené v prodejní faktuře.,
Create Sample Collection document for Lab Test,Vytvořte dokument Sample Collection pro laboratorní test,
Checking this will create a Sample Collection document  every time you create a Lab Test,Zaškrtnutím této možnosti vytvoříte dokument Sample Collection při každém vytvoření laboratorního testu,
Employee name and designation in print,Jméno a označení zaměstnance v tisku,
Check this if you want the Name and Designation of the Employee associated with the User who submits the document to be printed in the Lab Test Report.,"Zaškrtněte toto, pokud chcete, aby se do protokolu o laboratorním testu vytisklo jméno a označení zaměstnance přidruženého k uživateli, který dokument odesílá.",
Do not print or email Lab Tests without Approval,Netiskněte ani neposílejte laboratorní testy e-mailem bez schválení,
Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Toto zaškrtnutí omezí tisk a zasílání e-mailů laboratorních testovacích dokumentů, pokud nemají status Schváleno.",
Custom Signature in Print,Vlastní podpis v tisku,
Laboratory SMS Alerts,Laboratorní SMS upozornění,
Result Printed Message,Výsledek Tištěná zpráva,
Result Emailed Message,Výsledek e-mailem,
Check In,Check In,
Check Out,Překontrolovat,
HLC-INP-.YYYY.-,HLC-INP-.RRRR.-,
A Positive,Pozitivní,
A Negative,Negativní,
AB Positive,AB pozitivní,
AB Negative,AB Negativní,
B Positive,B Pozitivní,
B Negative,B Negativní,
O Positive,O pozitivní,
O Negative,O Negativní,
Date of birth,Datum narození,
Admission Scheduled,Přijetí naplánováno,
Discharge Scheduled,Plnění je naplánováno,
Discharged,Vypnuto,
Admission Schedule Date,Datum příjezdu,
Admitted Datetime,Přidané datum,
Expected Discharge,Předpokládané uvolnění,
Discharge Date,Datum propuštění,
Lab Prescription,Lab Předpis,
Lab Test Name,Název laboratorního testu,
Test Created,Test byl vytvořen,
Submitted Date,Datum odeslání,
Approved Date,Datum schválení,
Sample ID,ID vzorku,
Lab Technician,Laboratorní technik,
Report Preference,Předvolba reportu,
Test Name,Testovací jméno,
Test Template,Testovací šablona,
Test Group,Testovací skupina,
Custom Result,Vlastní výsledek,
LabTest Approver,Nástroj LabTest,
Add Test,Přidat test,
Normal Range,Normální vzdálenost,
Result Format,Formát výsledků,
Single,Jednolůžkový,
Compound,Sloučenina,
Descriptive,Popisný,
Grouped,Skupinové,
No Result,Žádný výsledek,
This value is updated in the Default Sales Price List.,Tato hodnota je aktualizována v seznamu výchozích prodejních cen.,
Lab Routine,Lab Rutine,
Result Value,Výsledek Hodnota,
Require Result Value,Požadovat hodnotu výsledku,
Normal Test Template,Normální šablona testu,
Patient Demographics,Demografie pacientů,
HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-,
Middle Name (optional),Prostřední jméno (volitelné),
Inpatient Status,Stavy hospitalizace,
"If ""Link Customer to Patient"" is checked in Healthcare Settings and an existing Customer is not selected then, a Customer will be created for this Patient for recording transactions in Accounts module.","Pokud je v nastavení zdravotnictví zaškrtnuto &quot;Propojit zákazníka s pacientem&quot; a není vybrán stávající zákazník, bude pro tohoto pacienta vytvořen zákazník pro záznam transakcí v modulu Účty.",
Personal and Social History,Osobní a sociální historie,
Marital Status,Rodinný stav,
Married,Ženatý,
Divorced,Rozvedený,
Widow,Vdova,
Patient Relation,Vztah pacienta,
"Allergies, Medical and Surgical History","Alergie, lékařská a chirurgická historie",
Allergies,Alergie,
Medication,Léky,
Medical History,Zdravotní historie,
Surgical History,Chirurgická historie,
Risk Factors,Rizikové faktory,
Occupational Hazards and Environmental Factors,Pracovní nebezpečí a environmentální faktory,
Other Risk Factors,Další rizikové faktory,
Patient Details,Podrobnosti pacienta,
Additional information regarding the patient,Další informace týkající se pacienta,
HLC-APP-.YYYY.-,HLC-APP-.RRRR.-,
Patient Age,Věk pacienta,
Get Prescribed Clinical Procedures,Získejte předepsané klinické postupy,
Therapy,Terapie,
Get Prescribed Therapies,Získejte předepsané terapie,
Appointment Datetime,Datum schůzky,
Duration (In Minutes),Doba trvání (v minutách),
Reference Sales Invoice,Referenční prodejní faktura,
More Info,Více informací,
Referring Practitioner,Odvolávající se praktikant,
Reminded,Připomenuto,
HLC-PA-.YYYY.-,HLC-PA-.RRRR.-,
Assessment Template,Šablona pro hodnocení,
Assessment Datetime,Datetime posouzení,
Assessment Description,Popis posouzení,
Assessment Sheet,Hodnotící list,
Total Score Obtained,Celkové dosažené skóre,
Scale Min,Měřítko min,
Scale Max,Měřítko Max,
Patient Assessment Detail,Podrobnosti o hodnocení pacienta,
Assessment Parameter,Parametr hodnocení,
Patient Assessment Parameter,Parametr hodnocení pacienta,
Patient Assessment Sheet,List pro hodnocení pacientů,
Patient Assessment Template,Šablona pro hodnocení pacientů,
Assessment Parameters,Parametry hodnocení,
Parameters,Parametry,
Assessment Scale,Hodnotící stupnice,
Scale Minimum,Minimální měřítko,
Scale Maximum,Maximální měřítko,
HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-,
Encounter Date,Datum setkání,
Encounter Time,Čas setkání,
Encounter Impression,Setkání s impresi,
Symptoms,Příznaky,
In print,V tisku,
Medical Coding,Lékařské kódování,
Procedures,Postupy,
Therapies,Terapie,
Review Details,Podrobné informace,
Patient Encounter Diagnosis,Diagnóza setkání pacientů,
Patient Encounter Symptom,Příznak setkání pacienta,
HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-,
Attach Medical Record,Připojte lékařský záznam,
Reference DocType,Referenční DocType,
Spouse,Manželka,
Family,Rodina,
Schedule Details,Podrobnosti plánu,
Schedule Name,Název plánu,
Time Slots,Časové úseky,
Practitioner Service Unit Schedule,Pracovní služba Servisní plán,
Procedure Name,Název postupu,
Appointment Booked,Schůzka byla rezervována,
Procedure Created,Postup byl vytvořen,
HLC-SC-.YYYY.-,HLC-SC-.YYYY.-,
Collected By,Shromážděno podle,
Particulars,Podrobnosti,
Result Component,Komponent výsledků,
HLC-THP-.YYYY.-,HLC-THP-.RRRR.-,
Therapy Plan Details,Podrobnosti o terapeutickém plánu,
Total Sessions,Celkem relací,
Total Sessions Completed,Celkový počet dokončených relací,
Therapy Plan Detail,Detail terapeutického plánu,
No of Sessions,Počet relací,
Sessions Completed,Session Completed,
Tele,Tele,
Exercises,Cvičení,
Therapy For,Terapie pro,
Add Exercises,Přidejte cvičení,
Body Temperature,Tělesná teplota,
Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Přítomnost horečky (teplota&gt; 38,5 ° C nebo trvalá teplota&gt; 38 ° C / 100,4 ° F)",
Heart Rate / Pulse,Srdeční frekvence / puls,
Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Dospělý puls je v rozmezí od 50 do 80 úderů za minutu.,
Respiratory rate,Dechová frekvence,
Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normální referenční rozsah pro dospělou osobu je 16-20 dechů / minutu (RCP 2012),
Tongue,Jazyk,
Coated,Povlečené,
Very Coated,Velmi povrstvená,
Normal,Normální,
Furry,Srstnatý,
Cuts,Řezy,
Abdomen,Břicho,
Bloated,Nafouklý,
Fluid,Tekutina,
Constipated,Zácpa,
Reflexes,Reflexy,
Hyper,Hyper,
Very Hyper,Velmi Hyper,
One Sided,Jednostranné,
Blood Pressure (systolic),Krevní tlak (systolický),
Blood Pressure (diastolic),Krevní tlak (diastolický),
Blood Pressure,Krevní tlak,
"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normální klidový krevní tlak u dospělého pacienta je přibližně 120 mmHg systolický a 80 mmHg diastolický, zkráceně &quot;120/80 mmHg&quot;",
Nutrition Values,Výživové hodnoty,
Height (In Meter),Výška (v metru),
Weight (In Kilogram),Hmotnost (v kilogramech),
BMI,BMI,
Hotel Room,Hotelový pokoj,
Hotel Room Type,Typ pokoje typu Hotel,
Capacity,Kapacita,
Extra Bed Capacity,Kapacita přistýlek,
Hotel Manager,Hotelový manažer,
Hotel Room Amenity,Hotel Room Amenity,
Billable,Zúčtovatelná,
Hotel Room Package,Hotelový balíček,
Amenities,Vybavení,
Hotel Room Pricing,Ceny pokojů v hotelu,
Hotel Room Pricing Item,Položka ceny pokoje hotelu,
Hotel Room Pricing Package,Balíček ceny pokojů hotelu,
Hotel Room Reservation,Rezervace pokojů v hotelu,
Guest Name,Jméno hosta,
Late Checkin,Pozdní checkin,
Booked,Rezervováno,
Hotel Reservation User,Uživatel rezervace ubytování,
Hotel Room Reservation Item,Položka rezervace pokojů v hotelu,
Hotel Settings,Nastavení hotelu,
Default Taxes and Charges,Výchozí Daně a poplatky,
Default Invoice Naming Series,Výchozí série pojmenování faktur,
Additional Salary,Další plat,
HR,HR,
HR-ADS-.YY.-.MM.-,HR-ADS-.YY .- MM.-,
Salary Component,plat Component,
Overwrite Salary Structure Amount,Přepsat částku struktury platu,
Deduct Full Tax on Selected Payroll Date,Odečíst plnou daň z vybraného data výplatní listiny,
Payroll Date,Den mzdy,
Date on which this component is applied,Datum použití této komponenty,
Salary Slip,Výplatní páska,
Salary Component Type,Typ platového komponentu,
HR User,HR User,
Appointment Letter,Jmenovací dopis,
Job Applicant,Job Žadatel,
Applicant Name,Žadatel Název,
Appointment Date,Datum schůzky,
Appointment Letter Template,Šablona dopisu schůzky,
Body,Tělo,
Closing Notes,Závěrečné poznámky,
Appointment Letter content,Obsah dopisu o jmenování,
Appraisal,Ocenění,
HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.,
Appraisal Template,Posouzení Template,
For Employee Name,Pro jméno zaměstnance,
Goals,Cíle,
Calculate Total Score,Vypočítat Celková skóre,
Total Score (Out of 5),Celkové skóre (Out of 5),
"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.",
Appraisal Goal,Posouzení Goal,
Key Responsibility Area,Key Odpovědnost Area,
Weightage (%),Weightage (%),
Score (0-5),Score (0-5),
Score Earned,Skóre Zasloužené,
Appraisal Template Title,Posouzení Template Název,
Appraisal Template Goal,Posouzení Template Goal,
KRA,KRA,
Key Performance Area,Key Performance Area,
HR-ATT-.YYYY.-,HR-ATT-.YYYY.-,
On Leave,Na odchodu,
Work From Home,Práce z domova,
Leave Application,Požadavek na absenci,
Attendance Date,Účast Datum,
Attendance Request,Žádost o účast,
Late Entry,Pozdní vstup,
Early Exit,Předčasný odchod,
Half Day Date,Half Day Date,
On Duty,Ve službě,
Explanation,Vysvětlení,
Compensatory Leave Request,Žádost o kompenzační dovolenou,
Leave Allocation,Přidelení dovolené,
Worked On Holiday,Pracoval na dovolené,
Work From Date,Práce od data,
Work End Date,Datum ukončení práce,
Email Sent To,Email poslán,
Select Users,Vyberte možnost Uživatelé,
Send Emails At,Posílat e-maily At,
Reminder,Připomínka,
Daily Work Summary Group User,Denní uživatel shrnutí skupiny práce,
email,e-mailem,
Parent Department,Oddělení rodičů,
Leave Block List,Nechte Block List,
Days for which Holidays are blocked for this department.,"Dnů, po které Prázdniny jsou blokovány pro toto oddělení.",
Leave Approver,Schvalovatel absenece,
Expense Approver,Schvalovatel výdajů,
Department Approver,Schválení oddělení,
Approver,Schvalovatel,
Required Skills,Požadované dovednosti,
Skills,Dovednosti,
Designation Skill,Označení Dovednost,
Skill,Dovednost,
Driver,Řidič,
HR-DRI-.YYYY.-,HR-DRI-.YYYY.-,
Suspended,Pozastaveno,
Transporter,Přepravce,
Applicable for external driver,Platí pro externí ovladač,
Cellphone Number,Mobilní číslo,
License Details,Podrobnosti licence,
License Number,Číslo licence,
Issuing Date,Datum vydání,
Driving License Categories,Kategorie řidičských oprávnění,
Driving License Category,Kategorie řidičských oprávnění,
Fleet Manager,Fleet manager,
Driver licence class,Třída řidičského průkazu,
HR-EMP-,HR-EMP-,
Employment Type,Typ zaměstnání,
Emergency Contact,Kontakt v nouzi,
Emergency Contact Name,kontaktní jméno v případě nouze,
Emergency Phone,Nouzový telefon,
ERPNext User,ERPN další uživatel,
"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.",
Create User Permission,Vytvořit oprávnění uživatele,
This will restrict user access to other employee records,To bude omezovat přístup uživatelů k dalším záznamům zaměstnanců,
Joining Details,Podrobnosti spojení,
Offer Date,Nabídka Date,
Confirmation Date,Potvrzení Datum,
Contract End Date,Smlouva Datum ukončení,
Notice (days),Oznámení (dny),
Date Of Retirement,Datum odchodu do důchodu,
Department and Grade,Oddělení a stupeň,
Reports to,Zprávy,
Attendance and Leave Details,Docházka a podrobnosti o dovolené,
Leave Policy,Zanechte zásady,
Attendance Device ID (Biometric/RF tag ID),ID docházkového zařízení (Biometric / RF tag ID),
Applicable Holiday List,Použitelný Seznam Svátků,
Default Shift,Výchozí posun,
Salary Details,Podrobnosti platu,
Salary Mode,Mode Plat,
Bank A/C No.,"Č, bank. účtu",
Health Insurance,Zdravotní pojištění,
Health Insurance Provider,Poskytovatel zdravotního pojištění,
Health Insurance No,Zdravotní pojištění č,
Prefered Email,preferovaný Email,
Personal Email,Osobní e-mail,
Permanent Address Is,Trvalé bydliště je,
Rented,Pronajato,
Owned,Vlastník,
Permanent Address,Trvalé bydliště,
Prefered Contact Email,Preferovaný Kontaktní e-mail,
Company Email,Společnost E-mail,
Provide Email Address registered in company,Poskytnout e-mailovou adresu registrovanou ve firmě,
Current Address Is,Aktuální adresa je,
Current Address,Aktuální adresa,
Personal Bio,Osobní bio,
Bio / Cover Letter,Bio / krycí dopis,
Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.,
Passport Number,Číslo pasu,
Date of Issue,Datum vydání,
Place of Issue,Místo vydání,
Widowed,Ovdovělý,
Family Background,Rodinné poměry,
"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",
Health Details,Zdravotní Podrobnosti,
"Here you can maintain height, weight, allergies, medical concerns etc","Zde můžete upravovat svou výšku, váhu, alergie, zdravotní problémy atd",
Educational Qualification,Vzdělávací Kvalifikace,
Previous Work Experience,Předchozí pracovní zkušenosti,
External Work History,Vnější práce History,
History In Company,Historie ve Společnosti,
Internal Work History,Vnitřní práce History,
Resignation Letter Date,Rezignace Letter Datum,
Relieving Date,Uvolnění Datum,
Reason for Leaving,Důvod Leaving,
Leave Encashed?,Dovolená proplacena?,
Encashment Date,Inkaso Datum,
Exit Interview Details,Exit Rozhovor Podrobnosti,
Held On,Které se konalo dne,
Reason for Resignation,Důvod rezignace,
Better Prospects,Lepší vyhlídky,
Health Concerns,Zdravotní Obavy,
New Workplace,Nové pracoviště,
HR-EAD-.YYYY.-,HR-EAD-.YYYY.-,
Returned Amount,Vrácená částka,
Claimed,Reklamace,
Advance Account,Advance účet,
Employee Attendance Tool,Docházky zaměstnanců Tool,
Unmarked Attendance,Neoznačené Návštěvnost,
Employees HTML,zaměstnanci HTML,
Marked Attendance,Výrazná Návštěvnost,
Marked Attendance HTML,Výrazná Účast HTML,
Employee Benefit Application,Aplikace pro zaměstnance,
Max Benefits (Yearly),Maximální přínosy (ročně),
Remaining Benefits (Yearly),Zbývající přínosy (ročně),
Payroll Period,Mzdové období,
Benefits Applied,Využité výhody,
Dispensed Amount (Pro-rated),Vyčerpaná částka (pro-hodnocena),
Employee Benefit Application Detail,Podrobnosti o žádostech o zaměstnanecké výhody,
Earning Component,Zisková složka,
Pay Against Benefit Claim,Platba proti nároku na dávku,
Max Benefit Amount,Maximální částka prospěchu,
Employee Benefit Claim,Požadavek na zaměstnanecké požitky,
Claim Date,Datum uplatnění nároku,
Benefit Type and Amount,Typ příspěvku a částka,
Claim Benefit For,Nárok na dávku pro,
Max Amount Eligible,Maximální částka je způsobilá,
Expense Proof,Výkaz výdajů,
Employee Boarding Activity,Aktivita nástupu zaměstnanců,
Activity Name,Název aktivity,
Task Weight,úkol Hmotnost,
Required for Employee Creation,Požadováno pro vytváření zaměstnanců,
Applicable in the case of Employee Onboarding,Platí pro zaměstnance na palubě,
Employee Checkin,Kontrola zaměstnanců,
Log Type,Typ protokolu,
OUT,VEN,
Location / Device ID,Umístění / ID zařízení,
Skip Auto Attendance,Přeskočit automatickou účast,
Shift Start,Shift Start,
Shift End,Shift End,
Shift Actual Start,Shift Skutečný start,
Shift Actual End,Shift Skutečný konec,
Employee Education,Vzdělávání zaměstnanců,
School/University,Škola / University,
Graduate,Absolvent,
Post Graduate,Postgraduální,
Under Graduate,Za absolventa,
Year of Passing,Rok Passing,
Class / Percentage,Třída / Procento,
Major/Optional Subjects,Hlavní / Volitelné předměty,
Employee External Work History,Zaměstnanec vnější práce History,
Total Experience,Celková zkušenost,
Default Leave Policy,Výchozí podmínky pro dovolenou,
Default Salary Structure,Výchozí platová struktura,
Employee Group Table,Tabulka skupiny zaměstnanců,
ERPNext User ID,ERPDalší ID uživatele,
Employee Health Insurance,Zdravotní pojištění zaměstnanců,
Health Insurance Name,Název zdravotního pojištění,
Employee Incentive,Zaměstnanecká pobídka,
Incentive Amount,Část pobídky,
Employee Internal Work History,Interní historie práce zaměstnance,
Employee Onboarding,Zaměstnanec na palubě,
Notify users by email,Upozornit uživatele e-mailem,
Employee Onboarding Template,Šablona zaměstnanců na palubě,
Activities,Aktivity,
Employee Onboarding Activity,Činnost zaměstnanců na palubě,
Employee Other Income,Jiný příjem zaměstnance,
Employee Promotion,Propagace zaměstnanců,
Promotion Date,Datum propagace,
Employee Promotion Details,Podrobnosti o podpoře zaměstnanců,
Employee Promotion Detail,Podrobnosti o podpoře zaměstnanců,
Employee Property History,Historie majetku zaměstnanců,
Employee Separation,Separace zaměstnanců,
Employee Separation Template,Šablona oddělení zaměstnanců,
Exit Interview Summary,Ukončete shrnutí rozhovoru,
Employee Skill,Dovednost zaměstnanců,
Proficiency,Znalost,
Evaluation Date,Datum vyhodnocení,
Employee Skill Map,Mapa dovedností zaměstnanců,
Employee Skills,Zaměstnanecké dovednosti,
Trainings,Školení,
Employee Tax Exemption Category,Kategorie osvobození od zaměstnanců,
Max Exemption Amount,Maximální částka pro výjimku,
Employee Tax Exemption Declaration,Vyhlášení osvobození od daně z pracovních sil,
Declarations,Prohlášení,
Total Declared Amount,Celková deklarovaná částka,
Total Exemption Amount,Celková částka osvobození,
Employee Tax Exemption Declaration Category,Vyhláška o osvobození od daně z příjmů zaměstnanců,
Exemption Sub Category,Osvobození podkategorie,
Exemption Category,Kategorie výjimek,
Maximum Exempted Amount,Maximální osvobozená částka,
Declared Amount,Deklarovaná částka,
Employee Tax Exemption Proof Submission,Osvobození od daně z osvobození zaměstnanců,
Submission Date,Datum podání,
Tax Exemption Proofs,Osvědčení o osvobození od daně,
Total Actual Amount,Celková skutečná částka,
Employee Tax Exemption Proof Submission Detail,Podrobnosti o předložení dokladu o osvobození od daně z provozu zaměstnanců,
Maximum Exemption Amount,Maximální částka pro výjimku,
Type of Proof,Typ důkazu,
Actual Amount,Skutečná částka,
Employee Tax Exemption Sub Category,Osvobození od daně z příjmů zaměstnanců,
Tax Exemption Category,Kategorie osvobození od daně,
Employee Training,Školení zaměstnanců,
Training Date,Datum školení,
Employee Transfer,Zaměstnanecký převod,
Transfer Date,Datum přenosu,
Employee Transfer Details,Podrobnosti o převodu zaměstnanců,
Employee Transfer Detail,Detail pracovníka,
Re-allocate Leaves,Přidělit listy,
Create New Employee Id,Vytvořit nové číslo zaměstnance,
New Employee ID,Nové číslo zaměstnance,
Employee Transfer Property,Vlastnictví převodů zaměstnanců,
HR-EXP-.YYYY.-,HR-EXP-.RRRR.-,
Expense Taxes and Charges,Nákladové daně a poplatky,
Total Sanctioned Amount,Celková částka potrestána,
Total Advance Amount,Celková výše zálohy,
Total Claimed Amount,Celkem žalované částky,
Total Amount Reimbursed,Celkové částky proplacené,
Vehicle Log,jízd,
Employees Email Id,Zaměstnanci Email Id,
More Details,Více informací,
Expense Claim Account,Náklady na pojistná Account,
Expense Claim Advance,Nároky na úhradu nákladů,
Unclaimed amount,Nevyžádaná částka,
Expense Claim Detail,Detail úhrady výdajů,
Expense Date,Datum výdaje,
Expense Claim Type,Náklady na pojistná Type,
Holiday List Name,Název seznamu dovolené,
Total Holidays,Celkem prázdnin,
Add Weekly Holidays,Přidat týdenní prázdniny,
Weekly Off,Týdenní Off,
Add to Holidays,Přidat do svátků,
Holidays,Prázdniny,
Clear Table,Clear Table,
HR Settings,Nastavení HR,
Employee Settings,Nastavení zaměstnanců,
Retirement Age,Duchodovy vek,
Enter retirement age in years,Zadejte věk odchodu do důchodu v letech,
Employee Records to be created by,"Zaměstnanec Záznamy, které vytvořil",
Employee record is created using selected field. ,Záznam Zaměstnanec je vytvořena pomocí vybrané pole.,
Stop Birthday Reminders,Zastavit připomenutí narozenin,
Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin,
Expense Approver Mandatory In Expense Claim,Povinnost pojistitele výdajů v nárocích na výdaje,
Payroll Settings,Nastavení Mzdové,
Leave,Odejít,
Max working hours against Timesheet,Maximální pracovní doba proti časového rozvrhu,
Include holidays in Total no. of Working Days,Zahrnout dovolenou v celkovém. pracovních dní,
"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",
"If checked, hides and disables Rounded Total field in Salary Slips","Pokud je zaškrtnuto, skryje a zakáže pole Zaokrouhlený celkový počet v Salary Slips",
The fraction of daily wages to be paid for half-day attendance,Zlomek denní mzdy vyplácené za poldenní docházku,
Email Salary Slip to Employee,Email výplatní pásce pro zaměstnance,
Emails salary slip to employee based on preferred email selected in Employee,"E-maily výplatní pásce, aby zaměstnanci na základě přednostního e-mailu vybraného v zaměstnaneckých",
Encrypt Salary Slips in Emails,Zašifrujte výplatní pásky do e-mailů,
"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","E-mail s platem zaslaný zaměstnancům bude chráněn heslem, heslo bude vygenerováno na základě hesla.",
Password Policy,Zásady hesla,
<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Příklad:</b> SAL- {first_name} - {date_of_birth.year} <br> Tím se vygeneruje heslo jako SAL-Jane-1972,
Leave Settings,Ponechte nastavení,
Leave Approval Notification Template,Ponechat šablonu oznámení o schválení,
Leave Status Notification Template,Ponechat šablonu oznamování stavu,
Role Allowed to Create Backdated Leave Application,Role povolená k vytvoření aplikace s okamžitou platností,
Leave Approver Mandatory In Leave Application,Povolení odchody je povinné v aplikaci Nechat,
Show Leaves Of All Department Members In Calendar,Zobrazit listy všech členů katedry v kalendáři,
Auto Leave Encashment,Automatické ponechání inkasa,
Restrict Backdated Leave Application,Omezte aplikaci Backdated Leave,
Hiring Settings,Nastavení najímání,
Check Vacancies On Job Offer Creation,Zkontrolujte volná místa při vytváření pracovních nabídek,
Identification Document Type,Identifikační typ dokumentu,
Effective from,Platí od,
Allow Tax Exemption,Povolit osvobození od daně,
"If enabled, Tax Exemption Declaration will be considered for income tax calculation.","Pokud je tato možnost povolena, při výpočtu daně z příjmu se zohlední prohlášení o osvobození od daně.",
Standard Tax Exemption Amount,Standardní částka osvobození od daně,
Taxable Salary Slabs,Zdanitelné platové desky,
Taxes and Charges on Income Tax,Daně a poplatky z daně z příjmu,
Other Taxes and Charges,Ostatní daně a poplatky,
Income Tax Slab Other Charges,Deska daně z příjmu Další poplatky,
Min Taxable Income,Minimální zdanitelný příjem,
Max Taxable Income,Max. Zdanitelný příjem,
Applicant for a Job,Žadatel o zaměstnání,
Accepted,Přijato,
Job Opening,Job Zahájení,
Cover Letter,Průvodní dopis,
Resume Attachment,Resume Attachment,
Job Applicant Source,Zdroj žádosti o zaměstnání,
Applicant Email Address,E-mailová adresa žadatele,
Awaiting Response,Čeká odpověď,
Job Offer Terms,Podmínky nabídky práce,
Select Terms and Conditions,Vyberte Podmínky,
Printing Details,Tisk detailů,
Job Offer Term,Termín nabídky práce,
Offer Term,Nabídka Term,
Value / Description,Hodnota / Popis,
Description of a Job Opening,Popis jednoho volných pozic,
Job Title,Název pozice,
Staffing Plan,Zaměstnanecký plán,
Planned number of Positions,Plánovaný počet pozic,
"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd.",
HR-LAL-.YYYY.-,HR-LAL-.YYYY.-,
Allocation,Přidělení,
New Leaves Allocated,Nové Listy Přidělené,
Add unused leaves from previous allocations,Přidat nevyužité listy z předchozích přídělů,
Unused leaves,Nepoužité listy,
Total Leaves Allocated,Celkem Leaves Přidělené,
Total Leaves Encashed,Celkový počet listů zapuštěných,
Leave Period,Opustit období,
Carry Forwarded Leaves,Carry Předáno listy,
Apply / Approve Leaves,Použít / Schválit listy,
HR-LAP-.YYYY.-,HR-LAP-.YYYY.-,
Leave Balance Before Application,Stav absencí před požadavkem,
Total Leave Days,Celkový počet dnů dovolené,
Leave Approver Name,Jméno schvalovatele dovolené,
Follow via Email,Sledovat e-mailem,
Block Holidays on important days.,Blokové Dovolená na významných dnů.,
Leave Block List Name,Nechte Jméno Block List,
Applies to Company,Platí pro firmy,
"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.",
Block Days,Blokové dny,
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.,
Leave Block List Dates,Nechte Block List termíny,
Allow Users,Povolit uživatele,
Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.,
Leave Block List Allowed,Nechte Block List povolena,
Leave Block List Allow,Nechte Block List Povolit,
Allow User,Umožňuje uživateli,
Leave Block List Date,Nechte Block List Datum,
Block Date,Block Datum,
Leave Control Panel,Ovládací panel dovolených,
Select Employees,Vybrat Zaměstnanci,
Employment Type (optional),Typ zaměstnání (volitelné),
Branch (optional),Větev (volitelné),
Department (optional),Oddělení (volitelné),
Designation (optional),Označení (volitelné),
Employee Grade (optional),Hodnocení zaměstnanců (volitelné),
Employee (optional),Zaměstnanec (volitelné),
Allocate Leaves,Přidělit listy,
Carry Forward,Převádět,
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",
New Leaves Allocated (In Days),Nové Listy Přidělené (ve dnech),
Allocate,Přidělit,
Leave Balance,Nechat zůstatek,
Encashable days,Dny zapamatovatelné,
Encashment Amount,Část inkasa,
Leave Ledger Entry,Opusťte zápis do knihy,
Transaction Name,Název transakce,
Is Carry Forward,Je převádět,
Is Expired,Platnost vypršela,
Is Leave Without Pay,Je odejít bez Pay,
Holiday List for Optional Leave,Dovolená seznam pro nepovinné dovolené,
Leave Allocations,Ponechat alokace,
Leave Policy Details,Zanechat podrobnosti o zásadách,
Leave Policy Detail,Ponechte detaily zásad,
Annual Allocation,Roční přidělení,
Leave Type Name,Jméno typu absence,
Max Leaves Allowed,Maximální povolené povolenky,
Applicable After (Working Days),Platí po (pracovní dny),
Maximum Continuous Days Applicable,Maximální počet nepřetržitých dnů,
Is Optional Leave,Je volitelné volno,
Allow Negative Balance,Povolit záporný zůstatek,
Include holidays within leaves as leaves,Zahrnout dovolenou v listech jsou listy,
Is Compensatory,Je kompenzační,
Maximum Carry Forwarded Leaves,Maximální počet přepravených listů,
Expire Carry Forwarded Leaves (Days),Vyprší doručené listy (dny),
Calculated in days,Vypočítáno ve dnech,
Encashment,Zapouzdření,
Allow Encashment,Povolit nákres,
Encashment Threshold Days,Dny prahu inkasa,
Earned Leave,Získaná dovolená,
Is Earned Leave,Získaná dovolená,
Earned Leave Frequency,Dosažená frekvence dovolené,
Rounding,Zaokrouhlení,
Payroll Employee Detail,Zaměstnanecký detail zaměstnanců,
Payroll Frequency,Mzdové frekvence,
Fortnightly,Čtrnáctidenní,
Bimonthly,dvouměsíčník,
Employees,zaměstnanci,
Number Of Employees,Počet zaměstnanců,
Employee Details,Podrobnosti o zaměstnanci,
Validate Attendance,Ověřit účast,
Salary Slip Based on Timesheet,Plat Slip na základě časového rozvrhu,
Select Payroll Period,Vyberte mzdové,
Deduct Tax For Unclaimed Employee Benefits,Odpočítte daň za nevyžádané zaměstnanecké výhody,
Deduct Tax For Unsubmitted Tax Exemption Proof,Odpočet daně za nezdařené osvobození od daně,
Select Payment Account to make Bank Entry,"Vybrat Platební účet, aby Bank Entry",
Salary Slips Created,Vytvořeny platební karty,
Salary Slips Submitted,Příspěvky na plat,
Payroll Periods,Mzdové lhůty,
Payroll Period Date,Den mzdy,
Purpose of Travel,Účel cesty,
Retention Bonus,Retenční bonus,
Bonus Payment Date,Bonus Datum platby,
Bonus Amount,Bonusová částka,
Abbr,Zkr,
Depends on Payment Days,Závisí na platebních dnech,
Is Tax Applicable,Je daň platná,
Variable Based On Taxable Salary,Proměnná založená na zdanitelném platu,
Exempted from Income Tax,Osvobozeno od daně z příjmu,
Round to the Nearest Integer,Zaokrouhlí na nejbližší celé číslo,
Statistical Component,Statistická složka,
"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Pokud je vybrána, hodnota zadaná nebo vypočtená v této složce nepřispívá k výnosům nebo odpočtem. Nicméně, jeho hodnota může být odkazováno na jiné komponenty, které mohou být přidány nebo odečteny.",
Do Not Include in Total,Nezahrnovat celkem,
Flexible Benefits,Flexibilní výhody,
Is Flexible Benefit,Je flexibilní přínos,
Max Benefit Amount (Yearly),Maximální částka prospěchu (ročně),
Only Tax Impact (Cannot Claim But Part of Taxable Income),"Pouze daňový dopad (nelze tvrdit, ale část zdanitelného příjmu)",
Create Separate Payment Entry Against Benefit Claim,Vytvoření odděleného zadání platby proti nároku na dávku,
Condition and Formula,Stav a vzorec,
Amount based on formula,Částka podle vzorce,
Formula,Vzorec,
Salary Detail,plat Detail,
Component,Komponent,
Do not include in total,Nezahrnujte celkem,
Default Amount,Výchozí částka,
Additional Amount,Další částka,
Tax on flexible benefit,Daň z flexibilní výhody,
Tax on additional salary,Daň z příplatku,
Salary Structure,Plat struktura,
Working Days,Pracovní dny,
Salary Slip Timesheet,Plat Slip časový rozvrh,
Total Working Hours,Celkové pracovní doby,
Hour Rate,Hour Rate,
Bank Account No.,Bankovní účet č.,
Earning & Deduction,Výdělek a dedukce,
Earnings,Výdělek,
Deductions,Odpočty,
Loan repayment,Splácení půjčky,
Employee Loan,zaměstnanec Loan,
Total Principal Amount,Celková hlavní částka,
Total Interest Amount,Celková částka úroků,
Total Loan Repayment,Celková splátky,
net pay info,Čistý plat info,
Gross Pay - Total Deduction - Loan Repayment,Hrubé mzdy - Total dedukce - splátky,
Total in words,Celkem slovy,
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.",
Salary Component for timesheet based payroll.,Plat komponent pro mzdy časového rozvrhu.,
Leave Encashment Amount Per Day,Ponechte částku zaplacení za den,
Max Benefits (Amount),Maximální výhody (částka),
Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.,
Total Earning,Celkem Zisk,
Salary Structure Assignment,Přiřazení struktury platu,
Shift Assignment,Shift Assignment,
Shift Type,Typ posunu,
Shift Request,Žádost o posun,
Enable Auto Attendance,Povolit automatickou účast,
Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Označte účast na základě „Kontrola zaměstnanců“ u zaměstnanců přiřazených k této změně.,
Auto Attendance Settings,Nastavení automatické účasti,
Determine Check-in and Check-out,Určete check-in a check-out,
Alternating entries as IN and OUT during the same shift,Střídavé záznamy jako IN a OUT během stejné směny,
Strictly based on Log Type in Employee Checkin,Přísně založené na typu protokolu při kontrole zaměstnanců,
Working Hours Calculation Based On,Výpočet pracovní doby na základě,
First Check-in and Last Check-out,První check-in a poslední check-out,
Every Valid Check-in and Check-out,Každá platná check-in a check-out,
Begin check-in before shift start time (in minutes),Zahájení kontroly před začátkem směny (v minutách),
The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas před začátkem směny, během kterého je za účast považováno přihlášení zaměstnanců.",
Allow check-out after shift end time (in minutes),Povolit odhlášení po době ukončení směny (v minutách),
Time after the end of shift during which check-out is considered for attendance.,"Čas po skončení směny, během kterého je check-out považován za účast.",
Working Hours Threshold for Half Day,Práh pracovní doby na půl dne,
Working hours below which Half Day is marked. (Zero to disable),"Pracovní doba, pod kterou je označen půl dne. (Nulování zakázat)",
Working Hours Threshold for Absent,Prahová hodnota pracovní doby pro nepřítomnost,
Working hours below which Absent is marked. (Zero to disable),"Pracovní doba, pod kterou je označen Absent. (Nulování zakázat)",
Process Attendance After,Procesní účast po,
Attendance will be marked automatically only after this date.,Účast bude automaticky označena až po tomto datu.,
Last Sync of Checkin,Poslední synchronizace Checkin,
Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,"Poslední známá úspěšná synchronizace kontroly zaměstnanců. Obnovte to, pouze pokud jste si jisti, že všechny protokoly jsou synchronizovány ze všech umístění. Pokud si nejste jisti, neupravujte to.",
Grace Period Settings For Auto Attendance,Nastavení doby odkladu pro automatickou účast,
Enable Entry Grace Period,Povolit období odkladu vstupu,
Late Entry Grace Period,Pozdní doba odkladu,
The time after the shift start time when check-in is considered as late (in minutes).,"Čas po začátku směny, kdy se check-in považuje za pozdní (v minutách).",
Enable Exit Grace Period,Povolit ukončení doby odkladu,
Early Exit Grace Period,Časné ukončení odkladu,
The time before the shift end time when check-out is considered as early (in minutes).,"Čas před koncem směny, kdy je check-out považován za časný (v minutách).",
Skill Name,Jméno dovednosti,
Staffing Plan Details,Podrobnosti personálního plánu,
Staffing Plan Detail,Personální plán detailu,
Total Estimated Budget,Celkový odhadovaný rozpočet,
Vacancies,Volná místa,
Estimated Cost Per Position,Odhadovaná cena za pozici,
Total Estimated Cost,Celkové odhadované náklady,
Current Count,Aktuální počet,
Current Openings,Aktuální místa,
Number Of Positions,Počet pozic,
Taxable Salary Slab,Zdanitelná mzdová deska,
From Amount,Z částky,
To Amount,Do výše,
Percent Deduction,Procentní odpočet,
Training Program,Tréninkový program,
Event Status,Event Status,
Has Certificate,Má certifikát,
Seminar,Seminář,
Theory,Teorie,
Workshop,Dílna,
Conference,Konference,
Exam,Zkouška,
Internet,Internet,
Self-Study,Samostudium,
Advance,Záloha,
Trainer Name,Jméno trenér,
Trainer Email,trenér Email,
Attendees,Účastníci,
Employee Emails,E-maily zaměstnanců,
Training Event Employee,Vzdělávání zaměstnanců Event,
Invited,Pozván,
Feedback Submitted,Zpětná vazba Vložené,
Optional,Volitelný,
Training Result Employee,Vzdělávací Výsledek,
Travel Itinerary,Cestovní itinerář,
Travel From,Cestování z,
Travel To,Cestovat do,
Mode of Travel,Způsob cestování,
Flight,Let,
Train,Vlak,
Taxi,Taxi,
Rented Car,Pronajaté auto,
Meal Preference,Předvolba jídla,
Vegetarian,Vegetariánský,
Non-Vegetarian,Nevegetarián,
Gluten Free,Bezlepkový,
Non Diary,Bez deníku,
Travel Advance Required,Vyžaduje se cestovní záloha,
Departure Datetime,Čas odletu,
Arrival Datetime,Čas příjezdu,
Lodging Required,Požadováno ubytování,
Preferred Area for Lodging,Preferovaná oblast pro ubytování,
Check-in Date,Datum příjezdu,
Check-out Date,Zkontrolovat datum,
Travel Request,Žádost o cestování,
Travel Type,Typ cesty,
Domestic,Domácí,
International,Mezinárodní,
Travel Funding,Financování cest,
Require Full Funding,Požádejte o plné financování,
Fully Sponsored,Plně sponzorováno,
"Partially Sponsored, Require Partial Funding","Částečně sponzorované, vyžadují částečné financování",
Copy of Invitation/Announcement,Kopie pozvánky / oznámení,
"Details of Sponsor (Name, Location)","Podrobnosti o sponzoru (název, umístění)",
Identification Document Number,identifikační číslo dokumentu,
Any other details,Další podrobnosti,
Costing Details,Kalkulovat podrobnosti,
Costing,Rozpočet,
Event Details,Podrobnosti události,
Name of Organizer,Název pořadatele,
Address of Organizer,Adresa pořadatele,
Travel Request Costing,Náklady na cestování,
Expense Type,Typ výdajů,
Sponsored Amount,Sponzorovaná částka,
Funded Amount,Financovaná částka,
Upload Attendance,Nahrát Návštěvnost,
Attendance From Date,Účast Datum od,
Attendance To Date,Účast na data,
Get Template,Získat šablonu,
Import Attendance,Importovat Docházku,
Upload HTML,Nahrát HTML,
Vehicle,Vozidlo,
License Plate,poznávací značka,
Odometer Value (Last),Údaj měřiče ujeté vzdálenosti (Last),
Acquisition Date,akvizice Datum,
Chassis No,podvozek Žádné,
Vehicle Value,Hodnota vozidla,
Insurance Details,pojištění Podrobnosti,
Insurance Company,Pojišťovna,
Policy No,Ne politika,
Additional Details,další detaily,
Fuel Type,Druh paliva,
Petrol,Benzín,
Diesel,motorová nafta,
Natural Gas,Zemní plyn,
Electric,Elektrický,
Fuel UOM,palivo UOM,
Last Carbon Check,Poslední Carbon Check,
Wheels,kola,
Doors,dveře,
HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-,
Odometer Reading,stav tachometru,
Current Odometer value ,Aktuální hodnota kilometru,
last Odometer Value ,poslední hodnota počítadla kilometrů,
Refuelling Details,Tankovací Podrobnosti,
Invoice Ref,Faktura Ref,
Service Details,Podrobnosti o službě,
Service Detail,servis Detail,
Vehicle Service,servis vozidel,
Service Item,servis Položka,
Brake Oil,Brake Oil,
Brake Pad,Brzdový pedál,
Clutch Plate,Kotouč spojky,
Engine Oil,Motorový olej,
Oil Change,Výměna oleje,
Inspection,Inspekce,
Mileage,Najeto,
Hub Tracked Item,Hubová sledovaná položka,
Hub Node,Hub Node,
Image List,Seznam obrázků,
Item Manager,Manažer Položka,
Hub User,Uživatel Hubu,
Hub Password,Heslo Hubu,
Hub Users,Uživatelé Hubu,
Marketplace Settings,Nastavení tržiště,
Disable Marketplace,Zakázat tržiště,
Marketplace URL (to hide and update label),Adresa URL tržiště (skrýt a aktualizovat štítek),
Registered,Registrovaný,
Sync in Progress,Synchronizace probíhá,
Hub Seller Name,Jméno prodejce hubu,
Custom Data,Vlastní data,
Member,Člen,
Partially Disbursed,částečně Vyplacené,
Loan Closure Requested,Požadováno uzavření úvěru,
Repay From Salary,Splatit z platu,
Loan Details,půjčka Podrobnosti,
Loan Type,Typ úvěru,
Loan Amount,Částka půjčky,
Is Secured Loan,Je zajištěná půjčka,
Rate of Interest (%) / Year,Úroková sazba (%) / rok,
Disbursement Date,výplata Datum,
Disbursed Amount,Částka vyplacená,
Is Term Loan,Je termín půjčka,
Repayment Method,splácení Metoda,
Repay Fixed Amount per Period,Splatit pevná částka na období,
Repay Over Number of Periods,Splatit Over počet období,
Repayment Period in Months,Splácení doba v měsících,
Monthly Repayment Amount,Výše měsíční splátky,
Repayment Start Date,Datum zahájení splacení,
Loan Security Details,Podrobnosti o půjčce,
Maximum Loan Value,Maximální hodnota půjčky,
Account Info,Informace o účtu,
Loan Account,Úvěrový účet,
Interest Income Account,Účet Úrokové výnosy,
Penalty Income Account,Účet peněžitých příjmů,
Repayment Schedule,splátkový kalendář,
Total Payable Amount,Celková částka Splatné,
Total Principal Paid,Celková zaplacená jistina,
Total Interest Payable,Celkem splatných úroků,
Total Amount Paid,Celková částka zaplacena,
Loan Manager,Správce půjček,
Loan Info,Informace o úvěr,
Rate of Interest,Úroková sazba,
Proposed Pledges,Navrhované zástavy,
Maximum Loan Amount,Maximální výše úvěru,
Repayment Info,splácení Info,
Total Payable Interest,Celkem Splatné úroky,
Against Loan ,Proti půjčce,
Loan Interest Accrual,Úvěrový úrok,
Amounts,Množství,
Pending Principal Amount,Čeká částka jistiny,
Payable Principal Amount,Splatná jistina,
Paid Principal Amount,Vyplacená jistina,
Paid Interest Amount,Částka zaplaceného úroku,
Process Loan Interest Accrual,Časově rozlišené úroky z procesu,
Repayment Schedule Name,Název splátkového kalendáře,
Regular Payment,Pravidelná platba,
Loan Closure,Uznání úvěru,
Payment Details,Platební údaje,
Interest Payable,Úroky splatné,
Amount Paid,Zaplacené částky,
Principal Amount Paid,Hlavní zaplacená částka,
Repayment Details,Podrobnosti splácení,
Loan Repayment Detail,Podrobnosti o splácení půjčky,
Loan Security Name,Název zabezpečení půjčky,
Unit Of Measure,Měrná jednotka,
Loan Security Code,Bezpečnostní kód půjčky,
Loan Security Type,Typ zabezpečení půjčky,
Haircut %,Střih%,
Loan  Details,Podrobnosti o půjčce,
Unpledged,Unpledged,
Pledged,Slíbil,
Partially Pledged,Částečně zastaveno,
Securities,Cenné papíry,
Total Security Value,Celková hodnota zabezpečení,
Loan Security Shortfall,Nedostatek zabezpečení úvěru,
Loan ,Půjčka,
Shortfall Time,Zkratový čas,
America/New_York,America / New_York,
Shortfall Amount,Částka schodku,
Security Value ,Hodnota zabezpečení,
Process Loan Security Shortfall,Nedostatek zabezpečení procesních půjček,
Loan To Value Ratio,Poměr půjčky k hodnotě,
Unpledge Time,Unpledge Time,
Loan Name,půjčka Name,
Rate of Interest (%) Yearly,Úroková sazba (%) Roční,
Penalty Interest Rate (%) Per Day,Trestní úroková sazba (%) za den,
Penalty Interest Rate is levied on the pending interest amount on a daily basis in case of delayed repayment ,V případě opožděného splacení se z nedočkané výše úroku vybírá penalizační úroková sazba denně,
Grace Period in Days,Grace Období ve dnech,
No. of days from due date until which penalty won't be charged in case of delay in loan repayment,"Počet dní od data splatnosti, do kterých nebude účtována pokuta v případě zpoždění splácení půjčky",
Pledge,Slib,
Post Haircut Amount,Částka za účes,
Process Type,Typ procesu,
Update Time,Čas aktualizace,
Proposed Pledge,Navrhovaný slib,
Total Payment,Celková platba,
Balance Loan Amount,Balance Výše úvěru,
Is Accrued,Je narostl,
Salary Slip Loan,Úvěrový půjček,
Loan Repayment Entry,Úvěrová splátka,
Sanctioned Loan Amount,Částka schváleného úvěru,
Sanctioned Amount Limit,Povolený limit částky,
Unpledge,Unpledge,
Haircut,Střih,
MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-,
Generate Schedule,Generování plán,
Schedules,Plány,
Maintenance Schedule Detail,Plán údržby Detail,
Scheduled Date,Plánované datum,
Actual Date,Skutečné datum,
Maintenance Schedule Item,Plán údržby Item,
Random,Náhodný,
No of Visits,Počet návštěv,
MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-,
Maintenance Date,Datum údržby,
Maintenance Time,Údržba Time,
Completion Status,Dokončení Status,
Partially Completed,Částečně Dokončeno,
Fully Completed,Plně Dokončeno,
Unscheduled,Neplánovaná,
Breakdown,Rozbor,
Purposes,Cíle,
Customer Feedback,Zpětná vazba od zákazníků,
Maintenance Visit Purpose,Maintenance Visit Účel,
Work Done,Odvedenou práci,
Against Document No,Proti dokumentu č,
Against Document Detail No,Proti Detail dokumentu č,
MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-,
Order Type,Typ objednávky,
Blanket Order Item,Dekorační objednávka zboží,
Ordered Quantity,Objednané množství,
Item to be manufactured or repacked,Položka k výrobě nebo zabalení,
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,
Set rate of sub-assembly item based on BOM,Nastavte ocenění položky podsestavy na základě kusovníku,
Allow Alternative Item,Povolit alternativní položku,
Item UOM,Položka UOM,
Conversion Rate,Míra konverze,
Rate Of Materials Based On,Ocenění materiálů na bázi,
With Operations,S operacemi,
Manage cost of operations,Správa nákladů na provoz,
Transfer Material Against,Přeneste materiál proti,
Routing,Směrování,
Materials,Materiály,
Quality Inspection Required,Vyžaduje se kontrola kvality,
Quality Inspection Template,Šablona inspekce kvality,
Scrap,Šrot,
Scrap Items,šrot položky,
Operating Cost,Provozní náklady,
Raw Material Cost,Cena surovin,
Scrap Material Cost,Šrot Material Cost,
Operating Cost (Company Currency),Provozní náklady (Company měna),
Raw Material Cost (Company Currency),Náklady na suroviny (měna společnosti),
Scrap Material Cost(Company Currency),Šrot materiálové náklady (Company měna),
Total Cost,Celkové náklady,
Total Cost (Company Currency),Celkové náklady (měna společnosti),
Materials Required (Exploded),Potřebný materiál (Rozložený),
Exploded Items,Rozložené položky,
Show in Website,Zobrazit na webu,
Item Image (if not slideshow),Item Image (ne-li slideshow),
Thumbnail,Thumbnail,
Website Specifications,Webových stránek Specifikace,
Show Items,Zobrazit položky,
Show Operations,Zobrazit Operations,
Website Description,Popis webu,
BOM Explosion Item,BOM Explosion Item,
Qty Consumed Per Unit,Množství spotřebované na jednotku,
Include Item In Manufacturing,Zahrnout položku do výroby,
BOM Item,Položka kusovníku,
Item operation,Položka položky,
Rate & Amount,Cena a částka,
Basic Rate (Company Currency),Basic Rate (Company měny),
Scrap %,Scrap%,
Original Item,Původní položka,
BOM Operation,BOM Operation,
Operation Time ,Provozní doba,
In minutes,Za pár minut,
Batch Size,Objem várky,
Base Hour Rate(Company Currency),Základna hodinová sazba (Company měny),
Operating Cost(Company Currency),Provozní náklady (Company měna),
BOM Scrap Item,BOM Scrap Item,
Basic Amount (Company Currency),Základní částka (Company měna),
BOM Update Tool,Nástroj pro aktualizaci kusovníku,
"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.","Nahraďte konkrétní kusovníku do všech ostatních kusovníků, kde se používá. Nahradí starý odkaz na kusovníku, aktualizuje cenu a obnoví tabulku &quot;BOM Výbušná položka&quot; podle nového kusovníku. Také aktualizuje poslední cenu ve všech kusovnících.",
Replace BOM,Nahraďte kusovníku,
Current BOM,Aktuální BOM,
The BOM which will be replaced,"BOM, který bude nahrazen",
The new BOM after replacement,Nový BOM po změně,
Replace,Vyměnit,
Update latest price in all BOMs,Aktualizujte nejnovější cenu všech kusovníků,
BOM Website Item,BOM Website Item,
BOM Website Operation,BOM Webové stránky Provoz,
Operation Time,Čas operace,
PO-JOB.#####,PO-JOB. #####,
Timing Detail,Časový detail,
Time Logs,Čas Záznamy,
Total Time in Mins,Celkový čas v minách,
Operation ID,ID operace,
Transferred Qty,Přenesená Množství,
Job Started,Úloha byla zahájena,
Started Time,Čas zahájení,
Current Time,Aktuální čas,
Job Card Item,Položka karty Job Card,
Job Card Time Log,Časový záznam karty práce,
Time In Mins,Čas v min,
Completed Qty,Dokončené Množství,
Manufacturing Settings,Výrobní nastavení,
Raw Materials Consumption,Spotřeba surovin,
Allow Multiple Material Consumption,Povolte vícenásobnou spotřebu materiálu,
Allow multiple Material Consumption against a Work Order,Povolit vícenásobnou spotřebu materiálu proti pracovní zakázce,
Backflush Raw Materials Based On,Se zpětným suroviny na základě,
Material Transferred for Manufacture,Převádí jaderný materiál pro Výroba,
Capacity Planning,Plánování kapacit,
Disable Capacity Planning,Zakázat plánování kapacity,
Allow Overtime,Povolit Přesčasy,
Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovních hodin.,
Allow Production on Holidays,Povolit Výrobu při dovolené,
Capacity Planning For (Days),Plánování kapacit Pro (dny),
Try planning operations for X days in advance.,Zkuste plánování operací pro X dní předem.,
Time Between Operations (in mins),Doba mezi operací (v min),
Default 10 mins,Výchozí 10 min,
Default Warehouses for Production,Výchozí sklady pro výrobu,
Default Work In Progress Warehouse,Výchozí práci ve skladu Progress,
Default Finished Goods Warehouse,Výchozí sklad hotových výrobků,
Default Scrap Warehouse,Výchozí sklad šrotu,
Over Production for Sales and Work Order,Over Production for Sales and Work Order,
Overproduction Percentage For Sales Order,Procento nadvýroby pro objednávku prodeje,
Overproduction Percentage For Work Order,Procento nadvýroby pro pracovní pořadí,
Other Settings,další nastavení,
Update BOM Cost Automatically,Aktualizovat cenu BOM automaticky,
"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Aktualizujte náklady na BOM automaticky pomocí programu Plánovač, založený na nejnovější hodnotící sazbě / ceníku / posledním nákupu surovin.",
Material Request Plan Item,Položka materiálu požadovaného plánu,
Material Request Type,Materiál Typ požadavku,
Material Issue,Material Issue,
Customer Provided,Poskytováno zákazníkem,
Minimum Order Quantity,Minimální množství pro objednání,
Default Workstation,Výchozí Workstation,
Production Plan,Plán produkce,
MFG-PP-.YYYY.-,MFG-PP-.YYYY.-,
Get Items From,Položka získaná z,
Get Sales Orders,Získat Prodejní objednávky,
Material Request Detail,Podrobnosti o vyžádání materiálu,
Get Material Request,Získat Materiál Request,
Material Requests,materiál Žádosti,
Get Items For Work Order,Získat položky pro pracovní objednávku,
Material Request Planning,Plánování požadavků na materiál,
Include Non Stock Items,"Zahrnout položky, které nejsou skladem",
Include Subcontracted Items,Zahrnout subdodávané položky,
Ignore Existing Projected Quantity,Ignorujte existující předpokládané množství,
"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","Chcete-li se dozvědět více o plánovaném množství, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">klikněte sem</a> .",
Download Required Materials,Stáhněte si požadované materiály,
Get Raw Materials For Production,Získejte suroviny pro výrobu,
Total Planned Qty,Celkový plánovaný počet,
Total Produced Qty,Celkový vyrobený počet,
Material Requested,Požadovaný materiál,
Production Plan Item,Výrobní program Item,
Make Work Order for Sub Assembly Items,Vytvořte pracovní objednávku pro položky podsestavy,
"If enabled, system will create the work order for the exploded items against which BOM is available.","Pokud je povoleno, systém vytvoří pracovní objednávku pro rozložené položky, proti nimž je kusovník k dispozici.",
Planned Start Date,Plánované datum zahájení,
Quantity and Description,Množství a popis,
material_request_item,material_request_item,
Product Bundle Item,Product Bundle Item,
Production Plan Material Request,Výroba Poptávka Plán Materiál,
Production Plan Sales Order,Výrobní program prodejní objednávky,
Sales Order Date,Prodejní objednávky Datum,
Routing Name,Název směrování,
MFG-WO-.YYYY.-,MFG-WO-YYYY.-,
Item To Manufacture,Položka k výrobě,
Material Transferred for Manufacturing,Materiál Přenesená pro výrobu,
Manufactured Qty,Vyrobeno Množství,
Use Multi-Level BOM,Použijte Multi-Level BOM,
Plan material for sub-assemblies,Plán materiál pro podsestavy,
Skip Material Transfer to WIP Warehouse,Přeskočit přenos materiálu do skladu WIP,
Check if material transfer entry is not required,"Zkontrolujte, zda není požadováno zadání materiálu",
Backflush Raw Materials From Work-in-Progress Warehouse,Zpětné suroviny z nedokončeného skladu,
Update Consumed Material Cost In Project,Aktualizujte spotřebované materiálové náklady v projektu,
Warehouses,Sklady,
This is a location where raw materials are available.,"Toto je místo, kde jsou dostupné suroviny.",
Work-in-Progress Warehouse,Work-in-Progress sklad,
This is a location where operations are executed.,"Toto je místo, kde se provádějí operace.",
This is a location where final product stored.,"Toto je místo, kde je uložen finální produkt.",
Scrap Warehouse,šrot Warehouse,
This is a location where scraped materials are stored.,"Toto je místo, kde se ukládají poškrábané materiály.",
Required Items,Povinné předměty,
Actual Start Date,Skutečné datum zahájení,
Planned End Date,Plánované datum ukončení,
Actual End Date,Skutečné datum ukončení,
Operation Cost,Provozní náklady,
Planned Operating Cost,Plánované provozní náklady,
Actual Operating Cost,Skutečné provozní náklady,
Additional Operating Cost,Další provozní náklady,
Total Operating Cost,Celkové provozní náklady,
Manufacture against Material Request,Výroba proti Materiál Request,
Work Order Item,Položka objednávky,
Available Qty at Source Warehouse,Dostupné množství v zdrojovém skladu,
Available Qty at WIP Warehouse,Dostupné množství v WIP skladu,
Work Order Operation,Obsluha zakázky,
Operation Description,Operace Popis,
Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?,
Work in Progress,Na cestě,
Estimated Time and Cost,Odhadovná doba a náklady,
Planned Start Time,Plánované Start Time,
Planned End Time,Plánované End Time,
in Minutes,V minutách,
Actual Time and Cost,Skutečný Čas a Náklady,
Actual Start Time,Skutečný čas začátku,
Actual End Time,Aktuální End Time,
Updated via 'Time Log',"Aktualizováno přes ""Time Log""",
Actual Operation Time,Aktuální Provozní doba,
in Minutes\nUpdated via 'Time Log',"v minutách \n aktualizovat přes ""Time Log""",
(Hour Rate / 60) * Actual Operation Time,(Hodinová sazba / 60) * Skutečný čas operace,
Workstation Name,Meno pracovnej stanice,
Production Capacity,Produkční kapacita,
Operating Costs,Provozní náklady,
Electricity Cost,Cena elektřiny,
per hour,za hodinu,
Consumable Cost,Spotřební Cost,
Rent Cost,Rent Cost,
Wages,Mzdy,
Wages per hour,Mzda za hodinu,
Net Hour Rate,Net Hour Rate,
Workstation Working Hour,Pracovní stanice Pracovní Hour,
Certification Application,Certifikační aplikace,
Name of Applicant,Jméno žadatele,
Certification Status,Stav certifikace,
Yet to appear,Přesto se objeví,
Certified,Certifikováno,
Not Certified,Není certifikováno,
USD,americký dolar,
INR,INR,
Certified Consultant,Certifikovaný konzultant,
Name of Consultant,Jméno konzultanta,
Certification Validity,Platnost certifikátu,
Discuss ID,Diskutujte o ID,
GitHub ID,GitHub ID,
Non Profit Manager,Neziskový manažer,
Chapter Head,Hlava kapitoly,
Meetup Embed HTML,Meetup Embed HTML,
chapters/chapter_name\nleave blank automatically set after saving chapter.,kapitoly / název_kapitoly nechte prázdné pole automaticky po uložení kapitoly.,
Chapter Members,Členové kapitoly,
Members,Členové,
Chapter Member,Člen kapitoly,
Website URL,URL webu,
Leave Reason,Nechte důvod,
Donor Name,Jméno dárce,
Donor Type,Typ dárce,
Withdrawn,uzavřený,
Grant Application Details ,Podrobnosti o žádosti o grant,
Grant Description,Grant Popis,
Requested Amount,Požadovaná částka,
Has any past Grant Record,Má nějaký minulý grantový záznam,
Show on Website,Zobrazit na webu,
Assessment  Mark (Out of 10),Známka hodnocení (z 10),
Assessment  Manager,Správce hodnocení,
Email Notification Sent,Zasláno oznámení o e-mailu,
NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
Membership Expiry Date,Datum ukončení členství,
Razorpay Details,Razorpay Podrobnosti,
Subscription ID,ID předplatného,
Customer ID,zákaznické identifikační číslo,
Subscription Activated,Předplatné aktivováno,
Subscription Start ,Začátek předplatného,
Subscription End,Konec předplatného,
Non Profit Member,Neziskový člen,
Membership Status,Stav členství,
Member Since,Členem od,
Payment ID,ID platby,
Membership Settings,Nastavení členství,
Enable RazorPay For Memberships,Povolit RazorPay pro členství,
RazorPay Settings,Nastavení RazorPay,
Billing Cycle,Zúčtovací období,
Billing Frequency,Fakturační frekvence,
"The number of billing cycles for which the customer should be charged. For example, if a customer is buying a 1-year membership that should be billed on a monthly basis, this value should be 12.","Počet fakturačních cyklů, za které by měl být zákazníkovi účtován poplatek. Pokud si například zákazník kupuje roční členství, které by mělo být účtováno měsíčně, měla by tato hodnota činit 12.",
Razorpay Plan ID,Razorpay plán ID,
Volunteer Name,Jméno dobrovolníka,
Volunteer Type,Typ dobrovolníka,
Availability and Skills,Dostupnost a dovednosti,
Availability,Dostupnost,
Weekends,Víkendy,
Availability Timeslot,Dostupnost Timeslot,
Morning,Ráno,
Afternoon,Odpoledne,
Evening,Večer,
Anytime,Kdykoliv,
Volunteer Skills,Dobrovolnické dovednosti,
Volunteer Skill,Dobrovolnické dovednosti,
Homepage,Domovská stránka,
Hero Section Based On,Hero Section Na základě,
Homepage Section,Sekce domovské stránky,
Hero Section,Hero Section,
Tag Line,tag linka,
Company Tagline for website homepage,Firma fb na titulní stránce webu,
Company Description for website homepage,Společnost Popis pro webové stránky domovskou stránku,
Homepage Slideshow,Domovská stránka Prezentace,
"URL for ""All Products""",URL pro &quot;všechny produkty&quot;,
Products to be shown on website homepage,"Produkty, které mají být uvedeny na internetových stránkách domovské",
Homepage Featured Product,Úvodní Doporučené zboží,
route,trasa,
Section Based On,Sekce založená na,
Section Cards,Karty sekce,
Number of Columns,Počet sloupců,
Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Počet sloupců pro tuto sekci. Pokud vyberete 3 sloupce, zobrazí se 3 karty na řádek.",
Section HTML,Sekce HTML,
Use this field to render any custom HTML in the section.,Toto pole použijte k vykreslení vlastního HTML v sekci.,
Section Order,Řád sekce,
"Order in which sections should appear. 0 is first, 1 is second and so on.","Pořadí, ve kterém se mají sekce zobrazit. 0 je první, 1 je druhý a tak dále.",
Homepage Section Card,Karta sekce domovské stránky,
Subtitle,Titulky,
Products Settings,Nastavení Produkty,
Home Page is Products,Domovskou stránkou je stránka Produkty.,
"If checked, the Home page will be the default Item Group for the website","Pokud je zaškrtnuto, domovská stránka bude výchozí bod skupina pro webové stránky",
Show Availability Status,Zobrazit stav dostupnosti,
Product Page,Stránka produktu,
Products per Page,Produkty na stránku,
Enable Field Filters,Povolit filtry pole,
Item Fields,Pole položek,
Enable Attribute Filters,Povolit filtry atributů,
Attributes,Atributy,
Hide Variants,Skrýt varianty,
Website Attribute,Atribut webové stránky,
Attribute,Atribut,
Website Filter Field,Pole filtru webových stránek,
Activity Cost,Náklady Aktivita,
Billing Rate,Fakturace Rate,
Costing Rate,Kalkulace Rate,
title,titul,
Projects User,Projekty uživatele,
Default Costing Rate,Výchozí kalkulace Rate,
Default Billing Rate,Výchozí fakturace Rate,
Dependent Task,Závislý Task,
Project Type,Typ projektu,
% Complete Method,Dokončeno% Method,
Task Completion,úkol Dokončení,
Task Progress,Pokrok úkol,
% Completed,% Dokončeno,
From Template,Ze šablony,
Project will be accessible on the website to these users,Projekt bude k dispozici na webových stránkách k těmto uživatelům,
Copied From,Zkopírován z,
Start and End Dates,Datum zahájení a ukončení,
Actual Time (in Hours),Skutečný čas (v hodinách),
Costing and Billing,Kalkulace a fakturace,
Total Costing Amount (via Timesheets),Celková částka kalkulování (prostřednictvím časových lístků),
Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nároků),
Total Purchase Cost (via Purchase Invoice),Celkové pořizovací náklady (přes nákupní faktury),
Total Sales Amount (via Sales Order),Celková částka prodeje (prostřednictvím objednávky prodeje),
Total Billable Amount (via Timesheets),Celková fakturační částka (prostřednictvím časových lístků),
Total Billed Amount (via Sales Invoices),Celková fakturační částka (prostřednictvím prodejních faktur),
Total Consumed Material Cost  (via Stock Entry),Celkové náklady na spotřebu materiálu (přes vstup zboží),
Gross Margin,Hrubá marže,
Gross Margin %,Hrubá Marže %,
Monitor Progress,Monitorování pokroku,
Collect Progress,Sbírat Progress,
Frequency To Collect Progress,Frekvence pro shromažďování pokroku,
Twice Daily,Dvakrát denně,
First Email,První e-mail,
Second Email,Druhý e-mail,
Time to send,Čas odeslání,
Day to Send,Den odeslání,
Message will be sent to the users to get their status on the Project,"Zpráva bude odeslána uživatelům, aby získali jejich stav v projektu",
Projects Manager,Správce projektů,
Project Template,Šablona projektu,
Project Template Task,Úloha šablony projektu,
Begin On (Days),Zahájit (dny),
Duration (Days),Trvání (dny),
Project Update,Aktualizace projektu,
Project User,projekt Uživatel,
View attachments,Zobrazit přílohy,
Projects Settings,Nastavení projektů,
Ignore Workstation Time Overlap,Ignorovat překrytí pracovní stanice,
Ignore User Time Overlap,Ignorovat překryv uživatelského času,
Ignore Employee Time Overlap,Ignorovat překrytí času zaměstnanců,
Weight,Hmotnost,
Parent Task,Rodičovská úloha,
Timeline,Časová osa,
Expected Time (in hours),Předpokládaná doba (v hodinách),
% Progress,% Progress,
Is Milestone,Je milník,
Task Description,Popis ulohy,
Dependencies,Závislosti,
Dependent Tasks,Závislé úkoly,
Depends on Tasks,Závisí na Úkoly,
Actual Start Date (via Time Sheet),Skutečné datum zahájení (přes Time Sheet),
Actual Time (in hours),Skutečná doba (v hodinách),
Actual End Date (via Time Sheet),Skutečné datum ukončení (přes Time Sheet),
Total Costing Amount (via Time Sheet),Celková kalkulace Částka (přes Time Sheet),
Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku),
Total Billing Amount (via Time Sheet),Celková částka Billing (přes Time Sheet),
Review Date,Review Datum,
Closing Date,Uzávěrka Datum,
Task Depends On,Úkol je závislá na,
Task Type,Typ úlohy,
TS-.YYYY.-,TS-.RRRR.-,
Employee Detail,Detail zaměstnanec,
Billing Details,fakturační údaje,
Total Billable Hours,Celkem zúčtovatelné hodiny,
Total Billed Hours,Celkem Předepsané Hodiny,
Total Costing Amount,Celková kalkulace Částka,
Total Billable Amount,Celková částka Zúčtovatelná,
Total Billed Amount,Celková částka Fakturovaný,
% Amount Billed,% Fakturované částky,
Hrs,hod,
Costing Amount,Kalkulace Částka,
Corrective/Preventive,Nápravné / preventivní,
Corrective,Nápravné,
Preventive,Preventivní,
Resolution,Řešení,
Resolutions,Usnesení,
Quality Action Resolution,Kvalitní akční rozlišení,
Quality Feedback Parameter,Parametr zpětné vazby kvality,
Quality Feedback Template Parameter,Parametr šablony zpětné vazby kvality,
Quality Goal,Kvalitní cíl,
Monitoring Frequency,Frekvence monitorování,
Weekday,Všední den,
January-April-July-October,Leden-duben-červenec-říjen,
Revision and Revised On,Revize a revize dne,
Revision,Revize,
Revised On,Revidováno dne,
Objectives,Cíle,
Quality Goal Objective,Cíl kvality,
Objective,Objektivní,
Agenda,Denní program,
Minutes,Minut,
Quality Meeting Agenda,Program jednání o kvalitě,
Quality Meeting Minutes,Kvalitní zápisnice z jednání,
Minute,Minuta,
Parent Procedure,Rodičovský postup,
Processes,Procesy,
Quality Procedure Process,Proces řízení kvality,
Process Description,Popis procesu,
Child Procedure,Postup dítěte,
Link existing Quality Procedure.,Propojte stávající postup kvality.,
Additional Information,dodatečné informace,
Quality Review Objective,Cíl kontroly kvality,
DATEV Settings,Nastavení DATEV,
Regional,Regionální,
Consultant ID,ID konzultanta,
GST HSN Code,GST HSN kód,
HSN Code,Kód HSN,
GST Settings,Nastavení GST,
GST Summary,Souhrn GST,
GSTIN Email Sent On,GSTIN E-mail odeslán na,
GST Accounts,Účty GST,
B2C Limit,B2C Limit,
Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Nastavte hodnotu faktury pro B2C. B2CL a B2CS vypočítané na základě této fakturované hodnoty.,
GSTR 3B Report,Zpráva GSTR 3B,
January,leden,
February,Únor,
March,březen,
April,duben,
May,Květen,
June,červen,
July,červenec,
August,srpen,
September,září,
October,říjen,
November,listopad,
December,prosinec,
JSON Output,Výstup JSON,
Invoices with no Place Of Supply,Faktury bez místa dodání,
Import Supplier Invoice,Importovat dodavatelskou fakturu,
Invoice Series,Fakturační řada,
Upload XML Invoices,Nahrajte faktury XML,
Zip File,Soubor ZIP,
Import Invoices,Importovat faktury,
Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Po připojení zip souboru k dokumentu klikněte na tlačítko Importovat faktury. Veškeré chyby související se zpracováním se zobrazí v protokolu chyb.,
Lower Deduction Certificate,Osvědčení o nižší srážce,
Certificate Details,Podrobnosti o certifikátu,
194A,194A,
194C,194C,
194D,194D,
194H,194H,
194I,194I,
194J,194J,
194LA,194LA,
194LBB,194 LBB,
194LBC,194LBC,
Certificate No,Certifikát č,
Deductee Details,Podrobnosti odvedeného,
PAN No,PAN č,
Validity Details,Podrobnosti o platnosti,
Rate Of TDS As Per Certificate,Sazba TDS podle certifikátu,
Certificate Limit,Limit certifikátu,
Invoice Series Prefix,Předvolba série faktur,
Active Menu,Aktivní nabídka,
Restaurant Menu,Nabídka restaurací,
Price List (Auto created),Ceník (vytvořeno automaticky),
Restaurant Manager,Manažer restaurace,
Restaurant Menu Item,Položka nabídky restaurace,
Restaurant Order Entry,Vstup do objednávky restaurace,
Restaurant Table,Restaurace Tabulka,
Click Enter To Add,Klepněte na tlačítko Zadat pro přidání,
Last Sales Invoice,Poslední prodejní faktura,
Current Order,Aktuální objednávka,
Restaurant Order Entry Item,Položka objednávky restaurace,
Served,Podával,
Restaurant Reservation,Rezervace restaurace,
Waitlisted,Vyčkejte,
No Show,Žádné vystoupení,
No of People,Počet lidí,
Reservation Time,Čas rezervace,
Reservation End Time,Doba ukončení rezervace,
No of Seats,Počet sedadel,
Minimum Seating,Minimální počet sedadel,
"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.",
SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-,
Campaign Schedules,Rozvrhy kampaní,
Buyer of Goods and Services.,Kupující zboží a služeb.,
CUST-.YYYY.-,CUST-.YYYY.-,
Default Company Bank Account,Výchozí firemní bankovní účet,
From Lead,Od Leadu,
Account Manager,Správce účtu,
Allow Sales Invoice Creation Without Sales Order,Povolit vytváření prodejní faktury bez prodejní objednávky,
Allow Sales Invoice Creation Without Delivery Note,Povolit vytváření prodejní faktury bez dodacího listu,
Default Price List,Výchozí Ceník,
Primary Address and Contact Detail,Primární adresa a podrobnosti kontaktu,
"Select, to make the customer searchable with these fields","Zvolte, chcete-li, aby se zákazník prohledal s těmito poli",
Customer Primary Contact,Primární kontakt zákazníka,
"Reselect, if the chosen contact is edited after save","Zvolte znovu, pokud je vybraný kontakt po uložení změněn",
Customer Primary Address,Primární adresa zákazníka,
"Reselect, if the chosen address is edited after save","Znovu vyberte, pokud je zvolená adresa po uložení upravena",
Primary Address,primární adresa,
Mention if non-standard receivable account,Zmínka v případě nestandardní pohledávky účet,
Credit Limit and Payment Terms,Úvěrový limit a platební podmínky,
Additional information regarding the customer.,Další informace týkající se zákazníka.,
Sales Partner and Commission,Prodej Partner a Komise,
Commission Rate,Výše provize,
Sales Team Details,Podrobnosti prodejní tým,
Customer POS id,ID zákazníka,
Customer Credit Limit,Úvěrový limit zákazníka,
Bypass Credit Limit Check at Sales Order,Zablokujte kontrolu úvěrového limitu na objednávce,
Industry Type,Typ Průmyslu,
MAT-INS-.YYYY.-,MAT-INS-.YYYY.-,
Installation Date,Datum instalace,
Installation Time,Instalace Time,
Installation Note Item,Poznámka k instalaci bod,
Installed Qty,Instalované množství,
Lead Source,Olovo Source,
Period Start Date,Datum zahájení období,
Period End Date,Datum konce období,
Cashier,Pokladní,
Difference,Rozdíl,
Modes of Payment,Způsoby platby,
Linked Invoices,Linkované faktury,
POS Closing Voucher Details,Podrobnosti závěrečného poukazu POS,
Collected Amount,Sběrná částka,
Expected Amount,Očekávaná částka,
POS Closing Voucher Invoices,Pokladní doklady POS,
Quantity of Items,Množství položek,
"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials","Souhrnný skupina ** položek ** do jiného ** Položka **. To je užitečné, pokud se svazování některé položky ** ** do balíku a budete udržovat zásoby balených ** Položky ** a ne agregát ** položky **. Balíček ** Položka ** bude mít &quot;Je skladem,&quot; jako &quot;Ne&quot; a &quot;Je prodeje Item&quot; jako &quot;Yes&quot;. 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ý Bundle Product Item. Poznámka: BOM = Kusovník",
Parent Item,Nadřazená položka,
List items that form the package.,"Seznam položek, které tvoří balíček.",
SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-,
Quotation To,Nabídka k,
Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou je měna zákazníka převedena na základní měnu společnosti",
Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou je ceníková měna převedena na základní měnu společnosti",
Additional Discount and Coupon Code,Další slevový a kuponový kód,
Referral Sales Partner,Prodejní partner pro doporučení,
In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku.",
Term Details,Termín Podrobnosti,
Quotation Item,Položka Nabídky,
Against Doctype,Proti DOCTYPE,
Against Docname,Proti Docname,
Additional Notes,Další poznámky,
SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
Skip Delivery Note,Přeskočit dodací list,
In Words will be visible once you save the Sales Order.,"Ve slovech budou viditelné, jakmile uložíte prodejní objednávky.",
Track this Sales Order against any Project,Sledovat tento prodejní objednávky na jakýkoli projekt,
Billing and Delivery Status,Fakturace a Delivery Status,
Not Delivered,Ne vyhlášeno,
Fully Delivered,Plně Dodáno,
Partly Delivered,Částečně vyhlášeno,
Not Applicable,Nehodí se,
%  Delivered,% Dodáno,
% of materials delivered against this Sales Order,% materiálů doručeno proti této prodejní objednávce,
% of materials billed against this Sales Order,% materiálů fakturovaných proti této prodejní obědnávce,
Not Billed,Ne Účtovaný,
Fully Billed,Plně Fakturovaný,
Partly Billed,Částečně Účtovaný,
Ensure Delivery Based on Produced Serial No,Zajistěte dodávku na základě vyrobeného sériového čísla,
Supplier delivers to Customer,Dodavatel doručí zákazníkovi,
Delivery Warehouse,Sklad pro příjem,
Planned Quantity,Plánované Množství,
For Production,Pro Výrobu,
Work Order Qty,Počet pracovních objednávek,
Produced Quantity,Produkoval Množství,
Used for Production Plan,Používá se pro výrobní plán,
Sales Partner Type,Typ obchodního partnera,
Contact No.,Kontakt Číslo,
Contribution (%),Příspěvek (%),
Contribution to Net Total,Příspěvek na celkových čistých,
Selling Settings,Prodejní Nastavení,
Settings for Selling Module,Nastavení pro prodej Module,
Customer Naming By,Zákazník Pojmenování By,
Campaign Naming By,Kampaň Pojmenování By,
Default Customer Group,Výchozí Customer Group,
Default Territory,Výchozí Territory,
Close Opportunity After Days,V blízkosti Příležitost po několika dnech,
Auto close Opportunity after 15 days,Auto v blízkosti Příležitost po 15 dnech,
Default Quotation Validity Days,Výchozí dny platnosti kotací,
Sales Update Frequency,Frekvence aktualizace prodeje,
How often should project and company be updated based on Sales Transactions.,Jak často by měl být projekt a společnost aktualizovány na základě prodejních transakcí.,
Each Transaction,Každé Transakce,
Allow user to edit Price List Rate in transactions,Povolit uživateli upravovat Ceník Cena při transakcích,
Allow multiple Sales Orders against a Customer's Purchase Order,Povolit více Prodejní objednávky proti Zákazníka Objednávky,
Validate Selling Price for Item against Purchase Rate or Valuation Rate,Ověření prodejní ceny položky proti nákupní ceně nebo ocenění,
Hide Customer's Tax Id from Sales Transactions,Inkognito daně zákazníka z prodejních transakcí,
SMS Center,SMS centrum,
Send To,Odeslat,
All Contact,Vše Kontakt,
All Customer Contact,Vše Kontakt Zákazník,
All Supplier Contact,Vše Dodavatel Kontakt,
All Sales Partner Contact,Všechny Partneři Kontakt,
All Lead (Open),Všechny Lead (Otevřeny),
All Employee (Active),Všichni zaměstnanci (Aktivní),
All Sales Person,Všichni obchodní zástupci,
Create Receiver List,Vytvořit přijímače seznam,
Receiver List,Přijímač Seznam,
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,
Total Characters,Celkový počet znaků,
Total Message(s),Celkem zpráv (y),
Authorization Control,Autorizace Control,
Authorization Rule,Autorizační pravidlo,
Average Discount,Průměrná sleva,
Customerwise Discount,Sleva podle zákazníka,
Itemwise Discount,Itemwise Sleva,
Customer or Item,Zákazník nebo položka,
Customer / Item Name,Zákazník / Název zboží,
Authorized Value,Autorizovaný Hodnota,
Applicable To (Role),Vztahující se na (Role),
Applicable To (Employee),Vztahující se na (Employee),
Applicable To (User),Vztahující se na (Uživatel),
Applicable To (Designation),Vztahující se na (označení),
Approving Role (above authorized value),Schválení role (nad oprávněné hodnoty),
Approving User  (above authorized value),Schválení uživatele (nad oprávněné hodnoty),
Brand Defaults,Výchozí hodnoty značky,
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.",
Change Abbreviation,Změna zkratky,
Parent Company,Mateřská společnost,
Default Values,Výchozí hodnoty,
Default Holiday List,Výchozí Holiday Seznam,
Default Selling Terms,Výchozí prodejní podmínky,
Default Buying Terms,Výchozí nákupní podmínky,
Create Chart Of Accounts Based On,Vytvořte účtový rozvrh založený na,
Standard Template,standardní šablona,
Existing Company,Stávající společnost,
Chart Of Accounts Template,Účtový rozvrh šablony,
Existing Company ,stávající Company,
Date of Establishment,Datum založení,
Sales Settings,Nastavení prodeje,
Monthly Sales Target,Měsíční prodejní cíl,
Sales Monthly History,Měsíční historie prodeje,
Transactions Annual History,Výroční historie transakcí,
Total Monthly Sales,Celkový měsíční prodej,
Default Cash Account,Výchozí Peněžní účet,
Default Receivable Account,Výchozí pohledávek účtu,
Round Off Cost Center,Zaokrouhlovací nákladové středisko,
Discount Allowed Account,Diskontní povolený účet,
Discount Received Account,Sleva přijatý účet,
Exchange Gain / Loss Account,Exchange Zisk / ztráty,
Unrealized Exchange Gain/Loss Account,Nerealizovaný účet zisku / ztráty na účtu Exchange,
Allow Account Creation Against Child Company,Povolit vytvoření účtu proti dětské společnosti,
Default Payable Account,Výchozí Splatnost účtu,
Default Employee Advance Account,Výchozí účet předplatného pro zaměstnance,
Default Cost of Goods Sold Account,Výchozí Náklady na prodané zboží účtu,
Default Income Account,Účet Default příjmů,
Default Deferred Revenue Account,Výchozí účet odloženého výnosu,
Default Deferred Expense Account,Výchozí účet odložených výdajů,
Default Payroll Payable Account,"Výchozí mzdy, splatnou Account",
Default Expense Claim Payable Account,Splatný účet s předběžným výdajovým nárokem,
Stock Settings,Stock Nastavení,
Enable Perpetual Inventory,Povolit trvalý inventář,
Default Inventory Account,Výchozí účet inventáře,
Stock Adjustment Account,Reklamní Nastavení účtu,
Fixed Asset Depreciation Settings,Nastavení odpisování dlouhodobého majetku,
Series for Asset Depreciation Entry (Journal Entry),Série pro odepisování aktiv (Entry Entry),
Gain/Loss Account on Asset Disposal,Zisk / ztráty na majetku likvidaci,
Asset Depreciation Cost Center,Asset Odpisy nákladového střediska,
Budget Detail,Detail Rozpočtu,
Exception Budget Approver Role,Role přístupu k výjimce rozpočtu,
Company Info,Společnost info,
For reference only.,Pouze orientační.,
Company Logo,Logo společnosti,
Date of Incorporation,Datum začlenění,
Date of Commencement,Datum začátku,
Phone No,Telefon,
Company Description,Popis společnosti,
Registration Details,Registrace Podrobnosti,
Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd,
Delete Company Transactions,Smazat transakcí Company,
Currency Exchange,Směnárna,
Specify Exchange Rate to convert one currency into another,Zadejte Exchange Rate převést jednu měnu na jinou,
From Currency,Od Měny,
To Currency,Chcete-li měny,
For Buying,Pro nákup,
For Selling,Pro prodej,
Customer Group Name,Zákazník Group Name,
Parent Customer Group,Parent Customer Group,
Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci,
Mention if non-standard receivable account applicable,Zmínka v případě nestandardní pohledávky účet použitelná,
Credit Limits,Úvěrové limity,
Email Digest,Email Digest,
Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.,
Email Digest Settings,Nastavení e-mailu Digest,
How frequently?,Jak často?,
Next email will be sent on:,Další e-mail bude odeslán dne:,
Note: Email will not be sent to disabled users,Poznámka: E-mail se nepodařilo odeslat pro zdravotně postižené uživatele,
Profit & Loss,Ztráta zisku,
New Income,New příjmů,
New Expenses,Nové výdaje,
Annual Income,Roční příjem,
Annual Expenses,roční náklady,
Bank Balance,Bank Balance,
Bank Credit Balance,Bankovní zůstatek,
Receivables,Pohledávky,
Payables,Závazky,
Sales Orders to Bill,Prodejní příkazy k Billu,
Purchase Orders to Bill,Objednávky k účtu,
New Sales Orders,Nové Prodejní objednávky,
New Purchase Orders,Nové vydané objednávky,
Sales Orders to Deliver,Prodejní objednávky k dodání,
Purchase Orders to Receive,Objednávky k nákupu,
New Purchase Invoice,Nová nákupní faktura,
New Quotations,Nové Citace,
Open Quotations,Otevřené nabídky,
Open Issues,Otevřené problémy,
Open Projects,Otevřené projekty,
Purchase Orders Items Overdue,Položky nákupních příkazů po splatnosti,
Upcoming Calendar Events,Nadcházející události kalendáře,
Open To Do,Otevřít úkol,
Add Quote,Přidat nabídku,
Global Defaults,Globální Výchozí,
Default Company,Výchozí Company,
Current Fiscal Year,Aktuální fiskální rok,
Default Distance Unit,Výchozí jednotka vzdálenosti,
Hide Currency Symbol,Skrýt symbol měny,
Do not show any symbol like $ etc next to currencies.,Nevykazují žádný symbol jako $ atd vedle měnám.,
"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",
Disable In Words,Zakázat ve slovech,
"If disable, 'In Words' field will not be visible in any transaction","Pokud zakázat, &quot;ve slovech&quot; poli nebude viditelný v jakékoli transakce",
Item Classification,Položka Klasifikace,
General Settings,Obecné nastavení,
Item Group Name,Položka Název skupiny,
Parent Item Group,Parent Item Group,
Item Group Defaults,Výchozí nastavení položky položky,
Item Tax,Daň Položky,
Check this if you want to show in website,"Zaškrtněte, pokud chcete zobrazit v webové stránky",
Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky,
HTML / Banner that will show on the top of product list.,"HTML / Banner, který se zobrazí nahoře v produktovém listu.",
Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakcí,
Setup Series,Nastavení číselných řad,
Select Transaction,Vybrat Transaction,
Help HTML,Nápověda HTML,
Series List for this Transaction,Řada seznam pro tuto transakci,
User must always select,Uživatel musí vždy vybrat,
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.",
Update Series,Řada Aktualizace,
Change the starting / current sequence number of an existing series.,Změnit výchozí / aktuální pořadové číslo existujícího série.,
Prefix,Prefix,
Current Value,Current Value,
This is the number of the last created transaction with this prefix,To je číslo poslední vytvořené transakci s tímto prefixem,
Update Series Number,Aktualizace Series Number,
Quotation Lost Reason,Důvod ztráty nabídky,
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.",
Sales Partner Name,Sales Partner Name,
Partner Type,Partner Type,
Address & Contacts,Adresa a kontakty,
Address Desc,Popis adresy,
Contact Desc,Kontakt Popis,
Sales Partner Target,Sales Partner Target,
Targets,Cíle,
Show In Website,Show pro webové stránky,
Referral Code,Kód doporučení,
To Track inbound purchase,Chcete-li sledovat příchozí nákup,
Logo,Logo,
Partner website,webové stránky Partner,
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.",
Name and Employee ID,Jméno a ID zaměstnance,
Sales Person Name,Prodej Osoba Name,
Parent Sales Person,Parent obchodník,
Select company name first.,Vyberte název společnosti jako první.,
Sales Person Targets,Obchodník cíle,
Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.,
Supplier Group Name,Název skupiny dodavatelů,
Parent Supplier Group,Nadřízená skupina dodavatelů,
Target Detail,Target Detail,
Target Qty,Target Množství,
Target  Amount,Cílová částka,
Target Distribution,Target Distribution,
"Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.","Všeobecné obchodní podmínky, které mohou být přidány do prodejů a nákupů.\n\n Příklady: \n\n 1. Platnost nabídky.\n 1. Platební podmínky (v předstihu, na úvěr, část zálohy atd.)\n 1. Co je to další (nebo zaplatit zákazníkem).\n 1. Bezpečnost / varování využití.\n 1. Záruka, pokud existuje.\n 1. Vrátí zásady.\n 1. Podmínky přepravy, v případě potřeby.\n 1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd \n 1. Adresa a kontakt na vaši společnost.",
Applicable Modules,Použitelné moduly,
Terms and Conditions Help,Podmínky nápovědy,
Classification of Customers by region,Rozdělení zákazníků podle krajů,
Territory Name,Území Name,
Parent Territory,Parent Territory,
Territory Manager,Oblastní manažer,
For reference,Pro srovnání,
Territory Targets,Území Cíle,
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.,
UOM Name,UOM Name,
Check this to disallow fractions. (for Nos),"Zkontrolujte, zda to zakázat frakce. (U č)",
Website Item Group,Website Item Group,
Cross Listing of Item in multiple groups,Cross Výpis zboží v několika skupinách,
Default settings for Shopping Cart,Výchozí nastavení Košík,
Enable Shopping Cart,Povolit Nákupní košík,
Display Settings,Nastavení zobrazení,
Show Public Attachments,Zobrazit veřejné přílohy,
Show Price,Zobrazit cenu,
Show Stock Availability,Zobrazit dostupnost skladem,
Show Contact Us Button,Tlačítko Zobrazit kontakt,
Show Stock Quantity,Zobrazit množství zásob,
Show Apply Coupon Code,Zobrazit Použít kód kupónu,
Allow items not in stock to be added to cart,"Povolit přidání zboží, které není na skladě, do košíku",
Prices will not be shown if Price List is not set,"Ceny nebude zobrazeno, pokud Ceník není nastaven",
Quotation Series,Číselná řada nabídek,
Checkout Settings,Pokladna Nastavení,
Enable Checkout,Aktivovat Checkout,
Payment Success Url,Platba Úspěch URL,
After payment completion redirect user to selected page.,Po dokončení platby přesměrovat uživatele na vybrané stránky.,
Batch Details,Podrobnosti o dávce,
Batch ID,Šarže ID,
image,obraz,
Parent Batch,Nadřazená dávka,
Manufacturing Date,Datum výroby,
Batch Quantity,Množství dávky,
Batch UOM,Hromadná MOM,
Source Document Type,Zdrojový typ dokumentu,
Source Document Name,Název zdrojového dokumentu,
Batch Description,Popis Šarže,
Bin,Popelnice,
Reserved Quantity,Vyhrazeno Množství,
Actual Quantity,Skutečné Množství,
Requested Quantity,Požadované množství,
Reserved Qty for sub contract,Vyhrazené množství pro subdodávky,
Moving Average Rate,Klouzavý průměr,
FCFS Rate,FCFS Rate,
Customs Tariff Number,Celního sazebníku,
Tariff Number,tarif Počet,
Delivery To,Doručení do,
MAT-DN-.YYYY.-,MAT-DN-.RRRR.-,
Is Return,Je Return,
Issue Credit Note,Vystavení kreditní poznámky,
Return Against Delivery Note,Návrat Proti dodací list,
Customer's Purchase Order No,Zákazníka Objednávka No,
Billing Address Name,Jméno Fakturační adresy,
Required only for sample item.,Požadováno pouze pro položku vzorku.,
"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.",
In Words will be visible once you save the Delivery Note.,"Ve slovech budou viditelné, jakmile uložíte doručení poznámku.",
In Words (Export) will be visible once you save the Delivery Note.,"Ve slovech (export) budou viditelné, jakmile uložíte doručení poznámku.",
Transporter Info,Transporter Info,
Driver Name,Jméno řidiče,
Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu,
Inter Company Reference,Inter Company Reference,
Print Without Amount,Tisknout bez Částka,
% Installed,% Instalováno,
% of materials delivered against this Delivery Note,% Materiálů doručeno proti tomuto dodacímu listu,
Installation Status,Stav instalace,
Excise Page Number,Spotřební Číslo stránky,
Instructions,Instrukce,
From Warehouse,Ze skladu,
Against Sales Order,Proti přijaté objednávce,
Against Sales Order Item,Proti položce přijaté objednávky,
Against Sales Invoice,Proti prodejní faktuře,
Against Sales Invoice Item,Proti položce vydané faktury,
Available Batch Qty at From Warehouse,K dispozici šarže Množství na Od Warehouse,
Available Qty at From Warehouse,K dispozici Množství na Od Warehouse,
Delivery Settings,Nastavení doručení,
Dispatch Settings,Nastavení odesílání,
Dispatch Notification Template,Šablona oznámení o odeslání,
Dispatch Notification Attachment,Oznámení o odeslání,
Leave blank to use the standard Delivery Note format,"Chcete-li použít standardní formát doručení, nechte prázdné",
Send with Attachment,Odeslat s přílohou,
Delay between Delivery Stops,Zpoždění mezi doručením,
Delivery Stop,Zastávka doručení,
Lock,Zámek,
Visited,Navštíveno,
Order Information,Informace o objednávce,
Contact Information,Kontaktní informace,
Email sent to,E-mailem odeslaným,
Dispatch Information,Informace o odeslání,
Estimated Arrival,odhadovaný příjezd,
MAT-DT-.YYYY.-,MAT-DT-.YYYY.-,
Initial Email Notification Sent,Původní e-mailové oznámení bylo odesláno,
Delivery Details,Zasílání,
Driver Email,E-mail řidiče,
Driver Address,Adresa řidiče,
Total Estimated Distance,Celková odhadovaná vzdálenost,
Distance UOM,Vzdálenost UOM,
Departure Time,Čas odjezdu,
Delivery Stops,Doručování se zastaví,
Calculate Estimated Arrival Times,Vypočítat odhadované časy příjezdu,
Use Google Maps Direction API to calculate estimated arrival times,Pro výpočet odhadovaných časů příjezdu použijte rozhraní Google Maps Direction API,
Optimize Route,Optimalizujte trasu,
Use Google Maps Direction API to optimize route,K optimalizaci trasy použijte rozhraní Google Maps Direction API,
In Transit,V tranzitu,
Fulfillment User,Uživatel splnění požadavků,
"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje.",
STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-,
Variant Of,Varianta,
"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",
Is Item from Hub,Je položka z Hubu,
Default Unit of Measure,Výchozí Měrná jednotka,
Maintain Stock,Udržovat stav zásob,
Standard Selling Rate,Standardní prodejní cena,
Auto Create Assets on Purchase,Automatické vytváření aktiv při nákupu,
Asset Naming Series,Série pojmenování aktiv,
Over Delivery/Receipt Allowance (%),Příplatek za doručení / příjem (%),
Barcodes,Čárové kódy,
Shelf Life In Days,Životnost v dnech,
End of Life,Konec životnosti,
Default Material Request Type,Výchozí typ požadavku na zásobování,
Valuation Method,Metoda ocenění,
FIFO,FIFO,
Moving Average,Klouzavý průměr,
Warranty Period (in days),Záruční doba (ve dnech),
Auto re-order,Automatické znovuobjednání,
Reorder level based on Warehouse,Úroveň Změna pořadí na základě Warehouse,
Will also apply for variants unless overrridden,"Bude platit i pro varianty, pokud nebude přepsáno",
Units of Measure,Jednotky měření,
Will also apply for variants,Bude platit i pro varianty,
Serial Nos and Batches,Sériové čísla a dávky,
Has Batch No,Má číslo šarže,
Automatically Create New Batch,Automaticky vytvořit novou dávku,
Batch Number Series,Číselná řada šarží,
"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Příklad: ABCD. #####. Je-li nastavena řada a v transakcích není uvedena šarže, pak se na základě této série vytvoří automatické číslo šarže. Pokud chcete výslovně uvést číslo dávky pro tuto položku, ponechte prázdné místo. Poznámka: Toto nastavení bude mít přednost před předčíslí série Naming v nastavení akcí.",
Has Expiry Date,Má datum vypršení platnosti,
Retain Sample,Zachovat vzorek,
Max Sample Quantity,Max. Množství vzorku,
Maximum sample quantity that can be retained,"Maximální množství vzorku, které lze zadržet",
Has Serial No,Má Sériové číslo,
Serial Number Series,Sériové číslo Series,
"Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Příklad:. ABCD ##### \n 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é.",
Variants,Varianty,
Has Variants,Má varianty,
"If this item has variants, then it cannot be selected in sales orders etc.","Pokud je tato položka má varianty, pak to nemůže být vybrána v prodejních objednávek atd",
Variant Based On,Varianta založená na,
Item Attribute,Položka Atribut,
"Sales, Purchase, Accounting Defaults","Prodej, Nákup, Účetní výchozí",
Item Defaults,Položka Výchozí,
"Purchase, Replenishment Details","Podrobnosti o nákupu, doplnění",
Is Purchase Item,je Nákupní Položka,
Default Purchase Unit of Measure,Výchozí nákupní měrná jednotka,
Minimum Order Qty,Minimální objednávka Množství,
Minimum quantity should be as per Stock UOM,Minimální množství by mělo být podle zásob UOM,
Average time taken by the supplier to deliver,Průměrná doba pořízena dodavatelem dodat,
Is Customer Provided Item,Je položka poskytovaná zákazníkem,
Delivered by Supplier (Drop Ship),Dodáváno dodavatelem (Drop Ship),
Supplier Items,Dodavatele položky,
Foreign Trade Details,Zahraniční obchod Podrobnosti,
Country of Origin,Země původu,
Sales Details,Prodejní Podrobnosti,
Default Sales Unit of Measure,Výchozí prodejní jednotka měření,
Is Sales Item,Je Sales Item,
Max Discount (%),Max sleva (%),
No of Months,Počet měsíců,
Customer Items,Zákazník položky,
Inspection Criteria,Inspekční Kritéria,
Inspection Required before Purchase,Inspekce Požadované před nákupem,
Inspection Required before Delivery,Inspekce Požadované před porodem,
Default BOM,Výchozí BOM,
Supply Raw Materials for Purchase,Dodávky suroviny pro nákup,
If subcontracted to a vendor,Pokud se subdodávky na dodavatele,
Customer Code,Code zákazníků,
Default Item Manufacturer,Výchozí výrobce položky,
Default Manufacturer Part No,Výchozí číslo dílu výrobce,
Show in Website (Variant),Show do webových stránek (Variant),
Items with higher weightage will be shown higher,Položky s vyšším weightage budou zobrazeny vyšší,
Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky,
Website Image,Obrázek webové stránky,
Website Warehouse,Sklad pro web,
"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.",
Website Item Groups,Webové stránky skupiny položek,
List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.,
Copy From Item Group,Kopírovat z bodu Group,
Website Content,Obsah webových stránek,
You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,V tomto poli můžete použít libovolnou platnou značku Bootstrap 4. Zobrazí se na vaší stránce s položkami.,
Total Projected Qty,Celková předpokládaná Množství,
Hub Publishing Details,Podrobnosti o publikování Hubu,
Publish in Hub,Publikovat v Hub,
Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com,
Hub Category to Publish,Kategorie Hubu k publikování,
Hub Warehouse,Hub Warehouse,
"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publikujte &quot;na skladě&quot; nebo &quot;není na skladě&quot; na Hubu na základě skladových zásob dostupných v tomto skladu.,
Synced With Hub,Synchronizovány Hub,
Item Alternative,Položka Alternativa,
Alternative Item Code,Alternativní kód položky,
Two-way,Obousměrné,
Alternative Item Name,Název alternativní položky,
Attribute Name,Název atributu,
Numeric Values,Číselné hodnoty,
From Range,Od Rozsah,
Increment,Přírůstek,
To Range,K Rozsah,
Item Attribute Values,Položka Hodnoty atributů,
Item Attribute Value,Položka Hodnota atributu,
Attribute Value,Hodnota atributu,
Abbreviation,Zkratka,
"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""",
Item Barcode,Položka Barcode,
Barcode Type,Typ čárového kódu,
EAN,EAN,
UPC-A,UPC-A,
Item Customer Detail,Položka Detail Zákazník,
"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",
Ref Code,Ref Code,
Item Default,Položka Výchozí,
Purchase Defaults,Předvolby nákupu,
Default Buying Cost Center,Výchozí středisko nákupu,
Default Supplier,Výchozí Dodavatel,
Default Expense Account,Výchozí výdajový účet,
Sales Defaults,Výchozí hodnoty prodeje,
Default Selling Cost Center,Výchozí Center Prodejní cena,
Item Manufacturer,položka Výrobce,
Item Price,Položka Cena,
Packing Unit,Balení,
Quantity  that must be bought or sold per UOM,"Množství, které musí být zakoupeno nebo prodané podle UOM",
Item Quality Inspection Parameter,Položka Kontrola jakosti Parametr,
Acceptance Criteria,Kritéria přijetí,
Item Reorder,Položka Reorder,
Check in (group),Check in (skupina),
Request for,Žádost o,
Re-order Level,Úroveň pro znovuobjednání,
Re-order Qty,Objednané množství při znovuobjednání,
Item Supplier,Položka Dodavatel,
Item Variant,Položka Variant,
Item Variant Attribute,Položka Variant Atribut,
Do not update variants on save,Neaktualizujte varianty při ukládání,
Fields will be copied over only at time of creation.,Pole budou kopírovány pouze v době vytváření.,
Allow Rename Attribute Value,Povolit přejmenování hodnoty atributu,
Rename Attribute Value in Item Attribute.,Přejmenujte hodnotu atributu v atributu položky.,
Copy Fields to Variant,Kopírování polí na variantu,
Item Website Specification,Položka webových stránek Specifikace,
Table for Item that will be shown in Web Site,"Tabulka k bodu, který se zobrazí na webových stránkách",
Landed Cost Item,Přistálo nákladovou položkou,
Receipt Document Type,Příjem Document Type,
Receipt Document,příjem dokumentů,
Applicable Charges,Použitelné Poplatky,
Purchase Receipt Item,Položka příjemky,
Landed Cost Purchase Receipt,Přistál Náklady doklad o koupi,
Landed Cost Taxes and Charges,Přistál nákladů daně a poplatky,
Landed Cost Voucher,Přistálo Náklady Voucher,
MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-,
Purchase Receipts,Příjmky,
Purchase Receipt Items,Položky příjemky,
Get Items From Purchase Receipts,Položka získaná z dodacího listu,
Distribute Charges Based On,Distribuovat poplatků na základě,
Landed Cost Help,Přistálo Náklady Help,
Manufacturers used in Items,Výrobci používané v bodech,
Limited to 12 characters,Omezeno na 12 znaků,
MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
Set Warehouse,Nastavit sklad,
Sets 'For Warehouse' in each row of the Items table.,Nastaví v každém řádku tabulky „For Warehouse“.,
Requested For,Požadovaných pro,
Partially Ordered,Částečně objednáno,
Transferred,Přestoupil,
% Ordered,% objednáno,
Terms and Conditions Content,Podmínky Content,
Quantity and Warehouse,Množství a sklad,
Lead Time Date,Datum a čas Leadu,
Min Order Qty,Min Objednané množství,
Packed Item,Zabalená položka,
To Warehouse (Optional),Warehouse (volitelné),
Actual Batch Quantity,Skutečné množství šarže,
Prevdoc DocType,Prevdoc DOCTYPE,
Parent Detail docname,Parent Detail docname,
"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.",
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)",
MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-,
From Package No.,Od č balíčku,
Identification of the package for the delivery (for print),Identifikace balíčku pro dodávky (pro tisk),
To Package No.,Balit No.,
If more than one package of the same type (for print),Pokud je více než jeden balík stejného typu (pro tisk),
Package Weight Details,Hmotnost balení Podrobnosti,
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),
Net Weight UOM,Hmotnost UOM,
Gross Weight,Hrubá hmotnost,
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),
Gross Weight UOM,Hrubá Hmotnost UOM,
Packing Slip Item,Položka balícího listu,
DN Detail,DN Detail,
STO-PICK-.YYYY.-,STO-PICK-.RRRR.-,
Material Transfer for Manufacture,Materiál Přenos: Výroba,
Qty of raw materials will be decided based on the qty of the Finished Goods Item,Množství surovin bude rozhodnuto na základě množství hotového zboží,
Parent Warehouse,Nadřízený sklad,
Items under this warehouse will be suggested,Položky v tomto skladu budou navrženy,
Get Item Locations,Získejte umístění položky,
Item Locations,Umístění položky,
Pick List Item,Vyberte položku seznamu,
Picked Qty,Vybráno Množství,
Price List Master,Ceník Master,
Price List Name,Ceník Jméno,
Price Not UOM Dependent,Cena není závislá na UOM,
Applicable for Countries,Pro země,
Price List Country,Ceník Země,
MAT-PRE-.YYYY.-,MAT-PRE-.RRRR.-,
Supplier Delivery Note,Dodávka Dodavatelská poznámka,
Time at which materials were received,"Čas, kdy bylo přijato materiály",
Return Against Purchase Receipt,Návrat Proti doklad o koupi,
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",
Sets 'Accepted Warehouse' in each row of the items table.,Nastaví v každém řádku tabulky položek „Přijatý sklad“.,
Sets 'Rejected Warehouse' in each row of the items table.,Nastaví v každém řádku tabulky položek „Odmítnutý sklad“.,
Raw Materials Consumed,Spotřebované suroviny,
Get Current Stock,Získejte aktuální stav,
Consumed Items,Spotřebované položky,
Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatků,
Auto Repeat Detail,Auto opakovat detail,
Transporter Details,Transporter Podrobnosti,
Vehicle Number,Číslo vozidla,
Vehicle Date,Datum Vehicle,
Received and Accepted,Obdrženo a přijato,
Accepted Quantity,Schválené Množství,
Rejected Quantity,Odmíntnuté množství,
Accepted Qty as per Stock UOM,Přijaté množství podle MJ skladu,
Sample Quantity,Množství vzorku,
Rate and Amount,Cena a částka,
MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
Report Date,Datum Reportu,
Inspection Type,Kontrola Type,
Item Serial No,Položka Výrobní číslo,
Sample Size,Velikost vzorku,
Inspected By,Zkontrolován,
Readings,Čtení,
Quality Inspection Reading,Kvalita Kontrola Reading,
Reading 1,Čtení 1,
Reading 2,Čtení 2,
Reading 3,Čtení 3,
Reading 4,Čtení 4,
Reading 5,Čtení 5,
Reading 6,Čtení 6,
Reading 7,Čtení 7,
Reading 8,Čtení 8,
Reading 9,Čtení 9,
Reading 10,Čtení 10,
Quality Inspection Template Name,Jméno šablony inspekce kvality,
Quick Stock Balance,Rychlá bilance zásob,
Available Quantity,dostupné množství,
Distinct unit of an Item,Samostatnou jednotku z položky,
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Změnu skladu je možné provést pouze prostřednictvím Skladového pohybu / dodacím listem / nákupním dokladem,
Purchase / Manufacture Details,Nákup / Výroba Podrobnosti,
Creation Document Type,Tvorba Typ dokumentu,
Creation Document No,Tvorba dokument č,
Creation Date,Datum vytvoření,
Creation Time,Čas vytvoření,
Asset Details,Podrobnosti o majetku,
Asset Status,Stav majetku,
Delivery Document Type,Dodávka Typ dokumentu,
Delivery Document No,Dodávka dokument č,
Delivery Time,Dodací lhůta,
Invoice Details,Podrobnosti faktury,
Warranty / AMC Details,Záruka / AMC Podrobnosti,
Warranty Expiry Date,Záruka Datum vypršení platnosti,
AMC Expiry Date,AMC Datum vypršení platnosti,
Under Warranty,V rámci záruky,
Out of Warranty,Out of záruky,
Under AMC,Podle AMC,
Out of AMC,Out of AMC,
Warranty Period (Days),Záruční doba (dny),
Serial No Details,Serial No Podrobnosti,
MAT-STE-.YYYY.-,MAT-STE-.YYYY.-,
Stock Entry Type,Typ položky skladu,
Stock Entry (Outward GIT),Zásoby (Outward GIT),
Material Consumption for Manufacture,Spotřeba materiálu pro výrobu,
Repack,Přebalit,
Send to Subcontractor,Odeslat subdodavateli,
Delivery Note No,Dodacího listu,
Sales Invoice No,Prodejní faktuře č,
Purchase Receipt No,Číslo příjmky,
Inspection Required,Kontrola Povinné,
From BOM,Od BOM,
For Quantity,Pro Množství,
As per Stock UOM,Podle Stock nerozpuštěných,
Including items for sub assemblies,Včetně položek pro podsestav,
Default Source Warehouse,Výchozí zdrojový sklad,
Source Warehouse Address,Adresa zdrojového skladu,
Default Target Warehouse,Výchozí cílový sklad,
Target Warehouse Address,Cílová adresa skladu,
Update Rate and Availability,Obnovovací rychlost a dostupnost,
Total Incoming Value,Celková hodnota Příchozí,
Total Outgoing Value,Celková hodnota Odchozí,
Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In),
Additional Costs,Dodatečné náklady,
Total Additional Costs,Celkem Dodatečné náklady,
Customer or Supplier Details,Zákazníka nebo dodavatele Podrobnosti,
Per Transferred,Za převedené,
Stock Entry Detail,Detail pohybu na skladu,
Basic Rate (as per Stock UOM),Základní sazba (dle Stock nerozpuštěných),
Basic Amount,Základní částka,
Additional Cost,Dodatečné náklady,
Serial No / Batch,Výrobní číslo / Batch,
BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce,
Material Request used to make this Stock Entry,Zadaný požadavek materiálu k výrobě této skladové karty,
Subcontracted Item,Subdodavatelská položka,
Against Stock Entry,Proti zadávání zásob,
Stock Entry Child,Zásoby dítě,
PO Supplied Item,PO dodaná položka,
Reference Purchase Receipt,Referenční potvrzení o nákupu,
Stock Ledger Entry,Reklamní Ledger Entry,
Outgoing Rate,Odchozí Rate,
Actual Qty After Transaction,Skutečné Množství Po transakci,
Stock Value Difference,Reklamní Value Rozdíl,
Stock Queue (FIFO),Sklad fronty (FIFO),
Is Cancelled,Je Zrušeno,
Stock Reconciliation,Reklamní Odsouhlasení,
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.",
MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-,
Reconciliation JSON,Odsouhlasení JSON,
Stock Reconciliation Item,Reklamní Odsouhlasení Item,
Before reconciliation,Před smíření,
Current Serial No,Aktuální sériové číslo,
Current Valuation Rate,Aktuální ocenění,
Current Amount,Aktuální výše,
Quantity Difference,množství Rozdíl,
Amount Difference,výše Rozdíl,
Item Naming By,Položka Pojmenování By,
Default Item Group,Výchozí bod Group,
Default Stock UOM,Výchozí Skladem UOM,
Sample Retention Warehouse,Úložiště uchovávání vzorků,
Default Valuation Method,Výchozí metoda ocenění,
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.",
Action if Quality inspection is not submitted,"Akce, pokud není předložena kontrola kvality",
Show Barcode Field,Show čárového kódu Field,
Convert Item Description to Clean HTML,Převést položku Popis k vyčištění HTML,
Auto insert Price List rate if missing,"Auto vložka Ceník sazba, pokud chybí",
Allow Negative Stock,Povolit Negativní Sklad,
Automatically Set Serial Nos based on FIFO,Automaticky nastavit sériových čísel na základě FIFO,
Set Qty in Transactions based on Serial No Input,Nastavte počet transakcí na základě sériového č. Vstupu,
Auto Material Request,Auto materiálu Poptávka,
Raise Material Request when stock reaches re-order level,Zvýšit Materiál vyžádání při stock dosáhne úrovně re-order,
Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka,
Inter Warehouse Transfer Settings,Nastavení přenosu Inter Warehouse,
Allow Material Transfer From Delivery Note and Sales Invoice,Povolit přenos materiálu z dodacího listu a prodejní faktury,
Allow Material Transfer From Purchase Receipt and Purchase Invoice,Povolit převod materiálu z dokladu o nákupu a faktury za nákup,
Freeze Stock Entries,Freeze Stock Příspěvky,
Stock Frozen Upto,Reklamní Frozen aľ,
Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny],
Role Allowed to edit frozen stock,Role povoleno upravovat zmrazené zásoby,
Batch Identification,Identifikace šarže,
Use Naming Series,Používejte sérii pojmenování,
Naming Series Prefix,Pojmenování předpony řady,
UOM Category,Kategorie UOM,
UOM Conversion Detail,UOM konverze Detail,
Variant Field,Pole variant,
A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny.",
Warehouse Detail,Sklad Detail,
Warehouse Name,Název Skladu,
Warehouse Contact Info,Sklad Kontaktní informace,
PIN,KOLÍK,
ISS-.YYYY.-,ISS-.RRRR.-,
Raised By (Email),Vznesené (e-mail),
Issue Type,Typ vydání,
Issue Split From,Vydání Rozdělit od,
Service Level,Úroveň služby,
Response By,Odpověď od,
Response By Variance,Reakce podle variace,
Ongoing,Pokračující,
Resolution By,Rozlišení podle,
Resolution By Variance,Rozlišení podle variace,
Service Level Agreement Creation,Vytvoření dohody o úrovni služeb,
First Responded On,Prvně odpovězeno dne,
Resolution Details,Rozlišení Podrobnosti,
Opening Date,Datum otevření,
Opening Time,Otevírací doba,
Resolution Date,Rozlišení Datum,
Via Customer Portal,Prostřednictvím zákaznického portálu,
Support Team,Tým podpory,
Issue Priority,Priorita vydání,
Service Day,Servisní den,
Workday,Pracovní den,
Default Priority,Výchozí priorita,
Priorities,Priority,
Support Hours,Hodiny podpory,
Support and Resolution,Podpora a rozlišení,
Default Service Level Agreement,Výchozí dohoda o úrovni služeb,
Entity,Entity,
Agreement Details,Podrobnosti dohody,
Response and Resolution Time,Doba odezvy a rozlišení,
Service Level Priority,Priorita úrovně služeb,
Resolution Time,Čas rozlišení,
Support Search Source,Podporovaný vyhledávací zdroj,
Source Type,Typ zdroje,
Query Route String,Dotaz řetězce trasy,
Search Term Param Name,Hledaný výraz Param Name,
Response Options,Možnosti odpovědi,
Response Result Key Path,Cesta k klíčovému výsledku odpovědi,
Post Route String,Přidat řetězec trasy,
Post Route Key List,Přidat seznam klíčových cest,
Post Title Key,Klíč příspěvku,
Post Description Key,Tlačítko Popis příspěvku,
Link Options,Možnosti odkazu,
Source DocType,Zdroj DocType,
Result Title Field,Výsledek Název pole,
Result Preview Field,Pole pro náhled výsledků,
Result Route Field,Výsledek pole trasy,
Service Level Agreements,Dohody o úrovni služeb,
Track Service Level Agreement,Smlouva o úrovni služeb sledování,
Allow Resetting Service Level Agreement,Povolit obnovení dohody o úrovni služeb,
Close Issue After Days,V blízkosti Issue po několika dnech,
Auto close Issue after 7 days,Auto v blízkosti Issue po 7 dnech,
Support Portal,Portál podpory,
Get Started Sections,Začínáme sekce,
Show Latest Forum Posts,Zobrazit nejnovější příspěvky ve fóru,
Forum Posts,Příspěvky ve fóru,
Forum URL,Adresa URL fóra,
Get Latest Query,Získejte nejnovější dotaz,
Response Key List,Seznam odpovědí,
Post Route Key,Zadejte klíč trasy,
Search APIs,API vyhledávání,
SER-WRN-.YYYY.-,SER-WRN-.YYYY.-,
Issue Date,Datum vydání,
Item and Warranty Details,Položka a Záruka Podrobnosti,
Warranty / AMC Status,Záruka / AMC Status,
Resolved By,Vyřešena,
Service Address,Servisní adresy,
If different than customer address,Pokud se liší od adresy zákazníka,
Raised By,Vznesené,
From Company,Od Společnosti,
Rename Tool,Přejmenování,
Utilities,Utilities,
Type of document to rename.,Typ dokumentu přejmenovat.,
File to Rename,Soubor k přejmenování,
"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",
Rename Log,Přejmenovat Přihlásit,
SMS Log,SMS Log,
Sender Name,Jméno odesílatele,
Sent On,Poslán na,
No of Requested SMS,Počet žádaným SMS,
Requested Numbers,Požadované Čísla,
No of Sent SMS,Počet odeslaných SMS,
Sent To,Odeslána,
Absent Student Report,Absent Student Report,
Assessment Plan Status,Stav plánu hodnocení,
Asset Depreciation Ledger,Asset Odpisy Ledger,
Asset Depreciations and Balances,Asset Odpisy a zůstatků,
Available Stock for Packing Items,K dispozici skladem pro balení položek,
Bank Clearance Summary,Souhrn bankovního zúčtování,
Bank Remittance,Bankovní převody,
Batch Item Expiry Status,Batch položky vypršení platnosti Stav,
Batch-Wise Balance History,Batch-Wise Balance History,
BOM Explorer,Průzkumník BOM,
BOM Search,Vyhledání kusovníku,
BOM Stock Calculated,Výpočet zásob BOM,
BOM Variance Report,Zpráva o odchylce kusovníku,
Campaign Efficiency,Efektivita kampaně,
Cash Flow,Tok peněz,
Completed Work Orders,Dokončené pracovní příkazy,
To Produce,K výrobě,
Produced,Produkoval,
Consolidated Financial Statement,Konsolidovaný finanční výkaz,
Course wise Assessment Report,Průběžná hodnotící zpráva,
Customer Acquisition and Loyalty,Zákazník Akvizice a loajality,
Customer Credit Balance,Zákazník Credit Balance,
Customer Ledger Summary,Shrnutí účetní knihy zákazníka,
Customer-wise Item Price,Cena předmětu podle přání zákazníka,
Customers Without Any Sales Transactions,Zákazníci bez jakýchkoli prodejních transakcí,
Daily Timesheet Summary,Denní časový rozvrh Souhrn,
Daily Work Summary Replies,Denní shrnutí odpovědí,
DATEV,DATEV,
Delayed Item Report,Zpráva o zpoždění položky,
Delayed Order Report,Zpoždění objednávky,
Delivered Items To Be Billed,Dodávaných výrobků fakturovaných,
Delivery Note Trends,Dodací list Trendy,
Electronic Invoice Register,Elektronický fakturační registr,
Employee Advance Summary,Zaměstnanecké předběžné shrnutí,
Employee Billing Summary,Přehled fakturace zaměstnanců,
Employee Birthday,Narozeniny zaměstnance,
Employee Information,Informace o zaměstnanci,
Employee Leave Balance,Zaměstnanec Leave Balance,
Employee Leave Balance Summary,Shrnutí zůstatku zaměstnanců,
Employees working on a holiday,Zaměstnanci pracující na dovolenou,
Eway Bill,Eway Bill,
Expiring Memberships,Platnost členství,
Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC],
Final Assessment Grades,Závěrečné hodnocení,
Fixed Asset Register,Registr dlouhodobých aktiv,
Gross and Net Profit Report,Hrubý a čistý zisk,
GST Itemised Purchase Register,GST Itemised Purchase Register,
GST Itemised Sales Register,GST Itemized Sales Register,
GST Purchase Register,GST Nákupní registr,
GST Sales Register,Obchodní registr GST,
GSTR-1,GSTR-1,
GSTR-2,GSTR-2,
Hotel Room Occupancy,Hotel Occupancy,
HSN-wise-summary of outward supplies,HSN - shrnutí vnějších dodávek,
Inactive Customers,neaktivní zákazníci,
Inactive Sales Items,Neaktivní prodejní položky,
IRS 1099,IRS 1099,
Issued Items Against Work Order,Vydávané položky proti pracovní zakázce,
Projected Quantity as Source,Množství projekcí as Zdroj,
Item Balance (Simple),Balance položky (jednoduché),
Item Price Stock,Položka Cena Sklad,
Item Prices,Ceny Položek,
Item Shortage Report,Položka Nedostatek Report,
Item Variant Details,Podrobnosti o variantě položky,
Item-wise Price List Rate,Item-moudrý Ceník Rate,
Item-wise Purchase History,Item-moudrý Historie nákupů,
Item-wise Purchase Register,Item-wise registr nákupu,
Item-wise Sales History,Item-moudrý Sales History,
Item-wise Sales Register,Item-moudrý Sales Register,
Items To Be Requested,Položky se budou vyžadovat,
Reserved,Rezervováno,
Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level,
Lead Details,Detaily leadu,
Lead Owner Efficiency,Vedoucí účinnost vlastníka,
Loan Repayment and Closure,Splácení a uzavření úvěru,
Loan Security Status,Stav zabezpečení úvěru,
Lost Opportunity,Ztracená příležitost,
Maintenance Schedules,Plány údržby,
Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny,
Monthly Attendance Sheet,Měsíční Účast Sheet,
Open Work Orders,Otevřete pracovní objednávky,
Qty to Deliver,Množství k dodání,
Patient Appointment Analytics,Analýza jmenování pacienta,
Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury,
Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka",
Procurement Tracker,Sledování nákupu,
Product Bundle Balance,Zůstatek produktu,
Production Analytics,výrobní Analytics,
Profit and Loss Statement,Výkaz zisků a ztrát,
Profitability Analysis,Analýza ziskovost,
Project Billing Summary,Přehled fakturace projektu,
Project wise Stock Tracking,Promyšlené sledování zásob,
Project wise Stock Tracking ,Sledování zboží dle projektu,
Prospects Engaged But Not Converted,"Perspektivy zapojení, ale nekonverze",
Purchase Analytics,Nákup Analytika,
Purchase Invoice Trends,Trendy přijatách faktur,
Qty to Receive,Množství pro příjem,
Received Qty Amount,Přijatá částka Množství,
Billed Qty,Účtované množství,
Purchase Order Trends,Nákupní objednávka trendy,
Purchase Receipt Trends,Doklad o koupi Trendy,
Purchase Register,Nákup Register,
Quotation Trends,Uvozovky Trendy,
Quoted Item Comparison,Citoval Položka Porovnání,
Received Items To Be Billed,"Přijaté položek, které mají být účtovány",
Qty to Order,Množství k objednávce,
Requested Items To Be Transferred,Požadované položky mají být převedeny,
Qty to Transfer,Množství pro přenos,
Salary Register,plat Register,
Sales Analytics,Prodejní Analytics,
Sales Invoice Trends,Prodejní faktury Trendy,
Sales Order Trends,Prodejní objednávky Trendy,
Sales Partner Commission Summary,Shrnutí provize prodejního partnera,
Sales Partner Target Variance based on Item Group,Cílová odchylka prodejního partnera na základě skupiny položek,
Sales Partner Transaction Summary,Souhrn transakcí obchodního partnera,
Sales Partners Commission,Obchodní partneři Komise,
Invoiced Amount (Exclusive Tax),Fakturovaná částka (bez daně),
Average Commission Rate,Průměrná cena Komise,
Sales Payment Summary,Přehled plateb prodeje,
Sales Person Commission Summary,Souhrnné informace Komise pro prodejce,
Sales Person Target Variance Based On Item Group,Cílová odchylka prodejní osoby na základě skupiny položek,
Sales Person-wise Transaction Summary,Prodej Person-moudrý Shrnutí transakce,
Sales Register,Sales Register,
Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti,
Serial No Status,Serial No Status,
Serial No Warranty Expiry,Pořadové č záruční lhůty,
Stock Ageing,Reklamní Stárnutí,
Stock and Account Value Comparison,Porovnání hodnoty akcií a účtu,
Stock Projected Qty,Reklamní Plánovaná POČET,
Student and Guardian Contact Details,Student a Guardian Kontaktní údaje,
Student Batch-Wise Attendance,Student Batch-Wise Účast,
Student Fee Collection,Student Fee Collection,
Student Monthly Attendance Sheet,Student měsíční návštěvnost Sheet,
Subcontracted Item To Be Received,Subdodávaná položka k přijetí,
Subcontracted Raw Materials To Be Transferred,"Subdodavatelské suroviny, které mají být převedeny",
Supplier Ledger Summary,Shrnutí účetní knihy dodavatele,
Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics,
Support Hour Distribution,Distribuce hodinové podpory,
TDS Computation Summary,Shrnutí výpočtu TDS,
TDS Payable Monthly,TDS splatné měsíčně,
Territory Target Variance Based On Item Group,Územní cílová odchylka podle skupiny položek,
Territory-wise Sales,Teritoriální prodej,
Total Stock Summary,Shrnutí souhrnného stavu,
Trial Balance,Trial Balance,
Trial Balance (Simple),Zkušební zůstatek (jednoduchý),
Trial Balance for Party,Trial váhy pro stranu,
Unpaid Expense Claim,Neplacené Náklady na pojistná,
Warehouse wise Item Balance Age and Value,Warehouse wise Item Balance věk a hodnota,
Work Order Stock Report,Zpráva o stavu pracovní smlouvy,
Work Orders in Progress,Pracovní příkazy v procesu,
Validation Error,Chyba ověření,
Automatically Process Deferred Accounting Entry,Automaticky zpracovat odložený účetní záznam,
Bank Clearance,Bankovní odbavení,
Bank Clearance Detail,Podrobnosti o bankovním odbavení,
Update Cost Center Name / Number,Aktualizujte název / číslo nákladového střediska,
Journal Entry Template,Šablona zápisu do deníku,
Template Title,Název šablony,
Journal Entry Type,Typ položky deníku,
Journal Entry Template Account,Účet šablony zápisu do deníku,
Process Deferred Accounting,Zpracovat odložené účetnictví,
Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Ruční zadání nelze vytvořit! V nastavení účtů zakažte automatické zadávání odloženého účetnictví a zkuste to znovu,
End date cannot be before start date,Datum ukončení nemůže být před datem zahájení,
Total Counts Targeted,Celkový počet zacílených,
Total Counts Completed,Celkový počet dokončen,
Counts Targeted: {0},Počet zacílených: {0},
Payment Account is mandatory,Platební účet je povinný,
"If checked, the full amount will be deducted from taxable income before calculating income tax without any declaration or proof submission.","Pokud je zaškrtnuto, bude odečtena celá částka ze zdanitelného příjmu před výpočtem daně z příjmu bez jakéhokoli prohlášení nebo předložení dokladu.",
Disbursement Details,Podrobnosti o výplatě,
Material Request Warehouse,Sklad požadavku na materiál,
Select warehouse for material requests,Vyberte sklad pro požadavky na materiál,
Transfer Materials For Warehouse {0},Přenos materiálů do skladu {0},
Production Plan Material Request Warehouse,Sklad požadavku na materiál výrobního plánu,
Set From Warehouse,Nastaveno ze skladu,
Source Warehouse (Material Transfer),Zdrojový sklad (přenos materiálu),
Sets 'Source Warehouse' in each row of the items table.,Nastaví v každém řádku tabulky položek „Zdrojový sklad“.,
Sets 'Target Warehouse' in each row of the items table.,Nastaví v každém řádku tabulky položek „Target Warehouse“.,
Show Cancelled Entries,Zobrazit zrušené položky,
Backdated Stock Entry,Zpětný vstup akcií,
Row #{}: Currency of {} - {} doesn't matches company currency.,Řádek # {}: Měna {} - {} neodpovídá měně společnosti.,
{} Assets created for {},{} Díla vytvořená pro {},
{0} Number {1} is already used in {2} {3},{0} Číslo {1} je již použito v {2} {3},
Update Bank Clearance Dates,Aktualizujte data zúčtování banky,
Healthcare Practitioner: ,Praktický lékař:,
Lab Test Conducted: ,Provedený laboratorní test:,
Lab Test Event: ,Laboratorní testovací událost:,
Lab Test Result: ,Výsledek laboratorního testu:,
Clinical Procedure conducted: ,Provedený klinický postup:,
Therapy Session Charges: {0},Poplatky za terapeutické sezení: {0},
Therapy: ,Terapie:,
Therapy Plan: ,Terapeutický plán:,
Total Counts Targeted: ,Celkový počet zacílených:,
Total Counts Completed: ,Celkový počet dokončených:,
Andaman and Nicobar Islands,Andamanské a Nikobarské ostrovy,
Andhra Pradesh,Andhra Pradesh,
Arunachal Pradesh,Arunáčalpradéš,
Assam,Assam,
Bihar,Bihar,
Chandigarh,Chandigarh,
Chhattisgarh,Chhattisgarh,
Dadra and Nagar Haveli,Dadra a Nagar Haveli,
Daman and Diu,Daman a Diu,
Delhi,Dillí,
Goa,Goa,
Gujarat,Gudžarát,
Haryana,Haryana,
Himachal Pradesh,Himáčalpradéš,
Jammu and Kashmir,Džammú a Kašmír,
Jharkhand,Jharkhand,
Karnataka,Karnataka,
Kerala,Kerala,
Lakshadweep Islands,Ostrovy Lakshadweep,
Madhya Pradesh,Madhya Pradesh,
Maharashtra,Maharashtra,
Manipur,Manipur,
Meghalaya,Meghalaya,
Mizoram,Mizoram,
Nagaland,Nagaland,
Odisha,Urísa,
Other Territory,Jiné území,
Pondicherry,Pondicherry,
Punjab,Paňdžáb,
Rajasthan,Rádžasthán,
Sikkim,Sikkim,
Tamil Nadu,Tamil Nadu,
Telangana,Telangana,
Tripura,Tripura,
Uttar Pradesh,Uttarpradéš,
Uttarakhand,Uttarakhand,
West Bengal,Západní Bengálsko,
Is Mandatory,Je povinná,
Published on,Publikováno dne,
Service Received But Not Billed,"Služba přijata, ale není účtována",
Deferred Accounting Settings,Nastavení odloženého účetnictví,
Book Deferred Entries Based On,Zarezervujte odložené položky na základě,
"If ""Months"" is selected then fixed amount will be booked as deferred revenue or expense for each month irrespective of number of days in a month. Will be prorated if deferred revenue or expense is not booked for an entire month.","Pokud je vybrána možnost „Měsíce“, bude pevná částka zaúčtována jako odložený výnos nebo výdaj za každý měsíc bez ohledu na počet dní v měsíci. Pokud nebudou odložené výnosy nebo výdaje rezervovány na celý měsíc, budou rozděleny podle nákladů.",
Days,Dny,
Months,Měsíce,
Book Deferred Entries Via Journal Entry,Zarezervujte si odložené položky prostřednictvím záznamu v deníku,
If this is unchecked direct GL Entries will be created to book Deferred Revenue/Expense,"Pokud toto políčko nezaškrtnete, budou vytvořeny přímé položky GL k zaúčtování odložených výnosů / výdajů",
Submit Journal Entries,Odeslat položky deníku,
If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Pokud není zaškrtnuto, budou se deníkové záznamy ukládat ve stavu konceptu a budou muset být odeslány ručně",
Enable Distributed Cost Center,Povolit distribuované nákladové středisko,
Distributed Cost Center,Distribuované nákladové středisko,
Dunning,Upomínání,
DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
Overdue Days,Dny po splatnosti,
Dunning Type,Typ upomínání,
Dunning Fee,Poplatek za upomínání,
Dunning Amount,Částka upuštění,
Resolved,Vyřešeno,
Unresolved,Nevyřešené,
Printing Setting,Nastavení tisku,
Body Text,Text těla,
Closing Text,Závěrečný text,
Resolve,Odhodlání,
Dunning Letter Text,Upuštění od dopisu Text,
Is Default Language,Je výchozí jazyk,
Letter or Email Body Text,Text v dopise nebo e-mailu,
Letter or Email Closing Text,Dopis nebo e-mail závěrečný text,
Body and Closing Text Help,Text a nápověda pro závěrečný text,
Overdue Interval,Interval po splatnosti,
Dunning Letter,Upomínka,
"This section allows the user to set the Body and Closing text of the Dunning Letter for the Dunning Type based on language, which can be used in Print.","Tato část umožňuje uživateli nastavit text a závěrečný text upomínkového dopisu pro typ upomínání na základě jazyka, který lze použít v tisku.",
Reference Detail No,Referenční číslo č,
Custom Remarks,Vlastní poznámky,
Please select a Company first.,Nejprve vyberte společnost.,
"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Řádek # {0}: Typ referenčního dokumentu musí být jeden z prodejní objednávky, prodejní faktury, zápisu do deníku nebo upomínání",
POS Closing Entry,Uzávěrka vstupu POS,
POS Opening Entry,Otevírací vstup POS,
POS Transactions,POS transakce,
POS Closing Entry Detail,Detail uzávěrky vstupu POS,
Opening Amount,Počáteční částka,
Closing Amount,Konečná částka,
POS Closing Entry Taxes,POS uzavírání vstupních daní,
POS Invoice,POS faktura,
ACC-PSINV-.YYYY.-,ACC-PSINV-.RRRR.-,
Consolidated Sales Invoice,Konsolidovaná prodejní faktura,
Return Against POS Invoice,Vraťte se proti POS faktuře,
Consolidated,Konsolidované,
POS Invoice Item,Položka faktury POS,
POS Invoice Merge Log,Protokol sloučení faktury POS,
POS Invoices,POS faktury,
Consolidated Credit Note,Konsolidovaný dobropis,
POS Invoice Reference,Odkaz na fakturu POS,
Set Posting Date,Nastavte datum zaúčtování,
Opening Balance Details,Počáteční zůstatek Podrobnosti,
POS Opening Entry Detail,Detail otevření vstupenky POS,
POS Payment Method,Způsob platby POS,
Payment Methods,platební metody,
Process Statement Of Accounts,Zpracování výpisu z účtů,
General Ledger Filters,Filtry hlavní knihy,
Customers,Zákazníci,
Select Customers By,Vyberte Zákazníci podle,
Fetch Customers,Načíst zákazníky,
Send To Primary Contact,Odeslat primárnímu kontaktu,
Print Preferences,Předvolby tisku,
Include Ageing Summary,Zahrnout shrnutí stárnutí,
Enable Auto Email,Povolit automatický e-mail,
Filter Duration (Months),Délka filtru (měsíce),
CC To,CC To,
Help Text,Pomocný text,
Emails Queued,E-maily ve frontě,
Process Statement Of Accounts Customer,Zpracování výpisu z účtu zákazníka,
Billing Email,Fakturační e-mail,
Primary Contact Email,Primární kontaktní e-mail,
PSOA Cost Center,Nákladové středisko PSOA,
PSOA Project,Projekt PSOA,
ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.RRRR.-,
Supplier GSTIN,Dodavatel GSTIN,
Place of Supply,Místo dodání,
Select Billing Address,Vyberte fakturační adresu,
GST Details,Podrobnosti GST,
GST Category,Kategorie GST,
Registered Regular,Registrováno pravidelně,
Registered Composition,Registrovaná kompozice,
Unregistered,Neregistrovaný,
SEZ,SEZ,
Overseas,Zámoří,
UIN Holders,Držitelé UIN,
With Payment of Tax,S platbou daně,
Without Payment of Tax,Bez platby daně,
Invoice Copy,Kopie faktury,
Original for Recipient,Originál pro příjemce,
Duplicate for Transporter,Duplikát pro Transporter,
Duplicate for Supplier,Duplikát pro dodavatele,
Triplicate for Supplier,Třikrát pro dodavatele,
Reverse Charge,Zpětný poplatek,
Y,Y,
N,N,
E-commerce GSTIN,Elektronický obchod GSTIN,
Reason For Issuing document,Důvod vystavení dokladu,
01-Sales Return,01-Návratnost prodeje,
02-Post Sale Discount,Sleva 02-post prodej,
03-Deficiency in services,03-Nedostatek služeb,
04-Correction in Invoice,04 - Oprava na faktuře,
05-Change in POS,05 - Změna v POS,
06-Finalization of Provisional assessment,06-Dokončení prozatímního posouzení,
07-Others,07-Ostatní,
Eligibility For ITC,Způsobilost pro ITC,
Input Service Distributor,Distributor vstupních služeb,
Import Of Service,Import služby,
Import Of Capital Goods,Dovoz investičního zboží,
Ineligible,Neoprávněné,
All Other ITC,Všechny ostatní ITC,
Availed ITC Integrated Tax,Využíval integrovanou daň ITC,
Availed ITC Central Tax,Využíval centrální daň ITC,
Availed ITC State/UT Tax,Využil stát ITC / daň UT,
Availed ITC Cess,Využil ITC Cess,
Is Nil Rated or Exempted,Je nulová nebo je osvobozena,
Is Non GST,Není GST,
ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.YYYY.-,
E-Way Bill No.,E-Way Bill č.,
Is Consolidated,Je konsolidováno,
Billing Address GSTIN,Fakturační adresa GSTIN,
Customer GSTIN,Zákazník GSTIN,
GST Transporter ID,ID přepravce GST,
Distance (in km),Vzdálenost (v km),
Road,Silnice,
Air,Vzduch,
Rail,Železnice,
Ship,Loď,
GST Vehicle Type,Typ vozidla GST,
Over Dimensional Cargo (ODC),Over Dimensional Cargo (ODC),
Consumer,Spotřebitel,
Deemed Export,Považován za export,
Port Code,Kód přístavu,
 Shipping Bill Number,Číslo faktury za přepravu,
Shipping Bill Date,Datum faktury za přepravu,
Subscription End Date,Datum ukončení předplatného,
Follow Calendar Months,Sledujte kalendářní měsíce,
If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Pokud je toto zaškrtnuto, budou se v den zahájení kalendářního měsíce a čtvrtletí vytvářet nové nové faktury bez ohledu na aktuální datum zahájení faktury",
Generate New Invoices Past Due Date,Generování nových faktur po splatnosti,
New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Nové faktury budou generovány podle plánu, i když jsou aktuální faktury nezaplacené nebo po splatnosti",
Document Type ,Typ dokumentu,
Subscription Price Based On,Cena předplatného na základě,
Fixed Rate,Pevná sazba,
Based On Price List,Na základě ceníku,
Monthly Rate,Měsíční sazba,
Cancel Subscription After Grace Period,Zrušte předplatné po uplynutí odkladné lhůty,
Source State,Stav zdroje,
Is Inter State,Je Inter State,
Purchase Details,Podrobnosti o nákupu,
Depreciation Posting Date,Datum zaúčtování odpisů,
Purchase Order Required for Purchase Invoice & Receipt Creation,Nákupní objednávka požadovaná pro vytvoření nákupní faktury a vytvoření účtenky,
Purchase Receipt Required for Purchase Invoice Creation,Potvrzení o nákupu požadované pro vytvoření faktury za nákup,
"By default, the Supplier Name is set as per the Supplier Name entered. If you want Suppliers to be named by a  ","Ve výchozím nastavení je název dodavatele nastaven podle zadaného názvu dodavatele. Pokud chcete, aby Dodavatelé byli pojmenováni a",
 choose the 'Naming Series' option.,vyberte možnost „Pojmenování série“.,
Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Při vytváření nové nákupní transakce nakonfigurujte výchozí ceník. Ceny položek budou načteny z tohoto ceníku.,
"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice or Receipt without creating a Purchase Order first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Order' checkbox in the Supplier master.","Pokud je tato možnost nakonfigurována na „Ano“, ERPNext vám zabrání ve vytvoření nákupní faktury nebo účtenky, aniž byste nejprve vytvořili nákupní objednávku. Tuto konfiguraci lze přepsat pro konkrétního dodavatele povolením zaškrtávacího políčka „Povolit vytvoření faktury za nákup bez objednávky“ v hlavním okně dodavatele.",
"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice without creating a Purchase Receipt first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Receipt' checkbox in the Supplier master.","Pokud je tato možnost nakonfigurována na „Ano“, ERPNext vám zabrání ve vytvoření nákupní faktury, aniž byste nejprve vytvořili nákupní doklad. Tuto konfiguraci lze pro konkrétního dodavatele přepsat povolením zaškrtávacího políčka „Povolit vytvoření faktury za nákup bez dokladu o nákupu“ v hlavním okně dodavatele.",
Quantity & Stock,Množství a sklad,
Call Details,Detaily hovoru,
Authorised By,Schváleno,
Signee (Company),Signee (společnost),
Signed By (Company),Podepsáno (společností),
First Response Time,Čas první reakce,
Request For Quotation,Žádost o nabídku,
Opportunity Lost Reason Detail,Detail ztraceného důvodu příležitosti,
Access Token Secret,Přístup k tajnému tokenu,
Add to Topics,Přidat do témat,
...Adding Article to Topics,... Přidávání článku k tématům,
Add Article to Topics,Přidat článek do témat,
This article is already added to the existing topics,Tento článek je již přidán k existujícím tématům,
Add to Programs,Přidat do programů,
Programs,Programy,
...Adding Course to Programs,... Přidání kurzu k programům,
Add Course to Programs,Přidejte kurz do programů,
This course is already added to the existing programs,Tento kurz je již přidán k existujícím programům,
Learning Management System Settings,Nastavení systému pro správu učení,
Enable Learning Management System,Povolit systém pro správu učení,
Learning Management System Title,Název systému řízení učení,
...Adding Quiz to Topics,... Přidání kvízu k tématům,
Add Quiz to Topics,Přidejte kvíz k tématům,
This quiz is already added to the existing topics,Tento kvíz je již přidán k existujícím tématům,
Enable Admission Application,Povolit žádost o přijetí,
EDU-ATT-.YYYY.-,EDU-ATT-.RRRR.-,
Marking attendance,Značení docházky,
Add Guardians to Email Group,Přidejte do skupiny e-mailů strážce,
Attendance Based On,Docházka na základě,
Check this to mark the student as present in case the student is not attending the institute to participate or represent the institute in any event.\n\n,"Zaškrtnutím tohoto políčka označíte studenta jako přítomného v případě, že se student v žádném případě neúčastní ústavu, aby se ho účastnil nebo zastupoval.",
Add to Courses,Přidat do kurzů,
...Adding Topic to Courses,... Přidání tématu do kurzů,
Add Topic to Courses,Přidejte téma do kurzů,
This topic is already added to the existing courses,Toto téma je již přidáno do stávajících kurzů,
"If Shopify does not have a customer in the order, then while syncing the orders, the system will consider the default customer for the order","Pokud Shopify nemá v objednávce zákazníka, bude systém při synchronizaci objednávek považovat výchozího zákazníka pro objednávku",
The accounts are set by the system automatically but do confirm these defaults,"Účty nastavuje systém automaticky, ale tyto výchozí hodnoty potvrzují",
Default Round Off Account,Výchozí zaokrouhlovací účet,
Failed Import Log,Neúspěšný import protokolu,
Fixed Error Log,Opravený protokol chyb,
Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Společnost {0} již existuje. Pokračováním přepíšete společnost a účtovou osnovu,
Meta Data,Meta data,
Unresolve,Nevyřešit,
Create Document,Vytvořit dokument,
Mark as unresolved,Označit jako nevyřešené,
TaxJar Settings,Nastavení TaxJar,
Sandbox Mode,Sandbox Mode,
Enable Tax Calculation,Povolit výpočet daně,
Create TaxJar Transaction,Vytvořte transakci TaxJar,
Credentials,Pověření,
Live API Key,Živý klíč API,
Sandbox API Key,Klíč Sandbox API,
Configuration,Konfigurace,
Tax Account Head,Vedoucí daňového účtu,
Shipping Account Head,Vedoucí přepravního účtu,
Practitioner Name,Jméno praktického lékaře,
Enter a name for the Clinical Procedure Template,Zadejte název šablony klinické procedury,
Set the Item Code which will be used for billing the Clinical Procedure.,"Nastavte kód položky, který bude použit pro fakturaci klinického postupu.",
Select an Item Group for the Clinical Procedure Item.,Vyberte skupinu položek pro položku klinického postupu.,
Clinical Procedure Rate,Míra klinického postupu,
Check this if the Clinical Procedure is billable and also set the rate.,"Zaškrtněte toto políčko, pokud je klinický postup fakturovatelný, a také nastavte rychlost.",
Check this if the Clinical Procedure utilises consumables. Click ,"Toto zkontrolujte, pokud klinický postup využívá spotřební materiál. Klepněte na",
 to know more,vědět více,
"You can also set the Medical Department for the template. After saving the document, an Item will automatically be created for billing this Clinical Procedure. You can then use this template while creating Clinical Procedures for Patients. Templates save you from filling up redundant data every single time. You can also create templates for other operations like Lab Tests, Therapy Sessions, etc.","Pro šablonu můžete také nastavit lékařské oddělení. Po uložení dokumentu se automaticky vytvoří položka pro fakturaci tohoto klinického postupu. Tuto šablonu pak můžete použít při vytváření Klinických postupů pro pacienty. Šablony vám pomohou pokaždé zaplnit nadbytečná data. Můžete také vytvořit šablony pro další operace, jako jsou laboratorní testy, terapeutické relace atd.",
Descriptive Test Result,Výsledek popisného testu,
Allow Blank,Povolit prázdné,
Descriptive Test Template,Popisná testovací šablona,
"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Pokud chcete sledovat mzdy a další operace HRMS pro praktického lékaře, vytvořte zaměstnance a propojte jej zde.",
Set the Practitioner Schedule you just created. This will be used while booking appointments.,"Nastavte si plán praktiků, který jste právě vytvořili. To bude použito při rezervaci schůzek.",
Create a service item for Out Patient Consulting.,Vytvořte položku služby pro Out Patient Consulting.,
"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Pokud tento zdravotnický pracovník pracuje pro interní oddělení, vytvořte položku služby pro hospitalizované návštěvy.",
Set the Out Patient Consulting Charge for this Practitioner.,U tohoto praktického lékaře stanovte poplatek za konzultaci s pacientem.,
"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","Pokud tento zdravotnický pracovník pracuje také pro interní oddělení, stanovte poplatek za návštěvu lůžkového lékaře pro tohoto praktického lékaře.",
"If checked, a customer will be created for every Patient. Patient Invoices will be created against this Customer. You can also select existing Customer while creating a Patient. This field is checked by default.","Pokud je zaškrtnuto, vytvoří se zákazník pro každého pacienta. Proti tomuto zákazníkovi budou vytvořeny pacientské faktury. Při vytváření pacienta můžete také vybrat stávajícího zákazníka. Toto pole je ve výchozím nastavení zaškrtnuto.",
Collect Registration Fee,Vybírat registrační poplatek,
"If your Healthcare facility bills registrations of Patients, you can check this and set the Registration Fee in the field below. Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.","Pokud vaše zdravotnické zařízení účtuje registrace pacientů, můžete to zkontrolovat a nastavit registrační poplatek v poli níže. Zaškrtnutí tohoto políčka ve výchozím nastavení vytvoří nové pacienty se zdravotním stavem a bude povoleno až po fakturaci registračního poplatku.",
Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,"Zaškrtnutím tohoto políčka se automaticky vytvoří prodejní faktura vždy, když je pacientovi rezervována schůzka.",
Healthcare Service Items,Položky zdravotní péče,
"You can create a service item for Inpatient Visit Charge and set it here. Similarly, you can set up other Healthcare Service Items for billing in this section. Click ",Můžete vytvořit položku služby pro poplatek za hospitalizaci a nastavit ji zde. Podobně můžete v této části nastavit další položky služeb zdravotní péče pro fakturaci. Klepněte na,
Set up default Accounts for the Healthcare Facility,Nastavte výchozí účty pro zdravotnické zařízení,
"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Pokud chcete přepsat výchozí nastavení účtů a nakonfigurovat účty příjmů a pohledávek pro Healthcare, můžete tak učinit zde.",
Out Patient SMS alerts,Upozornění na SMS mimo pacienta,
"If you want to send SMS alert on Patient Registration, you can enable this option. Similary, you can set up Out Patient SMS alerts for other functionalities in this section. Click ","Chcete-li odeslat upozornění SMS na registraci pacienta, můžete tuto možnost povolit. Podobně můžete v této části nastavit výstrahy SMS pro pacienta pro další funkce. Klepněte na",
Admission Order Details,Podrobnosti objednávky,
Admission Ordered For,Objednáno vstupné,
Expected Length of Stay,Očekávaná délka pobytu,
Admission Service Unit Type,Typ jednotky přijímacího servisu,
Healthcare Practitioner (Primary),Praktický lékař (primární),
Healthcare Practitioner (Secondary),Praktický lékař (sekundární),
Admission Instruction,Pokyny k přijetí,
Chief Complaint,Hlavní stížnost,
Medications,Léky,
Investigations,Vyšetřování,
Discharge Detials,Vybíjení Detials,
Discharge Ordered Date,Datum objednání vyložení,
Discharge Instructions,Pokyny k vybíjení,
Follow Up Date,Následné datum,
Discharge Notes,Poznámky k vybíjení,
Processing Inpatient Discharge,Zpracování propuštění pacientů,
Processing Patient Admission,Zpracování přijetí pacienta,
Check-in time cannot be greater than the current time,Čas příjezdu nesmí být větší než aktuální čas,
Process Transfer,Přenos procesu,
HLC-LAB-.YYYY.-,HLC-LAB-.RRRR.-,
Expected Result Date,Očekávané datum výsledku,
Expected Result Time,Očekávaný čas výsledku,
Printed on,Vytištěno na,
Requesting Practitioner,Žádající odborník,
Requesting Department,Žádající oddělení,
Employee (Lab Technician),Zaměstnanec (laboratorní technik),
Lab Technician Name,Jméno laboranta,
Lab Technician Designation,Označení laboratorního technika,
Compound Test Result,Výsledek složené zkoušky,
Organism Test Result,Výsledek testu organismu,
Sensitivity Test Result,Výsledek testu citlivosti,
Worksheet Print,Tisk listu,
Worksheet Instructions,Pokyny k listu,
Result Legend Print,Výsledek Tisk legendy,
Print Position,Pozice tisku,
Bottom,Dno,
Top,Horní,
Both,Oba,
Result Legend,Legenda výsledku,
Lab Tests,Laboratorní testy,
No Lab Tests found for the Patient {0},Nebyly nalezeny žádné laboratorní testy pro pacienta {0},
"Did not send SMS, missing patient mobile number or message content.","Neposlal SMS, chybějící číslo mobilního telefonu pacienta nebo obsah zprávy.",
No Lab Tests created,Nebyly vytvořeny žádné laboratorní testy,
Creating Lab Tests...,Vytváření laboratorních testů ...,
Lab Test Group Template,Šablona laboratorní skupiny,
Add New Line,Přidat nový řádek,
Secondary UOM,Sekundární UOM,
"<b>Single</b>: Results which require only a single input.\n<br>\n<b>Compound</b>: Results which require multiple event inputs.\n<br>\n<b>Descriptive</b>: Tests which have multiple result components with manual result entry.\n<br>\n<b>Grouped</b>: Test templates which are a group of other test templates.\n<br>\n<b>No Result</b>: Tests with no results, can be ordered and billed but no Lab Test will be created. e.g.. Sub Tests for Grouped results","<b>Single</b> : Výsledky, které vyžadují pouze jeden vstup.<br> <b>Sloučenina</b> : Výsledky, které vyžadují více vstupů událostí.<br> <b>Popisné</b> : Testy, které mají více složek výsledků s ručním zadáváním výsledků.<br> <b>Seskupeno</b> : Testovací šablony, které jsou skupinou dalších testovacích šablon.<br> <b>Žádný výsledek</b> : Testy bez výsledků, lze objednat a účtovat, ale nebude vytvořen žádný laboratorní test. např. Dílčí testy pro seskupené výsledky",
"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Pokud není zaškrtnuto, položka nebude k dispozici v prodejních fakturách pro fakturaci, ale lze ji použít při vytváření skupinových testů.",
Description ,Popis,
Descriptive Test,Popisný test,
Group Tests,Skupinové testy,
Instructions to be printed on the worksheet,"Pokyny, které mají být vytištěny na listu",
"Information to help easily interpret the test report, will be printed as part of the Lab Test result.","Informace, které usnadní interpretaci protokolu o testu, budou vytištěny jako součást výsledku laboratorního testu.",
Normal Test Result,Normální výsledek testu,
Secondary UOM Result,Výsledek sekundárního UOM,
Italic,Kurzíva,
Underline,Zdůraznit,
Organism,Organismus,
Organism Test Item,Testovací položka organismu,
Colony Population,Populace kolonií,
Colony UOM,Colony UOM,
Tobacco Consumption (Past),Spotřeba tabáku (minulá),
Tobacco Consumption (Present),Spotřeba tabáku (současnost),
Alcohol Consumption (Past),Spotřeba alkoholu (minulá),
Alcohol Consumption (Present),Spotřeba alkoholu (současnost),
Billing Item,Fakturační položka,
Medical Codes,Lékařské kódy,
Clinical Procedures,Klinické postupy,
Order Admission,Objednávka Vstupné,
Scheduling Patient Admission,Plánování přijetí pacienta,
Order Discharge,Vybití objednávky,
Sample Details,Ukázkové podrobnosti,
Collected On,Shromážděno dne,
No. of prints,Počet výtisků,
Number of prints required for labelling the samples,Počet výtisků požadovaných pro označení vzorků,
HLC-VTS-.YYYY.-,HLC-VTS-.RRRR.-,
In Time,Včas,
Out Time,Out Time,
Payroll Cost Center,Mzdové náklady,
Approvers,Schvalovatelé,
The first Approver in the list will be set as the default Approver.,První schvalovatel v seznamu bude nastaven jako výchozí schvalovatel.,
Shift Request Approver,Schvalovatel žádosti o změnu,
PAN Number,PAN číslo,
Provident Fund Account,Účet fondu Provident,
MICR Code,Kód MICR,
Repay unclaimed amount from salary,Vrátit nevyzvednutou částku z platu,
Deduction from salary,Srážka z platu,
Expired Leaves,Vypršela platnost listů,
Reference No,Referenční číslo,
Haircut percentage is the percentage difference between market value of the Loan Security and the value ascribed to that Loan Security when used as collateral for that loan.,"Procento srážky je procentní rozdíl mezi tržní hodnotou zajištění úvěru a hodnotou připisovanou tomuto zajištění úvěru, pokud je použit jako kolaterál pro danou půjčku.",
Loan To Value Ratio expresses the ratio of the loan amount to the value of the security pledged. A loan security shortfall will be triggered if this falls below the specified value for any loan ,"Poměr půjčky k hodnotě vyjadřuje poměr výše půjčky k hodnotě zastaveného cenného papíru. Nedostatek zabezpečení půjčky se spustí, pokud poklesne pod stanovenou hodnotu jakékoli půjčky",
If this is not checked the loan by default will be considered as a Demand Loan,"Pokud to není zaškrtnuto, bude se úvěr ve výchozím nastavení považovat za půjčku na vyžádání",
This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,Tento účet slouží k rezervaci splátek půjčky od dlužníka a také k vyplácení půjček dlužníkovi,
This account is capital account which is used to allocate capital for loan disbursal account ,"Tento účet je kapitálovým účtem, který se používá k přidělení kapitálu pro účet vyplácení půjček",
This account will be used for booking loan interest accruals,Tento účet bude použit pro rezervaci časového rozlišení úroků z půjčky,
This account will be used for booking penalties levied due to delayed repayments,Tento účet bude použit k rezervaci pokut uložených v důsledku zpožděných splátek,
Variant BOM,Varianta kusovníku,
Template Item,Položka šablony,
Select template item,Vyberte položku šablony,
Select variant item code for the template item {0},Vyberte kód varianty položky pro položku šablony {0},
Downtime Entry,Vstup do odstávky,
DT-,DT-,
Workstation / Machine,Pracovní stanice / stroj,
Operator,Operátor,
In Mins,In Mins,
Downtime Reason,Důvod prostoje,
Stop Reason,Přestat Důvod,
Excessive machine set up time,Nadměrný čas pro nastavení stroje,
Unplanned machine maintenance,Neplánovaná údržba stroje,
On-machine press checks,Kontroly lisu na stroji,
Machine operator errors,Chyby obsluhy stroje,
Machine malfunction,Porucha stroje,
Electricity down,Elektřina dole,
Operation Row Number,Číslo řádku operace,
Operation {0} added multiple times in the work order {1},Operace {0} přidána několikrát v pracovní objednávce {1},
"If ticked, multiple materials can be used for a single Work Order. This is useful if one or more time consuming products are being manufactured.","Pokud je zaškrtnuto, lze pro jednu pracovní objednávku použít více materiálů. To je užitečné, pokud se vyrábí jeden nebo více časově náročných produktů.",
Backflush Raw Materials,Backflush suroviny,
"The Stock Entry of type 'Manufacture' is known as backflush. Raw materials being consumed to manufacture finished goods is known as backflushing. <br><br> When creating Manufacture Entry, raw-material items are backflushed based on BOM of production item. If you want raw-material items to be backflushed based on Material Transfer entry made against that Work Order instead, then you can set it under this field.","Skladová položka typu „Výroba“ je známá jako backflush. Suroviny, které se spotřebovávají k výrobě hotových výrobků, se nazývají zpětné proplachování.<br><br> Při vytváření položky výroby jsou položky surovin zpětně vyplaceny na základě kusovníku výrobní položky. Pokud chcete, aby položky surovin byly zpětně proplaceny na základě vstupu převodu materiálu provedeného namísto této pracovní objednávky, můžete jej nastavit v tomto poli.",
Work In Progress Warehouse,Work In Progress Warehouse,
This Warehouse will be auto-updated in the Work In Progress Warehouse field of Work Orders.,Tento sklad se automaticky aktualizuje v poli Work In Progress Warehouse v pracovních objednávkách.,
Finished Goods Warehouse,Sklad hotových výrobků,
This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,Tento sklad se automaticky aktualizuje v poli Cílový sklad pracovního příkazu.,
"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Pokud je zatrženo, náklady na kusovníku se automaticky aktualizují na základě míry ocenění / ceny ceníku / míry posledního nákupu surovin.",
Source Warehouses (Optional),Zdrojové sklady (volitelné),
"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","Systém vyzvedne materiály z vybraných skladů. Pokud není zadáno, systém vytvoří materiální požadavek na nákup.",
Lead Time,Dodací lhůta,
PAN Details,PAN Podrobnosti,
Create Customer,Vytvořit zákazníka,
Invoicing,Fakturace,
Enable Auto Invoicing,Povolit automatickou fakturaci,
Send Membership Acknowledgement,Odeslat potvrzení členství,
Send Invoice with Email,Odeslat fakturu e-mailem,
Membership Print Format,Formát tisku členství,
Invoice Print Format,Formát tisku faktury,
Revoke <Key></Key>,Zrušit&lt;Key&gt;&lt;/Key&gt;,
You can learn more about memberships in the manual. ,Další informace o členství najdete v příručce.,
ERPNext Docs,ERPNext Docs,
Regenerate Webhook Secret,Znovu vygenerujte tajemství Webhook,
Generate Webhook Secret,Generovat Webhook Secret,
Copy Webhook URL,Zkopírujte adresu URL Webhooku,
Linked Item,Propojená položka,
Is Recurring,Opakuje se,
HRA Exemption,Výjimka HRA,
Monthly House Rent,Měsíční nájem domu,
Rented in Metro City,Pronajato v Metro City,
HRA as per Salary Structure,HRA podle struktury platů,
Annual HRA Exemption,Roční výjimka HRA,
Monthly HRA Exemption,Měsíční výjimka HRA,
House Rent Payment Amount,Částka platby za pronájem domu,
Rented From Date,Pronajato od data,
Rented To Date,Pronajato k dnešnímu dni,
Monthly Eligible Amount,Způsobilá částka za měsíc,
Total Eligible HRA Exemption,Celková způsobilá výjimka HRA,
Validating Employee Attendance...,Ověření docházky zaměstnanců ...,
Submitting Salary Slips and creating Journal Entry...,Odeslání výplatních pásek a vytvoření zápisu do deníku ...,
Calculate Payroll Working Days Based On,Vypočítejte mzdové pracovní dny na základě,
Consider Unmarked Attendance As,Zvažte neoznačenou účast jako,
Fraction of Daily Salary for Half Day,Frakce denního platu za půl dne,
Component Type,Typ součásti,
Provident Fund,Podpůrný fond,
Additional Provident Fund,Dodatečný zajišťovací fond,
Provident Fund Loan,Půjčka na penzijní fond,
Professional Tax,Profesionální daň,
Is Income Tax Component,Je složkou daně z příjmu,
Component properties and references ,Vlastnosti komponent a odkazy,
Additional Salary ,Dodatečný plat,
Condtion and formula,Podmínky a vzorec,
Unmarked days,Neoznačené dny,
Absent Days,Chybějící dny,
Conditions and Formula variable and example,Podmínky a proměnná vzorce a příklad,
Feedback By,Zpětná vazba od,
MTNG-.YYYY.-.MM.-.DD.-,MTNG-.RRRR .-. MM .-. DD.-,
Manufacturing Section,Sekce výroby,
Sales Order Required for Sales Invoice & Delivery Note Creation,Pro vytvoření prodejní faktury a dodacího listu je vyžadována prodejní objednávka,
Delivery Note Required for Sales Invoice Creation,Pro vytvoření prodejní faktury je nutný dodací list,
"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","Ve výchozím nastavení je jméno zákazníka nastaveno podle zadaného celého jména. Pokud chcete, aby zákazníci byli pojmenováni a",
Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Při vytváření nové prodejní transakce nakonfigurujte výchozí ceník. Ceny položek budou načteny z tohoto ceníku.,
"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice or Delivery Note without creating a Sales Order first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Sales Order' checkbox in the Customer master.","Pokud je tato možnost nakonfigurována na „Ano“, ERPNext vám zabrání ve vytvoření prodejní faktury nebo dodacího listu, aniž byste nejprve vytvořili prodejní objednávku. Tuto konfiguraci lze pro konkrétního zákazníka přepsat povolením zaškrtávacího políčka „Povolit vytvoření prodejní faktury bez prodejní objednávky“ v hlavním okně zákazníka.",
"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice without creating a Delivery Note first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Delivery Note' checkbox in the Customer master.","Pokud je tato možnost nakonfigurována na „Ano“, ERPNext vám zabrání ve vytvoření prodejní faktury, aniž byste nejprve vytvořili dodací list. Tuto konfiguraci lze pro konkrétního zákazníka přepsat povolením zaškrtávacího políčka „Povolit vytvoření prodejní faktury bez dodacího listu“ v hlavním okně zákazníka.",
Default Warehouse for Sales Return,Výchozí sklad pro vrácení prodeje,
Default In Transit Warehouse,Výchozí v tranzitním skladu,
Enable Perpetual Inventory For Non Stock Items,"Povolit trvalou inventuru pro položky, které nejsou skladem",
HRA Settings,Nastavení HRA,
Basic Component,Základní komponenta,
HRA Component,Součást HRA,
Arrear Component,Arrear Component,
Please enter the company name to confirm,Pro potvrzení zadejte název společnosti,
Quotation Lost Reason Detail,Nabídka ztraceného důvodu - detail,
Enable Variants,Povolit varianty,
Save Quotations as Draft,Uložit nabídky jako koncept,
MAT-DN-RET-.YYYY.-,MAT-DN-RET-.YYYY.-,
Please Select a Customer,Vyberte prosím zákazníka,
Against Delivery Note Item,Proti položce dodacího listu,
Is Non GST ,Není GST,
Image Description,Popis obrázku,
Transfer Status,Stav přenosu,
MAT-PR-RET-.YYYY.-,MAT-PR-RET-.RRRR.-,
Track this Purchase Receipt against any Project,Sledujte toto potvrzení o nákupu vůči jakémukoli projektu,
Please Select a Supplier,Vyberte prosím dodavatele,
Add to Transit,Přidat do veřejné dopravy,
Set Basic Rate Manually,Nastavte základní sazbu ručně,
"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","Ve výchozím nastavení je název položky nastaven podle zadaného kódu položky. Pokud chcete, aby položky byly pojmenovány a",
Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Nastavit výchozí sklad pro transakce zásob. Toto bude načteno do výchozího skladu v hlavní položce.,
"This will allow stock items to be displayed in negative values. Using this option depends on your use case. With this option unchecked, the system warns before obstructing a transaction that is causing negative stock.","To umožní, aby se skladové položky zobrazovaly v záporných hodnotách. Použití této možnosti závisí na vašem případu použití. Pokud není tato možnost zaškrtnuta, systém varuje před překážením transakce, která způsobuje záporné zásoby.",
Choose between FIFO and Moving Average Valuation Methods. Click ,Vyberte si mezi metodami ocenění FIFO a klouzavým průměrem. Klepněte na,
 to know more about them.,vědět o nich více.,
Show 'Scan Barcode' field above every child table to insert Items with ease.,"Chcete-li snadno vkládat položky, zobrazte nad každou podřízenou tabulkou pole „Skenovat čárový kód“.",
"Serial numbers for stock will be set automatically based on the Items entered based on first in first out in transactions like Purchase/Sales Invoices, Delivery Notes, etc.","Sériová čísla pro akcie budou nastavena automaticky na základě položek zadaných na základě prvního do prvního v transakcích, jako jsou nákupní / prodejní faktury, dodací listy atd.",
"If blank, parent Warehouse Account or company default will be considered in transactions","Pokud je prázdné, bude při transakcích zohledněn nadřazený účet skladu nebo výchozí nastavení společnosti",
Service Level Agreement Details,Podrobnosti smlouvy o úrovni služeb,
Service Level Agreement Status,Stav smlouvy o úrovni služeb,
On Hold Since,Pozastaveno od,
Total Hold Time,Celková doba zadržení,
Response Details,Podrobnosti odpovědi,
Average Response Time,Průměrná doba odezvy,
User Resolution Time,Čas rozlišení uživatele,
SLA is on hold since {0},SLA je pozastavena od {0},
Pause SLA On Status,Pozastavit SLA na stav,
Pause SLA On,Pozastavit SLA zapnuto,
Greetings Section,Sekce pozdravů,
Greeting Title,Pozdrav titul,
Greeting Subtitle,Pozdrav titulky,
Youtube ID,Youtube ID,
Youtube Statistics,Statistiky YouTube,
Views,Pohledy,
Dislikes,Nelíbí se,
Video Settings,Nastavení videa,
Enable YouTube Tracking,Povolit sledování YouTube,
30 mins,30 minut,
1 hr,1 hod,
6 hrs,6 hodin,
Patient Progress,Pokrok pacienta,
Targetted,Cílené,
Score Obtained,Dosažené skóre,
Sessions,Session,
Average Score,Průměrné skóre,
Select Assessment Template,Vyberte šablonu pro hodnocení,
 out of ,mimo,
Select Assessment Parameter,Vyberte parametr posouzení,
Gender: ,Rod:,
Contact: ,Kontakt:,
Total Therapy Sessions: ,Celková terapeutická sezení:,
Monthly Therapy Sessions: ,Měsíční terapeutická sezení:,
Patient Profile,Profil pacienta,
Point Of Sale,Místě prodeje,
Email sent successfully.,Email úspěšně odeslán.,
Search by invoice id or customer name,Hledání podle čísla faktury nebo jména zákazníka,
Invoice Status,Stav faktury,
Filter by invoice status,Filtrovat podle stavu faktury,
Select item group,Vyberte skupinu položek,
No items found. Scan barcode again.,Žádné předměty nenalezeny. Znovu naskenujte čárový kód.,
"Search by customer name, phone, email.","Hledání podle jména zákazníka, telefonu, e-mailu.",
Enter discount percentage.,Zadejte procento slevy.,
Discount cannot be greater than 100%,Sleva nesmí být větší než 100%,
Enter customer's email,Zadejte e-mail zákazníka,
Enter customer's phone number,Zadejte telefonní číslo zákazníka,
Customer contact updated successfully.,Kontakt se zákazníkem byl úspěšně aktualizován.,
Item will be removed since no serial / batch no selected.,"Položka bude odstraněna, protože není vybráno žádné sériové číslo / dávka.",
Discount (%),Sleva (%),
You cannot submit the order without payment.,Objednávku nemůžete odeslat bez platby.,
You cannot submit empty order.,Nemůžete odeslat prázdnou objednávku.,
To Be Paid,Bude zaplaceno,
Create POS Opening Entry,Vytvořte otevírací položku POS,
Please add Mode of payments and opening balance details.,Přidejte prosím způsob platby a počáteční zůstatek.,
Toggle Recent Orders,Přepnout nedávné objednávky,
Save as Draft,Uložit jako koncept,
You must add atleast one item to save it as draft.,"Musíte přidat alespoň jednu položku, abyste ji uložili jako koncept.",
There was an error saving the document.,Při ukládání dokumentu došlo k chybě.,
You must select a customer before adding an item.,Před přidáním položky musíte vybrat zákazníka.,
Please Select a Company,Vyberte prosím společnost,
Active Leads,Aktivní zájemci,
Please Select a Company.,Vyberte prosím společnost.,
BOM Operations Time,Čas provozu kusovníku,
BOM ID,ID kusovníku,
BOM Item Code,Kód položky kusovníku,
Time (In Mins),Čas (v minutách),
Sub-assembly BOM Count,Počet kusů podsestavy,
View Type,Typ zobrazení,
Total Delivered Amount,Celková dodaná částka,
Downtime Analysis,Analýza prostojů,
Machine,Stroj,
Downtime (In Hours),Odstávka (v hodinách),
Employee Analytics,Analýza zaměstnanců,
"""From date"" can not be greater than or equal to ""To date""",„Od data“ nesmí být větší než nebo rovno „Od data“,
Exponential Smoothing Forecasting,Exponenciální vyhlazování prognóz,
First Response Time for Issues,Čas první reakce na problémy,
First Response Time for Opportunity,Čas první reakce na příležitost,
Depreciatied Amount,Odepsaná částka,
Period Based On,Období založené na,
Date Based On,Datum založeno na,
{0} and {1} are mandatory,{0} a {1} jsou povinné,
Consider Accounting Dimensions,Zvažte účetní dimenze,
Income Tax Deductions,Srážky daně z příjmu,
Income Tax Component,Složka daně z příjmu,
Income Tax Amount,Výše daně z příjmu,
Reserved Quantity for Production,Rezervované množství pro výrobu,
Projected Quantity,Předpokládané množství,
 Total Sales Amount,Celková částka prodeje,
Job Card Summary,Shrnutí pracovní karty,
Id,Id,
Time Required (In Mins),Požadovaný čas (v minutách),
From Posting Date,Od data zveřejnění,
To Posting Date,K datu zaúčtování,
No records found,Nenalezeny žádné záznamy,
Customer/Lead Name,Jméno zákazníka / zájemce,
Unmarked Days,Neoznačené dny,
Jan,Jan,
Feb,Února,
Mar,Mar,
Apr,Dubna,
Aug,Srpen,
Sep,Září,
Oct,Října,
Nov,listopad,
Dec,Prosinec,
Summarized View,Shrnutý pohled,
Production Planning Report,Zpráva o plánování výroby,
Order Qty,Množství objednávky,
Raw Material Code,Kód suroviny,
Raw Material Name,Název suroviny,
Allotted Qty,Přidělené množství,
Expected Arrival Date,Očekávané datum příjezdu,
Arrival Quantity,Množství příjezdu,
Raw Material Warehouse,Sklad surovin,
Order By,Seřadit podle,
Include Sub-assembly Raw Materials,Zahrnout suroviny podsestavy,
Professional Tax Deductions,Profesionální odpočty daní,
Program wise Fee Collection,Programově moudrý výběr poplatků,
Fees Collected,Poplatky vybírány,
Project Summary,Shrnutí projektu,
Total Tasks,Celkem úkolů,
Tasks Completed,Úkoly byly dokončeny,
Tasks Overdue,Úkoly po splatnosti,
Completion,Dokončení,
Provident Fund Deductions,Srážky fondu poskytovatele,
Purchase Order Analysis,Analýza nákupní objednávky,
From and To Dates are required.,Od a do jsou požadována data.,
To Date cannot be before From Date.,To Date nemůže být před From Date.,
Qty to Bill,Množství Billovi,
Group by Purchase Order,Seskupit podle nákupní objednávky,
 Purchase Value,Hodnota nákupu,
Total Received Amount,Celková přijatá částka,
Quality Inspection Summary,Shrnutí kontroly kvality,
 Quoted Amount,Citovaná částka,
Lead Time (Days),Dodací lhůta (dny),
Include Expired,Zahrnout vypršela,
Recruitment Analytics,Náborová analýza,
Applicant name,Jméno uchazeče,
Job Offer status,Stav pracovní nabídky,
On Date,Na rande,
Requested Items to Order and Receive,Požadované položky k objednání a přijetí,
Salary Payments Based On Payment Mode,Platy na základě platebního režimu,
Salary Payments via ECS,Platy přes ECS,
Account No,Číslo účtu,
IFSC,IFSC,
MICR,MICR,
Sales Order Analysis,Analýza prodejní objednávky,
Amount Delivered,Doručená částka,
Delay (in Days),Zpoždění (ve dnech),
Group by Sales Order,Seskupit podle prodejní objednávky,
 Sales Value,Hodnota prodeje,
Stock Qty vs Serial No Count,Skladové množství vs sériové číslo se nepočítá,
Serial No Count,Sériové číslo,
Work Order Summary,Shrnutí pracovní objednávky,
Produce Qty,Množství produkce,
Lead Time (in mins),Dodací lhůta (v minutách),
Charts Based On,Grafy založené na,
YouTube Interactions,Interakce s YouTube,
Published Date,Datum zveřejnění,
Barnch,Barnch,
Select a Company,Vyberte společnost,
Opportunity {0} created,Byla vytvořena příležitost {0},
Kindly select the company first,Nejprve prosím vyberte společnost,
Please enter From Date and To Date to generate JSON,"Chcete-li vygenerovat JSON, zadejte datum a datum",
PF Account,Účet PF,
PF Amount,Částka PF,
Additional PF,Další PF,
PF Loan,PF Půjčka,
Download DATEV File,Stáhněte si soubor DATEV,
Numero has not set in the XML file,Numero není nastaveno v souboru XML,
Inward Supplies(liable to reverse charge),Dovozní dodávky (podléhající přenesení daňové povinnosti),
This is based on the course schedules of this Instructor,Vychází to z rozvrhů kurzu tohoto instruktora,
Course and Assessment,Kurz a hodnocení,
Course {0} has been added to all the selected programs successfully.,Kurz {0} byl úspěšně přidán do všech vybraných programů.,
Programs updated,Programy aktualizovány,
Program and Course,Program a kurz,
{0} or {1} is mandatory,{0} nebo {1} je povinné,
Mandatory Fields,Povinná pole,
Student {0}: {1} does not belong to Student Group {2},Student {0}: {1} nepatří do skupiny Student {2},
Student Attendance record {0} already exists against the Student {1},Záznam docházky studentů {0} proti studentovi již existuje {1},
Duplicate Entry,Duplicitní záznam,
Course and Fee,Kurz a poplatek,
Not eligible for the admission in this program as per Date Of Birth,Nemá nárok na přijetí v tomto programu podle data narození,
Topic {0} has been added to all the selected courses successfully.,Téma {0} bylo úspěšně přidáno do všech vybraných kurzů.,
Courses updated,Kurzy aktualizovány,
{0} {1} has been added to all the selected topics successfully.,{0} {1} byl úspěšně přidán do všech vybraných témat.,
Topics updated,Témata aktualizována,
Academic Term and Program,Akademický termín a program,
Last Stock Transaction for item {0} was on {1}.,Poslední skladová transakce u položky {0} proběhla {1}.,
Stock Transactions for Item {0} cannot be posted before this time.,Skladové transakce s položkou {0} nelze do této doby zaúčtovat.,
Please remove this item and try to submit again or update the posting time.,Odeberte tuto položku a zkuste ji odeslat znovu nebo aktualizujte čas zveřejnění.,
Failed to Authenticate the API key.,Ověření klíče API se nezdařilo.,
Invalid Credentials,Neplatná pověření,
URL can only be a string,URL může být pouze řetězec,
"Here is your webhook secret, this will be shown to you only once.","Toto je vaše tajemství webhooku, které se vám zobrazí pouze jednou.",
The payment for this membership is not paid. To generate invoice fill the payment details,Platba za toto členství se neplatí. Pro vygenerování faktury vyplňte platební údaje,
An invoice is already linked to this document,Faktura je již propojena s tímto dokumentem,
No customer linked to member {},Žádný zákazník není propojen s členem {},
You need to set <b>Debit Account</b> in Membership Settings,V nastavení členství musíte nastavit <b>debetní účet</b>,
You need to set <b>Default Company</b> for invoicing in Membership Settings,Musíte nastavit <b>Výchozí společnost</b> pro fakturaci v Nastavení členství,
You need to enable <b>Send Acknowledge Email</b> in Membership Settings,Musíte povolit <b>Odeslat potvrzovací e-mail</b> v Nastavení členství,
Error creating membership entry for {0},Chyba při vytváření záznamu o členství pro {0},
A customer is already linked to this Member,Zákazník je již s tímto členem propojen,
End Date must not be lesser than Start Date,Datum ukončení nesmí být menší než datum zahájení,
Employee {0} already has Active Shift {1}: {2},Zaměstnanec {0} již má aktivní posun {1}: {2},
 from {0},od {0},
 to {0},do {0},
Please select Employee first.,Nejprve prosím vyberte Zaměstnanec.,
Please set {0} for the Employee or for Department: {1},Nastavte prosím {0} pro zaměstnance nebo pro oddělení: {1},
To Date should be greater than From Date,Do data by mělo být větší než Od data,
Employee Onboarding: {0} is already for Job Applicant: {1},Zapojení zaměstnanců: {0} je již pro uchazeče o zaměstnání: {1},
Job Offer: {0} is already for Job Applicant: {1},Nabídka práce: {0} je již pro uchazeče o zaměstnání: {1},
Only Shift Request with status 'Approved' and 'Rejected' can be submitted,Lze odeslat pouze žádost o změnu se stavem „Schváleno“ a „Odmítnuto“,
Shift Assignment: {0} created for Employee: {1},Přiřazení směny: {0} vytvořeno pro zaměstnance: {1},
You can not request for your Default Shift: {0},O svůj výchozí posun nemůžete požádat: {0},
Only Approvers can Approve this Request.,Tuto žádost mohou schválit pouze schvalovatelé.,
Asset Value Analytics,Analýza hodnoty majetku,
Category-wise Asset Value,Hodnota aktiv podle kategorie,
Total Assets,Celková aktiva,
New Assets (This Year),Nová aktiva (tento rok),
Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Řádek {{}: Datum zaúčtování odpisů by se nemělo rovnat Datumu použitelnosti.,
Incorrect Date,Nesprávné datum,
Invalid Gross Purchase Amount,Neplatná hrubá částka nákupu,
There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,U aktiva probíhá aktivní údržba nebo opravy. Před zrušením aktiva je musíte všechny dokončit.,
% Complete,% Kompletní,
Back to Course,Zpět na kurz,
Finish Topic,Dokončit téma,
Mins,Min,
by,podle,
Back to,Zpět k,
Enrolling...,Registrace ...,
You have successfully enrolled for the program ,Úspěšně jste se zaregistrovali do programu,
Enrolled,Zapsáno,
Watch Intro,Sledujte úvod,
We're here to help!,"Jsme tu, abychom vám pomohli!",
Frequently Read Articles,Často číst články,
Please set a default company address,Nastavte prosím výchozí adresu společnosti,
{0} is not a valid state! Check for typos or enter the ISO code for your state.,{0} není platný stav! Zkontrolujte překlepy nebo zadejte kód ISO svého státu.,
Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,"Při analýze účtové osnovy došlo k chybě: Ujistěte se, že žádné dva účty nemají stejný název",
Plaid invalid request error,Přehozená chyba neplatné žádosti,
Please check your Plaid client ID and secret values,Zkontrolujte prosím ID klienta a tajné hodnoty,
Bank transaction creation error,Chyba při vytváření bankovní transakce,
Unit of Measurement,Jednotka měření,
Row #{}: Selling rate for item {} is lower than its {}. Selling rate should be atleast {},Řádek {}: Míra prodeje pro položku {} je nižší než její {}. Míra prodeje by měla být alespoň {},
Fiscal Year {0} Does Not Exist,Fiskální rok {0} neexistuje,
Row # {0}: Returned Item {1} does not exist in {2} {3},Řádek č. {0}: Vrácená položka {1} neexistuje v doméně {2} {3},
Valuation type charges can not be marked as Inclusive,Poplatky typu ocenění nelze označit jako inkluzivní,
You do not have permissions to {} items in a {}.,K {} položkám v {} nemáte oprávnění.,
Insufficient Permissions,Nedostatečná oprávnění,
You are not allowed to update as per the conditions set in {} Workflow.,Nemáte povolení k aktualizaci podle podmínek stanovených v {} Workflow.,
Expense Account Missing,Chybí výdajový účet,
{0} is not a valid Value for Attribute {1} of Item {2}.,{0} není platná hodnota pro atribut {1} položky {2}.,
Invalid Value,Neplatná hodnota,
The value {0} is already assigned to an existing Item {1}.,Hodnota {0} je již přiřazena ke stávající položce {1}.,
"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Chcete-li pokračovat v úpravách této hodnoty atributu, povolte {0} v nastavení varianty položky.",
Edit Not Allowed,Upravit není povoleno,
Row #{0}: Item {1} is already fully received in Purchase Order {2},Řádek č. {0}: Položka {1} je již plně přijata v objednávce {2},
You cannot create or cancel any accounting entries with in the closed Accounting Period {0},V uzavřeném účetním období nemůžete vytvářet ani rušit žádné účetní položky {0},
POS Invoice should have {} field checked.,Na faktuře POS by mělo být zaškrtnuto pole {}.,
Invalid Item,Neplatná položka,
Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,"Řádek č. {}: Do zpáteční faktury nelze přidat poštovní množství. Chcete-li vrácení dokončit, odeberte položku {}.",
The selected change account {} doesn't belongs to Company {}.,Vybraný účet změny {} nepatří společnosti {}.,
Atleast one invoice has to be selected.,Je třeba vybrat alespoň jednu fakturu.,
Payment methods are mandatory. Please add at least one payment method.,Platební metody jsou povinné. Přidejte alespoň jednu platební metodu.,
Please select a default mode of payment,Vyberte prosím výchozí způsob platby,
You can only select one mode of payment as default,Jako výchozí můžete vybrat pouze jeden způsob platby,
Missing Account,Chybějící účet,
Customers not selected.,Zákazníci nevybrali.,
Statement of Accounts,Výpis z účtů,
Ageing Report Based On ,Zpráva o stárnutí na základě,
Please enter distributed cost center,Zadejte distribuované nákladové středisko,
Total percentage allocation for distributed cost center should be equal to 100,Celková procentní alokace pro distribuované nákladové středisko by se měla rovnat 100,
Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,Nelze povolit distribuované nákladové středisko pro nákladové středisko již přidělené v jiném distribuovaném nákladovém středisku,
Parent Cost Center cannot be added in Distributed Cost Center,Nadřazené nákladové středisko nelze přidat do distribuovaného nákladového střediska,
A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Distribuované nákladové středisko nelze přidat do alokační tabulky Distribuované nákladové středisko.,
Cost Center with enabled distributed cost center can not be converted to group,Nákladové středisko s povoleným distribuovaným nákladovým střediskem nelze převést na skupinu,
Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,Nákladové středisko již přidělené v distribuovaném nákladovém středisku nelze převést na skupinu,
Trial Period Start date cannot be after Subscription Start Date,Datum zahájení zkušebního období nemůže být po datu zahájení předplatného,
Subscription End Date must be after {0} as per the subscription plan,Podle data předplatného musí být datum ukončení předplatného po {0},
Subscription End Date is mandatory to follow calendar months,Datum ukončení předplatného je povinné pro dodržení kalendářních měsíců,
Row #{}: POS Invoice {} is not against customer {},Řádek č. {}: POS faktura {} není proti zákazníkovi {},
Row #{}: POS Invoice {} is not submitted yet,Řádek č. {}: POS faktura {} ještě není odeslána,
Row #{}: POS Invoice {} has been {},Řádek č. {}: POS faktura {} byla {},
No Supplier found for Inter Company Transactions which represents company {0},"Nebyl nalezen žádný dodavatel pro mezipodnikové transakce, který zastupuje společnost {0}",
No Customer found for Inter Company Transactions which represents company {0},"Nebyl nalezen žádný zákazník pro mezipodnikové transakce, které představují společnost {0}",
Invalid Period,Neplatné období,
Selected POS Opening Entry should be open.,Vybraná položka otevření POS by měla být otevřená.,
Invalid Opening Entry,Neplatný úvodní záznam,
Please set a Company,Zadejte společnost,
"Sorry, this coupon code's validity has not started","Je nám líto, platnost tohoto kódu kupónu nebyla zahájena",
"Sorry, this coupon code's validity has expired","Je nám líto, platnost tohoto kódu kupónu vypršela",
"Sorry, this coupon code is no longer valid","Je nám líto, tento kód kupónu již není platný",
For the 'Apply Rule On Other' condition the field {0} is mandatory,Pro podmínku „Použít pravidlo na jiné“ je pole {0} povinné,
{1} Not in Stock,{1} Není na skladě,
Only {0} in Stock for item {1},Pouze {0} skladem u položky {1},
Please enter a coupon code,Zadejte kód kupónu,
Please enter a valid coupon code,Zadejte platný kód kupónu,
Invalid Child Procedure,Postup při neplatném dítěti,
Import Italian Supplier Invoice.,Importovat italskou dodavatelskou fakturu.,
"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.",K provádění účetních záznamů pro {1} {2} je vyžadována míra ocenění položky {0}.,
 Here are the options to proceed:,"Zde jsou možnosti, jak pokračovat:",
"If the item is transacting as a Zero Valuation Rate item in this entry, please enable 'Allow Zero Valuation Rate' in the {0} Item table.","Pokud položka v této položce probíhá jako položka s nulovou hodnotou, povolte v tabulce položky {0} položku „Povolit nulovou hodnotu.“",
"If not, you can Cancel / Submit this entry ","Pokud ne, můžete tento záznam zrušit / odeslat",
 performing either one below:,provedení některého z níže uvedených:,
Create an incoming stock transaction for the Item.,Vytvořte příchozí skladovou transakci pro položku.,
Mention Valuation Rate in the Item master.,Uveďte míru ocenění v předloze položky.,
Valuation Rate Missing,Míra ocenění chybí,
Serial Nos Required,Je vyžadováno sériové číslo,
Quantity Mismatch,Neshoda množství,
"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Chcete-li pokračovat, obnovte zásoby a aktualizujte výběrový seznam. Chcete-li pokračovat, zrušte výběrový seznam.",
Out of Stock,Vyprodáno,
{0} units of Item {1} is not available.,{0} jednotky položky {1} nejsou k dispozici.,
Item for row {0} does not match Material Request,Položka pro řádek {0} neodpovídá požadavku na materiál,
Warehouse for row {0} does not match Material Request,Sklad v řádku {0} neodpovídá požadavku na materiál,
Accounting Entry for Service,Účetní záznam za službu,
All items have already been Invoiced/Returned,Všechny položky již byly fakturovány / vráceny,
All these items have already been Invoiced/Returned,Všechny tyto položky již byly fakturovány / vráceny,
Stock Reconciliations,Burzovní vyrovnání,
Merge not allowed,Sloučení není povoleno,
The following deleted attributes exist in Variants but not in the Template. You can either delete the Variants or keep the attribute(s) in template.,"Následující odstraněné atributy existují ve variantách, ale ne v šabloně. Varianty můžete buď odstranit, nebo ponechat atributy v šabloně.",
Variant Items,Položky variant,
Variant Attribute Error,Chyba atributu varianty,
The serial no {0} does not belong to item {1},Sériové číslo {0} nepatří do položky {1},
There is no batch found against the {0}: {1},Proti {0} nebyla nalezena žádná dávka: {1},
Completed Operation,Dokončená operace,
Work Order Analysis,Analýza pracovního příkazu,
Quality Inspection Analysis,Analýza kontroly kvality,
Pending Work Order,Nevyřízená pracovní objednávka,
Last Month Downtime Analysis,Analýza prostojů za poslední měsíc,
Work Order Qty Analysis,Analýza množství zakázky,
Job Card Analysis,Analýza karty práce,
Monthly Total Work Orders,Celkový měsíční pracovní příkaz,
Monthly Completed Work Orders,Měsíčně dokončené pracovní objednávky,
Ongoing Job Cards,Probíhající pracovní karty,
Monthly Quality Inspections,Měsíční kontroly kvality,
(Forecast),(Předpověď),
Total Demand (Past Data),Celková poptávka (minulá data),
Total Forecast (Past Data),Celková předpověď (minulá data),
Total Forecast (Future Data),Celková prognóza (budoucí data),
Based On Document,Na základě dokumentu,
Based On Data ( in years ),Na základě údajů (v letech),
Smoothing Constant,Konstantní vyhlazování,
Please fill the Sales Orders table,Vyplňte prosím tabulku Prodejní objednávky,
Sales Orders Required,Požadované prodejní objednávky,
Please fill the Material Requests table,Vyplňte prosím tabulku požadavků na materiál,
Material Requests Required,Požadované materiály,
Items to Manufacture are required to pull the Raw Materials associated with it.,"K výrobě surovin, které jsou s ní spojené, jsou nutné položky k výrobě.",
Items Required,Požadované položky,
Operation {0} does not belong to the work order {1},Operace {0} nepatří do pracovního příkazu {1},
Print UOM after Quantity,Tisk MJ po množství,
Set default {0} account for perpetual inventory for non stock items,U výchozích položek nastavte výchozí účet {0} pro věčný inventář,
Loan Security {0} added multiple times,Zabezpečení půjčky {0} přidáno několikrát,
Loan Securities with different LTV ratio cannot be pledged against one loan,Úvěrové cenné papíry s různým poměrem LTV nelze zastavit proti jedné půjčce,
Qty or Amount is mandatory for loan security!,Množství nebo částka je pro zajištění půjčky povinné!,
Only submittted unpledge requests can be approved,Schváleny mohou být pouze odeslané žádosti o odpojení,
Interest Amount or Principal Amount is mandatory,Částka úroku nebo částka jistiny je povinná,
Disbursed Amount cannot be greater than {0},Vyplacená částka nemůže být větší než {0},
Row {0}: Loan Security {1} added multiple times,Řádek {0}: Zabezpečení půjčky {1} přidáno několikrát,
Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Řádek č. {0}: Podřízená položka by neměla být balíkem produktů. Odeberte prosím položku {1} a uložte ji,
Credit limit reached for customer {0},Dosažen úvěrový limit pro zákazníka {0},
Could not auto create Customer due to the following missing mandatory field(s):,Nelze automaticky vytvořit zákazníka kvůli následujícím chybějícím povinným polím:,
Please create Customer from Lead {0}.,Vytvořte prosím zákazníka z Lead {0}.,
Mandatory Missing,Povinně chybí,
Please set Payroll based on in Payroll settings,Nastavte prosím mezd na základě v nastavení mezd,
Additional Salary: {0} already exist for Salary Component: {1} for period {2} and {3},Další plat: {0} již pro komponentu Plat: {1} pro období {2} a {3},
From Date can not be greater than To Date.,Od data nemůže být větší než od data.,
Payroll date can not be less than employee's joining date.,Datum výplaty nesmí být menší než datum nástupu zaměstnance.,
From date can not be less than employee's joining date.,Od data nesmí být menší než datum nástupu zaměstnance.,
To date can not be greater than employee's relieving date.,K dnešnímu dni nemůže být větší než datum ulehčení zaměstnance.,
Payroll date can not be greater than employee's relieving date.,Datum výplaty nesmí být větší než datum uvolnění zaměstnance.,
Row #{0}: Please enter the result value for {1},Řádek č. {0}: Zadejte hodnotu výsledku pro {1},
Mandatory Results,Povinné výsledky,
Sales Invoice or Patient Encounter is required to create Lab Tests,K vytvoření laboratorních testů je nutná prodejní faktura nebo setkání pacientů,
Insufficient Data,Nedostatečné údaje,
Lab Test(s) {0} created successfully,Laboratorní testy {0} byly úspěšně vytvořeny,
Test :,Test :,
Sample Collection {0} has been created,Byla vytvořena kolekce vzorků {0},
Normal Range: ,Normální vzdálenost:,
Row #{0}: Check Out datetime cannot be less than Check In datetime,Řádek č. {0}: Datum odhlášení nemůže být menší než datum odbavení,
"Missing required details, did not create Inpatient Record","Chybějící požadované podrobnosti, nevytvořil záznam o hospitalizaci",
Unbilled Invoices,Nevyfakturované faktury,
Standard Selling Rate should be greater than zero.,Standardní prodejní sazba by měla být větší než nula.,
Conversion Factor is mandatory,Konverzní faktor je povinný,
Row #{0}: Conversion Factor is mandatory,Řádek č. {0}: Konverzní faktor je povinný,
Sample Quantity cannot be negative or 0,Množství vzorku nesmí být záporné nebo 0,
Invalid Quantity,Neplatné množství,
"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","V nastavení prodeje prosím nastavte výchozí hodnoty pro skupinu zákazníků, teritorium a ceník prodeje",
{0} on {1},{0} dne {1},
{0} with {1},{0} s {1},
Appointment Confirmation Message Not Sent,Zpráva o potvrzení schůzky nebyla odeslána,
"SMS not sent, please check SMS Settings","SMS nebyla odeslána, zkontrolujte nastavení SMS",
Healthcare Service Unit Type cannot have both {0} and {1},Typ jednotky zdravotní péče nemůže mít {0} i {1},
Healthcare Service Unit Type must allow atleast one among {0} and {1},Typ jednotky zdravotní péče musí umožňovat alespoň jednu z {0} a {1},
Set Response Time and Resolution Time for Priority {0} in row {1}.,Nastavte čas odezvy a čas rozlišení pro prioritu {0} v řádku {1}.,
Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Doba odezvy pro {0} prioritu v řádku {1} nesmí být větší než doba rozlišení.,
{0} is not enabled in {1},{0} není povolen v {1},
Group by Material Request,Seskupit podle požadavku na materiál,
"Row {0}: For Supplier {0}, Email Address is Required to Send Email",Řádek {0}: U dodavatele {0} je pro odesílání e-mailů vyžadována e-mailová adresa,
Email Sent to Supplier {0},E-mail odeslaný dodavateli {0},
"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Přístup k žádosti o nabídku z portálu je zakázán. Chcete-li povolit přístup, povolte jej v nastavení portálu.",
Supplier Quotation {0} Created,Nabídka dodavatele {0} vytvořena,
Valid till Date cannot be before Transaction Date,Platnost do data nemůže být před datem transakce,
