@evolu/common 8.2.0 → 8.3.1

package/dist/src/intl/ro.js

@@ -0,0 +1,258 @@
+/**
+ * Formatatoare românești pentru erorile Evolu Type.
+ *
+ * @module
+ */
+import { assertNonNullable } from "../Assert.js";
+import { safelyStringifyUnknownValue } from "../String.js";
+const formatTypeOfError = (error) => {
+    const typeOf = error.expected.toLowerCase();
+    return `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este de tipul ${typeOf}.`;
+};
+const formatPlainObjectRootError = (reason) => reason.kind === "NotObject"
+    ? `Valoarea ${safelyStringifyUnknownValue(reason.value)} nu este un obiect.`
+    : "Valoarea este un obiect, dar un Output Object trebuie să fie un obiect simplu sau să aibă un prototip null.";
+/** Formatează un NeverError în română. */
+export const formatNeverError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este validă pentru tipul Never.`;
+/** Formatează un String TypeOfError în română. */
+export const formatStringError = formatTypeOfError;
+/** Formatează un TemplateLiteralError în română. */
+export const formatTemplateLiteralError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu corespunde șablonului literal.`;
+/** Formatează un Number TypeOfError în română. */
+export const formatNumberError = formatTypeOfError;
+/** Formatează un BigInt TypeOfError în română. */
+export const formatBigIntError = formatTypeOfError;
+/** Formatează un Boolean TypeOfError în română. */
+export const formatBooleanError = formatTypeOfError;
+/** Formatează un Symbol TypeOfError în română. */
+export const formatSymbolError = formatTypeOfError;
+/** Formatează un Function TypeOfError în română. */
+export const formatFunctionError = formatTypeOfError;
+/** Formatează un EvoluTypeError în română. */
+export const formatEvoluTypeError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este un Evolu Type.`;
+/** Formatează un ObjectTagError în română. */
+export const formatObjectTagError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu are eticheta de obiect așteptată ${safelyStringifyUnknownValue(error.expected)}.`;
+/** Formatează un InstanceOfError în română. */
+export const formatInstanceOfError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este o instanță a ${error.constructorName}.`;
+/** Formatează un LiteralError în română. */
+export const formatLiteralError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este strict egală cu literalul așteptat: ${globalThis.String(error.expected)}.`;
+/** Formatează un UnionError în română. */
+export const formatUnionError = () => "O valoare nu corespunde niciunei variante permise.";
+/** Formatează un DateIsoError în română. */
+export const formatDateIsoError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este un șir canonic de dată și oră ISO.`;
+/** Formatează un DateIsoFromDateError în română. */
+export const formatDateIsoFromDateError = () => "Date nu poate fi reprezentat ca DateIso.";
+/** Formatează un DecimalStringError în română. */
+export const formatDecimalStringError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie un șir zecimal canonic.`;
+/** Formatează un Int64Error în română. */
+export const formatInt64Error = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este un număr întreg cu semn valid pe 64 de biți (Int64).`;
+/** Formatează un UInt64Error în română. */
+export const formatUInt64Error = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este un număr întreg fără semn valid pe 64 de biți (UInt64).`;
+/** Formatează un Int64StringError în română. */
+export const formatInt64StringError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este un șir Int64 valid.`;
+/** Formatează un CapitalizedError în română. */
+export const formatCapitalizedError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să înceapă cu literă mare.`;
+/** Formatează un TrimmedError în română. */
+export const formatTrimmedError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie fără spații la început sau la sfârșit.`;
+/** Formatează un MinLengthError în română. */
+export const formatMinLengthError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu îndeplinește lungimea minimă de ${error.min}.`;
+/** Formatează un MaxLengthError în română. */
+export const formatMaxLengthError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} depășește lungimea maximă de ${error.max}.`;
+/** Formatează un LengthError în română. */
+export const formatLengthError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu are lungimea necesară de ${error.exact}.`;
+/** Formatează un RegexError în română. */
+export const formatRegexError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu corespunde cu /${error.source}/${error.flags}.`;
+/** Formatează un Base64UrlError în română. */
+export const formatBase64UrlError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este un șir Base64Url valid.`;
+/** Formatează un NameError în română. */
+export const formatNameError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este un Name valid.`;
+/** Formatează un MnemonicError în română. */
+export const formatMnemonicError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este o frază mnemonică BIP39 în engleză validă.`;
+/** Formatează un IdError în română. */
+export const formatIdError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este un Id valid.`;
+/** Formatează un TableIdError în română. */
+export const formatTableIdError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu este un Id valid pentru tabelul ${error.table}.`;
+/** Formatează un NonNegativeError în română. */
+export const formatNonNegativeError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie nenegativă (>= 0).`;
+/** Formatează un NonNegativeDecimalStringError în română. */
+export const formatNonNegativeDecimalStringError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie un șir zecimal nenegativ.`;
+/** Formatează un PositiveError în română. */
+export const formatPositiveError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie pozitivă (> 0).`;
+/** Formatează un PositiveDecimalStringError în română. */
+export const formatPositiveDecimalStringError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie un șir zecimal pozitiv.`;
+/** Formatează un NonPositiveError în română. */
+export const formatNonPositiveError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie nepozitivă (<= 0).`;
+/** Formatează un NonPositiveDecimalStringError în română. */
+export const formatNonPositiveDecimalStringError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie un șir zecimal nepozitiv.`;
+/** Formatează un NegativeError în română. */
+export const formatNegativeError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie negativă (< 0).`;
+/** Formatează un NegativeDecimalStringError în română. */
+export const formatNegativeDecimalStringError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie un șir zecimal negativ.`;
+/** Formatează un IntError în română. */
+export const formatIntError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie un număr întreg sigur.`;
+/** Formatează un GreaterThanError în română. */
+export const formatGreaterThanError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie mai mare decât ${error.min}.`;
+/** Formatează un GreaterThanOrEqualToError în română. */
+export const formatGreaterThanOrEqualToError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie mai mare sau egală cu ${error.min}.`;
+/** Formatează un LessThanError în română. */
+export const formatLessThanError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie mai mică decât ${error.max}.`;
+/** Formatează un LessThanOrEqualToError în română. */
+export const formatLessThanOrEqualToError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie mai mică sau egală cu ${error.max}.`;
+/** Formatează un NonNaNError în română. */
+export const formatNonNaNError = () => "Valoarea nu trebuie să fie NaN.";
+/** Formatează un FiniteError în română. */
+export const formatFiniteError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie finită.`;
+/** Formatează un MultipleOfError în română. */
+export const formatMultipleOfError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie un multiplu de ${error.divisor}.`;
+/** Formatează un BetweenError în română. */
+export const formatBetweenError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} trebuie să fie între ${error.min} și ${error.max}, inclusiv.`;
+/** Formatează un ArrayError în română. */
+export const formatArrayError = (error) => {
+    if (error.reason.kind === "NotArray") {
+        return `Valoarea ${safelyStringifyUnknownValue(error.reason.value)} nu este un tablou.`;
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `Lipsește un element al tabloului la indexul ${issue.index}.`;
+        case "Accessor":
+            return `Elementul tabloului de la indexul ${issue.index} trebuie să fie o proprietate de date.`;
+        case "ExcessProperty":
+            return "O proprietate Array în exces nu este permisă. Eliminați-o sau utilizați un Type diferit.";
+        case "Element":
+            return `Elementul tabloului de la indexul ${issue.index} nu este valid.`;
+    }
+};
+/** Formatează un SetError în română. */
+export const formatSetError = (error) => {
+    if (error.reason.kind === "NotSet") {
+        return `Valoarea ${safelyStringifyUnknownValue(error.reason.value)} nu este un Set.`;
+    }
+    if (error.reason.kind === "UnexpectedPrototype") {
+        return "Valoarea este o instanță a unei subclase Set, dar un Output Set trebuie să fie o instanță Set directă.";
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "ExcessProperty":
+            return `O proprietate Set în exces ${safelyStringifyUnknownValue(issue.key)} nu este permisă.`;
+        case "Element":
+            return `Elementul Set de la indexul ${issue.index} nu este valid.`;
+    }
+};
+/** Formatează un TupleError în română. */
+export const formatTupleError = (error) => {
+    if (error.reason.kind === "NotArray") {
+        return `Valoarea ${safelyStringifyUnknownValue(error.reason.value)} nu este un tuplu.`;
+    }
+    if (error.reason.kind === "InvalidLength") {
+        return `Un Tuple trebuie să conțină exact ${error.reason.expected} elemente, dar valoarea conține ${error.reason.actual}.`;
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `Lipsește un element Tuple la indexul ${issue.index}.`;
+        case "Accessor":
+            return `Elementul Tuple de la indexul ${issue.index} trebuie să fie o proprietate de date.`;
+        case "ExcessProperty":
+            return "O proprietate Tuple în exces nu este permisă. Eliminați-o sau utilizați un Type diferit.";
+        case "Element":
+            return `Elementul Tuple de la indexul ${issue.index} nu este valid.`;
+    }
+};
+/** Formatează un RecordError în română. */
+export const formatRecordError = (error) => {
+    if (error.reason.kind === "NotRecord") {
+        return `Valoarea ${safelyStringifyUnknownValue(error.reason.value)} nu este un Record.`;
+    }
+    if (error.reason.kind === "NotPlainRecord") {
+        return "Valoarea este un obiect, dar un Output Record trebuie să fie un obiect simplu sau să aibă un prototip null.";
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Key":
+            return `Cheia proprietății ${safelyStringifyUnknownValue(issue.key)} nu este validă.`;
+        case "Value":
+            return `Valoarea proprietății ${safelyStringifyUnknownValue(issue.key)} nu este validă.`;
+        case "Accessor":
+            return `Proprietatea Record ${safelyStringifyUnknownValue(issue.key)} trebuie să fie o proprietate de date.`;
+        case "NonEnumerable":
+            return `Proprietatea Record ${safelyStringifyUnknownValue(issue.key)} trebuie să fie enumerabilă.`;
+        case "Collision":
+            return `Cheile Record ${safelyStringifyUnknownValue(issue.previousKey)} și ${safelyStringifyUnknownValue(issue.key)} se decodează la aceeași cheie ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+    }
+};
+/** Formatează un ObjectError în română. */
+export const formatObjectError = (error) => {
+    if (error.reason.kind !== "Properties") {
+        return formatPlainObjectRootError(error.reason);
+    }
+    const key = Reflect.ownKeys(error.reason.errors).at(0);
+    assertNonNullable(key);
+    const propertyError = error.reason.errors[key];
+    assertNonNullable(propertyError);
+    if (propertyError.type === "ObjectPropertyAccess") {
+        switch (propertyError.reason) {
+            case "Accessor":
+                return "O proprietate Object trebuie să fie o proprietate de date. Materializați valorile accesorilor în date simple înainte de a utiliza acest Type sau utilizați un Type diferit.";
+            case "NonEnumerable":
+                return "O proprietate Object trebuie să fie enumerabilă. Faceți-o enumerabilă sau utilizați un Type diferit.";
+        }
+    }
+    if (propertyError.type === "ObjectMissingProperty") {
+        return `Lipsește proprietatea obligatorie ${safelyStringifyUnknownValue(key)}.`;
+    }
+    if (typeof key === "symbol") {
+        return "Cheia unei proprietăți Object trebuie să fie un șir. Eliminați proprietatea simbol sau utilizați un Type diferit.";
+    }
+    if (propertyError.type === "ObjectExcessProperty") {
+        return `Proprietatea ${safelyStringifyUnknownValue(key)} nu este permisă. Eliminați-o sau utilizați un Type diferit.`;
+    }
+    return `Proprietatea ${safelyStringifyUnknownValue(key)} nu este validă.`;
+};
+/** Formatează un DiscriminatedUnionError în română. */
+export const formatDiscriminatedUnionError = (error) => {
+    switch (error.reason.kind) {
+        case "Object":
+            return formatPlainObjectRootError(error.reason.error.reason);
+        case "PropertyAccess": {
+            const property = `Proprietatea discriminator ${safelyStringifyUnknownValue(error.reason.key)}`;
+            if (error.reason.reason === "Accessor") {
+                return `${property} trebuie să fie o proprietate de date.`;
+            }
+            if (error.reason.reason === "Inherited") {
+                return `${property} trebuie să fie o proprietate proprie.`;
+            }
+            return `${property} trebuie să fie enumerabilă.`;
+        }
+        case "Discriminator":
+            return `Proprietatea discriminator ${safelyStringifyUnknownValue(error.reason.key)} are valoarea neașteptată ${safelyStringifyUnknownValue(error.reason.value)}.`;
+        case "Member":
+            return `Varianta selectată ${safelyStringifyUnknownValue(error.reason.discriminator)} nu este validă.`;
+    }
+};
+/** Formatează un JsonValueError în română. */
+export const formatJsonValueError = (error) => {
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "InvalidType":
+            return `Valoarea ${safelyStringifyUnknownValue(issue.value)} nu este o valoare JSON.`;
+        case "NonFiniteNumber":
+            return "Un număr JSON trebuie să fie finit.";
+        case "UnexpectedPrototype":
+            return "Valoarea este un obiect, dar un obiect JsonValue trebuie să fie un obiect simplu sau să aibă un prototip null.";
+        case "Accessor":
+            return "O proprietate JSON trebuie să fie o proprietate de date. Materializați valorile accesorilor în date simple înainte de a utiliza acest Type sau utilizați un Type diferit.";
+        case "NonEnumerable":
+            return "O proprietate a unui obiect JSON trebuie să fie enumerabilă. Eliminați-o sau utilizați un Type diferit.";
+        case "SymbolProperty":
+            return "Cheia unei proprietăți a unui obiect JSON trebuie să fie un șir. Eliminați proprietatea simbol sau utilizați un Type diferit.";
+        case "Hole":
+            return "Lipsește un element al unui tablou JSON.";
+        case "ExcessProperty":
+            return "O proprietate a unui tablou JSON în exces nu este permisă. Eliminați-o sau utilizați un Type diferit.";
+        case "CircularReference":
+            return "Un JsonValue nu trebuie să conțină referințe circulare.";
+    }
+};
+/** Formatează un JsonError în română. */
+export const formatJsonError = (error) => `Valoarea ${safelyStringifyUnknownValue(error.value)} nu poate fi analizată ca JsonValue.`;

package/dist/src/intl/sk.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Slovak Evolu Type error formatters.
+ *
+ * @module
+ */
+import type { ArrayError, Base64UrlError, BetweenError, CapitalizedError, DateIsoError, DateIsoFromDateError, DecimalStringError, DiscriminatedUnionError, EvoluTypeError, FiniteError, GreaterThanError, GreaterThanOrEqualToError, InstanceOfError, Int64Error, Int64StringError, IntError, IdError, JsonError, JsonValueError, LengthError, LessThanError, LessThanOrEqualToError, LiteralError, MaxLengthError, MinLengthError, MnemonicError, MultipleOfError, NegativeDecimalStringError, NegativeError, NameError, NeverError, NonNaNError, NonNegativeDecimalStringError, NonNegativeError, NonPositiveDecimalStringError, NonPositiveError, ObjectError, ObjectTagError, PositiveDecimalStringError, PositiveError, RecordError, RegexError, SetError, TableIdError, TemplateLiteralError, TrimmedError, TupleElementsError, TupleError, TypeError, TypeErrorFormatter, TypeOfError, UInt64Error, UnionError } from "../Type.ts";
+/** Formats a NeverError in Slovak. */
+export declare const formatNeverError: TypeErrorFormatter<NeverError>;
+/** Formats a String TypeOfError in Slovak. */
+export declare const formatStringError: TypeErrorFormatter<TypeOfError<"String">>;
+/** Formats a TemplateLiteralError in Slovak. */
+export declare const formatTemplateLiteralError: TypeErrorFormatter<TemplateLiteralError>;
+/** Formats a Number TypeOfError in Slovak. */
+export declare const formatNumberError: TypeErrorFormatter<TypeOfError<"Number">>;
+/** Formats a BigInt TypeOfError in Slovak. */
+export declare const formatBigIntError: TypeErrorFormatter<TypeOfError<"BigInt">>;
+/** Formats a Boolean TypeOfError in Slovak. */
+export declare const formatBooleanError: TypeErrorFormatter<TypeOfError<"Boolean">>;
+/** Formats a Symbol TypeOfError in Slovak. */
+export declare const formatSymbolError: TypeErrorFormatter<TypeOfError<"Symbol">>;
+/** Formats a Function TypeOfError in Slovak. */
+export declare const formatFunctionError: TypeErrorFormatter<TypeOfError<"Function">>;
+/** Formats an EvoluTypeError in Slovak. */
+export declare const formatEvoluTypeError: TypeErrorFormatter<EvoluTypeError>;
+/** Formats an ObjectTagError in Slovak. */
+export declare const formatObjectTagError: TypeErrorFormatter<ObjectTagError>;
+/** Formats an InstanceOfError in Slovak. */
+export declare const formatInstanceOfError: TypeErrorFormatter<InstanceOfError>;
+/** Formats a LiteralError in Slovak. */
+export declare const formatLiteralError: TypeErrorFormatter<LiteralError>;
+/** Formats a UnionError in Slovak. */
+export declare const formatUnionError: TypeErrorFormatter<UnionError>;
+/** Formats a DateIsoError in Slovak. */
+export declare const formatDateIsoError: TypeErrorFormatter<DateIsoError>;
+/** Formats a DateIsoFromDateError in Slovak. */
+export declare const formatDateIsoFromDateError: TypeErrorFormatter<DateIsoFromDateError>;
+/** Formats a DecimalStringError in Slovak. */
+export declare const formatDecimalStringError: TypeErrorFormatter<DecimalStringError>;
+/** Formats an Int64Error in Slovak. */
+export declare const formatInt64Error: TypeErrorFormatter<Int64Error>;
+/** Formats a UInt64Error in Slovak. */
+export declare const formatUInt64Error: TypeErrorFormatter<UInt64Error>;
+/** Formats an Int64StringError in Slovak. */
+export declare const formatInt64StringError: TypeErrorFormatter<Int64StringError>;
+/** Formats a CapitalizedError in Slovak. */
+export declare const formatCapitalizedError: TypeErrorFormatter<CapitalizedError>;
+/** Formats a TrimmedError in Slovak. */
+export declare const formatTrimmedError: TypeErrorFormatter<TrimmedError>;
+/** Formats a MinLengthError in Slovak. */
+export declare const formatMinLengthError: TypeErrorFormatter<MinLengthError>;
+/** Formats a MaxLengthError in Slovak. */
+export declare const formatMaxLengthError: TypeErrorFormatter<MaxLengthError>;
+/** Formats a LengthError in Slovak. */
+export declare const formatLengthError: TypeErrorFormatter<LengthError>;
+/** Formats a RegexError in Slovak. */
+export declare const formatRegexError: TypeErrorFormatter<RegexError>;
+/** Formats a Base64UrlError in Slovak. */
+export declare const formatBase64UrlError: TypeErrorFormatter<Base64UrlError>;
+/** Formats a NameError in Slovak. */
+export declare const formatNameError: TypeErrorFormatter<NameError>;
+/** Formats a MnemonicError in Slovak. */
+export declare const formatMnemonicError: TypeErrorFormatter<MnemonicError>;
+/** Formats an IdError in Slovak. */
+export declare const formatIdError: TypeErrorFormatter<IdError>;
+/** Formats a TableIdError in Slovak. */
+export declare const formatTableIdError: TypeErrorFormatter<TableIdError>;
+/** Formats a NonNegativeError in Slovak. */
+export declare const formatNonNegativeError: TypeErrorFormatter<NonNegativeError>;
+/** Formats a NonNegativeDecimalStringError in Slovak. */
+export declare const formatNonNegativeDecimalStringError: TypeErrorFormatter<NonNegativeDecimalStringError>;
+/** Formats a PositiveError in Slovak. */
+export declare const formatPositiveError: TypeErrorFormatter<PositiveError>;
+/** Formats a PositiveDecimalStringError in Slovak. */
+export declare const formatPositiveDecimalStringError: TypeErrorFormatter<PositiveDecimalStringError>;
+/** Formats a NonPositiveError in Slovak. */
+export declare const formatNonPositiveError: TypeErrorFormatter<NonPositiveError>;
+/** Formats a NonPositiveDecimalStringError in Slovak. */
+export declare const formatNonPositiveDecimalStringError: TypeErrorFormatter<NonPositiveDecimalStringError>;
+/** Formats a NegativeError in Slovak. */
+export declare const formatNegativeError: TypeErrorFormatter<NegativeError>;
+/** Formats a NegativeDecimalStringError in Slovak. */
+export declare const formatNegativeDecimalStringError: TypeErrorFormatter<NegativeDecimalStringError>;
+/** Formats an IntError in Slovak. */
+export declare const formatIntError: TypeErrorFormatter<IntError>;
+/** Formats a GreaterThanError in Slovak. */
+export declare const formatGreaterThanError: TypeErrorFormatter<GreaterThanError>;
+/** Formats a GreaterThanOrEqualToError in Slovak. */
+export declare const formatGreaterThanOrEqualToError: TypeErrorFormatter<GreaterThanOrEqualToError>;
+/** Formats a LessThanError in Slovak. */
+export declare const formatLessThanError: TypeErrorFormatter<LessThanError>;
+/** Formats a LessThanOrEqualToError in Slovak. */
+export declare const formatLessThanOrEqualToError: TypeErrorFormatter<LessThanOrEqualToError>;
+/** Formats a NonNaNError in Slovak. */
+export declare const formatNonNaNError: TypeErrorFormatter<NonNaNError>;
+/** Formats a FiniteError in Slovak. */
+export declare const formatFiniteError: TypeErrorFormatter<FiniteError>;
+/** Formats a MultipleOfError in Slovak. */
+export declare const formatMultipleOfError: TypeErrorFormatter<MultipleOfError>;
+/** Formats a BetweenError in Slovak. */
+export declare const formatBetweenError: TypeErrorFormatter<BetweenError>;
+/** Formats an ArrayError in Slovak. */
+export declare const formatArrayError: TypeErrorFormatter<ArrayError>;
+/** Formats a SetError in Slovak. */
+export declare const formatSetError: TypeErrorFormatter<SetError>;
+/** Formats a TupleError in Slovak. */
+export declare const formatTupleError: TypeErrorFormatter<TupleError | TupleElementsError<TypeError>>;
+/** Formats a RecordError in Slovak. */
+export declare const formatRecordError: TypeErrorFormatter<RecordError>;
+/** Formats an ObjectError in Slovak. */
+export declare const formatObjectError: TypeErrorFormatter<ObjectError>;
+/** Formats a DiscriminatedUnionError in Slovak. */
+export declare const formatDiscriminatedUnionError: TypeErrorFormatter<DiscriminatedUnionError>;
+/** Formats a JsonValueError in Slovak. */
+export declare const formatJsonValueError: TypeErrorFormatter<JsonValueError>;
+/** Formats a JsonError in Slovak. */
+export declare const formatJsonError: TypeErrorFormatter<JsonError>;
+//# sourceMappingURL=sk.d.ts.map

package/dist/src/intl/sk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sk.d.ts","sourceRoot":"","sources":["../../../src/intl/sk.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,UAAU,EACV,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EACvB,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,yBAAyB,EACzB,eAAe,EACf,UAAU,EACV,gBAAgB,EAChB,QAAQ,EACR,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,aAAa,EACb,sBAAsB,EACtB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,aAAa,EACb,eAAe,EACf,0BAA0B,EAC1B,aAAa,EACb,SAAS,EACT,UAAU,EACV,WAAW,EACX,6BAA6B,EAC7B,gBAAgB,EAChB,6BAA6B,EAC7B,gBAAgB,EAChB,WAAW,EAGX,cAAc,EAEd,0BAA0B,EAC1B,aAAa,EACb,WAAW,EACX,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,oBAAoB,EACpB,YAAY,EACZ,kBAAkB,EAClB,UAAU,EACV,SAAS,EACT,kBAAkB,EAClB,WAAW,EACX,WAAW,EACX,UAAU,EACX,MAAM,YAAY,CAAC;AAapB,sCAAsC;AACtC,eAAO,MAAM,gBAAgB,EAAE,kBAAkB,CAAC,UAAU,CACwB,CAAC;AACrF,8CAA8C;AAC9C,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAE1B,CAAC;AAC/C,gDAAgD;AAChD,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CACzD,oBAAoB,CAEmE,CAAC;AAC1F,8CAA8C;AAC9C,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAE5B,CAAC;AAC7C,8CAA8C;AAC9C,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAEX,CAAC;AAC9D,+CAA+C;AAC/C,eAAO,MAAM,kBAAkB,EAAE,kBAAkB,CAAC,WAAW,CAAC,SAAS,CAAC,CAEpB,CAAC;AACvD,8CAA8C;AAC9C,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAE3B,CAAC;AAC9C,gDAAgD;AAChD,eAAO,MAAM,mBAAmB,EAAE,kBAAkB,CAClD,WAAW,CAAC,UAAU,CAAC,CAC+B,CAAC;AACzD,2CAA2C;AAC3C,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,cAAc,CAEW,CAAC;AAChF,2CAA2C;AAC3C,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,cAAc,CAGiE,CAAC;AACtI,4CAA4C;AAC5C,eAAO,MAAM,qBAAqB,EAAE,kBAAkB,CAAC,eAAe,CAG+B,CAAC;AACtG,wCAAwC;AACxC,eAAO,MAAM,kBAAkB,EAAE,kBAAkB,CAAC,YAAY,CACwE,CAAC;AACzI,sCAAsC;AACtC,eAAO,MAAM,gBAAgB,EAAE,kBAAkB,CAAC,UAAU,CACJ,CAAC;AACzD,wCAAwC;AACxC,eAAO,MAAM,kBAAkB,EAAE,kBAAkB,CAAC,YAAY,CACgD,CAAC;AACjH,gDAAgD;AAChD,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CACzD,oBAAoB,CACmC,CAAC;AAC1D,8CAA8C;AAC9C,eAAO,MAAM,wBAAwB,EAAE,kBAAkB,CACvD,kBAAkB,CAEyE,CAAC;AAC9F,uCAAuC;AACvC,eAAO,MAAM,gBAAgB,EAAE,kBAAkB,CAAC,UAAU,CACuD,CAAC;AACpH,uCAAuC;AACvC,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CACsD,CAAC;AACrH,6CAA6C;AAC7C,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,gBAAgB,CAGc,CAAC;AACvF,4CAA4C;AAC5C,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,gBAAgB,CAGa,CAAC;AACtF,wCAAwC;AACxC,eAAO,MAAM,kBAAkB,EAAE,kBAAkB,CAAC,YAAY,CAC0C,CAAC;AAC3G,0CAA0C;AAC1C,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,cAAc,CAK0B,CAAC;AAC/F,0CAA0C;AAC1C,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,cAAc,CAGwB,CAAC;AAC7F,uCAAuC;AACvC,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CAC+B,CAAC;AAC9F,sCAAsC;AACtC,eAAO,MAAM,gBAAgB,EAAE,kBAAkB,CAAC,UAAU,CAC2D,CAAC;AACxH,0CAA0C;AAC1C,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,cAAc,CAGoB,CAAC;AACzF,qCAAqC;AACrC,eAAO,MAAM,eAAe,EAAE,kBAAkB,CAAC,SAAS,CACkB,CAAC;AAC7E,yCAAyC;AACzC,eAAO,MAAM,mBAAmB,EAAE,kBAAkB,CAAC,aAAa,CACwC,CAAC;AAC3G,oCAAoC;AACpC,eAAO,MAAM,aAAa,EAAE,kBAAkB,CAAC,OAAO,CACmB,CAAC;AAC1E,wCAAwC;AACxC,eAAO,MAAM,kBAAkB,EAAE,kBAAkB,CAAC,YAAY,CACiE,CAAC;AAClI,4CAA4C;AAC5C,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,gBAAgB,CAGU,CAAC;AACnF,yDAAyD;AACzD,eAAO,MAAM,mCAAmC,EAAE,kBAAkB,CAClE,6BAA6B,CAE8D,CAAC;AAC9F,yCAAyC;AACzC,eAAO,MAAM,mBAAmB,EAAE,kBAAkB,CAAC,aAAa,CACY,CAAC;AAC/E,sDAAsD;AACtD,eAAO,MAAM,gCAAgC,EAAE,kBAAkB,CAC/D,0BAA0B,CAE8D,CAAC;AAC3F,4CAA4C;AAC5C,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,gBAAgB,CAGS,CAAC;AAClF,yDAAyD;AACzD,eAAO,MAAM,mCAAmC,EAAE,kBAAkB,CAClE,6BAA6B,CAE6D,CAAC;AAC7F,yCAAyC;AACzC,eAAO,MAAM,mBAAmB,EAAE,kBAAkB,CAAC,aAAa,CACa,CAAC;AAChF,sDAAsD;AACtD,eAAO,MAAM,gCAAgC,EAAE,kBAAkB,CAC/D,0BAA0B,CAE+D,CAAC;AAC5F,qCAAqC;AACrC,eAAO,MAAM,cAAc,EAAE,kBAAkB,CAAC,QAAQ,CAC6B,CAAC;AACtF,4CAA4C;AAC5C,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,gBAAgB,CAGiB,CAAC;AAC1F,qDAAqD;AACrD,eAAO,MAAM,+BAA+B,EAAE,kBAAkB,CAC9D,yBAAyB,CAEsE,CAAC;AAClG,yCAAyC;AACzC,eAAO,MAAM,mBAAmB,EAAE,kBAAkB,CAAC,aAAa,CACuB,CAAC;AAC1F,kDAAkD;AAClD,eAAO,MAAM,4BAA4B,EAAE,kBAAkB,CAC3D,sBAAsB,CAEyE,CAAC;AAClG,uCAAuC;AACvC,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CACnC,CAAC;AAC5B,uCAAuC;AACvC,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CACW,CAAC;AAC1E,2CAA2C;AAC3C,eAAO,MAAM,qBAAqB,EAAE,kBAAkB,CAAC,eAAe,CAG2B,CAAC;AAClG,wCAAwC;AACxC,eAAO,MAAM,kBAAkB,EAAE,kBAAkB,CAAC,YAAY,CACmD,CAAC;AAEpH,uCAAuC;AACvC,eAAO,MAAM,gBAAgB,EAAE,kBAAkB,CAAC,UAAU,CAc3D,CAAC;AACF,oCAAoC;AACpC,eAAO,MAAM,cAAc,EAAE,kBAAkB,CAAC,QAAQ,CAYvD,CAAC;AACF,sCAAsC;AACtC,eAAO,MAAM,gBAAgB,EAAE,kBAAkB,CAC/C,UAAU,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAiB3C,CAAC;AACF,uCAAuC;AACvC,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CAkB7D,CAAC;AACF,wCAAwC;AACxC,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,WAAW,CAsB7D,CAAC;AACF,mDAAmD;AACnD,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAC5D,uBAAuB,CAkBxB,CAAC;AACF,0CAA0C;AAC1C,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,cAAc,CAwBnE,CAAC;AACF,qCAAqC;AACrC,eAAO,MAAM,eAAe,EAAE,kBAAkB,CAAC,SAAS,CAC+B,CAAC"}

package/dist/src/intl/sk.js

@@ -0,0 +1,244 @@
+/**
+ * Slovak Evolu Type error formatters.
+ *
+ * @module
+ */
+import { assertNonNullable } from "../Assert.js";
+import { safelyStringifyUnknownValue } from "../String.js";
+const formatValueMustBe = (value, expected) => `Hodnota ${safelyStringifyUnknownValue(value)} musí byť ${expected}.`;
+const formatPlainObjectRootError = (reason) => reason.kind === "NotObject"
+    ? `Hodnota ${safelyStringifyUnknownValue(reason.value)} nie je objekt.`
+    : "Hodnota je objekt, ale výstup typu Object musí byť obyčajný objekt alebo mať prototyp null.";
+/** Formats a NeverError in Slovak. */
+export const formatNeverError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nie je platná pre typ Never.`;
+/** Formats a String TypeOfError in Slovak. */
+export const formatStringError = (error) => formatValueMustBe(error.value, "reťazec");
+/** Formats a TemplateLiteralError in Slovak. */
+export const formatTemplateLiteralError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nezodpovedá šablónovému literálu.`;
+/** Formats a Number TypeOfError in Slovak. */
+export const formatNumberError = (error) => formatValueMustBe(error.value, "číslo");
+/** Formats a BigInt TypeOfError in Slovak. */
+export const formatBigIntError = (error) => formatValueMustBe(error.value, "celé číslo typu bigint");
+/** Formats a Boolean TypeOfError in Slovak. */
+export const formatBooleanError = (error) => formatValueMustBe(error.value, "logická hodnota");
+/** Formats a Symbol TypeOfError in Slovak. */
+export const formatSymbolError = (error) => formatValueMustBe(error.value, "symbol");
+/** Formats a Function TypeOfError in Slovak. */
+export const formatFunctionError = (error) => formatValueMustBe(error.value, "funkcia");
+/** Formats an EvoluTypeError in Slovak. */
+export const formatEvoluTypeError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť Evolu Type.`;
+/** Formats an ObjectTagError in Slovak. */
+export const formatObjectTagError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nemá očakávanú značku objektu ${safelyStringifyUnknownValue(error.expected)}.`;
+/** Formats an InstanceOfError in Slovak. */
+export const formatInstanceOfError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť inštanciou ${error.constructorName}.`;
+/** Formats a LiteralError in Slovak. */
+export const formatLiteralError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} sa musí presne rovnať očakávanému literálu ${globalThis.String(error.expected)}.`;
+/** Formats a UnionError in Slovak. */
+export const formatUnionError = () => "Hodnota nezodpovedá žiadnemu z povolených variantov.";
+/** Formats a DateIsoError in Slovak. */
+export const formatDateIsoError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť reťazec dátumu a času v kanonickom formáte ISO.`;
+/** Formats a DateIsoFromDateError in Slovak. */
+export const formatDateIsoFromDateError = () => "Dátum nie je možné reprezentovať ako DateIso.";
+/** Formats a DecimalStringError in Slovak. */
+export const formatDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť kanonický desatinný reťazec.`;
+/** Formats an Int64Error in Slovak. */
+export const formatInt64Error = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť platné 64-bitové celé číslo so znamienkom (Int64).`;
+/** Formats a UInt64Error in Slovak. */
+export const formatUInt64Error = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť platné 64-bitové celé číslo bez znamienka (UInt64).`;
+/** Formats an Int64StringError in Slovak. */
+export const formatInt64StringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť platný reťazec Int64.`;
+/** Formats a CapitalizedError in Slovak. */
+export const formatCapitalizedError = (error) => `Reťazec ${safelyStringifyUnknownValue(error.value)} musí začínať veľkým písmenom.`;
+/** Formats a TrimmedError in Slovak. */
+export const formatTrimmedError = (error) => `Reťazec ${safelyStringifyUnknownValue(error.value)} nesmie obsahovať medzery na začiatku ani na konci.`;
+/** Formats a MinLengthError in Slovak. */
+export const formatMinLengthError = (error) => typeof error.value === "string" && error.min === 1
+    ? "Reťazec nesmie byť prázdny."
+    : `Hodnota ${safelyStringifyUnknownValue(error.value)} musí mať dĺžku aspoň ${error.min}.`;
+/** Formats a MaxLengthError in Slovak. */
+export const formatMaxLengthError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} môže mať dĺžku najviac ${error.max}.`;
+/** Formats a LengthError in Slovak. */
+export const formatLengthError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí mať presne dĺžku ${error.exact}.`;
+/** Formats a RegexError in Slovak. */
+export const formatRegexError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nezodpovedá regulárnemu výrazu /${error.source}/${error.flags}.`;
+/** Formats a Base64UrlError in Slovak. */
+export const formatBase64UrlError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nie je platný reťazec Base64Url.`;
+/** Formats a NameError in Slovak. */
+export const formatNameError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nie je platný názov.`;
+/** Formats a MnemonicError in Slovak. */
+export const formatMnemonicError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nie je platná anglická mnemotechnická fráza BIP39.`;
+/** Formats an IdError in Slovak. */
+export const formatIdError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nie je platné Id.`;
+/** Formats a TableIdError in Slovak. */
+export const formatTableIdError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nie je platné Id pre tabuľku ${safelyStringifyUnknownValue(error.table)}.`;
+/** Formats a NonNegativeError in Slovak. */
+export const formatNonNegativeError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť nezáporná (>= 0).`;
+/** Formats a NonNegativeDecimalStringError in Slovak. */
+export const formatNonNegativeDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť nezáporný desatinný reťazec.`;
+/** Formats a PositiveError in Slovak. */
+export const formatPositiveError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť kladná (> 0).`;
+/** Formats a PositiveDecimalStringError in Slovak. */
+export const formatPositiveDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť kladný desatinný reťazec.`;
+/** Formats a NonPositiveError in Slovak. */
+export const formatNonPositiveError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť nekladná (<= 0).`;
+/** Formats a NonPositiveDecimalStringError in Slovak. */
+export const formatNonPositiveDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť nekladný desatinný reťazec.`;
+/** Formats a NegativeError in Slovak. */
+export const formatNegativeError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť záporná (< 0).`;
+/** Formats a NegativeDecimalStringError in Slovak. */
+export const formatNegativeDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť záporný desatinný reťazec.`;
+/** Formats an IntError in Slovak. */
+export const formatIntError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť bezpečné celé číslo.`;
+/** Formats a GreaterThanError in Slovak. */
+export const formatGreaterThanError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť väčšia ako ${error.min}.`;
+/** Formats a GreaterThanOrEqualToError in Slovak. */
+export const formatGreaterThanOrEqualToError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť väčšia alebo rovná ${error.min}.`;
+/** Formats a LessThanError in Slovak. */
+export const formatLessThanError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť menšia ako ${error.max}.`;
+/** Formats a LessThanOrEqualToError in Slovak. */
+export const formatLessThanOrEqualToError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť menšia alebo rovná ${error.max}.`;
+/** Formats a NonNaNError in Slovak. */
+export const formatNonNaNError = () => "Hodnota nesmie byť NaN.";
+/** Formats a FiniteError in Slovak. */
+export const formatFiniteError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť konečná.`;
+/** Formats a MultipleOfError in Slovak. */
+export const formatMultipleOfError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť násobkom čísla ${error.divisor}.`;
+/** Formats a BetweenError in Slovak. */
+export const formatBetweenError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí byť v rozsahu od ${error.min} do ${error.max} vrátane.`;
+/** Formats an ArrayError in Slovak. */
+export const formatArrayError = (error) => {
+    if (error.reason.kind === "NotArray")
+        return `Hodnota ${safelyStringifyUnknownValue(error.reason.value)} nie je pole.`;
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `V poli chýba prvok na indexe ${issue.index}.`;
+        case "Accessor":
+            return `Prvok poľa na indexe ${issue.index} musí byť dátová vlastnosť.`;
+        case "ExcessProperty":
+            return "Pole obsahuje nepovolenú vlastnosť. Odstráňte ju alebo použite iný Type.";
+        case "Element":
+            return `Prvok poľa na indexe ${issue.index} nie je platný.`;
+    }
+};
+/** Formats a SetError in Slovak. */
+export const formatSetError = (error) => {
+    if (error.reason.kind === "NotSet")
+        return `Hodnota ${safelyStringifyUnknownValue(error.reason.value)} nie je Set.`;
+    if (error.reason.kind === "UnexpectedPrototype")
+        return "Hodnota je inštanciou podtriedy Set, ale výstup typu Set musí byť priamou inštanciou Set.";
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "ExcessProperty":
+            return `Set obsahuje nepovolenú vlastnosť ${safelyStringifyUnknownValue(issue.key)}.`;
+        case "Element":
+            return `Prvok Set na indexe ${issue.index} nie je platný.`;
+    }
+};
+/** Formats a TupleError in Slovak. */
+export const formatTupleError = (error) => {
+    if (error.reason.kind === "NotArray")
+        return `Hodnota ${safelyStringifyUnknownValue(error.reason.value)} nie je tuple.`;
+    if (error.reason.kind === "InvalidLength")
+        return `Tuple musí obsahovať presne ${error.reason.expected} prvkov, ale hodnota obsahuje ${error.reason.actual}.`;
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `V Tuple chýba prvok na indexe ${issue.index}.`;
+        case "Accessor":
+            return `Prvok Tuple na indexe ${issue.index} musí byť dátová vlastnosť.`;
+        case "ExcessProperty":
+            return "Tuple obsahuje nepovolenú vlastnosť. Odstráňte ju alebo použite iný Type.";
+        case "Element":
+            return `Prvok Tuple na indexe ${issue.index} nie je platný.`;
+    }
+};
+/** Formats a RecordError in Slovak. */
+export const formatRecordError = (error) => {
+    if (error.reason.kind === "NotRecord")
+        return `Hodnota ${safelyStringifyUnknownValue(error.reason.value)} nie je Record.`;
+    if (error.reason.kind === "NotPlainRecord")
+        return "Hodnota je objekt, ale výstup typu Record musí byť obyčajný objekt alebo mať prototyp null.";
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Key":
+            return `Kľúč vlastnosti ${safelyStringifyUnknownValue(issue.key)} nie je platný.`;
+        case "Value":
+            return `Hodnota vlastnosti ${safelyStringifyUnknownValue(issue.key)} nie je platná.`;
+        case "Accessor":
+            return `Vlastnosť Record ${safelyStringifyUnknownValue(issue.key)} musí byť dátová vlastnosť.`;
+        case "NonEnumerable":
+            return `Vlastnosť Record ${safelyStringifyUnknownValue(issue.key)} musí byť enumerovateľná.`;
+        case "Collision":
+            return `Kľúče Record ${safelyStringifyUnknownValue(issue.previousKey)} a ${safelyStringifyUnknownValue(issue.key)} sa dekódujú na rovnaký kľúč ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+    }
+};
+/** Formats an ObjectError in Slovak. */
+export const formatObjectError = (error) => {
+    if (error.reason.kind !== "Properties")
+        return formatPlainObjectRootError(error.reason);
+    const key = Reflect.ownKeys(error.reason.errors).at(0);
+    assertNonNullable(key);
+    const propertyError = error.reason.errors[key];
+    assertNonNullable(propertyError);
+    if (propertyError.type === "ObjectPropertyAccess") {
+        switch (propertyError.reason) {
+            case "Accessor":
+                return "Vlastnosť Object musí byť dátová vlastnosť. Pred použitím tohto Type materializujte hodnoty prístupových vlastností do obyčajných dát alebo použite iný Type.";
+            case "NonEnumerable":
+                return "Vlastnosť Object musí byť enumerovateľná.";
+        }
+    }
+    if (propertyError.type === "ObjectMissingProperty")
+        return `Chýba povinná vlastnosť ${safelyStringifyUnknownValue(key)}.`;
+    if (typeof key === "symbol")
+        return "Kľúč vlastnosti Object musí byť reťazec. Odstráňte vlastnosť so symbolom alebo použite iný Type.";
+    if (propertyError.type === "ObjectExcessProperty")
+        return `Vlastnosť ${safelyStringifyUnknownValue(key)} nie je povolená. Odstráňte ju alebo použite iný Type.`;
+    return `Vlastnosť ${safelyStringifyUnknownValue(key)} nie je platná.`;
+};
+/** Formats a DiscriminatedUnionError in Slovak. */
+export const formatDiscriminatedUnionError = (error) => {
+    switch (error.reason.kind) {
+        case "Object":
+            return formatPlainObjectRootError(error.reason.error.reason);
+        case "PropertyAccess": {
+            const property = `Rozlišovacia vlastnosť ${safelyStringifyUnknownValue(error.reason.key)}`;
+            if (error.reason.reason === "Accessor")
+                return `${property} musí byť dátová vlastnosť.`;
+            if (error.reason.reason === "Inherited")
+                return `${property} musí byť vlastná vlastnosť.`;
+            return `${property} musí byť enumerovateľná.`;
+        }
+        case "Discriminator":
+            return `Rozlišovacia vlastnosť ${safelyStringifyUnknownValue(error.reason.key)} má neočakávanú hodnotu ${safelyStringifyUnknownValue(error.reason.value)}.`;
+        case "Member":
+            return `Vybraný variant ${safelyStringifyUnknownValue(error.reason.discriminator)} nie je platný.`;
+    }
+};
+/** Formats a JsonValueError in Slovak. */
+export const formatJsonValueError = (error) => {
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "InvalidType":
+            return `Hodnota ${safelyStringifyUnknownValue(issue.value)} nie je hodnota JSON.`;
+        case "NonFiniteNumber":
+            return "Číslo JSON musí byť konečné.";
+        case "UnexpectedPrototype":
+            return "Hodnota je objekt, ale objekt JsonValue musí byť obyčajný objekt alebo mať prototyp null.";
+        case "Accessor":
+            return "Vlastnosť JSON musí byť dátová vlastnosť. Pred použitím tohto Type materializujte hodnoty prístupových vlastností do obyčajných dát alebo použite iný Type.";
+        case "NonEnumerable":
+            return "Vlastnosť objektu JSON musí byť enumerovateľná. Odstráňte ju alebo použite iný Type.";
+        case "SymbolProperty":
+            return "Kľúč vlastnosti objektu JSON musí byť reťazec. Odstráňte vlastnosť so symbolom alebo použite iný Type.";
+        case "Hole":
+            return "V poli JSON chýba prvok.";
+        case "ExcessProperty":
+            return "Pole JSON obsahuje nepovolenú vlastnosť. Odstráňte ju alebo použite iný Type.";
+        case "CircularReference":
+            return "JsonValue nesmie obsahovať cyklické referencie.";
+    }
+};
+/** Formats a JsonError in Slovak. */
+export const formatJsonError = (error) => `Hodnotu ${safelyStringifyUnknownValue(error.value)} nemožno analyzovať ako JsonValue.`;