"""Customer Provided Item"" cannot be Purchase Item also",„Položka poskytovaná zákazníkom“ nemôže byť tiež nákupnou položkou,
"""Customer Provided Item"" cannot have Valuation Rate",„Položka poskytovaná zákazníkom“ nemôže mať mieru ocenenia,
"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Je Fixed Asset&quot; nemôže byť bez povšimnutia, pretože existuje Asset záznam proti položke",
'Based On' and 'Group By' can not be same,"""Založené na"" a ""Zoskupené podľa"", nemôžu byť rovnaké",
'Days Since Last Order' must be greater than or equal to zero,"""Dní od poslednej objednávky"" musí byť väčšie alebo rovnajúce sa nule",
'Entries' cannot be empty,"""Položky"" nemôžu býť prázdne",
'From Date' is required,"""Dátum od"" je povinný",
'From Date' must be after 'To Date',"""Dátum DO"" musí byť po ""Dátum OD""",
'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemôže byť ""áno"" pre neskladový tovar",
'Opening',"""Otváranie""",
'To Case No.' cannot be less than 'From Case No.',"""Do Prípadu č ' nesmie byť menší ako ""Od Prípadu č '",
'To Date' is required,"""Dátum Do"" je povinný",
'Total',&quot;Celkom&quot;,
'Update Stock' can not be checked because items are not delivered via {0},"""Aktualizovať Sklad ' nie je možné skontrolovať, pretože položky nie sú dodané cez {0}",
'Update Stock' cannot be checked for fixed asset sale,&quot;Aktualizácia Sklad&quot; nemôžu byť kontrolované na pevnú predaji majetku,
1 exact match.,1 presná zhoda.,
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ěnit název zákazníka nebo přejmenujte skupinu zákazníků",
A Default Service Level Agreement already exists.,Predvolená dohoda o úrovni služieb už existuje.,
A Lead requires either a person's name or an organization's name,Vedúci vyžaduje meno osoby alebo meno organizácie,
A customer with the same name already exists,Zákazník s rovnakým názvom už existuje,
A question must have more than one options,Otázka musí mať viac ako jednu možnosť,
A qustion must have at least one correct options,Spálenie musí mať aspoň jednu správnu voľbu,
A4,A4,
API Endpoint,Koncový bod rozhrania API,
API Key,kľúč API,
Abbr can not be blank or space,Skrátená nemôže byť prázdne alebo priestor,
Abbreviation already used for another company,Skratka už použitý pre inú spoločnosť,
Abbreviation cannot have more than 5 characters,Skratka nesmie mať viac ako 5 znakov,
Abbreviation is mandatory,Skratka je povinná,
About the Company,O spoločnosti,
About your company,O vašej spoločnosti,
Above,vyššie,
Academic Term,akademický Term,
Academic Term: ,Akademický termín:,
Academic Year,Akademický rok,
Academic Year: ,Akademický rok:,
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamietnuté množstvo sa musí rovnať Prijatému množstvu pre položku {0},
Access Token,Přístupový Token,
Accessable Value,Prístupná hodnota,
Account,účet,
Account Number,Číslo účtu,
Account Number {0} already used in account {1},Číslo účtu {0} už použité v účte {1},
Account Pay Only,Účet Pay Iba,
Account Type,Typ účtu,
Account Type for {0} must be {1},Typ účtu pre {0} musí byť {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 pre účet {0} nie je k dispozícii. <br> Prosím, nastavte účtovnú schému správne.",
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 podriadené uzly nie je možné nastaviť ako hlavnej 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 existujúcimi transakciami nemôže byť zmazaný,
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} nie je patria spoloč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} sa nezhoduje so spoločnosťou {1} v režime účtov: {2},
Account {0} has been entered multiple times,Účet {0} bol zadaný viackrát,
Account {0} is added in the child company {1},Účet {0} sa pridal do podradenej spoločnosti {1},
Account {0} is frozen,Účet {0} je zmrazen,
Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatná. Mena účtu musí byť {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 menou: {1} nemožno vybrať,
Accountant,Účtovník,
Accounting,Účtovníctvo,
Accounting Entry for Asset,Účtovné položky pre aktíva,
Accounting Entry for Stock,Účetní položka na skladě,
Accounting Entry for {0}: {1} can only be made in currency: {2},Účtovný záznam pre {0}: {1} môžu vykonávať len v mene: {2},
Accounting Ledger,Účtovné Ledger,
Accounting journal entries.,Zápisy v účetním deníku.,
Accounts,účty,
Accounts Manager,Manažér účtov,
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 tabuľka nemôže byť prázdne.,
Accumulated Depreciation,oprávky,
Accumulated Depreciation Amount,oprávky Suma,
Accumulated Depreciation as on,Oprávky aj na,
Accumulated Monthly,nahromadené za mesiac,
Accumulated Values,neuhradená Hodnoty,
Accumulated Values in Group Company,Akumulované hodnoty v skupine spoločnosti,
Achieved ({}),Dosiahnuté ({}),
Action,Akce,
Action Initialised,Iniciovaná akcia,
Actions,Akcie,
Active,Aktívny,
Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pre zamestnancov {0} proti Typ aktivity - {1},
Activity Cost per Employee,Náklady na činnosť na jedného zamestnanca,
Activity Type,Druh činnosti,
Actual Cost,Skutočné náklady,
Actual Delivery Date,Skutočný dátum dodania,
Actual Qty,Skutečné Množství,
Actual Qty is mandatory,Skutočné množstvo je povinné,
Actual Qty {0} / Waiting Qty {1},Aktuálny počet {0} / Čakajúci počet {1},
Actual Qty: Quantity available in the warehouse.,Skutečné množ.: Množství k dispozici ve skladu.,
Actual qty in stock,Aktuálne množstvo na sklade,
Actual type tax cannot be included in Item rate in row {0},Aktuálny typ daň nemôže byť zahrnutý v cene Položka v riadku {0},
Add,Pridať,
Add / Edit Prices,Pridať / upraviť ceny,
Add Comment,Pridať komentár,
Add Customers,Pridajte zákazníkov,
Add Employees,Pridajte Zamestnanci,
Add Item,Pridať položku,
Add Items,Pridať položky,
Add Leads,Pridať návrhy,
Add Multiple Tasks,Pridať viacero úloh,
Add Sales Partners,Pridať obchodných partnerov,
Add Serial No,Pridať sériové číslo,
Add Students,Pridajte študentov,
Add Suppliers,Pridať dodávateľov,
Add Time Slots,Pridať časové sloty,
Add Timesheets,Pridať pracovné výkazy,
Add Timeslots,Pridať Timeslots,
Add Users to Marketplace,Pridajte používateľov na trh,
Add a new address,Pridajte novú adresu,
Add cards or custom sections on homepage,Pridajte karty alebo vlastné sekcie na domovskú stránku,
Add more items or open full form,Pridať ďalšie položky alebo otvorené plnej forme,
Add notes,Pridajte 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,Pridajte ostatných z vašej organizácie ako používateľov. Môžete tiež pridať a pozvať zákazníkov na portál ich pridaním zo zoznamu kontaktov,
Add/Remove Recipients,Pridať / Odobrať príjemcu,
Added,Pridané,
Added {0} users,Pridali sme {0} používateľov,
Additional Salary Component Exists.,Existuje ďalšia zložka platu.,
Address,Adresa,
Address Line 2,Riadok adresy 2,
Address Name,Meno adresy,
Address Title,Označenie adresy,
Address Type,Typ adresy,
Administrative Expenses,Administrativní náklady,
Administrative Officer,Správní ředitel,
Administrator,Správce,
Admission,Vstupné,
Admission and Enrollment,Prijatie a zápis,
Admissions for {0},Prijímacie konanie pre {0},
Admit,Pripustiť,
Admitted,"pripustil,",
Advance Amount,Záloha ve výši,
Advance Payments,Zálohové platby,
Advance account currency should be same as company currency {0},Advance mena účtu by mala byť rovnaká ako mena spoločnosti {0},
Advance amount cannot be greater than {0} {1},Množstvo vopred nemôže byť väčšia ako {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,Vek,
Age (Days),Staroba (dni),
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,poľnohospodárstvo,
Agriculture (beta),Poľnohospodárstvo (beta),
Airline,letecká linka,
All Accounts,Všetky účty,
All Addresses.,Všetky adresy,
All Assessment Groups,Všetky skupiny Assessment,
All BOMs,Všetky kusovníky,
All Contacts.,Všechny kontakty.,
All Customer Groups,Všechny skupiny zákazníků,
All Day,Celý den,
All Departments,Všetky oddelenia,
All Healthcare Service Units,Všetky jednotky zdravotnej starostlivosti,
All Item Groups,Všechny skupiny položek,
All Products,Všetky produkty,
All Products or Services.,Všechny výrobky nebo služby.,
All Student Admissions,Všetky Študent Prijímacie,
All Supplier Groups,Všetky skupiny dodávateľov,
All Supplier scorecards.,Všetky hodnotiace karty dodávateľa.,
All Territories,Všetky územia,
All Warehouses,Všetky sklady,
All communications including and above this shall be moved into the new Issue,Všetky komunikácie vrátane a nad nimi sa presunú do nového čísla,
All items have already been transferred for this Work Order.,Všetky položky už boli prevedené na túto pracovnú objednávku.,
All other ITC,Všetky ostatné ITC,
All the mandatory Task for employee creation hasn't been done yet.,Všetky povinné úlohy na tvorbu zamestnancov ešte neboli vykonané.,
Allocate Payment Amount,Vyčleniť sumu platby,
Allocated Amount,Přidělené sumy,
Allocating leaves...,Prideľovanie listov ...,
Already record exists for the item {0},Už existuje záznam pre položku {0},
"Already set default in pos profile {0} for user {1}, kindly disabled default",Už bolo nastavené predvolené nastavenie profilu {0} pre používateľa {1},
Alternate Item,Alternatívna položka,
Alternative item must not be same as item code,Alternatívna položka nesmie byť rovnaká ako kód položky,
Amended From,Platném znění,
Amount,Částka,
Amount After Depreciation,Suma po odpisoch,
Amount of Integrated Tax,Výška integrovanej dane,
Amount of TDS Deducted,Výška odpočítanej TDS,
Amount should not be less than zero.,Suma by nemala byť nižšia ako nula.,
Amount to Bill,Částka k Fakturaci,
Amount {0} {1} against {2} {3},Množstvo {0} {1} na {2} {3},
Amount {0} {1} deducted against {2},Množstvo {0} {1} odpočítať proti {2},
Amount {0} {1} transferred from {2} to {3},Množstvo {0} {1} prevedená z {2} na {3},
Amount {0} {1} {2} {3},Množstvo {0} {1} {2} {3},
Amt,Amt,
"An Item Group exists with same name, please change the item name or rename the item group","Položková  skupina s rovnakým názvom už existuje. Prosím, zmeňte názov položky alebo premenujte skupinu položiek",
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; Meno Termín&#39; {1} už existuje. Upravte tieto položky a skúste to znova.,
An error occurred during the update process,Počas procesu aktualizácie sa vyskytla chyba,
"An item exists with same name ({0}), please change the item group name or rename the item","Položka s rovnakým názvom už existuje ({0}), prosím, zmente názov skupiny položiek alebo premenujte položku",
Analyst,analytik,
Annual Billing: {0},Ročný Billing: {0},
Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Ďalší rozpočetový záznam {0} už existuje proti {1} &#39;{2}&#39; a účet {3} pre fiškálny 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,Ďalšia predaja osoba {0} existuje s rovnakým id zamestnanca,
Antibiotic,antibiotikum,
Apparel & Accessories,Oblečení a doplňky,
Applicable For,Použitelné pro,
"Applicable if the company is SpA, SApA or SRL","Uplatniteľné, ak je spoločnosť SpA, SApA alebo SRL",
Applicable if the company is a limited liability company,"Uplatniteľné, ak je spoločnosť spoločnosť s ručením obmedzeným",
Applicable if the company is an Individual or a Proprietorship,"Uplatniteľné, ak je spoločnosť fyzická osoba alebo vlastníčka",
Application of Funds (Assets),Aplikace fondů (aktiv),
Applied,aplikovaný,
Appointment Confirmation,Potvrdenie menovania,
Appointment Duration (mins),Dĺžka schôdzky (min),
Appointment Type,Typ schôdze,
Appointment {0} and Sales Invoice {1} cancelled,Menovanie {0} a faktúra predaja {1} boli zrušené,
Appointments and Encounters,Schôdzky a stretnutia,
Appointments and Patient Encounters,Schôdzky a stretnutia s pacientmi,
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í,
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?","Aplikácie používajúce aktuálny kľúč nebudú mať prístup, určite?",
Are you sure you want to cancel this appointment?,Naozaj chcete zrušiť túto schôdzku?,
Arrear,nedoplatok,
As Examiner,Ako skúšajúci,
As On Date,Rovnako ako u Date,
As Supervisor,Ako školiteľ,
As per rules 42 & 43 of CGST Rules,Podľa pravidiel 42 a 43 pravidiel CGST,
As per section 17(5),Podľa oddielu 17 ods. 5,
Assessment,posúdenie,
Assessment Criteria,Kritériá hodnotenia,
Assessment Group,skupina Assessment,
Assessment Group: ,Hodnotiaca skupina:,
Assessment Plan,Plan Assessment,
Assessment Plan Name,Názov plánu hodnotenia,
Assessment Report,Hodnotiaca správa,
Assessment Reports,Hodnotiace správy,
Assessment Result,hodnotenie výsledkov,
Assessment Result record {0} already exists.,Hodnotenie výsledkov {0} už existuje.,
Asset,Majetek,
Asset Category,asset Kategórie,
Asset Category is mandatory for Fixed Asset item,Asset kategória je povinný pre položku investičného majetku,
Asset Maintenance,Údržba majetku,
Asset Movement,asset Movement,
Asset Movement record {0} created,Záznam Asset Pohyb {0} vytvoril,
Asset Name,asset Name,
Asset Received But Not Billed,"Akt prijatý, ale neúčtovaný",
Asset Value Adjustment,Úprava hodnoty majetku,
"Asset cannot be cancelled, as it is already {0}","Asset nemožno zrušiť, pretože je už {0}",
Asset scrapped via Journal Entry {0},Asset vyhodený cez položka denníka {0},
"Asset {0} cannot be scrapped, as it is already {1}","Aktíva {0} nemôže byť vyhodený, ako je to už {1}",
Asset {0} does not belong to company {1},Aktíva {0} nepatrí do spoločnosti {1},
Asset {0} must be submitted,Asset {0} musí byť predložené,
Assets,Aktíva,
Assign To,Priradiť (komu),
Associate,spolupracovník,
At least one mode of payment is required for POS invoice.,pre POS faktúru je nutná aspoň jeden spôsob platby.,
Atleast one item should be entered with negative quantity in return document,Aspoň jedna položka by mala byť zadaná s negatívnym množstvom vo vratnom dokumente,
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,Pripojiť logo,
Attachment,Príloha,
Attachments,Přílohy,
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,Dátum návštevnosť nemôže byť nižšia ako spojovacie dáta zamestnanca,
Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen,
Attendance has been marked successfully.,Účasť bola úspešne označená.,
Attendance not submitted for {0} as {1} on leave.,Účasť sa nepodala za {0} ako {1} v dovolenke.,
Attribute table is mandatory,Atribút tabuľka je povinné,
Attribute {0} selected multiple times in Attributes Table,Atribút {0} vybraný niekoľkokrát v atribútoch tabuľke,
Authorized Signatory,Prokurista,
Auto Material Requests Generated,Žiadosti Auto materiál vygenerovaný,
Auto Repeat,Automatické opakovanie,
Auto repeat document updated,Dokument bol aktualizovaný automaticky,
Automotive,Automobilový,
Available,K dispozici,
Available Qty,Množství k dispozici,
Available Selling,Dostupný predaj,
Available for use date is required,Je potrebný dátum použiteľného na použitie,
Available slots,Dostupné priestory,
Available {0},K dispozícii {0},
Available-for-use Date should be after purchase date,Dátum dostupný na použitie by mal byť po dátume nákupu,
Average Age,Průměrný věk,
Average Rate,Priemerná hodnota,
Avg Daily Outgoing,Avg Daily Odchozí,
Avg. Buying Price List Rate,Avg. Cena nákupného cenníka,
Avg. Selling Price List Rate,Avg. Sadzba predajného cenníka,
Avg. Selling Rate,Avg. Prodej Rate,
BOM,BOM,
BOM Browser,BOM Browser,
BOM No,BOM No,
BOM Rate,BOM Rate,
BOM Stock Report,BOM Reklamné Report,
BOM and Manufacturing Quantity are required,BOM a Výrobné množstvo sú povinné,
BOM does not contain any stock item,BOM neobsahuje žiadnu skladovú 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,zostatok,
Balance (Dr - Cr),Zostatok (Dr - Cr),
Balance ({0}),Zostatok ({0}),
Balance Qty,Zostatkové množstvo,
Balance Sheet,Rozvaha,
Balance Value,Hodnota zostatku,
Balance for Account {0} must always be {1},Zostatok na účte {0} musí byť vždy {1},
Bank,Banka,
Bank Account,Bankový účet,
Bank Accounts,Bankové účty,
Bank Draft,Bank Návrh,
Bank Name,Názov banky,
Bank Overdraft Account,Kontokorentní úvěr na účtu,
Bank Reconciliation,Bankové odsúhlasenie,
Bank Reconciliation Statement,Bank Odsouhlasení prohlášení,
Bank Statement,Výpis z bankového účtu,
Bank Statement Settings,Nastavenia bankového výpisu,
Bank Statement balance as per General Ledger,Bankový zostatok podľa hlavnej knihy,
Bank account cannot be named as {0},Bankový účet nemôže byť pomenovaný {0},
Bank/Cash transactions against party or for internal transfer,Banka / Hotovostné operácie proti osobe alebo pre interný prevod,
Banking,bankovníctvo,
Banking and Payments,Bankovníctvo 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,Čiarový kód {0} nie je platný {1} kód,
Base URL,Základná adresa URL,
Based On,Založené na,
Based On Payment Terms,Na základe platobných podmienok,
Batch,Šarža,
Batch Entries,Dávky šarže,
Batch ID is mandatory,Číslo šarže je povinné,
Batch Inventory,Batch Zásoby,
Batch Name,Názov šarže,
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.,Batch {0} z {1} bodu vypršala.,
Batch {0} of Item {1} is disabled.,Dávka {0} položky {1} je vypnutá.,
Batch: ,šarže:,
Batches,Šarže,
Become a Seller,Staňte sa predajcom,
Bill,Účtenka,
Bill Date,Bill Datum,
Bill No,Bill No,
Bill of Materials,Kusovník,
Bill of Materials (BOM),Bill of Materials (BOM),
Billable Hours,Fakturovateľné hodiny,
Billed,Fakturované,
Billed Amount,Fakturovaná čiastka,
Billing Address,Fakturačná adresa,
Billing Address is same as Shipping Address,Fakturačná adresa je rovnaká ako dodacia adresa,
Billing Amount,Fakturovaná čiastka,
Billing Status,Stav fakturácie,
Billing currency must be equal to either default company's currency or party account currency,Mena fakturácie sa musí rovnať mene menovej jednotky alebo účtovnej parity,
Bills raised by Suppliers.,Faktúry od dodávateľov,
Bills raised to Customers.,Faktúry zákazníkom,
Biotechnology,biotechnológie,
Black,čierna,
Blanket Orders from Costumers.,Peňažné objednávky od zákazníkov.,
Block Invoice,Blokovať faktúru,
Boms,kusovníky,
Both Trial Period Start Date and Trial Period End Date must be set,Musí sa nastaviť dátum spustenia skúšobného obdobia a dátum ukončenia skúšobného obdobia,
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,Prechádzať BOM,
Budget Against,Rozpočet proti,
Budget List,Rozpočtový zoznam,
Budget Variance Report,Rozpočet Odchylka Report,
Budget cannot be assigned against Group Account {0},Rozpočet nemôže byť priradená na skupinový účet {0},
"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Rozpočet nemožno priradiť proti {0}, pretože to nie je výnos alebo 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,kúpiť,
Buying,nákupy,
Buying Amount,Nákup Částka,
Buying Price List,Nákupný cenník,
Buying Rate,Sadzba 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 ,Zablokovanie kreditnej kontroly na objednávke,
C-Form records,C-Form záznamy,
C-form is not applicable for Invoice: {0},C-forma sa nevzťahuje na faktúre: {0},
CEO,CEO,
CESS Amount,Čiastka CESS,
CGST Amount,CGST Suma,
CRM,CRM,
CWIP Account,Účet CWIP,
Calculated Bank Statement balance,Vypočítaná výpis z bankového účtu zostatok,
Campaign,kampaň,
Can be approved by {0},Môže byť schválené kým: {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}","Nemožno označiť Vypustený záznam pacienta, existujú nevyfakturné faktúry {0}",
Can only make payment against unbilled {0},Možno vykonať len 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","Metódu oceňovania nemožno zmeniť, pretože existujú transakcie proti niektorým položkám, ktoré nemajú vlastnú metódu oceňovania",
Can't create standard criteria. Please rename the criteria,Štandardné kritériá sa nedajú vytvoriť. Premenujte kritériá,
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šiť odber,
Cancel the journal entry {0} first,Najskôr zrušte záznam denníka {0},
Canceled,zrušený,
"Cannot Submit, Employees left to mark attendance","Nepodarilo sa odoslať, Zamestnanci odišli na označenie účasti",
Cannot be a fixed asset item as Stock Ledger is created.,"Nemôže byť položka fixného majetku, pretože je vytvorená účtovná kniha.",
Cannot cancel because submitted Stock Entry {0} exists,"Nie je možné zrušiť, pretože existuje potvrdený zápis zásoby {0}",
Cannot cancel transaction for Completed Work Order.,Pre dokončenú pracovnú zákazku nie je možné zrušiť transakciu.,
Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},"Nie je možné zrušiť {0} {1}, pretože sériové číslo {2} nepatrí do skladu {3}",
Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Atribúty nie je možné zmeniť po transakcii s akciami. Vytvorte novú položku a presuňte materiál do novej 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},Nemôžem zmeniť dátum ukončenia servisu pre položku v riadku {0},
Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Nemožno zmeniť vlastnosti Variantu po transakcii s akciami. Budete musieť urobiť novú položku.,
"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 zmeniť štatút študenta {0} je prepojený s aplikáciou študentské {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,Nemožno vytvoriť retenčný bonus pre odídených zamestnancov,
Cannot create a Delivery Trip from Draft documents.,Z koncepčných dokumentov nie je možné vytvoriť doručovací výlet.,
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 odpočítať, ak kategória je pre &quot;ocenenie&quot; alebo &quot;Vaulation a Total&quot;",
"Cannot delete Serial No {0}, as it is used in stock transactions","Nemožno odstrániť Poradové číslo {0}, ktorý sa používa na sklade transakciách",
Cannot enroll more than {0} students for this student group.,Nemôže prihlásiť viac ako {0} študentov na tejto študentské skupiny.,
Cannot produce more Item {0} than Sales Order quantity {1},Nie je možné vyrobiť viac Položiek {0} ako je množstvo na predajnej objednávke {1},
Cannot promote Employee with status Left,Nemožno povýšiť zamestnanca so statusom odídený,
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 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.,Nie je možné nastaviť viaceré predvolené položky pre spoločnosť.,
Cannot set quantity less than delivered quantity,Nie je možné nastaviť menšie množstvo ako dodané množstvo,
Cannot set quantity less than received quantity,Nie je možné nastaviť množstvo menšie ako prijaté množstvo,
Cannot set the field <b>{0}</b> for copying in variants,Nemožno nastaviť pole <b>{0}</b> na kopírovanie vo variantoch,
Cannot transfer Employee with status Left,Nie je možné previesť zamestnanca so stavom doľava,
Cannot {0} {1} {2} without any negative outstanding invoice,Nemožno {0} {1} {2} bez negatívnych vynikajúce faktúra,
Capital Equipments,Kapitál Vybavenie,
Capital Stock,Kapitál Zásoby,
Capital Work in Progress,Kapitál Rozrobenosť,
Cart,Košík,
Cart is Empty,Košík je prázdny,
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,Prehľad o peňažných tokoch,
Cash Flow from Financing,Peňažný tok z financovania,
Cash Flow from Investing,Peňažný tok z investovania,
Cash Flow from Operations,Cash flow z prevádzkových činností,
Cash In Hand,Pokladničná hotovosť,
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,Uzávierka pokladníka,
Category,Kategória,
Category Name,Názov kategórie,
Caution,pozor,
Central Tax,Centrálna daň,
Certification,osvedčenie,
Cess,Cess,
Change Amount,zmena Suma,
Change Item Code,Zmeniť kód položky,
Change Release Date,Zmeniť dátum vydania,
Change Template Code,Zmena kódu šablóny,
Changing Customer Group for the selected Customer is not allowed.,Zmena zákazníckej skupiny pre vybraného zákazníka nie je povolená.,
Chapter,kapitola,
Chapter information.,Informácie 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 Cost Centers,Diagram nákladových stredísk,
Check all,Skontrolovať všetko,
Checkout,Odhlásiť sa,
Chemical,chemický,
Cheque,Šek,
Cheque/Reference No,Šek / Referenčné číslo,
Cheques Required,Potrebné kontroly,
Cheques and Deposits incorrectly cleared,Šeky a Vklady nesprávne vymazané,
Child Task exists for this Task. You can not delete this Task.,Detská úloha existuje pre túto úlohu. Túto úlohu nemôžete odstrániť.,
Child nodes can be only created under 'Group' type nodes,Podriadené uzly môžu byť vytvorené len na základe typu uzly &quot;skupina&quot;,
Child warehouse exists for this warehouse. You can not delete this warehouse.,Dieťa sklad existuje pre tento sklad. Nemôžete odstrániť tento sklad.,
Circular Reference Error,Kruhové Referenčné Chyba,
City,Mesto,
City/Town,Mesto / Obec,
Clay,hlina,
Clear filters,Vymazať filtre,
Clear values,Vymazať hodnoty,
Clearance Date,Výprodej Datum,
Clearance Date not mentioned,Výprodej Datum není uvedeno,
Clearance Date updated,Svetlá Dátum aktualizované,
Client,Klient,
Client ID,ID klienta,
Client Secret,Klientské tajomstvo,
Clinical Procedure,Klinický postup,
Clinical Procedure Template,Šablóna klinického postupu,
Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.,
Close Loan,Zatvorte pôžičku,
Close the POS,Zatvorte POS,
Closed,Zavreté,
Closed order cannot be cancelled. Unclose to cancel.,Uzavretá objednávka nemôže byť zrušený. Otvoriť zrušiť.,
Closing (Cr),Uzavření (Cr),
Closing (Dr),Uzavření (Dr),
Closing (Opening + Total),Uzávierka (otvorenie + celkom),
Closing Account {0} must be of type Liability / Equity,Záverečný účet {0} musí byť typu zodpovednosti / Equity,
Closing Balance,Konečný zostatok,
Code,Kód,
Collapse All,zbaliť všetko,
Color,Farba,
Colour,farba,
Combined invoice portion must equal 100%,Kombinovaná časť faktúry sa musí rovnať 100%,
Commercial,Obchodné,
Commission,Provízia,
Commission Rate %,Komisia sadzba%,
Commission on Sales,Provizia z prodeja,
Commission rate cannot be greater than 100,Komisná sadzba nemôže byť väčšia ako 100,
Community Forum,Komunitné fórum,
Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.,
Company Abbreviation,Skratka názvu spoločnosti,
Company Abbreviation cannot have more than 5 characters,Skratka firmy nemôže mať viac ako 5 znakov,
Company Name,Názov spoločnosti,
Company Name cannot be Company,Názov spoločnosti nemôže byť Company,
Company currencies of both the companies should match for Inter Company Transactions.,Spoločné meny oboch spoločností by mali zodpovedať transakciám medzi spoločnosťami.,
Company is manadatory for company account,Spoločnosť je vedúca pre firemný účet,
Company name not same,Názov spoločnosti nie je rovnaký,
Company {0} does not exist,Spoločnosť {0} neexistuje,
Compensatory leave request days not in valid holidays,Kompenzačné dni žiadosti o dovolenku nie sú v platných sviatkoch,
Complaint,sťažnosť,
Completion Date,Dokončení Datum,
Computer,Počítač,
Condition,Podmienka,
Configure,konfigurácia,
Configure {0},Konfigurovať {0},
Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.,
Connect Amazon with ERPNext,Pripojte Amazon s ERPNext,
Connect Shopify with ERPNext,Pripojte službu Shopify s nástrojom ERPNext,
Connect to Quickbooks,Pripojte sa k Quickbooks,
Connected to QuickBooks,Pripojené k QuickBooks,
Connecting to QuickBooks,Pripojenie k aplikácii QuickBooks,
Consultation,Konzultácia,
Consultations,konzultácie,
Consulting,consulting,
Consumable,Spotrebný materiál,
Consumed,Spotřeba,
Consumed Amount,Spotřebovaném množství,
Consumed Qty,Spotřeba Množství,
Consumer Products,Zákaznícke produkty,
Contact,Kontakt,
Contact Us,Kontaktuj nás,
Content,Obsah,
Content Masters,Obsahové mastery,
Content Type,Typ obsahu,
Continue Configuration,Pokračovať v konfigurácii,
Contract,zmluva,
Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování,
Contribution %,Príspevok%,
Contribution Amount,Výška príspevku,
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,Previesť na skupinu,
Convert to Non-Group,Previesť na non-Group,
Cosmetics,kozmetika,
Cost Center,Nákladové stredisko,
Cost Center Number,Číslo nákladového strediska,
Cost Center and Budgeting,Nákladové stredisko a rozpočtovanie,
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é strediská,
Cost Updated,Náklady aktualizované,
Cost as on,Náklady ako na,
Cost of Delivered Items,Náklady na dodané položky,
Cost of Goods Sold,Náklady na predaj tovaru,
Cost of Issued Items,Náklady na vydané položky,
Cost of New Purchase,Náklady na nový nákup,
Cost of Purchased Items,Náklady na zakúpené položky,
Cost of Scrapped Asset,Náklady na vyradené aktíva,
Cost of Sold Asset,Náklady predaných aktív,
Cost of various activities,Náklady na rôzne aktivity,
"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again",Automaticky sa nepodarilo vytvoriť kreditnú poznámku. Zrušte začiarknutie možnosti &quot;Zmeniť kreditnú poznámku&quot; a znova ju odošlite,
Could not generate Secret,Tajomstvo sa nepodarilo vytvoriť,
Could not retrieve information for {0}.,Nepodarilo sa získať informácie pre {0}.,
Could not solve criteria score function for {0}. Make sure the formula is valid.,"Nie je možné vyriešiť funkciu skóre skóre {0}. Skontrolujte, či je vzorec platný.",
Could not solve weighted score function. Make sure the formula is valid.,"Funkciu váženého skóre sa nepodarilo vyriešiť. Skontrolujte, či je vzorec platný.",
Could not submit some Salary Slips,Nepodarilo sa odoslať niektoré platobné pásky,
"Could not update stock, invoice contains drop shipping item.","Nie je možné aktualizovať zásob, faktúra obsahuje pokles lodnej dopravy tovaru.",
Country wise default Address Templates,Země moudrý výchozí adresa Templates,
Course Code: ,Kód kurzu:,
Course Enrollment {0} does not exists,Zápis do kurzu {0} neexistuje,
Course Schedule,rozvrh,
Course: ,Predmet:,
Cr,Cr,
Create,vytvoriť,
Create BOM,Vytvorte kusovník,
Create Delivery Trip,Vytvoriť doručovací výlet,
Create Employee,Vytvorte zamestnanca,
Create Employee Records,Vytvoriť zamestnanecké záznamy,
"Create Employee records to manage leaves, expense claims and payroll","Vytvoriť Zamestnanecké záznamy pre správu listy, vyhlásenia o výdavkoch a miezd",
Create Fee Schedule,Vytvorte rozvrh poplatkov,
Create Fees,Vytvorte poplatky,
Create Inter Company Journal Entry,Založenie záznamu do firemného denníka,
Create Invoice,Vytvoriť faktúru,
Create Invoices,Vytváranie faktúr,
Create Job Card,Vytvorte kartu práce,
Create Journal Entry,Vytvoriť zápis do denníka,
Create Lead,Vytvoriť potenciálneho zákazníka,
Create Leads,Vytvoriť iniciatívu,
Create Maintenance Visit,Vytvorte návštevu údržby,
Create Material Request,Vytvoriť požiadavku na materiál,
Create Multiple,Vytvorte viacero,
Create Opening Sales and Purchase Invoices,Vytvorte otváracie predajné a nákupné faktúry,
Create Payment Entries,Vytvorte platobné položky,
Create Payment Entry,Založenie záznamu platby,
Create Print Format,Vytvoriť formát tlače,
Create Purchase Order,Vytvorenie objednávky,
Create Purchase Orders,Vytvorenie objednávok,
Create Quotation,Vytvoriť Ponuku,
Create Sales Invoice,Vytvoriť predajnú faktúru,
Create Sales Order,Vytvorenie objednávky predaja,
Create Sales Orders to help you plan your work and deliver on-time,"Vytvorte zákazky odberateľa, aby ste si mohli naplánovať svoju prácu a včas dodať",
Create Sample Retention Stock Entry,Založenie záznamu vzorky retenčných zásob,
Create Student,Vytvorte študenta,
Create Student Batch,Vytvorenie šarže pre študentov,
Create Student Groups,Vytvorenie skupiny študentov,
Create Supplier Quotation,Vytvoriť ponuku dodávateľa,
Create Tax Template,Vytvorte šablónu dane,
Create Timesheet,Vytvorenie časového rozvrhu,
Create User,Vytvoriť používateľa,
Create Users,Vytvoriť používateľov,
Create Variant,Vytvoriť variant,
Create Variants,Vytvorenie variantov,
"Create and manage daily, weekly and monthly email digests.","Tvorba a správa denných, týždenných a mesačných emailových spravodajcov",
Create customer quotes,Vytvoriť zákaznícke ponuky,
Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.,
Created {0} scorecards for {1} between: ,Vytvorili {0} scorecards pre {1} medzi:,
Creating Company and Importing Chart of Accounts,Založenie spoločnosti a importná účtovná osnova,
Creating Fees,Vytváranie poplatkov,
Creating student groups,Vytváranie študentských skupín,
Creating {0} Invoice,Vytvorenie faktúry {0},
Credit,úver,
Credit ({0}),Úver ({0}),
Credit Account,Úverový účet,
Credit Balance,Credit Balance,
Credit Card,Kreditní karta,
Credit Days cannot be a negative number,Kreditné dni nemôžu byť záporné číslo,
Credit Limit,Úverový limit,
Credit Note,Dobropis,
Credit Note Amount,Výška úverovej poznámky,
Credit Note Issued,dobropisu vystaveného,
Credit Note {0} has been created automatically,Kreditná poznámka {0} bola vytvorená automaticky,
Credit limit has been crossed for customer {0} ({1}/{2}),Úverový limit bol pre zákazníka prekročený {0} ({1} / {2}),
Creditors,veritelia,
Criteria weights must add up to 100%,Kritériové váhy musia pripočítať až 100%,
Crop Cycle,Orezový cyklus,
Crops & Lands,Plodiny a pôdy,
Currency Exchange must be applicable for Buying or for Selling.,Výmena peňazí musí byť uplatniteľná pri kúpe alebo predaji.,
Currency can not be changed after making entries using some other currency,Mena nemôže byť zmenený po vykonaní položky pomocou inej mene,
Currency exchange rate master.,Devizový kurz master.,
Currency for {0} must be {1},Mena pre {0} musí byť {1},
Currency is required for Price List {0},Mena je vyžadovaná pre Cenník {0},
Currency of the Closing Account must be {0},"Mena záverečného účtu, musí byť {0}",
Currency of the price list {0} must be {1} or {2},Mena cenníka {0} musí byť {1} alebo {2},
Currency should be same as Price List Currency: {0},Mena by mala byť rovnaká ako mena cenníka: {0},
Current Assets,Oběžná aktiva,
Current BOM and New BOM can not be same,Aktuální BOM a New BOM nemůže být stejné,
Current Liabilities,Krátkodobé závazky,
Current Qty,Aktuálne Množstvo,
Current invoice {0} is missing,Aktuálna faktúra {0} chýba,
Custom HTML,Vlastné HTML,
Custom?,Prispôsobené?,
Customer,zákazník,
Customer Addresses And Contacts,Adresy zákazníkov a kontakty,
Customer Contact,Zákaznícky kontakt,
Customer Database.,Databáza zákazníkov,
Customer Group,Zákaznícka skupina,
Customer LPO,Zákazník LPO,
Customer LPO No.,Číslo zákazníka LPO,
Customer Name,Meno zákazníka,
Customer POS Id,Id zákazníka POS,
Customer Service,Služby zákazníkom,
Customer and Supplier,Zákazník a dodávateľ,
Customer is required,Je nutná zákazník,
Customer isn't enrolled in any Loyalty Program,Zákazník nie je zaregistrovaný v žiadnom vernostnom programe,
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 vytvorený.,
Customers in Queue,Zákazníci vo fronte,
Customize Homepage Sections,Prispôsobte sekcie domovskej stránky,
Customizing Forms,Prispôsobenie Formuláre,
Daily Project Summary for {0},Zhrnutie denného projektu za {0},
Daily Reminders,Denné pripomienky,
Data Import and Export,Import dát a export,
Data Import and Settings,Import a nastavenie údajov,
Database of potential customers.,Databáze potenciálních zákazníků.,
Date Format,Formát dátumu,
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 of Birth,Dátum narodenia,
Date of Birth cannot be greater than today.,Dátum narodenia nemôže byť väčšia ako dnes.,
Date of Commencement should be greater than Date of Incorporation,Dátum začiatku by mal byť väčší ako dátum založenia,
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,Dátum transakcie,
Day,Deň,
Debit,Debet,
Debit ({0}),Debet ({0}),
Debit Account,Debetný účet,
Debit Note,Debit Note,
Debit Note Amount,Výška dlžnej sumy,
Debit Note Issued,vydanie dlhopisu,
Debit To is required,Debetné K je vyžadované,
Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetné a kreditné nerovná za {0} # {1}. Rozdiel je v tom {2}.,
Debtors,dlžníci,
Debtors ({0}),Dlžníci ({0}),
Declare Lost,Vyhlásiť za stratené,
Default Activity Cost exists for Activity Type - {0},Existuje Náklady Predvolené aktivity pre Typ aktivity - {0},
Default BOM ({0}) must be active for this item or its template,Predvolené BOM ({0}) musí byť aktívna pre túto položku alebo jeho šablóny,
Default BOM for {0} not found,Predvolené BOM pre {0} nebol nájdený,
Default BOM not found for Item {0} and Project {1},Predvolený kusovník sa nenašiel pre položku {0} a projekt {1},
Default Letter Head,Predvolená tlačová hlavička,
Default Tax Template,Štandardná daňová šablóna,
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ýchodzí merná jednotka bodu {0} nemôže byť zmenená priamo, pretože ste už nejaké transakcie (y) s iným nerozpustených. Budete musieť vytvoriť novú položku použiť iný predvolený UOM.",
Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Východzí merná jednotka varianty &#39;{0}&#39; musí byť rovnaký ako 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.,Predvolené daňové šablóny pre predaj a nákup sú vytvorené.,
Defaults,Predvolené,
Defense,obrana,
Define Project type.,Definujte typ projektu.,
Define budget for a financial year.,Definovať rozpočet pre finančný rok.,
Define various loan types,Definovať rôzne typy úverov,
Del,del,
Delay in payment (Days),Oneskorenie s platbou (dni),
Delete all the Transactions for this Company,Odstráňte všetky transakcie pre túto spoločnosť,
Deletion is not permitted for country {0},Vymazanie nie je povolené pre krajinu {0},
Delivered,Dodané,
Delivered Amount,Dodaná čiastka,
Delivered Qty,Dodané množstvo,
Delivered: {0},Dodáva: {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,Poznámky o doručení {0} boli aktualizované,
Delivery Status,Stav dodania,
Delivery Trip,Rozvoz tovaru,
Delivery warehouse required for stock item {0},Dodávka sklad potrebný pre živočíšnu položku {0},
Department,Oddelenie,
Department Stores,Obchodní domy,
Depreciation,Odpisovanie,
Depreciation Amount,Suma odpisov,
Depreciation Amount during the period,Odpisy hodnoty v priebehu obdobia,
Depreciation Date,odpisy Dátum,
Depreciation Eliminated due to disposal of assets,Odpisy vypadol v dôsledku nakladania s majetkom,
Depreciation Entry,Zápis odpisu,
Depreciation Method,odpisy Metóda,
Depreciation Row {0}: Depreciation Start Date is entered as past date,Odpisový riadok {0}: Dátum začiatku odpisovania sa zadáva ako posledný dátum,
Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Riadok odpisov {0}: Očakávaná hodnota po uplynutí životnosti musí byť väčšia alebo rovná {1},
Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Odpisový riadok {0}: Nasledujúci dátum odpisovania nemôže byť pred dátumom k dispozícii na použitie,
Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Odpisový riadok {0}: Nasledujúci Dátum odpisovania nemôže byť pred dátumom nákupu,
Designer,návrhár,
Detailed Reason,Podrobný dôvod,
Details,Podrobnosti,
Details of Outward Supplies and inward supplies liable to reverse charge,Podrobnosti o vonkajších dodávkach a vnútorných dodávkach podliehajúcich preneseniu daňovej povinnosti,
Details of the operations carried out.,Podrobnosti o prováděných operací.,
Diagnosis,diagnóza,
Did not find any item called {0},Nenašiel žiadnu položku s názvom {0},
Diff Qty,Rozdielové množstvo,
Difference Account,Rozdíl účtu,
"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Rozdiel účet musí byť typu aktív / Zodpovednosť účet, pretože to Reklamná Zmierenie je Entry Otvorenie",
Difference Amount,Rozdiel Suma,
Difference Amount must be zero,Rozdiel Suma musí byť 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,Priame náklady,
Direct Income,Priame príjmy,
Disable,Vypnúť,
Disabled template must not be default template,Bezbariérový šablóna nesmie byť predvolenú šablónu,
Disburse Loan,Vyplatiť pôžičku,
Disbursed,vyplatená,
Disc,kotúč,
Discharge,výtok,
Discount,zľava,
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,Choroby a hnojivá,
Dispatch,Odeslání,
Dispatch Notification,Oznámenie o doručení,
Dispatch State,Štát odoslania,
Distance,vzdialenosť,
Distribution,distribúcia,
Distributor,distribútor,
Dividends Paid,Dividendy platené,
Do you really want to restore this scrapped asset?,Naozaj chcete obnoviť tento vyradený aktívum?,
Do you really want to scrap this asset?,Naozaj chcete zrušiť túto pohľadávku?,
Do you want to notify all the customers by email?,Chcete upozorniť všetkých zákazníkov e-mailom?,
Doc Date,Dátum dokumentu,
Doc Name,Doc Name,
Doc Type,DokTyp,
Docs Search,Vyhľadávanie dokumentov,
Document Name,Názov dokumentu,
Document Type,typ dokumentu,
Domain,Doména,
Domains,Domény,
Done,hotový,
Donor,darcu,
Donor Type information.,Informácie o dárcovom type.,
Donor information.,Informácie pre darcu.,
Download JSON,Stiahnite si JSON,
Draft,Návrh,
Drop Ship,Drop Loď,
Drug,liek,
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,Dátum splatnosti nemôže byť skôr ako dátum zaúčtovania / fakturácie dodávateľa,
Due Date is mandatory,Dátum 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íkov uvedené v tabuľke na knihy zákazníkov skupiny,
Duplicate entry,Duplicitní záznam,
Duplicate item group found in the item group table,Duplicitné skupinu položiek uvedené v tabuľke na položku v skupine,
Duplicate roll number for student {0},Duplicitné číslo rolky pre študenta {0},
Duplicate row {0} with same {1},Duplicitný riadok {0} s rovnakým {1},
Duplicate {0} found in the table,V tabuľke sa našlo duplikát {0},
Duration in Days,Trvanie v dňoch,
Duties and Taxes,Odvody a dane,
E-Invoicing Information Missing,Chýbajú informácie o elektronickej fakturácii,
ERPNext Demo,ERPNext Demo,
ERPNext Settings,ERPĎalšie nastavenia,
Earliest,Najstarší,
Earnest Money,Earnest Money,
Edit,editovať,
Edit Publishing Details,Upraviť podrobnosti o publikovaní,
"Edit in full page for more options like assets, serial nos, batches etc.","Upravte celú stránku pre ďalšie možnosti, ako sú aktíva, sériové nosiče, dávky atď.",
Education,vzdelanie,
Either location or employee must be required,"Musí sa vyžadovať buď umiestnenie, alebo zamestnanec",
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é zariadenia,
Electronics,elektronika,
Eligible ITC,Oprávnené ITC,
Email Account,E-mailový účet,
Email Address,Emailová adresa,
"Email Address must be unique, already exists for {0}","E-mailová adresa musí byť jedinečná, už existuje pre {0}",
Email Digest: ,E-mail Digest:,
Email Reminders will be sent to all parties with email contacts,Pripomienky e-mailu budú zaslané všetkým stranám s e-mailovými kontaktmi,
Email Sent,Email odoslaný,
Email Template,Šablóna e-mailu,
Email not found in default contact,E-mail sa v predvolenom kontakte nenachádza,
Email sent to {0},Email odoslaný na {0},
Employee,zamestnanec,
Employee Advances,Zamestnanecké zálohy,
Employee ID,zamestnanecké ID,
Employee Lifecycle,Životný cyklus zamestnancov,
Employee Name,Meno zamestnanca,
Employee Promotion cannot be submitted before Promotion Date ,Propagácia zamestnancov nemôže byť predložená pred dátumom propagácie,
Employee Transfer cannot be submitted before Transfer Date ,Prevod zamestnancov nemožno odoslať pred dátumom prevodu,
Employee cannot report to himself.,Zamestnanec nemôže reportovať sám sebe.,
Employee {0} has already applied for {1} between {2} and {3} : ,Zamestnanec {0} už požiadal {1} medzi {2} a {3}:,
Employee {0} of grade {1} have no default leave policy,Zamestnanec {0} v platovej triede {1} nemá žiadne predvolené pravidlá pre dovolenku,
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","Povolenie &quot;použitia na nákupného košíka&quot;, ako je povolené Nákupný košík a tam by mala byť aspoň jedna daňové pravidlá pre Košík",
End Date,Datum ukončení,
End Date can not be less than Start Date,Dátum ukončenia nemôže byť menší ako dátum začiatku,
End Date cannot be before Start Date.,Dátum ukončenia nemôže byť pred dátumom začiatku.,
End Year,Koniec roka,
End Year cannot be before Start Year,Koniec roka nemôže byť pred uvedením do prevádzky roku,
End on,Ukončiť,
Ends On date cannot be before Next Contact Date.,Koniec dátumu nemôže byť pred dátumom nasledujúceho kontaktu.,
Energy,energie,
Engineer,Inženýr,
Enough Parts to Build,Dosť Časti vybudovať,
Enroll,zapísať,
Enrolling student,učiaci študenta,
Enrolling students,Zapisovanie študentov,
Enter depreciation details,Zadajte podrobnosti o odpisoch,
Enter the Bank Guarantee Number before submittting.,Pred odoslaním zadajte číslo bankovej záruky.,
Enter the name of the Beneficiary before submittting.,Pred odoslaním zadajte meno príjemcu.,
Enter the name of the bank or lending institution before submittting.,Pred odoslaním zadajte názov banky alebo inštitúcie poskytujúcej pôžičku.,
Enter value betweeen {0} and {1},Zadajte hodnotu medzi {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 pri hodnotení kritéria kritérií,
Error in formula or condition: {0},Chyba vo vzorci alebo stave: {0},
Error: Not a valid id?,Chyba: Nie je platný id?,
Estimated Cost,Odhadované náklady,
"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:",
Exchange Gain/Loss,Exchange zisk / strata,
Exchange Rate Revaluation master.,Master preceňovacieho kurzu.,
Exchange Rate must be same as {0} {1} ({2}),Exchange Rate musí byť rovnaká ako {0} {1} ({2}),
Excise Invoice,Spotrebný Faktúra,
Execution,Provedení,
Executive Search,Executive Search,
Expand All,Rozbaliť všetko,
Expected Delivery Date,Očekávané datum dodání,
Expected Delivery Date should be after Sales Order Date,Očakávaný dátum doručenia by mal byť po dátume zákazky predaja,
Expected End Date,Očekávané datum ukončení,
Expected Hrs,Očaká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 Claims,Nákladové Pohľadá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 ocenenia majetku,
Expenses Included In Valuation,Náklady ceně oceňování,
Expired Batches,Vypršané dávky,
Expires On,Vyprší,
Expiring On,Vypršanie zapnuté,
Expiry (In Days),Doba použiteľnosti (v dňoch),
Explore,Prieskumník,
Export E-Invoices,Export elektronických faktúr,
Extra Large,Extra veľké,
Extra Small,Extra Malé,
Fail,zlyhať,
Failed,Nepodarilo,
Failed to create website,Nepodarilo sa vytvoriť webové stránky,
Failed to install presets,Nepodarilo sa nainštalovať predvoľby,
Failed to login,Nepodarilo sa prihlásiť,
Failed to setup company,Nepodarilo sa nastaviť spoločnosť,
Failed to setup defaults,Nepodarilo sa nastaviť predvolené hodnoty,
Failed to setup post company fixtures,Nepodarilo sa nastaviť doplnky firmy,
Fax,Fax,
Fee,poplatok,
Fee Created,Poplatok vytvorený,
Fee Creation Failed,Vytvorenie poplatku zlyhalo,
Fee Creation Pending,Tvorba poplatkov čaká,
Fee Records Created - {0},Fee Records Vytvoril - {0},
Feedback,Zpětná vazba,
Fees,poplatky,
Female,Žena,
Fetch Data,Načítať údaje,
Fetch Subscription Updates,Načítať aktualizácie odberov,
Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin),
Fetching records......,Prebieha načítavanie záznamov ......,
Field Name,Názov poľa,
Fieldname,Názov poľa,
Fields,Pole,
"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Riadok č. Filtra: {0}: Názov poľa <b>{1}</b> musí byť typu „Link“ alebo „Table MultiSelect“,
Filter Total Zero Qty,Filtrovanie celkového množstva nuly,
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,Skončiť,
Finished Good,Ukončené dobro,
Finished Good Item Code,Kód dokončeného tovaru,
Finished Goods,Hotové zboží,
Finished Item {0} must be entered for Manufacture type entry,Dokončené Položka {0} musí byť zadaný pre vstup typu Výroba,
Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Množstvo hotového produktu <b>{0}</b> a Množstvo <b>{1}</b> sa nemôžu líšiť,
First Name,Meno,
"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiškálny režim je povinný, láskavo nastavte fiškálny režim v spoločnosti {0}",
Fiscal Year,Fiškálny rok,
Fiscal Year End Date should be one year after Fiscal Year Start Date,Dátum konca fiškálneho roka by mal byť jeden rok po dátume začiatku fiškálneho roka,
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,Dátum začatia fiškálneho roka by mal byť o jeden rok skôr ako dátum ukončenia fiškálneho roka,
Fiscal Year {0} does not exist,Fiškálny rok {0} neexistuje,
Fiscal Year {0} is required,Fiškálny rok {0} je vyžadovaná,
Fixed Asset,Základní Jmění,
Fixed Asset Item must be a non-stock item.,Fixed Asset položky musia byť non-skladová položka.,
Fixed Assets,Dlhodobý majetok,
Following Material Requests have been raised automatically based on Item's re-order level,Nasledujúci materiál žiadosti boli automaticky zvýšená na základe úrovni re-poradie položky,
Following accounts might be selected in GST Settings:,Nasledujúce účty môžu byť vybraté v nastaveniach GST:,
Following course schedules were created,Boli vytvorené rozvrhy kurzov,
Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Nasledujúca položka {0} nie je označená ako položka {1}. Môžete ich povoliť ako {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,Nasledujúce položky {0} nie sú označené ako položka {1}. Môžete ich povoliť ako {1} položku z jeho položky Master,
"Food, Beverage & Tobacco","Potraviny, nápoje a tabak",
For,pre,
"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.","Pre &quot;produktom Bundle predmety, sklad, sériové číslo a dávkové No bude považovaná zo&quot; Balenie zoznam &#39;tabuľky. Ak Warehouse a Batch No sú rovnaké pre všetky balenia položky pre akúkoľvek &quot;Výrobok balík&quot; položky, tieto hodnoty môžu byť zapísané do hlavnej tabuľky položky, budú hodnoty skopírované do &quot;Balenie zoznam&quot; tabuľku.",
For Quantity (Manufactured Qty) is mandatory,Pre Množstvo (Vyrobené 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",Pre položku {0} musí byť množstvo záporné,
"For an item {0}, quantity must be positive number",Pri položke {0} musí byť množstvo kladné,
"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",V prípade karty pracovných miest {0} môžete vykonať len typ zásob typu „Transfer materiálu na výrobu“,
"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pre riadok {0} v {1}. Ak chcete v rýchlosti položku sú {2}, riadky {3} musí byť tiež zahrnuté",
For row {0}: Enter Planned Qty,Pre riadok {0}: Zadajte naplánované množstvo,
"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í",
Forum Activity,Aktivita fóra,
Free item code is not selected,Zadarmo kód položky nie je vybratý,
Freight and Forwarding Charges,Nákladní a Spediční Poplatky,
Frequency,Frekvencia,
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 dátumu a do dátumu ležia v inom fiškálnom roku,
From Date cannot be greater than To Date,Dátum OD nemôže byť väčší ako dátum 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 Datetime,Od datetime,
From Delivery Note,Z Dodacího Listu,
From Fiscal Year,Od fiškálneho roka,
From GSTIN,Z GSTIN,
From Party Name,Z názvu strany,
From Pin Code,Z kódu PIN,
From Place,Z miesta,
From Range has to be less than To Range,"Z rozsahu, musí byť nižšia ako na Range",
From State,Z štátu,
From Time,Času od,
From Time Should Be Less Than To Time,Čas by mal byť menej ako čas,
From Time cannot be greater than To Time.,Od doby nemôže byť väčšia ako na čas.,
"From a supplier under composition scheme, Exempt and Nil rated",Od dodávateľa v rámci schémy zloženia boli spoločnosti Oslobodené a Nil ohodnotené,
From and To dates required,Data OD a DO jsou vyžadována,
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},
Fulfillment,splnenie,
Full Name,Celé meno/názov,
Fully Depreciated,plne odpísaný,
Furnitures and Fixtures,Nábytok a svietidlá,
"Further accounts can be made under Groups, but entries can be made against non-Groups","Ďalšie účty môžu byť vyrobené v rámci skupiny, ale údaje je možné proti non-skupín",
Further cost centers can be made under Groups but entries can be made against non-Groups,"Ďalšie nákladové strediská môžu byť vyrobené v rámci skupiny, ale položky môžu byť vykonané proti non-skupín",
Further nodes can be only created under 'Group' type nodes,"Další uzly mohou být pouze vytvořena v uzlech typu ""skupiny""",
GSTIN,GSTIN,
GSTR3B-Form,GSTR3B-Form,
Gain/Loss on Asset Disposal,Zisk / strata z aktív likvidácii,
Gantt Chart,Pruhový diagram,
Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.,
Gender,Pohlavie,
General,všeobecný,
General Ledger,Hlavná Účtovná Kniha,
Generate Material Requests (MRP) and Work Orders.,Generovanie žiadostí o materiál (MRP) a pracovných príkazov.,
Generate Secret,Generovať tajomstvo,
Get Invocies,Získajte faktúry,
Get Invoices,Získajte faktúry,
Get Invoices based on Filters,Získajte faktúry na základe filtrov,
Get Items from BOM,Získat předměty z BOM,
Get Items from Healthcare Services,Získajte položky zo služieb zdravotnej starostlivosti,
Get Items from Prescriptions,Získajte položky z predpisov,
Get Items from Product Bundle,Získať predmety z Bundle Product,
Get Suppliers,Získajte dodávateľov,
Get Suppliers By,Získajte dodávateľov od,
Get Updates,Získať aktualizácie,
Get customers from,Získajte zákazníkov z,
Get from Patient Encounter,Získajte od stretnutia s pacientmi,
Getting Started,Začíname,
GitHub Sync ID,Identifikátor GitHub Sync,
Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.,
Go to the Desktop and start using ERPNext,Prejdite na plochu a začnite používať ERPNext,
GoCardless SEPA Mandate,GoCardless SEPA mandát,
GoCardless payment gateway settings,Nastavenia platobnej brány GoCardless,
Goal and Procedure,Cieľ a postup,
Goals cannot be empty,Bránky nemôže byť prázdny,
Goods In Transit,Tovar v tranzite,
Goods Transferred,Prevedený tovar,
Goods and Services Tax (GST India),Daň z tovarov a služieb (GST India),
Goods are already received against the outward entry {0},Tovar je už prijatý proti vonkajšiemu vstupu {0},
Government,vláda,
Grand Total,Celkem,
Grant,grant,
Grant Application,Žiadosť o grant,
Grant Leaves,Grantové listy,
Grant information.,Poskytnite informácie.,
Grocery,potraviny,
Gross Profit,Hrubý zisk,
Gross Profit %,Hrubý zisk %,
Gross Profit / Loss,Hrubý zisk / strata,
Gross Purchase Amount,Gross Suma nákupu,
Gross Purchase Amount is mandatory,Gross Suma nákupu je povinná,
Group by Account,Seskupit podle účtu,
Group by Party,Skupina podľa strany,
Group by Voucher,Seskupit podle Poukazu,
Group by Voucher (Consolidated),Zoskupiť podľa poukážky (konsolidované),
Group node warehouse is not allowed to select for transactions,Uzol skupina sklad nie je dovolené vybrať pre transakcie,
Group to Non-Group,Skupina na Non-Group,
Group your students in batches,Skupina vaši študenti v dávkach,
Groups,skupiny,
Guardian1 Email ID,ID e-mailu Guardian1,
Guardian1 Mobile No,Guardian1 Mobile Žiadne,
Guardian1 Name,Meno Guardian1,
Guardian2 Email ID,ID e-mailu Guardian2,
Guardian2 Mobile No,Guardian2 Mobile Žiadne,
Guardian2 Name,Meno Guardian2,
HR Manager,HR Manager,
HSN,HSN,
HSN/SAC,HSN / SAC,
Half Yearly,Polročne,
Half-Yearly,Polročne,
Hardware,Technické vybavení,
Head of Marketing and Sales,Vedoucí marketingu a prodeje,
Health Care,Péče o zdraví,
Healthcare,Zdravotná starostlivosť,
Healthcare (beta),Zdravotníctvo (beta),
Healthcare Practitioner,Zdravotnícky lekár,
Healthcare Practitioner not available on {0},Zdravotnícky lekár nie je k dispozícii na {0},
Healthcare Practitioner {0} not available on {1},Zdravotnícky lekár {0} nie je k dispozícii na {1},
Healthcare Service Unit,Útvar zdravotníckej služby,
Healthcare Service Unit Tree,Strom jednotky zdravotníckych služieb,
Healthcare Service Unit Type,Typ jednotky zdravotníckych služieb,
Healthcare Services,Zdravotnícke služby,
Healthcare Settings,Nastavenia zdravotnej starostlivosti,
Help Results for,Výsledky pomoci pre,
High,Vysoké,
High Sensitivity,Vysoká citlivosť,
Hold,Držet,
Hold Invoice,Podržte faktúru,
Holiday,Dovolená,
Holiday List,Dovolená Seznam,
Hotel Rooms of type {0} are unavailable on {1},Hotel Izby typu {0} sú k dispozícii na {1},
Hotels,hotely,
Hourly,hodinový,
Hours,hodiny,
How Pricing Rule is applied?,Jak Ceny pravidlo platí?,
Hub Category,Kategória Hubu,
Hub Sync ID,ID synchronizácie Hubu,
Human Resource,Ľudské Zdroje,
Human Resources,Lidské zdroje,
IGST Amount,Suma IGST,
IP Address,IP adresa,
ITC Available (whether in full op part),ITC k dispozícii (či už v plnej op časti),
ITC Reversed,ITC obrátené,
Identifying Decision Makers,Identifikácia rozhodovacích orgánov,
"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Ak je začiarknuté políčko Auto Opt In, zákazníci budú automaticky prepojení s príslušným vernostným programom (pri ukladaní)",
"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.","Ak sa zvolí pravidlo Pricing for &#39;Rate&#39;, prepíše cenník. Sadzba Pravidlo sadzba je konečná sadzba, takže žiadna ďalšia zľava by sa mala použiť. Preto v transakciách, ako je Predajná objednávka, Objednávka atď., Bude vyzdvihnuté v poli &quot;Rýchlosť&quot;, a nie v poli Cena.",
"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.","V prípade neobmedzeného uplynutia platnosti Vernostných bodov, ponechajte dobu trvania expirácie prázdnu alebo 0.",
"If you have any questions, please get back to us.","Ak máte akékoľvek otázky, obráťte sa na nás.",
Ignore Existing Ordered Qty,Ignorovať existujúce objednané množstvo,
Image,Obrázok,
Image View,Image View,
Import Data,Importovať údaje,
Import Day Book Data,Importovať údaje dennej knihy,
Import Log,Záznam importu,
Import Master Data,Import kmeňových dát,
Import in Bulk,Dovoz hromadnú,
Import of goods,Dovoz tovaru,
Import of services,Dovoz služieb,
Importing Items and UOMs,Import položiek a UOM,
Importing Parties and Addresses,Dovážajúce strany a adresy,
In Maintenance,V Údržbe,
In Production,Vo výrobe,
In Qty,V Množství,
In Stock Qty,Na sklade Množstvo,
In Stock: ,Na sklade:,
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 prípade viacvrstvového programu budú zákazníci automaticky priradení príslušnému vrstvu podľa ich vynaložených prostriedkov,
Inactive,neaktívne,
Incentives,Pobídky,
Include Default FB Entries,Zahrnúť predvolené položky knihy,
Include Exploded Items,Zahrňte explodované položky,
Include POS Transactions,Zahrňte POS transakcie,
Include UOM,Zahrňte UOM,
Included in Gross Profit,Zahrnuté v hrubom zisku,
Income,príjem,
Income Account,Účet příjmů,
Income Tax,Daň z prí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,Prírastok nemôže byť 0,
Increment for Attribute {0} cannot be 0,Prírastok pre atribút {0} nemôže byť 0,
Indirect Expenses,Nepřímé náklady,
Indirect Income,Nepřímé příjmy,
Individual,Individuální,
Ineligible ITC,Neoprávnené ITC,
Initiated,Zahájil,
Inpatient Record,Liečebný záznam,
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,Inštalácia predvolieb,
Institute Abbreviation,Inštitút Skratka,
Institute Name,Meno Institute,
Instructor,inštruktor,
Insufficient Stock,nedostatočná Sklad,
Insurance Start date should be less than Insurance End date,Dátum poistenie štarte by mala byť menšia ako poistenie koncovým dátumom,
Integrated Tax,Integrovaná daň,
Inter-State Supplies,Medzištátne dodávky,
Internet Publishing,Internet Publishing,
Intra-State Supplies,Vnútroštátne dodávky,
Introduction,Úvod,
Invalid Attribute,Neplatný atribút,
Invalid Blanket Order for the selected Customer and Item,Neplatná objednávka prázdnej objednávky pre vybraného zákazníka a položku,
Invalid Company for Inter Company Transaction.,Neplatná spoločnosť pre medzipodnikové transakcie.,
Invalid GSTIN! A GSTIN must have 15 characters.,Neplatné GSTIN! GSTIN musí mať 15 znakov.,
Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Neplatné GSTIN! Prvé dve číslice GSTIN by sa mali zhodovať s číslom štátu {0}.,
Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Neplatné GSTIN! Zadaný vstup sa nezhoduje s formátom GSTIN.,
Invalid Posting Time,Neplatný čas odoslania,
Invalid attribute {0} {1},Neplatný atribút {0} {1},
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Neplatné množstvo uvedené pre položku {0}. Množstvo by malo byť väčšie než 0.,
Invalid reference {0} {1},Neplatná referencie {0} {1},
Invalid {0},Neplatný {0},
Invalid {0} for Inter Company Transaction.,Neplatná hodnota {0} pre internú transakciu.,
Invalid {0}: {1},Neplatný {0}: {1},
Inventory,inventár,
Investment Banking,Investiční bankovnictví,
Investments,Investice,
Invoice,faktúra,
Invoice Created,Vytvorená faktúra,
Invoice Discounting,Diskontovanie faktúry,
Invoice Patient Registration,Faktúra Registrácia pacienta,
Invoice Posting Date,Faktúra Dátum zverejnenia,
Invoice Type,Typ faktúry,
Invoice already created for all billing hours,Faktúra už vytvorená pre všetky fakturačné hodiny,
Invoice can't be made for zero billing hour,Faktúru nemožno vykonať za nulovú fakturačnú hodinu,
Invoice {0} no longer exists,Faktúra {0} už neexistuje,
Invoiced,fakturovaná,
Invoiced Amount,Fakturovaná čiastka,
Invoices,faktúry,
Invoices for Costumers.,Faktúry pre zákazníkov.,
Inward supplies from ISD,Dovozné zásielky z ISD,
Inward supplies liable to reverse charge (other than 1 & 2 above),Dovozné zásielky podliehajúce preneseniu daňovej povinnosti (iné ako vyššie uvedené položky 1 a 2),
Is Active,Je Aktívny,
Is Default,Je Výchozí,
Is Existing Asset,Je existujúcemu aktívu,
Is Frozen,Je Frozen,
Is Group,Is Group,
Issue,Problém,
Issue Material,Vydání Material,
Issued,Vydané,
Issues,problémy,
It is needed to fetch Item Details.,"Je potrebné, aby priniesla 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,Položková skupina,
Item Group Tree,Strom položkových skupín,
Item Group not mentioned in item master for item {0},Položková skupina nie je uvedená v hlavnej položke pre  položku {0},
Item Name,Názov položky,
Item Price added for {0} in Price List {1},Položka Cena pridaný pre {0} v Cenníku {1},
"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Položka Cena sa objavuje viackrát na základe cenníka, dodávateľa / zákazníka, meny, položky, UOM, množstva a dátumov.",
Item Price updated for {0} in Price List {1},Položka Cena aktualizovaný pre {0} v Cenníku {1},
Item Row {0}: {1} {2} does not exist in above '{1}' table,Položka Riadok {0}: {1} {2} neexistuje v tabuľke nad {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,Šablóna položky,
Item Variant Settings,Nastavenia variantu položky,
Item Variant {0} already exists with same attributes,Variant Položky {0} už existuje s rovnakými vlastnosťami,
Item Variants,Varianty položky,
Item Variants updated,Varianty položiek boli aktualizované,
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ány pomocí ""získat předměty z kupní příjmy"" tlačítkem",
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,Variant Položky {0} existuje s rovnakými vlastnosťami,
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} bol zakázaný,
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 šablóna, prosím vyberte jednu z jeho variantov",
Item {0} is cancelled,Položka {0} je zrušená,
Item {0} is disabled,Položka {0} je zakázaná,
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í byť dlhodobý majetok 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í byť 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} nebol nájdený v &quot;suroviny dodanej&quot; tabuľky v objednávke {1},
Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množstvo {1} nemôže byť nižšia ako minimálna Objednané množstvo {2} (definovanej v bode).,
Item: {0} does not exist in the system,Položka: {0} neexistuje v systému,
Items,Položky,
Items Filter,Filtrovanie položiek,
Items and Pricing,Položky a ceny,
Items for Raw Material Request,Položky pre požiadavku na suroviny,
Job Card,Pracovná karta,
Job card {0} created,Vytvorila sa pracovná karta {0},
Join,pripojiť,
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 Stena,
Key Reports,Kľúčové správy,
LMS Activity,Aktivita LMS,
Lab Test,Laboratórny test,
Lab Test Report,Lab Test Report,
Lab Test Sample,Laboratórna vzorka,
Lab Test Template,Šablóna testu laboratória,
Lab Test UOM,Laboratórne testovanie UOM,
Lab Tests and Vital Signs,Laboratórne testy a vitálne znaky,
Lab result datetime cannot be before testing datetime,Výsledok dátumu výsledku laboratória nemôže byť pred dátumom testovania,
Lab testing datetime cannot be before collection datetime,Laboratórne testovanie dátumu nemôže byť pred dátumom zberu,
Label,Popis,
Laboratory,laboratórium,
Large,Veľký,
Last Communication,Posledná komunikácia,
Last Communication Date,Dátum poslednej komunikácie,
Last Name,Priezvisko,
Last Order Amount,Suma poslednej objednávky,
Last Order Date,Posledná Dátum objednávky,
Last Purchase Price,Posledná nákupná cena,
Last Purchase Rate,Posledná nákupná cena,
Latest,najnovšie,
Latest price updated in all BOMs,Posledná cena bola aktualizovaná vo všetkých kusovníkoch,
Lead,Obchodná iniciatíva,
Lead Count,Počet iniciatív,
Lead Owner,Získateľ Obchodnej iniciatívy,
Lead Owner cannot be same as the Lead,Získateľ Obchodnej iniciatívy nemôže byť to isté ako Obchodná iniciatíva,
Lead Time Days,Vek Obchodnej iniciatívy v dňoch,
Lead to Quotation,Pretvorenie iniciatívy na ponuku,
"Leads help you get business, add all your contacts and more as your leads","Obchodné iniciatívy vám pomôžu získať zákazku, zaevidovať všetky vaše kontakty",
Learn,Učenie,
Leave Management,Správa priepustiek,
Leave and Attendance,Priepustky a dochádzky,
Leave application {0} already exists against the student {1},Ponechať aplikáciu {0} už existuje proti študentovi {1},
Leaves has been granted sucessfully,Listy boli úspešne udelené,
Leaves must be allocated in multiples of 0.5,"Listy musí být přiděleny v násobcích 0,5",
Ledger,Účtovná kniha,
Legal,Právne,
Legal Expenses,Výdavky na právne služby,
Letter Head,Záhlavie,
Letter Heads for print templates.,Dopis hlavy na tiskových šablon.,
Level,Úroveň,
Liability,Odpovědnost,
Limit Crossed,limit skríženými,
Link to Material Request,Odkaz na žiadosť o materiál,
List of all share transactions,Zoznam všetkých transakcií s akciami,
List of available Shareholders with folio numbers,Zoznam dostupných akcionárov s číslami fotiek,
Loading Payment System,Načítanie platobného systému,
Loan,pôžička,
Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Dátum začatia pôžičky a obdobie pôžičky sú povinné na uloženie diskontovania faktúry,
Loans (Liabilities),Úvěry (závazky),
Loans and Advances (Assets),Úvěrů a půjček (aktiva),
Local,Místní,
Logs for maintaining sms delivery status,Protokoly pre udržanie stavu doručenia sms,
Lost,Ztracený,
Lost Reasons,Stratené dôvody,
Low,Nízké,
Low Sensitivity,Nízka citlivosť,
Lower Income,S nižšími příjmy,
Loyalty Amount,Vernostná suma,
Loyalty Point Entry,Zadanie vernostného bodu,
Loyalty Points,Vernostné body,
"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Vernostné body sa vypočítajú z vynaloženej hotovosti (prostredníctvom faktúry predaja) na základe zmieneného faktora zberu.,
Loyalty Points: {0},Vernostné body: {0},
Loyalty Program,Vernostný program,
Main,Hlavné,
Maintenance,údržba,
Maintenance Log,Denník údržby,
Maintenance Manager,Správca ú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 v porovnaní s {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í byť zrušený alebo dokončený na odoslanie,
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,Vytvoriť,
Make Payment,Vykonať platbu,
Make project from a template.,Vytvorte projekt zo šablóny.,
Making Stock Entries,Tvorba prírastkov 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,Spravovať svoje objednávky,
Management,Manažment,
Manager,manažér,
Managing Projects,Správa projektov,
Managing Subcontracting,Správa Subdodávky,
Mandatory,Povinné,
Mandatory field - Academic Year,Povinná oblasť - akademický rok,
Mandatory field - Get Students From,Povinné pole - Získajte študentov z,
Mandatory field - Program,Povinné pole - Program,
Manufacture,Výroba,
Manufacturer,Výrobca,
Manufacturer Part Number,Typové označení,
Manufacturing,Výroba,
Manufacturing Quantity is mandatory,Výrobné množstvo je povinné,
Mapping,mapovanie,
Mapping Type,Typ mapovania,
Mark Absent,Označiť ako neprítomný,
Mark Half Day,Mark Poldenné,
Mark Present,Mark Present,
Marketing,marketing,
Marketing Expenses,Marketingové náklady,
Marketplace,Marketplace,
Marketplace Error,Chyba trhu,
Masters,masters,
Match Payments with Invoices,Spárovať úhrady s faktúrami,
Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.,
Material,materiál,
Material Consumption,Spotreba materiálu,
Material Consumption is not set in Manufacturing Settings.,Spotreba materiálu nie je nastavená v nastaveniach výroby.,
Material Receipt,Príjem materiálu,
Material Request,Požiadavka 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.","Požiadavka na materiál nebola vytvorená, pretože množstvo surovín je už k dispozícii.",
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 Žiadosť o príkaze k nákupu,
Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena,
Material Request {0} submitted.,Žiadosť o materiál {0} bola odoslaná.,
Material Transfer,Přesun materiálu,
Material Transferred,Prevedený materiál,
Material to Supplier,Materiál Dodávateľovi,
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álne vzorky - {0} môžu byť zadržané pre dávky {1} a položku {2}.,
Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximálne vzorky - {0} už boli zadržané pre dávku {1} a položku {2} v dávke {3}.,
Maximum discount for Item {0} is {1}%,Maximálna zľava pre položku {0} je {1}%,
Medical Code,Zdravotný zákonník,
Medical Code Standard,Štandardný zdravotnícky kód,
Medical Department,Lekárske oddelenie,
Medical Record,Zdravotný záznam,
Medium,Střední,
Member Activity,Členská aktivita,
Member ID,ID člena,
Member Name,Meno člena,
Member information.,Informácie pre členov.,
Membership,členstva,
Membership Details,Podrobnosti o členstve,
Membership ID,ID členstva,
Membership Type,Typ členstva,
Memebership Details,Informácie o členstve,
Memebership Type Details,Podrobnosti o členstve typu,
Merge,Zlúčiť,
Merge Account,Zlúčiť účet,
Merge with Existing Account,Zlúčiť so existujúcim účtom,
"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojenie je možné len vtedy, ak tieto vlastnosti sú rovnaké v oboch záznamoch. Je Group, Root Type, Company",
Message Examples,Příklady Zpráv,
Message Sent,Správa bola odoslaná,
Method,Metoda,
Middle Income,Středními příjmy,
Middle Name,Stredné meno,
Middle Name (Optional),Druhé meno (voliteľné),
Min Amt can not be greater than Max Amt,Minimálny Amt nesmie byť väčší ako Max. Amt,
Min Qty can not be greater than Max Qty,Min množstvo nemôže byť väčšie ako Max množstvo,
Minimum Lead Age (Days),Minimálny vek vedenia (dni),
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.,Chýba šablóna e-mailu na odoslanie. Prosím nastavte jednu z možností Delivery Settings.,
"Missing value for Password, API Key or Shopify URL","Chýba hodnota hesla, kľúč API alebo URL predaja",
Mode of Payment,Spôsob platby,
Mode of Payments,Spôsob platieb,
Mode of Transport,Druh transportu,
Mode of Transportation,Spôsob dopravy,
Model,Modelka,
Moderate Sensitivity,Stredná citlivosť,
Monday,Pondělí,
Monthly,Měsíčně,
Monthly Distribution,Měsíční Distribution,
More,Viac,
More Information,Viac informácií,
More...,Viac ...,
Motion Picture & Video,Motion Picture & Video,
Move,Stěhovat,
Move Item,Posunúť položku,
Multi Currency,Viac mien,
Multiple Item prices.,Více ceny položku.,
Multiple Loyalty Program found for the Customer. Please select manually.,Viacnásobný vernostný program bol nájdený pre zákazníka. Vyberte prosím ručne.,
"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Viac Cena pravidlá existuje u rovnakých kritérií, prosím vyriešiť konflikt tým, že priradí prioritu. Cena Pravidlá: {0}",
Multiple Variants,Viac variantov,
Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Niekoľko fiškálnych rokov existujú pre dáta {0}. Prosím nastavte spoločnosť vo fiškálnom roku,
Music,Hudba,
Name error: {0},Názov chyba: {0},
Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Názov nového účtu. Poznámka: Prosím, vytvárať účty pre zákazníkov a dodávateľmi",
Name or Email is mandatory,Meno alebo e-mail je povinné,
Nature Of Supplies,Príroda dodávok,
Navigating,Navigácia,
Needs Analysis,Analýza potrieb,
Negative Quantity is not allowed,Záporné množstvo nie je dovolené,
Negative Valuation Rate is not allowed,Negativní ocenění Rate není povoleno,
Negotiation/Review,Vyjednávanie / Review,
Net Asset value as on,Čistá hodnota aktív aj na,
Net Cash from Financing,Čistý peňažný tok z financovania,
Net Cash from Investing,Čistý peňažný tok z investičnej,
Net Cash from Operations,Čistý peňažný tok z prevádzkovej,
Net Change in Accounts Payable,Čistá Zmena účty záväzkov,
Net Change in Accounts Receivable,Čistá zmena objemu pohľadávok,
Net Change in Cash,Čistá zmena v hotovosti,
Net Change in Equity,Čistá zmena vo vlastnom imaní,
Net Change in Fixed Asset,Čistá zmena v stálych aktív,
Net Change in Inventory,Čistá zmena stavu zásob,
Net ITC Available(A) - (B),Dostupné čisté ITC (A) - (B),
Net Profit,Čistý zisk,
Net Total,Netto Spolu,
New Account Name,Nový názov účtu,
New Address,Nová adresa,
New BOM,New BOM,
New Batch ID (Optional),Nové číslo dávky (voliteľné),
New Batch Qty,Nová dávková dávka,
New Company,Nová spoločnosť,
New Cost Center Name,Názov nového nákladového strediska,
New Customer Revenue,Nový zákazník Příjmy,
New Customers,noví zákazníci,
New Department,Nové oddelenie,
New Employee,Nový zamestnanec,
New Location,Nová poloha,
New Quality Procedure,Nový postup kvality,
New Sales Invoice,Nová predajná faktúra,
New Sales Person Name,Meno Nová Sales Osoba,
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,"New Pořadové číslo nemůže mít Warehouse. Warehouse musí být nastaveny Stock vstupním nebo doklad o koupi,",
New Warehouse Name,Nový sklad Name,
New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nový úverový limit je nižšia ako aktuálna dlžnej čiastky za zákazníka. Úverový limit musí byť aspoň {0},
New task,novú úlohu,
New {0} pricing rules are created,Vytvoria sa nové {0} pravidlá tvorby cien,
Newspaper Publishers,Vydavatelia novín,
Next,Ďalej,
Next Contact By cannot be same as the Lead Email Address,Nasledujúce Kontakt Tým nemôže byť rovnaký ako hlavný e-mailovú adresu,
Next Contact Date cannot be in the past,Nasledujúce Kontakt dátum nemôže byť v minulosti,
Next Steps,Ďalšie kroky,
No Action,Žiadna akcia,
No Customers yet!,Zatiaľ žiadni zákazníci!,
No Data,No Data,
No Delivery Note selected for Customer {},Pre zákazníka nie je vybratá žiadna dodacia poznámka {},
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,Pre prenos nie sú k dispozícii žiadne položky,
No Items selected for transfer,Nie sú vybraté žiadne položky na prenos,
No Items to pack,Žádné položky k balení,
No Items with Bill of Materials to Manufacture,Žiadne položky s Bill of Materials Výroba,
No Items with Bill of Materials.,Žiadne položky s kusovníkom.,
No Permission,Nemáte oprávnenie,
No Remarks,Žiadne poznámky,
No Result to submit,Žiadny výsledok na odoslanie,
No Student Groups created.,Žiadne študentské skupiny vytvorený.,
No Students in,Žiadni študenti v,
No Tax Withholding data found for the current Fiscal Year.,Pre súčasný fiškálny rok neboli zistené žiadne údaje o zadržaní dane.,
No Work Orders created,Žiadne pracovné príkazy neboli vytvorené,
No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady,
No contacts with email IDs found.,Neboli nájdené žiadne kontakty s e-mailovými ID.,
No data for this period,Žiadne údaje za toto obdobie,
No description given,Bez popisu,
No employees for the mentioned criteria,Žiadni zamestnanci pre uvedené kritériá,
No gain or loss in the exchange rate,Žiadne zisky alebo straty vo výmennom kurze,
No items listed,Nie sú uvedené žiadne položky,
No items to be received are overdue,"Žiadne položky, ktoré sa majú dostať, nie sú oneskorené",
No material request created,Žiadna materiálová žiadosť nebola vytvorená,
No of Interactions,Počet interakcií,
No of Shares,Počet akcií,
No pending Material Requests found to link for the given items.,"Žiadne prebiehajúce žiadosti o materiál, z ktorých sa zistilo, že odkazujú na dané položky.",
No products found,Nenašli sa žiadne produkty,
No products found.,Nenašli sa žiadne 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 tasks,Žiadne úlohy,
No time sheets,Žiadne časové rozvrhy,
No values,Žiadne hodnoty,
No {0} found for Inter Company Transactions.,Nie je {0} zistené pre transakcie medzi spoločnosťami.,
Non GST Inward Supplies,Spotrebný materiál iný ako GST,
Non Profit,Non Profit,
Non Profit (beta),Neziskové (beta),
Non-GST outward supplies,Vonkajšie dodávky mimo GST,
Non-Group to Group,Non-skupiny k skupine,
None,nikto,
None of the items have any change in quantity or value.,Žiadna z týchto položiek nemá zmenu v množstve alebo hodnote.,
Nos,Balenie,
Not Available,Není k dispozici,
Not Marked,neoznačený,
Not Paid and Not Delivered,Nezaplatené a nedoručené,
Not Permitted,Nepovolené,
Not Started,Nezahájené,
Not active,Neaktívny,
Not allow to set alternative item for the item {0},Nepovoliť nastavenie alternatívnej položky pre 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},Nepovolené pre {0},
"Not permitted, configure Lab Test Template as required","Ak nie je povolené, nakonfigurujte podľa potreby šablónu Lab Test",
Not permitted. Please disable the Service Unit Type,Nepovolené. Zakážte typ servisnej 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 kontrolovať nad-dodávku a nad-rezerváciu pre Položku {0} , keďže množstvo alebo čiastka 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,Hrubé hodnoty nie sú zahrnuté,
Nothing more to show.,To je všetko,
Notify Customers via Email,Informujte zákazníkov prostredníctvom e-mailu,
Number,číslo,
Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervované nemôže byť väčšia ako celkový počet Odpisy,
Number of Interaction,Počet interakcií,
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 zahrnuté do názvu účtu ako predpona",
"Number of new Cost Center, it will be included in the cost center name as a prefix","Počet nových nákladových centier, bude zahrnuté v názve nákladového strediska ako predponu",
Number of root accounts cannot be less than 4,Počet koreňových účtov nesmie byť menší ako 4,
Odometer,Počítadlo najazdených kilometrov,
Office Equipments,Kancelářské Vybavení,
Office Maintenance Expenses,Náklady Office údržby,
Office Rent,Pronájem kanceláře,
On Hold,Podržanie,
On Net Total,On Net Celkem,
One customer can be part of only single Loyalty Program.,Jeden zákazník môže byť súčasťou len jedného vernostného programu.,
Online Auctions,Aukce online,
"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Do nasledujúcej tabuľky bude vybraný iba žiadateľ o štúdium so stavom &quot;Schválený&quot;.,
Only users with {0} role can register on Marketplace,V službe Marketplace sa môžu zaregistrovať iba používatelia s rolou {0},
Open BOM {0},Otvorená BOM {0},
Open Item {0},Otvorená Položka {0},
Open Notifications,Otvorené Oznámenie,
Open Orders,Otvorené objednávky,
Open a new ticket,Otvorte novú letenku,
Opening,Otvor,
Opening (Cr),Otvor (Cr),
Opening (Dr),Opening (Dr),
Opening Accounting Balance,Otvorenie účtovníctva Balance,
Opening Accumulated Depreciation,otvorenie Oprávky,
Opening Accumulated Depreciation must be less than equal to {0},Otvorenie Oprávky musí byť menšia ako rovná {0},
Opening Balance,Počiatočný zostatok,
Opening Balance Equity,Počiatočný stav Equity,
Opening Date and Closing Date should be within same Fiscal Year,Dátum začatia a dátumom ukončenia by malo byť v rámci rovnakého fiškálny rok,
Opening Date should be before Closing Date,Dátum začatia by mala byť pred uzávierky,
Opening Entry Journal,Otvorenie denníka vstupu,
Opening Invoice Creation Tool,Otvorenie nástroja na tvorbu faktúr,
Opening Invoice Item,Otvorenie položky faktúry,
Opening Invoices,Otvorenie faktúr,
Opening Invoices Summary,Otvorenie súhrnu faktúr,
Opening Qty,Otváracie množstvo,
Opening Stock,otvorenie Sklad,
Opening Stock Balance,Otvorenie Sklad Balance,
Opening Value,otvorenie Value,
Opening {0} Invoice created,Otvorenie {0} Vytvorená faktúra,
Operation,Operace,
Operation Time must be greater than 0 for Operation {0},Prevádzková doba musí byť väčšia ako 0 pre prevádzku {0},
"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Prevádzka {0} dlhšie, než všetkých dostupných pracovných hodín v pracovnej stanici {1}, rozložiť prevádzku do niekoľkých operácií",
Operations,Operace,
Operations cannot be left blank,Operácia nemôže byť prázdne,
Opp Count,Opp Count,
Opp/Lead %,Opp / Olovo%,
Opportunities,príležitosti,
Opportunities by lead source,Príležitosti podľa zdroja olova,
Opportunity,príležitosť,
Opportunity Amount,Príležitostná suma,
"Optional. Sets company's default currency, if not specified.","Voliteľné. Nastaví východiskovej mene spoločnosti, ak nie je uvedené.",
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čet objednávok,
Order Entry,Zadanie objednávky,
Order Value,Hodnota objednávky,
Order rescheduled for sync,Objednávka bola preplánovaná na synchronizáciu,
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,organizácie,
Organization Name,Názov organizácie,
Other,Ostatní,
Other Reports,Ostatné správy,
"Other outward supplies(Nil rated,Exempted)","Ostatné pasívne výrobky (bez hodnotenia, oslobodené)",
Out Qty,Out Množství,
Out Value,limitu,
Out of Order,Mimo prevádzky,
Outgoing,Vycházející,
Outstanding,vynikajúci,
Outstanding Amount,Dlužné částky,
Outstanding Amt,Vynikající Amt,
Outstanding Cheques and Deposits to clear,Vynikajúci Š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 podliehajúce zdaneniu (hodnotené nulovou hodnotou),
Overdue,Zpožděný,
Overlap in scoring between {0} and {1},Prekrývajúci sa bodovanie medzi {0} a {1},
Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:,
Owner,Majitel,
PAN,PAN,
POS,POS,
POS Profile,POS Profile,
POS Profile is required to use Point-of-Sale,Profil POS je potrebný na použitie predajného miesta,
POS Profile required to make POS Entry,"POS Profile požadované, aby POS Vstup",
POS Settings,Nastavenia POS,
Packed quantity must equal quantity for Item {0} in row {1},Balené množstvo se musí rovnať množstvu pre položku {0} v riadku {1},
Packing Slip,List k balíku,
Packing Slip(s) cancelled,Balení Slip (y) zrušeno,
Paid,Zaplatené,
Paid Amount,Uhradená čiastka,
Paid Amount cannot be greater than total negative outstanding amount {0},Zaplatená suma nemôže byť vyšší ako celkový negatívny dlžnej čiastky {0},
Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total,
Paid and Not Delivered,Platená a nie je doručenie,
Parameter,Parametr,
Parent Item {0} must not be a Stock Item,Parent Item {0} nesmie byť skladom,
Parents Teacher Meeting Attendance,Zúčastňovanie učiteľov rodičov,
Partially Depreciated,čiastočne odpíše,
Partially Received,Čiastočne prijaté,
Party,Strana,
Party Name,Meno Party,
Party Type,Typ Party,
Party Type and Party is mandatory for {0} account,Typ strany a strana je povinný pre účet {0},
Party Type is mandatory,Typ strana je povinná,
Party is mandatory,Party je povinná,
Past Due Date,Dátum splatnosti,
Patient,trpezlivý,
Patient Appointment,Menovanie pacienta,
Patient Encounter,Stretnutie s pacientmi,
Patient not found,Pacient sa nenašiel,
Pay Remaining,Platba zostávajúca,
Pay {0} {1},Plaťte {0} {1},
Payable,splatný,
Payable Account,Splatnost účtu,
Payment,Splátka,
Payment Cancelled. Please check your GoCardless Account for more details,Platba bola zrušená. Skontrolujte svoj účet GoCardless pre viac informácií,
Payment Confirmation,Potvrdenie platby,
Payment Document,platba Document,
Payment Due Date,Splatné dňa,
Payment Entries {0} are un-linked,Platobné Príspevky {0} sú un-spojený,
Payment Entry,platba Entry,
Payment Entry already exists,Platba Entry už 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 už vytvorili,
Payment Failed. Please check your GoCardless Account for more details,Platba zlyhala. Skontrolujte svoj účet GoCardless pre viac informácií,
Payment Gateway,Platobná brána,
"Payment Gateway Account not created, please create one manually.","Platobná brána účet nevytvorili, prosím, vytvorte ručne.",
Payment Gateway Name,Názov platobnej brány,
Payment Mode,Způsob platby,
Payment Receipt Note,Doklad o zaplatení Note,
Payment Request,Platba Dopyt,
Payment Request for {0},Žiadosť o platbu za {0},
Payment Tems,Platobné podmienky,
Payment Term,Lehota splatnosti,
Payment Terms,Platobné podmienky,
Payment Terms Template,Šablóna platobných podmienok,
Payment Terms based on conditions,Platobné podmienky založené na podmienkach,
Payment Type,Typ platby,
"Payment Type must be one of Receive, Pay and Internal Transfer",Typ platby musí byť jedným z príjem Pay a interný prevod,
Payment against {0} {1} cannot be greater than Outstanding Amount {2},Platba proti {0} {1} nemôže byť väčšia ako dlžnej čiastky {2},
Payment request {0} created,Žiadosť o platbu {0} bola vytvorená,
Payments,Platby,
Payroll Payable,mzdové Splatné,
Payslip,výplatná páska,
Pending Activities,Nevybavené Aktivity,
Pending Amount,Čeká Částka,
Pending Leaves,Čakajúce listy,
Pending Qty,Čakajúci Množstvo,
Pending Quantity,Čakajúce množstvo,
Pending Review,Čeká Review,
Pending activities for today,Nevybavené aktivity pre dnešok,
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ímania,
Period,Obdobie,
Period Closing Entry,Období Uzávěrka Entry,
Period Closing Voucher,Období Uzávěrka Voucher,
Periodicity,periodicita,
Personal Details,Osobné údaje,
Pharmaceutical,farmaceutické,
Pharmaceuticals,Farmaceutické,
Physician,lekár,
Place Of Supply (State/UT),Miesto dodania (štát / UT),
Place Order,Objednať,
Plan Name,Názov 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žstvo: Množstvo, pre ktoré bola zadaná pracovná objednávka, ale čaká sa na výrobu.",
Planning,Plánování,
Plants and Machineries,Rastliny a strojné vybavenie,
Please Set Supplier Group in Buying Settings.,Nastavte skupinu dodávateľov v nastaveniach nákupu.,
Please add a Temporary Opening account in Chart of Accounts,Pridajte účet dočasného otvorenia v účtovej tabuľke,
Please add the account to root level Company - ,Pridajte účet do spoločnosti root -,
Please check Multi Currency option to allow accounts with other currency,"Prosím, skontrolujte viac mien možnosť povoliť účty s inú menu",
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 create purchase receipt or purchase invoice for the item {0},Vytvorte doklad o kúpe alebo nákupnú faktúru pre položku {0},
Please define grade for Threshold 0%,Definujte stupeň pre prah 0%,
Please enable Applicable on Booking Actual Expenses,"Ak chcete použiť skutočné výdavky na rezerváciu, zapnite ho",
Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,"Ak chcete použiť skutočné výdavky na rezerváciu, povoľte platnú objednávku a platné rezervácie",
Please enable pop-ups,Prosím povoľte vyskakovacie okná,
Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne",
Please enter API Consumer Key,Zadajte prosím kľúč spotrebiteľského kľúča API,
Please enter API Consumer Secret,Zadajte zákaznícke tajomstvo služby API,
Please enter Account for Change Amount,"Prosím, zadajte účet pre zmenu Suma",
Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel,
Please enter Cost Center,"Prosím, zadajte nákladové stredisko",
Please enter Delivery Date,Zadajte dátum doručenia,
Please enter Employee Id of this sales person,"Prosím, zadajte ID zamestnanca z tohto predaja osoby",
Please enter Expense Account,"Prosím, zadejte výdajového účtu",
Please enter Item Code to get Batch Number,"Prosím, zadajte kód položky sa dostať čí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, najprv zadajte 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, zadajte Preferred Kontaktný 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, zadajte prevzatia dokumentu",
Please enter Reference date,"Prosím, zadejte Referenční den",
Please enter Reqd by Date,Zadajte Reqd podľa dátumu,
Please enter Woocommerce Server URL,Zadajte URL servera 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, najprv zadajte spoločnosť",
Please enter company name first,"Prosím, zadajte najprv názov spoloč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},Zadajte prosím množstvo pre Položku {0},
Please enter relieving date.,Zadejte zmírnění datum.,
Please enter valid Financial Year Start and End Dates,Zadajte platné dátumy začiatku a konca finančného roka,
Please enter valid email address,Zadajte platnú e-mailovú adresu,
Please enter {0} first,"Prosím, najprv zadajte {0}",
Please fill in all the details to generate Assessment Result.,"Vyplňte všetky podrobnosti, aby ste vygenerovali výsledok hodnotenia.",
Please identify/create Account (Group) for type - {0},Určte / vytvorte účet (skupinu) pre typ - {0},
Please identify/create Account (Ledger) for type - {0},Identifikujte / vytvorte účet (kniha) pre typ - {0},
Please login as another user to register on Marketplace,Prihláste sa ako iný používateľ na registráciu v službe Marketplace,
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.,"Uistite sa, že naozaj chcete vymazať všetky transakcie pre túto spoločnosť. Vaše kmeňové dáta zostanú, ako to je. Túto akciu nie je možné vrátiť späť.",
Please mention Basic and HRA component in Company,"Uveďte, prosím, komponent Basic a HRA v spoločnosti",
Please mention Round Off Account in Company,"Prosím, uveďte zaokrúhliť účet v spoločnosti",
Please mention Round Off Cost Center in Company,"Prosím, uveďte zaokrúhliť nákladové stredisko v spoloč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},Označte vedúci názov vo vedúcej {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,Prihláste prosím číslo SIREN do informačného súboru spoločnosti,
Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1},
Please save the patient first,Najprv si pacienta uložte,
Please save the report again to rebuild or update,Znova zostavte alebo aktualizujte prehľad,
"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žiť Zľava na",
Please select BOM against item {0},"Prosím, vyberte položku BOM proti položke {0}",
Please select BOM for Item in Row {0},"Prosím, vyberte BOM pre položku v riadku {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 spoločnosť",
Please select Company and Posting Date to getting entries,Zvoľte Spoločnosť a dátum odoslania na zadanie záznamov,
Please select Company first,"Prosím, vyberte najprv firmu",
Please select Completion Date for Completed Asset Maintenance Log,Vyberte dátum dokončenia pre dokončený protokol údržby majetku,
Please select Completion Date for Completed Repair,Vyberte dátum dokončenia dokončenej opravy,
Please select Course,Vyberte možnosť Kurz,
Please select Drug,Vyberte Drug,
Please select Existing Company for creating Chart of Accounts,Vyberte existujúci spoločnosti pre vytváranie účtový rozvrh,
Please select Healthcare Service,Vyberte prosím službu zdravotnej starostlivosti,
"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 skladom,&quot; je &quot;Nie&quot; a &quot;je Sales Item&quot; &quot;Áno&quot; a nie je tam žiadny iný produkt Bundle",
Please select Maintenance Status as Completed or remove Completion Date,Vyberte Stav údržby ako Dokončené alebo Odstráňte Dátum dokončenia,
Please select Party Type first,"Prosím, vyberte typ Party prvý",
Please select Patient,Vyberte pacienta,
Please select Patient to get Lab Tests,"Ak chcete získať laboratórne testy, vyberte položku Pacient",
Please select Posting Date before selecting Party,"Prosím, vyberte Dátum zverejnenia pred výberom Party",
Please select Posting Date first,"Prosím, vyberte najprv Dátum zverejnenia",
Please select Price List,"Prosím, vyberte cenník",
Please select Program,Vyberte program,
Please select Qty against item {0},Vyberte položku Qty v položke {0},
Please select Sample Retention Warehouse in Stock Settings first,Najskôr vyberte položku Sample Retention Warehouse in Stock Stock Settings,
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 Študentské prijatie, ktoré je povinné pre platených študentov",
Please select a BOM,Vyberte kusovník,
Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Vyberte položku Dávka pre položku {0}. Nie je možné nájsť jednu dávku, ktorá spĺňa túto požiadavku",
Please select a Company,Vyberte spoločnosť,
Please select a batch,Vyberte dávku,
Please select a field to edit from numpad,"Vyberte pole, ktoré chcete upraviť z čísla",
Please select a table,Vyberte tabuľku,
Please select a valid Date,Vyberte platný dátum,
Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1},
Please select a warehouse,Vyberte si sklad,
Please select at least one domain.,Vyberte aspoň jednu doménu.,
Please select correct account,"Prosím, vyberte správny účet",
Please select date,"Prosím, vyberte dátum",
Please select item code,"Prosím, vyberte položku kód",
Please select month and year,Vyberte měsíc a rok,
Please select the Company,Vyberte spoločnosť,
Please select the Multiple Tier Program type for more than one collection rules.,Vyberte typ viacvrstvového programu pre viac ako jednu pravidlá kolekcie.,
Please select the assessment group other than 'All Assessment Groups',Vyberte inú hodnotiacu skupinu ako &quot;Všetky hodnotiace skupiny&quot;,
Please select the document type first,Najprv vyberte 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, najprv vyberte {0}",
Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použiť dodatočnú zľavu On&quot;,
Please set 'Asset Depreciation Cost Center' in Company {0},Prosím nastavte &quot;odpisy majetku nákladové stredisko&quot; vo firme {0},
Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prosím nastavte &quot;/ STRATY zisk z aktív odstraňovaním&quot; vo firme {0},
Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Nastavte účet vo Warehouse {0} alebo predvolený účet inventára v spoločnosti {1},
Please set B2C Limit in GST Settings.,V nastavení GST nastavte limit B2C.,
Please set Company,Nastavte spoločnosť,
Please set Company filter blank if Group By is 'Company',"Filtrovanie spoločnosti nastavte prázdne, ak je položka Skupina pod skupinou &quot;Spoločnosť&quot;",
Please set Default Payroll Payable Account in Company {0},"Prosím nastaviť predvolený účet mzdy, splatnú v spoločnosti {0}",
Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosím, amortizácia účty s ním súvisiacich v kategórii Asset {0} alebo {1} Company",
Please set GST Accounts in GST Settings,Nastavte si účty GST v nastaveniach služby GST,
Please set Hotel Room Rate on {},"Prosím, nastavte sadzbu izby hotela na {}",
Please set Number of Depreciations Booked,Prosím nastavte Počet Odpisy rezervované,
Please set Unrealized Exchange Gain/Loss Account in Company {0},Prosím nastavte Unrealized Exchange Gain / Loss účet v spoločnosti {0},
Please set User ID field in an Employee record to set Employee Role,Prosím nastavte používateľské ID v karte zamestnanca ak chcete umožniť rolu zamestnanca,
Please set a default Holiday List for Employee {0} or Company {1},Prosím nastaviť predvolené Holiday List pre zamestnancov {0} alebo {1} Company,
Please set account in Warehouse {0},Nastavte si účet v službe Warehouse {0},
Please set an active menu for Restaurant {0},Nastavte prosím aktívnu ponuku reštaurácie {0},
Please set associated account in Tax Withholding Category {0} against Company {1},Nastavte priradený účet v kategórii zrážky dane {0} voči spoločnosti {1},
Please set at least one row in the Taxes and Charges Table,V tabuľke daní a poplatkov nastavte aspoň jeden riadok,
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 nastaviť predvolený účet platu Component {0},
Please set default customer in Restaurant Settings,Nastavte štandardný zákazník v nastaveniach reštaurácie,
Please set default {0} in Company {1},Prosím nastaviť predvolený {0} vo firme {1},
Please set filter based on Item or Warehouse,Prosím nastaviť filter na základe výtlačku alebo v sklade,
Please set leave policy for employee {0} in Employee / Grade record,Nastavte prosím politiku dovolenky pre zamestnanca {0} v zázname Employee / Grade,
Please set recurring after saving,Prosím nastavte opakovanie po uložení,
Please set the Customer Address,Nastavte adresu zákazníka,
Please set the Default Cost Center in {0} company.,Nastavte štandardné cenové centrum v spoločnosti {0}.,
Please set the Email ID for the Student to send the Payment Request,"Prosím, nastavte ID e-mailu, aby študent poslal Žiadosť o platbu",
Please set the Item Code first,Najprv nastavte kód položky,
Please set the Payment Schedule,Nastavte plán platieb,
Please set {0} for address {1},Nastavte {0} pre adresu {1},
Please setup Students under Student Groups,Nastavte prosím študentov pod študentskými skupinami,
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},Zadajte platný riadok ID riadku tabuľky {0} {1},
Please specify at least one attribute in the Attributes table,Uveďte aspoň jeden atribút v tabuľke atribúty,
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žstvo alebo Pomer ocenenia, alebo obidve.",
Please specify from/to range,Uveďte z / do rozmedzie,
Please supply the specified items at the best possible rates,Prosím dodávať uvedené položky na najlepšie možné ceny,
Please wait 3 days before resending the reminder.,"Počkajte, prosím, 3 dni pred odoslaním pripomienky.",
Point of Sale,Miesto predaja,
Point-of-Sale,Mieste predaja,
Point-of-Sale Profile,Point-of-Sale Profil,
Portal,Portál,
Possible Supplier,možné Dodávateľ,
Postal Expenses,Poštovní náklady,
Posting Date,Dátum pridania,
Posting Date cannot be future date,Vysielanie dátum nemôže byť budúci dátum,
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ý rozvrh,
Pre Sales,Predpredaj,
Preference,prednosť,
Prescribed Procedures,Predpísané postupy,
Prescription,predpis,
Prescription Dosage,Dávkovanie na predpis,
Prescription Duration,Trvanie predpisu,
Prescriptions,predpisy,
Prev,Predchádzajúce,
Preview,Náhľad,
Previous Financial Year is not closed,Predchádzajúci finančný rok nie je uzavretý,
Price,cena,
Price List,Cenník,
Price List Currency not selected,Mena pre cenník nie je vybratá,
Price List Rate,Cenníková cena,
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,Cenníková cena {0} je zakázaná alebo neexistuje,
Price or product discount slabs are required,Vyžadujú sa dosky na zníženie ceny alebo produktu,
Pricing,stanovenie ceny,
Pricing Rule,Cenové 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 tvorby cien {0} je aktualizované,
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árnej adrese,
Primary Contact Details,Priame kontaktné údaje,
Print Format,Formát tlače,
Print IRS 1099 Forms,Tlačte formuláre IRS 1099,
Print Report Card,Vytlačiť kartu správ,
Print Settings,Nastavenie tlače,
Print and Stationery,Tlač a papiernictva,
Print settings updated in respective print format,Nastavenie tlače aktualizované v príslušnom formáte tlači,
Print taxes with zero amount,Tlačiť dane s nulovou čiastkou,
Printing and Branding,Tisk a identita,
Private Equity,Private Equity,
Procedure,procedúra,
Process Day Book Data,Spracovať údaje dennej knihy,
Process Master Data,Spracovať kmeňové dáta,
Processing Chart of Accounts and Parties,Spracovateľská schéma účtov a strán,
Processing Items and UOMs,Spracúvanie položiek a UOM,
Processing Party Addresses,Adresy spracovateľských strán,
Processing Vouchers,Spracovávajú sa poukazy,
Procurement,Obstarávanie,
Produced Qty,Vyrobené Množstvo,
Product,výrobok,
Product Bundle,Produktový balíček,
Product Search,Hľadať produkt,
Production,výroba,
Production Item,Výrobná položka,
Products,Výrobky,
Profit and Loss,Zisk a strata,
Profit for the year,Zisk za rok,
Program,Program,
Program in the Fee Structure and Student Group {0} are different.,Program v štruktúre poplatkov a študentskej skupine {0} je odlišný.,
Program {0} does not exist.,Program {0} neexistuje.,
Program: ,Program:,
Progress % for a task cannot be more than 100.,Pokrok% za úlohu nemôže byť viac ako 100.,
Project Collaboration Invitation,Projekt spolupráce Pozvánka,
Project Id,Id projektu,
Project Manager,Project Manager,
Project Name,Názov projektu,
Project Start Date,Datum zahájení projektu,
Project Status,Stav projektu,
Project Summary for {0},Zhrnutie projektu pre {0},
Project Update.,Aktualizácia 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,Premietané množstvo,
Projected Quantity Formula,Vzorec predpokladaného množstva,
Projects,projekty,
Proposal Writing,Návrh Psaní,
Proposal/Price Quote,Návrh / cenová ponuka,
Prospecting,prieskum,
Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit),
Publications,Publikácie,
Publish Items on Website,Publikovať položky na webových stránkach,
Published,Zverejnené,
Publishing,Zverejnenie,
Purchase,nákup,
Purchase Amount,Suma nákupu,
Purchase Date,Dátum nákupu,
Purchase Invoice,Prijatá faktúra,
Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána,
Purchase Manager,Manažér nákupu,
Purchase Master Manager,Nadriadený manažér nákupu,
Purchase Order,Nákupná objednávka,
Purchase Order Amount,Suma objednávky,
Purchase Order Amount(Company Currency),Suma objednávky (mena spoločnosti),
Purchase Order Date,Dátum objednávky,
Purchase Order Items not received on time,Položky objednávok neboli prijaté 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 platobné,
Purchase Order {0} is not submitted,Vydaná objednávka {0} nie je odoslaná,
Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Objednávky nie sú povolené {0} kvôli postaveniu 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,Spotrebná daň šablóny,
Purchase User,Nákup Uživatel,
Purchase orders help you plan and follow up on your purchases,Objednávky pomôžu pri plánovaní a sledovaní na vaše nákupy,
Purchasing,nákup,
Purpose must be one of {0},Cíl musí být jedním z {0},
Qty,množstvo,
Qty To Manufacture,Množství K výrobě,
Qty Total,Celkový počet,
Qty for {0},Množství pro {0},
Qualification,Kvalifikace,
Quality,kvalita,
Quality Action,Kvalitná akcia,
Quality Goal.,Cieľ kvality.,
Quality Inspection,Kontrola kvality,
Quality Inspection: {0} is not submitted for the item: {1} in row {2},Kontrola kvality: {0} sa neodovzdáva pre položku: {1} v riadku {2},
Quality Management,Riadenie kvality,
Quality Meeting,Kvalitné stretnutie,
Quality Procedure,Postup kvality,
Quality Procedure.,Postup kvality.,
Quality Review,Kontrola kvality,
Quantity,množstvo,
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žstvo musí byť menší ako alebo rovný {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žstvo by mala byť väčšia ako 0,
Quantity to Make,"Množstvo, ktoré sa má vyrobiť",
Quantity to Manufacture must be greater than 0.,"Množstvo, ktoré má výroba musí byť väčšia ako 0 ° C.",
Quantity to Produce,Množstvo na výrobu,
Quantity to Produce can not be less than Zero,Množstvo na výrobu nesmie byť menšie ako nula,
Query Options,Možnosti dotazu,
Queued for replacing the BOM. It may take a few minutes.,Namiesto výmeny kusovníka. Môže to trvať niekoľko minút.,
Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Naliehavá aktualizácia najnovšej ceny vo všetkých účtovných dokladoch. Môže to trvať niekoľko minút.,
Quick Journal Entry,Rýchly vstup Journal,
Quot Count,Počet kvót,
Quot/Lead %,Quot / Olovo%,
Quotation,citát,
Quotation {0} is cancelled,Ponuka {0} je zrušená,
Quotation {0} not of type {1},Ponuka {0} nie je typu {1},
Quotations,Ponuky,
"Quotations are proposals, bids you have sent to your customers","Ponuky sú návrhy, ponuky zaslané vašim zákazníkom",
Quotations received from Suppliers.,Ponuky od Dodávateľov.,
Quotations: ,Ponuky:,
Quotes to Leads or Customers.,Ponuka z Obchodnej Iniciatívy alebo pre Zákazníka,
RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ nie sú povolené pre {0} kvôli postaveniu skóre {1},
Range,rozsah,
Rate,Sadzba,
Rate:,rýchlosť:,
Rating,Rating,
Raw Material,Surovina,
Raw Materials,Suroviny,
Raw Materials cannot be blank.,Suroviny nemůže být prázdný.,
Re-open,Znovu otvoriť,
Read blog,Prečítajte si blog,
Read the ERPNext Manual,Prečítajte si ERPNext Manuál,
Reading Uploaded File,Čítanie nahraného súboru,
Real Estate,Nehnuteľnosť,
Reason For Putting On Hold,Dôvod pre pozastavenie,
Reason for Hold,Dôvod pozastavenia,
Reason for hold: ,Dôvod pozastavenia:,
Receipt,Potvrdenka,
Receipt document must be submitted,Príjem a musí byť predložený,
Receivable,Pohľadávky,
Receivable Account,Účet pohľadávok,
Received,Prijaté,
Received On,Prijaté dňa,
Received Quantity,Prijaté množstvo,
Received Stock Entries,Prijaté položky zásob,
Receiver List is empty. Please create Receiver List,Zoznam príjemcov je prázdny. Prosím vytvorte zoznam príjemcov.,
Recipients,Príjemcovia,
Reconcile,Zosúladiť,
"Record of all communications of type email, phone, chat, visit, etc.","Záznam všetkých oznámení typu e-mail, telefón, chát, návštevy, atď",
Records,záznamy,
Redirect URL,presmerovanie URL,
Ref,Ref,
Ref Date,Ref Dátum,
Reference,Referencia,
Reference #{0} dated {1},Referencia # {0} zo dňa {1},
Reference Date,Referenčný dátum,
Reference Doctype must be one of {0},Referenčná DOCTYPE musí byť 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ý dátum je povinný pre bankové transakcie,
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 Type,Typ reference,
"Reference: {0}, Item Code: {1} and Customer: {2}","Odkaz: {0}, Kód položky: {1} a zákazník: {2}",
References,Referencie,
Refresh Token,obnoviť Token,
Register,Registrovať,
Rejected,Zamítnuto,
Related,príbuzný,
Relation with Guardian1,Súvislosť s Guardian1,
Relation with Guardian2,Súvislosť s Guardian2,
Release Date,Dátum vydania,
Reload Linked Analysis,Znova načítať prepojenú analýzu,
Remaining,zostávajúce,
Remaining Balance,Zostávajúci zostatok,
Remarks,Poznámky,
Reminder to update GSTIN Sent,Pripomenutie aktualizácie 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.,Odstránené položky bez zmeny množstva alebo hodnoty.,
Reopen,znovu otvoriť,
Reorder Level,Změna pořadí Level,
Reorder Qty,Změna pořadí Množství,
Repeat Customer Revenue,Repeat Customer Příjmy,
Repeat Customers,Verní zákazníci,
Replace BOM and update latest price in all BOMs,Nahraďte kusovník a aktualizujte najnovšiu cenu vo všetkých kusovníkoch,
Replied,Odpovězeno,
Report,Report,
Report Type,Typ výpisu,
Report Type is mandatory,Report Type je povinné,
Reports,správy,
Reqd By Date,Pr p Podľa dátumu,
Reqd Qty,Požad,
Request for Quotation,Žiadosť o cenovú ponuku,
Request for Quotations,Žiadosť o citátov,
Request for Raw Materials,Žiadosť o suroviny,
Request for purchase.,Žádost o koupi.,
Request for quotation.,Žiadosť o cenovú ponuku.,
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,Žiadajúci web,
Requesting payment against {0} {1} for amount {2},Požiadavka na platbu proti {0} {1} na sumu {2},
Requestor,žiadateľ,
Required On,Povinné On,
Required Qty,Požadované množství,
Required Quantity,Požadované množstvo,
Reschedule,presunúť,
Research,Výzkum,
Research & Development,Výzkum a vývoj,
Researcher,Výzkumník,
Resend Payment Email,Znovu poslať e-mail Payment,
Reserve Warehouse,Rezervný sklad,
Reserved Qty,Reserved Množství,
Reserved Qty for Production,Vyhradené množstvo pre výrobu,
Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Vyhradené množstvo pre výrobu: Množstvo surovín na výrobu výrobných položiek.,
"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,Vyhradený sklad je povinný pre položku {0} v dodávaných surovinách,
Reserved for manufacturing,Vyhradené pre výrobu,
Reserved for sale,Vyhradené pre predaj,
Reserved for sub contracting,Vyhradené pre subkontraktovanie,
Resistant,odolný,
Resolve error and upload again.,Vyriešte chybu a odovzdajte znova.,
Rest Of The World,Zbytek světa,
Restart Subscription,Reštartujte odber,
Restaurant,reštaurácie,
Result Date,Dátum výsledku,
Result already Submitted,Výsledok už bol odoslaný,
Resume,Pokračovať,
Retail,Maloobchod,
Retail & Wholesale,Maloobchod a veľkoobchod,
Retail Operations,Maloobchodné operácie,
Retained Earnings,Nerozdelený zisk,
Retention Stock Entry,Retenčný záznam,
Retention Stock Entry already created or Sample Quantity not provided,Už vytvorený záznam o zadržaní alebo množstvo neposkytnuté,
Return,Spiatočná,
Return / Credit Note,Return / dobropis,
Return / Debit Note,Return / ťarchopis,
Returns,výnos,
Reverse Journal Entry,Zadanie reverzného denníka,
Review Invitation Sent,Recenzia pozvánky odoslaná,
Review and Action,Preskúmanie a konanie,
Rooms Booked,Izby boli rezervované,
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,Zaokrúhliť,
Rounded Total,Zaoblený Total,
Route,trasa,
Row # {0}: ,Řádek # {0}:,
Row # {0}: Batch No must be same as {1} {2},"Row # {0}: Batch No musí byť rovnaké, ako {1} {2}",
Row # {0}: Cannot return more than {1} for Item {2},Riadok # {0}: Nemožno vrátiť viac ako {1} pre bodu {2},
Row # {0}: Rate cannot be greater than the rate used in {1} {2},Riadok # {0}: Sadzba nesmie byť vyššia ako sadzba použitá v {1} {2},
Row # {0}: Serial No is mandatory,Riadok # {0}: Výrobné číslo je povinné,
Row # {0}: Serial No {1} does not match with {2} {3},Riadok # {0}: Výrobné číslo {1} nezodpovedá {2} {3},
Row #{0} (Payment Table): Amount must be negative,Riadok # {0} (Platobný stôl): Suma musí byť záporná,
Row #{0} (Payment Table): Amount must be positive,Riadok # {0} (Platobný stôl): Suma musí byť pozitívna,
Row #{0}: Account {1} does not belong to company {2},Riadok # {0}: Účet {1} nepatrí spoločnosti {2},
Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Riadok # {0}: Pridelená čiastka nemôže byť vyššia ako dlžná suma.,
"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Riadok # {0}: Asset {1} nemôže byť predložený, je už {2}",
Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Riadok # {0}: Nie je možné nastaviť sadzbu, ak je suma vyššia ako čiastka fakturácie pre položku {1}.",
Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Riadok # {0}: dátum Svetlá {1} nemôže byť pred Cheque Dátum {2},
Row #{0}: Duplicate entry in References {1} {2},Riadok # {0}: Duplicitný záznam v referenciách {1} {2},
Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Riadok # {0}: Predpokladaný dátum doručenia nemôže byť pred dátumom objednávky,
Row #{0}: Item added,Riadok # {0}: Položka bola pridaná,
Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Riadok # {0}: Journal Entry {1} nemá účet {2} alebo už uzavreté proti inému poukazu,
Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Riadok # {0}: Nie je povolené meniť dodávateľa, objednávky už existuje",
Row #{0}: Please set reorder quantity,Riadok # {0}: Prosím nastavte množstvo objednávacie,
Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1},
Row #{0}: Qty increased by 1,Riadok # {0}: Množstvo sa zvýšilo o 1,
Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Riadok # {0}: Cena musí byť rovnaké, ako {1}: {2} ({3} / {4})",
Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Riadok # {0}: Typ referenčného dokumentu musí byť jeden z nárokov na výdaj alebo denníka,
"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Riadok # {0}: Reference Document Type musí byť jedným z objednávky, faktúry alebo Journal Entry",
Row #{0}: Rejected Qty can not be entered in Purchase Return,Riadok # {0}: zamietnutie Množstvo nemôže byť zapísaný do kúpnej Návrat,
Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Riadok # {0}: zamietnutie Warehouse je povinná proti zamietnutej bodu {1},
Row #{0}: Reqd by Date cannot be before Transaction Date,Riadok # {0}: Reqd by Date nemôže byť pred dátumom transakcie,
Row #{0}: Set Supplier for item {1},Riadok # {0}: Nastavte Dodávateľ pre položku {1},
Row #{0}: Status must be {1} for Invoice Discounting {2},"Riadok č. {0}: Stav musí byť {1}, aby sa mohlo znížiť množstvo faktúr {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","Riadok # {0}: Dávka {1} má iba {2} qty. Vyberte inú dávku, ktorá má {3} k dispozícii, alebo rozdeľte riadok do viacerých riadkov a doručte / vydávajte z viacerých šarží",
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},Riadok # {0}: {1} nemôže byť negatívne na {2},
Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},"Riadok č {0}: Čiastka nemôže byť väčšia ako Čakajúci Suma proti Expense nároku {1}. Do doby, než množstvo je {2}",
Row {0} : Operation is required against the raw material item {1},Riadok {0}: Vyžaduje sa operácia proti položke surovín {1},
Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Riadok {0} # Položka {1} nemožno previesť viac ako {2} do objednávky {3},
Row {0}: Activity Type is mandatory.,Riadok {0}: typ činnosti je povinná.,
Row {0}: Advance against Customer must be credit,Riadok {0}: Advance proti zákazník musí byť úver,
Row {0}: Advance against Supplier must be debit,Riadok {0}: Advance proti dodávateľom musí byť odpísať,
Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Riadok {0}: Pridelená suma {1} musí byť menší ako alebo sa rovná sume zaplatení 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},Riadok {0}: Nomenklatúra nebol nájdený pre výtlačku {1},
Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné,
Row {0}: Cost center is required for an item {1},Riadok {0}: Pre položku {1} sa vyžaduje nákladové centrum.,
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},Riadok {0}: Mena BOM # {1} by sa mala rovnať vybranej mene {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,Riadok {0}: Vyžaduje sa dátum začiatku odpisovania,
Row {0}: Enter location for the asset item {1},Riadok {0}: Zadajte umiestnenie položky majetku {1},
Row {0}: Exchange Rate is mandatory,Riadok {0}: Exchange Rate je povinné,
Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Riadok {0}: Očakávaná hodnota po skončení životnosti musí byť nižšia ako čiastka hrubého nákupu,
Row {0}: From Time and To Time is mandatory.,Riadok {0}: From Time a na čas je povinná.,
Row {0}: From Time and To Time of {1} is overlapping with {2},Riadok {0}: čas od času aj na čas z {1} sa prekrýva s {2},
Row {0}: From time must be less than to time,Riadok {0}: Čas od času musí byť kratší ako čas,
Row {0}: Hours value must be greater than zero.,Riadok {0}: doba hodnota musí byť väčšia ako nula.,
Row {0}: Invalid reference {1},Riadok {0}: Neplatné referencie {1},
Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Riadok {0}: Party / Account nezhoduje s {1} / {2} do {3} {4},
Row {0}: Party Type and Party is required for Receivable / Payable account {1},Riadok {0}: Typ Party Party a je nutné pre pohľadávky / záväzky na účte {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,Riadok {0}: V Dane z obratu a poplatkoch nastavte prosím na dôvod oslobodenia od dane,
Row {0}: Please set the Mode of Payment in Payment Schedule,Riadok {0}: Nastavte si spôsob platby v pláne platieb,
Row {0}: Please set the correct code on Mode of Payment {1},Riadok {0}: Nastavte správny kód v platobnom režime {1},
Row {0}: Qty is mandatory,Row {0}: Množství je povinný,
Row {0}: Quality Inspection rejected for item {1},Riadok {0}: Kontrola kvality zamietnutá pre položku {1},
Row {0}: UOM Conversion Factor is mandatory,Riadok {0}: Konverzný faktor MJ je povinný,
Row {0}: select the workstation against the operation {1},Riadok {0}: vyberte pracovnú stanicu proti operácii {1},
Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Riadok {0}: {1} Sériové čísla vyžadované pre položku {2}. Poskytli ste {3}.,
Row {0}: {1} must be greater than 0,Riadok {0}: {1} musí byť väčší ako 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},V iných riadkoch boli nájdené riadky s duplicitnými termínmi: {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,Suma SGST,
SO Qty,Množstvo na PO,
Safety Stock,Bezpečnostná zásoba,
Salary,plat,
Salary Slip submitted for period from {0} to {1},Zápis platu bol odoslaný na obdobie od {0} do {1},
Salary Structure must be submitted before submission of Tax Ememption Declaration,Štruktúra miezd musí byť predložená pred predložením daňového priznania,
Sales,Predaj,
Sales Account,Predajný účet,
Sales Expenses,Predajné náklady,
Sales Funnel,Predajný lievik,
Sales Invoice,Predajná faktúra,
Sales Invoice {0} has already been submitted,Predajná faktúra {0} už bola odoslaná,
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žér predaja,
Sales Master Manager,Nadriadený manažér predaja,
Sales Order,Predajné objednávky,
Sales Order Item,Položka predajnej objednávky,
Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0},
Sales Order to Payment,Predajné 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},Predajné objednávky {0} {1},
Sales Orders,Predajné objednávky,
Sales Partner,Partner predaja,
Sales Pipeline,predajné Pipeline,
Sales Price List,Predajný cenník,
Sales Return,Sales Return,
Sales Summary,Súhrn predajov,
Sales Tax Template,Daň z predaja Template,
Sales Team,Predajný tím,
Sales User,Používateľ predaja,
Sales and Returns,Predaje a vrátenia,
Sales campaigns.,Predajné kampane,
Sales orders are not available for production,Príkazy na predaj nie sú k dispozícii na výrobu,
Salutation,Oslovenie,
Same Company is entered more than once,Rovnaký Spoločnosť je zapísaná viac ako raz,
Same item cannot be entered multiple times.,Rovnakú položku nemožno zadávať viackrát.,
Same supplier has been entered multiple times,Rovnaký dodávateľ bol zadaný viackrát,
Sample Collection,Zbierka vzoriek,
Sample quantity {0} cannot be more than received quantity {1},Množstvo vzorky {0} nemôže byť väčšie ako prijaté množstvo {1},
Sanctioned,Sankcionované,
Sand,piesok,
Saturday,Sobota,
Saving {0},Uloženie {0},
Scan Barcode,Naskenujte čiarový kód,
Schedule,plán,
Schedule Admission,Plán prijatia,
Schedule Course,rozvrh,
Schedule Date,Plán Dátum,
Schedule Discharge,Rozvrh Výdavky,
Scheduled,Plánované,
Scheduled Upto,Plánované až,
"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Plán pre prekrytie {0}, chcete pokračovať po preskočení prekryvných pozícií?",
Score cannot be greater than Maximum Score,Skóre nemôže byť väčšia ako maximum bodov,
Scorecards,scorecards,
Scrapped,zošrotovaný,
Search,Hľadať,
Search Results,Výsledky vyhľadávania,
Search Sub Assemblies,Vyhľadávanie Sub Assemblies,
"Search by item code, serial number, batch no or barcode","Vyhľadajte podľa kódu položky, sériového čísla, šarže alebo čiarového kódu",
"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd.",
Secret Key,Tajný kľúč,
Secretary,sekretárka,
Section Code,Kód sekcie,
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,Pozrite si všetky články,
See all open tickets,Pozrite si všetky otvorené lístky,
See past orders,Zobraziť minulé objednávky,
See past quotations,Zobraziť minulé ponuky,
Select,Vybrať,
Select Alternate Item,Vyberte alternatívnu položku,
Select Attribute Values,Vyberte hodnoty atribútov,
Select BOM,select BOM,
Select BOM and Qty for Production,Vyberte BOM a Množstvo na výrobu,
"Select BOM, Qty and For Warehouse","Vyberte kusovník, množstvo a sklad",
Select Batch,Vyberte možnosť Dávka,
Select Batch Numbers,Vyberte dávkové čísla,
Select Brand...,Zvoľte značku ...,
Select Company,Vyberte spoločnosť,
Select Company...,Vyberte spoločnosť ...,
Select Customer,Vyberte zákazníka,
Select Days,Vyberte dni,
Select Default Supplier,Vybrať Predvolené Dodávateľ,
Select DocType,Zvoľte DocType,
Select Fiscal Year...,Vyberte fiškálny rok ...,
Select Item (optional),Vyberte položku (voliteľné),
Select Items based on Delivery Date,Vyberte položku podľa dátumu doručenia,
Select Items to Manufacture,Vyberte položky do výroby,
Select Loyalty Program,Vyberte Vernostný program,
Select Patient,Vyberte pacienta,
Select Possible Supplier,Zvoľte Možné dodávateľa,
Select Quantity,Zvoľte množstvo,
Select Serial Numbers,Vyberte Sériové čísla,
Select Target Warehouse,Vyberte položku Target Warehouse,
Select Warehouse...,Vyberte sklad ...,
Select an account to print in account currency,"Vyberte účet, ktorý chcete vytlačiť v mene účtu",
Select at least one value from each of the attributes.,Vyberte aspoň jednu hodnotu z každého atribútu.,
Select change amount account,Vybrať zmena výšky účet,
Select company first,Najprv vyberte spoločnosť,
Select students manually for the Activity based Group,Vyberte manuálne študentov pre skupinu založenú na aktivitách,
Select the customer or supplier.,Vyberte zákazníka alebo dodávateľa.,
Select the nature of your business.,Vyberte podstatu svojho podnikania.,
Select the program first,Najprv vyberte program,
Select to add Serial Number.,"Vyberte, ak chcete pridať sériové číslo.",
Select your Domains,Vyberte svoje domény,
Selected Price List should have buying and selling fields checked.,Vybraný cenník by mal kontrolovať pole nákupu a predaja.,
Sell,Predať,
Selling,Predaj,
Selling Amount,Predajná čiastka,
Selling Price List,Cenník predaja,
Selling Rate,Predajná sadzba,
"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,Odošlite e-mail na posúdenie grantu,
Send Now,Odoslať teraz,
Send SMS,Poslať SMS,
Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům,
Sensitivity,citlivosť,
Sent,Odoslané,
Serial No and Batch,Sériové číslo a Dávka,
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} nepatrí do dávky {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,"Poradové číslo {0} nepatrí 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} už je uvedené vo faktúre predaja: {1},
Serial Numbers,Sériové čísla,
Serial Numbers in row {0} does not match with Delivery Note,Sériové čísla v riadku {0} sa nezhodujú s dodacím listom,
Serial no {0} has been already returned,Sériové číslo {0} už bolo vrátené,
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é,
Service,Služba,
Service Level Agreement,Dohoda o úrovni služieb,
Service Level Agreement.,Dohoda o úrovni služieb.,
Service Level.,Úroveň služieb.,
Service Stop Date cannot be after Service End Date,Dátum ukončenia servisu nemôže byť po dátume ukončenia služby,
Service Stop Date cannot be before Service Start Date,Dátum ukončenia servisu nemôže byť pred dátumom začiatku 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ý dátum vydania,
Set Project and all Tasks to status {0}?,Nastaviť projekt a všetky úlohy do stavu {0}?,
Set Status,Nastaviť stav,
Set Tax Rule for shopping cart,Sada Daňové Pravidlo pre nákupného košíka,
Set as Closed,Nastaviť ako zatvorené,
Set as Completed,Nastaviť ako dokončené,
Set as Lost,Nastaviť ako Nezískané,
Set as Open,Nastaviť ako Otvorené,
Set default inventory account for perpetual inventory,Nastavte predvolený inventárny účet pre trvalý inventár,
Set this if the customer is a Public Administration company.,"Nastavte, ak je zákazníkom spoločnosť verejnej správy.",
Set {0} in asset category {1} or company {2},Nastavte {0} v kategórii majetku {1} alebo v spoločnosti {2},
"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Nastavenie udalostí do {0}, pretože zamestnanec pripojená k nižšie predajcom nemá ID užívateľa {1}",
Setting defaults,Nastavenie predvolených nastavení,
Setting up Email,Nastavenia pre e-mail,
Setting up Email Account,Nastavenie e-mailového konta,
Setting up Employees,Nastavenia pre modul Zamestnanci,
Setting up Taxes,Nastavenie Dane,
Setting up company,Založenie spoločnosti,
Settings,Nastavenia,
"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,Nastavenie titulnej stránky webu,
Settings for website product listing,Nastavenia pre zoznam produktov webových stránok,
Settled,usadil,
Setup Gateway accounts.,Nastavenia brány účty.,
Setup SMS gateway settings,Nastavenie SMS brány,
Setup cheque dimensions for printing,Skontrolujte nastavenie rozmery pre tlač,
Setup default values for POS Invoices,Nastavte predvolené hodnoty POS faktúr,
Setup mode of POS (Online / Offline),Nastavovací režim POS (Online / Offline),
Setup your Institute in ERPNext,Nastavte svoj inštitút v ERPNext,
Share Balance,Zostatok na účtoch,
Share Ledger,Zdieľať knihu,
Share Management,Správa podielov,
Share Transfer,Prenos podielu,
Share Type,Typ zdieľania,
Shareholder,akcionár,
Ship To State,Loď do štátu,
Shipments,zásielky,
Shipping Address,Dodacia adresa,
"Shipping Address does not have country, which is required for this Shipping Rule","Adresa pre odosielanie nemá krajinu, ktorá sa vyžaduje pre toto Pravidlo plavby",
Shipping rule only applicable for Buying,Pravidlo platia iba pre nákup,
Shipping rule only applicable for Selling,Pravidlo platia iba pre predaj,
Shopify Supplier,Nakupujte dodávateľa,
Shopping Cart,Nákupný košík,
Shopping Cart Settings,Nastavenie Nákupného košíka,
Short Name,Skrátené meno,
Shortage Qty,Nedostatek Množství,
Show Completed,Zobraziť dokončené,
Show Cumulative Amount,Zobraziť kumulatívnu čiastku,
Show Open,ukázať otvorené,
Show Opening Entries,Zobraziť úvodné záznamy,
Show Payment Details,Zobraziť podrobnosti platby,
Show Return Entries,Zobraziť položky návratu,
Show Variant Attributes,Zobraziť atribúty variantu,
Show Variants,Zobraziť varianty,
Show closed,Zobraziť uzatvorené,
Show exploded view,Zobraziť rozložený pohľad,
Show only POS,Zobraziť len POS,
Show unclosed fiscal year's P&L balances,Ukázať P &amp; L zostatky neuzavretý fiškálny rok je,
Show zero values,Ukázat nulové hodnoty,
Silt,kal,
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}","Preskočiť Ponechať alokáciu pre nasledujúcich zamestnancov, pretože záznamy proti alokácii už existujú proti nim. {0}",
Slideshow,Premietanie obrázkov na webstránke,
Slots for {0} are not added to the schedule,Sloty pre {0} nie sú pridané 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ôdne zložky nedosahujú hodnotu 100,
Sold,Predané,
Some emails are invalid,Niektoré e-maily sú neplatné,
Some information is missing,Niektoré informácie chýbajú,
Something went wrong!,Niečo sa pokazilo!,
"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit",
Source,Zdroj,
Source Name,Názov zdroja,
Source Warehouse,Zdroj Warehouse,
Source and Target Location cannot be same,Zdroj a cieľové umiestnenie nemôžu byť rovnaké,
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 cieľové sklad sa musí líšiť,
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,rozdeliť,
Split Batch,Split Batch,
Split Issue,Split Issue,
Sports,Sportovní,
Standard Buying,Štandardný nákup,
Standard Selling,Štandardný predaj,
Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.,
Start Date,Dátum začiatku,
Start Date of Agreement can't be greater than or equal to End Date.,Dátum začatia dohody nemôže byť väčší alebo rovný dátumu ukončenia.,
Start Year,Začiatočný rok,
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},Dátum začiatku by mal byť menší ako dátum ukončenia úlohy {0},
Start day is greater than end day in task '{0}',Začiatočný deň je väčší ako koniec dňa v úlohe &#39;{0}&#39;,
Start on,Začnite zapnuté,
State,stáť,
State/UT Tax,Štátna / UT daň,
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,Úprava skladových zásob,
Stock Analytics,Analýza zásob,
Stock Assets,Stock Aktiva,
Stock Available,Skladom k dispozícii,
Stock Balance,Stav zásob,
Stock Entries already created for Work Order ,Zápisy už boli vytvorené pre pracovnú objednávku,
Stock Entry,Pohyb zásob,
Stock Entry {0} created,Sklad Vstup {0} vytvoril,
Stock Entry {0} is not submitted,Sklad Entry {0} nie je predložená,
Stock Expenses,Náklady na skladovanie,
Stock In Hand,Skladom V Ruke,
Stock Items,Položky zásob,
Stock Ledger,Súpis zásob,
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,Úrovne zásob,
Stock Liabilities,Zásoby Pasíva,
Stock Qty,Množstvo zásob,
Stock Received But Not Billed,Prijaté na zásoby ale neúčtované,
Stock Reports,Reporty o zásobách,
Stock Summary,Sumár zásob,
Stock Transactions,Transackia na zásobách,
Stock UOM,Skladová MJ,
Stock Value,Hodnota na zásobách,
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 nie je možné aktualizovať proti dokladu o kúpe {0},
Stock cannot exist for Item {0} since has variants,"Zásoba nemôže byť na položke {0}, protože má varianty",
Stock transactions before {0} are frozen,Skladové transakcie pred {0} sú zmrazené,
Stop,Stop,
Stopped,Zastavené,
"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zastavenú pracovnú objednávku nemožno zrušiť, najskôr ju zrušte zrušením",
Stores,obchody,
Student,študent,
Student Activity,Aktivita študentov,
Student Address,Adresa študenta,
Student Admissions,študent Prijímacie,
Student Attendance,študent Účasť,
"Student Batches help you track attendance, assessments and fees for students","Študent Šarže pomôže sledovať dochádzku, hodnotenia a poplatky pre študentov",
Student Email Address,Študent E-mailová adresa,
Student Email ID,Študent ID e-mailu,
Student Group,študent Group,
Student Group Strength,Sila študentskej skupiny,
Student Group is already updated.,Skupina študentov je už aktualizovaná.,
Student Group: ,Skupina študentov:,
Student ID,Študentská karta,
Student ID: ,Študentská karta:,
Student LMS Activity,Aktivita študentského LMS,
Student Mobile No.,Študent Mobile No.,
Student Name,Meno študenta,
Student Name: ,Meno študenta:,
Student Report Card,Kartu pre študentov,
Student is already enrolled.,Študent je už zapísané.,
Student {0} - {1} appears Multiple times in row {2} & {3},Študent {0} - {1} objaví viackrát za sebou {2} {3},
Student {0} does not belong to group {1},Študent {0} nepatrí do skupiny {1},
Student {0} exist against student applicant {1},Existujú Študent {0} proti uchádzač študent {1},
"Students are at the heart of the system, add all your students","Študenti sú v centre systému, pridajte všetky svoje študentov",
Sub Assemblies,Podsestavy,
Sub Type,Sub typ,
Sub-contracting,subdodávky,
Subcontract,subdodávka,
Subject,Predmet,
Submit,Potvrdiť,
Submit this Work Order for further processing.,Odošlite túto objednávku na ďalšie spracovanie.,
Subscription,predplatné,
Subscription Management,Správa predplatného,
Subscriptions,odbery,
Subtotal,medzisúčet,
Successful,Úspešný,
Successfully Reconciled,Úspešne zinventarizované,
Successfully Set Supplier,Úspešne nastaviť dodávateľa,
Successfully created payment entries,Úspešne vytvorené položky platieb,
Successfully deleted all transactions related to this company!,Úspešne vypúšťa všetky transakcie súvisiace s týmto spoločnosti!,
Sum of Scores of Assessment Criteria needs to be {0}.,Súčet skóre hodnotiacich kritérií musí byť {0}.,
Sum of points for all goals should be 100. It is {0},Súčet bodov za všetkých cieľov by malo byť 100. Je {0},
Summary,zhrnutie,
Summary for this month and pending activities,Zhrnutie pre tento mesiac a prebiehajúcim činnostiam,
Summary for this week and pending activities,Zhrnutie pre tento týždeň a prebiehajúcim činnostiam,
Sunday,Nedeľa,
Suplier,Dodávateľ,
Supplier,dodávateľ,
Supplier Group,Skupina dodávateľov,
Supplier Group master.,Predajca skupiny dodávateľov.,
Supplier Id,Dodavatel Id,
Supplier Invoice Date cannot be greater than Posting Date,Dodávateľ Dátum faktúry nemôže byť väčšia ako Dátum zverejnenia,
Supplier Invoice No,Dodávateľská faktúra č,
Supplier Invoice No exists in Purchase Invoice {0},Dodávateľské faktúry No existuje vo faktúre {0},
Supplier Name,Názov dodávateľa,
Supplier Part No,Žiadny dodávateľ Part,
Supplier Quotation,Dodávateľská ponuka,
Supplier Scorecard,Hodnotiaca tabuľka dodávateľa,
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},Dodávateľ {0} nebol nájdený v {1},
Supplier(s),Dodávateľ (é),
Supplies made to UIN holders,Spotrebný materiál vyrobený pre držiteľov UIN,
Supplies made to Unregistered Persons,Dodávky dodávané neregistrovaným osobám,
Suppliies made to Composition Taxable Persons,Doplnky pre osoby podliehajúce dani zo zloženia,
Supply Type,Typ dodávky,
Support,podpora,
Support Analytics,Podpora Analytics,
Support Settings,nastavenie podporných,
Support Tickets,Podporné vstupenky,
Support queries from customers.,Podpora dotazy ze strany zákazníků.,
Susceptible,vnímavý,
Sync has been temporarily disabled because maximum retries have been exceeded,"Synchronizácia bola dočasne zakázaná, pretože boli prekročené maximálne počet opakovaní",
Syntax error in condition: {0},Chyba syntaxe v stave: {0},
Syntax error in formula or condition: {0},syntaktická chyba vo vzorci alebo stave: {0},
System Manager,Správca systému,
TDS Rate %,TDS%,
Tap items to add them here,Poklepte na položky a pridajte ich sem,
Target,Cíl,
Target ({}),Zacielenie ({}),
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}),Boli vytvorené úlohy na správu ochorenia {0} (na riadku {1}),
Tax,daň,
Tax Assets,Daňové aktíva,
Tax Category,Daňová kategória,
Tax Category for overriding tax rates.,Daňová kategória pre hlavné daňové sadzby.,
"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Daňová kategória bola zmenená na &quot;Celkom&quot;, pretože všetky položky sú položky, ktoré nie sú na sklade",
Tax ID,DIČ,
Tax Id: ,Id dane:,
Tax Rate,Sadzba dane,
Tax Rule Conflicts with {0},Daňové Pravidlo Konflikty s {0},
Tax Rule for transactions.,Daňové pravidlo pre transakcie.,
Tax Template is mandatory.,Daňová šablóna je povinné.,
Tax Withholding rates to be applied on transactions.,"Sadzby zrážky dane, ktoré sa majú uplatňovať na transakcie.",
Tax template for buying transactions.,Daňové šablona pro nákup transakcí.,
Tax template for item tax rates.,Šablóna dane pre sadzby dane z položiek.,
Tax template for selling transactions.,Daňové šablona na prodej transakce.,
Taxable Amount,Zdaniteľná čiastka,
Taxes,dane,
Technology,technológie,
Telecommunications,Telekomunikace,
Telephone Expenses,Telefonní Náklady,
Television,Televize,
Template Name,Názov šablóny,
Template of terms or contract.,Šablona podmínek nebo smlouvy.,
Templates of supplier scorecard criteria.,Šablóny kritérií kritérií pre dodávateľa.,
Templates of supplier scorecard variables.,Šablóny premenných ukazovateľa skóre dodávateľa.,
Templates of supplier standings.,Šablóny poradia dodávateľov.,
Temporarily on Hold,Dočasne pozastavené,
Temporary,dočasný,
Temporary Accounts,Dočasné účty,
Temporary Opening,Dočasné otvorenie,
Terms and Conditions,Podmínky,
Terms and Conditions Template,Podmínky Template,
Territory,Území,
Thank you for your business!,Ďakujeme vám za vašu firmu!,
The 'From Package No.' field must neither be empty nor it's value less than 1.,&quot;Z balíka č.&quot; pole nesmie byť prázdne ani jeho hodnota nižšia ako 1.,
The Brand,Značka,
The Item {0} cannot have Batch,Položka {0} nemôže mať dávku,
The Loyalty Program isn't valid for the selected company,Vernostný program nie je platný pre vybranú firmu,
The Payment Term at row {0} is possibly a duplicate.,Platobný termín na riadku {0} je pravdepodobne duplicitný.,
The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Termínovaný Dátum ukončenia nesmie byť starší ako Počiatočný dátum doby platnosti. Opravte dáta a skúste to znova.,
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ý Dátum ukončenia nemôže byť neskôr ako v roku Dátum ukončenia akademického roka, ku ktorému termín je spojená (akademický rok {}). Opravte dáta a skúste to znova.",
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ý Dátum začatia nemôže byť skôr ako v roku dátum začiatku akademického roka, ku ktorému termín je spojená (akademický rok {}). Opravte dáta a skúste to znova.",
The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Rok Dátum ukončenia nesmie byť starší ako dátum rok Štart. Opravte dáta a skúste to znova.,
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.,"Suma {0} nastavená v tejto žiadosti o platbu sa líši od vypočítanej sumy všetkých platobných plánov: {1}. Pred odoslaním dokumentu sa uistite, že je to správne.",
The field From Shareholder cannot be blank,Pole od akcionára nesmie byť prázdne,
The field To Shareholder cannot be blank,Pole Akcionár nesmie byť prázdne,
The fields From Shareholder and To Shareholder cannot be blank,Polia Od akcionára a akcionára nemôžu byť prázdne,
The folio numbers are not matching,Čísla fotiek sa nezhodujú,
The holiday on {0} is not between From Date and To Date,Dovolenka na {0} nie je medzi Dátum od a do dnešného dňa,
The name of the institute for which you are setting up this system.,Názov inštitútu pre ktorý nastavujete tento systém.,
The name of your company for which you are setting up this system.,"Názov spoločnosti, pre ktorú nastavujete tento systém",
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 platobnej brány v pláne {0} sa líši od účtu platobnej brány v tejto žiadosti o platbu,
The selected BOMs are not for the same item,Vybrané kusovníky nie sú rovnaké položky,
The selected item cannot have Batch,Vybraná položka nemôže mať dávku,
The seller and the buyer cannot be the same,Predávajúci a kupujúci nemôžu byť rovnakí,
The shareholder does not belong to this company,Akcionár nepatrí k tejto spoločnosti,
The shares already exist,Akcie už existujú,
The shares don't exist with the {0},Akcie neexistujú pri {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",Úloha bola zadaná ako práca na pozadí. V prípade akýchkoľvek problémov so spracovaním na pozadí systém pridá komentár k chybe pri tomto zúčtovaní zásob a vráti sa do fázy Koncept.,
"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ú nezrovnalosti medzi sadzbou, počtom akcií a vypočítanou sumou",
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.,Na základe celkovej výdavky môže byť viacnásobný zberný faktor. Ale konverzný faktor pre spätné odkúpenie bude vždy rovnaký pre všetky úrovne.,
There can only be 1 Account per Company in {0} {1},Tam môže byť len 1 účet na spoloč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 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,Pre vybranú položku nie je žiadna iná položka,
"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á sa, že je problém s konfiguráciou servera GoCardless. Nebojte sa, v prípade zlyhania bude suma vrátená do vášho účtu.",
There were errors creating Course Schedule,Pri vytváraní kurzov sa vyskytli chyby,
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).,Táto položka je variantom {0} (šablóna).,
This Month's Summary,Tento mesiac je zhrnutie,
This Week's Summary,Tento týždeň Zhrnutie,
This action will stop future billing. Are you sure you want to cancel this subscription?,Táto akcia zastaví budúcu fakturáciu. Naozaj chcete zrušiť tento odber?,
This covers all scorecards tied to this Setup,Toto pokrýva všetky výsledkové karty viazané na toto nastavenie,
This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Tento dokument je nad hranicou {0} {1} pre položku {4}. Robíte si iný {3} proti rovnakej {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 koreňové oddelenie a nemôže byť upravené.,
This is a root healthcare service unit and cannot be edited.,Jedná sa o koreňovú službu zdravotnej starostlivosti a nemožno ju upraviť.,
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 koreňová skupina dodávateľov a nie je možné ju upravovať.,
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,Toto je príklad webovej stránky automaticky generovanej z ERPNext,
This is based on logs against this Vehicle. See timeline below for details,To je založené na protokoloch proti tomuto vozidlu. Pozri časovú os nižšie podrobnosti,
This is based on stock movement. See {0} for details,To je založené na akciovom pohybu. Pozri {0} Podrobnosti,
This is based on the Time Sheets created against this project,To je založené na časových výkazov vytvorených proti tomuto projektu,
This is based on the attendance of this Student,To je založené na účasti tohto študenta,
This is based on transactions against this Customer. See timeline below for details,To je založené na transakciách proti tomuto zákazníkovi. Pozri časovú os nižšie podrobnosti,
This is based on transactions against this Healthcare Practitioner.,Toto je založené na transakciách s týmto zdravotníckym lekárom.,
This is based on transactions against this Patient. See timeline below for details,Toto je založené na transakciách proti tomuto pacientovi. Viac informácií nájdete v nasledujúcej časovej osi,
This is based on transactions against this Sales Person. See timeline below for details,Vychádza z transakcií s touto predajnou osobou. Viac informácií nájdete v nasledujúcej časovej osi,
This is based on transactions against this Supplier. See timeline below for details,To je založené na transakciách proti tomuto dodávateľovi. Pozri časovú os nižšie podrobnosti,
This {0} conflicts with {1} for {2} {3},Táto {0} je v rozpore s {1} o {2} {3},
Time Sheet for manufacturing.,Čas list pre výrobu.,
Time Tracking,Time Tracking,
"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Časový interval preskočil, slot {0} až {1} presahuje existujúci slot {2} na {3}",
Time slots added,Pridané časové úseky,
Time(in mins),Čas (v min),
Timer,časomerač,
Timer exceeded the given hours.,Časovač prekročil daný čas.,
Timesheet,pracovný výkaz,
Timesheet for tasks.,Časového rozvrhu pre úlohy.,
Timesheet {0} is already completed or cancelled,Harmonogramu {0} je už dokončená alebo zrušená,
Timesheets,Pracovné výkazy,
"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomôže udržať prehľad o času, nákladov a účtovania pre aktivít hotový svojho tímu",
Titles for print templates e.g. Proforma Invoice.,"Tituly na tiskových šablon, např zálohové faktury.",
To,na,
To Address 1,Na adresu 1,
To Address 2,Na adresu 2,
To Bill,K fakturácii,
To Date,To Date,
To Date cannot be before From Date,Dátum DO nemôže byť skôr ako dátum OD,
To Date cannot be less than From Date,Dátumu nemôže byť menšia ako od dátumu,
To Date must be greater than From Date,Dátum musí byť väčší ako od dátumu,
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,Dodať,
To Deliver and Bill,Dodať a Bill,
To Fiscal Year,Do fiškálneho roka,
To GSTIN,Na GSTIN,
To Party Name,Do názvu strany,
To Pin Code,Kódovanie kódu,
To Place,Na miesto,
To Receive,Obdržať,
To Receive and Bill,Prijímať a Bill,
To State,Do stavu,
To Warehouse,Do skladu,
To create a Payment Request reference document is required,Vyžaduje sa vytvorenie referenčného dokumentu žiadosti o platbu,
"To filter based on Party, select Party Type first","Ak chcete filtrovať na základe Party, vyberte typ Party prvý",
"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Ak chcete získať to najlepšie z ERPNext, odporúčame vám nejaký čas venovať týmto videám.",
"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.,Vytváranie motivačných schém založených na zákazníkoch.,
"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.,Zobrazenie denníkov vernostných bodov priradených zákazníkovi.,
To {0},Chcete-li {0},
To {0} | {1} {2},Chcete-li {0} | {1} {2},
Toggle Filters,Prepnúť filtre,
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),Spolu (bez dane),
Total Achieved,Celkem Dosažená,
Total Actual,Celkem Aktuální,
Total Amount,Celková částka,
Total Amount Credited,Celková čiastka bola pripísaná,
Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,"Celkom Použiteľné Poplatky v doklade o kúpe tovaru, ktorý tabuľky musí byť rovnaká ako celkom daní a poplatkov",
Total Budget,Celkový rozpočet,
Total Collected: {0},Celkom zhromaždené: {0},
Total Commission,Celkem Komise,
Total Contribution Amount: {0},Celková suma príspevku: {0},
Total Credit/ Debit Amount should be same as linked Journal Entry,Celková suma kreditnej / debetnej platby by mala byť rovnaká ako prepojená položka denníka,
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 Invoiced Amount,Celková fakturovaná čiastka,
Total Order Considered,Celková objednávka Zvážil,
Total Order Value,Celková hodnota objednávky,
Total Outgoing,Celkem Odchozí,
Total Outstanding,Celkom nevybavené,
Total Outstanding Amount,Celková dlužná částka,
Total Outstanding: {0},Celkom nevybavené: {0},
Total Paid Amount,Celkem uhrazené částky,
Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Celková čiastka platby v pláne platieb sa musí rovnať veľkému / zaokrúhlenému súčtu,
Total Payments,Celkové platby,
Total Qty,Celkem Množství,
Total Quantity,Celkové množstvo,
Total Revenue,Celkový příjem,
Total Student,Celkový počet študentov,
Total Target,Celkem Target,
Total Tax,Total Tax,
Total Taxable Amount,Celková zdaniteľná suma,
Total Taxable Value,Celková zdaniteľná hodnota,
Total Unpaid: {0},Celkové nezaplatené: {0},
Total Variance,Celkový rozptyl,
Total Weightage of all Assessment Criteria must be 100%,Celkový weightage všetkých hodnotiacich kritérií musí byť 100%,
Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celkové zálohy ({0}) na objednávku {1} nemôže byť väčšia ako Celkom ({2}),
Total advance amount cannot be greater than total claimed amount,Celková čiastka zálohy nemôže byť vyššia ako celková nárokovaná čiastka,
Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Celkový počet priradených listov je viac dní ako maximálna alokácia {0} typu dovolenky pre zamestnanca {1} v danom období,
Total allocated leaves are more than days in the period,Celkové pridelené listy sú viac ako dni 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,Suma nemôže byť nulová,
Total contribution percentage should be equal to 100,Celkové percento príspevku by sa malo rovnať 100,
Total hours: {0},Celkom hodín: {0},
Total {0} ({1}),Celkom {0} ({1}),
"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Total {0} u všetkých položiek je nulová, môže byť by ste mali zmeniť, Distribuovať poplatkov na základe &#39;",
Total(Amt),Total (Amt),
Total(Qty),Total (ks),
Traceability,sledovateľnosť,
Track Leads by Lead Source.,Track Leads by Lead Zdroj.,
Transaction,Transakce,
Transaction Date,Transakce Datum,
Transaction Type,Typ transakcie,
Transaction currency must be same as Payment Gateway currency,Mena transakcie musí byť rovnaká ako platobná brána menu,
Transaction not allowed against stopped Work Order {0},Transakcia nie je povolená proti zastavenej pracovnej zákazke {0},
Transaction reference no {0} dated {1},Referenčné transakcie no {0} z {1},
Transactions,transakcie,
Transactions can only be deleted by the creator of the Company,Transakcie môžu byť vymazané len tvorca Spoločnosti,
Transfer,prevod,
Transfer Material,Přenos materiálu,
Transfer Type,Typ prenosu,
Transfer an asset from one warehouse to another,Previesť aktíva z jedného skladu do druhého,
Transfered,prevedené,
Transferred Quantity,Prevedené množstvo,
Transport Receipt Date,Dátum príjmu dopravy,
Transport Receipt No,Doklad o preprave č,
Transportation,Doprava,
Transporter ID,ID prepravcu,
Transporter Name,Názov prepravcu,
Travel Expenses,Cestovní výdaje,
Tree Type,Tree Type,
Tree of Bill of Materials,Strom Bill materiálov,
Tree of Item Groups.,Strom skupiny položek.,
Tree of Procedures,Strom postupov,
Tree of Quality Procedures.,Postupy pri strome stromu.,
Tree of financial Cost Centers.,Strom Nákl.stredisko finančných.,
Tree of financial accounts.,Strom finančných účtov.,
Treshold {0}% appears more than once,Prah {0}% sa objaví viac ako raz,
Trial Period End Date Cannot be before Trial Period Start Date,Dátum ukončenia skúšobného obdobia nemôže byť pred začiatkom skúšobného obdobia,
Trialling,skúšanie,
Type of Business,Typ podnikania,
Types of activities for Time Logs,Typy činností pre 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},Koeficient prepočtu MJ je potrebný k MJ: {0} v bode: {1},
URL,URL,
Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nepodarilo sa nájsť kurz {0} až {1} pre kľúčový dátum {2}. Ručne vytvorte záznam o menovej karte,
Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nepodarilo sa nájsť skóre od {0}. Musíte mať stály počet bodov od 0 do 100,
Unable to find variable: ,Nepodarilo sa nájsť premennú:,
Unblock Invoice,Odblokovať faktúru,
Uncheck all,Zrušte zaškrtnutie políčka všetko,
Unclosed Fiscal Years Profit / Loss (Credit),Neuzavretý fiškálnych rokov Zisk / strata (Credit),
Unit,jednotka,
Unit of Measure,Merná 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,nevedno,
Unpaid,Nezaplacený,
Unsecured Loans,Nezajištěných úvěrů,
Unsubscribe from this Email Digest,Odhlásiť sa z tohto Email Digest,
Unsubscribed,Odhlášen z odběru,
Until,Dokud,
Unverified Webhook Data,Neoverené údaje Webhook,
Update Account Name / Number,Aktualizovať názov / číslo účtu,
Update Account Number / Name,Aktualizovať číslo účtu / meno,
Update Cost,Aktualizace Cost,
Update Items,Aktualizovať položky,
Update Print Format,Aktualizácia Print Format,
Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů.",
Update in progress. It might take a while.,Prebieha aktualizácia. Môže to chvíľu trvať.,
Update rate as per last purchase,Miera aktualizácie podľa posledného nákupu,
Update stock must be enable for the purchase invoice {0},Ak chcete aktualizovať nákupnú faktúru {0},
Updating Variants...,Aktualizácia variantov ...,
Upload your letter head and logo. (you can edit them later).,Nahrajte svoju hlavičku a logo pre dokumenty. (Môžete ich upravovať neskôr.),
Upper Income,Horní příjmů,
Use Sandbox,použitie Sandbox,
User,užívateľ,
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},Používateľ na faktúru neuplatnil pravidlo {0},
User {0} already exists,Používateľ {0} už existuje,
User {0} created,Používateľ {0} bol vytvorený,
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.,Používateľ {0} nemá predvolený profil POS. Začiarknite predvolené nastavenie v riadku {1} pre tohto používateľa.,
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},Používateľ {0} je už pridelený zdravotnému lekárovi {1},
Users,Uživatelé,
Utility Expenses,Utility Náklady,
Valid From Date must be lesser than Valid Upto Date.,Platná od dátumu musí byť menšia ako platná do dátumu.,
Valid Till,Platný do,
Valid from and valid upto fields are mandatory for the cumulative,Pre kumulatívne sú povinné a platné až polia,
Valid from date must be less than valid upto date,Platné od dátumu musí byť kratšie ako platné do dátumu,
Valid till date cannot be before transaction date,Platné do dátumu nemôže byť pred dátumom transakcie,
Validity,Platnosť,
Validity period of this quotation has ended.,Platnosť tejto ponuky sa skončila.,
Valuation Rate,Ocenění Rate,
Valuation Rate is mandatory if Opening Stock entered,"Ocenenie Rate je povinné, ak zadaná počiatočným stavom zásob",
Valuation type charges can not marked as Inclusive,Poplatky typu ocenenie môže nie je označený ako 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 atribútu {0} musí byť v rozmedzí od {1} až {2} v krokoch po {3} pre item {4},
Value must be between {0} and {1},Hodnota musí byť medzi {0} a {1},
"Values of exempt, nil rated and non-GST inward supplies","Hodnoty vyňatých, nulových a nemateriálnych vnútorných dodávok",
Variance,odchýlka,
Variance ({}),Variácia ({}),
Variant,Varianta,
Variant Attributes,Variantov atribúty,
Variant Based On cannot be changed,Variant Based On sa nedá zmeniť,
Variant Details Report,Variant Details Report,
Variant creation has been queued.,Tvorba variantu bola zaradená do frontu.,
Vehicle Expenses,Náklady pre autá,
Vehicle No,Vozidle,
Vehicle Type,Typ vozidla,
Vehicle/Bus Number,Číslo vozidla / autobusu,
Venture Capital,Venture Capital,
View Chart of Accounts,Zobraziť účtovnú schému,
View Fees Records,Zobrazenie záznamov poplatkov,
View Form,Zobraziť formulár,
View Lab Tests,Zobraziť laboratórne testy,
View Leads,Zobraziť Obchodné iniciatívy,
View Ledger,View Ledger,
View Now,Zobrazit nyní,
View a list of all the help videos,Zobraziť zoznam všetkých videí nápovedy,
View in Cart,Zobraziť Košík,
Visit report for maintenance call.,Navštivte zprávu pro volání údržby.,
Visit the forums,Navštívte fóra,
Vital Signs,Živé znamenia,
Volunteer,dobrovoľník,
Volunteer Type information.,Informácie o type dobrovoľníka.,
Volunteer information.,Informácie o dobrovoľníkoch.,
Voucher #,Voucher #,
Voucher No,Voucher No,
Voucher Type,Voucher Type,
WIP Warehouse,WIP Warehouse,
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}","Požadovaný sklad v riadku Nie {0}, nastavte prosím predvolený sklad pre položku {1} pre spoločnosť {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} nie je prepojený s žiadnym účtom, uveďte účet v zozname skladov alebo nastavte predvolený inventárny účet v spoločnosti {1}.",
Warehouses with child nodes cannot be converted to ledger,Sklady s podriadené uzlami nemožno previesť do hlavnej účtovnej knihy,
Warehouses with existing transaction can not be converted to group.,Sklady s existujúcimi transakcie nemožno previesť na skupinu.,
Warehouses with existing transaction can not be converted to ledger.,Sklady s existujúcimi transakcie nemožno previesť na knihy.,
Warning,Upozornění,
Warning: Another {0} # {1} exists against stock entry {2},Upozornenie: Ďalším {0} # {1} existuje proti akciovej vstupu {2},
Warning: Invalid SSL certificate on attachment {0},Varovanie: Neplatný certifikát SSL na prílohu {0},
Warning: Invalid attachment {0},Varovanie: Neplatná Príloha {0},
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},Upozornenie: predajné objednávky {0} už existuje proti Zákazníka objednanie {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 mala byť verejná súboru alebo webovej stránky URL,
Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} pripája k bodu {1} nemožno nájsť,
Website Manager,Správce webu,
Website Settings,Nastavení www stránky,
Wednesday,Středa,
Week,týždeň,
Weekly,Týdenní,
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnosť je uvedená, \n uveďte prosím aj ""váhu MJ""",
Welcome email sent,Uvítací email odeslán,
Welcome to ERPNext,Vitajte v ERPNext,
What do you need help with?,S čím potrebujete pomôcť?,
What does it do?,Čím sa zaoberá?,
Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny.",
White,Biela,
Wire Transfer,Bankovní převod,
WooCommerce Products,Produkty spoločnosti WooCommerce,
Work In Progress,Work in Progress,
Work Order,Zákazka,
Work Order already created for all items with BOM,Pracovná objednávka už vytvorená pre všetky položky s kusovníkom,
Work Order cannot be raised against a Item Template,Pracovnú objednávku nemožno vzniesť voči šablóne položky,
Work Order has been {0},Pracovná objednávka bola {0},
Work Order not created,Pracovná objednávka nebola vytvorená,
Work Order {0} must be cancelled before cancelling this Sales Order,Pred zrušením tejto objednávky musí byť pracovná objednávka {0} zrušená,
Work Order {0} must be submitted,Musí sa odoslať pracovná objednávka {0},
Work Orders Created: {0},Vytvorené pracovné príkazy: {0},
Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat,
Working,Pracovní,
Working Hours,Pracovní doba,
Workstation,pracovna stanica,
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,Zahaliť,
Wrong Password,Zlé heslo,
Year start date or end date is overlapping with {0}. To avoid please set company,Rok dátum začatia alebo ukončenia sa prekrýva s {0}. Aby sa 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 set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení,
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 predplatnom môžete mať len Plány s rovnakým účtovacím cyklom,
You can only redeem max {0} points in this order.,V tomto poradí môžete uplatniť maximálne {0} body.,
You can only renew if your membership expires within 30 days,"Môžete obnoviť iba vtedy, ak vaše členstvo uplynie do 30 dní",
You can only select a maximum of one option from the list of check boxes.,V zozname začiarkavacích políčok môžete vybrať maximálne jednu možnosť.,
You can't redeem Loyalty Points having more value than the Grand Total.,"Nemôžete uplatniť vernostné body, ktoré majú väčšiu hodnotu ako celkové množstvo.",
You cannot credit and debit same account at the same time,Nemôžete robiť kreditný a debetný záznam na rovnaký účet naraz,
You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Nemožno odstrániť fiškálny rok {0}. Fiškálny rok {0} je nastavený ako predvolený v globálnom nastavení,
You cannot delete Project Type 'External',Nemôžete odstrániť typ projektu &quot;Externé&quot;,
You cannot edit root node.,Nemôžete upraviť koreňový uzol.,
You cannot restart a Subscription that is not cancelled.,"Predplatné, ktoré nie je zrušené, nemôžete reštartovať.",
You don't have enough Loyalty Points to redeem,Nemáte dostatok vernostných bodov na vykúpenie,
You have already assessed for the assessment criteria {}.,Vyhodnotili ste kritériá hodnotenia {}.,
You have already selected items from {0} {1},Už ste vybrané položky z {0} {1},
You have been invited to collaborate on the project: {0},Boli ste pozvaní k spolupráci na projekte: {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.,"Aby ste sa mohli zaregistrovať na trhu, musíte byť iným používateľom než správcom s roly Správcu systémov a Správca položiek.",
You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,"Musíte byť používateľom s funkciami Správca systémov a Správca položiek, pomocou ktorých môžete používateľov pridávať do služby Marketplace.",
You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Musíte byť používateľom s funkciami Správca systému a Správca položiek na registráciu na trhu.,
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 predtým vygenerovaných faktúrach. Naozaj chcete tento odber reštartovať?,
Your Organization,Vaša organizácia,
Your cart is Empty,Vaša karta je prázdna,
Your email address...,Vaša emailová adresa...,
Your order is out for delivery!,Vaša objednávka je k dispozícii!,
Your tickets,Vaše lístky,
ZIP Code,PSČ,
[Error],[Chyba],
[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Položka / {0}) nie je na sklade,
`Freeze Stocks Older Than` should be smaller than %d days.,`Zmraziť zásoby staršie ako` malo by byť menšie než %d dní.,
based_on,založené na,
cannot be greater than 100,nemôže byť väčšie ako 100,
disabled user,zakázané uživatelské,
"e.g. ""Build tools for builders""","napríklad ""Nástroje pre stavbárov """,
"e.g. ""Primary School"" or ""University""",napríklad &quot;Základná škola&quot; alebo &quot;univerzita&quot;,
"e.g. Bank, Cash, Credit Card","napríkklad banka, hotovosť, kreditné karty",
hidden,skrytý,
modified,modifikovaný,
old_parent,old_parent,
on,Kdy,
{0} '{1}' is disabled,{0} '{1}' je vypnuté,
{0} '{1}' not in Fiscal Year {2},{0} '{1}' nie je vo fiškálnom roku {2},
{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nemôže byť väčšia ako plánované množstvo ({2}) v pracovnom poradí {3},
{0} - {1} is inactive student,{0} - {1} je neaktívnym študentom,
{0} - {1} is not enrolled in the Batch {2},{0} - {1} nie je zapísaná v dávke {2},
{0} - {1} is not enrolled in the Course {2},{0} - {1} nie je zapísaný 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 presahovať o {5},
{0} Digest,{0} Digest,
{0} Request for {1},{0} Žiadosť o {1},
{0} Result submittted,{0} Výsledok bol odoslaný,
{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Sériové čísla požadované pre položku {1}. Poskytli ste {2}.,
{0} Student Groups created.,{0} Vytvorené študentské skupiny.,
{0} Students have been enrolled,{0} Študenti boli zapísaní,
{0} against Bill {1} dated {2},{0} proti účtu {1} z dňa {2},
{0} against Purchase Order {1},{0} proti objednávke {1},
{0} against Sales Invoice {1},{0} proti predajnej faktúre {1},
{0} against Sales Order {1},{0} proti Predajnej Objednávke {1},
{0} asset cannot be transferred,{0} pohľadávku nemôže byť prevedená,
{0} can not be negative,{0} nemôže byť záporné,
{0} created,{0} vytvoril,
"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} v súčasnosti má postavenie {1} Scorecardu pre dodávateľov a nákupné objednávky tomuto dodávateľovi by mali byť vydané opatrne.,
"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} v súčasnosti má {1} hodnotiacu kartu pre dodávateľa, a RFQ pre tohto dodávateľa by mali byť vydané opatrne.",
{0} does not belong to Company {1},{0} nepatrí do Spoločnosti {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nemá Plán zdravotníckych pracovníkov. Pridajte ho do programu Master of Health Practitioner,
{0} entered twice in Item Tax,{0} vložené dvakrát v Daňovej Položke,
{0} for {1},{0} pre {1},
{0} has been submitted successfully,{0} bola úspešne odoslaná,
{0} has fee validity till {1},{0} má platnosť do {1},
{0} hours,{0} hodín,
{0} in row {1},{0} v riadku {1},
{0} is blocked so this transaction cannot proceed,"{0} je zablokovaná, aby táto transakcia nemohla pokračovať",
{0} is mandatory,{0} je povinné,
{0} is mandatory for Item {1},{0} je povinná k položke {1},
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možno nie je vytvorený záznam Zmeny meny pre {1} až {2}.,
{0} is not a stock Item,{0} nie je skladová položka,
{0} is not a valid Batch Number for Item {1},{0} nie je platné číslo šarže pre položku {1},
{0} is not added in the table,{0} sa do tabuľky nepridáva,
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,"{0} je teraz predvolený Fiškálny rok. Prosím aktualizujte svoj prehliadač, aby sa prejavili zmeny.",
{0} is on hold till {1},{0} je pozastavená do {1},
{0} item found.,{0} nájdená položka.,
{0} items found.,Nájdených {0} položiek.,
{0} items in progress,{0} položky v prebiehajúcej,
{0} items produced,{0} predmety vyrobené,
{0} must appear only once,{0} môže byť uvedené iba raz,
{0} must be negative in return document,{0} musí byť negatívny vo vratnom dokumente,
{0} not allowed to transact with {1}. Please change the Company.,{0} nesmie transakcie s {1}. Zmeňte spoločnosť.,
{0} not found for item {1},{0} sa nenašiel pre položku {1},
{0} parameter is invalid,Parameter {0} je neplatný,
{0} payment entries can not be filtered by {1},{0} platobné položky nemôžu byť filtrované podľa {1},
{0} should be a value between 0 and 100,{0} by mala byť hodnota medzi 0 a 100,
{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednotiek [{1}] (# Form / bodu / {1}) bola nájdená v [{2}] (# Form / sklad / {2}),
{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jednotiek {1} potrebná {2} o {3} {4} na {5} pre dokončenie tejto transakcie.,
{0} units of {1} needed in {2} to complete this transaction.,{0} jednotiek {1} potrebná {2} pre dokončenie tejto transakcie.,
{0} valid serial nos for Item {1},{0} platné sériové čísla pre položky {1},
{0} variants created.,{0} vytvorené varianty.,
{0} {1} created,{0} {1} vytvoril,
{0} {1} does not exist,{0} {1} neexistuje,
{0} {1} has been modified. Please refresh.,{0} {1} bol zmenený. Prosím aktualizujte.,
{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nebola odoslaná, takže akciu nemožno dokončiť",
"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je priradená ku {2}, ale účet Party je {3}",
{0} {1} is cancelled or closed,{0} {1} je zrušený alebo zatvorené,
{0} {1} is cancelled or stopped,{0} {1} je zrušená alebo zastavená,
{0} {1} is cancelled so the action cannot be completed,"{0} {1} je zrušená, takže akciu nemožno dokončiť",
{0} {1} is closed,{0} {1} je uzavretý,
{0} {1} is disabled,{0} {1} je zakázaný,
{0} {1} is frozen,{0} {1} je zmrazený,
{0} {1} is fully billed,{0} {1} je úplne fakturované,
{0} {1} is not active,{0} {1} nie je aktívny,
{0} {1} is not associated with {2} {3},{0} {1} nie je priradená k {2} {3},
{0} {1} is not present in the parent company,{0} {1} nie je v materskej spoločnosti,
{0} {1} is not submitted,{0} {1} nie je odoslané,
{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} žiadnym aktívnym fiškálny rok.,
{0} {1} status is {2},{0} {1} stav je {2},
{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &quot;výkaz ziskov a strát&quot; typ účtu {2} nie je povolený vstup do Otváracia Entry,
{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Účet {2} nepatrí do spoločnosti {3},
{0} {1}: Account {2} is inactive,{0} {1}: Účet {2} je neaktívny,
{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Účtovné Vstup pre {2} môžu vykonávať len v mene: {3},
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové stredisko je povinné pre 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 potrebné nákladového strediska pre &#39;zisku a straty &quot;účtu {2}. Prosím nastaviť predvolené nákladového strediska pre spoločnosť.,
{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: náklady Center {2} nepatrí do spoločnosti {3},
{0} {1}: Customer is required against Receivable account {2},{0} {1}: Zákazník je potrebná proti pohľadávok účtu {2},
{0} {1}: Either debit or credit amount is required for {2},{0} {1}: buď debetnou alebo kreditnou čiastku je nutné pre {2},
{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dodávateľ je potrebná proti zaplatení účtu {2},
{0}% Billed,{0}% Fakturované,
{0}% Delivered,{0}% Dodané,
{0}: From {1},{0}: Z {1},
{0}: {1} does not exists,{0}: {1} neexistuje,
{0}: {1} not found in Invoice Details table,{0}: {1} nenájdené v tabuľke Podrobnosti Faktúry,
{} of {},{} z {},
Assigned To,Priradené (komu),
Chat,Čet,
Completed By,Dokončené kým,
Day of Week,Deň v týždni,
"Dear System Manager,","Vážený System Manager,",
Default Value,Výchozí hodnota,
Email Group,email Group,
Email Settings,Nastavenia emailu,
Email not sent to {0} (unsubscribed / disabled),Email nie je poslaný do {0} (odhlásili / vypnuté),
Error Message,Chybná správa,
Fieldtype,Typ pole,
Help Articles,články pomocníka,
ID,ID,
Import,Importovat,
Language,Jazyk,
Likes,Záľuby,
Merge with existing,Zlúčiť s existujúcim,
Orientation,orientácia,
Parent,Rodič,
Payment Failed,platba zlyhala,
Personal,Osobné,
Post,Príspevok,
Postal Code,poštové smerovacie číslo,
Provider,poskytovateľ,
Read Only,Len na čítanie,
Recipient,Príjemca,
Reviews,recenzia,
Sender,Odosielateľ,
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 Zmenil,
or,alebo,
Ageing Range 4,Rozsah starnutia 4,
Allocated amount cannot be greater than unadjusted amount,Pridelená suma nemôže byť vyššia ako neupravená suma,
Allocated amount cannot be negative,Pridelená suma nemôže byť záporná,
"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Účet rozdielov musí byť účtom typu aktív / pasív, pretože tento záznam na sklade je otváracím záznamom",
Import Successful,Import bol úspešný,
Please save first,Uložte najskôr,
Price not found for item {0} in price list {1},Cena nebola nájdená pre položku {0} v cenníku {1},
Warehouse Type,Typ skladu,
'Date' is required,Vyžaduje sa „Dátum“,
Budgets,rozpočty,
Bundle Qty,Balík Množ,
Company GSTIN,IČDPH firmy,
Company field is required,Pole spoločnosti je povinné,
Creating Dimensions...,Vytvára sa dimenzia ...,
Duplicate entry against the item code {0} and manufacturer {1},Duplikát oproti kódu položky {0} a výrobcovi {1},
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 sa nezhoduje s formátom GSTIN pre držiteľov UIN alebo nerezidentných poskytovateľov služieb OIDAR,
Invoice Grand Total,Celková faktúra,
Last carbon check date cannot be a future date,Posledný dátum kontroly uhlíkom nemôže byť budúcim dátumom,
Make Stock Entry,Vykonajte zadanie zásob,
Quality Feedback,Spätná väzba kvality,
Quality Feedback Template,Šablóna spätnej väzby kvality,
Rules for applying different promotional schemes.,Pravidlá uplatňovania rôznych propagačných programov.,
Show {0},Zobraziť {0},
Target Details,Podrobnosti o cieli,
{0} already has a Parent Procedure {1}.,{0} už má rodičovský postup {1}.,
API,API,
Annual,Roční,
Change,Zmena,
Contact Email,Kontaktný e-mail,
From Date,Od data,
Group By,Zoskupiť podľa,
Invalid URL,neplatná URL adresa,
Landscape,krajina,
Naming Series,Číselné rady,
No data to export,Žiadne údaje na export,
Portrait,portrét,
Print Heading,Hlavička tlače,
Scheduler Inactive,Plánovač neaktívny,
Scheduler is inactive. Cannot import data.,Plánovač je neaktívny. Nie je možné importovať údaje.,
Show Document,Zobraziť dokument,
Show Traceback,Zobraziť Traceback,
Video,video,
% Of Grand Total,% Z celkového súčtu,
<b>Company</b> is a mandatory filter.,<b>Spoločnosť</b> je povinný filter.,
<b>From Date</b> is a mandatory filter.,<b>Od dátumu</b> je povinný filter.,
<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>Čas od času</b> nemôže byť neskôr ako <b>Čas od času</b> {0},
<b>To Date</b> is a mandatory filter.,<b>Do dnešného dňa</b> je povinný filter.,
A new appointment has been created for you with {0},Bola pre vás vytvorená nová schôdzka s {0},
Account Value,Hodnota účtu,
Account is mandatory to get payment entries,Účet je povinný na získanie platobných záznamov,
Account is not set for the dashboard chart {0},Účet nie je nastavený pre tabuľku dashboardov {0},
Account {0} does not exists in the dashboard chart {1},Účet {0} v grafe dashboardu neexistuje {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 Prebieha spracovanie a nedá sa aktualizovať zápisom do denníka,
Account: {0} is not permitted under Payment Entry,Účet: {0} nie je povolený v rámci zadania platby,
Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Účtovná dimenzia <b>{0}</b> sa vyžaduje pre účet „Súvaha“ {1}.,
Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Účtovná dimenzia <b>{0}</b> sa vyžaduje pre účet „Zisk a strata“ {1}.,
Accounting Masters,Masters účtovníctva,
Accounting Period overlaps with {0},Účtovné obdobie sa prekrýva s {0},
Activity,Aktivita,
Add / Manage Email Accounts.,Pridanie / Správa e-mailových účtov.,
Add Child,Pridať potomka,
Add Multiple,Pridať viacero,
Add Participants,Pridať účastníkov,
Add to Featured Item,Pridať k odporúčanej položke,
Add your review,Pridajte svoju recenziu,
Add/Edit Coupon Conditions,Pridať / upraviť podmienky kupónu,
Added to Featured Items,Pridané do odporúčaných položiek,
Added {0} ({1}),Pridané: {0} ({1}),
Address Line 1,Riadok adresy 1,
Addresses,Adresy,
Admission End Date should be greater than Admission Start Date.,Dátum ukončenia prijímania by mal byť vyšší ako dátum začatia prijímania.,
All,ALL,
All bank transactions have been created,Všetky bankové transakcie boli vytvorené,
All the depreciations has been booked,Všetky odpisy boli zaúčtované,
Allow Resetting Service Level Agreement from Support Settings.,Povoľte obnovenie dohody o úrovni služieb z nastavení podpory.,
Amount of {0} is required for Loan closure,Na uzatvorenie úveru je potrebná suma {0},
Applied Coupon Code,Kód použitého kupónu,
Apply Coupon Code,Použite kód kupónu,
Appointment Booking,Rezervácia schôdzky,
"As there are existing transactions against item {0}, you can not change the value of {1}",Pretože existujú nejaké transakcie voči položke {0} nemožno zmeniť hodnotu {1},
Asset Id,ID majetku,
Asset Value,Hodnota aktív,
Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Úprava hodnoty aktív nemôže byť zaúčtovaná pred dátumom nákupu aktíva <b>{0}</b> .,
Asset {0} does not belongs to the custodian {1},Majetok {0} nepatrí do úschovy {1},
Asset {0} does not belongs to the location {1},Diela {0} nepatria do umiestnenia {1},
At least one of the Applicable Modules should be selected,Mal by sa vybrať aspoň jeden z použiteľných modulov,
Atleast one asset has to be selected.,Musí byť vybrané aspoň jedno aktívum.,
Authentication Failed,Overenie zlyhalo,
Automatic Reconciliation,Automatické vyrovnanie,
Available For Use Date,Dostupné na použitie,
Available Stock,K dispozícii na sklade,
"Available quantity is {0}, you need {1}","Dostupné množstvo je {0}, potrebujete {1}",
BOM 1,Kus 1,
BOM 2,Kusovník 2,
BOM Comparison Tool,Nástroj na porovnávanie kusovníkov,
BOM recursion: {0} cannot be child of {1},Rekurzia kusovníka: {0} nemôže byť dieťaťom z {1},
BOM recursion: {0} cannot be parent or child of {1},Rekurzia kusovníka: {0} nemôže byť rodičom alebo dieťaťom {1},
Back to Messages,Späť na Správy,
Bank Data mapper doesn't exist,Mapovač bankových údajov neexistuje,
Bank Details,Bankové údaje,
Bank account '{0}' has been synchronized,Bankový účet &#39;{0}&#39; bol synchronizovaný,
Bank account {0} already exists and could not be created again,Bankový účet {0} už existuje a nedá sa znova vytvoriť,
Bank accounts added,Boli pridané bankové účty,
Batch no is required for batched item {0},Šarža č. Sa vyžaduje pre dávkovú položku {0},
Billing Date,Dátum fakturácie,
Billing Interval Count cannot be less than 1,Počet intervalov fakturácie nesmie byť menší ako 1,
Blue,Modrý,
Book,kniha,
Book Appointment,Kniha schôdzka,
Brand,značka,
Browse,Prehliadať,
Call Connected,Hovor bol spojený,
Call Disconnected,Hovor bol odpojený,
Call Missed,Zmeškaný hovor,
Call Summary,Zhrnutie hovoru,
Call Summary Saved,Súhrn hovorov bol uložený,
Cancelled,ZRUŠENÉ,
Cannot Calculate Arrival Time as Driver Address is Missing.,"Nie je možné vypočítať čas príchodu, pretože chýba adresa vodiča.",
Cannot Optimize Route as Driver Address is Missing.,"Nie je možné optimalizovať trasu, pretože chýba adresa vodiča.",
Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,"Nie je možné dokončiť úlohu {0}, pretože jej závislá úloha {1} nie je dokončená / zrušená.",
Cannot find a matching Item. Please select some other value for {0}.,Nemožno nájsť zodpovedajúce položku. Vyberte nejakú inú hodnotu pre {0}.,
"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nie je možné preplatiť položku {0} v riadku {1} viac ako {2}. Ak chcete povoliť nadmernú fakturáciu, nastavte príspevok v nastaveniach účtov",
"Capacity Planning Error, planned start time can not be same as end time","Chyba plánovania kapacity, plánovaný čas začiatku nemôže byť rovnaký ako čas ukončenia",
Categories,Kategórie,
Changes in {0},Zmeny v {0},
Chart,Graf,
Choose a corresponding payment,Vyberte zodpovedajúcu platbu,
Click on the link below to verify your email and confirm the appointment,Kliknutím na odkaz nižšie overte svoj e-mail a potvrďte schôdzku,
Close,Zavrieť,
Communication,Komunikácia,
Compact Item Print,Tlačiť položku kompaktne,
Company,Spoločnosť,
Company of asset {0} and purchase document {1} doesn't matches.,Spoločnosť s majetkom {0} a nákupný doklad {1} sa nezhodujú.,
Compare BOMs for changes in Raw Materials and Operations,Porovnajte kusovníky pre zmeny v surovinách a operáciách,
Compare List function takes on list arguments,Funkcia Porovnanie zoznamu preberie argumenty zoznamu,
Complete,Hotovo,
Completed,Dokončeno,
Completed Quantity,Dokončené množstvo,
Connect your Exotel Account to ERPNext and track call logs,Pripojte svoj účet Exotel k ERPĎalším a sledujte protokoly hovorov,
Connect your bank accounts to ERPNext,Pripojte svoje bankové účty k ERPĎalším,
Contact Seller,Kontaktovať predajcu,
Continue,Pokračovať,
Cost Center: {0} does not exist,Nákladové stredisko: {0} neexistuje,
Couldn't Set Service Level Agreement {0}.,Nepodarilo sa nastaviť dohodu o úrovni služieb {0}.,
Country,Krajina,
Country Code in File does not match with country code set up in the system,Kód krajiny v súbore sa nezhoduje s kódom krajiny nastaveným v systéme,
Create New Contact,Vytvoriť nový kontakt,
Create New Lead,Vytvoriť nového potenciálneho zákazníka,
Create Pick List,Vytvoriť zoznam,
Create Quality Inspection for Item {0},Vytvoriť kontrolu kvality pre položku {0},
Creating Accounts...,Vytváranie účtov ...,
Creating bank entries...,Vytvárajú sa bankové záznamy ...,
Credit limit is already defined for the Company {0},Úverový limit je už pre spoločnosť definovaný {0},
Ctrl + Enter to submit,Ctrl + Enter na odoslanie,
Ctrl+Enter to submit,Ctrl + Enter na odoslanie,
Currency,Mena,
Current Status,Aktuální stav,
Customer PO,Zákazník PO,
Daily,Denne,
Date,Dátum,
Date of Birth cannot be greater than Joining Date.,Dátum narodenia nemôže byť väčší ako dátum vstupu.,
Dear,Vážený (á),
Default,Východzie,
Define coupon codes.,Definujte kódy kupónov.,
Delayed Days,Oneskorené dni,
Delete,Zmazať,
Delivered Quantity,Dodané množstvo,
Delivery Notes,Dodacie listy,
Depreciated Amount,Odpisovaná suma,
Description,popis,
Designation,Označení,
Difference Value,Hodnota rozdielu,
Dimension Filter,Dimenzačný filter,
Disabled,Vypnuté,
Disbursement and Repayment,Vyplatenie a splatenie,
Distance cannot be greater than 4000 kms,Vzdialenosť nesmie byť väčšia ako 4000 km,
Do you want to submit the material request,Chcete odoslať žiadosť o materiál,
Doctype,DocType,
Document {0} successfully uncleared,Dokument {0} bol úspešne nejasný,
Download Template,Stiahnuť šablónu,
Dr,Dr,
Due Date,Datum splatnosti,
Duplicate,Duplikát,
Duplicate Project with Tasks,Duplikát projektu s úlohami,
Duplicate project has been created,Bol vytvorený duplikát projektu,
E-Way Bill JSON can only be generated from a submitted document,E-Way Bill JSON môže byť generovaný iba z predloženého dokumentu,
E-Way Bill JSON can only be generated from submitted document,E-Way Bill JSON môže byť generovaný iba z predloženého dokumentu,
E-Way Bill JSON cannot be generated for Sales Return as of now,Účet e-Way Bill JSON už nie je možné vygenerovať pre návratnosť predaja,
ERPNext could not find any matching payment entry,ERPNext nemohol nájsť žiadny zodpovedajúci platobný záznam,
Earliest Age,Najstarší vek,
Edit Details,Upraviť podrobnosti,
Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Ak je spôsob dopravy cestná, vyžaduje sa ID prepravcu GST alebo číslo vozidla",
Email,e-mail,
Email Campaigns,E-mailové kampane,
Employee ID is linked with another instructor,ID zamestnanca je prepojené s iným inštruktorom,
Employee Tax and Benefits,Daň z príjmu zamestnancov a výhody,
Employee is required while issuing Asset {0},Zamestnanec je povinný pri vydávaní aktíva {0},
Employee {0} does not belongs to the company {1},Zamestnanec {0} nepatrí do spoločnosti {1},
Enable Auto Re-Order,Povoliť automatické opätovné objednávanie,
End Date of Agreement can't be less than today.,Dátum ukončenia dohody nemôže byť nižší ako dnes.,
End Time,End Time,
Energy Point Leaderboard,Leaderboard Energy Point,
Enter API key in Google Settings.,Zadajte kľúč rozhrania API v Nastaveniach Google.,
Enter Supplier,Zadajte dodávateľa,
Enter Value,Zadejte hodnotu,
Entity Type,Typ entity,
Error,Chyba,
Error in Exotel incoming call,Chyba pri prichádzajúcom hovore z Exotelu,
Error: {0} is mandatory field,Chyba: {0} je povinné pole,
Exception occurred while reconciling {0},Počas vyrovnania došlo k výnimke {0},
Expected and Discharge dates cannot be less than Admission Schedule date,Očakávané a dátumy absolutória nemôžu byť kratšie ako dátum plánovania prijatia,
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,Nepodarilo sa pridať doménu,
Fetch Items from Warehouse,Načítať položky zo skladu,
Fetching...,Načítanie ...,
Field,Pole,
Filters,Filtry,
Finding linked payments,Hľadanie prepojených platieb,
Fleet Management,fleet management,
Following fields are mandatory to create address:,Na vytvorenie adresy sú povinné nasledujúce polia:,
For Month,Za mesiac,
"For item {0} at row {1}, count of serial numbers does not match with the picked quantity",Pre položku {0} v riadku {1} sa počet sériových čísel nezhoduje s vybraným množstvom,
For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Pre operáciu {0}: Množstvo ({1}) nemôže byť väčšie ako množstvo čakajúce na spracovanie ({2}),
For quantity {0} should not be greater than work order quantity {1},Pre množstvo {0} by nemalo byť väčšie ako množstvo pre pracovný príkaz {1},
Free item not set in the pricing rule {0},Bezplatná položka nie je stanovená v cenovom pravidle {0},
From Date and To Date are Mandatory,Od dátumu do dátumu sú povinné,
From employee is required while receiving Asset {0} to a target location,Od príjemcu sa vyžaduje pri prijímaní aktíva {0} na cieľové miesto,
Future Payment Amount,Čiastka budúcej platby,
Future Payment Ref,Budúca platba Ref,
Future Payments,Budúce platby,
GST HSN Code does not exist for one or more items,Kód GST HSN neexistuje pre jednu alebo viac položiek,
Generate E-Way Bill JSON,Vygenerujte E-Way Bill JSON,
Get Items,Získat položky,
Get Outstanding Documents,Získajte vynikajúce dokumenty,
Goal,Cieľ,
Greater Than Amount,Väčšie ako množstvo,
Green,Zelená,
Group,Skupina,
Group By Customer,Zoskupiť podľa zákazníka,
Group By Supplier,Skupina podľa dodávateľa,
Group Node,Group Node,
Group Warehouses cannot be used in transactions. Please change the value of {0},Skupinové sklady sa nemôžu používať pri transakciách. Zmeňte hodnotu {0},
Help,Nápoveda,
Help Article,pomoc článok,
"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomôže vám sledovať zmluvy na základe dodávateľa, zákazníka a zamestnanca",
Helps you manage appointments with your leads,Pomáha vám spravovať schôdzky s vašimi potenciálnymi zákazníkmi,
Home,Domov,
IBAN is not valid,IBAN nie je platný,
Import Data from CSV / Excel files.,Importovanie údajov z súborov CSV / Excel.,
In Progress,Pokrok,
Incoming call from {0},Prichádzajúci hovor od {0},
Incorrect Warehouse,Nesprávny sklad,
Invalid Barcode. There is no Item attached to this barcode.,Neplatný čiarový kód. K tomuto čiarovému kódu nie je pripojená žiadna položka.,
Invalid credentials,Neplatné poverenia,
Issue Priority.,Priorita vydania.,
Issue Type.,Typ vydania.,
"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á sa, že existuje problém s konfiguráciou pásma servera. V prípade zlyhania bude suma vrátená na váš účet.",
Item Reported,Položka bola nahlásená,
Item listing removed,Zoznam položiek bol odstránený,
Item quantity can not be zero,Množstvo položky nemôže byť nula,
Item taxes updated,Dane z tovaru boli aktualizované,
Item {0}: {1} qty produced. ,Položka {0}: {1} vyprodukované množstvo.,
Joining Date can not be greater than Leaving Date,Dátum vstupu nemôže byť väčší ako dátum odchodu,
Lab Test Item {0} already exist,Testovacia položka laboratória {0} už existuje,
Last Issue,Posledné vydanie,
Latest Age,Najnovší vek,
Leaves Taken,Listy odobraté,
Less Than Amount,Menej ako suma,
Liabilities,záväzky,
Loading...,Nahrávám...,
Loan Applications from customers and employees.,Žiadosti o pôžičky od zákazníkov a zamestnancov.,
Loan Processes,Úverové procesy,
Loan Type for interest and penalty rates,Typ úveru pre úroky a penále,
Loans,pôžičky,
Loans provided to customers and employees.,Pôžičky poskytnuté zákazníkom a zamestnancom.,
Location,Místo,
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,"Vyzerá to, že vás niekto poslal k neúplnému URL. Požiadajte ho, aby sa na to pozrel.",
Make Journal Entry,Proveďte položka deníku,
Make Purchase Invoice,Proveďte nákupní faktury,
Manufactured,vyrábané,
Mark Work From Home,Označte prácu z domu,
Master,Hlavné,
Max strength cannot be less than zero.,Maximálna pevnosť nesmie byť menšia ako nula.,
Maximum attempts for this quiz reached!,Dosiahli ste maximálny počet pokusov o tento test!,
Message,správa,
Missing Values Required,Chybějící hodnoty vyžadovány,
Mobile No,Mobile No,
Mobile Number,Telefónne číslo,
Month,Měsíc,
Name,Meno,
Near you,Vo vašom okolí,
Net Profit/Loss,Čistý zisk / strata,
New Expense,Nové výdavky,
New Invoice,Nová faktúra,
New Payment,Nová platba,
New release date should be in the future,Nový dátum vydania by mal byť v budúcnosti,
No Account matched these filters: {},K týmto filtrom nezodpovedal žiadny účet: {},
No communication found.,Nenašla sa žiadna komunikácia.,
No correct answer is set for {0},Pre {0} nie je nastavená žiadna správna odpoveď,
No description,žiadny popis,
No issue has been raised by the caller.,Volajúci nenastolil žiadny problém.,
No items to publish,Žiadne položky na zverejnenie,
No outstanding invoices found,Nenašli sa žiadne neuhradené faktúry,
No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,"Za {0} {1} sa nenašli žiadne nevyrovnané faktúry, ktoré by spĺňali zadané filtre.",
No outstanding invoices require exchange rate revaluation,Nevyrovnané faktúry nevyžadujú precenenie výmenného kurzu,
No reviews yet,Zatiaľ žiadne recenzie,
No views yet,Zatiaľ žiadne zobrazenia,
Non stock items,Neskladové položky,
Not Allowed,Není povoleno,
Not allowed to create accounting dimension for {0},Nie je povolené vytvárať účtovnú dimenziu pre {0},
Not permitted. Please disable the Lab Test Template,Nepovolené. Zakážte šablónu testu laboratória,
Note,Poznámka,
Notes: ,Poznámky:,
On Converting Opportunity,O konverzii príležitosti,
On Purchase Order Submission,Pri zadávaní objednávky,
On Sales Order Submission,O zadaní zákazky odberateľa,
On Task Completion,Pri dokončení úlohy,
On {0} Creation,Dňa {0} stvorenia,
Only .csv and .xlsx files are supported currently,Momentálne sú podporované iba súbory .csv a .xlsx,
Open,Otvoriť,
Open Contact,Otvorte kontakt,
Open Lead,Otvorte potenciálneho zákazníka,
Opening and Closing,Otváranie a zatváranie,
Operating Cost as per Work Order / BOM,Prevádzkové náklady podľa objednávky / kusovníka,
Order Amount,Suma objednávky,
Page {0} of {1},Strana {0} z {1},
Paid amount cannot be less than {0},Platená suma nemôže byť nižšia ako {0},
Parent Company must be a group company,Materská spoločnosť musí byť spoločnosťou v skupine,
Passing Score value should be between 0 and 100,Hodnota úspešného skóre by mala byť medzi 0 a 100,
Patient History,História pacientov,
Pause,pause,
Pay,Platiť,
Payment Document Type,Druh platobného dokladu,
Payment Name,Názov platby,
Pending,Čakajúce,
Performance,výkon,
Period based On,Obdobie založené na,
Perpetual inventory required for the company {0} to view this report.,Na zobrazenie tejto správy je potrebná trvalá inventarizácia spoločnosti {0}.,
Phone,Telefón,
Pick List,Vyberte zoznam,
Plaid authentication error,Chyba overeného overenia,
Plaid public token error,Plaid public token error,
Plaid transactions sync error,Chyba synchronizácie prehľadných transakcií,
Please check the error log for details about the import errors,Podrobnosti o chybách importu nájdete v protokole chýb,
Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Vytvorte <b>nastavenia</b> spoločnosti <b>DATEV</b> pre spoločnosť <b>{}</b> .,
Please create adjustment Journal Entry for amount {0} ,Vytvorte opravný zápis do denníka pre sumu {0},
Please do not create more than 500 items at a time,Nevytvárajte naraz viac ako 500 položiek,
Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Zadajte <b>rozdielny účet</b> alebo nastavte predvolený <b>účet</b> na vyrovnanie <b>zásob</b> spoločnosti {0},
Please enter GSTIN and state for the Company Address {0},Zadajte GSTIN a uveďte adresu spoločnosti {0},
Please enter Item Code to get item taxes,"Ak chcete získať dane z tovaru, zadajte kód položky",
Please enter Warehouse and Date,Zadajte sklad a dátum,
Please login as a Marketplace User to edit this item.,"Ak chcete upraviť túto položku, prihláste sa ako používateľ služby Marketplace.",
Please login as a Marketplace User to report this item.,"Ak chcete nahlásiť túto položku, prihláste sa ako používateľ Marketplace.",
Please select <b>Template Type</b> to download template,Vyberte <b>šablónu</b> pre stiahnutie šablóny,
Please select Customer first,Najskôr vyberte zákazníka,
Please select Item Code first,Najskôr vyberte kód položky,
Please select a Delivery Note,Vyberte dodací list,
Please select a Sales Person for item: {0},Vyberte obchodnú osobu pre položku: {0},
Please select another payment method. Stripe does not support transactions in currency '{0}',Vyberte iný spôsob platby. Stripe nepodporuje transakcie s menou &quot;{0}&quot;,
Please select the customer.,Vyberte zákazníka.,
Please set a Supplier against the Items to be considered in the Purchase Order.,"Prosím, nastavte Dodávateľa na položky, ktoré sa majú zohľadniť v Objednávke.",
Please set account heads in GST Settings for Compnay {0},Nastavte hlavičky účtu v časti Nastavenia GST pre Compnay {0},
Please set an email id for the Lead {0},Zadajte e-mailovú identifikáciu potenciálneho zákazníka {0},
Please set default UOM in Stock Settings,Nastavte predvolené UOM v nastaveniach zásob,
Please set filter based on Item or Warehouse due to a large amount of entries.,Kvôli veľkému počtu záznamov nastavte filter na základe položky alebo skladu.,
Please set up the Campaign Schedule in the Campaign {0},Nastavte kampaň v kampani {0},
Please set valid GSTIN No. in Company Address for company {0},Zadajte platné číslo GSTIN v adrese spoločnosti pre spoločnosť {0},
Please set {0},"Prosím, nastavte {0}",customer
Please setup a default bank account for company {0},Nastavte predvolený bankový účet spoločnosti {0},
Please specify,Prosím upresnite,
Please specify a {0},Zadajte {0},lead
Priority,Priorita,
Priority has been changed to {0}.,Priorita sa zmenila na {0}.,
Priority {0} has been repeated.,Priorita {0} bola opakovaná.,
Processing XML Files,Spracovanie súborov XML,
Profitability,Ziskovosť,
Project,Projekt,
Provide the academic year and set the starting and ending date.,Uveďte akademický rok a stanovte počiatočný a konečný dátum.,
Public token is missing for this bank,V tejto banke chýba verejný token,
Publish 1 Item,Zverejniť 1 položku,
Publish Items,Publikovať položky,
Publish More Items,Zverejniť viac položiek,
Publish Your First Items,Zverejnite svoje prvé položky,
Publish {0} Items,Zverejniť {0} položiek,
Published Items,Zverejnené položky,
Purchase Invoice cannot be made against an existing asset {0},Nákupnú faktúru nie je možné uplatniť proti existujúcemu dielu {0},
Purchase Invoices,Nákup faktúr,
Purchase Orders,Objednávky,
Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,"Potvrdenie o kúpe nemá žiadnu položku, pre ktorú je povolená vzorka ponechania.",
Purchase Return,Nákup Return,
Qty of Finished Goods Item,Množstvo dokončeného tovaru,
Quality Inspection required for Item {0} to submit,"Vyžaduje sa kontrola kvality, aby sa položka {0} mohla predložiť",
Quantity to Manufacture,Množstvo na výrobu,
Quantity to Manufacture can not be zero for the operation {0},Množstvo na výrobu nemôže byť pre operáciu nulové {0},
Quarterly,Čtvrtletně,
Queued,Vo fronte,
Quick Entry,Rýchly vstup,
Quiz {0} does not exist,Kvíz {0} neexistuje,
Quotation Amount,Suma ponuky,
Rate or Discount is required for the price discount.,Na zľavu z ceny sa vyžaduje sadzba alebo zľava.,
Reason,Dôvod,
Reconcile Entries,Zmieriť položky,
Reconcile this account,Zosúladiť tento účet,
Reconciled,zmierený,
Recruitment,nábor,
Red,Červená,
Release date must be in the future,Dátum vydania musí byť v budúcnosti,
Relieving Date must be greater than or equal to Date of Joining,Dátum vydania musí byť väčší alebo rovný dátumu pripojenia,
Rename,Premenovať,
Rename Not Allowed,Premenovať nie je povolené,
Report Item,Položka správy,
Report this Item,Nahláste túto položku,
Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Vyhradené množstvo pre subdodávky: Množstvo surovín na výrobu subdodávateľských položiek.,
Reset,Reštartovať,
Reset Service Level Agreement,Obnoviť dohodu o úrovni služieb,
Resetting Service Level Agreement.,Obnovenie dohody o úrovni služieb.,
Return amount cannot be greater unclaimed amount,Čiastka vrátenia nemôže byť väčšia nevyžiadaná suma,
Review,Preskúmanie,
Room,izbu,
Room Type,Typ izby,
Row # ,Row #,
Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Riadok # {0}: Prijatý sklad a dodávateľský sklad nemôžu byť rovnaké,
Row #{0}: Cannot delete item {1} which has already been billed.,"Riadok # {0}: Nie je možné odstrániť položku {1}, ktorá už bola fakturovaná.",
Row #{0}: Cannot delete item {1} which has already been delivered,"Riadok # {0}: Nedá sa odstrániť položka {1}, ktorá už bola doručená",
Row #{0}: Cannot delete item {1} which has already been received,"Riadok # {0}: Nemožno odstrániť položku {1}, ktorá už bola prijatá",
Row #{0}: Cannot delete item {1} which has work order assigned to it.,"Riadok # {0}: Nie je možné odstrániť položku {1}, ktorá má priradený pracovný príkaz.",
Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,"Riadok # {0}: Nie je možné odstrániť položku {1}, ktorá je priradená k objednávke zákazníka.",
Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,"Riadok # {0}: Nie je možné vybrať dodávateľa, zatiaľ čo dodávame suroviny subdodávateľovi",
Row #{0}: Cost Center {1} does not belong to company {2},Riadok # {0}: Nákladové stredisko {1} nepatrí spoloč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}.,Riadok # {0}: Operácia {1} nie je dokončená pre {2} množstvo hotového tovaru v objednávke {3}. Aktualizujte prevádzkový stav prostredníctvom Job Card {4}.,
Row #{0}: Payment document is required to complete the transaction,Riadok # {0}: Na dokončenie transakcie je potrebný platobný doklad,
Row #{0}: Serial No {1} does not belong to Batch {2},Riadok # {0}: Poradové číslo {1} nepatrí do šarže {2},
Row #{0}: Service End Date cannot be before Invoice Posting Date,Riadok # {0}: Dátum ukončenia služby nemôže byť pred dátumom zaúčtovania faktúry,
Row #{0}: Service Start Date cannot be greater than Service End Date,Riadok # {0}: Dátum začatia služby nemôže byť väčší ako dátum ukončenia služby,
Row #{0}: Service Start and End Date is required for deferred accounting,Riadok # {0}: Dátum odloženia a začiatku služby je potrebný pre odložené účtovanie,
Row {0}: Invalid Item Tax Template for item {1},Riadok {0}: Neplatná šablóna dane z položky pre položku {1},
Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Riadok {0}: Množstvo nie je k dispozícii pre {4} v sklade {1} v čase účtovania vstupu ({2} {3}),
Row {0}: user has not applied the rule {1} on the item {2},Riadok {0}: používateľ neuplatnil pravidlo {1} na položku {2},
Row {0}:Sibling Date of Birth cannot be greater than today.,Riadok {0}: Dátum súrodenia nemôže byť väčší ako dnes.,
Row({0}): {1} is already discounted in {2},Riadok ({0}): {1} je už zľavnený v {2},
Rows Added in {0},Riadky pridané v {0},
Rows Removed in {0},Riadky odstránené o {0},
Save,Uložiť,
Save Item,Uložiť položku,
Saved Items,Uložené položky,
Search Items ...,Hľadať položky ...,
Search for a payment,Vyhľadajte platbu,
Search for anything ...,Vyhľadajte čokoľvek ...,
Search results for,Výsledky vyhľadávania pre,
Select Difference Account,Vyberte rozdielny účet,
Select a Default Priority.,Vyberte predvolenú prioritu.,
Select a company,Vyberte spoločnosť,
Select finance book for the item {0} at row {1},Vyberte finančnú knihu pre položku {0} v riadku {1},
Select only one Priority as Default.,Ako predvolenú vyberte iba jednu prioritu.,
Seller Information,Informácie o predajcovi,
Send,Odoslať,
Send a message,Poslať správu,
Sending,Odosielanie,
Sends Mails to lead or contact based on a Campaign schedule,Pošle e-maily na vedenie alebo kontakt na základe plánu kampane,
Serial Number Created,Sériové číslo bolo vytvorené,
Serial Numbers Created,Vytvorené sériové čísla,
Serial no(s) required for serialized item {0},Sériové číslo (-a) požadované pre serializovanú položku {0},
Series,Série,
Server Error,Chyba servera,
Service Level Agreement has been changed to {0}.,Dohoda o úrovni služieb sa zmenila na {0}.,
Service Level Agreement was reset.,Dohoda o úrovni služieb bola obnovená.,
Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Dohoda o úrovni služieb s typom entity {0} a entitou {1} už existuje.,
Set Meta Tags,Nastavte značky meta,
Set {0} in company {1},Set {0} v spoločnosti {1},
Setup,Nastavenie,
Shift Management,Shift Management,
Show Future Payments,Zobraziť budúce platby,
Show Linked Delivery Notes,Zobraziť prepojené dodacie listy,
Show Sales Person,Zobraziť predajnú osobu,
Show Stock Ageing Data,Zobraziť údaje o starnutí zásob,
Show Warehouse-wise Stock,Zobraziť skladové zásoby,
Size,Veľkosť,
Something went wrong while evaluating the quiz.,Pri vyhodnocovaní testu sa niečo pokazilo.,
Sr,staršie,
Start,Štart,
Start Date cannot be before the current date,Dátum začiatku nemôže byť pred aktuálnym dátumom,
Start Time,Start Time,
Status,Stav,
Status must be Cancelled or Completed,Stav musí byť zrušený alebo dokončený,
Stock Balance Report,Správa o stave zásob,
Stock Entry has been already created against this Pick List,Položka zásob už bola vytvorená v rámci tohto zoznamu,
Stock Ledger ID,ID skladu,
Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Hodnota zásob ({0}) a zostatok na účte ({1}) nie sú synchronizované s účtom {2} a súvisiacimi skladmi.,
Stores - {0},Obchody - {0},
Student with email {0} does not exist,Študent s e-mailom {0} neexistuje,
Submit Review,Odoslať recenziu,
Submitted,Potvrdené,
Supplier Addresses And Contacts,Dodavatel Adresy a kontakty,
Synchronize this account,Synchronizujte tento účet,
Tag,štítok,
Target Location is required while receiving Asset {0} from an employee,Cieľová lokalita je vyžadovaná pri prijímaní aktíva {0} od zamestnanca,
Target Location is required while transferring Asset {0},Cieľová poloha je vyžadovaná pri prenose diela {0},
Target Location or To Employee is required while receiving Asset {0},Cieľová poloha alebo Na zamestnanca je potrebné pri prijímaní aktíva {0},
Task's {0} End Date cannot be after Project's End Date.,Dátum ukončenia úlohy {0} nemôže byť po dátume ukončenia projektu.,
Task's {0} Start Date cannot be after Project's End Date.,{0} Dátum začatia úlohy nemôže byť po dátume ukončenia projektu.,
Tax Account not specified for Shopify Tax {0},Daňový účet nie je uvedený pre daň z obchodov {0},
Tax Total,Daň celkom,
Template,Šablona,
The Campaign '{0}' already exists for the {1} '{2}',Kampaň &#39;{0}&#39; už existuje pre {1} &#39;{2}&#39;,
The difference between from time and To Time must be a multiple of Appointment,Rozdiel medzi časom a časom musí byť násobkom stretnutia,
The field Asset Account cannot be blank,Pole Majetkový účet nemôže byť prázdne,
The field Equity/Liability Account cannot be blank,Pole Účet vlastného imania / zodpovednosti nemôže byť prázdne,
The following serial numbers were created: <br><br> {0},Boli vytvorené nasledujúce sériové čísla: <br><br> {0},
The parent account {0} does not exists in the uploaded template,Materský účet {0} v odovzdanej šablóne neexistuje,
The question cannot be duplicate,Otázka nemôže byť duplikovaná,
The selected payment entry should be linked with a creditor bank transaction,Vybraný platobný záznam by mal byť prepojený s veriteľskou bankovou transakciou,
The selected payment entry should be linked with a debtor bank transaction,Vybraný platobný záznam by mal byť spojený s bankovou transakciou dlžníka,
The total allocated amount ({0}) is greated than the paid amount ({1}).,Celková alokovaná čiastka ({0}) je označená ako zaplatená suma ({1}).,
This Service Level Agreement is specific to Customer {0},Táto dohoda o úrovni služieb je špecifická pre 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 ?,Táto akcia zruší prepojenie tohto účtu s akoukoľvek externou službou integrujúcou ERPNext s vašimi bankovými účtami. Nedá sa vrátiť späť. Ste si istí?,
This bank account is already synchronized,Tento bankový účet je už synchronizovaný,
This bank transaction is already fully reconciled,Táto banková transakcia je už úplne vyrovnaná,
This page keeps track of items you want to buy from sellers.,"Táto stránka sleduje položky, ktoré chcete kúpiť od predajcov.",
This page keeps track of your items in which buyers have showed some interest.,"Táto stránka sleduje vaše položky, o ktoré kupujúci prejavili určitý záujem.",
Thursday,Čtvrtek,
Title,Názov,
"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Ak chcete povoliť nadmernú fakturáciu, aktualizujte položku „Príspevok na fakturáciu“ v nastaveniach účtov alebo v položke.",
"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Ak chcete povoliť príjem / doručenie, aktualizujte položku „Príjem a príjem zásielok“ v nastaveniach zásob alebo v položke.",
Total,Celkem,
Total Payment Request amount cannot be greater than {0} amount,Celková suma žiadosti o platbu nemôže byť vyššia ako {0} suma,
Total payments amount can't be greater than {},Celková suma platieb nemôže byť vyššia ako {},
Totals,Súčty,
Transactions already retreived from the statement,"Transakcie, ktoré už boli z výkazu prevzaté",
Transfer Material to Supplier,Preneste materiál Dodávateľovi,
Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Pre zvolený spôsob dopravy sú povinné číslo a dátum prepravy,
Tuesday,Úterý,
Type,Typ,
Unable to find the time slot in the next {0} days for the operation {1}.,V nasledujúcich {0} dňoch nie je možné nájsť časový interval operácie {1}.,
Unable to update remote activity,Nemožno aktualizovať vzdialenú aktivitu,
Unknown Caller,Neznámy volajúci,
Unlink external integrations,Odpojte externé integrácie,
Unpublish Item,Zverejniť položku,
Unreconciled,nezmierilo,
Unsupported GST Category for E-Way Bill JSON generation,Nepodporovaná kategória GST pre generáciu E-Way Bill JSON,
Update,Aktualizovat,
Update Taxes for Items,Aktualizujte dane pre položky,
"Upload a bank statement, link or reconcile a bank account","Odovzdajte bankový výpis, prepojte bankový účet alebo ho zladte",
Upload a statement,Nahrajte vyhlásenie,
Use a name that is different from previous project name,"Použite názov, ktorý sa líši od názvu predchádzajúceho projektu",
User {0} is disabled,Uživatel {0} je zakázána,
Users and Permissions,Uživatelé a oprávnění,
Valuation Rate required for Item {0} at row {1},Sadzba ocenenia požadovaná pre položku {0} v riadku {1},
Values Out Of Sync,Hodnoty nie sú synchronizované,
Vehicle Type is required if Mode of Transport is Road,"Ak je spôsob dopravy cestný, vyžaduje sa typ vozidla",
Vendor Name,Meno predajcu,
Verify Email,potvrdiť Email,
View,Pohľad,
View all issues from {0},Zobraziť všetky čísla od {0},
View call log,Zobraziť denník hovorov,
Warehouse,sklad,
Warehouse not found against the account {0},Sklad nebol nájdený oproti účtu {0},
Welcome to {0},Vitajte v {0},
Why do think this Item should be removed?,"Prečo si myslíte, že by sa táto položka mala odstrániť?",
Work Order {0}: Job Card not found for the operation {1},Pracovný príkaz {0}: karta úlohy nebola pre operáciu nájdená {1},
Workday {0} has been repeated.,Pracovný deň {0} sa opakoval.,
XML Files Processed,Spracované súbory XML,
Year,Rok,
Yearly,Ročne,
You are not allowed to enroll for this course,Nemáte povolenie sa prihlásiť na tento kurz,
You are not enrolled in program {0},Nie ste prihlásení do programu {0},
You can Feature upto 8 items.,Môžete obsahovať až 8 položiek.,
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 publikovať až 200 položiek.,
You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Ak chcete zachovať úrovne opätovného poradia, musíte povoliť automatické opätovné objednávanie v nastaveniach zásob.",
You must be a registered supplier to generate e-Way Bill,"Ak chcete generovať faktúru za e-Way, musíte byť registrovaným dodávateľom",
You need to login as a Marketplace User before you can add any reviews.,Pred pridaním akýchkoľvek recenzií sa musíte prihlásiť ako používateľ Marketplace.,
Your Featured Items,Vaše odporúčané položky,
Your Items,Vaše položky,
Your Profile,Tvoj profil,
Your rating:,Vaše hodnotenie:,
and,a,
e-Way Bill already exists for this document,Elektronický účet už pre tento dokument existuje,
woocommerce - {0},woocommerce - {0},
{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Používa sa kupón {1}. Povolené množstvo je vyčerpané,
{0} Operations: {1},{0} Operácie: {1},
{0} bank transaction(s) created,Vytvorené bankové transakcie,
{0} bank transaction(s) created and {1} errors,Počet vytvorených bankových transakcií: {0} a {1} chýb,
{0} can not be greater than {1},{0} nemôže byť väčší ako {1},
{0} conversations,{0} konverzácií,
{0} is not a company bank account,{0} nie je firemný bankový účet,
{0} is not a group node. Please select a group node as parent cost center,{0} nie je skupinový uzol. Vyberte skupinový uzol ako materské nákladové stredisko,
{0} is not the default supplier for any items.,{0} nie je predvoleným dodávateľom žiadnych položiek.,
{0} is required,{0} je potrebné,
{0}: {1} must be less than {2},{0}: {1} musí byť menej ako {2},
{} is required to generate E-Way Bill JSON,{} je potrebný na vygenerovanie E-Way Bill JSON,
"Invalid lost reason {0}, please create a new lost reason","Neplatný stratený dôvod {0}, vytvorte nový stratený dôvod",
Profit This Year,Zisk tento rok,
Total Expense,Celkové náklady,
Total Expense This Year,Celkové náklady v tomto roku,
Total Income,Celkový príjem,
Total Income This Year,Celkový príjem v tomto roku,
Barcode,čiarový kód,
Clear,jasný,
Comments,Komentáre,
DocType,DOCTYPE,
Download,Stiahnuť ▼,
Left,Vľavo,
Link,odkaz,
New,Nový,
Print,vytlačiť,
Reference Name,Referenčný názov,
Refresh,Obnoviť,
Success,Úspech,
Time,čas,
Value,hodnota,
Actual,skutočný,
Add to Cart,Pridať do košíka,
Days Since Last Order,Dni od poslednej objednávky,
In Stock,Na skladě,
Mode Of Payment,Způsob platby,
No students Found,Nenašli sa žiadni študenti,
Not in Stock,Nie je na sklade,
Please select a Customer,Vyberte zákazníka,
Received From,Prijaté od,
Sales Person,Predajca,
To date cannot be before From date,Dátum DO nemôže byť skôr ako dátum OD,
Write Off,Odpísať,
{0} Created,{0} vytvoril,
Email Id,Email ID,
No,Nie,
Reference Doctype,Reference DocType,
Yes,Áno,
Actual ,Aktuální,
Add to cart,Pridať do košíka,
Budget,rozpočet,
Chart of Accounts,Účtová osnova,
Customer database.,Databáza zákazníkov.,
Days Since Last order,Počet dnů od poslední objednávky,
Download as JSON,Stiahnuť ako JSON,
End date can not be less than start date,Dátum ukončenia nemôže byť menší ako dátum začiatku,
For Default Supplier (Optional),Pre predvoleného dodávateľa (nepovinné),
From date cannot be greater than To date,Dátum OD nemôže byť väčší ako dátum DO,
Group by,Seskupit podle,
In stock,Skladom,
Item name,Názov položky,
Minimum Qty,Minimálny počet,
More details,Další podrobnosti,
Nature of Supplies,Povaha spotrebného materiálu,
No Items found.,Nenašli sa žiadne položky.,
No students found,Žiadni študenti Nájdené,
Not in stock,Nie je na sklade,
Not permitted,Nepovolené,
Open Issues ,Otvorené problémy,
Open Projects ,Otvorené projekty,
Open To Do ,otvorená robiť,
Operation Id,Prevádzka ID,
Partially ordered,čiastočne usporiadané,
Please select company first,"Prosím, vyberte najprv firmu",
Please select patient,Vyberte položku Pacient,
Printed On ,Vytlačené dňa,
Projected qty,Premietané množstvo,
Sales person,Predajca,
Serial No {0} Created,Pořadové číslo {0} vytvořil,
Source Location is required for the Asset {0},Umiestnenie zdroja sa vyžaduje pre majetok {0},
Tax Id,DIČ,
To Time,Chcete-li čas,
To date cannot be before from date,Dátum nemôže byť pred dátumom,
Total Taxable value,Celková zdaniteľná hodnota,
Upcoming Calendar Events ,Nadchádzajúce Udalosti v kalendári,
Value or Qty,Hodnota nebo Množství,
Variance ,odchýlka,
Variant of,Varianta,
Write off,Odpísať,
hours,hodiny,
received from,prijaté od,
to,na,
Cards,karty,
Percentage,percento,
Failed to setup defaults for country {0}. Please contact support@erpnext.com,"Nepodarilo sa nastaviť predvolené nastavenia pre krajinu {0}. Prosím, kontaktujte support@erpnext.com",
Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Riadok # {0}: Položka {1} nie je sériová / dávková položka. Proti nemu nemôže mať sériové číslo / číslo šarže.,
Please set {0},Prosím nastavte {0},
Please set {0},"Prosím, nastavte {0}",supplier
Draft,Návrh,"docstatus,=,0"
Cancelled,zrušený,"docstatus,=,2"
Please setup Instructor Naming System in Education > Education Settings,Nastavte Pomenovací systém inštruktorov v časti Vzdelanie&gt; Nastavenia vzdelávania,
Please set Naming Series for {0} via Setup > Settings > Naming Series,Prosím pomenujte Series pre {0} cez Setup&gt; Settings&gt; Naming Series,
UOM Conversion factor ({0} -> {1}) not found for item: {2},Prepočítavací faktor UOM ({0} -&gt; {1}) nebol nájdený pre položku: {2},
Item Code > Item Group > Brand,Kód položky&gt; Skupina položiek&gt; Značka,
Customer > Customer Group > Territory,Zákazník&gt; Skupina zákazníkov&gt; Územie,
Supplier > Supplier Type,Dodávateľ&gt; Typ dodávateľa,
The value of {0} differs between Items {1} and {2},Hodnota {0} sa líši medzi položkami {1} a {2},
Auto Fetch,Auto Fetch,
Fetch Serial Numbers based on FIFO,Načítajte sériové čísla na základe FIFO,
"Outward taxable supplies(other than zero rated, nil rated and exempted)","Vonkajšie zdaniteľné dodávky (iné ako nulové, nulové a oslobodené od dane)",
"To allow different rates, disable the {0} checkbox in {1}.","Ak chcete povoliť rôzne sadzby, deaktivujte {0} začiarkavacie políčko v {1}.",
Asset{} {assets_link} created for {},Dielo {} {assets_link} vytvorené pre {},
Row {}: Asset Naming Series is mandatory for the auto creation for item {},Riadok {}: Série s názvami položiek sú povinné pre automatické vytváranie položky {},
Assets not created for {0}. You will have to create asset manually.,"Diela, ktoré neboli vytvorené pre {0}. Budete musieť vytvoriť dielo manuálne.",
{0} {1} has accounting entries in currency {2} for company {3}. Please select a receivable or payable account with currency {2}.,{0} {1} má účtovné záznamy v mene {2} pre spoločnosť {3}. Vyberte pohľadávku alebo záväzok s menou {2}.,
Invalid Account,Nesprávny účet,
Purchase Order Required,Vydaná objednávka je vyžadována,
Purchase Receipt Required,Příjmka je vyžadována,
Account Missing,Účet chýba,
Requested,Požadované,
Partially Paid,Čiastočne zaplatené,
Invalid Account Currency,Neplatná mena účtu,
"Row {0}: The item {1}, quantity must be positive number","Riadok {0}: Položka {1}, množstvo musí byť kladné číslo",
"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Nastavte {0} pre dávkovú položku {1}, ktorá sa používa na nastavenie {2} pri odoslaní.",
Expiry Date Mandatory,Dátum exspirácie je povinný,
Variant Item,Položka variantu,
BOM 1 {0} and BOM 2 {1} should not be same,Kusovník 1 {0} a kusovník 2 {1} by nemali byť rovnaké,
Note: Item {0} added multiple times,Poznámka: Položka {0} bola pridaná viackrát,
YouTube,YouTube,
Vimeo,Vimeo,
Publish Date,Dátum vydania,
Duration,trvanie,
Advanced Settings,Pokročilé nastavenia,
Path,cesta,
Components,komponenty,
Verified By,Verified By,
Invalid naming series (. missing) for {0},Neplatný rad pomenovaní (. Chýba) pre {0},
Filter Based On,Filtrovať na základe,
Reqd by date,Požadované podľa dátumu,
Manufacturer Part Number <b>{0}</b> is invalid,Číslo výrobcu <b>{0}</b> je neplatné,
Invalid Part Number,Neplatné číslo dielu,
Select atleast one Social Media from Share on.,Vyberte aspoň jedno sociálne médium v časti Zdieľať.,
Invalid Scheduled Time,Neplatný naplánovaný čas,
Length Must be less than 280.,Dĺžka musí byť menšia ako 280.,
Error while POSTING {0},Chyba pri ODOSIELANÍ {0},
"Session not valid, Do you want to login?","Relácia nie je platná, chcete sa prihlásiť?",
Session Active,Relácia aktívna,
Session Not Active. Save doc to login.,Relácia nie je aktívna. Uložiť dokument na prihlásenie.,
Error! Failed to get request token.,Chyba! Získať token žiadosti sa nepodarilo.,
Invalid {0} or {1},Neplatné {0} alebo {1},
Error! Failed to get access token.,Chyba! Nepodarilo sa získať prístupový token.,
Invalid Consumer Key or Consumer Secret Key,Neplatný kľúč zákazníka alebo tajný kľúč zákazníka,
Your Session will be expire in ,Vaša relácia vyprší o,
 days.,dni.,
Session is expired. Save doc to login.,Relácia vypršala. Uložiť dokument na prihlásenie.,
Error While Uploading Image,Chyba pri nahrávaní obrázka,
You Didn't have permission to access this API,Nemali ste povolenie na prístup k tomuto API,
Valid Upto date cannot be before Valid From date,Platná do dátumu nemôže byť skôr ako platná od dátumu,
Valid From date not in Fiscal Year {0},"Platné od dátumu, ktorý nie je vo fiškálnom roku {0}",
Valid Upto date not in Fiscal Year {0},"Platné do dnešného dňa, nie vo fiškálnom roku {0}",
Group Roll No,Skupina Roll č,
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}.","Riadok {1}: Množstvo ({0}) nemôže byť zlomok. Ak to chcete povoliť, 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,Vytvorenie kontaktu zlyhalo,
Leaves Expired,Listy vypršali,
Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Riadok č. {}: {} Z {} by mal byť {}. Upravte účet alebo vyberte iný účet.,
Row #{}: Please asign task to a member.,Riadok # {}: Priraďte úlohu členovi.,
Process Failed,Proces zlyhal,
Tally Migration Error,Chyba migrácie záznamu,
Please set Warehouse in Woocommerce Settings,Nastavte Sklad v Nastaveniach Woocommerce,
Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Riadok {0}: Dodací sklad ({1}) a Zákaznícky sklad ({2}) nemôžu byť rovnaké,
Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Riadok {0}: Dátum splatnosti v tabuľke Platobné podmienky nemôže byť skôr ako Dátum zaúčtovania,
Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,Nie je možné nájsť položku {} pre položku {}. Rovnaké nastavte v nastaveniach predlohy alebo skladu.,
Row #{0}: The batch {1} has already expired.,Riadok č. {0}: Dávke {1} už uplynula platnosť.,
Start Year and End Year are mandatory,Začiatočný a Koncový rok sú povinné,
GL Entry,Vstup GL,
Cannot allocate more than {0} against payment term {1},Nie je možné prideliť viac ako {0} oproti platobnému termínu {1},
The root account {0} must be a group,Koreňový účet {0} musí byť skupina,
Shipping rule not applicable for country {0} in Shipping Address,Pravidlo dodania sa nevzťahuje na krajinu {0} v časti Adresa dodania,
Get Payments from,Získajte platby od,
Set Shipping Address or Billing Address,Nastavte dodaciu adresu alebo fakturačnú adresu,
Consultation Setup,Nastavenie konzultácie,
Fee Validity,Platnosť poplatku,
Laboratory Setup,Laboratórne usporiadanie,
Dosage Form,Dávkovací formulár,
Records and History,Záznamy a história,
Patient Medical Record,Záznam pacienta,
Rehabilitation,Rehabilitácia,
Exercise Type,Typ cvičenia,
Exercise Difficulty Level,Úroveň obtiažnosti cvičenia,
Therapy Type,Typ terapie,
Therapy Plan,Terapeutický plán,
Therapy Session,Terapeutické sedenie,
Motor Assessment Scale,Motorická hodnotiaca stupnica,
[Important] [ERPNext] Auto Reorder Errors,[Dôležité] [ERPNext] Chyby automatického poradia,
"Regards,","S pozdravom,",
The following {0} were created: {1},Boli vytvorené nasledujúce položky ({0}): {1},
Work Orders,Pracovné príkazy,
The {0} {1} created sucessfully,Aplikácia {0} {1} bola úspešne vytvorená,
Work Order cannot be created for following reason: <br> {0},Pracovnú objednávku nie je možné vytvoriť z nasledujúceho dôvodu:<br> {0},
Add items in the Item Locations table,Pridajte položky do tabuľky Umiestnenia položiek,
Update Current Stock,Aktualizujte aktuálnu skladovú zásobu,
"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Ponechať vzorku je založené na dávke. Ak chcete uchovať vzorku položky, začiarknite políčko Má dávku č",
Empty,Prázdny,
Currently no stock available in any warehouse,Momentálne nie sú na sklade k dispozícii žiadne skladové zásoby,
BOM Qty,Kusovník kusov,
Time logs are required for {0} {1},Pre {0} {1} sú povinné časové záznamy,
Total Completed Qty,Celkom dokončené množstvo,
Qty to Manufacture,Množství K výrobě,
Social Media Campaigns,Kampane na sociálnych sieťach,
From Date can not be greater than To Date,Od dátumu nemôže byť väčšie ako Od dátumu,
Please set a Customer linked to the Patient,Nastavte zákazníka prepojeného s pacientom,
Customer Not Found,Zákazník sa nenašiel,
Please Configure Clinical Procedure Consumable Item in ,Nakonfigurujte spotrebnú položku klinického postupu v systéme Windows,
Missing Configuration,Chýba konfigurácia,
Out Patient Consulting Charge Item,Zariadenie pre poplatok za konzultáciu pacienta,
Inpatient Visit Charge Item,Položka poplatku za hospitalizáciu,
OP Consulting Charge,OP Poradenstvo Charge,
Inpatient Visit Charge,Poplatok za návštevu v nemocnici,
Appointment Status,Stav schôdzky,
Test: ,Test:,
Collection Details: ,Podrobnosti zbierky:,
{0} out of {1},{0} z {1},
Select Therapy Type,Vyberte typ terapie,
{0} sessions completed,Dokončené relácie: {0},
{0} session completed,Relácia {0} je dokončená,
 out of {0},z {0},
Therapy Sessions,Terapeutické sedenia,
Add Exercise Step,Pridajte cvičebný krok,
Edit Exercise Step,Upravte krok cvičenia,
Patient Appointments,Termíny pacientov,
Item with Item Code {0} already exists,Položka s kódom položky {0} už existuje,
Registration Fee cannot be negative or zero,Registračný poplatok nemôže byť záporný ani nulový,
Configure a service Item for {0},Konfigurácia servisnej položky pre {0},
Temperature: ,Teplota:,
Pulse: ,Impulz:,
Respiratory Rate: ,Dychová frekvencia:,
BP: ,BP:,
BMI: ,BMI:,
Note: ,Poznámka:,
Check Availability,Skontrolovať dostupnosť,
Please select Patient first,Najskôr vyberte pacienta,
Please select a Mode of Payment first,Najskôr vyberte spôsob platby,
Please set the Paid Amount first,Najskôr nastavte zaplatenú sumu,
Not Therapies Prescribed,Nie sú predpísané terapie,
There are no Therapies prescribed for Patient {0},Pre pacienta {0} nie sú predpísané žiadne terapie.,
Appointment date and Healthcare Practitioner are Mandatory,Dátum menovania a pracovník zdravotnej starostlivosti sú povinné,
No Prescribed Procedures found for the selected Patient,Pre vybraného pacienta sa nenašli žiadne predpísané procedúry,
Please select a Patient first,Najskôr vyberte pacienta,
There are no procedure prescribed for ,Nie je predpísaný žiadny postup,
Prescribed Therapies,Predpísané terapie,
Appointment overlaps with ,Vymenovanie sa prekrýva s,
{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,{0} má naplánovaný schôdzku s {1} na {2} s trvaním {3} minút.,
Appointments Overlapping,Prekrývajúce sa schôdzky,
Consulting Charges: {0},Poplatky za konzultáciu: {0},
Appointment Cancelled. Please review and cancel the invoice {0},Vymenovanie bolo zrušené. Skontrolujte a zrušte faktúru {0},
Appointment Cancelled.,Vymenovanie bolo zrušené.,
Fee Validity {0} updated.,Platnosť poplatku {0} aktualizovaná.,
Practitioner Schedule Not Found,Rozvrh lekára sa nenašiel,
{0} is on a Half day Leave on {1},{0} má poldennú dovolenku od {1},
{0} is on Leave on {1},{0} je ponechané na dovolenku {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner,{0} nemá plán zdravotníka. Pridajte to do sekcie Healthcare Practitioner,
Healthcare Service Units,Jednotky zdravotnej starostlivosti,
Complete and Consume,Vyplňte a spotrebujte,
Complete {0} and Consume Stock?,Dokončiť {0} a spotrebovať zásoby?,
Complete {0}?,Dokončiť {0}?,
Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Množstvo skladu na začatie postupu nie je k dispozícii v sklade {0}. Chcete zaznamenať skladovú položku?,
{0} as on {1},{0} ako dňa {1},
Clinical Procedure ({0}):,Klinický postup ({0}):,
Please set Customer in Patient {0},Nastavte zákazníka na pacienta {0},
Item {0} is not active,Položka {0} nie je aktívna,
Therapy Plan {0} created successfully.,Terapeutický plán {0} bol úspešne vytvorený.,
Symptoms: ,Príznaky:,
No Symptoms,Žiadne príznaky,
Diagnosis: ,Diagnóza:,
No Diagnosis,Žiadna diagnóza,
Drug(s) Prescribed.,Predpísané lieky.,
Test(s) Prescribed.,Predpísané testy.,
Procedure(s) Prescribed.,Predpísaný postup.,
Counts Completed: {0},Počet dokončených: {0},
Patient Assessment,Hodnotenie pacienta,
Assessments,Hodnotenia,
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ázov účtu,
Inter Company Account,Inter firemný úč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,Spoplatniteľné,
Rate at which this tax is applied,"Sadzba, pri ktorej sa použije táto 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,Zostatok musí byť,
Lft,Lft,
Rgt,Rgt,
Old Parent,Staré nadřazené,
Include in gross,Zahrnúť do brutto,
Auditor,Auditor,
Accounting Dimension,Účtovná dimenzia,
Dimension Name,Názov dimenzie,
Dimension Defaults,Predvolené rozmery,
Accounting Dimension Detail,Detail účtovnej dimenzie,
Default Dimension,Predvolená dimenzia,
Mandatory For Balance Sheet,Povinné pre súvahu,
Mandatory For Profit and Loss Account,Povinné pre účet ziskov a strát,
Accounting Period,Účtovného obdobia,
Period Name,Názov obdobia,
Closed Documents,Uzavreté dokumenty,
Accounts Settings,Nastavenie účtu,
Settings for Accounts,Nastavenie Účtovníctva,
Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob,
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čite kategóriu dane z adresy,
Over Billing Allowance (%),Príplatok za fakturáciu (%),
Credit Controller,Credit Controller,
Check Supplier Invoice Number Uniqueness,"Skontrolujte, či dodávateľské faktúry Počet Jedinečnosť",
Make Payment via Journal Entry,Vykonať platbu cez Journal Entry,
Unlink Payment on Cancellation of Invoice,Odpojiť Platba o zrušení faktúry,
Book Asset Depreciation Entry Automatically,Automatické odpisovanie majetku v účtovnej závierke,
Automatically Add Taxes and Charges from Item Tax Template,Automaticky pridávať dane a poplatky zo šablóny dane z položiek,
Automatically Fetch Payment Terms,Automaticky načítať platobné podmienky,
Show Payment Schedule in Print,Zobraziť plán platieb v časti Tlač,
Currency Exchange Settings,Nastavenia výmeny meny,
Allow Stale Exchange Rates,Povoliť stale kurzy výmeny,
Stale Days,Stale dni,
Report Settings,Nastavenia prehľadov,
Use Custom Cash Flow Format,Použiť formát vlastného toku peňazí,
Allowed To Transact With,Povolené na transakciu 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,Konfigurácia importu údajov,
Bank Transaction Mapping,Mapovanie bankových transakcií,
Plaid Access Token,Plaid Access Token,
Company Account,Firemný účet,
Account Subtype,Podtyp účtu,
Is Default Account,Je predvolený účet,
Is Company Account,Je firemný účet,
Party Details,Party Podrobnosti,
Account Details,Údaje o účtu,
IBAN,IBAN,
Bank Account No,Číslo bankového účtu,
Integration Details,Podrobnosti o integrácii,
Integration ID,Integračné ID,
Last Integration Date,Dátum poslednej integrácie,
Change this date manually to setup the next synchronization start date,Tento dátum zmeňte manuálne a nastavte nasledujúci dátum začatia synchronizácie,
Mask,maskovať,
Bank Account Subtype,Podtyp bankového účtu,
Bank Account Type,Typ bankového účtu,
Bank Guarantee,Banková záruka,
Bank Guarantee Type,Typ bankovej záruky,
Receiving,Príjem,
Providing,ak,
Reference Document Name,Názov referenčného dokumentu,
Validity in Days,Platnosť v dňoch,
Bank Account Info,Informácie o bankovom účte,
Clauses and Conditions,Doložky a podmienky,
Other Details,Ostatné detaily,
Bank Guarantee Number,Číslo bankovej záruky,
Name of Beneficiary,Názov príjemcu,
Margin Money,Margin Money,
Charges Incurred,Poplatky vzniknuté,
Fixed Deposit Number,Číslo s pevným vkladom,
Account Currency,Mena účtu,
Select the Bank Account to reconcile.,"Vyberte bankový účet, ktorý chcete zladiť.",
Include Reconciled Entries,Zahrnout odsouhlasené zápisy,
Get Payment Entries,Získať Platobné položky,
Payment Entries,platobné Príspevky,
Update Clearance Date,Aktualizace Výprodej Datum,
Bank Reconciliation Detail,Detail bankového odsúhlasenia,
Cheque Number,Šek číslo,
Cheque Date,Šek Datum,
Statement Header Mapping,Hlásenie hlavičky výkazu,
Statement Headers,Hlavičky vyhlásení,
Transaction Data Mapping,Mapovanie dát transakcií,
Mapped Items,Mapované položky,
Bank Statement Settings Item,Položka Nastavenia bankového výpisu,
Mapped Header,Zmapovaná hlavička,
Bank Header,Záhlavie banky,
Bank Statement Transaction Entry,Výpis transakcie z bankového výpisu,
Bank Transaction Entries,Položky bankových transakcií,
New Transactions,Nové transakcie,
Match Transaction to Invoices,Prebieha transakcia so faktúrami,
Create New Payment/Journal Entry,Vytvorte novú položku Platba / denník,
Submit/Reconcile Payments,Odoslať / Zosúladiť platby,
Matching Invoices,Zodpovedajúce faktúry,
Payment Invoice Items,Položky faktúry platby,
Reconciled Transactions,Zosúladené transakcie,
Bank Statement Transaction Invoice Item,Položka faktúry transakcie na bankový účet,
Payment Description,Popis platby,
Invoice Date,Dátum fakturácie,
invoice,faktúra,
Bank Statement Transaction Payment Item,Platobná položka transakcie v banke,
outstanding_amount,nesplatená suma,
Payment Reference,Označenie platby,
Bank Statement Transaction Settings Item,Položka nastavenia transakcie bankového výpisu,
Bank Data,Bankové údaje,
Mapped Data Type,Mapovaný typ údajov,
Mapped Data,Mapované údaje,
Bank Transaction,Bankové transakcie,
ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-,
Transaction ID,ID transakcie,
Unallocated Amount,nepridelené Suma,
Field in Bank Transaction,Pole v bankovej transakcii,
Column in Bank File,Stĺpec v bankovom súbore,
Bank Transaction Payments,Platby bankových transakcií,
Control Action,Kontrolná akcia,
Applicable on Material Request,Platí pre materiálové požiadavky,
Action if Annual Budget Exceeded on MR,Opatrenie v prípade prekročenia ročného rozpočtu na MR,
Warn,Varovat,
Ignore,Ignorovat,
Action if Accumulated Monthly Budget Exceeded on MR,Ak je akumulovaný mesačný rozpočet prekročen na MR,
Applicable on Purchase Order,Platí pre nákupnú objednávku,
Action if Annual Budget Exceeded on PO,"Opatrenie, ak bol prekročený ročný rozpočet na PO",
Action if Accumulated Monthly Budget Exceeded on PO,Ak akumulovaný mesačný rozpočet prekročil PO,
Applicable on booking actual expenses,Platí pri rezervácii skutočných výdavkov,
Action if Annual Budget Exceeded on Actual,"Opatrenie, ak bol ročný rozpočet prekročený na skutočný",
Action if Accumulated Monthly Budget Exceeded on Actual,Ak akumulovaný mesačný rozpočet prekročil skutočný,
Budget Accounts,rozpočtové účty,
Budget Account,rozpočet účtu,
Budget Amount,rozpočet Suma,
C-Form,C-Form,
ACC-CF-.YYYY.-,ACC-CF-.YYYY.-,
C-Form No,C-Form No,
Received Date,Dátum prijatia,
Quarter,Čtvrtletí,
I,ja,
II,II,
III,III,
IV,IV,
C-Form Invoice Detail,C-Form Faktura Detail,
Invoice No,Faktúra č.,
Cash Flow Mapper,Mapovač hotovostných tokov,
Section Name,Názov sekcie,
Section Header,Záhlavie sekcie,
Section Leader,Vedúci sekcie,
e.g Adjustments for:,napr. Úpravy pre:,
Section Subtotal,Oddiel Medzisúčet,
Section Footer,Päta sekcie,
Cash Flow Mapping,Mapovanie peňažných tokov,
Select Maximum Of 1,Vyberte možnosť Maximálne 1,
Is Finance Cost,Sú finančné náklady,
Is Working Capital,Je pracovný kapitál,
Is Finance Cost Adjustment,Je úprava finančných nákladov,
Is Income Tax Liability,Zodpovednosť za dane z príjmov,
Is Income Tax Expense,Daň z príjmov,
Cash Flow Mapping Accounts,Zúčtovanie peňažných tokov,
account,Účet,
Cash Flow Mapping Template,Šablóna mapovania peňažných tokov,
Cash Flow Mapping Template Details,Podrobné informácie o šablóne mapovania peňažných tokov,
POS-CLO-,POS-CLO-,
Custody,starostlivosť,
Net Amount,Čistá suma,
Cashier Closing Payments,Pokladničné platby,
Chart of Accounts Importer,Graf účtov dovozcov,
Import Chart of Accounts from a csv file,Importujte účtovnú schému zo súboru CSV,
Attach custom Chart of Accounts file,Pripojte vlastný súbor účtovných osnov,
Chart Preview,Ukážka grafu,
Chart Tree,Strom stromu,
Cheque Print Template,Šek šablóny tlače,
Has Print Format,Má formát tlače,
Primary Settings,primárnej Nastavenie,
Cheque Size,šek Veľkosť,
Regular,pravidelný,
Starting position from top edge,Východisková poloha od horného okraja,
Cheque Width,šek Šírka,
Cheque Height,šek Výška,
Scanned Cheque,skenovaných Šek,
Is Account Payable,Je účtu splatný,
Distance from top edge,Vzdialenosť od horného okraja,
Distance from left edge,Vzdialenosť od ľavého okraja,
Message to show,správa ukázať,
Date Settings,Nastavenia dátumu,
Starting location from left edge,Počnúc umiestnenie od ľavého okraja,
Payer Settings,nastavenie platcu,
Width of amount in word,Šírka sumy v slove,
Line spacing for amount in words,riadkovanie za čiastku v slovách,
Amount In Figure,Na obrázku vyššie,
Signatory Position,signatár Position,
Closed Document,Uzavretý 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,Meno nákladového strediska,
Parent Cost Center,Nadřazené Nákladové středisko,
lft,LFT,
rgt,Rgt,
Coupon Code,kód kupónu,
Coupon Name,Názov kupónu,
"e.g. ""Summer Holiday 2019 Offer 20""","napr. „Letná dovolenka 2019, ponuka 20“",
Coupon Type,Typ kupónu,
Promotional,propagačné,
Gift Card,Darčeková karta,
unique e.g. SAVE20  To be used to get discount,"jedinečný, napr. SAVE20 Používa sa na získanie zľavy",
Validity and Usage,Platnosť a použitie,
Valid From,Platnosť od,
Valid Upto,Platné do,
Maximum Use,Maximálne použitie,
Used,použité,
Coupon Description,Popis kupónu,
Discounted Invoice,Zľavnená faktúra,
Debit to,Debet na,
Exchange Rate Revaluation,Prehodnotenie výmenného kurzu,
Get Entries,Získajte záznamy,
Exchange Rate Revaluation Account,Účet z precenenia výmenného kurzu,
Total Gain/Loss,Celkový zisk / strata,
Balance In Account Currency,Zostatok v mene účtu,
Current Exchange Rate,Aktuálny kurz,
Balance In Base Currency,Zostatok v základnej mene,
New Exchange Rate,Nový kurz,
New Balance In Base Currency,Nový zostatok v základnej mene,
Gain/Loss,Zisk / strata,
**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiškálny rok ** predstavuje finančný rok. Všetky účtovné záznamy a ďalšie významné transakcie sú sledované pod ** Fiškálny rok **.,
Year Name,Meno roku,
"For e.g. 2012, 2012-13","Pro např 2012, 2012-13",
Year Start Date,Dátom začiatku roka,
Year End Date,Dátum konca roka,
Companies,Spoločnosti,
Auto Created,Automatické vytvorenie,
Stock User,Používateľ skladu,
Fiscal Year Company,Spoločnosť pre fiškálny rok,
Debit Amount,Debetné Suma,
Credit Amount,Výška úveru,
Debit Amount in Account Currency,Debetné Čiastka v mene účtu,
Credit Amount in Account Currency,Kreditné Čiastka v mene účtu,
Voucher Detail No,Voucher Detail No,
Is Opening,Se otevírá,
Is Advance,Je Zálohová,
To Rename,Premenovať,
GST Account,Účet GST,
CGST Account,CGST účet,
SGST Account,Účet SGST,
IGST Account,Účet IGST,
CESS Account,Účet CESS,
Loan Start Date,Dátum začiatku pôžičky,
Loan Period (Days),Úverové obdobie (dni),
Loan End Date,Dátum ukončenia pôžičky,
Bank Charges,Bankové poplatky,
Short Term Loan Account,Krátkodobý úverový účet,
Bank Charges Account,Účet bankových poplatkov,
Accounts Receivable Credit Account,Úverový účet pohľadávok,
Accounts Receivable Discounted Account,Zľavový účet pohľadávok,
Accounts Receivable Unpaid Account,Nesplatené účty pohľadávok,
Item Tax Template,Šablóna dane z položky,
Tax Rates,Daňové sadzby,
Item Tax Template Detail,Detail šablóny dane z položky,
Entry Type,Entry Type,
Inter Company Journal Entry,Inter company Journal Entry,
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,Otvárací údaj,
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á suma Mena,
Total Amount in Words,Celková částka slovy,
Remark,Poznámka,
Paid Loan,Platené pôžičky,
Inter Company Journal Entry Reference,Inter Company Entry Reference,
Write Off Based On,Odepsat založené na,
Get Outstanding Invoices,Získat neuhrazených faktur,
Write Off Amount,Odpísať čiastku,
Printing Settings,Nastavenie tlače,
Pay To / Recd From,Platit K / Recd Z,
Payment Order,Platobný príkaz,
Subscription Section,Sekcia odberu,
Journal Entry Account,Zápis do deníku Účet,
Account Balance,Zůstatek na účtu,
Party Balance,Balance Party,
Accounting Dimensions,Účtovné dimenzie,
If Income or Expense,Pokud je výnos nebo náklad,
Exchange Rate,Výmenný kurz,
Debit in Company Currency,Debetnej v spoločnosti Mena,
Credit in Company Currency,Úverové spoločnosti v mene,
Payroll Entry,Mzdový účet,
Employee Advance,Zamestnanec Advance,
Reference Due Date,Referenčný dátum splatnosti,
Loyalty Program Tier,Vernostný programový stupeň,
Redeem Against,Späť na začiatok,
Expiry Date,Datum vypršení platnosti,
Loyalty Point Entry Redemption,Vrátenie bodu vkladu,
Redemption Date,Dátum vykúpenia,
Redeemed Points,Vymožené body,
Loyalty Program Name,Názov vernostného programu,
Loyalty Program Type,Typ vernostného programu,
Single Tier Program,Jednoduchý program,
Multiple Tier Program,Viacvrstvový program,
Customer Territory,Oblasť zákazníka,
Auto Opt In (For all customers),Automatická registrácia (pre všetkých zákazníkov),
Collection Tier,Zbierka Tier,
Collection Rules,Pravidlá zberu,
Redemption,vykúpenie,
Conversion Factor,Konverzný koeficient,
1 Loyalty Points = How much base currency?,1 Vernostné body = Koľko základnej meny?,
Expiry Duration (in days),Trvanie platnosti (v dňoch),
Help Section,Sekcia pomocníka,
Loyalty Program Help,Nápoveda vernostného programu,
Loyalty Program Collection,Zber vernostného programu,
Tier Name,Názov úrovne,
Minimum Total Spent,Minimálny celkový počet vynaložených prostriedkov,
Collection Factor (=1 LP),Faktor zberu (= 1 LP),
For how much spent = 1 Loyalty Point,Pre koľko strávil = 1 vernostný bod,
Mode of Payment Account,Způsob platby účtu,
Default Account,Východzí účet,
Default account will be automatically updated in POS Invoice when this mode is selected.,"Predvolený účet sa automaticky aktualizuje v POS faktúre, keď je vybratý tento režim.",
**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Mesačný Distribúcia ** umožňuje distribuovať Rozpočet / Target celé mesiace, ak máte sezónnosti vo vašej firme.",
Distribution Name,Názov distribúcie,
Name of the Monthly Distribution,Názov mesačného rozdelenia,
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,Vytvoriť chýbajúcu stranu,
Create missing customer or supplier.,Vytvorte chýbajúceho zákazníka alebo dodávateľa.,
Opening Invoice Creation Tool Item,Otvorenie položky nástroja na vytvorenie faktúry,
Temporary Opening Account,Dočasný úvodný účet,
Party Account,Party účtu,
Type of Payment,typ platby,
ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
Receive,Prijať,
Internal Transfer,vnútorné Prevod,
Payment Order Status,Stav platobného príkazu,
Payment Ordered,Platba objednaná,
Payment From / To,Platba od / do,
Company Bank Account,Firemný bankový účet,
Party Bank Account,Bankový účet strany,
Account Paid From,Účet sú platení z prostriedkov,
Account Paid To,účet Venovaná,
Paid Amount (Company Currency),Zaplatená suma (Company meny),
Received Amount,Prijatá suma,
Received Amount (Company Currency),Prijatá suma (v peňažnej mene firmy),
Get Outstanding Invoice,Získajte vynikajúcu faktúru,
Payment References,platobné Referencie,
Writeoff,odpísanie,
Total Allocated Amount,Celková alokovaná suma,
Total Allocated Amount (Company Currency),Celková alokovaná suma (Company mena),
Set Exchange Gain / Loss,Set Exchange zisk / strata,
Difference Amount (Company Currency),Rozdiel Suma (Company mena),
Write Off Difference Amount,Odpísať Difference Suma,
Deductions or Loss,Odpočty alebo strata,
Payment Deductions or Loss,Platobné zrážky alebo strata,
Cheque/Reference Date,Šek / Referenčný dátum,
Payment Entry Deduction,Platba Vstup dedukcie,
Payment Entry Reference,Platba Vstup referencie,
Allocated,Přidělené,
Payment Gateway Account,Platobná brána účet,
Payment Account,Platební účet,
Default Payment Request Message,Východzí Platba Request Message,
PMO-,PMO-,
Payment Order Type,Typ platobného príkazu,
Payment Order Reference,Odkaz na platobný príkaz,
Bank Account Details,Podrobnosti o bankovom účte,
Payment Reconciliation,Platba Odsouhlasení,
Receivable / Payable Account,Účet pohľadávok/záväzkov,
Bank / Cash Account,Bankový / Peňažný účet,
From Invoice Date,Z faktúry Dátum,
To Invoice Date,Ak chcete dátumu vystavenia faktúry,
Minimum Invoice Amount,Minimálna suma faktúry,
Maximum Invoice Amount,Maximálna suma faktúry,
System will fetch all the entries if limit value is zero.,"Ak je limitná hodnota nula, systém načíta všetky záznamy.",
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 faktúry,
Payment Reconciliation Payment,Platba Odsouhlasení Platba,
Reference Row,referenčnej Row,
Allocated amount,Přidělené sumy,
Payment Request Type,Typ žiadosti o platbu,
Outward,von,
Inward,dovnútra,
ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-,
Transaction Details,detaily transakcie,
Amount in customer's currency,Čiastka v mene zákazníka,
Is a Subscription,Je predplatné,
Transaction Currency,transakčné mena,
Subscription Plans,Predplatné,
SWIFT Number,SWIFT číslo,
Recipient Message And Payment Details,Príjemca správy a platobných informácií,
Make Sales Invoice,Vytvoriť faktúru,
Mute Email,Stíšiť email,
payment_url,payment_url,
Payment Gateway Details,Platobná brána Podrobnosti,
Payment Schedule,Rozvrh platieb,
Invoice Portion,Časť faktúry,
Payment Amount,Částka platby,
Payment Term Name,Názov platby,
Due Date Based On,Dátum splatnosti založený na,
Day(s) after invoice date,Deň (dni) po dátume fakturácie,
Day(s) after the end of the invoice month,Deň (dni) po skončení fakturačného mesiaca,
Month(s) after the end of the invoice month,Mesiac (mesiace) po skončení mesiaca faktúry,
Credit Days,Úverové dni,
Credit Months,Kreditné mesiace,
Allocate Payment Based On Payment Terms,Prideľte platbu na základe platobných podmienok,
"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Ak je toto začiarkavacie políčko začiarknuté, vyplatená suma sa rozdelí a pridelí podľa čiastok v rozvrhu platieb voči každému platobnému termínu",
Payment Terms Template Detail,Podrobné informácie o podmienkach platieb,
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áväzkom alebo vlastným imaním, v ktorom budú Zisk / strata rezervovať",
POS Customer Group,POS Customer Group,
POS Field,Pole POS,
POS Item Group,POS položky Group,
Company Address,Adresa spoločnosti,
Update Stock,Aktualizace skladem,
Ignore Pricing Rule,Ignorovat Ceny pravidlo,
Applicable for Users,Platí pre používateľov,
Sales Invoice Payment,Platba na odoslanú faktúru,
Item Groups,Skupiny položiek,
Only show Items from these Item Groups,Zobrazovať iba položky z týchto skupín položiek,
Customer Groups,skupiny zákazníkov,
Only show Customer of these Customer Groups,Zobraziť iba zákazníka z týchto skupín zákazníkov,
Write Off Account,Odepsat účet,
Write Off Cost Center,Odepsat nákladové středisko,
Account for Change Amount,Účet pre zmenu Suma,
Taxes and Charges,Daně a poplatky,
Apply Discount On,Použiť Zľava na,
POS Profile User,Používateľ profilu POS,
Apply On,Aplikujte na,
Price or Product Discount,Cena alebo zľava produktu,
Apply Rule On Item Code,Použiť pravidlo pre kód položky,
Apply Rule On Item Group,Použiť pravidlo pre skupinu položiek,
Apply Rule On Brand,Použiť pravidlo na značku,
Mixed Conditions,Zmiešané podmienky,
Conditions will be applied on all the selected items combined. ,Na všetky vybrané položky sa použijú podmienky spolu.,
Is Cumulative,Je kumulatívne,
Coupon Code Based,Na základe kódu kupónu,
Discount on Other Item,Zľava na inú položku,
Apply Rule On Other,Použiť pravidlo na iné,
Party Information,Informácie o večierku,
Quantity and Amount,Množstvo a množstvo,
Min Qty,Min Množství,
Max Qty,Max Množství,
Min Amt,Min. Amt,
Max Amt,Max Amt,
Period Settings,Nastavenie obdobia,
Margin,Marža,
Margin Type,margin Type,
Margin Rate or Amount,Marža sadzbou alebo pevnou sumou,
Price Discount Scheme,Schéma zníženia ceny,
Rate or Discount,Sadzba alebo zľava,
Discount Percentage,Zľava v percentách,
Discount Amount,Čiastka zľavy,
For Price List,Pre Cenník,
Product Discount Scheme,Schéma zľavy na výrobok,
Same Item,Rovnaká položka,
Free Item,Zadarmo položka,
Threshold for Suggestion,Prahová hodnota návrhu,
System will notify to increase or decrease quantity or amount ,Systém vás upozorní na zvýšenie alebo zníženie množstva alebo množstva,
"Higher the number, higher the priority","Vyšší číslo, vyšší priorita",
Apply Multiple Pricing Rules,Použite pravidlá viacerých cien,
Apply Discount on Rate,Použite zľavu na sadzbu,
Validate Applied Rule,Potvrdiť použité pravidlo,
Rule Description,Popis pravidla,
Pricing Rule Help,Ceny Pravidlo Help,
Promotional Scheme Id,ID propagačnej schémy,
Promotional Scheme,Propagačná schéma,
Pricing Rule Brand,Značka pravidla stanovovania cien,
Pricing Rule Detail,Podrobnosti pravidla o cenách,
Child Docname,Názov dieťaťa,
Rule Applied,Platí pravidlo,
Pricing Rule Item Code,Kód položky pravidla pravidla,
Pricing Rule Item Group,Skupina položiek cenových pravidiel,
Price Discount Slabs,Cenové zľavy,
Promotional Scheme Price Discount,Zľava na propagačnú schému,
Product Discount Slabs,Dosky na zľavu produktov,
Promotional Scheme Product Discount,Zľava na propagačnú schému,
Min Amount,Min. Suma,
Max Amount,Maximálna suma,
Discount Type,Typ zľavy,
ACC-PINV-.YYYY.-,ACC-pInv-.YYYY.-,
Tax Withholding Category,Daňová kategória,
Edit Posting Date and Time,Úpraviť dátum a čas vzniku,
Is Paid,sa vypláca,
Is Return (Debit Note),Je Return (Debit Note),
Apply Tax Withholding Amount,Použiť čiastku zrážkovej dane,
Accounting Dimensions ,Účtovné dimenzie,
Supplier Invoice Details,Detaily dodávateľskej faktúry,
Supplier Invoice Date,Dátum dodávateľskej faktúry,
Return Against Purchase Invoice,Návrat proti nákupnej faktúry,
Select Supplier Address,Vybrať Dodávateľ Address,
Contact Person,Kontaktná osoba,
Select Shipping Address,Zvoľte adresu pre dodanie,
Currency and Price List,Cenník a mena,
Price List Currency,Mena cenníka,
Price List Exchange Rate,Katalogová cena Exchange Rate,
Set Accepted Warehouse,Nastaviť prijatý 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,Suroviny dodané,
Supplier Warehouse,Dodavatel Warehouse,
Pricing Rules,Pravidlá stanovovania cien,
Supplied Items,Dodávané položky,
Total (Company Currency),Total (Company meny),
Net Total (Company Currency),Net Total (Company Měna),
Total Net Weight,Celková čistá hmotnosť,
Shipping Rule,Prepravné pravidlo,
Purchase Taxes and Charges Template,Kúpte Dane a poplatky šablóny,
Purchase Taxes and Charges,Nákup Daně a poplatky,
Tax Breakup,Daňové rozdelenie,
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),Spolu dane a poplatky (v peňažnej mene firmy),
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,Ďalšie zľavy,
Apply Additional Discount On,Použiť dodatočné Zľava na,
Additional Discount Amount (Company Currency),Dodatočná zľava Suma (Mena Company),
Additional Discount Percentage,Dodatočné percento zľavy,
Additional Discount Amount,Dodatočná suma zľavy,
Grand Total (Company Currency),Celkový součet (Měna společnosti),
Rounding Adjustment (Company Currency),Úprava zaokrúhľovania (mena spoločnosti),
Rounded Total (Company Currency),Zaoblený Total (Company Měna),
In Words (Company Currency),Slovy (měna společnosti),
Rounding Adjustment,Nastavenie zaokrúhľovania,
In Words,Slovy,
Total Advance,Total Advance,
Disable Rounded Total,Vypnúť zaokrúhlovanie sumy spolu,
Cash/Bank Account,Hotovostný / Bankový účet,
Write Off Amount (Company Currency),Odpísať Suma (Company meny),
Set Advances and Allocate (FIFO),Nastaviť preddavky a alokovať (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 rovnaké položky,
Print Language,Jazyk tlače,
"Once set, this invoice will be on hold till the set date",Po nastavení bude táto faktúra pozastavená až do stanoveného dátumu,
Credit To,Kredit:,
Party Account Currency,Party Mena účtu,
Against Expense Account,Proti výdajového účtu,
Inter Company Invoice Reference,Interná referencia faktúry spoločnosti,
Is Internal Supplier,Je interný dodávateľ,
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,Aktualizovať referenciu automatického opakovania,
Purchase Invoice Advance,Záloha přijaté faktury,
Purchase Invoice Item,Položka přijaté faktury,
Quantity and Rate,Množstvo a Sadzba,
Received Qty,Prijaté množstvo,
Accepted Qty,Prijaté množstvo,
Rejected Qty,zamietnutá Množstvo,
UOM Conversion Factor,Faktor konverzie MJ,
Discount on Price List Rate (%),Zľava z cenníkovej ceny (%),
Price List Rate (Company Currency),Cenníková cena (mena firmy),
Rate ,Sadzba,
Rate (Company Currency),Sadzba (V mene spoločnosti),
Amount (Company Currency),Částka (Měna Společnosti),
Is Free Item,Je bezplatná položka,
Net Rate,Čistá miera,
Net Rate (Company Currency),Čistý Rate (Company meny),
Net Amount (Company Currency),Čistá suma (Company Mena),
Item Tax Amount Included in Value,Čiastka dane z položky zahrnutá v hodnote,
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,Zamítnuto Serial No,
Expense Head,Náklady Head,
Is Fixed Asset,Je dlhodobého majetku,
Asset Location,Umiestnenie majetku,
Deferred Expense,Odložené náklady,
Deferred Expense Account,Odložený nákladový účet,
Service Stop Date,Dátum ukončenia servisu,
Enable Deferred Expense,Povolenie odloženého výdavku,
Service Start Date,Dátum začiatku služby,
Service End Date,Dátum ukončenia služby,
Allow Zero Valuation Rate,Povoliť sadzbu nulového oceňovania,
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 nákupnej objednávky,
Purchase Receipt Detail,Detail dokladu o kúpe,
Item Weight Details,Podrobnosti o položke hmotnosti,
Weight Per Unit,Hmotnosť na jednotku,
Total Weight,Celková váha,
Weight UOM,Hmotnostná MJ,
Page Break,Zalomenie 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,Odpočítať,
On Previous Row Amount,Na předchozí řady Částka,
On Previous Row Total,Na předchozí řady Celkem,
On Item Quantity,Na množstvo 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 Múdra daň - podrobnosti,
"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ň.",
ACC-SINV-.YYYY.-,ACC-Sinv-.YYYY.-,
Include Payment (POS),Zahŕňajú 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 predajnej faktúre,
Update Billed Amount in Sales Order,Aktualizovať faktúrovanú čiastku v objednávke predaja,
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,Adresa zákazníka,
Shipping Address Name,Názov dodacej adresy,
Company Address Name,Názov adresy spoločnosti,
Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je zákazník měny převeden na zákazníka základní měny",
Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny",
Set Source Warehouse,Nastaviť zdrojový sklad,
Packing List,Zoznam balenia,
Packed Items,Zabalené položky,
Product Bundle Help,Product Bundle Help,
Time Sheet List,Zoznam časových rozvrhov,
Time Sheets,Časové rozvrhy,
Total Billing Amount,Celková suma fakturácie,
Sales Taxes and Charges Template,Predaj Dane a poplatky šablóny,
Sales Taxes and Charges,Dane z predaja a poplatky,
Loyalty Points Redemption,Vernostné body Vykúpenie,
Redeem Loyalty Points,Uplatnite vernostné body,
Redemption Account,Účet spätného odkúpenia,
Redemption Cost Center,Centrum výdavkových nákladov,
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 prideľovať preddavky (FIFO),
Get Advances Received,Získat přijaté zálohy,
Base Change Amount (Company Currency),Základňa Zmena Suma (Company mena),
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 zľava,
Unpaid and Discounted,Nezaplatené a diskontované,
Overdue and Discounted,Omeškanie a zľava,
Accounting Details,Účtovné Podrobnosti,
Debit To,Debetní K,
Is Opening Entry,Je vstupní otvor,
C-Form Applicable,C-Form Použitelné,
Commission Rate (%),Výška provízie (%),
Sales Team1,Sales Team1,
Against Income Account,Proti účet příjmů,
Sales Invoice Advance,Záloha na odoslanej faktúre,
Advance amount,Záloha ve výši,
Sales Invoice Item,Položka odoslanej faktúry,
Customer's Item Code,Zákazníka Kód položky,
Brand Name,Jméno značky,
Qty as per Stock UOM,Množstvo podľa skladovej MJ,
Discount and Margin,Zľava a Margin,
Rate With Margin,Sadzba s maržou,
Discount (%) on Price List Rate with Margin,Zľava (%) na sadzbe cien s maržou,
Rate With Margin (Company Currency),Sadzba s maržou (mena spoločnosti),
Delivered By Supplier,Dodáva sa podľa dodávateľa,
Deferred Revenue,Výnosy budúcich období,
Deferred Revenue Account,Účet odloženého výnosu,
Enable Deferred Revenue,Povoliť odložené výnosy,
Stock Details,Detaily zásob,
Customer Warehouse (Optional),Zákazník Warehouse (voliteľne),
Available Batch Qty at Warehouse,K dispozícii dávky Množstvo v sklade,
Available Qty at Warehouse,Množství k dispozici na skladu,
Delivery Note Item,Delivery Note Item,
Base Amount (Company Currency),Základná suma (Company Currency),
Sales Invoice Timesheet,Predajná faktúry časový rozvrh,
Time Sheet,Časový rozvrh,
Billing Hours,billing Hodiny,
Timesheet Detail,Detail pracovného výkazu,
Tax Amount After Discount Amount (Company Currency),Suma dane po zľave Suma (Company meny),
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 vypočítané v transakcii.,
From No,Od č,
To No,Nie,
Is Company,Je spoločnosť,
Current State,Aktuálny stav,
Purchased,zakúpené,
From Shareholder,Od akcionára,
From Folio No,Z Folio č,
To Shareholder,Akcionárovi,
To Folio No,Do priečinka č,
Equity/Liability Account,Účet vlastného imania / zodpovednosti,
Asset Account,Asset Account,
(including),(počítajúc do toho),
ACC-SH-.YYYY.-,ACC-SH-.YYYY.-,
Folio no.,Folio č.,
Address and Contacts,Adresa a kontakty,
Contact List,Zoznam kontaktov,
Hidden list maintaining the list of contacts linked to Shareholder,Skrytý zoznam vedúci zoznam kontaktov prepojených s akcionárom,
Specify conditions to calculate shipping amount,Stanovte podmienky na výpočet výšky prepravných nákladov,
Shipping Rule Label,Přepravní Pravidlo Label,
example: Next Day Shipping,Příklad: Next Day Shipping,
Shipping Rule Type,Typ pravidla odoslania,
Shipping Account,Dodací účet,
Calculate Based On,Vypočítať na základe,
Fixed,fixné,
Net Weight,Hmotnost,
Shipping Amount,Prepravovaná čiastka,
Shipping Rule Conditions,Přepravní Článek Podmínky,
Restrict to Countries,Obmedziť na krajiny,
Valid for Countries,"Platí pre krajiny,",
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,Prepravné Pravidlo Krajina,
Subscription Period,Obdobie upisovania,
Subscription Start Date,Dátum začiatku odberu,
Cancelation Date,Dátum zrušenia,
Trial Period Start Date,Dátum začiatku skúšobného obdobia,
Trial Period End Date,Dátum ukončenia skúšobného obdobia,
Current Invoice Start Date,Aktuálny dátum začiatku faktúry,
Current Invoice End Date,Aktuálny dátum ukončenia faktúry,
Days Until Due,Dni až do splatnosti,
Number of days that the subscriber has to pay invoices generated by this subscription,"Počet dní, ktoré musí účastník zaplatiť faktúry generované týmto odberom",
Cancel At End Of Period,Zrušiť na konci obdobia,
Generate Invoice At Beginning Of Period,Generovanie faktúry na začiatku obdobia,
Plans,plány,
Discounts,Zľavy,
Additional DIscount Percentage,Ďalšie zľavy Percento,
Additional DIscount Amount,Dodatočná zľava Suma,
Subscription Invoice,Faktúra odberu,
Subscription Plan,Plán predplatného,
Cost,Náklady,
Billing Interval,Fakturačný interval,
Billing Interval Count,Počet fakturačných intervalov,
"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 intervalov pre intervalové pole, napr. Ak je Interval &quot;Dni&quot; a Interval fakturácie je 3, faktúry sa vygenerujú každých 3 dni",
Payment Plan,Platobný plán,
Subscription Plan Detail,Podrobný popis predplatného,
Plan,plán,
Subscription Settings,Nastavenia odberu,
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í dátumu faktúry pred zrušením predplatného alebo označením predplatného ako nezaplateného,
Prorate,kľúčovanie,
Tax Rule,Daňové Pravidlo,
Tax Type,Typ dane,
Use for Shopping Cart,Použitie pre Košík,
Billing City,Fakturačné mesto,
Billing County,Fakturačný okres,
Billing State,Fakturačný štát,
Billing Zipcode,Fakturačný PSČ,
Billing Country,Fakturačná krajina,
Shipping City,Mesto dodania,
Shipping County,Okres dodania,
Shipping State,Prepravné State,
Shipping Zipcode,Prepravný PSČ,
Shipping Country,Krajina dodania,
Tax Withholding Account,Zrážkový účet,
Tax Withholding Rates,Sadzby zrážkovej dane,
Rates,Sadzby,
Tax Withholding Rate,Sadzba zrážkovej dane,
Single Transaction Threshold,Jednoduchá transakčná prahová hodnota,
Cumulative Transaction Threshold,Kumulatívna hranica transakcií,
Agriculture Analysis Criteria,Kritériá analýzy poľnohospodárstva,
Linked Doctype,Linked Doctype,
Water Analysis,Analýza vody,
Soil Analysis,Analýza pôdy,
Plant Analysis,Analýza rastlín,
Fertilizer,umelé hnojivo,
Soil Texture,Textúra pôdy,
Weather,počasie,
Agriculture Manager,Poľnohospodársky manažér,
Agriculture User,Poľnohospodársky užívateľ,
Agriculture Task,Úloha poľnohospodárstva,
Task Name,Meno Task,
Start Day,Deň začiatku,
End Day,Koniec dňa,
Holiday Management,Správa prázdnin,
Ignore holidays,Ignorovať dovolenku,
Previous Business Day,Predchádzajúci pracovný deň,
Next Business Day,Nasledujúci pracovný deň,
Urgent,Naléhavý,
Crop Name,Názov plodiny,
Scientific Name,Vedecké meno,
"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 definovať všetky úlohy, ktoré je potrebné vykonať pre túto plodinu tu. Denné pole sa používa na uvedenie dňa, kedy je potrebné vykonať úlohu, 1 je prvý deň atď.",
Crop Spacing,Rozdelenie plodín,
Crop Spacing UOM,Rozmiestnenie medzných plôch,
Row Spacing,Rozstup riadkov,
Row Spacing UOM,Rozloženie riadkov UOM,
Perennial,trvalka,
Biennial,dvojročný,
Planting UOM,Výsadba UOM,
Planting Area,Oblasť výsadby,
Yield UOM,Výnos UOM,
Materials Required,Potrebné materiály,
Produced Items,Vyrobené položky,
Produce,vyrobiť,
Byproducts,vedľajšie produkty,
Linked Location,Prepojená poloha,
A link to all the Locations in which the Crop is growing,"Odkaz na všetky lokality, v ktorých rastie plodina",
This will be day 1 of the crop cycle,Toto bude prvý deň cyklu plodín,
ISO 8601 standard,ISO 8601,
Cycle Type,Typ cyklu,
Less than a year,Menej ako rok,
The minimum length between each plant in the field for optimum growth,Minimálna dĺžka medzi jednotlivými rastlinami v teréne pre optimálny rast,
The minimum distance between rows of plants for optimum growth,Minimálna vzdialenosť medzi radmi rastlín pre optimálny rast,
Detected Diseases,Zistené choroby,
List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Zoznam chorôb zistených v teréne. Po výbere bude automaticky pridaný zoznam úloh, ktoré sa budú týkať tejto choroby",
Detected Disease,Zistená choroba,
LInked Analysis,Llnked Analysis,
Disease,choroba,
Tasks Created,Vytvorené úlohy,
Common Name,Spoločný názov,
Treatment Task,Liečebná úloha,
Treatment Period,Liečebné obdobie,
Fertilizer Name,Názov hnojiva,
Density (if liquid),Hustota (ak je kvapalná),
Fertilizer Contents,Obsah hnojiva,
Fertilizer Content,Obsah hnojiva,
Linked Plant Analysis,Analýza prepojených rastlín,
Linked Soil Analysis,Analýza prepojenej pôdy,
Linked Soil Texture,Prepojená pôdna štruktúra,
Collection Datetime,Dátum zberu,
Laboratory Testing Datetime,Laboratórne testovanie,
Result Datetime,Výsledok Datetime,
Plant Analysis Criterias,Kritériá analýzy rastlín,
Plant Analysis Criteria,Kritériá analýzy rastlín,
Minimum Permissible Value,Minimálna prípustná hodnota,
Maximum Permissible Value,Maximálna prí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ériá analýzy pôdy,
Soil Analysis Criteria,Kritériá analýzy pôdy,
Soil Type,Typ pôdy,
Loamy Sand,Loamy Sand,
Sandy Loam,Sandy Loam,
Loam,hlina,
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 (%),Zloženie hliny (%),
Sand Composition (%),Zloženie piesku (%),
Silt Composition (%),Zloženie sklonu (%),
Ternary Plot,Ternary Plot,
Soil Texture Criteria,Kritériá textúry pôdy,
Type of Sample,Typ vzorky,
Container,kontajner,
Origin,pôvod,
Collection Temperature ,Teplota zberu,
Storage Temperature,Teplota skladovania,
Appearance,vzhľad,
Person Responsible,Zodpovedná osoba,
Water Analysis Criteria,Kritériá analýzy vody,
Weather Parameter,Parametre počasia,
ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
Asset Owner,Majiteľ majetku,
Asset Owner Company,Spoločnosť vlastníka aktív,
Custodian,strážca,
Disposal Date,Likvidácia Dátum,
Journal Entry for Scrap,Zápis do denníka do šrotu,
Available-for-use Date,Dátum k dispozícii na použitie,
Calculate Depreciation,Vypočítať odpisy,
Allow Monthly Depreciation,Povoliť mesačné odpisy,
Number of Depreciations Booked,Počet Odpisy rezervované,
Finance Books,Finančné knihy,
Straight Line,Priamka,
Double Declining Balance,double degresívne,
Manual,Manuálny,
Value After Depreciation,Hodnota po odpisoch,
Total Number of Depreciations,Celkový počet Odpisy,
Frequency of Depreciation (Months),Frekvencia odpisy (mesiace),
Next Depreciation Date,Vedľa Odpisy Dátum,
Depreciation Schedule,plán odpisy,
Depreciation Schedules,odpisy Plány,
Insurance details,Podrobnosti o poistení,
Policy number,Číslo politiky,
Insurer,poisťovateľ,
Insured value,Poistná hodnota,
Insurance Start Date,Dátum začatia poistenia,
Insurance End Date,Dátum ukončenia poistenia,
Comprehensive Insurance,Komplexné poistenie,
Maintenance Required,Požadovaná údržba,
Check if Asset requires Preventive Maintenance or Calibration,"Skontrolujte, či si aktívum vyžaduje preventívnu údržbu alebo kalibráciu",
Booked Fixed Asset,Rezervovaný dlhodobý majetok,
Purchase Receipt Amount,Čiastka kúpnej sumy,
Default Finance Book,Predvolená kniha financií,
Quality Manager,Manažér kvality,
Asset Category Name,Asset názov kategórie,
Depreciation Options,Možnosti odpisovania,
Enable Capital Work in Progress Accounting,Povoliť kapitálové účtovníctvo v priebehu,
Finance Book Detail,Detail knihy financií,
Asset Category Account,Asset Kategórie Account,
Fixed Asset Account,Fixed Asset Account,
Accumulated Depreciation Account,účet oprávok,
Depreciation Expense Account,Odpisy Náklady účtu,
Capital Work In Progress Account,Účet Kapitálu Rozrobenosti,
Asset Finance Book,Asset Finance Book,
Written Down Value,Písomná hodnota,
Expected Value After Useful Life,Očakávaná hodnota po celú dobu životnosti,
Rate of Depreciation,Miera odpisovania,
In Percentage,V percentách,
Maintenance Team,Tím údržby,
Maintenance Manager Name,Meno správcu údržby,
Maintenance Tasks,Úlohy údržby,
Manufacturing User,Používateľ výroby,
Asset Maintenance Log,Denník údržby majetku,
ACC-AML-.YYYY.-,ACC-AML-.YYYY.-,
Maintenance Type,Typ Maintenance,
Maintenance Status,Status Maintenance,
Planned,plánovaná,
Has Certificate ,Má certifikát,
Certificate,Osvedčenie,
Actions performed,Vykonané akcie,
Asset Maintenance Task,Úloha údržby majetku,
Maintenance Task,Úloha údržby,
Preventive Maintenance,Preventívna údržba,
Calibration,Kalibrácia,
2 Yearly,2 ročne,
Certificate Required,Potrebný certifikát,
Assign to Name,Priradiť k menu,
Next Due Date,Ďalší dátum splatnosti,
Last Completion Date,Posledný dátum dokončenia,
Asset Maintenance Team,Tím na údržbu aktív,
Maintenance Team Name,Názov tímu údržby,
Maintenance Team Members,Členovia tímu údržby,
Purpose,Účel,
Stock Manager,Manažér zásob,
Asset Movement Item,Položka na presun majetku,
Source Location,Umiestnenie zdroja,
From Employee,Od Zaměstnance,
Target Location,Miesto zacielenia,
To Employee,Zamestnanec,
Asset Repair,Oprava majetku,
ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
Failure Date,Dátum zlyhania,
Assign To Name,Priradiť k názvu,
Repair Status,Stav opravy,
Error Description,Popis chyby,
Downtime,prestoje,
Repair Cost,Náklady na opravu,
Manufacturing Manager,Výrobný riaditeľ,
Current Asset Value,Aktuálna hodnota aktív,
New Asset Value,Nová hodnota majetku,
Make Depreciation Entry,Urobiť Odpisy Entry,
Finance Book Id,ID finančnej knihy,
Location Name,Názov miesta,
Parent Location,Umiestnenie rodičov,
Is Container,Je kontajner,
Check if it is a hydroponic unit,"Skontrolujte, či ide o hydroponickú jednotku",
Location Details,Podrobné informácie o polohe,
Latitude,zemepisná šírka,
Longitude,zemepisná dĺžka,
Area,rozloha,
Area UOM,Oblasť 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,Nastavenie nákupu,
Settings for Buying Module,Nastavenie pre modul Nákupy,
Supplier Naming By,Pomenovanie dodávateľa podľa,
Default Supplier Group,Predvolená skupina dodávateľov,
Default Buying Price List,Predvolený nákupný cenník,
Backflush Raw Materials of Subcontract Based On,Backflush Suroviny subdodávateľských služieb založené na,
Material Transferred for Subcontract,Materiál prenesený na subdodávateľskú zmluvu,
Over Transfer Allowance (%),Preplatok za prevod (%),
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.,"Percentuálny podiel, ktorý môžete previesť viac oproti objednanému množstvu. Napríklad: Ak ste si objednali 100 kusov. a váš príspevok je 10%, potom môžete previesť 110 jednotiek.",
PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
Get Items from Open Material Requests,Získať predmety z žiadostí Otvoriť Materiál,
Fetch items based on Default Supplier.,Načítajte položky na základe predvoleného dodávateľa.,
Required By,Vyžadováno,
Order Confirmation No,Potvrdenie objednávky č,
Order Confirmation Date,Dátum potvrdenia objednávky,
Customer Mobile No,Zákazník Mobile Žiadne,
Customer Contact Email,Kontaktný e-mail zákazníka,
Set Target Warehouse,Nastaviť cieľový sklad,
Sets 'Warehouse' in each row of the Items table.,Nastavuje „Sklad“ v každom riadku tabuľky Položky.,
Supply Raw Materials,Dodávok surovín,
Purchase Order Pricing Rule,Pravidlo stanovenia ceny objednávky,
Set Reserve Warehouse,Nastaviť 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,Sledovanie,
% Billed,% Fakturovaných,
% Received,% Prijaté,
Ref SQ,Ref SQ,
Inter Company Order Reference,Referencia objednávky medzi spoločnosťami,
Supplier Part Number,Dodavatel Číslo dílu,
Billed Amt,Fakturovaná čiastka,
Warehouse and Reference,Sklad a reference,
To be delivered to customer,Ak chcete byť doručený zákazníkovi,
Material Request Item,Materiál Žádost o bod,
Supplier Quotation Item,Položka dodávateľskej ponuky,
Against Blanket Order,Proti paušálnej objednávke,
Blanket Order,Objednávka prikrývky,
Blanket Order Rate,Dekoračná objednávka,
Returned Qty,Vrátené Množstvo,
Purchase Order Item Supplied,Dodané položky vydané objednávky,
BOM Detail No,BOM Detail No,
Stock Uom,Skladová MJ,
Raw Material Item Code,Surovina Kód položky,
Supplied Qty,Dodávané Množstvo,
Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané,
Current Stock,Current skladem,
PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
For individual supplier,Pre jednotlivé dodávateľa,
Link to Material Requests,Odkaz na materiálové požiadavky,
Message for Supplier,Správa pre dodávateľov,
Request for Quotation Item,Žiadosť o cenovú ponuku výtlačku,
Required Date,Požadovaná data,
Request for Quotation Supplier,Žiadosť o cenovú ponuku dodávateľa,
Send Email,Odoslať email,
Quote Status,Citácia Stav,
Download PDF,Stiahnuť PDF,
Supplier of Goods or Services.,Dodavatel zboží nebo služeb.,
Name and Type,Názov a typ,
SUP-.YYYY.-,SUP-.YYYY.-,
Default Bank Account,Prednastavený Bankový účet,
Is Transporter,Je Transporter,
Represents Company,Reprezentuje spoločnosť,
Supplier Type,Dodavatel Type,
Allow Purchase Invoice Creation Without Purchase Order,Povoliť vytváranie nákupných faktúr bez objednávky,
Allow Purchase Invoice Creation Without Purchase Receipt,Povoliť vytváranie nákupných faktúr bez dokladu o kúpe,
Warn RFQs,Upozornenie na RFQ,
Warn POs,Upozorňujte organizácie výrobcov,
Prevent RFQs,Zabráňte RFQ,
Prevent POs,Zabráňte organizáciám výrobcov,
Billing Currency,Mena fakturácie,
Default Payment Terms Template,Šablóna predvolených platobných podmienok,
Block Supplier,Zablokovať dodávateľa,
Hold Type,Typ zadržania,
Leave blank if the Supplier is blocked indefinitely,"Nechajte prázdne, ak je Dodávateľ blokovaný neurčito",
Default Payable Accounts,Výchozí úplatu účty,
Mention if non-standard payable account,"Uveďte, či je neštandardný splatný účet",
Default Tax Withholding Config,Predvolená kont,
Supplier Details,Detaily dodávateľa,
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álnych požiadaviek,
Rounding Adjustment (Company Currency,Zaokrúhľovanie úprav (mena spoločnosti,
Auto Repeat Section,Sekcia Auto Repeat,
Is Subcontracted,Subdodavatelům,
Lead Time in days,Vek Obchodnej iniciatívy v dňoch,
Supplier Score,Skóre dodávateľa,
Indicator Color,Farba indikátora,
Evaluation Period,Hodnotiace obdobie,
Per Week,Za týždeň,
Per Month,Za mesiac,
Per Year,Za rok,
Scoring Setup,Nastavenie bodovania,
Weighting Function,Funkcia váženia,
"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","Možno použiť premenné tabuľky výsledkov, rovnako ako: {total_score} (celkové skóre z tohto obdobia), {period_number} (počet období do súčasnosti)",
Scoring Standings,Skóre bodov,
Criteria Setup,Nastavenie kritérií,
Load All Criteria,Načítať všetky kritériá,
Scoring Criteria,Kritériá hodnotenia,
Scorecard Actions,Akcie Scorecard,
Warn for new Request for Quotations,Upozornenie na novú žiadosť o ponuku,
Warn for new Purchase Orders,Upozornenie na nové nákupné objednávky,
Notify Supplier,Informujte dodávateľa,
Notify Employee,Upozorniť zamestnanca,
Supplier Scorecard Criteria,Kritériá hodnotiacej tabuľky dodávateľa,
Criteria Name,Názov kritéria,
Max Score,Maximálny výsledok,
Criteria Formula,Kritérium vzorca,
Criteria Weight,Hmotnosť kritérií,
Supplier Scorecard Period,Termín dodacieho obdobia dodávateľa,
PU-SSP-.YYYY.-,PU-SSP-.YYYY.-,
Period Score,Skóre obdobia,
Calculations,Výpočty,
Criteria,kritériá,
Variables,Premenné,
Supplier Scorecard Setup,Nastavenie tabuľky dodávateľov,
Supplier Scorecard Scoring Criteria,Hodnotiace kritériá pre dodávateľa Scorecard,
Score,skóre,
Supplier Scorecard Scoring Standing,Hodnotenie skóre dodávateľa,
Standing Name,Stály názov,
Purple,Fialová,
Yellow,žltá,
Orange,Oranžová,
Min Grade,Min Grade,
Max Grade,Max stupeň,
Warn Purchase Orders,Upozornenie na nákupné objednávky,
Prevent Purchase Orders,Zabráňte nákupným objednávkam,
Employee ,Zamestnanec,
Supplier Scorecard Scoring Variable,Hodnota ukazovateľa skóre skóre dodávateľa,
Variable Name,Názov premennej,
Parameter Name,Názov parametra,
Supplier Scorecard Standing,Hodnota karty dodávateľa je stála,
Notify Other,Oznámiť iné,
Supplier Scorecard Variable,Premenná ukazovateľa tabuľky dodávateľov,
Call Log,Výpis hovorov,
Received By,Prijaté od,
Caller Information,Informácie o volajúcom,
Contact Name,Meno kontaktu,
Lead ,Viesť,
Lead Name,Meno Obchodnej iniciatívy,
Ringing,zvoniaci,
Missed,vynechal,
Call Duration in seconds,Trvanie hovoru v sekundách,
Recording URL,Nahrávacia adresa URL,
Communication Medium,Komunikační médium,
Communication Medium Type,Typ komunikačného média,
Voice,hlas,
Catch All,Chytiť všetko,
"If there is no assigned timeslot, then communication will be handled by this group","Ak nie je priradený žiadny časový rozvrh, komunikácia bude uskutočnená touto skupinou",
Timeslots,Časové úseky,
Communication Medium Timeslot,Komunikačné stredné časové pásmo,
Employee Group,Skupina zamestnancov,
Appointment,vymenovanie,
Scheduled Time,Naplánovaný čas,
Unverified,neoverený,
Customer Details,Podrobnosti zákazníkov,
Phone Number,Telefónne číslo,
Skype ID,Skype identifikácia,
Linked Documents,Prepojené dokumenty,
Appointment With,Schôdzka s,
Calendar Event,Udalosť kalendára,
Appointment Booking Settings,Nastavenia rezervácie schôdzky,
Enable Appointment Scheduling,Povoliť plánovanie schôdzky,
Agent Details,Podrobnosti o agentovi,
Availability Of Slots,Dostupnosť automatov,
Number of Concurrent Appointments,Počet súbežných stretnutí,
Agents,agents,
Appointment Details,Podrobnosti o schôdzke,
Appointment Duration (In Minutes),Trvanie stretnutia (v minútach),
Notify Via Email,Upozorniť e-mailom,
Notify customer and agent via email on the day of the appointment.,V deň stretnutia informujte zákazníka a agenta e-mailom.,
Number of days appointments can be booked in advance,Počet dní schôdzky si môžete rezervovať vopred,
Success Settings,Nastavenia úspechu,
Success Redirect URL,Adresa URL presmerovania úspechu,
"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Nechajte doma prázdne. Ide o relatívnu adresu URL stránky, napríklad „about“ presmeruje na „https://yoursitename.com/about“",
Appointment Booking Slots,Výherné automaty na schôdzky,
Day Of Week,Deň v týždni,
From Time ,Času od,
Campaign Email Schedule,Časový plán e-mailu kampane,
Send After (days),Odoslať po (dni),
Signed,podpísaný,
Party User,Používateľ strany,
Unsigned,nepodpísaný,
Fulfilment Status,Stav plnenia,
N/A,N / A,
Unfulfilled,nesplnený,
Partially Fulfilled,Čiastočne splnené,
Fulfilled,splnené,
Lapsed,odpadlý,
Contract Period,Zmluvné obdobie,
Signee Details,Signee Details,
Signee,Signee,
Signed On,Zapnuté,
Contract Details,Detaily zmluvy,
Contract Template,Šablóna zmluvy,
Contract Terms,Zmluvné podmienky,
Fulfilment Details,Podrobnosti o plnení,
Requires Fulfilment,Vyžaduje splnenie,
Fulfilment Deadline,Termín splnenia,
Fulfilment Terms,Podmienky plnenia,
Contract Fulfilment Checklist,Kontrolný zoznam plnenia zmluvy,
Requirement,požiadavka,
Contract Terms and Conditions,Zmluvné podmienky,
Fulfilment Terms and Conditions,Zmluvné podmienky plnenia,
Contract Template Fulfilment Terms,Zmluvné podmienky pre splnenie podmienok zmluvy,
Email Campaign,E-mailová kampaň,
Email Campaign For ,E-mailová kampaň pre,
Lead is an Organization,Vedenie je organizácia,
CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-,
Person Name,Osoba Meno,
Lost Quotation,stratil Citácia,
Interested,Zájemci,
Converted,Prevedené,
Do Not Contact,Nekontaktujte,
From Customer,Od Zákazníka,
Campaign Name,Názov kampane,
Follow Up,Nasleduj,
Next Contact By,Další Kontakt By,
Next Contact Date,Další Kontakt Datum,
Ends On,Končí sa,
Address & Contact,Adresa a kontakt,
Mobile No.,Mobile No.,
Lead Type,Typ Iniciatívy,
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,Nastavenia LinkedIn,
Company ID,IČO,
OAuth Credentials,Poverenia OAuth,
Consumer Key,Spotrebiteľský kľúč,
Consumer Secret,Spotrebiteľské tajomstvo,
User Details,Detaily používateľa,
Person URN,Osoba URN,
Session Status,Stav relácie,
Lost Reason Detail,Podrobnosti strateného dôvodu,
Opportunity Lost Reason,Príležitosť stratila 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 / Iniciatíva Meno,
Opportunity Type,Typ Příležitosti,
Converted By,Prevedené,
Sales Stage,Predajná fáza,
Lost Reason,Ztracené Důvod,
Expected Closing Date,Očakávaný dátum uzávierky,
To Discuss,K projednání,
With Items,S položkami,
Probability (%),Pravdepodobnosť (%),
Contact Info,Kontaktné informácie,
Customer / Lead Address,Adresa zákazníka/obchodnej iniciatívy,
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,Základná sadzba,
Stage Name,Pseudonym,
Social Media Post,Príspevok na sociálnych sieťach,
Post Status,Stav príspevku,
Posted,Zverejnené,
Share On,Zdieľať ďalej,
Twitter,Twitter,
LinkedIn,LinkedIn,
Twitter Post Id,ID príspevku na Twitteri,
LinkedIn Post Id,LinkedIn Post Id,
Tweet,Tweet,
Twitter Settings,Nastavenia Twitteru,
API Secret Key,Tajný kľúč API,
Term Name,termín Name,
Term Start Date,Termín Dátum začatia,
Term End Date,Termín Dátum ukončenia,
Academics User,akademici Užívateľ,
Academic Year Name,Akademický rok Meno,
Article,článok,
LMS User,Užívateľ LMS,
Assessment Criteria Group,Hodnotiace kritériá Group,
Assessment Group Name,Názov skupiny Assessment,
Parent Assessment Group,Materská skupina Assessment,
Assessment Name,Názov Assessment,
Grading Scale,stupnica,
Examiner,skúšajúci,
Examiner Name,Meno Examiner,
Supervisor,Nadriadený,
Supervisor Name,Meno Supervisor,
Evaluate,Ohodnotiť,
Maximum Assessment Score,Maximálne skóre Assessment,
Assessment Plan Criteria,Plan Assessment Criteria,
Maximum Score,maximálny počet bodov,
Grade,stupeň,
Assessment Result Detail,Posúdenie Detail Výsledok,
Assessment Result Tool,Assessment Tool Výsledok,
Result HTML,výsledok HTML,
Content Activity,Obsahová aktivita,
Last Activity ,Posledná aktivita,
Content Question,Otázka obsahu,
Question Link,Odkaz na otázku,
Course Name,Názov kurzu,
Topics,témy,
Hero Image,Obrázok hrdiny,
Default Grading Scale,Predvolené Stupnica,
Education Manager,Správca vzdelávania,
Course Activity,Aktivita kurzu,
Course Enrollment,Zápis do kurzu,
Activity Date,Dátum aktivity,
Course Assessment Criteria,Hodnotiace kritériá kurz,
Weightage,Weightage,
Course Content,Obsah kurzu,
Quiz,kvíz,
Program Enrollment,Registrácia do programu,
Enrollment Date,zápis Dátum,
Instructor Name,inštruktor Name,
EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-,
Course Scheduling Tool,Samozrejme Plánovanie Tool,
Course Start Date,Začiatok Samozrejme Dátum,
To TIme,Chcete-li čas,
Course End Date,Koniec Samozrejme Dátum,
Course Topic,Téma kurzu,
Topic Name,Názov témy,
Education Settings,Nastavenia vzdelávania,
Current Academic Year,Súčasný akademický rok,
Current Academic Term,Aktuálny akademický výraz,
Attendance Freeze Date,Účasť,
Validate Batch for Students in Student Group,Overenie dávky pre študentov v študentskej skupine,
"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",V prípade dávkovej študentskej skupiny bude študentská dávka schválená pre každého študenta zo zápisu do programu.,
Validate Enrolled Course for Students in Student Group,Overiť zapísaný kurz pre študentov v študentskej skupine,
"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",V prípade kurzov študentskej skupiny bude kurz potvrdený pre každého študenta z prihlásených kurzov pri zaradení do programu.,
Make Academic Term Mandatory,Akademický termín je povinný,
"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ak je povolené, pole Akademický termín bude povinné v programe Program registrácie.",
Skip User creation for new Student,Preskočiť vytváranie používateľov pre nového študenta,
"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.","V predvolenom nastavení je nový používateľ vytvorený pre každého nového študenta. Ak je táto možnosť povolená, pri vytváraní nového študenta sa nevytvorí žiadny nový používateľ.",
Instructor Records to be created by,"Záznamy inštruktorov, ktoré vytvorí",
Employee Number,Počet zaměstnanců,
Fee Category,poplatok Kategórie,
Fee Component,poplatok Component,
Fees Category,kategórie poplatky,
Fee Schedule,poplatok Plán,
Fee Structure,štruktúra poplatkov,
EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
Fee Creation Status,Stav tvorby poplatkov,
In Process,V procesu,
Send Payment Request Email,Poslať e-mail s požiadavkou na platbu,
Student Category,študent Kategórie,
Fee Breakup for each student,Poplatok za každý študent,
Total Amount per Student,Celková suma na študenta,
Institution,inštitúcie,
Fee Schedule Program,Program rozpisu poplatkov,
Student Batch,študent Batch,
Total Students,Celkový počet študentov,
Fee Schedule Student Group,Poplatkový študijný program,
EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
Include Payment,Zahrňte platbu,
Send Payment Request,Odoslať žiadosť o platbu,
Student Details,Podrobnosti študenta,
Student Email,Študentský e-mail,
Grading Scale Name,Stupnica Name,
Grading Scale Intervals,Triedenie dielikov,
Intervals,intervaly,
Grading Scale Interval,Stupnica Interval,
Grade Code,grade Code,
Threshold,Prah,
Grade Description,grade Popis,
Guardian,poručník,
Guardian Name,Meno Guardian,
Alternate Number,Alternatívne Number,
Occupation,povolania,
Work Address,pracovná adresa,
Guardian Of ,Guardian Of,
Students,študenti,
Guardian Interests,Guardian záujmy,
Guardian Interest,Guardian Záujem,
Interest,záujem,
Guardian Student,Guardian Student,
EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
Instructor Log,Denník inštruktorov,
Other details,Ďalšie podrobnosti,
Option,voľba,
Is Correct,Je správne,
Program Name,Názov programu,
Program Abbreviation,program Skratka,
Courses,predmety,
Is Published,Publikované,
Allow Self Enroll,Povoliť vlastné prihlásenie,
Is Featured,Je odporúčané,
Intro Video,Úvodné video,
Program Course,program kurzu,
School House,School House,
Boarding Student,Stravovanie Študent,
Check this if the Student is residing at the Institute's Hostel.,"Skontrolujte, či študent býva v hosteli inštitútu.",
Walking,chôdza,
Institute's Bus,Autobus ústavu,
Self-Driving Vehicle,Samohybné vozidlo,
Pick/Drop by Guardian,Pick / Drop od Guardian,
Enrolled courses,Zapísané kurzy,
Program Enrollment Course,Program na zápis do programu,
Program Enrollment Fee,program zápisné,
Program Enrollment Tool,Program Tool zápis,
Get Students From,Získať študentov z,
Student Applicant,študent Žiadateľ,
Get Students,získať študentov,
Enrollment Details,Podrobnosti o registrácii,
New Program,nový program,
New Student Batch,Nová študentská dávka,
Enroll Students,zapísať študenti,
New Academic Year,Nový akademický rok,
New Academic Term,Nový akademický termín,
Program Enrollment Tool Student,Registrácia do programu Student Tool,
Student Batch Name,Študent Batch Name,
Program Fee,program Fee,
Question,otázka,
Single Correct Answer,Jedna správna odpoveď,
Multiple Correct Answer,Viacnásobná správna odpoveď,
Quiz Configuration,Konfigurácia testu,
Passing Score,Skóre skóre,
Score out of 100,Skóre zo 100,
Max Attempts,Max Pokusy,
Enter 0 to waive limit,"Ak chcete upustiť od limitu, zadajte 0",
Grading Basis,Základ klasifikácie,
Latest Highest Score,Najvyššie skóre,
Latest Attempt,Najnovší pokus,
Quiz Activity,Kvízová aktivita,
Enrollment,Zápis,
Pass,priechod,
Quiz Question,Kvízová otázka,
Quiz Result,Výsledok testu,
Selected Option,Vybraná možnosť,
Correct,korektné,
Wrong,zle,
Room Name,Room Meno,
Room Number,Číslo izby,
Seating Capacity,Počet miest na sedenie,
House Name,Meno dom,
EDU-STU-.YYYY.-,EDU-STU-.YYYY.-,
Student Mobile Number,Študent Číslo mobilného telefónu,
Blood Group,Krevní Skupina,
A+,A +,
A-,A-,
B+,B +,
B-,B-,
O+,O +,
O-,O-,
AB+,AB +,
AB-,AB-,
Nationality,národnosť,
Home Address,Adresa bydliska,
Guardian Details,Guardian Podrobnosti,
Guardians,Guardians,
Sibling Details,súrodenec Podrobnosti,
Siblings,súrodenci,
Exit,Východ,
Date of Leaving,Dátum odchodu,
Leaving Certificate Number,maturita číslo,
Reason For Leaving,Dôvod na odchod,
Student Admission,študent Vstupné,
Admission Start Date,Vstupné Dátum začatia,
Admission End Date,Vstupné Dátum ukončenia,
Eligibility and Details,Oprávnenosť a podrobnosti,
Student Admission Program,Prijímací program pre študentov,
Minimum Age,Minimálny vek,
Maximum Age,Maximálny vek,
Application Fee,Poplatok za prihlášku,
Naming Series (for Student Applicant),Pomenovanie Series (pre študentské prihlasovateľ),
LMS Only,Iba LMS,
EDU-APP-.YYYY.-,EDU-APP-.YYYY.-,
Application Date,aplikácie Dátum,
Student Attendance Tool,Študent Účasť Tool,
Group Based On,Skupina založená na,
Students HTML,študenti HTML,
Group Based on,Skupina založená na,
Student Group Name,Meno Študent Group,
Max Strength,Max Sila,
Set 0 for no limit,Nastavte 0 pre žiadny limit,
Instructors,inštruktori,
Student Group Creation Tool,Študent Group Tool Creation,
Leave blank if you make students groups per year,"Nechajte prázdne, ak robíte študentské skupiny ročne",
Get Courses,získať kurzy,
Separate course based Group for every Batch,Samostatná skupina kurzov pre každú dávku,
Leave unchecked if you don't want to consider batch while making course based groups. ,"Ponechajte nezačiarknuté, ak nechcete zohľadňovať dávku pri zaradení do skupín.",
Student Group Creation Tool Course,Študent Group Creation Tool ihrisko,
Course Code,kód predmetu,
Student Group Instructor,Inštruktor skupiny študentov,
Student Group Student,Študent Skupina Student,
Group Roll Number,Číslo skupiny rollov,
Student Guardian,študent Guardian,
Relation,Vztah,
Mother,matka,
Father,otec,
Student Language,študent Language,
Student Leave Application,Študent nechať aplikáciu,
Mark as Present,Označiť ako prítomný,
Student Log,študent Log,
Academic,akademický,
Achievement,úspech,
Student Report Generation Tool,Nástroj na generovanie správ študentov,
Include All Assessment Group,Zahrnúť celú hodnotiacu skupinu,
Show Marks,Zobraziť značky,
Add letterhead,Pridať hlavičkový papier,
Print Section,Tlačiť sekciu,
Total Parents Teacher Meeting,Celkové stretnutie učiteľov rodičov,
Attended by Parents,Zúčastnili sa rodičia,
Assessment Terms,Hodnotiace podmienky,
Student Sibling,študent Súrodenec,
Studying in Same Institute,Štúdium v Same ústave,
NO,Č,
YES,Ano,
Student Siblings,študentské Súrodenci,
Topic Content,Obsah témy,
Amazon MWS Settings,Amazon MWS Settings,
ERPNext Integrations,ERPNext integrácie,
Enable Amazon,Povoliť Amazon,
MWS Credentials,Poverenia MWS,
Seller ID,ID predávajúceho,
AWS Access Key ID,Identifikátor prístupového kľúča AWS,
MWS Auth Token,MWS Auth Token,
Market Place ID,ID miesta na trhu,
AE,AE,
AU,AU,
BR,BR,
CA,CA,
CN,CN,
DE,DE,
ES,ES,
FR,FR,
JP,JP,
IT,IT,
MX,MX,
UK,Spojené kráľovstvo,
US,US,
Customer Type,Typ zákazníka,
Market Place Account Group,Skupina účtov na trhu,
After Date,Po dátume,
Amazon will synch data updated after this date,Spoločnosť Amazon bude synchronizovať údaje aktualizované po tomto dátume,
Sync Taxes and Charges,Synchronizujte dane a poplatky,
Get financial breakup of Taxes and charges data by Amazon ,Získajte finančné rozdelenie údajov o daniach a poplatkoch od spoločnosti Amazon,
Sync Products,Synchronizovať produkty,
Always sync your products from Amazon MWS before synching the Orders details,Pred synchronizáciou podrobností objednávky vždy synchronizujte svoje produkty z Amazonu MWS,
Sync Orders,Synchronizovať objednávky,
Click this button to pull your Sales Order data from Amazon MWS.,Kliknutím na toto tlačidlo vyberiete údaje o predajnej objednávke od spoločnosti Amazon MWS.,
Enable Scheduled Sync,Povoliť naplánovanú synchronizáciu,
Check this to enable a scheduled Daily synchronization routine via scheduler,"Začiarknite toto, ak chcete povoliť plánovanú dennú synchronizáciu prostredníctvom plánovača",
Max Retry Limit,Maximálny limit opakovania,
Exotel Settings,Nastavenia exotelu,
Account SID,SID účtu,
API Token,Rozhranie API,
GoCardless Mandate,GoCardless Mandate,
Mandate,mandát,
GoCardless Customer,Zákazník spoločnosti GoCardless,
GoCardless Settings,Nastavenia GoCardless,
Webhooks Secret,Webhooks Secret,
Plaid Settings,Plaid Settings,
Synchronize all accounts every hour,Synchronizujte všetky účty každú hodinu,
Plaid Client ID,ID platného klienta,
Plaid Secret,Plaid Secret,
Plaid Environment,Plaid Environment,
sandbox,pieskovisko,
development,vývoj,
production,výroba,
QuickBooks Migrator,QuickBooks Migrator,
Application Settings,Nastavenia aplikácie,
Token Endpoint,Koncový bod tokenu,
Scope,Rozsah,
Authorization Settings,Nastavenia autorizácie,
Authorization Endpoint,Koncový bod autorizácie,
Authorization URL,Autorizačná adresa URL,
Quickbooks Company ID,Identifikátor spoločnosti Quickbooks,
Company Settings,Nastavenia firmy,
Default Shipping Account,Predvolený dodací účet,
Default Warehouse,Predvolený sklad,
Default Cost Center,Predvolené nákladové stredisko,
Undeposited Funds Account,Účet neukladaných finančných prostriedkov,
Shopify Log,Obchodný záznam,
Shopify Settings,Nastavenie nakupovania,
status html,status html,
Enable Shopify,Povoliť funkciu Shopify,
App Type,Typ aplikácie,
Last Sync Datetime,Dátum posledného synchronizácie,
Shop URL,Adresa URL obchodu,
eg: frappe.myshopify.com,napr .: frappe.myshopify.com,
Shared secret,Zdieľané tajomstvo,
Webhooks Details,Webhooks Details,
Webhooks,Webhooks,
Customer Settings,Nastavenia zákazníka,
Default Customer,Predvolený zákazník,
Customer Group will set to selected group while syncing customers from Shopify,Zákaznícka skupina nastaví vybranú skupinu pri synchronizácii zákazníkov so službou Shopify,
For Company,Pre spoločnosť,
Cash Account will used for Sales Invoice creation,Pokladničný účet sa použije na vytvorenie faktúry za predaj,
Update Price from Shopify To ERPNext Price List,Aktualizovať cenu z Shopify do ERPNext Cenník,
Default Warehouse to to create Sales Order and Delivery Note,Predvolená skladačka na vytvorenie objednávky predaja a dodacieho listu,
Sales Order Series,Séria objednávok,
Import Delivery Notes from Shopify on Shipment,Importovať doručené poznámky z Shopify pri odoslaní,
Delivery Note Series,Séria dodacích poznámok,
Import Sales Invoice from Shopify if Payment is marked,"Importovať faktúru z predaja, ak je platba označená",
Sales Invoice Series,Séria predajných faktúr,
Shopify Tax Account,Nakupujte daňový účet,
Shopify Tax/Shipping Title,Nakupujte názov dane / plavby,
ERPNext Account,Následný účet ERP,
Shopify Webhook Detail,Nakupujte podrobnosti Webhook,
Webhook ID,Webhook ID,
Tally Migration,Tally Migration,
Master Data,Hlavné dáta,
"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Údaje exportované z Tally, ktoré tvoria účtovná osnova, zákazníci, dodávatelia, adresy, položky a MJ",
Is Master Data Processed,Spracovávajú sa kmeňové údaje,
Is Master Data Imported,Importujú sa kmeňové údaje,
Tally Creditors Account,Účet veriteľov,
Creditors Account set in Tally,Účet veriteľov nastavený v Tally,
Tally Debtors Account,Účet Tally dlžníkov,
Debtors Account set in Tally,Účet dlžníkov nastavený v Tally,
Tally Company,Spoločnosť Tally,
Company Name as per Imported Tally Data,Názov spoločnosti podľa importovaných záznamových údajov,
Default UOM,Predvolená UOM,
UOM in case unspecified in imported data,"MJ v prípade, že v importovaných údajoch nie je uvedený inak",
ERPNext Company,ERPĎalšia spoločnosť,
Your Company set in ERPNext,Vaša spoločnosť nastavená v ERPNext,
Processed Files,Spracované súbory,
Parties,strany,
UOMs,Merné Jednotky,
Vouchers,poukážky,
Round Off Account,Zaokrúhliť účet,
Day Book Data,Údaje o dennej knihe,
Day Book Data exported from Tally that consists of all historic transactions,"Denná kniha Údaje exportované z Tally, ktoré pozostávajú zo všetkých historických transakcií",
Is Day Book Data Processed,Spracovávajú sa údaje dennej knihy,
Is Day Book Data Imported,Importujú sa údaje dennej knihy,
Woocommerce Settings,Woocommerce Settings,
Enable Sync,Povoliť synchronizáciu,
Woocommerce Server URL,Woocommerce URL servera,
Secret,tajomstvo,
API consumer key,API spotrebiteľský kľúč,
API consumer secret,API spotrebiteľské tajomstvo,
Tax Account,Daňový účet,
Freight and Forwarding Account,Účet pre prepravu a prepravu,
Creation User,Vytvorenie používateľa,
"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Používateľ, ktorý sa použije na vytvorenie zákazníkov, položiek a zákaziek odberateľa. Tento používateľ by mal mať príslušné povolenia.",
"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Tento sklad sa použije na vytvorenie zákaziek odberateľa. Núdzový sklad je „Obchody“.,
"The fallback series is ""SO-WOO-"".",Záložná séria je „SO-WOO-“.,
This company will be used to create Sales Orders.,Táto spoločnosť sa použije na vytvorenie zákaziek odberateľa.,
Delivery After (Days),Dodanie po (dňoch),
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 predvolený ofset (dni) pre Dátum dodania v zákazkách odberateľa. Náhradný odstup je 7 dní od dátumu zadania objednávky.,
"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Toto je predvolené UOM použité pre položky a predajné objednávky. Záložná UOM je „Nos“.,
Endpoints,Endpoints,
Endpoint,Endpoint,
Antibiotic Name,Názov antibiotika,
Healthcare Administrator,Administrátor zdravotnej starostlivosti,
Laboratory User,Laboratórny používateľ,
Is Inpatient,Je hospitalizovaný,
Default Duration (In Minutes),Predvolené trvanie (v minútach),
Body Part,Časť tela,
Body Part Link,Odkaz na časť tela,
HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-,
Procedure Template,Šablóna postupu,
Procedure Prescription,Predpísaný postup,
Service Unit,Servisná jednotka,
Consumables,Spotrebný,
Consume Stock,Spotreba akcií,
Invoice Consumables Separately,Spotrebný materiál na faktúru osobitne,
Consumption Invoiced,Spotreba fakturovaná,
Consumable Total Amount,Celková spotrebná čiastka,
Consumption Details,Údaje o spotrebe,
Nursing User,Ošetrujúci používateľ,
Clinical Procedure Item,Položka klinickej procedúry,
Invoice Separately as Consumables,Faktúra samostatne ako spotrebný materiál,
Transfer Qty,Množstvo prenosu,
Actual Qty (at source/target),Skutečné množství (u zdroje/cíle),
Is Billable,Je fakturovaná,
Allow Stock Consumption,Povoliť skladovú zásobu,
Sample UOM,Ukážka UOM,
Collection Details,Podrobnosti zbierky,
Change In Item,Zmena v položke,
Codification Table,Kodifikačná tabuľka,
Complaints,Sťažnosti,
Dosage Strength,Pevnosť dávkovania,
Strength,pevnosť,
Drug Prescription,Predpísaný liek,
Drug Name / Description,Názov / popis lieku,
Dosage,dávkovanie,
Dosage by Time Interval,Dávkovanie podľa časového intervalu,
Interval,interval,
Interval UOM,Interval UOM,
Hour,Hodina,
Update Schedule,Aktualizovať plán,
Exercise,Cvičenie,
Difficulty Level,Obtiažnosť,
Counts Target,Počíta cieľ,
Counts Completed,Počty boli dokončené,
Assistance Level,Úroveň pomoci,
Active Assist,Active Assist,
Exercise Name,Názov cvičenia,
Body Parts,Časti tela,
Exercise Instructions,Pokyny na cvičenie,
Exercise Video,Cvičebné video,
Exercise Steps,Kroky na cvičenie,
Steps Table,Tabuľka krokov,
Exercise Type Step,Typ cvičenia Krok,
Max number of visit,Maximálny počet návštev,
Visited yet,Navštívené,
Reference Appointments,Referenčné stretnutia,
Valid till,Platný do,
Fee Validity Reference,Referencia platnosti poplatkov,
Basic Details,Základné podrobnosti,
HLC-PRAC-.YYYY.-,HLC-PRAC-.RRRR.-,
Mobile,Mobilné,
Phone (R),Telefón (R),
Phone (Office),Telefón (Office),
Employee and User Details,Podrobnosti o zamestnancovi a používateľovi,
Hospital,Nemocnica,
Appointments,schôdzky,
Practitioner Schedules,Pracovník plánuje,
Charges,Poplatky,
Out Patient Consulting Charge,Poplatok za konzultáciu s pacientom,
Default Currency,Predvolená mena,
Healthcare Schedule Time Slot,Časový rozvrh časového harmonogramu zdravotnej starostlivosti,
Parent Service Unit,Rodičovská služba,
Service Unit Type,Typ servisnej jednotky,
Allow Appointments,Povoliť schôdzky,
Allow Overlap,Povoliť prekrytie,
Inpatient Occupancy,Umiestnenie v nemocnici,
Occupancy Status,Stav obsadenosti,
Vacant,prázdny,
Occupied,obsadený,
Item Details,Položka Podrobnosti,
UOM Conversion in Hours,UOM Konverzia v hodinách,
Rate / UOM,Sadzba / MJ,
Change in Item,Zmeniť položku,
Out Patient Settings,Nastavenia pre pacienta,
Patient Name By,Názov pacienta,
Patient Name,Názov pacienta,
Link Customer to Patient,Prepojte zákazníka s pacientom,
"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.","Ak je začiarknuté, vytvorí sa zákazník, zmapovaný na pacienta. Faktúry pacienta budú vytvorené voči tomuto zákazníkovi. Môžete tiež vybrať existujúceho zákazníka pri vytváraní pacienta.",
Default Medical Code Standard,Predvolený štandard medicínskeho kódu,
Collect Fee for Patient Registration,Získať poplatok za registráciu pacienta,
Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,Začiarknutím tohto políčka sa v predvolenom nastavení vytvoria noví pacienti so zdravotným stavom a budú povolení až po fakturácii registračného poplatku.,
Registration Fee,Registračný poplatok,
Automate Appointment Invoicing,Automatizujte fakturáciu udalostí,
Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Spravujte faktúru odstupňovania a automaticky zrušte za stretnutie pacienta,
Enable Free Follow-ups,Povoliť bezplatné následné kroky,
Number of Patient Encounters in Valid Days,Počet stretnutí pacientov v platných dňoch,
The number of free follow ups (Patient Encounters in valid days) allowed,Počet povolených bezplatných následných kontrol (stretnutia pacientov v platných dňoch),
Valid Number of Days,Platný počet dní,
Time period (Valid number of days) for free consultations,Časové obdobie (platný počet dní) pre bezplatné konzultácie,
Default Healthcare Service Items,Predvolené položky zdravotnej starostlivosti,
"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Môžete nakonfigurovať predvolené položky pre fakturačné poplatky za konzultácie, položky spotreby procedúr a návštevy hospitalizovaných pacientov",
Clinical Procedure Consumable Item,Klinický postup Spotrebný bod,
Default Accounts,Predvolené účty,
Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Predpokladané výnosové účty, ktoré sa použijú, ak nie sú stanovené v zdravotníckom praktickom lekári na vyúčtovanie poplatkov za schôdzku.",
Default receivable accounts to be used to book Appointment charges.,"Predvolené účty pohľadávok, ktoré sa majú použiť na zaúčtovanie poplatkov za schôdzku.",
Out Patient SMS Alerts,SMS upozorňovanie na pacientov,
Patient Registration,Registrácia pacienta,
Registration Message,Registrácia Správa,
Confirmation Message,Potvrdzujúca správa,
Avoid Confirmation,Vyhnite sa konfirmácii,
Do not confirm if appointment is created for the same day,"Nepotvrdzujú, či sa schôdzka vytvorí v ten istý deň",
Appointment Reminder,Pripomienka na menovanie,
Reminder Message,Pripomenutie správy,
Laboratory Settings,Laboratórne nastavenia,
Create Lab Test(s) on Sales Invoice Submission,Vytvorte laboratórne testy pri odoslaní predajnej faktúry,
Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,Začiarknutím tohto políčka sa pri odoslaní vytvoria laboratórne testy uvedené v predajnej faktúre.,
Create Sample Collection document for Lab Test,Vytvorte dokument Zbierka vzoriek pre laboratórny test,
Checking this will create a Sample Collection document  every time you create a Lab Test,Začiarknutím tohto políčka sa vytvorí dokument Sample Collection pri každom vytvorení laboratórneho testu,
Employee name and designation in print,Meno a označenie zamestnanca v tlači,
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.,"Toto začiarknite, ak chcete, aby sa meno a označenie zamestnanca spojeného s používateľom, ktorý predkladá dokument, vytlačil v protokole o laboratórnom teste.",
Do not print or email Lab Tests without Approval,Bez schválenia netlačte ani neposielajte laboratórne testy e-mailom,
Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Toto začiarknutie obmedzí tlač a odosielanie e-mailových dokumentov laboratórnych testov, pokiaľ nebudú mať stav Schválené.",
Custom Signature in Print,Vlastný podpis v tlači,
Laboratory SMS Alerts,Laboratórne SMS upozornenia,
Result Printed Message,Výsledok Vytlačená správa,
Result Emailed Message,Výsledná e-mailová správa,
Check In,Prihlásiť sa,
Check Out,Odhlásiť sa,
HLC-INP-.YYYY.-,HLC-INP-.YYYY.-,
A Positive,Pozitívny,
A Negative,Negatívny,
AB Positive,AB Pozitívny,
AB Negative,AB Negatívny,
B Positive,B Pozitívne,
B Negative,B Negatívny,
O Positive,O pozitívne,
O Negative,O Negatívny,
Date of birth,Dátum narodenia,
Admission Scheduled,Prijatie naplánované,
Discharge Scheduled,Plnenie je naplánované,
Discharged,Vybitý,
Admission Schedule Date,Dátum schôdze prijatia,
Admitted Datetime,Pripravený dátum,
Expected Discharge,Očakávané vybitie,
Discharge Date,Dátum vykládky,
Lab Prescription,Lab Prescription,
Lab Test Name,Názov laboratórneho testu,
Test Created,Test bol vytvorený,
Submitted Date,Dátum odoslania,
Approved Date,Schválený dátum,
Sample ID,ID vzorky,
Lab Technician,Laboratórny technik,
Report Preference,Preferencia prehľadu,
Test Name,Názov testu,
Test Template,Šablóna testu,
Test Group,Testovacia skupina,
Custom Result,Vlastný výsledok,
LabTest Approver,LabTest Approver,
Add Test,Pridať test,
Normal Range,Normálny rozsah,
Result Format,Formát výsledkov,
Single,Slobodný/á,
Compound,zlúčenina,
Descriptive,opisný,
Grouped,zoskupené,
No Result,žiadny výsledok,
This value is updated in the Default Sales Price List.,Táto hodnota sa aktualizuje v Predvolenom zozname cien predaja.,
Lab Routine,Lab Rutine,
Result Value,Výsledná hodnota,
Require Result Value,Vyžadovať výslednú hodnotu,
Normal Test Template,Normálna šablóna testu,
Patient Demographics,Demografia pacienta,
HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-,
Middle Name (optional),Prostredné meno (voliteľné),
Inpatient Status,Stav lôžka,
"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.","Ak je v nastaveniach zdravotnej starostlivosti začiarknuté políčko „Prepojiť zákazníka s pacientom“ a nevyberiete existujúceho zákazníka, pre tohto pacienta sa vytvorí zákazník na zaznamenávanie transakcií v module Účty.",
Personal and Social History,Osobná a sociálna história,
Marital Status,Rodinný stav,
Married,Ženatý,
Divorced,Rozvedený,
Widow,vdova,
Patient Relation,Vzťah pacientov,
"Allergies, Medical and Surgical History","Alergie, lekárske a chirurgické dejepisy",
Allergies,alergie,
Medication,liečenie,
Medical History,História medicíny,
Surgical History,Chirurgická história,
Risk Factors,Rizikové faktory,
Occupational Hazards and Environmental Factors,Pracovné nebezpečenstvo a environmentálne faktory,
Other Risk Factors,Ďalšie rizikové faktory,
Patient Details,Podrobnosti o pacientoch,
Additional information regarding the patient,Ďalšie informácie týkajúce sa pacienta,
HLC-APP-.YYYY.-,HLC-APP-.RRRR.-,
Patient Age,Vek pacienta,
Get Prescribed Clinical Procedures,Získajte predpísané klinické postupy,
Therapy,Terapia,
Get Prescribed Therapies,Získajte predpísané terapie,
Appointment Datetime,Dátum schôdzky,
Duration (In Minutes),Trvanie (v minútach),
Reference Sales Invoice,Referenčná predajná faktúra,
More Info,Více informací,
Referring Practitioner,Odporúčajúci lekár,
HLC-PA-.YYYY.-,HLC-PA-.RRRR.-,
Assessment Template,Šablóna na hodnotenie,
Assessment Datetime,Hodnotiaci dátum a čas,
Assessment Description,Popis posúdenia,
Assessment Sheet,Hodnotiaci list,
Total Score Obtained,Celkové dosiahnuté skóre,
Scale Min,Stupnica min,
Scale Max,Stupnica Max,
Patient Assessment Detail,Podrobnosti o hodnotení pacienta,
Assessment Parameter,Parameter hodnotenia,
Patient Assessment Parameter,Parameter hodnotenia pacienta,
Patient Assessment Sheet,Hárok s hodnotením pacienta,
Patient Assessment Template,Šablóna na hodnotenie pacienta,
Assessment Parameters,Parametre hodnotenia,
Parameters,parametre,
Assessment Scale,Hodnotiaca škála,
Scale Minimum,Stupnica minimálna,
Scale Maximum,Maximálna mierka,
HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-,
Encounter Date,Dátum stretnutia,
Encounter Time,Stretnutie s časom,
Encounter Impression,Zaznamenajte zobrazenie,
Symptoms,Príznaky,
In print,V tlači,
Medical Coding,Lekárske kódovanie,
Procedures,postupy,
Therapies,Terapie,
Review Details,Prehľad podrobností,
Patient Encounter Diagnosis,Diagnóza stretnutia pacienta,
Patient Encounter Symptom,Príznak stretnutia pacienta,
HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-,
Attach Medical Record,Priložte lekársky záznam,
Spouse,manželka,
Family,Rodina,
Schedule Details,Podrobnosti rozvrhu,
Schedule Name,Názov plánu,
Time Slots,Časové úseky,
Practitioner Service Unit Schedule,Časový plán služby pre praktizujúcich,
Procedure Name,Názov procedúry,
Appointment Booked,Schôdza rezervovaná,
Procedure Created,Postup bol vytvorený,
HLC-SC-.YYYY.-,HLC-SC-.YYYY.-,
Collected By,Zhromaždené podľa,
Particulars,podrobnosti,
Result Component,Zložka výsledkov,
HLC-THP-.YYYY.-,HLC-THP-.RRRR.-,
Therapy Plan Details,Podrobnosti o terapeutickom pláne,
Total Sessions,Celkový počet relácií,
Total Sessions Completed,Celkový počet dokončených relácií,
Therapy Plan Detail,Detail terapeutického plánu,
No of Sessions,Počet relácií,
Sessions Completed,Relácie boli dokončené,
Tele,Tele,
Exercises,Cvičenia,
Therapy For,Terapia pre,
Add Exercises,Pridajte cvičenia,
Body Temperature,Teplota tela,
Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prítomnosť horúčky (teplota&gt; 38,5 ° C alebo udržiavaná teplota&gt; 38 ° C / 100,4 ° F)",
Heart Rate / Pulse,Srdcová frekvencia / pulz,
Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Dávka dospelých sa pohybuje od 50 do 80 úderov za minútu.,
Respiratory rate,Dýchacia frekvencia,
Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normálny referenčný rozsah pre dospelého je 16-20 dych / minúta (RCP 2012),
Tongue,jazyk,
Coated,obalený,
Very Coated,Veľmi potiahnuté,
Normal,normálne,
Furry,srstnatý,
Cuts,rezy,
Abdomen,brucho,
Bloated,nafúknutý,
Fluid,tekutina,
Constipated,zápchu,
Reflexes,reflexy,
Hyper,hyper,
Very Hyper,Veľmi Hyper,
One Sided,Jednostranné,
Blood Pressure (systolic),Krvný tlak (systolický),
Blood Pressure (diastolic),Krvný tlak (diastolický),
Blood Pressure,Krvný tlak,
"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normálny pokojový krvný tlak u dospelého pacienta je približne 120 mmHg systolický a diastolický 80 mmHg, skrátený &quot;120/80 mmHg&quot;",
Nutrition Values,Výživové hodnoty,
Height (In Meter),Výška (v metre),
Weight (In Kilogram),Hmotnosť (v kilogramoch),
BMI,BMI,
Hotel Room,Hotelová izba,
Hotel Room Type,Typ izby hotela,
Capacity,kapacita,
Extra Bed Capacity,Kapacita prístelky,
Hotel Manager,Hotelový manažér,
Hotel Room Amenity,Hotel Amenity,
Billable,Zúčtovatelná,
Hotel Room Package,Balík hotelových izieb,
Amenities,Vybavenie,
Hotel Room Pricing,Ceny izieb v hoteli,
Hotel Room Pricing Item,Položka ceny izieb hotela,
Hotel Room Pricing Package,Balík ceny izieb v hoteli,
Hotel Room Reservation,Rezervácia izieb v hoteli,
Guest Name,Meno hosťa,
Late Checkin,Neskoro checkin,
Booked,rezervovaný,
Hotel Reservation User,Používateľ rezervácie hotelov,
Hotel Room Reservation Item,Položka rezervácie izieb hotela,
Hotel Settings,Nastavenia hotela,
Default Taxes and Charges,Východiskové Dane a poplatky,
Default Invoice Naming Series,Predvolená séria pomenovaní faktúr,
HR,HR,
Date on which this component is applied,"Dátum, kedy sa táto zložka použije",
Salary Slip,Výplatná páska,
HR User,HR User,
Job Applicant,Job Žadatel,
Body,telo,
Appraisal Template,Posouzení Template,
Parent Department,Rodičovské oddelenie,
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,Schvaľovateľ voľna,
Expense Approver,Schvalovatel výdajů,
Required Skills,Požadované zručnosti,
Skills,zručností,
Driver,vodič,
HR-DRI-.YYYY.-,HR-DRI-.YYYY.-,
Suspended,suspendovaný,
Transporter,prepravca,
Applicable for external driver,Platí pre externý ovládač,
Cellphone Number,Mobilné číslo,
License Details,Detaily licencie,
License Number,Číslo licencie,
Issuing Date,Dátum vydania,
Driving License Categories,Kategórie vodičských preukazov,
Driving License Category,Kategória vodičského preukazu,
Fleet Manager,fleet manager,
Driver licence class,Trieda vodičského preukazu,
HR-EMP-,HR-EMP,
Employment Type,Typ zaměstnání,
Emergency Contact,Kontakt v nouzi,
Emergency Contact Name,Núdzové kontaktné meno,
Emergency Phone,Nouzový telefon,
ERPNext User,ERPĎalší používateľ,
"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,Vytvoriť povolenie používateľa,
This will restrict user access to other employee records,Tým sa obmedzí prístup používateľov k iným záznamom zamestnancov,
Joining Details,Podrobnosti spojenia,
Offer Date,Dátum Ponuky,
Confirmation Date,Dátum potvrdenia,
Contract End Date,Smlouva Datum ukončení,
Notice (days),Oznámenie (dni),
Date Of Retirement,Dátum odchodu do dôchodku,
Department and Grade,Oddelenie a trieda,
Reports to,Zprávy,
Attendance and Leave Details,Účasť a podrobnosti o dovolenke,
Attendance Device ID (Biometric/RF tag ID),ID dochádzkového zariadenia (biometrické / RF ID značky),
Applicable Holiday List,Použitelný Seznam Svátků,
Default Shift,Predvolená zmena,
Salary Mode,Mode Plat,
Bank A/C No.,"Č, bank. účtu",
Health Insurance,Zdravotné poistenie,
Health Insurance Provider,Poskytovateľ zdravotného poistenia,
Health Insurance No,Zdravotné poistenie č,
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,E-mail spoločnosti,
Provide Email Address registered in company,Poskytnúť e-mailovú adresu registrovanú vo firme,
Current Address Is,Aktuálna adresa je,
Current Address,Aktuálna adresa,
Personal Bio,Osobná bio,
Bio / Cover Letter,Bio / Cover Letter,
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é pomery,
"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 si můžete udržet 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 priepustky,
Leave Encashed?,Ponechte zpeněžení?,
Encashment Date,Inkaso Datum,
New Workplace,Nové pracovisko,
Returned Amount,Vrátená suma,
Advance Account,Advance účet,
Benefits Applied,Výhody aplikované,
Benefit Type and Amount,Druh dávky a výška dávky,
Task Weight,úloha Hmotnosť,
Employee Education,Vzdelávanie zamestnancov,
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,Externá pracovná história zamestnanca,
Total Experience,Celková zkušenost,
Default Leave Policy,Predvolené pravidlá pre dovolenku,
Employee Group Table,Tabuľka skupiny zamestnancov,
ERPNext User ID,ERPĎalšie ID používateľa,
Employee Internal Work History,Interní historie práce zaměstnance,
Activities,aktivity,
Employee Onboarding Activity,Činnosť zamestnancov na palube,
Employee Promotion Detail,Podrobnosti o propagácii zamestnancov,
Employee Transfer Property,Vlastníctvo prevodu zamestnancov,
Unclaimed amount,Nevyžiadaná suma,
Holiday List Name,Názov zoznamu sviatkov,
Total Holidays,Celkové prázdniny,
Add Weekly Holidays,Pridajte týždenné sviatky,
Weekly Off,Týdenní Off,
Add to Holidays,Pridať do sviatkov,
Holidays,Prázdniny,
Clear Table,Clear Table,
Retirement Age,dôchodkový vek,
Enter retirement age in years,Zadajte vek odchodu do dôchodku v rokoch,
Stop Birthday Reminders,Zastaviť pripomenutie narodenín,
Leave Settings,Nechajte nastavenia,
Accepted,Přijato,
Printing Details,Detaily tlače,
Job Title,Názov pozície,
Allocation,Pridelenie,
Select Employees,Vybrať Zamestnanci,
Allocate,Přidělit,
Max Leaves Allowed,Max povolené povolenia,
Maximum Continuous Days Applicable,Maximálne nepretržité dni,
Select Payroll Period,Vyberte mzdové,
Abbr,Zkr,
Condition and Formula,Podmienka a vzorec,
Total Working Hours,Celkovej pracovnej doby,
Hour Rate,Hodinová sadzba,
Bank Account No.,Číslo bankového účtu,
Earning & Deduction,Príjem a odpočty,
Loan repayment,Splácanie úveru,
Employee Loan,Pôžička zamestnanca,
Total Principal Amount,Celková hlavná čiastka,
Total Interest Amount,Celková výška úroku,
Total Loan Repayment,celkové splátky,
net pay info,Čistá mzda info,
Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Total dedukcie - splátky,
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.",
Staffing Plan Details,Podrobnosti personálneho plánu,
Optional,voliteľný,
Costing,Rozpočet,
Vehicle,vozidlo,
License Plate,Poznávacia značka,
Odometer Value (Last),Hodnota počítadla kilometrov (Last),
Acquisition Date,akvizície Dátum,
Chassis No,Číslo podvozku,
Vehicle Value,hodnota vozidla,
Insurance Details,poistenie Podrobnosti,
Insurance Company,Poisťovňa,
Policy No,nie politika,
Additional Details,Ďalšie podrobnosti,
Fuel Type,Druh paliva,
Petrol,benzín,
Diesel,Diesel,
Natural Gas,Zemný plyn,
Electric,elektrický,
Fuel UOM,palivo UOM,
Last Carbon Check,Posledné Carbon Check,
Wheels,kolesá,
Doors,dvere,
last Odometer Value ,posledná hodnota počítadla kilometrov,
Service Detail,servis Detail,
Hub Tracked Item,Pásová sledovaná položka,
Hub Node,Hub Node,
Image List,Zoznam obrázkov,
Item Manager,Manažér položiek,
Hub User,Používateľ Hubu,
Hub Password,Heslo Hubu,
Hub Users,Používatelia Hubu,
Marketplace Settings,Nastavenia trhov,
Disable Marketplace,Zakázať trhovisko,
Marketplace URL (to hide and update label),Adresa URL Marketplace (skryť a aktualizovať štítok),
Registered,registrovaný,
Sync in Progress,Priebeh synchronizácie,
Hub Seller Name,Názov predajcu Hubu,
Custom Data,Vlastné údaje,
Repay From Salary,Splatiť z platu,
Regular Payment,Pravidelná platba,
Loan Closure,Uzavretie úveru,
Rate of Interest (%) Yearly,Úroková sadzba (%) Ročné,
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á väzba od zákazníkov,
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,Objednávka tovaru,
Ordered Quantity,Objednané množstvo,
Item to be manufactured or repacked,Položka být vyráběn nebo znovu zabalena,
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 rýchlosť položky podsúboru na základe kusovníka,
Allow Alternative Item,Povoliť alternatívnu položku,
Item UOM,MJ položky,
Conversion Rate,Konverzný kurz,
Rate Of Materials Based On,Hodnotit materiálů na bázi,
With Operations,S operacemi,
Manage cost of operations,Správa nákladů na provoz,
Transfer Material Against,Preneste materiál proti,
Routing,Smerovanie,
Materials,Materiály,
Quality Inspection Required,Vyžaduje sa kontrola kvality,
Quality Inspection Template,Šablóna inšpekcie 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),Prevádzkové náklady (Company mena),
Raw Material Cost (Company Currency),Náklady na suroviny (mena spoločnosti),
Scrap Material Cost(Company Currency),Šrot materiálové náklady (Company mena),
Total Cost,Celkové náklady,
Total Cost (Company Currency),Celkové náklady (mena spoločnosti),
Materials Required (Exploded),Potřebný materiál (Rozložený),
Exploded Items,Rozložené položky,
Show in Website,Zobraziť na webe,
Item Image (if not slideshow),Item Image (ne-li slideshow),
Thumbnail,Thumbnail,
Website Specifications,Webových stránek Specifikace,
Show Items,Zobraziť položky,
Show Operations,ukázať 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,Zahrnúť položku do výroby,
BOM Item,BOM Item,
Item operation,Funkcia položky,
Rate & Amount,Sadzba a množstvo,
Basic Rate (Company Currency),Basic Rate (Company měny),
Scrap %,Scrap%,
Original Item,Pôvodná položka,
BOM Operation,BOM Operation,
Operation Time ,Čas prevádzky,
In minutes,O pár minút,
Batch Size,Veľkosť šarže,
Base Hour Rate(Company Currency),Základňa hodinová sadzba (Company meny),
Operating Cost(Company Currency),Prevádzkové náklady (Company mena),
BOM Scrap Item,BOM Scrap Item,
Basic Amount (Company Currency),Základná suma (Company mena),
BOM Update Tool,Nástroj na aktualizáciu kusovníka,
"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.","Nahradiť konkrétny kusovník vo všetkých ostatných kusovníkoch, kde sa používa. Bude nahradiť starý odkaz BOM, aktualizovať cenu a obnoviť tabuľku &quot;BOM Explosion Item&quot; podľa nového kusovníka. Aktualizuje tiež poslednú cenu vo všetkých kusovníkoch.",
Replace BOM,Nahraďte kusovník,
Current BOM,Aktuální BOM,
The BOM which will be replaced,"BOM, který bude nahrazen",
The new BOM after replacement,Nový BOM po výměně,
Replace,Vyměnit,
Update latest price in all BOMs,Aktualizujte najnovšiu cenu vo všetkých kusovníkoch,
BOM Website Item,BOM Website Item,
BOM Website Operation,BOM Website Operation,
Operation Time,Provozní doba,
PO-JOB.#####,PO-JOB. #####,
Timing Detail,Časový detail,
Time Logs,Čas Záznamy,
Total Time in Mins,Celkový čas v minútach,
Operation ID,ID operácie,
Transferred Qty,Přenesená Množství,
Job Started,Úloha sa začala,
Started Time,Čas začiatku,
Current Time,Aktuálny čas,
Job Card Item,Položka Job Card,
Job Card Time Log,Denník pracovných kariet,
Time In Mins,Čas v minútach,
Completed Qty,Dokončené množstvo,
Manufacturing Settings,Nastavenia Výroby,
Raw Materials Consumption,Spotreba surovín,
Allow Multiple Material Consumption,Povoliť viacnásobnú spotrebu materiálu,
Backflush Raw Materials Based On,So spätným suroviny na základe,
Material Transferred for Manufacture,Prevádza jadrový materiál pre Výroba,
Capacity Planning,Plánovanie kapacít,
Disable Capacity Planning,Vypnite plánovanie kapacity,
Allow Overtime,Povoliť Nadčasy,
Allow Production on Holidays,Povolit Výrobu při dovolené,
Capacity Planning For (Days),Plánovanie kapacít Pro (dni),
Default Warehouses for Production,Predvolené sklady na výrobu,
Default Work In Progress Warehouse,Východiskové prácu v sklade Progress,
Default Finished Goods Warehouse,Predvolený sklad hotových výrobkov,
Default Scrap Warehouse,Predvolený sklad šrotu,
Overproduction Percentage For Sales Order,Percento nadprodukcie pre objednávku predaja,
Overproduction Percentage For Work Order,Percento nadprodukcie pre pracovnú objednávku,
Other Settings,ďalšie nastavenie,
Update BOM Cost Automatically,Automaticky sa aktualizuje cena kusovníka,
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,Poskytnuté zákazníkom,
Minimum Order Quantity,Minimálna objednávka,
Default Workstation,Výchozí Workstation,
Production Plan,Výrobný plán,
MFG-PP-.YYYY.-,MFG-PP-.YYYY.-,
Get Items From,Získať predmety z,
Get Sales Orders,Získat Prodejní objednávky,
Material Request Detail,Podrobnosti o vyžiadaní materiálu,
Get Material Request,Získať Materiál Request,
Material Requests,materiál Žiadosti,
Get Items For Work Order,Získajte položky pre pracovnú objednávku,
Material Request Planning,Plánovanie žiadostí o materiál,
Include Non Stock Items,"Zahrňte položky, ktoré nie sú na sklade",
Include Subcontracted Items,Zahrňte subdodávateľné položky,
Ignore Existing Projected Quantity,Ignorujte existujúce predpokladané množstvo,
"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>.","Ak sa chcete dozvedieť viac o plánovanom množstve, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">kliknite sem</a> .",
Download Required Materials,Stiahnite si požadované materiály,
Get Raw Materials For Production,Získajte suroviny pre 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,Vykonajte objednávku práce pre položky podzostavy,
"If enabled, system will create the work order for the exploded items against which BOM is available.","Ak je povolený, systém vytvorí pracovný príkaz pre rozložené položky, proti ktorým je kusovník k dispozícii.",
Planned Start Date,Plánované datum zahájení,
Quantity and Description,Množstvo a popis,
material_request_item,material_request_item,
Product Bundle Item,Položka produktového balíčka,
Production Plan Material Request,Výroba Dopyt Plán Materiál,
Production Plan Sales Order,Výrobní program prodejní objednávky,
Sales Order Date,Dátum predajnej objednávky,
Routing Name,Názov smerovania,
MFG-WO-.YYYY.-,MFG-WO-.YYYY.-,
Item To Manufacture,Bod K výrobě,
Material Transferred for Manufacturing,Materiál Prenesená pre 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,Preskočiť prenos materiálu do skladu WIP,
Check if material transfer entry is not required,"Skontrolujte, či sa nepožaduje zadávanie materiálu",
Backflush Raw Materials From Work-in-Progress Warehouse,Spätné suroviny z nedokončeného skladu,
Update Consumed Material Cost In Project,Aktualizácia spotrebovaných materiálových nákladov v projekte,
Warehouses,Sklady,
This is a location where raw materials are available.,"Toto je miesto, kde sú k dispozícii suroviny.",
Work-in-Progress Warehouse,Work-in-Progress sklad,
This is a location where operations are executed.,"Toto je miesto, kde sa vykonávajú operácie.",
This is a location where final product stored.,"Toto je miesto, kde je uložený konečný produkt.",
Scrap Warehouse,šrot Warehouse,
This is a location where scraped materials are stored.,"Toto je miesto, kde sa skladujú zoškrabané materiály.",
Required Items,povinné predmety,
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 pracovnej objednávky,
Available Qty at Source Warehouse,Dostupné množstvo v zdrojovom sklade,
Available Qty at WIP Warehouse,Dostupné množstvo v WIP Warehouse,
Work Order Operation,Obsluha pracovnej objednávky,
Operation Description,Operace Popis,
Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?,
Work in Progress,Work in Progress,
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 minútach,
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 minútach \n aktualizované pomocou ""Time Log""",
(Hour Rate / 60) * Actual Operation Time,(Hodina Rate / 60) * Skutočná Prevádzková doba,
Workstation Name,Meno pracovnej stanice,
Production Capacity,Výrobná kapacita,
Operating Costs,Provozní náklady,
Electricity Cost,Cena elektřiny,
per hour,za hodinu,
Consumable Cost,Spotrebné náklady,
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á aplikácia,
Name of Applicant,Meno žiadateľa,
Certification Status,Stav certifikácie,
Yet to appear,Napriek tomu sa objaví,
Certified,certifikované,
Not Certified,Nie je certifikovaný,
USD,Americký dolár,
INR,INR,
Certified Consultant,Certifikovaný konzultant,
Name of Consultant,Názov konzultanta,
Certification Validity,Platnosť certifikátu,
Discuss ID,Diskutujte ID,
GitHub ID,Identifikátor GitHub,
Non Profit Manager,Neziskový manažér,
Chapter Head,Kapitola hlavu,
Meetup Embed HTML,Meetup Vložiť HTML,
chapters/chapter_name\nleave blank automatically set after saving chapter.,kapitoly / názov_kategórie nechajte prázdne automaticky nastavené po uložení kapitoly.,
Chapter Members,Členovia kapitoly,
Members,členovia,
Chapter Member,Člen kapitoly,
Website URL,URL webu,
Leave Reason,Nechajte dôvod,
Donor Name,Názov darcu,
Donor Type,Typ darcu,
Withdrawn,uzavretý,
Grant Application Details ,Podrobnosti o žiadosti o grant,
Grant Description,Názov grantu,
Requested Amount,Požadovaná suma,
Has any past Grant Record,Má nejaký predchádzajúci grantový záznam,
Show on Website,Zobraziť na webovej stránke,
Assessment  Mark (Out of 10),Značka hodnotenia (z 10),
Assessment  Manager,Manažér pre hodnotenie,
Email Notification Sent,E-mailové upozornenie bolo odoslané,
NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
Membership Expiry Date,Dátum ukončenia členstva,
Razorpay Details,Razorpay podrobnosti,
Subscription ID,ID predplatného,
Customer ID,ID zákazníka,
Subscription Activated,Predplatné aktivované,
Subscription Start ,Spustenie predplatného,
Subscription End,Koniec predplatného,
Non Profit Member,Neziskový člen,
Membership Status,Stav členstva,
Member Since,Členom od,
Payment ID,ID platby,
Membership Settings,Nastavenia členstva,
Enable RazorPay For Memberships,Povoliť RazorPay pre členstvá,
RazorPay Settings,Nastavenia RazorPay,
Billing Cycle,Fakturačný cyklus,
Billing Frequency,Frekvencia fakturácie,
"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 cyklov, za ktoré by sa zákazníkovi mali účtovať poplatky. Napríklad ak si zákazník kupuje ročné členstvo, ktoré by sa malo fakturovať mesačne, mala by byť táto hodnota 12.",
Razorpay Plan ID,Razorpay plán ID,
Volunteer Name,Názov dobrovoľníka,
Volunteer Type,Typ dobrovoľníka,
Availability and Skills,Dostupnosť a zručnosti,
Availability,Dostupnosť,
Weekends,víkendy,
Availability Timeslot,Dostupnosť Timeslot,
Morning,dopoludnia,
Afternoon,Popoludnie,
Evening,Večer,
Anytime,kedykoľvek,
Volunteer Skills,Dobrovoľnícke zručnosti,
Volunteer Skill,Dobrovoľnícka zručnosť,
Homepage,Úvodné,
Hero Section Based On,Hero Section Na základe,
Homepage Section,Domovská stránka,
Hero Section,Sekcia hrdinov,
Tag Line,tag linka,
Company Tagline for website homepage,Firemný slogan na titulnej stránke webu,
Company Description for website homepage,Spoločnosť Popis pre webové stránky domovskú stránku,
Homepage Slideshow,Domovská stránka Slideshow,
"URL for ""All Products""",URL pre &quot;všetky produkty&quot;,
Products to be shown on website homepage,"Produkty, ktoré majú byť uvedené na internetových stránkach domovskej",
Homepage Featured Product,Úvodná Odporúčané tovar,
route,trasa,
Section Based On,Časť založená na,
Section Cards,Karty sekcií,
Number of Columns,Počet stĺpcov,
Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Počet stĺpcov pre túto sekciu. Ak vyberiete 3 stĺpce, zobrazia sa 3 karty na riadok.",
Section HTML,Sekcia HTML,
Use this field to render any custom HTML in the section.,Toto pole slúži na vykreslenie vlastného HTML v tejto sekcii.,
Section Order,Poradie sekcií,
"Order in which sections should appear. 0 is first, 1 is second and so on.","Poradie, v ktorom sa majú sekcie zobraziť. 0 je prvý, 1 je druhý a tak ďalej.",
Homepage Section Card,Karta sekcie domovskej stránky,
Subtitle,podtitul,
Products Settings,nastavenie 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","Ak je zaškrtnuté, domovská stránka bude východiskový bod skupina pre webové stránky",
Show Availability Status,Zobraziť stav dostupnosti,
Product Page,Stránka produktu,
Products per Page,Produkty na stránku,
Enable Field Filters,Povoliť filtre polí,
Item Fields,Polia položky,
Enable Attribute Filters,Povoliť filtre atribútov,
Attributes,Atribúty,
Hide Variants,Skryť varianty,
Website Attribute,Atribút webovej stránky,
Attribute,Atribút,
Website Filter Field,Pole filtra webových stránok,
Activity Cost,Náklady Aktivita,
Billing Rate,Fakturačná cena,
Costing Rate,Sadzba kalkulácie nákladov,
title,titul,
Projects User,Projekty uživatele,
Default Costing Rate,Predvolená sadzba kalkulácie nákladov,
Default Billing Rate,Predvolené fakturácia Rate,
Dependent Task,Závislá úloha,
Project Type,Typ projektu,
% Complete Method,Dokončené% Method,
Task Completion,úloha Dokončenie,
Task Progress,pokrok úloha,
% Completed,% Dokončených,
From Template,Zo šablóny,
Project will be accessible on the website to these users,Projekt bude k dispozícii na webových stránkach k týmto užívateľom,
Copied From,Skopírované z,
Start and End Dates,Dátum začatia a ukončenia,
Actual Time in Hours (via Timesheet),Skutočný čas (v hodinách),
Costing and Billing,Kalkulácia a fakturácia,
Total Costing Amount (via Timesheet),Celková výška sumy (prostredníctvom časových rozpisov),
Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nárokov),
Total Purchase Cost (via Purchase Invoice),Celkové obstarávacie náklady (cez nákupné faktúry),
Total Sales Amount (via Sales Order),Celková výška predaja (prostredníctvom objednávky predaja),
Total Billable Amount (via Timesheet),Celková fakturovaná suma (prostredníctvom dochádzky),
Total Billed Amount (via Sales Invoice),Celková fakturovaná suma (prostredníctvom faktúr za predaj),
Total Consumed Material Cost (via Stock Entry),Celková spotreba materiálových nákladov (prostredníctvom vkladu),
Gross Margin,Hrubá marža,
Gross Margin %,Hrubá Marža %,
Monitor Progress,Monitorovanie pokroku,
Collect Progress,Zbierajte postup,
Frequency To Collect Progress,Frekvencia na zhromažďovanie pokroku,
Twice Daily,Dva krát denne,
First Email,Prvý e-mail,
Second Email,Druhý e-mail,
Time to send,Čas odoslania,
Day to Send,Deň na odoslanie,
Message will be sent to the users to get their status on the Project,Užívateľom sa odošle správa s cieľom zistiť ich stav v projekte,
Projects Manager,Správce projektů,
Project Template,Šablóna projektu,
Project Template Task,Úloha šablóny projektu,
Begin On (Days),Začať dňa (dni),
Duration (Days),Trvanie (dni),
Project Update,Aktualizácia projektu,
Project User,projekt Užívateľ,
View attachments,Zobraziť prílohy,
Projects Settings,Nastavenia projektov,
Ignore Workstation Time Overlap,Ignorovať prekrytie pracovnej doby,
Ignore User Time Overlap,Ignorovať prekrytie času používateľa,
Ignore Employee Time Overlap,Ignorovať prekrytie času zamestnanca,
Weight,váha,
Parent Task,Rodičovská úloha,
Timeline,časová os,
Expected Time (in hours),Predpokladaná doba (v hodinách),
% Progress,% Progress,
Is Milestone,Je míľnikom,
Task Description,Popis úlohy,
Dependencies,závislosti,
Dependent Tasks,Závislé úlohy,
Depends on Tasks,Závisí na úlohách,
Actual Start Date (via Timesheet),Skutočný dátum začatia (cez Časový rozvrh),
Actual Time in Hours (via Timesheet),Skutočná doba (v hodinách),
Actual End Date (via Timesheet),Skutočný dátum ukončenia (cez Time Sheet),
Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku),
Review Date,Review Datum,
Closing Date,Uzávěrka Datum,
Task Depends On,Úloha je závislá na,
Task Type,Typ úlohy,
TS-.YYYY.-,TS-.RRRR.-,
Employee Detail,Detail zamestnanca,
Billing Details,fakturačné údaje,
Total Billable Hours,Celkovo zúčtované hodiny,
Total Billed Hours,Celkom Predpísané Hodiny,
Total Costing Amount,Celková kalkulácie Čiastka,
Total Billable Amount,Celková fakturovaná suma,
Total Billed Amount,Celková suma Fakturovaný,
% Amount Billed,% Fakturovanej čiastky,
Hrs,hod,
Costing Amount,Nákladová Čiastka,
Corrective/Preventive,Nápravné / preventívne,
Corrective,nápravný,
Preventive,preventívna,
Resolution,Řešení,
Resolutions,rezolúcia,
Quality Action Resolution,Kvalitné akčné rozlíšenie,
Quality Feedback Parameter,Parameter spätnej väzby kvality,
Quality Feedback Template Parameter,Parameter šablóny spätnej väzby kvality,
Quality Goal,Cieľ kvality,
Monitoring Frequency,Frekvencia monitorovania,
Weekday,všedný deň,
Objectives,ciele,
Quality Goal Objective,Cieľ kvality,
Objective,objektívny,
Agenda,program,
Minutes,minúty,
Quality Meeting Agenda,Program rokovania o kvalite,
Quality Meeting Minutes,Zápisnica zo zasadnutia o kvalite,
Minute,Minúta,
Parent Procedure,Rodičovský postup,
Processes,Procesy,
Quality Procedure Process,Proces kvality,
Process Description,Popis procesu,
Link existing Quality Procedure.,Prepojiť existujúci postup kvality.,
Additional Information,Ďalšie informácie,
Quality Review Objective,Cieľ preskúmania kvality,
DATEV Settings,Nastavenia DATEV,
Regional,regionálne,
Consultant ID,ID konzultanta,
GST HSN Code,GST kód HSN,
HSN Code,Kód HSN,
GST Settings,Nastavenia GST,
GST Summary,Súhrn GST,
GSTIN Email Sent On,GSTIN E-mail odoslaný 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 faktúry pre B2C. B2CL a B2CS vypočítané na základe tejto hodnoty faktúry.,
GSTR 3B Report,Správa GSTR 3B,
January,január,
February,február,
March,marec,
April,apríl,
August,august,
September,septembra,
October,október,
November,november,
December,December,
JSON Output,Výstup JSON,
Invoices with no Place Of Supply,Faktúry bez miesta dodania,
Import Supplier Invoice,Importovať dodávateľskú faktúru,
Invoice Series,Fakturačná séria,
Upload XML Invoices,Odovzdajte faktúry XML,
Zip File,Súbor ZIP,
Import Invoices,Importovať faktúry,
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 pripojení súboru zip k dokumentu kliknite na tlačidlo Importovať faktúry. Všetky chyby týkajúce sa spracovania sa zobrazia v protokole chýb.,
Lower Deduction Certificate,Osvedčenie o znížení odpočtu,
Certificate Details,Podrobnosti o certifikáte,
194A,194A,
194C,194C,
194D,194D,
194H,194H,
194I,194I,
194J,194J,
194LA,194LA,
194LBB,194LBB,
194LBC,194LBC,
Certificate No,Osvedčenie č,
Deductee Details,Podrobnosti odvedeného,
PAN No,PAN č,
Validity Details,Platnosť,
Rate Of TDS As Per Certificate,Sadzba TDS podľa certifikátu,
Certificate Limit,Limit certifikátu,
Invoice Series Prefix,Prefix radu faktúr,
Active Menu,Aktívna ponuka,
Restaurant Menu,Reštaurácia,
Price List (Auto created),Cenník (vytvorený automaticky),
Restaurant Manager,Manažér reštaurácie,
Restaurant Menu Item,Položka ponuky Reštaurácia,
Restaurant Order Entry,Vstup do objednávky reštaurácie,
Restaurant Table,Reštaurácia Tabuľka,
Click Enter To Add,Kliknite na položku Zadat &#39;na pridanie,
Last Sales Invoice,Posledná faktúra predaja,
Current Order,Aktuálna objednávka,
Restaurant Order Entry Item,Položka objednávky reštaurácie,
Served,slúžil,
Restaurant Reservation,Rezervácia reštaurácie,
Waitlisted,poradovníka,
No Show,Žiadne zobrazenie,
No of People,Počet ľudí,
Reservation Time,Čas rezervácie,
Reservation End Time,Čas ukončenia rezervácie,
No of Seats,Počet sedadiel,
Minimum Seating,Minimálne sedenie,
"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Majte prehľad o predajných kampaniach. Majte prehľad o Iniciatívach, ponukách, objednávkach z kampane, aby ste zistili, návratnosť investície.",
SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-,
Campaign Schedules,Harmonogramy kampaní,
Buyer of Goods and Services.,Kupující zboží a služeb.,
CUST-.YYYY.-,CUST-.YYYY.-,
Default Company Bank Account,Predvolený firemný bankový účet,
From Lead,Od Obchodnej iniciatívy,
Account Manager,Account Manager,
Allow Sales Invoice Creation Without Sales Order,Povoliť vytváranie predajných faktúr bez zákazky odberateľa,
Allow Sales Invoice Creation Without Delivery Note,Povoliť vytváranie predajných faktúr bez dodacieho listu,
Default Price List,Predvolený cenník,
Primary Address and Contact Detail,Primárna adresa a podrobnosti kontaktu,
"Select, to make the customer searchable with these fields","Vyberte, ak chcete, aby sa zákazník stal pomocou týchto polí",
Customer Primary Contact,Primárny kontakt zákazníka,
"Reselect, if the chosen contact is edited after save","Znova vyberte, ak sa zvolený kontakt upraví po uložení",
Customer Primary Address,Primárna adresa zákazníka,
"Reselect, if the chosen address is edited after save","Znovu zvoľte, ak je zvolená adresa upravená po uložení",
Primary Address,Primárna adresa,
Mention if non-standard receivable account,Zmienka v prípade neštandardnej pohľadávky účet,
Credit Limit and Payment Terms,Úverový limit a platobné podmienky,
Additional information regarding the customer.,Ďalšie informácie týkajúce sa zákazníka.,
Sales Partner and Commission,Partner predaja a provízia,
Commission Rate,Výška provízie,
Sales Team Details,Podrobnosti prodejní tým,
Customer POS id,ID zákazníka,
Customer Credit Limit,Kreditný limit zákazníka,
Bypass Credit Limit Check at Sales Order,Zablokujte kontrolu kreditného limitu na objednávke,
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,Zdroj Iniciatívy,
Period Start Date,Dátum začiatku obdobia,
Period End Date,Dátum ukončenia obdobia,
Cashier,Pokladník,
Difference,Rozdiel,
Modes of Payment,Spôsoby platby,
Linked Invoices,Prepojené faktúry,
POS Closing Voucher Details,Podrobnosti o uzatvorení dokladu POS,
Collected Amount,Zozbieraná suma,
Expected Amount,Očakávaná suma,
POS Closing Voucher Invoices,Faktúry POS uzatváracieho dokladu,
Quantity of Items,Množstvo položiek,
"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","Súhrnný skupina ** položiek ** do iného ** Položka **. To je užitočné, ak sa zväzovanie niektoré položky ** ** do balíka a budete udržiavať zásoby balených ** Položky ** a nie agregát ** položky **. Balíček ** Položka ** bude mať &quot;Je skladom,&quot; ako &quot;Nie&quot; a &quot;Je predaja Item&quot; ako &quot;Yes&quot;. Napríklad: Ak predávate notebooky a batohy oddelene a majú špeciálnu cenu, ak zákazník kúpi obidva, potom Laptop + Backpack bude nový Bundle Product Item. Poznámka: BOM = Nomenklatúra",
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,Ponuka k,
Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou zákazník měny je převeden na společnosti základní měny",
Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou Ceník měna je převedena na společnosti základní měny",
Additional Discount and Coupon Code,Dodatočný zľavový a kupónový kód,
Referral Sales Partner,Sprostredkovateľský predajca,
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 ponuky,
Against Doctype,Proti DOCTYPE,
Against Docname,Proti Docname,
Additional Notes,Doplňujúce Poznámky,
SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
Skip Delivery Note,Preskočiť 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,Stav fakturácie a dodania,
Not Delivered,Nedodané,
Fully Delivered,Plně Dodáno,
Partly Delivered,Částečně vyhlášeno,
Not Applicable,Nehodí se,
%  Delivered,% Dodaných,
% of materials delivered against this Sales Order,% materiálov dodaných proti tejto Predajnej objednávke,
% of materials billed against this Sales Order,% Materiálov fakturovaných proti tejto Predajnej objednávke,
Not Billed,Nevyúčtované,
Fully Billed,Plně Fakturovaný,
Partly Billed,Částečně Účtovaný,
Ensure Delivery Based on Produced Serial No,Zabezpečte doručenie na základe vyrobeného sériového čísla,
Supplier delivers to Customer,Dodávateľ doručí zákazníkovi,
Delivery Warehouse,Dodací sklad,
Planned Quantity,Plánované Množstvo,
For Production,Pro Výrobu,
Work Order Qty,Počet pracovných zákaziek,
Produced Quantity,Vyrobené Množstvo,
Used for Production Plan,Používá se pro výrobní plán,
Sales Partner Type,Typ obchodného partnera,
Contact No.,Kontakt Číslo,
Contribution (%),Príspevok (%),
Contribution to Net Total,Príspevok na celkom netto,
Selling Settings,Nastavenia pre Predaj,
Settings for Selling Module,Nastavenie modulu Predaj,
Customer Naming By,Zákazník Pojmenování By,
Campaign Naming By,Pomenovanie kampane podľa,
Default Customer Group,Výchozí Customer Group,
Default Territory,Výchozí Territory,
Close Opportunity After Days,Close Opportunity po niekoľkých dňoch,
Default Quotation Validity Days,Predvolené dni platnosti cenovej ponuky,
Sales Update Frequency,Frekvencia aktualizácie predaja,
Each Transaction,Každá Transakcia,
SMS Center,SMS centrum,
Send To,Odoslať na,
All Contact,Vše Kontakt,
All Customer Contact,Všetky Kontakty Zákazníka,
All Supplier Contact,Vše Dodavatel Kontakt,
All Sales Partner Contact,Všechny Partneři Kontakt,
All Lead (Open),Všetky Iniciatívy (Otvorené),
All Employee (Active),Všichni zaměstnanci (Aktivní),
All Sales Person,Všichni obchodní zástupci,
Create Receiver List,Vytvoriť zoznam príjemcov,
Receiver List,Zoznam príjemcov,
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 alebo položka,
Customer / Item Name,Názov zákazníka/položky,
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álenie role (nad oprávnenej hodnoty),
Approving User  (above authorized value),Schválenie užívateľa (nad oprávnenej hodnoty),
Brand Defaults,Predvolené 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,Zmeniť skratku,
Parent Company,Materská spoločnosť,
Default Values,Predvolené hodnoty,
Default Holiday List,Východzí zoznam sviatkov,
Default Selling Terms,Predvolené podmienky predaja,
Default Buying Terms,Predvolené nákupné podmienky,
Create Chart Of Accounts Based On,Vytvorte účtový rozvrh založený na,
Standard Template,štandardná šablóna,
Existing Company,Existujúca spoločnosť,
Chart Of Accounts Template,Šablóna účtovného rozvrhu,
Existing Company ,existujúce Company,
Date of Establishment,Dátum založenia,
Sales Settings,Nastavenia predaja,
Monthly Sales Target,Mesačný cieľ predaja,
Sales Monthly History,Mesačná história predaja,
Transactions Annual History,Výročná história transakcií,
Total Monthly Sales,Celkový mesačný predaj,
Default Cash Account,Výchozí Peněžní účet,
Default Receivable Account,Výchozí pohledávek účtu,
Round Off Cost Center,Zaokrúhliť nákladové stredisko,
Discount Allowed Account,Zľavový účet,
Discount Received Account,Zľavový prijatý účet,
Exchange Gain / Loss Account,Exchange Zisk / straty,
Unrealized Exchange Gain/Loss Account,Nerealizovaný účet ziskov a strát na výmene,
Allow Account Creation Against Child Company,Povoliť vytvorenie účtu proti dcérskej spoločnosti,
Default Payable Account,Výchozí Splatnost účtu,
Default Employee Advance Account,Predvolený účet predvoleného zamestnanca,
Default Cost of Goods Sold Account,Východiskové Náklady na predaný tovar účte,
Default Income Account,Predvolený účet príjmov,
Default Deferred Revenue Account,Predvolený účet odloženého výnosu,
Default Deferred Expense Account,Predvolený účet odloženého výdavku,
Default Payroll Payable Account,"Predvolené mzdy, splatnú Account",
Default Expense Claim Payable Account,Splatný účet s predpokladaným výdavkom,
Stock Settings,Nastavenie Skladu,
Enable Perpetual Inventory,Povoliť trvalý inventár,
Default Inventory Account,Predvolený inventárny účet,
Stock Adjustment Account,Reklamní Nastavení účtu,
Fixed Asset Depreciation Settings,Nastavenie odpisovania dlhodobého majetku,
Series for Asset Depreciation Entry (Journal Entry),Séria pre odpisy majetku (záznam v účte),
Gain/Loss Account on Asset Disposal,Zisk / straty na majetku likvidáciu,
Asset Depreciation Cost Center,Asset Odpisy nákladového strediska,
Budget Detail,Detail Rozpočtu,
Exception Budget Approver Role,Role prístupu k výnimke rozpočtu,
Company Info,Informácie o spoločnosti,
For reference only.,Pouze orientační.,
Company Logo,Logo spoločnosti,
Date of Incorporation,Dátum začlenenia,
Date of Commencement,Dátum začiatku,
Phone No,Telefónne číslo,
Company Description,Popis firmy,
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,Zmazať transakcie spoločnosti,
Currency Exchange,Zmenáreň,
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,Pre nákup,
For Selling,Pre predaj,
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,Zmienka v prípade neštandardnej pohľadávky účet použiteľná,
Credit Limits,Úverové 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 nebude odoslaný neaktívnym používateľom,
Profit & Loss,Zisk & Strata,
New Income,new príjmov,
New Expenses,nové výdavky,
Annual Income,Ročný príjem,
Annual Expenses,ročné náklady,
Bank Balance,Bankový zostatok,
Bank Credit Balance,Zostatok bankového úveru,
Receivables,Pohľadávky,
Payables,Závazky,
Sales Orders to Bill,Predajné príkazy k Billovi,
Purchase Orders to Bill,Objednávky k nákupu,
New Sales Orders,Nové Prodejní objednávky,
New Purchase Orders,Nové vydané objednávky,
Sales Orders to Deliver,Predajné príkazy na dodanie,
Purchase Orders to Receive,Nákupné príkazy na príjem,
New Purchase Invoice,Nová nákupná faktúra,
New Quotations,Nové Citace,
Open Quotations,Otvorené citácie,
Open Issues,Otvorené problémy,
Open Projects,Otvorené projekty,
Purchase Orders Items Overdue,Položky nákupných objednávok Po splatnosti,
Upcoming Calendar Events,Nadchádzajúce udalosti kalendára,
Open To Do,Otvoriť úlohu,
Add Quote,Pridať ponuku,
Global Defaults,Globální Výchozí,
Default Company,Predvolená spoločnosť,
Current Fiscal Year,Aktuálny fiškálny rok,
Default Distance Unit,Predvolená vzdialenosť jednotky,
Hide Currency Symbol,Skrýt symbol měny,
Do not show any symbol like $ etc next to currencies.,Neukazovať žiadny symbol ako $ atď vedľa meny.,
"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ázať v slovách,
"If disable, 'In Words' field will not be visible in any transaction","Pokiaľ zakázať, &quot;v slovách&quot; poli nebude viditeľný v akejkoľvek transakcie",
Item Classification,Položka Klasifikace,
General Settings,Všeobecné nastavenia,
Item Group Name,Názov položkovej skupiny,
Parent Item Group,Parent Item Group,
Item Group Defaults,Predvolené položky skupiny položiek,
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í na první místo v seznamu výrobků.",
Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakcí,
Setup Series,Řada Setup,
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.,
Quotation Lost Reason,Dôvod neúspešnej ponuky,
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,Meno predajného partnera,
Partner Type,Partner Type,
Address & Contacts,Adresa a kontakty,
Address Desc,Popis adresy,
Contact Desc,Opis kontaktu,
Sales Partner Target,Sales Partner Target,
Targets,Cíle,
Show In Website,Zobraziť na webstránke,
Referral Code,referenčný kód,
To Track inbound purchase,Ak chcete sledovať prichádzajúci 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,Meno a ID zamestnanca,
Sales Person Name,Meno predajcu,
Parent Sales Person,Parent obchodník,
Select company name first.,"Prosím, vyberte najprv názov spoločnosti",
Sales Person Targets,Obchodnícke ciele,
Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.,
Supplier Group Name,Názov skupiny dodávateľov,
Parent Supplier Group,Rodičovská skupina dodávateľov,
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,Uplatniteľné moduly,
Terms and Conditions Help,podmienky nápovedy,
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,Názov Mernej Jednotky,
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,Predvolené nastavenia pre Košík,
Enable Shopping Cart,Povolit Nákupní košík,
Display Settings,Nastavenia zobrazení,
Show Public Attachments,Zobraziť verejné prílohy,
Show Price,Zobraziť cenu,
Show Stock Availability,Zobraziť dostupnosť zásob,
Show Contact Us Button,Zobraziť tlačidlo Kontaktujte nás,
Show Stock Quantity,Zobraziť množstvo zásob,
Show Apply Coupon Code,Zobraziť Použiť kód kupónu,
Allow items not in stock to be added to cart,"Nechajte položky, ktoré nie sú na sklade, pridať do košíka",
Prices will not be shown if Price List is not set,"Ceny sa nebudú zobrazovať, pokiaľ Cenník nie je nastavený",
Quotation Series,Číselná rada ponúk,
Checkout Settings,Nastavenia checkout,
Enable Checkout,aktivovať Checkout,
Payment Success Url,Platba Úspech URL,
After payment completion redirect user to selected page.,Po dokončení platby presmerovať užívateľa na vybrané stránky.,
Batch Details,Podrobnosti o dávke,
Batch ID,Šarže ID,
image,obrázok,
Parent Batch,Rodičovská dávka,
Manufacturing Date,Dátum výroby,
Batch Quantity,Množstvo dávky,
Batch UOM,MNO šarže,
Source Document Type,Zdrojový typ dokumentu,
Source Document Name,Názov zdrojového dokumentu,
Batch Description,Popis Šarže,
Bin,Kôš,
Reserved Quantity,Vyhrazeno Množství,
Actual Quantity,Skutočné Množstvo,
Requested Quantity,požadované množstvo,
Reserved Qty for sub contract,Vyhradené množstvo pre subkontrakt,
Moving Average Rate,Klouzavý průměr,
FCFS Rate,FCFS Rate,
Customs Tariff Number,colného sadzobníka,
Tariff Number,tarif Počet,
Delivery To,Doručenie do,
MAT-DN-.YYYY.-,MAT-DN-.YYYY.-,
Is Return,Je Return,
Issue Credit Note,Vydanie kreditnej 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,Názov fakturačnej 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.","Ak ste vytvorili štandardné šablónu v predaji daní a poplatkov šablóny, vyberte jednu a kliknite na tlačidlo nižšie.",
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,Názov vodiča,
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,% Inštalovaných,
% of materials delivered against this Delivery Note,% materiálov dodaných proti tomuto dodaciemu listu,
Installation Status,Stav instalace,
Excise Page Number,Spotřební Číslo stránky,
Instructions,Instrukce,
From Warehouse,Zo 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 dispozícii dávky Množstvo na Od Warehouse,
Available Qty at From Warehouse,K dispozícii Množstvo na Od Warehouse,
Delivery Settings,Nastavenia doručenia,
Dispatch Settings,Nastavenia odosielania,
Dispatch Notification Template,Šablóna oznámenia odoslania,
Dispatch Notification Attachment,Príloha o oznámení odoslania,
Leave blank to use the standard Delivery Note format,"Nechajte prázdne, ak chcete použiť štandardný formát dodacieho listu",
Send with Attachment,Odoslať s prílohou,
Delay between Delivery Stops,Oneskorenie medzi doručením,
Delivery Stop,Zastavenie doručenia,
Lock,Zamknúť,
Visited,navštívil,
Order Information,informacie o objednavke,
Contact Information,Kontaktné informácie,
Email sent to,E-mail odoslaný na,
Dispatch Information,Informácie o odoslaní,
Estimated Arrival,Odhadovaný príchod,
MAT-DT-.YYYY.-,MAT-DT-.YYYY.-,
Initial Email Notification Sent,Odoslané pôvodné oznámenie o e-maile,
Delivery Details,Detaily dodania,
Driver Email,E-mail vodiča,
Driver Address,Adresa vodiča,
Total Estimated Distance,Celková odhadovaná vzdialenosť,
Distance UOM,Vzdialenosť UOM,
Departure Time,Čas odchodu,
Delivery Stops,Zastavenie doručenia,
Calculate Estimated Arrival Times,Vypočítať odhadované časy príchodu,
Use Google Maps Direction API to calculate estimated arrival times,Na výpočet odhadovaných časov príchodu použite rozhranie API služby Mapy Google,
Optimize Route,Optimalizujte trasu,
Use Google Maps Direction API to optimize route,Na optimalizáciu trasy použite rozhranie API služby Mapy Google,
In Transit,V preprave,
Fulfillment User,Užívateľ splnenia,
"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,Variant z,
"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,Predvolená merná jednotka,
Maintain Stock,Udržiavať Zásoby,
Standard Selling Rate,Štandardné predajné kurz,
Auto Create Assets on Purchase,Automatické vytváranie aktív pri nákupe,
Asset Naming Series,Asset Naming Series,
Over Delivery/Receipt Allowance (%),Príspevok na prekročenie dodávky / príjem (%),
Barcodes,čiarové kódy,
Shelf Life In Days,Životnosť počas dní,
End of Life,Konec životnosti,
Default Material Request Type,Predvolený typ materiálovej požiadavky,
Valuation Method,Ocenění Method,
FIFO,FIFO,
Moving Average,Klouzavý průměr,
Warranty Period (in days),Záruční doba (ve dnech),
Auto re-order,Auto re-order,
Reorder level based on Warehouse,Úroveň Zmena poradia na základe Warehouse,
Will also apply for variants unless overridden,"Bude platiť aj pre varianty, pokiaľ nebude prepísané",
Units of Measure,merné jednotky,
Will also apply for variants,Bude platiť aj pre varianty,
Serial Nos and Batches,Sériové čísla a dávky,
Has Batch No,Má číslo šarže,
Automatically Create New Batch,Automaticky vytvoriť novú dávku,
Batch Number Series,Číselná séria š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.","Príklad: ABCD. #####. Ak je nastavená séria a v transakciách sa neuvádza dávka, potom sa na základe tejto série vytvorí automatické číslo dávky. Ak chcete vždy výslovne uviesť číslo dávky pre túto položku, ponechajte prázdne. Poznámka: Toto nastavenie bude mať prednosť pred prefixom série Naming v nastaveniach zásob.",
Has Expiry Date,Má dátum skončenia platnosti,
Retain Sample,Zachovať ukážku,
Max Sample Quantity,Max. Množstvo vzoriek,
Maximum sample quantity that can be retained,"Maximálne množstvo vzorky, ktoré možno uchovať",
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.","Ak je táto položka má varianty, potom to nemôže byť vybraná v predajných objednávok atď",
Variant Based On,Variant založená na,
Item Attribute,Položka Atribut,
"Sales, Purchase, Accounting Defaults","Predaj, nákup, predvolené účtovníctvo",
Item Defaults,Predvolené položky,
"Purchase, Replenishment Details","Podrobnosti o nákupe, doplnení",
Is Purchase Item,je Nákupní Položka,
Default Purchase Unit of Measure,Predvolená nákupná merná jednotka,
Minimum Order Qty,Minimální objednávka Množství,
Minimum quantity should be as per Stock UOM,Minimálne množstvo by malo byť podľa zásob UOM,
Average time taken by the supplier to deliver,Priemerná doba zhotovená dodávateľom dodať,
Is Customer Provided Item,Je položka poskytnutá zákazníkom,
Delivered by Supplier (Drop Ship),Dodáva Dodávateľom (Drop Ship),
Supplier Items,Dodavatele položky,
Foreign Trade Details,Zahraničný obchod Podrobnosti,
Country of Origin,Krajina pôvodu,
Sales Details,Predajné podrobnosti,
Default Sales Unit of Measure,Predvolená predajná jednotka merania,
Is Sales Item,Je Sales Item,
Max Discount (%),Max zľava (%),
No of Months,Počet mesiacov,
Customer Items,Zákaznícke položky,
Inspection Criteria,Inšpekčné kritéria,
Inspection Required before Purchase,Inšpekcia Požadované pred nákupom,
Inspection Required before Delivery,Inšpekcia Požadované pred pôrodom,
Default BOM,Východzí BOM,
Supply Raw Materials for Purchase,Dodávky suroviny pre nákup,
If subcontracted to a vendor,Ak sa subdodávky na dodávateľa,
Customer Code,Code zákazníků,
Default Item Manufacturer,Predvolený výrobca položky,
Default Manufacturer Part No,Predvolené číslo dielu výrobcu,
Show in Website (Variant),Zobraziť na webstránke (Variant),
Items with higher weightage will be shown higher,Položky s vyšším weightage budú zobrazené vyššie,
Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky,
Website Image,Obrázok webovej 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írovať z položkovej skupiny,
Website Content,Obsah webových stránok,
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žiť akékoľvek platné značenie Bootstrap 4. Bude sa zobrazovať na vašej stránke s položkami.,
Total Projected Qty,Celková predpokladaná Množstvo,
Hub Publishing Details,Podrobnosti o publikovaní 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,Kategória Hubu na publikovanie,
Hub Warehouse,Hub Warehouse,
"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Zverejnite na sklade &quot;Na sklade&quot; alebo &quot;Nie je na sklade&quot; na základe dostupných zásob v tomto sklade.,
Synced With Hub,Synchronizovány Hub,
Item Alternative,Položka Alternatíva,
Alternative Item Code,Kód alternatívnej položky,
Two-way,obojsmerný,
Alternative Item Name,Alternatívny názov položky,
Attribute Name,Názov atribútu,
Numeric Values,Číselné hodnoty,
From Range,Od Rozsah,
Increment,Prírastok,
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 čiarové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 Predvolená,
Purchase Defaults,Predvolené nákupy,
Default Buying Cost Center,Výchozí Center Nákup Cost,
Default Supplier,Výchozí Dodavatel,
Default Expense Account,Výchozí výdajového účtu,
Sales Defaults,Predvolené hodnoty predaja,
Default Selling Cost Center,Výchozí Center Prodejní cena,
Item Manufacturer,položka Výrobca,
Item Price,Položka Cena,
Packing Unit,Balenie,
Quantity  that must be bought or sold per UOM,"Množstvo, ktoré je potrebné zakúpiť alebo predať podľa 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,Žiadosť o,
Re-order Level,Úroveň doobjednania,
Re-order Qty,Doobjednacie množstvo,
Item Supplier,Položka Dodavatel,
Item Variant,Variant Položky,
Item Variant Attribute,Vlastnosť Variantu Položky,
Do not update variants on save,Neaktualizujte varianty uloženia,
Fields will be copied over only at time of creation.,Polia budú kopírované iba v čase vytvorenia.,
Allow Rename Attribute Value,Povoliť premenovanie hodnoty atribútu,
Rename Attribute Value in Item Attribute.,Premenujte hodnotu atribútu v atribúte položky.,
Copy Fields to Variant,Kopírovať polia na variant,
Item Website Specification,Položka webových stránek Specifikace,
Table for Item that will be shown in Web Site,"Tabuľka k Položke, která sa zobrazí na webových stránkách",
Landed Cost Item,Přistálo nákladovou položkou,
Receipt Document Type,Príjem Document Type,
Receipt Document,príjem dokumentov,
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,Získat položky z Příjmové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ýrobcovia používané v bodoch,
Limited to 12 characters,Obmedzené na 12 znakov,
MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
Partially Ordered,Čiastočne objednané,
Transferred,prevedená,
% Ordered,% Objednané,
Terms and Conditions Content,Podmínky Content,
Quantity and Warehouse,Množstvo a sklad,
Lead Time Date,Čas a Dátum Obchodnej iniciatívy,
Min Order Qty,Min Objednané množství,
Packed Item,Zabalená položka,
To Warehouse (Optional),Warehouse (voliteľné),
Actual Batch Quantity,Skutočné množstvo š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,Detail hmotnosti zásielky,
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,Čistá hmotnosť MJ,
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á Hmotnosť MJ,
Packing Slip Item,Balení Slip Item,
DN Detail,DN Detail,
STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
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,O množstve surovín sa rozhodne na základe množstva hotového tovaru,
Parent Warehouse,Parent Warehouse,
Items under this warehouse will be suggested,Položky v tomto sklade budú navrhnuté,
Get Item Locations,Získajte informácie o položkách,
Item Locations,Polohy položiek,
Pick List Item,Vyberte položku zoznamu,
Picked Qty,Vybrané množstvo,
Price List Master,Ceník Master,
Price List Name,Názov cenníka,
Price Not UOM Dependent,Cena nie je závislá od UOM,
Applicable for Countries,Pre krajiny,
Price List Country,Cenník Krajina,
MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-,
Supplier Delivery Note,Dodacie oznámenie dodávateľa,
Time at which materials were received,"Čas, kdy bylo přijato materiály",
Return Against Purchase Receipt,Návrat Proti doklad o kúpe,
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.,Nastavuje „Prijatý sklad“ v každom riadku tabuľky položiek.,
Sets 'Rejected Warehouse' in each row of the items table.,Nastavuje „Odmietnutý sklad“ v každom riadku tabuľky s položkami.,
Raw Materials Consumed,Spotrebované suroviny,
Get Current Stock,Získať aktuálny stav,
Consumed Items,Spotrebované položky,
Add / Edit Taxes and Charges,Pridať / Upraviť dane a poplatky,
Auto Repeat Detail,Podrobnosti o automatickom opakovaní,
Transporter Details,Transporter Podrobnosti,
Vehicle Number,Číslo vozidla,
Vehicle Date,Dátum Vehicle,
Received and Accepted,Prijaté a akceptované,
Accepted Quantity,Schválené Množstvo,
Rejected Quantity,Zamítnuto Množství,
Accepted Qty as per Stock UOM,Prijaté množstvo podľa MJ na sklade,
Sample Quantity,Množstvo vzoriek,
Rate and Amount,Sadzba a množstvo,
MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
Report Date,Datum Reportu,
Inspection Type,Kontrola Type,
Item Serial No,Položka Výrobní číslo,
Sample Size,Veľkosť vzorky,
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,Názov šablóny inšpekcie kvality,
Quick Stock Balance,Rýchla bilancia zásob,
Available Quantity,Dostupné množstvo,
Distinct unit of an Item,Samostatnou jednotku z položky,
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sklad je možné provést pouze prostřednictvím Burzy Entry / dodací list / doklad o zakoupení,
Purchase / Manufacture Details,Nákup / Výroba Podrobnosti,
Creation Document Type,Tvorba Typ dokumentu,
Creation Document No,Tvorba dokument č,
Creation Date,Dátum vytvorenia,
Creation Time,Čas vytvorenia,
Asset Details,Podrobnosti o majetku,
Asset Status,Stav majetku,
Delivery Document Type,Dodávka Typ dokumentu,
Delivery Document No,Dodávka dokument č,
Delivery Time,Dodacia doba,
Invoice Details,Podrobnosti faktúry,
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,Podrodnosti k sériovému číslu,
MAT-STE-.YYYY.-,MAT-STE-.YYYY.-,
Stock Entry Type,Druh položky na sklade,
Stock Entry (Outward GIT),Zásoby (Outward GIT),
Material Consumption for Manufacture,Spotreba materiálu na výrobu,
Repack,Přebalit,
Send to Subcontractor,Odoslať subdodávateľovi,
Delivery Note No,Číslo dodacieho listu,
Sales Invoice No,Číslo odoslanej faktúry,
Purchase Receipt No,Číslo příjmky,
Inspection Required,Kontrola je povinná,
From BOM,Od BOM,
For Quantity,Pre Množstvo,
As per Stock UOM,Podľa skladovej MJ,
Including items for sub assemblies,Vrátane položiek pre montážnych podskupín,
Default Source Warehouse,Výchozí zdroj Warehouse,
Source Warehouse Address,Adresa zdrojového skladu,
Default Target Warehouse,Výchozí Target Warehouse,
Target Warehouse Address,Adresa cieľového skladu,
Update Rate and Availability,Obnovovaciu rýchlosť a dostupnosť,
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,Dodatočné náklady,
Total Additional Costs,Celkom Dodatočné náklady,
Customer or Supplier Details,Zákazníka alebo dodávateľa Podrobnosti,
Per Transferred,Za prevedené,
Stock Entry Detail,Detail pohybu zásob,
Basic Rate (as per Stock UOM),Základná sadzba (podľa skladovej MJ),
Basic Amount,Základná čiastka,
Additional Cost,Dodatočné náklady,
Serial No / Batch,Sériové číslo / Dávka,
BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce,
Material Request used to make this Stock Entry,Materiál Žádost používá k výrobě této populace Entry,
Subcontracted Item,Subkontraktovaná položka,
Against Stock Entry,Proti zásobám,
Stock Entry Child,Zásoby Dieťa,
PO Supplied Item,PO Dodaná položka,
Reference Purchase Receipt,Referenčný doklad o nákupe,
Stock Ledger Entry,Zápis do súpisu zásob,
Outgoing Rate,Odchádzajúce Rate,
Actual Qty After Transaction,Skutečné Množství Po transakci,
Stock Value Difference,Rozdiel v hodnote zásob,
Stock Queue (FIFO),Skladové karty (FIFO),
Is Cancelled,Je zrušené,
Stock Reconciliation,Inventúra zásob,
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,Inventúrna položka,
Before reconciliation,Pred odsúhlasením,
Current Serial No,Aktuálne poradové číslo,
Current Valuation Rate,Aktuálne ocenenie Rate,
Current Amount,Aktuálna výška,
Quantity Difference,Množstvo Rozdiel,
Amount Difference,vyššie Rozdiel,
Item Naming By,Položka Pojmenování By,
Default Item Group,Predvolená skupina položiek,
Default Stock UOM,Predvolená skladová MJ,
Sample Retention Warehouse,Sklad pre uchovávanie vzoriek,
Default Valuation Method,Výchozí metoda ocenění,
Show Barcode Field,Show čiarového kódu Field,
Convert Item Description to Clean HTML,Konvertovať popis položky na HTML,
Allow Negative Stock,Povoliť mínusové zásoby,
Automatically Set Serial Nos based on FIFO,Automaticky nastaviť sériové čísla na základe FIFO,
Auto Material Request,Auto materiálu Poptávka,
Inter Warehouse Transfer Settings,Nastavenia prevodu medziskladu,
Freeze Stock Entries,Freeze Stock Příspěvky,
Stock Frozen Upto,Reklamní Frozen aľ,
Batch Identification,Identifikácia šarže,
Use Naming Series,Použiť pomenovacie série,
Naming Series Prefix,Pomenovanie predvoľby série,
UOM Category,UOM kategória,
UOM Conversion Detail,Detail konverzie MJ,
Variant Field,Variantné pole,
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ázov skladu,
Warehouse Contact Info,Sklad Kontaktní informace,
PIN,PIN,
ISS-.YYYY.-,ISS-.RRRR.-,
Raised By (Email),Vznesené (e-mail),
Issue Type,Typ vydania,
Issue Split From,Vydanie rozdelené z,
Service Level,Úroveň služieb,
Response By,Odpoveď používateľom,
Response By Variance,Odpoveď podľa odchýlky,
Ongoing,pokračujúce,
Resolution By,Rozlíšenie podľa,
Resolution By Variance,Rozlíšenie podľa odchýlky,
Service Level Agreement Creation,Vytvorenie dohody o úrovni služieb,
First Responded On,Prvně odpovězeno dne,
Resolution Details,Rozlišení Podrobnosti,
Opening Date,Otvárací dátum,
Opening Time,Otevírací doba,
Resolution Date,Rozlišení Datum,
Via Customer Portal,Prostredníctvom zákazníckeho portálu,
Support Team,Tým podpory,
Issue Priority,Priorita vydania,
Service Day,Servisný deň,
Workday,pracovný deň,
Default Priority,Predvolená priorita,
Priorities,priority,
Support Hours,Čas podpory,
Support and Resolution,Podpora a rozlíšenie,
Default Service Level Agreement,Predvolená dohoda o úrovni služieb,
Entity,bytosť,
Agreement Details,Podrobnosti dohody,
Response and Resolution Time,Čas odozvy a riešenia problémov,
Service Level Priority,Priorita na úrovni služby,
Resolution Time,Čas riešenia,
Support Search Source,Zdroj vyhľadávania podpory,
Source Type,typ zdroja,
Query Route String,Dotaz reťazca trasy,
Search Term Param Name,Hľadaný výraz Param Name,
Response Options,Možnosti odpovede,
Response Result Key Path,Cesta kľúča výsledku odpovede,
Post Route String,Pridať reťazec trasy,
Post Route Key List,Pridať zoznam kľúčov,
Post Title Key,Kľúč správy titulu,
Post Description Key,Popisný kľúč Popis,
Link Options,Možnosti odkazu,
Source DocType,Zdroj DocType,
Result Title Field,Pole Názov výsledku,
Result Preview Field,Pole pre zobrazenie výsledkov,
Result Route Field,Výsledok Pole trasy,
Service Level Agreements,Dohody o úrovni služieb,
Track Service Level Agreement,Dohoda o úrovni sledovania služieb,
Allow Resetting Service Level Agreement,Povoliť obnovenie dohody o úrovni služieb,
Close Issue After Days,Close Issue po niekoľkých dňoch,
Auto close Issue after 7 days,Auto zavrieť Issue po 7 dňoch,
Support Portal,Podporný portál,
Get Started Sections,Začnite sekcie,
Show Latest Forum Posts,Zobraziť najnovšie príspevky vo fórach,
Forum Posts,Fórum príspevky,
Forum URL,Adresa URL fóra,
Get Latest Query,Získajte najnovší dotaz,
Response Key List,Zoznam kľúčových odpovedí,
Post Route Key,Pridať kľúč trasy,
Search APIs,API vyhľadávania,
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,Nástroj na premenovanie,
Utilities,Utilities,
Type of document to rename.,Typ dokumentu na premenovanie.,
File to Rename,Súbor premenovať,
"Attach .csv file with two columns, one for the old name and one for the new name","Pripojiť CSV súbor s dvomi stĺpci, jeden pre starý názov a jeden pre nový názov",
Rename Log,Premenovať Log,
SMS Log,SMS Log,
Sender Name,Meno odosielateľa,
Sent On,Poslané 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,Odoslané na,
Absent Student Report,Absent Študent Report,
Assessment Plan Status,Stav plánu hodnotenia,
Asset Depreciation Ledger,Asset Odpisy Ledger,
Asset Depreciations and Balances,Asset Odpisy a zostatkov,
Available Stock for Packing Items,K dispozici skladem pro balení položek,
Bank Clearance Summary,Súhrn bankového zúčtovania,
Batch Item Expiry Status,Batch Item Zánik Status,
Batch-Wise Balance History,Batch-Wise Balance History,
BOM Explorer,Prieskumník kusovníka,
BOM Search,BOM Search,
BOM Stock Calculated,Výpočet zásob BOM,
BOM Variance Report,Správa o odchýlkach kusovníka,
Campaign Efficiency,Efektívnosť kampane,
Cash Flow,Cash Flow,
Completed Work Orders,Dokončené pracovné príkazy,
To Produce,K výrobě,
Produced,Produkoval,
Consolidated Financial Statement,Konsolidovaný finančný výkaz,
Course wise Assessment Report,Priebežná hodnotiaca správa,
Customer Acquisition and Loyalty,Zákazník Akvizice a loajality,
Customer Credit Balance,Zákazník Credit Balance,
Customer Ledger Summary,Zhrnutie knihy odberateľov,
Customer-wise Item Price,Cena tovaru podľa priania zákazníka,
Customers Without Any Sales Transactions,Zákazníci bez akýchkoľvek predajných transakcií,
Daily Timesheet Summary,Denný súhrn pracovných výkazov,
DATEV,DATEV,
Delayed Item Report,Prehľad oneskorených položiek,
Delayed Order Report,Správa o oneskorení objednávky,
Delivered Items To Be Billed,Dodávaných výrobků fakturovaných,
Delivery Note Trends,Dodací list Trendy,
Electronic Invoice Register,Elektronický register faktúr,
Employee Billing Summary,Súhrn fakturácie zamestnancov,
Employee Birthday,Narozeniny zaměstnance,
Employee Information,Informace o zaměstnanci,
Employee Leave Balance,Zostatok voľna pre zamestnanca,
Employee Leave Balance Summary,Zhrnutie stavu zostatku zamestnancov,
Eway Bill,Eway Bill,
Expiring Memberships,Platnosť členstva,
Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC],
Final Assessment Grades,Záverečné stupne hodnotenia,
Fixed Asset Register,Register fixných aktív,
Gross and Net Profit Report,Správa o hrubom a čistom zisku,
GST Itemised Purchase Register,Registrovaný nákupný register spoločnosti GST,
GST Itemised Sales Register,GST Podrobný predajný register,
GST Purchase Register,Registrácia nákupov GST,
GST Sales Register,Obchodný register spoločnosti GST,
GSTR-1,GSTR-1,
GSTR-2,GSTR-2,
Hotel Room Occupancy,Hotel Occupancy,
HSN-wise-summary of outward supplies,HSN-múdre zhrnutie vonkajších dodávok,
Inactive Customers,Neaktívni zákazníci,
Inactive Sales Items,Neaktívne predajné položky,
IRS 1099,IRS 1099,
Issued Items Against Work Order,Vydané položky proti pracovnému príkazu,
Projected Quantity as Source,Množstvo projekciou as Zdroj,
Item Balance (Simple),Zostatok 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 variantoch 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-moudrý Nákup Register,
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,Podrobnosti Obchodnej iniciatívy,
Lead Owner Efficiency,Efektívnosť vlastníka iniciatívy,
Lost Opportunity,Stratená príležitosť,
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,
Open Work Orders,Otvorte pracovné príkazy,
Qty to Deliver,Množství k dodání,
Patient Appointment Analytics,Analýza vymenovania 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,Sledovanie obstarávania,
Product Bundle Balance,Zostatok produktu,
Production Analytics,Analýza výroby,
Profit and Loss Statement,Výkaz ziskov a strát,
Profitability Analysis,Analýza ziskovosti,
Project Billing Summary,Súhrn fakturácie projektu,
Project wise Stock Tracking,Sledovanie stavu zásob podľa projektu,
Project wise Stock Tracking ,Sledování zboží dle projektu,
Prospects Engaged But Not Converted,"Perspektívy zapojené, ale nekonvertované",
Purchase Analytics,Analýza nákupu,
Purchase Invoice Trends,Trendy přijatách faktur,
Qty to Receive,Množství pro příjem,
Received Qty Amount,Prijatá suma Množstvo,
Billed Qty,Účtované množstvo,
Purchase Order Trends,Nákupní objednávka trendy,
Purchase Receipt Trends,Doklad o koupi Trendy,
Purchase Register,Nákup Register,
Quotation Trends,Vývoje ponúk,
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,
Sales Analytics,Analýza predaja,
Sales Invoice Trends,Prodejní faktury Trendy,
Sales Order Trends,Prodejní objednávky Trendy,
Sales Partner Commission Summary,Zhrnutie provízie obchodného partnera,
Sales Partner Target Variance based on Item Group,Cieľová odchýlka odbytového partnera na základe skupiny položiek,
Sales Partner Transaction Summary,Zhrnutie transakcií obchodného partnera,
Sales Partners Commission,Obchodní partneři Komise,
Invoiced Amount (Exclusive Tax),Fakturovaná suma (bez dane),
Average Commission Rate,Průměrná cena Komise,
Sales Payment Summary,Prehľad platieb z predaja,
Sales Person Commission Summary,Súhrnný prehľad komisie pre predajcov,
Sales Person Target Variance Based On Item Group,Cieľová odchýlka predajnej osoby na základe skupiny položiek,
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,Starnutie zásob,
Stock and Account Value Comparison,Porovnanie hodnoty zásob a účtu,
Stock Projected Qty,Naprojektovaná úroveň zásob,
Student and Guardian Contact Details,Študent a Guardian Kontaktné údaje,
Student Batch-Wise Attendance,Študent Batch-Wise Účasť,
Student Fee Collection,Študent Fee Collection,
Student Monthly Attendance Sheet,Študent mesačná návštevnosť Sheet,
Subcontracted Item To Be Received,"Subdodávaná položka, ktorá sa má prijať",
Subcontracted Raw Materials To Be Transferred,"Subdodávateľské suroviny, ktoré sa majú preniesť",
Supplier Ledger Summary,Zhrnutie knihy dodávateľov,
Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics,
Support Hour Distribution,Distribúcia hodín podpory,
TDS Computation Summary,Zhrnutie výpočtu TDS,
TDS Payable Monthly,TDS splatné mesačne,
Territory Target Variance Based On Item Group,Variant teritoriálneho cieľa na základe skupiny položiek,
Territory-wise Sales,Územný predaj,
Total Stock Summary,Súhrnné zhrnutie zásob,
Trial Balance,Trial Balance,
Trial Balance (Simple),Skúšobný zostatok (jednoduchý),
Trial Balance for Party,Trial váhy pre stranu,
Warehouse wise Item Balance Age and Value,Skladové číslo Položka Stav veku a hodnoty,
Work Order Stock Report,Správa o stave pracovnej objednávky,
Work Orders in Progress,Pracovné príkazy v procese,
Automatically Process Deferred Accounting Entry,Automaticky spracovať odložený záznam účtovníctva,
Bank Clearance,Bankové spojenie,
Bank Clearance Detail,Detail bankového zúčtovania,
Update Cost Center Name / Number,Aktualizujte názov / číslo nákladového strediska,
Journal Entry Template,Šablóna denníka,
Template Title,Názov šablóny,
Journal Entry Type,Typ denníka,
Journal Entry Template Account,Účet šablóny denníka,
Process Deferred Accounting,Spracovať odložené účtovníctvo,
Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Ručné zadanie nie je možné vytvoriť! V nastaveniach účtov zakážte automatické zadávanie pre odložené účtovníctvo a skúste to znova,
End date cannot be before start date,Dátum ukončenia nemôže byť skôr ako dátum začatia,
Total Counts Targeted,Celkový počet zameraných,
Total Counts Completed,Celkový počet dokončených,
Counts Targeted: {0},Zacielené počty: {0},
Material Request Warehouse,Sklad žiadosti o materiál,
Select warehouse for material requests,Vyberte sklad pre požiadavky na materiál,
Transfer Materials For Warehouse {0},Prenos materiálov do skladu {0},
Production Plan Material Request Warehouse,Sklad požiadaviek na materiál výrobného plánu,
Sets 'Source Warehouse' in each row of the items table.,Nastavuje „Zdrojový sklad“ v každom riadku tabuľky položiek.,
Sets 'Target Warehouse' in each row of the items table.,Nastavuje „Cieľový sklad“ v každom riadku tabuľky položiek.,
Show Cancelled Entries,Zobraziť zrušené záznamy,
Backdated Stock Entry,Spätný zápis položky,
Row #{}: Currency of {} - {} doesn't matches company currency.,Riadok č. {}: Mena {} - {} sa nezhoduje s menou spoločnosti.,
{} Assets created for {},{} Diela vytvorené pre {},
{0} Number {1} is already used in {2} {3},{0} Číslo {1} sa už používa v jazyku {2} {3},
Update Bank Clearance Dates,Aktualizujte dátumy bankového zúčtovania,
Healthcare Practitioner: ,Zdravotník:,
Lab Test Conducted: ,Vykonaný laboratórny test:,
Lab Test Event: ,Laboratórna testovacia udalosť:,
Lab Test Result: ,Výsledok laboratórneho testu:,
Clinical Procedure conducted: ,Vykonaný klinický postup:,
Therapy Session Charges: {0},Poplatky za terapeutické sedenie: {0},
Therapy: ,Terapia:,
Therapy Plan: ,Terapeutický plán:,
Total Counts Targeted: ,Celkový počet zameraných:,
Total Counts Completed: ,Celkový počet dokončených:,
Is Mandatory,Je povinné,
Service Received But Not Billed,"Služba prijatá, ale neúčtovaná",
Deferred Accounting Settings,Nastavenia odloženého účtovníctva,
Book Deferred Entries Based On,Rezervovať odložené príspevky na základe,
Days,Dni,
Months,Mesiace,
Book Deferred Entries Via Journal Entry,Rezervácia odložených záznamov prostredníctvom denníka,
Submit Journal Entries,Odoslať záznamy v denníku,
If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Ak nie je začiarknuté, položky denníka sa uložia v stave konceptu a budú sa musieť odoslať ručne",
Enable Distributed Cost Center,Povoliť distribuované nákladové stredisko,
Distributed Cost Center,Distribuované nákladové stredisko,
Dunning,Vymáhanie,
DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
Overdue Days,Dni po splatnosti,
Dunning Type,Typ upomínania,
Dunning Fee,Poplatok za upomínanie,
Dunning Amount,Suma upomínania,
Resolved,Vyriešené,
Unresolved,Nevyriešené,
Printing Setting,Nastavenie tlače,
Body Text,Hlavný text,
Closing Text,Záverečný text,
Resolve,Vyriešiť,
Dunning Letter Text,Text upomienky,
Is Default Language,Je predvolený jazyk,
Letter or Email Body Text,Hlavný text listu alebo e-mailu,
Letter or Email Closing Text,Záverečný text listu alebo e-mailu,
Body and Closing Text Help,Telo a záverečný text Pomoc,
Overdue Interval,Interval po lehote splatnosti,
Dunning Letter,Upomienkový list,
"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.","Táto časť umožňuje používateľovi nastaviť text tela a záverečný text upomienkového listu pre typ upomínania na základe jazyka, ktorý je možné použiť v tlači.",
Reference Detail No,Referenčné číslo detailu,
Custom Remarks,Vlastné poznámky,
Please select a Company first.,Najskôr vyberte spoločnosť.,
"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Riadok č. {0}: Typ referenčného dokumentu musí byť jeden z objednávok odberateľa, predajnej faktúry, záznamu do denníka alebo upomienky",
POS Closing Entry,Uzávierka vstupu POS,
POS Opening Entry,Vstupný otvorenie POS,
POS Transactions,POS transakcie,
POS Closing Entry Detail,Detail uzávierky vstupu POS,
Opening Amount,Počiatočná suma,
Closing Amount,Konečná suma,
POS Closing Entry Taxes,Uzávierka vstupných daní POS,
POS Invoice,POS faktúra,
ACC-PSINV-.YYYY.-,ACC-PSINV-.RRRR.-,
Consolidated Sales Invoice,Konsolidovaná predajná faktúra,
Return Against POS Invoice,Vrátiť sa proti POS faktúre,
Consolidated,Konsolidované,
POS Invoice Item,Položka faktúry POS,
POS Invoice Merge Log,Denník zlúčenia faktúry POS,
POS Invoices,POS faktúry,
Consolidated Credit Note,Konsolidovaný dobropis,
POS Invoice Reference,Referenčné číslo faktúry POS,
Set Posting Date,Nastavte dátum zverejnenia,
Opening Balance Details,Počiatočný zostatok,
POS Opening Entry Detail,POS otváranie vstupných detailov,
POS Payment Method,Spôsob platby POS,
Payment Methods,spôsob platby,
Process Statement Of Accounts,Spracovať výpis z účtov,
General Ledger Filters,Filtre hlavnej knihy,
Customers,Zákazníci,
Select Customers By,Vyberte Zákazníci podľa,
Fetch Customers,Načítajte zákazníkov,
Send To Primary Contact,Poslať primárnemu kontaktu,
Print Preferences,Predvoľby tlače,
Include Ageing Summary,Zahrnúť zhrnutie starnutia,
Enable Auto Email,Povoliť automatický e-mail,
Filter Duration (Months),Trvanie filtra (mesiace),
CC To,CC To,
Help Text,Text pomocníka,
Emails Queued,E-maily boli zaradené do poradia,
Process Statement Of Accounts Customer,Spracovať výpis z účtu zákazníka,
Billing Email,Fakturačný e-mail,
Primary Contact Email,Primárny kontaktný e-mail,
PSOA Cost Center,Nákladové stredisko PSOA,
PSOA Project,Projekt PSOA,
ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.RRRR.-,
Supplier GSTIN,Dodávateľ GSTIN,
Place of Supply,Miesto dodávky,
Select Billing Address,Vyberte fakturačnú adresu,
GST Details,GST podrobnosti,
GST Category,Kategória GST,
Registered Regular,Registrovaný pravidelne,
Registered Composition,Registrované zloženie,
Unregistered,Neregistrovaný,
SEZ,SEZ,
Overseas,V zámorí,
UIN Holders,Držitelia UIN,
With Payment of Tax,S platením dane,
Without Payment of Tax,Bez platenia dane,
Invoice Copy,Kópia faktúry,
Original for Recipient,Originál pre príjemcu,
Duplicate for Transporter,Duplikát pre Transporter,
Duplicate for Supplier,Duplikát pre dodávateľa,
Triplicate for Supplier,Triplikát pre dodávateľa,
Reverse Charge,Reverzný náboj,
Y,Y.,
N,N,
E-commerce GSTIN,Elektronický obchod GSTIN,
Reason For Issuing document,Dôvod vystavenia dokladu,
01-Sales Return,01-Návratnosť predaja,
02-Post Sale Discount,Zľava po predaji 02,
03-Deficiency in services,03-Nedostatok služieb,
04-Correction in Invoice,04 - Oprava vo faktúre,
05-Change in POS,05-Zmena v POS,
06-Finalization of Provisional assessment,06-Dokončenie predbežného posúdenia,
07-Others,07-Ostatné,
Eligibility For ITC,Oprávnenosť pre ITC,
Input Service Distributor,Distribútor vstupných služieb,
Import Of Service,Import služieb,
Import Of Capital Goods,Dovoz investičného majetku,
Ineligible,Neoprávnené,
All Other ITC,Všetky ostatné ITC,
Availed ITC Integrated Tax,Využila integrovanú daň ITC,
Availed ITC Central Tax,Využila sa centrálna daň ITC,
Availed ITC State/UT Tax,Využitý štát ITC / daň UT,
Availed ITC Cess,Využil ITC Cess,
Is Nil Rated or Exempted,Nie je nijako hodnotený alebo vyňatý,
Is Non GST,Nie je GST,
ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.YYYY.-,
E-Way Bill No.,E-Way Bill č.,
Is Consolidated,Je konsolidovaná,
Billing Address GSTIN,Fakturačná adresa GSTIN,
Customer GSTIN,Zákazník GSTIN,
GST Transporter ID,GST ID transportéra,
Distance (in km),Vzdialenosť (v km),
Road,Cesta,
Air,Vzduch,
Rail,Železnica,
Ship,Loď,
GST Vehicle Type,GST Typ vozidla,
Over Dimensional Cargo (ODC),Nadmerný náklad (ODC),
Consumer,Spotrebiteľ,
Deemed Export,Predpokladaný vývoz,
Port Code,Kód prístavu,
 Shipping Bill Number,Číslo faktúry za prepravu,
Shipping Bill Date,Dátum vystavenia faktúry,
Subscription End Date,Dátum ukončenia predplatného,
Follow Calendar Months,Sledujte kalendárne mesiace,
If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Ak je toto začiarknuté, budú sa v termínoch začatia kalendárneho mesiaca a štvrťroka vytvárať nové nové faktúry bez ohľadu na aktuálny dátum začatia fakturácie",
Generate New Invoices Past Due Date,Generujte nové faktúry po dátume splatnosti,
New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Nové faktúry sa budú generovať podľa harmonogramu, aj keď sú súčasné faktúry neuhradené alebo sú po termíne splatnosti",
Document Type ,typ dokumentu,
Subscription Price Based On,Cena predplatného založená na,
Fixed Rate,Pevne stanovena sadzba,
Based On Price List,Na základe cenníka,
Monthly Rate,Mesačná sadzba,
Cancel Subscription After Grace Period,Zrušiť predplatné po uplynutí odkladnej lehoty,
Source State,Štát zdroja,
Is Inter State,Je medzištátny,
Purchase Details,Podrobnosti o nákupe,
Depreciation Posting Date,Dátum zaúčtovania odpisov,
"By default, the Supplier Name is set as per the Supplier Name entered. If you want Suppliers to be named by a  ","Názov dodávateľa je predvolene nastavený podľa zadaného názvu dodávateľa. Ak chcete, aby dodávateľov menoval a",
 choose the 'Naming Series' option.,zvoľte možnosť „Pomenovanie série“.,
Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Pri vytváraní novej transakcie nákupu nakonfigurujte predvolený cenník. Ceny položiek sa načítajú z tohto cenníka.,
"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.","Ak je táto možnosť nakonfigurovaná na hodnotu „Áno“, program ERPNext vám zabráni vo vytvorení nákupnej faktúry alebo príjmového dokladu bez vytvorenia nákupnej objednávky. Túto konfiguráciu je možné pre konkrétneho dodávateľa prepísať začiarknutím políčka „Povoliť vytváranie nákupných faktúr bez objednávky“ v hlavnom okne dodávateľa.",
"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.","Ak je táto možnosť nakonfigurovaná na hodnotu „Áno“, program ERPNext vám zabráni vo vytvorení nákupnej faktúry bez vytvorenia dokladu o kúpe. Túto konfiguráciu je možné pre konkrétneho dodávateľa prepísať začiarknutím políčka „Povoliť vytváranie faktúr za nákup bez dokladu o kúpe“ v hlavnom okne dodávateľa.",
Quantity & Stock,Množstvo a sklad,
Call Details,Detaily hovoru,
Authorised By,Autorizovaný,
Signee (Company),Signee (spoločnosť),
Signed By (Company),Podpísaný (spoločnosť),
First Response Time,Čas prvej odpovede,
Request For Quotation,Žiadosť o cenovú ponuku,
Opportunity Lost Reason Detail,Príčina Stratená príčina - dôvod,
Access Token Secret,Tajomstvo prístupového tokenu,
Add to Topics,Pridať do tém,
...Adding Article to Topics,... Pridávanie článku k témam,
Add Article to Topics,Pridajte článok k témam,
This article is already added to the existing topics,Tento článok je už pridaný k existujúcim témam,
Add to Programs,Pridať do programov,
Programs,Programov,
...Adding Course to Programs,... Pridanie kurzu k programom,
Add Course to Programs,Pridajte kurz k programom,
This course is already added to the existing programs,Tento kurz je už pridaný k existujúcim programom,
Learning Management System Settings,Nastavenia systému riadenia výučby,
Enable Learning Management System,Povoliť systém riadenia výučby,
Learning Management System Title,Názov systému riadenia výučby,
...Adding Quiz to Topics,... Pridávanie kvízu k témam,
Add Quiz to Topics,Pridajte kvíz do tém,
This quiz is already added to the existing topics,Tento kvíz je už pridaný k existujúcim témam,
Enable Admission Application,Povoliť žiadosť o prijatie,
EDU-ATT-.YYYY.-,EDU-ATT-.RRRR.-,
Marking attendance,Značenie dochádzky,
Add Guardians to Email Group,Pridajte si strážcov do e-mailovej skupiny,
Attendance Based On,Dochádzka založená na,
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čiarknutím tohto políčka označíte študenta za prítomného v prípade, že študent nenavštevuje ústav, aby sa ho v žiadnom prípade zúčastnil alebo zastupoval.",
Add to Courses,Pridať do kurzov,
...Adding Topic to Courses,... Pridávanie témy do kurzov,
Add Topic to Courses,Pridajte tému do kurzov,
This topic is already added to the existing courses,Táto téma je už pridaná k existujúcim kurzom,
"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","Ak Shopify nemá zákazníka v objednávke, potom bude systém pri synchronizácii objednávok brať ohľad na predvoleného zákazníka pre objednávku",
The accounts are set by the system automatically but do confirm these defaults,"Účty nastavuje systém automaticky, tieto predvolené hodnoty však potvrdzujú",
Default Round Off Account,Predvolený zaokrúhlený účet,
Failed Import Log,Zlyhal import protokolu,
Fixed Error Log,Opravený protokol chýb,
Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Spoločnosť {0} už existuje. Pokračovanie prepíše spoločnosť a účtovnú osnovu,
Meta Data,Meta dáta,
Unresolve,Neriešiť,
Create Document,Vytvoriť dokument,
Mark as unresolved,Označiť ako nevyriešené,
TaxJar Settings,Nastavenia TaxJar,
Sandbox Mode,Režim karantény,
Enable Tax Calculation,Povoliť výpočet dane,
Create TaxJar Transaction,Vytvorte transakciu TaxJar,
Credentials,Poverovacie listiny,
Live API Key,Kľúč Live API,
Sandbox API Key,Kľúč Sandbox API,
Configuration,Konfigurácia,
Tax Account Head,Vedúci daňového účtu,
Shipping Account Head,Vedúci prepravného účtu,
Practitioner Name,Meno praktizujúceho,
Enter a name for the Clinical Procedure Template,Zadajte názov šablóny klinického postupu,
Set the Item Code which will be used for billing the Clinical Procedure.,"Nastavte kód položky, ktorý sa použije na fakturáciu klinického postupu.",
Select an Item Group for the Clinical Procedure Item.,Vyberte skupinu položiek pre položku klinického postupu.,
Clinical Procedure Rate,Miera klinického postupu,
Check this if the Clinical Procedure is billable and also set the rate.,"Začiarknite toto, ak je klinický postup fakturovateľný, a tiež nastavte mieru.",
Check this if the Clinical Procedure utilises consumables. Click ,"Toto skontrolujte, ak sa v klinickom postupe spotrebný materiál. Kliknite",
 to know more,vedieť viac,
"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.","Pre šablónu môžete tiež nastaviť lekárske oddelenie. Po uložení dokumentu sa automaticky vytvorí položka na fakturáciu tohto klinického postupu. Túto šablónu potom môžete použiť pri vytváraní Klinických postupov pre pacientov. Šablóny vám ušetria vyplnenie nadbytočných údajov zakaždým. Môžete tiež vytvoriť šablóny pre ďalšie operácie, ako sú laboratórne testy, terapeutické sedenia atď.",
Descriptive Test Result,Výsledok popisného testu,
Allow Blank,Povoliť prázdne,
Descriptive Test Template,Popisná testovacia šablóna,
"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Ak chcete sledovať mzdy a ďalšie operácie HRMS pre praktického lekára, vytvorte zamestnanca a prepojte ho tu.",
Set the Practitioner Schedule you just created. This will be used while booking appointments.,"Nastavte si plán praktického lekára, ktorý ste práve vytvorili. Použije sa to pri rezervácii termínov.",
Create a service item for Out Patient Consulting.,Vytvorte položku služby pre Out Patient Consulting.,
"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Ak tento zdravotnícky pracovník pracuje pre lôžkové oddelenie, vytvorte položku služby pre hospitalizované návštevy.",
Set the Out Patient Consulting Charge for this Practitioner.,Stanovte poplatok za konzultáciu s pacientom pre tohto lekára.,
"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","Ak tento zdravotnícky pracovník pracuje aj pre lôžkové oddelenie, nastavte pre tohto lekára poplatok za návštevu stacionára.",
"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.","Ak je začiarknuté, pre každého pacienta sa vytvorí zákazník. Proti tomuto zákazníkovi sa vytvoria pacientove faktúry. Pri vytváraní pacienta môžete tiež vybrať existujúceho zákazníka. Toto pole je predvolene začiarknuté.",
Collect Registration Fee,Vyberajte registračný poplatok,
"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.","Ak vaše zdravotnícke zariadenie fakturuje registrácie pacientov, môžete to skontrolovať a nastaviť registračný poplatok v poli nižšie. Začiarknutím tohto políčka sa v predvolenom nastavení vytvoria noví pacienti so zdravotným stavom a budú povolení až po fakturácii registračného poplatku.",
Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,"Začiarknutím tohto políčka sa automaticky vytvorí predajná faktúra vždy, keď je pacientovi rezervovaná schôdzka.",
Healthcare Service Items,Položky zdravotnej starostlivosti,
"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 vytvoriť položku služby pre poplatok za hospitalizáciu a nastaviť ju tu. Podobne môžete v tejto časti nastaviť ďalšie položky zdravotnej starostlivosti pre fakturáciu. Kliknite,
Set up default Accounts for the Healthcare Facility,Nastavte predvolené účty pre zdravotnícke zariadenie,
"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Ak chcete prepísať predvolené nastavenia účtov a nakonfigurovať účty výnosov a pohľadávok pre zdravotníctvo, môžete to urobiť tu.",
Out Patient SMS alerts,Upozornenia 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 ","Ak chcete odoslať upozornenie SMS na registráciu pacienta, môžete povoliť túto možnosť. Podobne môžete v tejto časti nastaviť výstrahy SMS pre pacienta pre ďalšie funkcie. Kliknite",
Admission Order Details,Podrobnosti o objednávke,
Admission Ordered For,Vstupné objednané na,
Expected Length of Stay,Očakávaná dĺžka pobytu,
Admission Service Unit Type,Typ jednotky prijímacej služby,
Healthcare Practitioner (Primary),Praktický lekár (primárny),
Healthcare Practitioner (Secondary),Praktický lekár (stredný),
Admission Instruction,Pokyny na prijatie,
Chief Complaint,Hlavná sťažnosť,
Medications,Lieky,
Investigations,Vyšetrovania,
Discharge Detials,Detekčné výboje,
Discharge Ordered Date,Dátum objednania absolutória,
Discharge Instructions,Pokyny na vybíjanie,
Follow Up Date,Nadväzujúci dátum,
Discharge Notes,Poznámky k absolutóriu,
Processing Inpatient Discharge,Spracovanie ústavného prepustenia,
Processing Patient Admission,Spracovanie prijatia pacienta,
Check-in time cannot be greater than the current time,Čas registrácie nemôže byť väčší ako aktuálny čas,
Process Transfer,Prenos procesu,
HLC-LAB-.YYYY.-,HLC-LAB-.RRRR.-,
Expected Result Date,Očakávaný dátum výsledku,
Expected Result Time,Očakávaný čas výsledku,
Printed on,Vytlačené na,
Requesting Practitioner,Žiadajúci odborník,
Requesting Department,Žiadajúce oddelenie,
Employee (Lab Technician),Zamestnanec (laborant),
Lab Technician Name,Meno laboranta,
Lab Technician Designation,Označenie laboranta,
Compound Test Result,Výsledok zloženej skúšky,
Organism Test Result,Výsledok testu na organizmus,
Sensitivity Test Result,Výsledok testu citlivosti,
Worksheet Print,Tlač listu,
Worksheet Instructions,Pokyny k pracovnému listu,
Result Legend Print,Výsledok Tlač legendy,
Print Position,Poloha tlače,
Both,Oboje,
Result Legend,Výsledková legenda,
Lab Tests,Laboratórne testy,
No Lab Tests found for the Patient {0},Pre pacienta {0} sa nenašli žiadne laboratórne testy.,
"Did not send SMS, missing patient mobile number or message content.","Neodoslal som SMS, chýbalo mobilné číslo pacienta alebo obsah správy.",
No Lab Tests created,Nie sú vytvorené žiadne laboratórne testy,
Creating Lab Tests...,Vytváranie laboratórnych testov ...,
Lab Test Group Template,Šablóna laboratórnej testovacej skupiny,
Add New Line,Pridať nový riadok,
Secondary UOM,Sekundárne 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, ktoré vyžadujú iba jeden vstup.<br> <b>Zlúčenina</b> : Výsledky, ktoré vyžadujú viac vstupov udalostí.<br> <b>Popisné</b> : Testy, ktoré obsahujú viac zložiek výsledku s manuálnym zadaním výsledku.<br> <b>Zoskupené</b> : Testovacie šablóny, ktoré sú skupinou ďalších testovacích šablón.<br> <b>Žiadny výsledok</b> : Testy bez výsledkov, je možné ich objednať a vyúčtovať, ale laboratórny test sa nevytvorí. napr. Čiastkové testy na zoskupené výsledky",
"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Ak nie je začiarknuté, položka nebude k dispozícii v predajných faktúrach na fakturáciu, ale dá sa použiť pri vytváraní skupinových testov.",
Description ,Popis,
Descriptive Test,Popisný test,
Group Tests,Skupinové testy,
Instructions to be printed on the worksheet,"Pokyny, ktoré sa majú vytlačiť na pracovnom liste",
"Information to help easily interpret the test report, will be printed as part of the Lab Test result.","Informácie, ktoré uľahčia interpretáciu protokolu o teste, sa vytlačia ako súčasť výsledku laboratórneho testu.",
Normal Test Result,Normálny výsledok testu,
Secondary UOM Result,Výsledok sekundárneho UOM,
Italic,Kurzíva,
Underline,Zdôrazniť,
Organism,Organizmus,
Organism Test Item,Skúšobná položka pre organizmus,
Colony Population,Obyvateľstvo kolónií,
Colony UOM,Kolónia MOM,
Tobacco Consumption (Past),Spotreba tabaku (minulé),
Tobacco Consumption (Present),Spotreba tabaku (súčasnosť),
Alcohol Consumption (Past),Spotreba alkoholu (minulá),
Alcohol Consumption (Present),Spotreba alkoholu (súčasnosť),
Billing Item,Fakturačná položka,
Medical Codes,Lekárske kódy,
Clinical Procedures,Klinické postupy,
Order Admission,Objednávka Vstupné,
Scheduling Patient Admission,Plánovanie prijatia pacienta,
Order Discharge,Vybitie objednávky,
Sample Details,Ukážkové podrobnosti,
Collected On,Zhromaždené dňa,
No. of prints,Počet výtlačkov,
Number of prints required for labelling the samples,Počet výtlačkov potrebných na označenie vzoriek,
HLC-VTS-.YYYY.-,HLC-VTS-.RRRR.-,
Payroll Cost Center,Mzdové náklady,
Approvers,Schvaľovatelia,
The first Approver in the list will be set as the default Approver.,Prvý schvaľovateľ v zozname bude nastavený ako predvolený schvaľovateľ.,
Shift Request Approver,Schvaľovateľ žiadosti o zmenu,
Provident Fund Account,Účet podielového fondu,
MICR Code,Kód MICR,
Repay unclaimed amount from salary,Vrátiť nevyzdvihnutú sumu z platu,
Deduction from salary,Odpočet z platu,
If this is not checked the loan by default will be considered as a Demand Loan,"Pokiaľ to nie je zaškrtnuté, pôžička sa štandardne bude považovať za pôžičku na požiadanie",
This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,Tento účet sa používa na rezerváciu splátok pôžičky od dlžníka a tiež na vyplácanie pôžičiek dlžníkovi,
This account is capital account which is used to allocate capital for loan disbursal account ,"Tento účet je kapitálovým účtom, ktorý sa používa na pridelenie kapitálu pre účet vyplácania pôžičiek",
This account will be used for booking loan interest accruals,Tento účet sa použije na rezerváciu časového rozlíšenia úrokov z pôžičky,
This account will be used for booking penalties levied due to delayed repayments,Tento účet sa použije na rezerváciu pokút vyrubených z dôvodu oneskorených splátok,
Variant BOM,Kusovník variantov,
Template Item,Položka šablóny,
Select template item,Vyberte položku šablóny,
Select variant item code for the template item {0},Vyberte variantný kód položky pre položku šablóny {0},
Downtime Entry,Zadanie odstávky,
DT-,DT-,
Workstation / Machine,Pracovná stanica / stroj,
Operator,Prevádzkovateľ,
In Mins,In Mins,
Downtime Reason,Dôvod výpadku,
Stop Reason,Prestaň s rozumom,
Excessive machine set up time,Nadmerný čas na nastavenie stroja,
Unplanned machine maintenance,Neplánovaná údržba stroja,
On-machine press checks,Kontroly lisu na stroji,
Machine operator errors,Chyby obsluhy stroja,
Machine malfunction,Porucha stroja,
Electricity down,Elektrina vypnutá,
Operation Row Number,Číslo riadku operácie,
Operation {0} added multiple times in the work order {1},Operácia {0} bola v pracovnom poradí pridaná viackrát {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.","Ak je začiarknuté, pre jednu pracovnú objednávku je možné použiť viac materiálov. To je užitočné, ak sa vyrába jeden alebo viac časovo náročných výrobkov.",
Backflush Raw Materials,Suroviny na spätné preplachovanie,
"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áma ako backflush. Suroviny, ktoré sa spotrebúvajú na výrobu hotových výrobkov, sú známe ako spätné preplachovanie.<br><br> Pri vytváraní položky výroby sa položky surovín vrátia späť na základe kusovníka položky výroby. Ak chcete, aby boli položky surovín spätne vyplnené na základe zadania prevodu materiálu, ktoré bolo urobené proti tejto pracovnej objednávke, môžete ju nastaviť 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 sa automaticky aktualizuje v poli Work In Progress Warehouse v časti Pracovné objednávky.,
Finished Goods Warehouse,Sklad hotových výrobkov,
This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,Tento sklad sa automaticky aktualizuje v poli Cieľový sklad v Pracovnej objednávke.,
"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Ak je začiarknuté, náklady na kusovník sa automaticky aktualizujú na základe hodnoty ocenenia / sadzby cenníka / sadzby posledného nákupu surovín.",
Source Warehouses (Optional),Zdrojové sklady (voliteľné),
"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","Systém vyzdvihne materiály z vybraných skladov. Ak nie je uvedené, systém vytvorí materiálnu požiadavku na nákup.",
Lead Time,Dodacia lehota,
PAN Details,Detaily PAN,
Create Customer,Vytvorte zákazníka,
Invoicing,Fakturácia,
Enable Auto Invoicing,Povoliť automatickú fakturáciu,
Send Membership Acknowledgement,Pošlite potvrdenie členstva,
Send Invoice with Email,Pošlite faktúru e-mailom,
Membership Print Format,Členský tlačový formát,
Invoice Print Format,Formát tlače faktúr,
Revoke <Key></Key>,Odvolať&lt;Key&gt;&lt;/Key&gt;,
You can learn more about memberships in the manual. ,Viac informácií o členstvách sa dozviete v príručke.,
ERPNext Docs,ERPNext Docs,
Regenerate Webhook Secret,Obnovte tajomstvo Webhook,
Generate Webhook Secret,Vytvorte tajomstvo Webhook,
Copy Webhook URL,Skopírujte webovú adresu Webhook,
Linked Item,Prepojená položka,
Feedback By,Spätná väzba od,
Manufacturing Section,Výrobná sekcia,
"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","Predvolene je meno zákazníka nastavené podľa zadaného celého mena. Ak chcete, aby boli zákazníci pomenovaní a",
Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Pri vytváraní novej predajnej transakcie nakonfigurujte predvolený cenník. Ceny položiek sa načítajú z tohto cenníka.,
"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.","Ak je táto možnosť nakonfigurovaná na hodnotu „Áno“, ERPNext vám zabráni vo vytvorení predajnej faktúry alebo dodacieho listu bez toho, aby ste najskôr vytvorili zákazku odberateľa. Túto konfiguráciu je možné pre konkrétneho zákazníka prepísať začiarknutím políčka „Povoliť vytvorenie predajnej faktúry bez zákazky odberateľa“ v hlavnom serveri 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.","Ak je táto možnosť nakonfigurovaná na hodnotu „Áno“, ERPNext vám zabráni vo vytvorení predajnej faktúry bez vytvorenia dodacieho listu. Túto konfiguráciu je možné pre konkrétneho zákazníka prepísať začiarknutím políčka „Povoliť vytvorenie predajnej faktúry bez dodacieho listu“ v hlavnom okne zákazníka.",
Default Warehouse for Sales Return,Predvolený sklad pre vrátenie predaja,
Default In Transit Warehouse,Predvolené v dopravnom sklade,
Enable Perpetual Inventory For Non Stock Items,"Povoliť priebežnú inventúru položiek, ktoré nie sú na sklade",
HRA Settings,Nastavenia HRA,
Basic Component,Základná súčasť,
HRA Component,Komponent HRA,
Arrear Component,Arrear Component,
Please enter the company name to confirm,Zadajte názov spoločnosti na potvrdenie,
Quotation Lost Reason Detail,Ponuka - detail dôvodu straty,
Enable Variants,Povoliť varianty,
Save Quotations as Draft,Uložiť ponuky ako koncept,
MAT-DN-RET-.YYYY.-,MAT-DN-RET-.RRRR.-,
Please Select a Customer,Vyberte zákazníka,
Against Delivery Note Item,Proti položke poznámky k dodaniu,
Is Non GST ,Nie je GST,
Image Description,Popis obrázku,
Transfer Status,Stav prenosu,
MAT-PR-RET-.YYYY.-,MAT-PR-RET-.RRRR.-,
Track this Purchase Receipt against any Project,Sledujte tento doklad o kúpe oproti ľubovoľnému projektu,
Please Select a Supplier,Vyberte dodávateľa,
Add to Transit,Pridať do verejnej dopravy,
Set Basic Rate Manually,Nastaviť základnú sadzbu ručne,
"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","Predvolene je názov položky nastavený podľa zadaného kódu položky. Ak chcete, aby boli položky pomenované a",
Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Nastavte predvolený sklad pre transakcie zásob. Toto sa načíta do Predvoleného skladu v predlohe položky.,
"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.","Toto umožní, aby sa skladové položky zobrazovali v záporných hodnotách. Použitie tejto možnosti závisí od vášho prípadu použitia. Ak táto možnosť nie je začiarknutá, systém varuje pred blokovaním transakcie, ktorá spôsobuje záporné zásoby.",
Choose between FIFO and Moving Average Valuation Methods. Click ,Vyberte si medzi metódami oceňovania FIFO a kĺzavým priemerom. Kliknite,
 to know more about them.,vedieť o nich viac.,
Show 'Scan Barcode' field above every child table to insert Items with ease.,"Položky „Skenovať čiarový kód“ zobrazte nad každou podradenou tabuľkou, aby ste mohli položky vkladať ľahko.",
"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 pre sklad sa nastavia automaticky na základe zadaných položiek na základe prvého do prvého v transakciách, ako sú nákupné / predajné faktúry, dodacie listy atď.",
"If blank, parent Warehouse Account or company default will be considered in transactions","Ak je pole prázdne, pri transakciách sa bude brať do úvahy materský účet skladu alebo predvolené nastavenie spoločnosti",
Service Level Agreement Details,Podrobnosti dohody o úrovni služieb,
Service Level Agreement Status,Stav dohody o úrovni služby,
On Hold Since,Pozastavené od,
Total Hold Time,Celkový čas zadržania,
Response Details,Podrobnosti odpovede,
Average Response Time,Priemerný čas odozvy,
User Resolution Time,Čas rozlíšenia používateľa,
SLA is on hold since {0},SLA je pozastavená od {0},
Pause SLA On Status,Pozastaviť SLA v stave,
Pause SLA On,Pozastaviť SLA zapnutú,
Greetings Section,Sekcia pozdravov,
Greeting Title,Pozdravujem titul,
Greeting Subtitle,Pozdrav titulky,
Youtube ID,Youtube ID,
Youtube Statistics,Štatistika Youtube,
Views,Názory,
Dislikes,Nemá rád,
Video Settings,Nastavenia videa,
Enable YouTube Tracking,Povoliť sledovanie YouTube,
30 mins,30 minút,
1 hr,1 hod,
6 hrs,6 hod,
Patient Progress,Pokrok pacienta,
Targetted,Cielené,
Score Obtained,Získané skóre,
Sessions,Relácie,
Average Score,Priemerné skóre,
Select Assessment Template,Vyberte hodnotiacu šablónu,
 out of ,z,
Select Assessment Parameter,Vyberte parameter hodnotenia,
Gender: ,Rod:,
Contact: ,Kontakt:,
Total Therapy Sessions: ,Celkom terapeutických sedení:,
Monthly Therapy Sessions: ,Mesačné terapeutické sedenia:,
Patient Profile,Profil pacienta,
Point Of Sale,Miesto predaja,
Email sent successfully.,E-mail bol úspešne odoslaný.,
Search by invoice id or customer name,Vyhľadávajte podľa ID faktúry alebo mena zákazníka,
Invoice Status,Stav faktúry,
Filter by invoice status,Filtrovať podľa stavu faktúry,
Select item group,Vyberte skupinu položiek,
No items found. Scan barcode again.,Nenašli sa žiadne položky. Znova naskenujte čiarový kód.,
"Search by customer name, phone, email.","Hľadajte podľa mena zákazníka, telefónu, e-mailu.",
Enter discount percentage.,Zadajte percento zľavy.,
Discount cannot be greater than 100%,Zľava nemôže byť vyššia ako 100%,
Enter customer's email,Zadajte e-mail zákazníka,
Enter customer's phone number,Zadajte telefónne číslo zákazníka,
Customer contact updated successfully.,Kontakt so zákazníkom bol úspešne aktualizovaný.,
Item will be removed since no serial / batch no selected.,"Položka bude odstránená, pretože nie je vybraté žiadne sériové číslo / dávka.",
Discount (%),Zľava (%),
You cannot submit the order without payment.,Objednávku nemôžete odoslať bez platby.,
You cannot submit empty order.,Nemôžete zadať prázdnu objednávku.,
To Be Paid,Byť zaplatený,
Create POS Opening Entry,Vytvorte vstupný otvor POS,
Please add Mode of payments and opening balance details.,Pridajte spôsob platby a podrobnosti počiatočného zostatku.,
Toggle Recent Orders,Prepnúť nedávne objednávky,
Save as Draft,Uložiť ako koncept,
You must add atleast one item to save it as draft.,"Musíte pridať aspoň jednu položku, aby ste ju uložili ako koncept.",
There was an error saving the document.,Pri ukladaní dokumentu sa vyskytla chyba.,
You must select a customer before adding an item.,Pred pridaním položky musíte vybrať zákazníka.,
Please Select a Company,Vyberte spoločnosť,
Active Leads,Aktívni zákazníci,
Please Select a Company.,Vyberte spoločnosť.,
BOM Operations Time,Čas prevádzky kusovníka,
BOM ID,ID kusovníka,
BOM Item Code,Kód položky kusovníka,
Time (In Mins),Čas (v minútach),
Sub-assembly BOM Count,Počet kusovníkov podzostavy,
View Type,Typ zobrazenia,
Total Delivered Amount,Celková dodaná suma,
Downtime Analysis,Analýza prestojov,
Machine,Stroj,
Downtime (In Hours),Odstávka (v hodinách),
Employee Analytics,Analýza zamestnancov,
"""From date"" can not be greater than or equal to ""To date""",„Od dátumu“ nemôže byť väčšie alebo rovnaké ako „Od dátumu“,
Exponential Smoothing Forecasting,Exponenciálne vyhladzovanie prognóz,
First Response Time for Issues,Čas prvej reakcie na problémy,
First Response Time for Opportunity,Čas prvej odpovede na príležitosť,
Depreciatied Amount,Odpisovaná suma,
Period Based On,Obdobie založené na,
Date Based On,Dátum založený na,
{0} and {1} are mandatory,{0} a {1} sú povinné,
Consider Accounting Dimensions,Zvážte účtovné dimenzie,
Reserved Quantity for Production,Rezervované množstvo na výrobu,
Projected Quantity,Predpokladané množstvo,
 Total Sales Amount,Celková suma predaja,
Job Card Summary,Zhrnutie pracovnej karty,
Id,Id,
Time Required (In Mins),Požadovaný čas (v minútach),
From Posting Date,Od dátumu zaúčtovania,
To Posting Date,Ku dňu zaúčtovania,
No records found,Nenašli sa žiadne záznamy,
Customer/Lead Name,Meno zákazníka / potenciálneho zákazníka,
Production Planning Report,Správa o plánovaní výroby,
Order Qty,Množstvo,
Raw Material Code,Kód suroviny,
Raw Material Name,Názov suroviny,
Allotted Qty,Pridelené množstvo,
Expected Arrival Date,Očakávaný dátum príchodu,
Arrival Quantity,Množstvo príchodu,
Raw Material Warehouse,Sklad surovín,
Order By,Zoradiť podľa,
Include Sub-assembly Raw Materials,Zahrnúť suroviny podzostavy,
Program wise Fee Collection,Programovo múdry výber poplatkov,
Fees Collected,Poplatky vyberané,
Project Summary,Zhrnutie projektu,
Total Tasks,Celkom úloh,
Tasks Completed,Úlohy splnené,
Tasks Overdue,Úlohy po termíne,
Completion,Dokončenie,
Purchase Order Analysis,Analýza objednávok,
From and To Dates are required.,Od a do sú potrebné dátumy.,
To Date cannot be before From Date.,To Date nemôže byť skôr ako From Date.,
Qty to Bill,Množstvo Billovi,
Group by Purchase Order,Zoskupiť podľa nákupnej objednávky,
 Purchase Value,Hodnota nákupu,
Total Received Amount,Celková prijatá suma,
Quality Inspection Summary,Zhrnutie kontroly kvality,
 Quoted Amount,Uvedená suma,
Lead Time (Days),Lead Time (Days),
Include Expired,Zahrnúť Platnosť vypršala,
Requested Items to Order and Receive,Požadované položky na objednávku a príjem,
Sales Order Analysis,Analýza zákazky odberateľa,
Amount Delivered,Dodaná suma,
Delay (in Days),Oneskorenie (v dňoch),
Group by Sales Order,Zoskupiť podľa zákazky odberateľa,
 Sales Value,Hodnota predaja,
Stock Qty vs Serial No Count,Množstvo skladu vs sériové číslo sa nepočíta,
Serial No Count,Sériové číslo sa nepočíta,
Work Order Summary,Zhrnutie pracovnej objednávky,
Produce Qty,Množstvo produkcie,
Lead Time (in mins),Lead Time (v minútach),
Charts Based On,Grafy založené na,
YouTube Interactions,Interakcie s YouTube,
Published Date,Dátum zverejnenia,
Barnch,Barnch,
Select a Company,Vyberte spoločnosť,
Opportunity {0} created,Bola vytvorená príležitosť {0},
Kindly select the company first,Najskôr láskavo vyberte spoločnosť,
Please enter From Date and To Date to generate JSON,Zadajte dátum od a do dátumu a vygenerujte JSON,
Download DATEV File,Stiahnite si súbor DATEV,
Numero has not set in the XML file,Numero nenastavil v súbore XML,
Inward Supplies(liable to reverse charge),Dovozné dodávky (podliehajú preneseniu daňovej povinnosti),
This is based on the course schedules of this Instructor,Toto je založené na rozvrhoch kurzov tohto inštruktora,
Course and Assessment,Priebeh a hodnotenie,
Course {0} has been added to all the selected programs successfully.,Kurz {0} bol úspešne pridaný do všetkých vybraných programov.,
Programs updated,Programy boli aktualizované,
Program and Course,Program a kurz,
{0} or {1} is mandatory,{0} alebo {1} je povinné,
Mandatory Fields,Povinné polia,
Student {0}: {1} does not belong to Student Group {2},Študent {0}: {1} nepatrí do skupiny študentov {2},
Student Attendance record {0} already exists against the Student {1},Záznam dochádzky študentov {0} už proti študentovi existuje {1},
Course and Fee,Kurz a poplatok,
Not eligible for the admission in this program as per Date Of Birth,Nemá nárok na prijatie do tohto programu podľa dátumu narodenia,
Topic {0} has been added to all the selected courses successfully.,Téma {0} bola úspešne pridaná do všetkých vybraných kurzov.,
Courses updated,Kurzy boli aktualizované,
{0} {1} has been added to all the selected topics successfully.,Adresa {0} {1} bola úspešne pridaná do všetkých vybratých tém.,
Topics updated,Témy boli aktualizované,
Academic Term and Program,Akademický termín a program,
Please remove this item and try to submit again or update the posting time.,Odstráňte túto položku a skúste ju odoslať znova alebo aktualizujte čas zverejnenia.,
Failed to Authenticate the API key.,Nepodarilo sa overiť kľúč API.,
Invalid Credentials,Neplatné poverenia,
URL can only be a string,URL môže byť iba reťazec,
"Here is your webhook secret, this will be shown to you only once.","Toto je tajomstvo vášho webhooku, ktoré sa vám zobrazí iba raz.",
The payment for this membership is not paid. To generate invoice fill the payment details,Platba za toto členstvo sa nevypláca. Pre vygenerovanie faktúry vyplňte platobné podrobnosti,
An invoice is already linked to this document,Faktúra je už s týmto dokumentom prepojená,
No customer linked to member {},S členom {} nie je prepojený žiadny zákazník,
You need to set <b>Debit Account</b> in Membership Settings,V nastaveniach členstva je potrebné nastaviť <b>debetný účet</b>,
You need to set <b>Default Company</b> for invoicing in Membership Settings,V nastaveniach členstva musíte nastaviť <b>predvolenú spoločnosť</b> pre fakturáciu,
You need to enable <b>Send Acknowledge Email</b> in Membership Settings,V nastaveniach členstva musíte povoliť <b>odoslanie potvrdzovacieho e-mailu</b>,
Error creating membership entry for {0},Chyba pri vytváraní záznamu o členstve pre {0},
A customer is already linked to this Member,Zákazník je už prepojený s týmto členom,
End Date must not be lesser than Start Date,Dátum ukončenia nesmie byť menší ako dátum začatia,
Employee {0} already has Active Shift {1}: {2},Zamestnanec {0} už má aktívny posun {1}: {2},
 from {0},od {0},
 to {0},do {0},
Please set {0} for the Employee or for Department: {1},Nastavte {0} pre zamestnanca alebo pre oddelenie: {1},
Employee Onboarding: {0} is already for Job Applicant: {1},Prihlásenie zamestnanca: {0} už je pre uchádzača o zamestnanie: {1},
Asset Value Analytics,Analýza hodnoty majetku,
Category-wise Asset Value,Hodnota majetku podľa kategórie,
Total Assets,Celkové aktíva,
New Assets (This Year),Nové aktíva (tento rok),
Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Riadok č. {}: Dátum zaúčtovania odpisov by sa nemal rovnať Dátumu použitelnosti.,
Incorrect Date,Nesprávny dátum,
Invalid Gross Purchase Amount,Neplatná hrubá suma nákupu,
There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,Existuje aktívna údržba alebo oprava majetku. Pred zrušením diela musíte všetky dokončiť.,
% Complete,% Dokončené,
Back to Course,Späť na kurz,
Finish Topic,Dokončiť tému,
Mins,Min,
by,od,
Back to,Späť k,
Enrolling...,Registruje sa ...,
You have successfully enrolled for the program ,Úspešne ste sa zaregistrovali do programu,
Enrolled,Zapísaný,
Watch Intro,Pozrieť sa na úvod,
We're here to help!,"Sme tu, aby sme pomohli!",
Frequently Read Articles,Často čítajte články,
Please set a default company address,Nastavte predvolenú adresu spoločnosti,
{0} is not a valid state! Check for typos or enter the ISO code for your state.,{0} nie je platný stav! Skontrolujte preklepy alebo zadajte kód ISO svojho štátu.,
Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,"Pri analýze účtovnej osnovy sa vyskytla chyba: Skontrolujte, či žiadne dva účty nemajú rovnaký názov",
Plaid invalid request error,Chyba neplatnej žiadosti o prehlásenie,
Please check your Plaid client ID and secret values,Skontrolujte svoje ID klienta a tajné hodnoty,
Bank transaction creation error,Chyba pri vytváraní bankových transakcií,
Unit of Measurement,Jednotka merania,
Fiscal Year {0} Does Not Exist,Fiškálny rok {0} neexistuje,
Row # {0}: Returned Item {1} does not exist in {2} {3},Riadok č. {0}: Vrátená položka {1} neexistuje v doméne {2} {3},
Valuation type charges can not be marked as Inclusive,Poplatky typu ocenenia nemožno označiť ako inkluzívne,
You do not have permissions to {} items in a {}.,Nemáte oprávnenie k {} položkám v {}.,
Insufficient Permissions,Nedostatočné povolenia,
You are not allowed to update as per the conditions set in {} Workflow.,Nemáte povolenie na aktualizáciu podľa podmienok stanovených v {} pracovnom postupe.,
Expense Account Missing,Chýba výdavkový účet,
{0} is not a valid Value for Attribute {1} of Item {2}.,{0} nie je platná hodnota pre atribút {1} položky {2}.,
Invalid Value,Nesprávna hodnota,
The value {0} is already assigned to an existing Item {1}.,Hodnota {0} je už priradená k existujúcej položke {1}.,
"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Ak chcete pokračovať v úprave tejto hodnoty atribútu, povoľte v nastaveniach variantov položiek položku {0}.",
Edit Not Allowed,Úpravy nie sú povolené,
Row #{0}: Item {1} is already fully received in Purchase Order {2},Riadok č. {0}: Položka {1} je už úplne prijatá v objednávke {2},
You cannot create or cancel any accounting entries with in the closed Accounting Period {0},V uzavretom účtovnom období {0} nemôžete vytvárať ani rušiť žiadne účtovné položky.,
POS Invoice should have {} field checked.,Na faktúre POS by malo byť začiarknuté políčko {}.,
Invalid Item,Neplatná položka,
Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,Riadok č. {}: Do spätnej faktúry nemôžete pridať poštové množstvá. Na dokončenie vrátenia odstráňte položku {}.,
The selected change account {} doesn't belongs to Company {}.,Vybratý účet zmeny {} nepatrí spoločnosti {}.,
Atleast one invoice has to be selected.,Je potrebné zvoliť minimálne jednu faktúru.,
Payment methods are mandatory. Please add at least one payment method.,Spôsoby platby sú povinné. Pridajte aspoň jeden spôsob platby.,
Please select a default mode of payment,Vyberte predvolený spôsob platby,
You can only select one mode of payment as default,Predvolene môžete zvoliť iba jeden spôsob platby,
Missing Account,Chýbajúci účet,
Customers not selected.,Zákazníci neboli vybraní.,
Statement of Accounts,Výpis z účtov,
Ageing Report Based On ,Správa o starnutí založená na,
Please enter distributed cost center,Zadajte distribuované nákladové stredisko,
Total percentage allocation for distributed cost center should be equal to 100,Celková percentuálna alokácia pre distribuované nákladové stredisko by sa mala rovnať 100,
Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,"Nie je možné povoliť distribuované nákladové stredisko pre nákladové stredisko, ktoré je už pridelené v inom distribuovanom nákladovom stredisku",
Parent Cost Center cannot be added in Distributed Cost Center,Rodičovské nákladové stredisko nie je možné pridať do distribuovaného nákladového strediska,
A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Distribuované nákladové stredisko nemožno pridať do alokačnej tabuľky Distribuované nákladové stredisko.,
Cost Center with enabled distributed cost center can not be converted to group,Nákladové stredisko s povoleným distribuovaným nákladovým strediskom nie je možné previesť na skupinu,
Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,"Nákladové stredisko, ktoré je už pridelené v distribuovanom nákladovom stredisku, nie je možné previesť na skupinu",
Trial Period Start date cannot be after Subscription Start Date,Dátum začiatku skúšobného obdobia nemôže byť po dátume začatia predplatného,
Subscription End Date must be after {0} as per the subscription plan,Podľa dátumu predplatného musí byť dátum ukončenia predplatného nasledujúci po {0},
Subscription End Date is mandatory to follow calendar months,Dátum ukončenia predplatného je povinný nasledovať po kalendárnych mesiacoch,
Row #{}: POS Invoice {} is not against customer {},Riadok č. {}: POS faktúra {} nie je proti zákazníkovi {},
Row #{}: POS Invoice {} is not submitted yet,Riadok č. {}: POS faktúra {} ešte nie je odoslaná,
Row #{}: POS Invoice {} has been {},Riadok č. {}: POS faktúra {} bola {},
No Supplier found for Inter Company Transactions which represents company {0},"Nenašiel sa žiadny dodávateľ pre medzipodnikové transakcie, ktorý predstavuje spoločnosť {0}",
No Customer found for Inter Company Transactions which represents company {0},"Nenašiel sa žiadny zákazník pre medzipodnikové transakcie, ktorý predstavuje spoločnosť {0}",
Invalid Period,Neplatné obdobie,
Selected POS Opening Entry should be open.,Vybratá položka na otvorenie POS by mala byť otvorená.,
Invalid Opening Entry,Neplatný úvodný záznam,
Please set a Company,Zadajte spoločnosť,
"Sorry, this coupon code's validity has not started","Je nám ľúto, platnosť tohto kódu kupónu sa nezačala",
"Sorry, this coupon code's validity has expired","Ľutujeme, platnosť tohto kódu kupónu vypršala",
"Sorry, this coupon code is no longer valid","Je nám ľúto, tento kód kupónu už nie je platný",
For the 'Apply Rule On Other' condition the field {0} is mandatory,Pre podmienku „Použiť pravidlo na iné“ je pole {0} povinné,
{1} Not in Stock,{1} Nie je na sklade,
Only {0} in Stock for item {1},Na sklade iba {0} pre položku {1},
Please enter a coupon code,Zadajte kód kupónu,
Please enter a valid coupon code,Zadajte platný kód kupónu,
Invalid Child Procedure,Postup pri neplatnom dieťati,
Import Italian Supplier Invoice.,Importovať taliansku dodávateľskú faktúru.,
"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.",Na vykonanie účtovných zápisov pre položku {1} {2} je potrebná miera ocenenia položky {0}.,
 Here are the options to proceed:,"Tu sú možnosti, ako postupovať:",
"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.","Ak položka v tejto položke prebieha ako položka s nulovou hodnotou, povoľte v tabuľke položky {0} položku „Povoliť nulovú mieru ocenenia“.",
"If not, you can Cancel / Submit this entry ","Ak nie, môžete tento záznam zrušiť / odoslať",
 performing either one below:,ktorýkoľvek z nižšie uvedených spôsobov:,
Create an incoming stock transaction for the Item.,Vytvorte došlú skladovú transakciu pre položku.,
Mention Valuation Rate in the Item master.,Mieru ocenenia uveďte v predlohe položky.,
Valuation Rate Missing,Chýba miera ocenenia,
Serial Nos Required,Vyžadujú sa sériové čísla,
Quantity Mismatch,Nesúlad množstva,
"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Ak chcete pokračovať, znova zásobte položky a aktualizujte výberový zoznam. Ak chcete pokračovať, zrušte výberový zoznam.",
Out of Stock,Vypredané,
{0} units of Item {1} is not available.,{0} jednotky položky {1} nie sú k dispozícii.,
Item for row {0} does not match Material Request,Položka v riadku {0} sa nezhoduje s požiadavkou na materiál,
Warehouse for row {0} does not match Material Request,Sklad v riadku {0} sa nezhoduje s požiadavkou na materiál,
Accounting Entry for Service,Účtovný záznam za službu,
All items have already been Invoiced/Returned,Všetky položky už boli fakturované / vrátené,
All these items have already been Invoiced/Returned,Všetky tieto položky už boli fakturované / vrátené,
Stock Reconciliations,Zmierenie zásob,
Merge not allowed,Zlúčenie nie je povolené,
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.,"Nasledujúce odstránené atribúty existujú vo variantoch, ale nie v šablóne. Môžete buď odstrániť varianty, alebo ponechať atribúty v šablóne.",
Variant Items,Položky variantov,
Variant Attribute Error,Chyba atribútu variantu,
The serial no {0} does not belong to item {1},Sériové číslo {0} nepatrí k položke {1},
There is no batch found against the {0}: {1},Proti {0} sa nenašla žiadna dávka: {1},
Completed Operation,Dokončená operácia,
Work Order Analysis,Analýza pracovného príkazu,
Quality Inspection Analysis,Analýza kontroly kvality,
Pending Work Order,Čakajúca pracovná objednávka,
Last Month Downtime Analysis,Analýza výpadku za posledný mesiac,
Work Order Qty Analysis,Analýza množstva pracovných objednávok,
Job Card Analysis,Analýza karty práce,
Monthly Total Work Orders,Mesačné celkové objednávky,
Monthly Completed Work Orders,Mesačné dokončené pracovné príkazy,
Ongoing Job Cards,Prebiehajúce pracovné karty,
Monthly Quality Inspections,Mesačné kontroly kvality,
(Forecast),(Predpoveď),
Total Demand (Past Data),Celková požiadavka (minulé údaje),
Total Forecast (Past Data),Celková prognóza (minulé údaje),
Total Forecast (Future Data),Celková prognóza (budúce dáta),
Based On Document,Na základe dokumentu,
Based On Data ( in years ),Na základe údajov (v rokoch),
Smoothing Constant,Vyhladzovanie konštantné,
Please fill the Sales Orders table,Vyplňte tabuľku Objednávky predaja,
Sales Orders Required,Vyžadujú sa objednávky na predaj,
Please fill the Material Requests table,Vyplňte tabuľku Žiadosti o materiál,
Material Requests Required,Vyžadujú sa materiálne požiadavky,
Items to Manufacture are required to pull the Raw Materials associated with it.,"Položky na výrobu sú potrebné na stiahnutie surovín, ktoré sú s nimi spojené.",
Items Required,Položky sú povinné,
Operation {0} does not belong to the work order {1},Operácia {0} nepatrí do pracovného príkazu {1},
Print UOM after Quantity,Tlač MJ po množstve,
Set default {0} account for perpetual inventory for non stock items,"Nastaviť predvolený účet {0} pre večný inventár pre položky, ktoré nie sú na sklade",
Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Riadok č. {0}: Podradená položka by nemala byť balíkom produktov. Odstráňte položku {1} a uložte,
Credit limit reached for customer {0},Dosiahol sa úverový limit pre zákazníka {0},
Could not auto create Customer due to the following missing mandatory field(s):,Nepodarilo sa automaticky vytvoriť zákazníka z dôvodu nasledujúcich chýbajúcich povinných polí:,
Please create Customer from Lead {0}.,Vytvorte zákazníka z potenciálneho zákazníka {0}.,
Mandatory Missing,Povinne chýba,
From Date can not be greater than To Date.,Od dátumu nemôže byť väčšie ako Od dátumu.,
Row #{0}: Please enter the result value for {1},Riadok č. {0}: Zadajte výslednú hodnotu pre {1},
Mandatory Results,Povinné výsledky,
Sales Invoice or Patient Encounter is required to create Lab Tests,Na vytvorenie laboratórnych testov je potrebná predajná faktúra alebo stretnutie pacientov,
Insufficient Data,Nedostatočné údaje,
Lab Test(s) {0} created successfully,Laboratórne testy {0} boli úspešne vytvorené,
Test :,Test:,
Sample Collection {0} has been created,Bola vytvorená vzorová kolekcia {0},
Normal Range: ,Normálny rozsah:,
Row #{0}: Check Out datetime cannot be less than Check In datetime,Riadok č. {0}: Dátum odhlásenia nemôže byť kratší ako dátum príchodu,
"Missing required details, did not create Inpatient Record","Chýbajúce požadované podrobnosti, záznam o stacionárovi sa nevytvoril",
Unbilled Invoices,Nevyfakturované faktúry,
Standard Selling Rate should be greater than zero.,Štandardná predajná cena by mala byť vyššia ako nula.,
Conversion Factor is mandatory,Prepočítavací faktor je povinný,
Row #{0}: Conversion Factor is mandatory,Riadok č. {0}: Konverzný faktor je povinný,
Sample Quantity cannot be negative or 0,Množstvo vzorky nemôže byť záporné alebo 0,
Invalid Quantity,Neplatné množstvo,
"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","V nastaveniach predaja nastavte predvolené hodnoty pre skupinu zákazníkov, teritórium a cenník predaja",
{0} on {1},{0} dňa {1},
{0} with {1},{0} s {1},
Appointment Confirmation Message Not Sent,Správa o potvrdení schôdzky nebola odoslaná,
"SMS not sent, please check SMS Settings","SMS nebola odoslaná, skontrolujte Nastavenia SMS",
Healthcare Service Unit Type cannot have both {0} and {1},Typ jednotky zdravotnej starostlivosti nemôže mať {0} aj {1},
Healthcare Service Unit Type must allow atleast one among {0} and {1},Typ jednotky zdravotnej starostlivosti musí umožniť minimálne jednu z možností {0} a {1},
Set Response Time and Resolution Time for Priority {0} in row {1}.,Nastavte čas odozvy a čas rozlíšenia pre prioritu {0} v riadku {1}.,
Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Čas odozvy pre {0} prioritu v riadku {1} nemôže byť väčší ako Čas rozlíšenia.,
{0} is not enabled in {1},Aplikácia {0} nie je povolená v doméne {1},
Group by Material Request,Zoskupiť podľa žiadosti o materiál,
Email Sent to Supplier {0},E-mail odoslaný dodávateľovi {0},
"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Prístup k žiadosti o cenovú ponuku z portálu je zakázaný. Ak chcete povoliť prístup, povoľte ho v nastaveniach portálu.",
Supplier Quotation {0} Created,Cenová ponuka dodávateľa {0} bola vytvorená,
Valid till Date cannot be before Transaction Date,Platné do dátumu nemôže byť skôr ako dátum transakcie,
Unlink Advance Payment on Cancellation of Order,Zrušenie prepojenia zálohy pri zrušení objednávky,
"Simple Python Expression, Example: territory != 'All Territories'","Jednoduchý výraz v jazyku Python, príklad: Teritorium! = &#39;Všetky územia&#39;",
Sales Contributions and Incentives,Príspevky k predaju a stimuly,
Sourced by Supplier,Zabezpečené dodávateľom,
Total weightage assigned should be 100%.<br>It is {0},Celková pridelená hmotnosť by mala byť 100%.<br> Je to {0},
Account {0} exists in parent company {1}.,Účet {0} existuje v materskej spoločnosti {1}.,
"To overrule this, enable '{0}' in company {1}","Ak to chcete prekonať, povoľte „{0}“ v spoločnosti {1}",
Invalid condition expression,Neplatný výraz podmienky,
Please Select a Company First,Najskôr vyberte spoločnosť,
Please Select Both Company and Party Type First,Najskôr vyberte spoločnosť a typ strany,
Provide the invoice portion in percent,Poskytnite časť faktúry v percentách,
Give number of days according to prior selection,Uveďte počet dní podľa predchádzajúceho výberu,
Email Details,E-mailové podrobnosti,
"Select a greeting for the receiver. E.g. Mr., Ms., etc.","Vyberte pozdrav pre príjemcu. Napr. Pán, pani atď.",
Preview Email,Zobraziť ukážku e-mailu,
Please select a Supplier,Vyberte dodávateľa,
Supplier Lead Time (days),Dodací čas dodávateľa (dni),
"Home, Work, etc.","Domov, Práca atď.",
Exit Interview Held On,Ukončený pohovor,
Sets 'Target Warehouse' in each row of the Items table.,Nastavuje „Cieľový sklad“ v každom riadku tabuľky Položky.,
Sets 'Source Warehouse' in each row of the Items table.,Nastavuje „Zdrojový sklad“ v každom riadku tabuľky Položky.,
POS Register,POS register,
"Can not filter based on POS Profile, if grouped by POS Profile","Nie je možné filtrovať na základe POS profilu, ak je zoskupený podľa POS profilu",
"Can not filter based on Customer, if grouped by Customer","Nie je možné filtrovať na základe zákazníka, ak je zoskupený podľa zákazníka",
"Can not filter based on Cashier, if grouped by Cashier","Nie je možné filtrovať na základe pokladne, ak je zoskupená podľa pokladníka",
Payment Method,Spôsob platby,
"Can not filter based on Payment Method, if grouped by Payment Method","Nie je možné filtrovať na základe spôsobu platby, ak je zoskupený podľa spôsobu platby",
Supplier Quotation Comparison,Porovnanie ponúk dodávateľa,
Price per Unit (Stock UOM),Cena za jednotku (skladové množstvo),
Group by Supplier,Zoskupiť podľa dodávateľa,
Group by Item,Zoskupiť podľa položky,
Remember to set {field_label}. It is required by {regulation}.,Nezabudnite nastaviť {field_label}. Vyžaduje sa {nariadením}.,
Enrollment Date cannot be before the Start Date of the Academic Year {0},Dátum registrácie nemôže byť skôr ako dátum začatia akademického roka {0},
Enrollment Date cannot be after the End Date of the Academic Term {0},Dátum registrácie nemôže byť po dátume ukončenia akademického obdobia {0},
Enrollment Date cannot be before the Start Date of the Academic Term {0},Dátum registrácie nemôže byť skôr ako dátum začiatku akademického obdobia {0},
Future Posting Not Allowed,Budúce zverejňovanie nie je povolené,
"To enable Capital Work in Progress Accounting, ","Ak chcete povoliť postupné účtovanie kapitálu,",
you must select Capital Work in Progress Account in accounts table,v tabuľke účtov musíte vybrať Účet rozpracovaného kapitálu,
You can also set default CWIP account in Company {},Môžete tiež nastaviť predvolený účet CWIP v spoločnosti {},
The Request for Quotation can be accessed by clicking on the following button,K žiadosti o cenovú ponuku sa dostanete kliknutím na nasledujúce tlačidlo,
Regards,S pozdravom,
Please click on the following button to set your new password,Kliknutím na nasledujúce tlačidlo nastavíte svoje nové heslo,
Update Password,Aktualizujte heslo,
Row #{}: Selling rate for item {} is lower than its {}. Selling {} should be atleast {},Riadok č. {}: Miera predaja položky {} je nižšia ako hodnota {}. Predaj {} by mal byť minimálne {},
You can alternatively disable selling price validation in {} to bypass this validation.,"Alternatívne môžete deaktivovať overenie predajnej ceny v {}, aby ste obišli toto overenie.",
Invalid Selling Price,Neplatná predajná cena,
Address needs to be linked to a Company. Please add a row for Company in the Links table.,Adresa musí byť prepojená so spoločnosťou. V tabuľke odkazov pridajte riadok pre spoločnosť.,
Company Not Linked,Spoločnosť neprepojená,
Import Chart of Accounts from CSV / Excel files,Importujte účtovnú osnovu zo súborov CSV / Excel,
Completed Qty cannot be greater than 'Qty to Manufacture',Vyplnené množstvo nemôže byť väčšie ako „Množstvo do výroby“,
"Row {0}: For Supplier {1}, Email Address is Required to send an email",Riadok {0}: Pre dodávateľa {1} je na odoslanie e-mailu vyžadovaná e-mailová adresa,
"If enabled, the system will post accounting entries for inventory automatically","Ak je povolené, systém bude automaticky účtovať účtovné položky pre inventár",
Accounts Frozen Till Date,Účty zmrazené do dátumu,
Accounting entries are frozen up to this date. Nobody can create or modify entries except users with the role specified below,Účtovné záznamy sú zmrazené až do tohto dátumu. Nikto nemôže vytvárať ani upravovať položky okrem používateľov s rolou uvedenou nižšie,
Role Allowed to Set Frozen Accounts and Edit Frozen Entries,Úloha povolená pri nastavovaní zmrazených účtov a úprave zmrazených záznamov,
Address used to determine Tax Category in transactions,Adresa použitá na určenie daňovej kategórie v transakciách,
"The 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 up to $110 ","Percento, ktoré môžete účtovať viac oproti objednanej sume. Napríklad, ak je hodnota objednávky pre položku 100 USD a tolerancia je nastavená na 10%, môžete fakturovať až 110 USD.",
This role is allowed to submit transactions that exceed credit limits,"Táto rola smie odosielať transakcie, ktoré prekračujú úverové limity",
"If ""Months"" is selected, a fixed amount will be booked as deferred revenue or expense for each month irrespective of the number of days in a month. It will be prorated if deferred revenue or expense is not booked for an entire month","Ak vyberiete možnosť „Mesiace“, pevná suma sa zaúčtuje ako odložený príjem alebo náklad za každý mesiac bez ohľadu na počet dní v mesiaci. Ak nebudú odložené príjmy alebo náklady zaúčtované celý mesiac, bude to rozdelené podľa pomerných častí",
"If this is unchecked, direct GL entries will be created to book deferred revenue or expense","Ak to nie je začiarknuté, vytvoria sa priame záznamy GL, aby sa zaúčtovali odložené výnosy alebo náklady",
Show Inclusive Tax in Print,Zobraziť tlačenú daň vrátane,
Only select this if you have set up the Cash Flow Mapper documents,"Túto voľbu vyberte, iba ak ste nastavili dokumenty mapovača hotovostných tokov",
Payment Channel,Platobný kanál,
Is Purchase Order Required for Purchase Invoice & Receipt Creation?,Je na vytvorenie nákupnej faktúry a prijatia objednávky potrebná objednávka?,
Is Purchase Receipt Required for Purchase Invoice Creation?,Je na vytvorenie faktúry za nákup potrebný doklad o kúpe?,
Maintain Same Rate Throughout the Purchase Cycle,Udržiavajte rovnakú mieru počas celého nákupného cyklu,
Allow Item To Be Added Multiple Times in a Transaction,Povoliť viacnásobné pridanie položky v transakcii,
Suppliers,Dodávatelia,
Send Emails to Suppliers,Posielajte e-maily dodávateľom,
Select a Supplier,Vyberte dodávateľa,
Cannot mark attendance for future dates.,Pre budúce dátumy nie je možné označiť účasť.,
Do you want to update attendance? <br> Present: {0} <br> Absent: {1},Chcete aktualizovať dochádzku?<br> Súčasnosť: {0}<br> Neprítomné: {1},
Mpesa Settings,Nastavenia Mpesa,
Initiator Name,Meno iniciátora,
Till Number,Číslo dokladu,
Sandbox,Pieskovisko,
 Online PassKey,Online PassKey,
Security Credential,Bezpečnostné poverenie,
Get Account Balance,Získajte zostatok na účte,
Please set the initiator name and the security credential,Nastavte meno iniciátora a bezpečnostné poverenie,
Inpatient Medication Entry,Vstup pre hospitalizovaných pacientov,
HLC-IME-.YYYY.-,HLC-IME-.RRRR.-,
Item Code (Drug),Kód položky (droga),
Medication Orders,Objednávky liekov,
Get Pending Medication Orders,Získajte čakajúce objednávky liekov,
Inpatient Medication Orders,Objednávky liekov na hospitalizáciu,
Medication Warehouse,Sklad liekov,
Warehouse from where medication stock should be consumed,"Sklad, z ktorého sa má spotrebovať sklad liekov",
Fetching Pending Medication Orders,Načítavajú sa čakajúce objednávky liekov,
Inpatient Medication Entry Detail,Podrobnosti o vstupe do ústavnej liečby,
Medication Details,Podrobnosti o liekoch,
Drug Code,Drogový zákonník,
Drug Name,Názov lieku,
Against Inpatient Medication Order,Proti príkazu na hospitalizáciu u pacienta,
Against Inpatient Medication Order Entry,Proti záznamu objednávky ústavnej liečby,
Inpatient Medication Order,Príkaz na hospitalizáciu u pacienta,
HLC-IMO-.YYYY.-,HLC-IMO-.RRRR.-,
Total Orders,Celkový počet objednávok,
Completed Orders,Vyplnené objednávky,
Add Medication Orders,Pridajte objednávky liekov,
Adding Order Entries,Pridávanie položiek objednávky,
{0} medication orders completed,Objednávky liekov boli dokončené,
{0} medication order completed,{0} objednávka liekov dokončená,
Inpatient Medication Order Entry,Zadanie objednávky ústavnej liečby,
Is Order Completed,Je objednávka dokončená,
Employee Records to Be Created By,"Záznamy zamestnancov, ktoré majú vytvárať",
Employee records are created using the selected field,Záznamy zamestnancov sa vytvárajú pomocou vybratého poľa,
Don't send employee birthday reminders,Neposielajte zamestnancom pripomienky k narodeninám,
Restrict Backdated Leave Applications,Obmedziť spätné použitie aplikácií,
Sequence ID,ID sekvencie,
Sequence Id,Id,
Allow multiple material consumptions against a Work Order,Povoliť viacnásobnú spotrebu materiálu oproti pracovnej objednávke,
Plan time logs outside Workstation working hours,Plánujte časové protokoly mimo pracovnej doby pracovnej stanice,
Plan operations X days in advance,Plánujte operácie X dní vopred,
Time Between Operations (Mins),Čas medzi operáciami (minúty),
Default: 10 mins,Predvolené: 10 minút,
Overproduction for Sales and Work Order,Nadprodukcia pre predaj a objednávku,
"Update BOM cost automatically via scheduler, based on the latest Valuation Rate/Price List Rate/Last Purchase Rate of raw materials",Aktualizujte náklady na kusovník automaticky pomocou plánovača na základe najnovšej hodnoty ocenenia / sadzby cenníka / sadzby posledného nákupu surovín.,
Purchase Order already created for all Sales Order items,Objednávka je už vytvorená pre všetky položky zákazky odberateľa,
Select Items,Vyberte položky,
Against Default Supplier,Proti predvolenému dodávateľovi,
Auto close Opportunity after the no. of days mentioned above,Automatické uzavretie príležitosti po č. dní uvedených vyššie,
Is Sales Order Required for Sales Invoice & Delivery Note Creation?,Vyžaduje sa zákazka odberateľa na vytvorenie predajnej faktúry a vytvorenia dodacieho listu?,
Is Delivery Note Required for Sales Invoice Creation?,Je na vytvorenie predajnej faktúry potrebný dodací list?,
How often should Project and Company be updated based on Sales Transactions?,Ako často by sa mal projekt a spoločnosť aktualizovať na základe predajných transakcií?,
Allow User to Edit Price List Rate in Transactions,Umožniť používateľovi upraviť cenník v transakciách,
Allow Item to Be Added Multiple Times in a Transaction,Povoliť viacnásobné pridanie položky v transakcii,
Allow Multiple Sales Orders Against a Customer's Purchase Order,Povoliť viac objednávok odberateľa oproti objednávke zákazníka,
Validate Selling Price for Item Against Purchase Rate or Valuation Rate,Overte predajnú cenu položky oproti kúpnej cene alebo miere ocenenia,
Hide Customer's Tax ID from Sales Transactions,Skryť daňové identifikačné číslo zákazníka z predajných transakcií,
"The 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.","Percento, ktoré môžete oproti objednanému množstvu prijať alebo doručiť viac. Napríklad, ak ste si objednali 100 jednotiek a váš príspevok je 10%, máte povolený príjem 110 jednotiek.",
Action If Quality Inspection Is Not Submitted,"Opatrenie, ak nie je predložená kontrola kvality",
Auto Insert Price List Rate If Missing,"Automatické vloženie cenníka, ak chýba",
Automatically Set Serial Nos Based on FIFO,Automaticky nastaviť sériové čísla na základe FIFO,
Set Qty in Transactions Based on Serial No Input,Nastaviť množstvo v transakciách na základe sériového bez vstupu,
Raise Material Request When Stock Reaches Re-order Level,"Zvýšiť požiadavku na materiál, keď skladová kapacita dosiahne úroveň opätovného objednania",
Notify by Email on Creation of Automatic Material Request,Upozorniť e-mailom na vytvorenie automatickej žiadosti o materiál,
Allow Material Transfer from Delivery Note to Sales Invoice,Povoliť prenos materiálu z dodacieho listu do predajnej faktúry,
Allow Material Transfer from Purchase Receipt to Purchase Invoice,Povoliť prenos materiálu z dokladu o kúpe do faktúry za nákup,
Freeze Stocks Older Than (Days),Zmraziť zásoby staršie ako (dni),
Role Allowed to Edit Frozen Stock,Úloha povolená na úpravu zmrazeného tovaru,
The unallocated amount of Payment Entry {0} is greater than the Bank Transaction's unallocated amount,Nepridelená suma položky platby {0} je vyššia ako nepridelená suma bankovej transakcie,
Payment Received,Platba prijatá,
Attendance cannot be marked outside of Academic Year {0},Účasť nie je možné označiť mimo akademického roku {0},
Student is already enrolled via Course Enrollment {0},Študent je už zaregistrovaný prostredníctvom registrácie do kurzu {0},
Attendance cannot be marked for future dates.,Účasť nie je možné označiť pre budúce dátumy.,
Please add programs to enable admission application.,"Pridajte programy, aby ste povolili prihlášku na prijatie.",
The following employees are currently still reporting to {0}:,Nasledujúci zamestnanci sa v súčasnosti stále hlásia pre {0}:,
Please make sure the employees above report to another Active employee.,"Uistite sa, že vyššie uvedení zamestnanci sa hlásia u iného aktívneho zamestnanca.",
Cannot Relieve Employee,Nemožno uvoľniť zamestnanca,
Please enter {0},Zadajte {0},
Please select another payment method. Mpesa does not support transactions in currency '{0}',Vyberte iný spôsob platby. Spoločnosť Mpesa nepodporuje transakcie v mene „{0}“,
Transaction Error,Chyba transakcie,
Mpesa Express Transaction Error,Chyba expresnej transakcie spoločnosti Mpesa,
"Issue detected with Mpesa configuration, check the error logs for more details",Zistil sa problém s konfiguráciou Mpesa. Ďalšie podrobnosti nájdete v protokoloch chýb,
Mpesa Express Error,Chyba Mpesa Express,
Account Balance Processing Error,Chyba spracovania zostatku na účte,
Please check your configuration and try again,Skontrolujte svoju konfiguráciu a skúste to znova,
Mpesa Account Balance Processing Error,Chyba spracovania zostatku na účte Mpesa,
Balance Details,Detaily zostatku,
Current Balance,Aktuálny zostatok,
Available Balance,Disponibilný zostatok,
Reserved Balance,Vyhradený zostatok,
Uncleared Balance,Nevyúčtovaný zostatok,
Payment related to {0} is not completed,Platba súvisiaca s účtom {0} nie je dokončená,
Row #{}: Item Code: {} is not available under warehouse {}.,Riadok # {}: Kód položky: {} nie je k dispozícii v sklade {}.,
Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}. Available quantity {}.,Riadok # {}: Množstvo skladu nestačí na kód položky: {} v sklade {}. Dostupné množstvo {}.,
Row #{}: Please select a serial no and batch against item: {} or remove it to complete transaction.,"Riadok č. {}: Vyberte sériové číslo a porovnajte položku s položkou: {} alebo ju odstráňte, čím dokončíte transakciu.",
Row #{}: No serial number selected against item: {}. Please select one or remove it to complete transaction.,Riadok # {}: Pri položke nebolo vybrané sériové číslo: {}. Na dokončenie transakcie vyberte jednu alebo ju odstráňte.,
Row #{}: No batch selected against item: {}. Please select a batch or remove it to complete transaction.,Riadok č. {}: Nie je vybratá žiadna dávka oproti položke: {}. Na dokončenie transakcie vyberte dávku alebo ju odstráňte.,
Payment amount cannot be less than or equal to 0,Výška platby nemôže byť menšia alebo rovná 0,
Please enter the phone number first,Najskôr zadajte telefónne číslo,
Row #{}: {} {} does not exist.,Riadok č. {}: {} {} Neexistuje.,
Row #{0}: {1} is required to create the Opening {2} Invoices,Riadok č. {0}: {1} sa vyžaduje na vytvorenie úvodných {2} faktúr,
You had {} errors while creating opening invoices. Check {} for more details,Pri vytváraní otváracích faktúr ste mali chyby {}. Ďalšie podrobnosti nájdete na {},
Error Occured,Vyskytla sa chyba,
Opening Invoice Creation In Progress,Otvára sa prebiehajúca tvorba faktúry,
Creating {} out of {} {},Vytvára sa {} z {} {},
(Serial No: {0}) cannot be consumed as it's reserverd to fullfill Sales Order {1}.,"(Sériové číslo: {0}) nie je možné spotrebovať, pretože sa vyhľadáva na vyplnenie zákazky odberateľa {1}.",
Item {0} {1},Položka {0} {1},
Last Stock Transaction for item {0} under warehouse {1} was on {2}.,Posledná skladová transakcia s položkou {0} v sklade {1} sa uskutočnila {2}.,
Stock Transactions for Item {0} under warehouse {1} cannot be posted before this time.,Skladové transakcie pre položku {0} v sklade {1} nemožno zaúčtovať skôr.,
Posting future stock transactions are not allowed due to Immutable Ledger,Zaúčtovanie budúcich transakcií s akciami nie je povolené z dôvodu Immutable Ledger,
A BOM with name {0} already exists for item {1}.,Kusovník s názvom {0} už pre položku {1} existuje.,
{0}{1} Did you rename the item? Please contact Administrator / Tech support,{0} {1} Premenovali ste položku? Kontaktujte administrátora / technickú podporu,
At row #{0}: the sequence id {1} cannot be less than previous row sequence id {2},V riadku č. {0}: ID sekvencie {1} nemôže byť menšie ako ID sekvencie v predchádzajúcom riadku {2},
The {0} ({1}) must be equal to {2} ({3}),Hodnota {0} ({1}) sa musí rovnať hodnote {2} ({3}),
"{0}, complete the operation {1} before the operation {2}.","{0}, dokončite operáciu {1} pred operáciou {2}.",
Cannot ensure delivery by Serial No as Item {0} is added with and without Ensure Delivery by Serial No.,"Nemôžem zabezpečiť dodanie podľa sériového čísla, pretože položka {0} je pridaná s alebo bez Zabezpečiť doručenie podľa sériového čísla",
Item {0} has no Serial No. Only serilialized items can have delivery based on Serial No,Položka {0} nemá sériové číslo. Na základe sériového čísla môžu byť dodávané iba položky serializované,
No active BOM found for item {0}. Delivery by Serial No cannot be ensured,Pre položku {0} sa nenašiel žiadny aktívny kusovník. Dodanie sériovým číslom nie je možné zabezpečiť,
No pending medication orders found for selected criteria,Pre vybrané kritériá sa nenašli žiadne čakajúce objednávky liekov,
From Date cannot be after the current date.,Od dátumu nemôže byť po aktuálnom dátume.,
To Date cannot be after the current date.,To Date nemôže byť po aktuálnom dátume.,
From Time cannot be after the current time.,Z času nemôže byť po aktuálnom čase.,
To Time cannot be after the current time.,Do času nemôže byť po aktuálnom čase.,
Stock Entry {0} created and ,Skladová položka {0} bola vytvorená a,
Inpatient Medication Orders updated successfully,Objednávky liekov na hospitalizáciu sa úspešne aktualizovali,
Row {0}: Cannot create Inpatient Medication Entry against cancelled Inpatient Medication Order {1},Riadok {0}: Nie je možné vytvoriť záznam o lôžkových liekoch proti zrušenej objednávke na lôžkové lieky {1},
Row {0}: This Medication Order is already marked as completed,Riadok {0}: Táto objednávka liekov je už označená ako dokončená,
Quantity not available for {0} in warehouse {1},Množstvo nie je k dispozícii pre {0} v sklade {1},
Please enable Allow Negative Stock in Stock Settings or create Stock Entry to proceed.,"Ak chcete pokračovať, povoľte možnosť Povoliť zápornú akciu v nastaveniach skladu alebo vytvorte položku skladu.",
No Inpatient Record found against patient {0},Proti pacientovi {0} sa nenašiel žiadny záznam o hospitalizácii,
An Inpatient Medication Order {0} against Patient Encounter {1} already exists.,Príkaz na hospitalizáciu {0} proti stretnutiu pacienta {1} už existuje.,
Allow In Returns,Povoliť pri vrátení,
Hide Unavailable Items,Skryť nedostupné položky,
Apply Discount on Discounted Rate,Použite zľavu na zľavnenú sadzbu,
Therapy Plan Template,Šablóna plánu terapie,
Fetching Template Details,Načítavajú sa podrobnosti šablóny,
Linked Item Details,Podrobnosti prepojenej položky,
Therapy Types,Typy terapie,
Therapy Plan Template Detail,Detail šablóny terapeutického plánu,
Non Conformance,Nezhoda,
Process Owner,Vlastník procesu,
Corrective Action,Nápravné opatrenia,
Preventive Action,Preventívna akcia,
Problem,Problém,
Responsible,Zodpovedný,
Completion By,Dokončenie do,
Process Owner Full Name,Celé meno vlastníka procesu,
Right Index,Správny index,
Left Index,Ľavý index,
Sub Procedure,Čiastkový postup,
Passed,Prešiel,
Print Receipt,Tlač potvrdenky,
Edit Receipt,Upraviť príjmový doklad,
Focus on search input,Zamerajte sa na vstup vyhľadávania,
Focus on Item Group filter,Zamerajte sa na filter Skupiny položiek,
Checkout Order / Submit Order / New Order,Pokladňa Objednávka / Odoslať objednávku / Nová objednávka,
Add Order Discount,Pridajte zľavu na objednávku,
Item Code: {0} is not available under warehouse {1}.,Kód položky: {0} nie je k dispozícii v sklade {1}.,
Serial numbers unavailable for Item {0} under warehouse {1}. Please try changing warehouse.,Sériové čísla nie sú k dispozícii pre položku {0} v sklade {1}. Skúste zmeniť sklad.,
Fetched only {0} available serial numbers.,Načítalo sa iba {0} dostupných sériových čísel.,
Switch Between Payment Modes,Prepínanie medzi platobnými režimami,
Enter {0} amount.,Zadajte sumu {0}.,
You don't have enough points to redeem.,Nemáte dostatok bodov na uplatnenie.,
You can redeem upto {0}.,Môžete uplatniť až {0}.,
Enter amount to be redeemed.,"Zadajte sumu, ktorá sa má uplatniť.",
You cannot redeem more than {0}.,Nemôžete uplatniť viac ako {0}.,
Open Form View,Otvorte formulárové zobrazenie,
POS invoice {0} created succesfully,POS faktúra {0} bola úspešne vytvorená,
Stock quantity not enough for Item Code: {0} under warehouse {1}. Available quantity {2}.,Skladové množstvo nestačí na kód položky: {0} v sklade {1}. Dostupné množstvo {2}.,
Serial No: {0} has already been transacted into another POS Invoice.,Sériové číslo: {0} už bolo prevedené na inú POS faktúru.,
Balance Serial No,Sériové číslo zostatku,
Warehouse: {0} does not belong to {1},Sklad: {0} nepatrí k {1},
Please select batches for batched item {0},Vyberte dávky pre dávkovú položku {0},
Please select quantity on row {0},Vyberte množstvo v riadku {0},
Please enter serial numbers for serialized item {0},Zadajte sériové čísla pre serializovanú položku {0},
Batch {0} already selected.,Dávka {0} je už vybratá.,
Please select a warehouse to get available quantities,"Vyberte si sklad, aby ste získali dostupné množstvá",
"For transfer from source, selected quantity cannot be greater than available quantity",Pre prenos zo zdroja nemôže byť vybrané množstvo väčšie ako dostupné množstvo,
Cannot find Item with this Barcode,Položka s týmto čiarovým kódom sa nedá nájsť,
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} je povinné. Možno nie je vytvorený záznam výmeny mien od {1} do {2},
{} has submitted assets linked to it. You need to cancel the assets to create purchase return.,"{} odoslal diela s ním spojené. Ak chcete vytvoriť návratnosť nákupu, musíte aktíva zrušiť.",
Cannot cancel this document as it is linked with submitted asset {0}. Please cancel it to continue.,"Tento dokument nie je možné zrušiť, pretože je prepojený s odoslaným dielom {0}. Ak chcete pokračovať, zrušte ich.",
Row #{}: Serial No. {} has already been transacted into another POS Invoice. Please select valid serial no.,Riadok # {}: Sériové číslo {} už bol prevedený na inú POS faktúru. Vyberte prosím platné sériové číslo.,
Row #{}: Serial Nos. {} has already been transacted into another POS Invoice. Please select valid serial no.,Riadok # {}: Sériové čísla {} už bol prevedený na inú POS faktúru. Vyberte prosím platné sériové číslo.,
Item Unavailable,Položka nie je k dispozícii,
Row #{}: Serial No {} cannot be returned since it was not transacted in original invoice {},"Riadok č. {}: Sériové číslo {} nie je možné vrátiť, pretože nebol vykonaný v pôvodnej faktúre {}",
Please set default Cash or Bank account in Mode of Payment {},V platobnom režime nastavte predvolenú hotovosť alebo bankový účet {},
Please set default Cash or Bank account in Mode of Payments {},V platobnom režime nastavte predvolený hotovostný alebo bankový účet {},
Please ensure {} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account.,"Zaistite, aby účet {} bol súvahovým účtom. Môžete zmeniť nadradený účet na súvahový alebo zvoliť iný účet.",
Please ensure {} account is a Payable account. Change the account type to Payable or select a different account.,"Zaistite, aby účet {} bol platiteľským účtom. Zmeňte typ účtu na splatný alebo vyberte iný účet.",
Row {}: Expense Head changed to {} ,Riadok {}: Výdavková hlava sa zmenila na {},
because account {} is not linked to warehouse {} ,pretože účet {} nie je prepojený so skladom {},
or it is not the default inventory account,alebo to nie je predvolený účet zásob,
Expense Head Changed,Výdavková hlava zmenená,
because expense is booked against this account in Purchase Receipt {},pretože náklady sú voči tomuto účtu zaúčtované v doklade o kúpe {},
as no Purchase Receipt is created against Item {}. ,pretože s položkou {} sa nevytvára žiadny doklad o kúpe.,
This is done to handle accounting for cases when Purchase Receipt is created after Purchase Invoice,"Toto sa vykonáva na spracovanie účtovníctva v prípadoch, keď sa po nákupnej faktúre vytvorí príjmový doklad",
Purchase Order Required for item {},Pre položku {} je požadovaná objednávka,
To submit the invoice without purchase order please set {} ,"Ak chcete odoslať faktúru bez objednávky, nastavte {}",
as {} in {},ako v {},
Mandatory Purchase Order,Povinná objednávka,
Purchase Receipt Required for item {},Pre položku {} sa vyžaduje doklad o kúpe,
To submit the invoice without purchase receipt please set {} ,"Ak chcete odoslať faktúru bez dokladu o kúpe, nastavte {}",
Mandatory Purchase Receipt,Povinný doklad o kúpe,
POS Profile {} does not belongs to company {},POS profil {} nepatrí spoločnosti {},
User {} is disabled. Please select valid user/cashier,Používateľ {} je zakázaný. Vyberte platného používateľa / pokladníka,
Row #{}: Original Invoice {} of return invoice {} is {}. ,Riadok č. {}: Pôvodná faktúra {} spätnej faktúry {} je {}.,
Original invoice should be consolidated before or along with the return invoice.,Originál faktúry by mal byť konsolidovaný pred alebo spolu so spätnou faktúrou.,
You can add original invoice {} manually to proceed.,"Ak chcete pokračovať, môžete originálnu faktúru pridať {} ručne.",
Please ensure {} account is a Balance Sheet account. ,"Zaistite, aby účet {} bol súvahovým účtom.",
You can change the parent account to a Balance Sheet account or select a different account.,Môžete zmeniť nadradený účet na súvahový alebo zvoliť iný účet.,
Please ensure {} account is a Receivable account. ,"Zaistite, aby účet {} bol prijatým účtom.",
Change the account type to Receivable or select a different account.,Zmeňte typ účtu na Pohľadávka alebo vyberte iný účet.,
{} can't be cancelled since the Loyalty Points earned has been redeemed. First cancel the {} No {},"Službu {} nie je možné zrušiť, pretože boli využité získané vernostné body. Najskôr zrušte {} Nie {}",
already exists,už existuje,
POS Closing Entry {} against {} between selected period,Uzávierka vstupu POS {} oproti {} medzi vybraným obdobím,
POS Invoice is {},Faktúra POS je {},
POS Profile doesn't matches {},POS profil sa nezhoduje s {},
POS Invoice is not {},POS faktúra nie je {},
POS Invoice isn't created by user {},POS faktúra nie je vytvorená používateľom {},
Row #{}: {},Riadok č. {}: {},
Invalid POS Invoices,Neplatné faktúry POS,
Please add the account to root level Company - {},Pridajte účet do spoločnosti na koreňovej úrovni - {},
"While creating account for Child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA",Pri vytváraní účtu pre detskú spoločnosť {0} sa rodičovský účet {1} nenašiel. Vytvorte nadradený účet v zodpovedajúcom COA,
Account Not Found,Účet nebol nájdený,
"While creating account for Child Company {0}, parent account {1} found as a ledger account.",Pri vytváraní účtu pre detskú spoločnosť {0} sa rodičovský účet {1} našiel ako účet hlavnej knihy.,
Please convert the parent account in corresponding child company to a group account.,Konvertujte materský účet v príslušnej podradenej spoločnosti na skupinový účet.,
Invalid Parent Account,Neplatný nadradený účet,
"Renaming it is only allowed via parent company {0}, to avoid mismatch.","Premenovanie je povolené iba prostredníctvom materskej spoločnosti {0}, aby sa zabránilo nesúladu.",
"If you {0} {1} quantities of the item {2}, the scheme {3} will be applied on the item.","Ak {0} {1} množstvá položky {2}, použije sa na ňu schéma {3}.",
"If you {0} {1} worth item {2}, the scheme {3} will be applied on the item.","Ak {0} {1} máte hodnotu položky {2}, použije sa na ňu schéma {3}.",
"As the field {0} is enabled, the field {1} is mandatory.","Pretože je pole {0} povolené, je pole {1} povinné.",
"As the field {0} is enabled, the value of the field {1} should be more than 1.","Keď je pole {0} povolené, hodnota poľa {1} by mala byť viac ako 1.",
Cannot deliver Serial No {0} of item {1} as it is reserved to fullfill Sales Order {2},"Nie je možné doručiť sériové číslo {0} položky {1}, pretože je rezervovaná na vyplnenie zákazky odberateľa {2}.",
"Sales Order {0} has reservation for the item {1}, you can only deliver reserved {1} against {0}.","Zákazka odberateľa {0} má rezerváciu pre položku {1}, môžete doručiť iba rezervované {1} oproti {0}.",
{0} Serial No {1} cannot be delivered,{0} Sériové číslo {1} nie je možné doručiť,
Row {0}: Subcontracted Item is mandatory for the raw material {1},Riadok {0}: Subdodávateľská položka je pre surovinu povinná {1},
"As there are sufficient raw materials, Material Request is not required for Warehouse {0}.","Pretože je tu dostatok surovín, požiadavka na materiál sa v sklade {0} nevyžaduje.",
" If you still want to proceed, please enable {0}.","Ak stále chcete pokračovať, povoľte {0}.",
The item referenced by {0} - {1} is already invoiced,"Položka, na ktorú odkazuje {0} - {1}, je už fakturovaná",
Therapy Session overlaps with {0},Terapeutické sedenie sa prekrýva s {0},
Therapy Sessions Overlapping,Terapeutické sedenia sa prekrývajú,
Therapy Plans,Terapeutické plány,
"Item Code, warehouse, quantity are required on row {0}","V riadku {0} sa vyžaduje kód položky, sklad, množstvo",
Get Items from Material Requests against this Supplier,Získajte položky z materiálových požiadaviek voči tomuto dodávateľovi,
Enable European Access,Umožniť európsky prístup,
Creating Purchase Order ...,Vytvára sa objednávka ...,
"Select a Supplier from the Default Suppliers of the items below. On selection, a Purchase Order will be made against items belonging to the selected Supplier only.",Z predvolených dodávateľov nižšie uvedených položiek vyberte dodávateľa. Pri výbere sa uskutoční objednávka iba na položky patriace vybranému dodávateľovi.,
Row #{}: You must select {} serial numbers for item {}.,Riadok č. {}: Musíte zvoliť {} sériové čísla pre položku {}.,
Add Comment,Pridať komentár,
More...,Viac ...,
Notes,Poznámky,
Payment Gateway,Platobná brána,
Payment Gateway Name,Názov platobnej brány,
Payments,Platby,
Plan Name,Názov plánu,
Portal,Portál,
Scan Barcode,Naskenujte čiarový kód,
Some information is missing,Niektoré informácie chýbajú,
Successful,Úspešný,
Tools,Nástroje,
Use Sandbox,použitie Sandbox,
Busy,Zaneprázdnený,
Completed By,Dokončené kým,
Payment Failed,platba zlyhala,
Column {0},Stĺpec {0},
Field Mapping,Polné mapovanie,
Not Specified,Nešpecifikované,
Update Type,Typ aktualizácie,
Dr,Dr,
End Time,End Time,
Fetching...,Načítanie ...,
"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á sa, že existuje problém s konfiguráciou pásma servera. V prípade zlyhania bude suma vrátená na váš účet.",
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,"Vyzerá to, že vás niekto poslal k neúplnému URL. Požiadajte ho, aby sa na to pozrel.",
Master,Hlavné,
Pay,Platiť,
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,
Verified By,Verified By,
Invalid naming series (. missing) for {0},Neplatný rad pomenovaní (. Chýba) pre {0},
Phone Number,Telefónne číslo,
Account SID,SID účtu,
Global Defaults,Globální Výchozí,
Is Mandatory,Je povinné,
WhatsApp,WhatsApp,
Make a call,Zavolať,
Approve,schvaľovať,
Reject,Odmietnuť,
