@evolu/common 8.6.2 → 8.8.0

package/src/intl/intl.test.ts

@@ -0,0 +1,3106 @@
+import { describe, test } from "node:test";
+import { assertEqual, assertLength, assertNotUndefined } from "../Assert.ts";
+import {
+  ar,
+  bn,
+  ca,
+  cs,
+  da,
+  de,
+  el,
+  es,
+  fa,
+  fi,
+  fil,
+  fr,
+  he,
+  hi,
+  hr,
+  hu,
+  id,
+  it,
+  ja,
+  ko,
+  ml,
+  mr,
+  ms,
+  nb,
+  nl,
+  pa,
+  pl,
+  pt,
+  ptBR,
+  ro,
+  sk,
+  sl,
+  sv,
+  sw,
+  ta,
+  te,
+  th,
+  tr,
+  uk,
+  ur,
+  vi,
+  zhCN,
+  zhTW,
+} from "@evolu/common/intl";
+
+import * as Type from "../Type.ts";
+import { ok } from "../Result.ts";
+
+const Created = Type.typed("Created", { value: Type.String });
+const Deleted = Type.typed("Deleted", { value: Type.String });
+const Between1And2 = Type.between(1, 2)(Type.Number);
+const LowercaseString = Type.transform(
+  "LowercaseString",
+  Type.String,
+  Type.String,
+  {
+    from: (value) => ok(value.toLowerCase()),
+    to: (value) => value,
+  },
+);
+
+const typesByLocale = Type.localizeTypes(
+  {
+    Age: Type.Age,
+    ArrayBuffer: Type.ArrayBuffer,
+    Base64Url: Type.Base64Url,
+    BigInt: Type.BigInt,
+    Boolean: Type.Boolean,
+    CapitalizedString: Type.CapitalizedString,
+    Date: Type.Date,
+    DateIso: Type.DateIso,
+    DateIsoFromDate: Type.DateIsoFromDate,
+    DecimalString: Type.DecimalString,
+    Digit: Type.Digit,
+    Digit1To6: Type.Digit1To6,
+    Digit1To9: Type.Digit1To9,
+    Digit1To23: Type.Digit1To23,
+    Digit1To51: Type.Digit1To51,
+    Digit1To59: Type.Digit1To59,
+    Digit1To99: Type.Digit1To99,
+    EvoluType: Type.EvoluType,
+    FiniteNumber: Type.FiniteNumber,
+    Function: Type.Function,
+    Id: Type.Id,
+    IdBytes: Type.IdBytes,
+    Int: Type.Int,
+    Int64: Type.Int64,
+    Int64FromInt64String: Type.Int64FromInt64String,
+    Int64String: Type.Int64String,
+    Json: Type.Json,
+    JsonArray: Type.JsonArray,
+    JsonObject: Type.JsonObject,
+    JsonValue: Type.JsonValue,
+    JsonValueFromJson: Type.JsonValueFromJson,
+    Literal: Type.literal("yes"),
+    Mnemonic: Type.Mnemonic,
+    Name: Type.Name,
+    NegativeDecimalString: Type.NegativeDecimalString,
+    NegativeInt: Type.NegativeInt,
+    NegativeNumber: Type.NegativeNumber,
+    Never: Type.Never,
+    NonEmptyTrimmedString: Type.NonEmptyTrimmedString,
+    NonEmptyTrimmedString100: Type.NonEmptyTrimmedString100,
+    NonEmptyTrimmedString1000: Type.NonEmptyTrimmedString1000,
+    NonNaNNumber: Type.NonNaNNumber,
+    NonNegativeDecimalString: Type.NonNegativeDecimalString,
+    NonNegativeFiniteNumber: Type.NonNegativeFiniteNumber,
+    NonNegativeInt: Type.NonNegativeInt,
+    NonNegativeNumber: Type.NonNegativeNumber,
+    NonPositiveDecimalString: Type.NonPositiveDecimalString,
+    NonPositiveInt: Type.NonPositiveInt,
+    NonPositiveNumber: Type.NonPositiveNumber,
+    Null: Type.Null,
+    Number: Type.Number,
+    Object: Type.Object,
+    PositiveDecimalString: Type.PositiveDecimalString,
+    PositiveFiniteNumber: Type.PositiveFiniteNumber,
+    PositiveInt: Type.PositiveInt,
+    PositiveNumber: Type.PositiveNumber,
+    Ratio: Type.Ratio,
+    SimplePassword: Type.SimplePassword,
+    String: Type.String,
+    Symbol: Type.Symbol,
+    TrimmedString: Type.TrimmedString,
+    UInt64: Type.UInt64,
+    Uint8Array: Type.Uint8Array,
+    Undefined: Type.Undefined,
+    Unknown: Type.Unknown,
+    UnknownNextResult: Type.UnknownNextResult,
+    UnknownResult: Type.UnknownResult,
+    UrlSafeString: Type.UrlSafeString,
+    Array: Type.array(Type.String),
+    Between: Between1And2,
+    DiscriminatedUnion: Type.discriminatedUnion(Created, Deleted),
+    GreaterThan: Type.greaterThan(1)(Type.Number),
+    GreaterThanOrEqualTo: Type.greaterThanOrEqualTo(1)(Type.Number),
+    InstanceOf: Type.instanceOf(Date),
+    Length: Type.length(2)(Type.String),
+    LessThan: Type.lessThan(1)(Type.Number),
+    LessThanOrEqualTo: Type.lessThanOrEqualTo(1)(Type.Number),
+    Map: Type.map(Type.String, Type.String),
+    MaxLength: Type.maxLength(2)(Type.String),
+    MinLength: Type.minLength(2)(Type.String),
+    MultipleOf: Type.multipleOf("2")(Type.Number),
+    ObjectFactory: Type.object({ value: Type.String }),
+    Record: Type.record(Type.String, Type.String),
+    RecordWithCollision: Type.record(LowercaseString, Type.String),
+    RecordWithKey: Type.record(
+      Type.regex("RecordKey", /^valid$/u)(Type.String),
+      Type.String,
+    ),
+    Regex: Type.regex("Regex", /^x$/u)(Type.String),
+    Set: Type.set(Type.String),
+    TableId: Type.id("Todo"),
+    TemplateLiteral: Type.templateLiteral("prefix:", Type.String),
+    Tuple: Type.tuple(Type.String, Type.Number),
+    Union: Type.union(Type.String, Type.Number),
+  },
+  {
+    ar: {
+      Array: ar.formatArrayError,
+      Base64Url: ar.formatBase64UrlError,
+      [Between1And2.name]: ar.formatBetweenError,
+      BigInt: ar.formatBigIntError,
+      Boolean: ar.formatBooleanError,
+      Capitalized: ar.formatCapitalizedError,
+      DateIso: ar.formatDateIsoError,
+      DateIsoFromDate: ar.formatDateIsoFromDateError,
+      DecimalString: ar.formatDecimalStringError,
+      DiscriminatedUnion: ar.formatDiscriminatedUnionError,
+      EvoluType: ar.formatEvoluTypeError,
+      Finite: ar.formatFiniteError,
+      Function: ar.formatFunctionError,
+      GreaterThan1: ar.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ar.formatGreaterThanOrEqualToError,
+      Id: ar.formatIdError,
+      InstanceOf: ar.formatInstanceOfError,
+      Int: ar.formatIntError,
+      Int64: ar.formatInt64Error,
+      Int64String: ar.formatInt64StringError,
+      Json: ar.formatJsonError,
+      JsonValue: ar.formatJsonValueError,
+      Length2: ar.formatLengthError,
+      Length16: ar.formatLengthError,
+      LessThan1: ar.formatLessThanError,
+      LessThan200: ar.formatLessThanError,
+      LessThanOrEqualTo1: ar.formatLessThanOrEqualToError,
+      Literal: ar.formatLiteralError,
+      Map: ar.formatMapError,
+      MaxLength2: ar.formatMaxLengthError,
+      MaxLength64: ar.formatMaxLengthError,
+      MaxLength100: ar.formatMaxLengthError,
+      MaxLength1000: ar.formatMaxLengthError,
+      MinLength1: ar.formatMinLengthError,
+      MinLength2: ar.formatMinLengthError,
+      MinLength8: ar.formatMinLengthError,
+      Mnemonic: ar.formatMnemonicError,
+      MultipleOf2: ar.formatMultipleOfError,
+      Name: ar.formatNameError,
+      Negative: ar.formatNegativeError,
+      NegativeDecimalString: ar.formatNegativeDecimalStringError,
+      Never: ar.formatNeverError,
+      NonNaN: ar.formatNonNaNError,
+      NonNegative: ar.formatNonNegativeError,
+      NonNegativeDecimalString: ar.formatNonNegativeDecimalStringError,
+      NonPositive: ar.formatNonPositiveError,
+      NonPositiveDecimalString: ar.formatNonPositiveDecimalStringError,
+      Number: ar.formatNumberError,
+      Object: ar.formatObjectError,
+      ObjectTag: ar.formatObjectTagError,
+      Positive: ar.formatPositiveError,
+      PositiveDecimalString: ar.formatPositiveDecimalStringError,
+      Record: ar.formatRecordError,
+      RecordKey: ar.formatRegexError,
+      Regex: ar.formatRegexError,
+      Set: ar.formatSetError,
+      String: ar.formatStringError,
+      Symbol: ar.formatSymbolError,
+      TableId: ar.formatTableIdError,
+      TemplateLiteral: ar.formatTemplateLiteralError,
+      Trimmed: ar.formatTrimmedError,
+      Tuple: ar.formatTupleError,
+      UInt64: ar.formatUInt64Error,
+      Union: ar.formatUnionError,
+      UrlSafeString: ar.formatRegexError,
+    },
+    bn: {
+      Array: bn.formatArrayError,
+      Base64Url: bn.formatBase64UrlError,
+      [Between1And2.name]: bn.formatBetweenError,
+      BigInt: bn.formatBigIntError,
+      Boolean: bn.formatBooleanError,
+      Capitalized: bn.formatCapitalizedError,
+      DateIso: bn.formatDateIsoError,
+      DateIsoFromDate: bn.formatDateIsoFromDateError,
+      DecimalString: bn.formatDecimalStringError,
+      DiscriminatedUnion: bn.formatDiscriminatedUnionError,
+      EvoluType: bn.formatEvoluTypeError,
+      Finite: bn.formatFiniteError,
+      Function: bn.formatFunctionError,
+      GreaterThan1: bn.formatGreaterThanError,
+      GreaterThanOrEqualTo1: bn.formatGreaterThanOrEqualToError,
+      Id: bn.formatIdError,
+      InstanceOf: bn.formatInstanceOfError,
+      Int: bn.formatIntError,
+      Int64: bn.formatInt64Error,
+      Int64String: bn.formatInt64StringError,
+      Json: bn.formatJsonError,
+      JsonValue: bn.formatJsonValueError,
+      Length2: bn.formatLengthError,
+      Length16: bn.formatLengthError,
+      LessThan1: bn.formatLessThanError,
+      LessThan200: bn.formatLessThanError,
+      LessThanOrEqualTo1: bn.formatLessThanOrEqualToError,
+      Literal: bn.formatLiteralError,
+      Map: bn.formatMapError,
+      MaxLength2: bn.formatMaxLengthError,
+      MaxLength64: bn.formatMaxLengthError,
+      MaxLength100: bn.formatMaxLengthError,
+      MaxLength1000: bn.formatMaxLengthError,
+      MinLength1: bn.formatMinLengthError,
+      MinLength2: bn.formatMinLengthError,
+      MinLength8: bn.formatMinLengthError,
+      Mnemonic: bn.formatMnemonicError,
+      MultipleOf2: bn.formatMultipleOfError,
+      Name: bn.formatNameError,
+      Negative: bn.formatNegativeError,
+      NegativeDecimalString: bn.formatNegativeDecimalStringError,
+      Never: bn.formatNeverError,
+      NonNaN: bn.formatNonNaNError,
+      NonNegative: bn.formatNonNegativeError,
+      NonNegativeDecimalString: bn.formatNonNegativeDecimalStringError,
+      NonPositive: bn.formatNonPositiveError,
+      NonPositiveDecimalString: bn.formatNonPositiveDecimalStringError,
+      Number: bn.formatNumberError,
+      Object: bn.formatObjectError,
+      ObjectTag: bn.formatObjectTagError,
+      Positive: bn.formatPositiveError,
+      PositiveDecimalString: bn.formatPositiveDecimalStringError,
+      Record: bn.formatRecordError,
+      RecordKey: bn.formatRegexError,
+      Regex: bn.formatRegexError,
+      Set: bn.formatSetError,
+      String: bn.formatStringError,
+      Symbol: bn.formatSymbolError,
+      TableId: bn.formatTableIdError,
+      TemplateLiteral: bn.formatTemplateLiteralError,
+      Trimmed: bn.formatTrimmedError,
+      Tuple: bn.formatTupleError,
+      UInt64: bn.formatUInt64Error,
+      Union: bn.formatUnionError,
+      UrlSafeString: bn.formatRegexError,
+    },
+    ca: {
+      Array: ca.formatArrayError,
+      Base64Url: ca.formatBase64UrlError,
+      [Between1And2.name]: ca.formatBetweenError,
+      BigInt: ca.formatBigIntError,
+      Boolean: ca.formatBooleanError,
+      Capitalized: ca.formatCapitalizedError,
+      DateIso: ca.formatDateIsoError,
+      DateIsoFromDate: ca.formatDateIsoFromDateError,
+      DecimalString: ca.formatDecimalStringError,
+      DiscriminatedUnion: ca.formatDiscriminatedUnionError,
+      EvoluType: ca.formatEvoluTypeError,
+      Finite: ca.formatFiniteError,
+      Function: ca.formatFunctionError,
+      GreaterThan1: ca.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ca.formatGreaterThanOrEqualToError,
+      Id: ca.formatIdError,
+      InstanceOf: ca.formatInstanceOfError,
+      Int: ca.formatIntError,
+      Int64: ca.formatInt64Error,
+      Int64String: ca.formatInt64StringError,
+      Json: ca.formatJsonError,
+      JsonValue: ca.formatJsonValueError,
+      Length2: ca.formatLengthError,
+      Length16: ca.formatLengthError,
+      LessThan1: ca.formatLessThanError,
+      LessThan200: ca.formatLessThanError,
+      LessThanOrEqualTo1: ca.formatLessThanOrEqualToError,
+      Literal: ca.formatLiteralError,
+      Map: ca.formatMapError,
+      MaxLength2: ca.formatMaxLengthError,
+      MaxLength64: ca.formatMaxLengthError,
+      MaxLength100: ca.formatMaxLengthError,
+      MaxLength1000: ca.formatMaxLengthError,
+      MinLength1: ca.formatMinLengthError,
+      MinLength2: ca.formatMinLengthError,
+      MinLength8: ca.formatMinLengthError,
+      Mnemonic: ca.formatMnemonicError,
+      MultipleOf2: ca.formatMultipleOfError,
+      Name: ca.formatNameError,
+      Negative: ca.formatNegativeError,
+      NegativeDecimalString: ca.formatNegativeDecimalStringError,
+      Never: ca.formatNeverError,
+      NonNaN: ca.formatNonNaNError,
+      NonNegative: ca.formatNonNegativeError,
+      NonNegativeDecimalString: ca.formatNonNegativeDecimalStringError,
+      NonPositive: ca.formatNonPositiveError,
+      NonPositiveDecimalString: ca.formatNonPositiveDecimalStringError,
+      Number: ca.formatNumberError,
+      Object: ca.formatObjectError,
+      ObjectTag: ca.formatObjectTagError,
+      Positive: ca.formatPositiveError,
+      PositiveDecimalString: ca.formatPositiveDecimalStringError,
+      Record: ca.formatRecordError,
+      RecordKey: ca.formatRegexError,
+      Regex: ca.formatRegexError,
+      Set: ca.formatSetError,
+      String: ca.formatStringError,
+      Symbol: ca.formatSymbolError,
+      TableId: ca.formatTableIdError,
+      TemplateLiteral: ca.formatTemplateLiteralError,
+      Trimmed: ca.formatTrimmedError,
+      Tuple: ca.formatTupleError,
+      UInt64: ca.formatUInt64Error,
+      Union: ca.formatUnionError,
+      UrlSafeString: ca.formatRegexError,
+    },
+    cs: {
+      Array: cs.formatArrayError,
+      Base64Url: cs.formatBase64UrlError,
+      [Between1And2.name]: cs.formatBetweenError,
+      BigInt: cs.formatBigIntError,
+      Boolean: cs.formatBooleanError,
+      Capitalized: cs.formatCapitalizedError,
+      DateIso: cs.formatDateIsoError,
+      DateIsoFromDate: cs.formatDateIsoFromDateError,
+      DecimalString: cs.formatDecimalStringError,
+      DiscriminatedUnion: cs.formatDiscriminatedUnionError,
+      EvoluType: cs.formatEvoluTypeError,
+      Finite: cs.formatFiniteError,
+      Function: cs.formatFunctionError,
+      GreaterThan1: cs.formatGreaterThanError,
+      GreaterThanOrEqualTo1: cs.formatGreaterThanOrEqualToError,
+      Id: cs.formatIdError,
+      InstanceOf: cs.formatInstanceOfError,
+      Int: cs.formatIntError,
+      Int64: cs.formatInt64Error,
+      Int64String: cs.formatInt64StringError,
+      Json: cs.formatJsonError,
+      JsonValue: cs.formatJsonValueError,
+      Length2: cs.formatLengthError,
+      Length16: cs.formatLengthError,
+      LessThan1: cs.formatLessThanError,
+      LessThan200: cs.formatLessThanError,
+      LessThanOrEqualTo1: cs.formatLessThanOrEqualToError,
+      Literal: cs.formatLiteralError,
+      Map: cs.formatMapError,
+      MaxLength2: cs.formatMaxLengthError,
+      MaxLength64: cs.formatMaxLengthError,
+      MaxLength100: cs.formatMaxLengthError,
+      MaxLength1000: cs.formatMaxLengthError,
+      MinLength1: cs.formatMinLengthError,
+      MinLength2: cs.formatMinLengthError,
+      MinLength8: cs.formatMinLengthError,
+      Mnemonic: cs.formatMnemonicError,
+      MultipleOf2: cs.formatMultipleOfError,
+      Name: cs.formatNameError,
+      Negative: cs.formatNegativeError,
+      NegativeDecimalString: cs.formatNegativeDecimalStringError,
+      Never: cs.formatNeverError,
+      NonNaN: cs.formatNonNaNError,
+      NonNegative: cs.formatNonNegativeError,
+      NonNegativeDecimalString: cs.formatNonNegativeDecimalStringError,
+      NonPositive: cs.formatNonPositiveError,
+      NonPositiveDecimalString: cs.formatNonPositiveDecimalStringError,
+      Number: cs.formatNumberError,
+      Object: cs.formatObjectError,
+      ObjectTag: cs.formatObjectTagError,
+      Positive: cs.formatPositiveError,
+      PositiveDecimalString: cs.formatPositiveDecimalStringError,
+      Record: cs.formatRecordError,
+      RecordKey: cs.formatRegexError,
+      Regex: cs.formatRegexError,
+      Set: cs.formatSetError,
+      String: cs.formatStringError,
+      Symbol: cs.formatSymbolError,
+      TableId: cs.formatTableIdError,
+      TemplateLiteral: cs.formatTemplateLiteralError,
+      Trimmed: cs.formatTrimmedError,
+      Tuple: cs.formatTupleError,
+      UInt64: cs.formatUInt64Error,
+      Union: cs.formatUnionError,
+      UrlSafeString: cs.formatRegexError,
+    },
+    da: {
+      Array: da.formatArrayError,
+      Base64Url: da.formatBase64UrlError,
+      [Between1And2.name]: da.formatBetweenError,
+      BigInt: da.formatBigIntError,
+      Boolean: da.formatBooleanError,
+      Capitalized: da.formatCapitalizedError,
+      DateIso: da.formatDateIsoError,
+      DateIsoFromDate: da.formatDateIsoFromDateError,
+      DecimalString: da.formatDecimalStringError,
+      DiscriminatedUnion: da.formatDiscriminatedUnionError,
+      EvoluType: da.formatEvoluTypeError,
+      Finite: da.formatFiniteError,
+      Function: da.formatFunctionError,
+      GreaterThan1: da.formatGreaterThanError,
+      GreaterThanOrEqualTo1: da.formatGreaterThanOrEqualToError,
+      Id: da.formatIdError,
+      InstanceOf: da.formatInstanceOfError,
+      Int: da.formatIntError,
+      Int64: da.formatInt64Error,
+      Int64String: da.formatInt64StringError,
+      Json: da.formatJsonError,
+      JsonValue: da.formatJsonValueError,
+      Length2: da.formatLengthError,
+      Length16: da.formatLengthError,
+      LessThan1: da.formatLessThanError,
+      LessThan200: da.formatLessThanError,
+      LessThanOrEqualTo1: da.formatLessThanOrEqualToError,
+      Literal: da.formatLiteralError,
+      Map: da.formatMapError,
+      MaxLength2: da.formatMaxLengthError,
+      MaxLength64: da.formatMaxLengthError,
+      MaxLength100: da.formatMaxLengthError,
+      MaxLength1000: da.formatMaxLengthError,
+      MinLength1: da.formatMinLengthError,
+      MinLength2: da.formatMinLengthError,
+      MinLength8: da.formatMinLengthError,
+      Mnemonic: da.formatMnemonicError,
+      MultipleOf2: da.formatMultipleOfError,
+      Name: da.formatNameError,
+      Negative: da.formatNegativeError,
+      NegativeDecimalString: da.formatNegativeDecimalStringError,
+      Never: da.formatNeverError,
+      NonNaN: da.formatNonNaNError,
+      NonNegative: da.formatNonNegativeError,
+      NonNegativeDecimalString: da.formatNonNegativeDecimalStringError,
+      NonPositive: da.formatNonPositiveError,
+      NonPositiveDecimalString: da.formatNonPositiveDecimalStringError,
+      Number: da.formatNumberError,
+      Object: da.formatObjectError,
+      ObjectTag: da.formatObjectTagError,
+      Positive: da.formatPositiveError,
+      PositiveDecimalString: da.formatPositiveDecimalStringError,
+      Record: da.formatRecordError,
+      RecordKey: da.formatRegexError,
+      Regex: da.formatRegexError,
+      Set: da.formatSetError,
+      String: da.formatStringError,
+      Symbol: da.formatSymbolError,
+      TableId: da.formatTableIdError,
+      TemplateLiteral: da.formatTemplateLiteralError,
+      Trimmed: da.formatTrimmedError,
+      Tuple: da.formatTupleError,
+      UInt64: da.formatUInt64Error,
+      Union: da.formatUnionError,
+      UrlSafeString: da.formatRegexError,
+    },
+    de: {
+      Array: de.formatArrayError,
+      Base64Url: de.formatBase64UrlError,
+      [Between1And2.name]: de.formatBetweenError,
+      BigInt: de.formatBigIntError,
+      Boolean: de.formatBooleanError,
+      Capitalized: de.formatCapitalizedError,
+      DateIso: de.formatDateIsoError,
+      DateIsoFromDate: de.formatDateIsoFromDateError,
+      DecimalString: de.formatDecimalStringError,
+      DiscriminatedUnion: de.formatDiscriminatedUnionError,
+      EvoluType: de.formatEvoluTypeError,
+      Finite: de.formatFiniteError,
+      Function: de.formatFunctionError,
+      GreaterThan1: de.formatGreaterThanError,
+      GreaterThanOrEqualTo1: de.formatGreaterThanOrEqualToError,
+      Id: de.formatIdError,
+      InstanceOf: de.formatInstanceOfError,
+      Int: de.formatIntError,
+      Int64: de.formatInt64Error,
+      Int64String: de.formatInt64StringError,
+      Json: de.formatJsonError,
+      JsonValue: de.formatJsonValueError,
+      Length2: de.formatLengthError,
+      Length16: de.formatLengthError,
+      LessThan1: de.formatLessThanError,
+      LessThan200: de.formatLessThanError,
+      LessThanOrEqualTo1: de.formatLessThanOrEqualToError,
+      Literal: de.formatLiteralError,
+      Map: de.formatMapError,
+      MaxLength2: de.formatMaxLengthError,
+      MaxLength64: de.formatMaxLengthError,
+      MaxLength100: de.formatMaxLengthError,
+      MaxLength1000: de.formatMaxLengthError,
+      MinLength1: de.formatMinLengthError,
+      MinLength2: de.formatMinLengthError,
+      MinLength8: de.formatMinLengthError,
+      Mnemonic: de.formatMnemonicError,
+      MultipleOf2: de.formatMultipleOfError,
+      Name: de.formatNameError,
+      Negative: de.formatNegativeError,
+      NegativeDecimalString: de.formatNegativeDecimalStringError,
+      Never: de.formatNeverError,
+      NonNaN: de.formatNonNaNError,
+      NonNegative: de.formatNonNegativeError,
+      NonNegativeDecimalString: de.formatNonNegativeDecimalStringError,
+      NonPositive: de.formatNonPositiveError,
+      NonPositiveDecimalString: de.formatNonPositiveDecimalStringError,
+      Number: de.formatNumberError,
+      Object: de.formatObjectError,
+      ObjectTag: de.formatObjectTagError,
+      Positive: de.formatPositiveError,
+      PositiveDecimalString: de.formatPositiveDecimalStringError,
+      Record: de.formatRecordError,
+      RecordKey: de.formatRegexError,
+      Regex: de.formatRegexError,
+      Set: de.formatSetError,
+      String: de.formatStringError,
+      Symbol: de.formatSymbolError,
+      TableId: de.formatTableIdError,
+      TemplateLiteral: de.formatTemplateLiteralError,
+      Trimmed: de.formatTrimmedError,
+      Tuple: de.formatTupleError,
+      UInt64: de.formatUInt64Error,
+      Union: de.formatUnionError,
+      UrlSafeString: de.formatRegexError,
+    },
+    el: {
+      Array: el.formatArrayError,
+      Base64Url: el.formatBase64UrlError,
+      [Between1And2.name]: el.formatBetweenError,
+      BigInt: el.formatBigIntError,
+      Boolean: el.formatBooleanError,
+      Capitalized: el.formatCapitalizedError,
+      DateIso: el.formatDateIsoError,
+      DateIsoFromDate: el.formatDateIsoFromDateError,
+      DecimalString: el.formatDecimalStringError,
+      DiscriminatedUnion: el.formatDiscriminatedUnionError,
+      EvoluType: el.formatEvoluTypeError,
+      Finite: el.formatFiniteError,
+      Function: el.formatFunctionError,
+      GreaterThan1: el.formatGreaterThanError,
+      GreaterThanOrEqualTo1: el.formatGreaterThanOrEqualToError,
+      Id: el.formatIdError,
+      InstanceOf: el.formatInstanceOfError,
+      Int: el.formatIntError,
+      Int64: el.formatInt64Error,
+      Int64String: el.formatInt64StringError,
+      Json: el.formatJsonError,
+      JsonValue: el.formatJsonValueError,
+      Length2: el.formatLengthError,
+      Length16: el.formatLengthError,
+      LessThan1: el.formatLessThanError,
+      LessThan200: el.formatLessThanError,
+      LessThanOrEqualTo1: el.formatLessThanOrEqualToError,
+      Literal: el.formatLiteralError,
+      Map: el.formatMapError,
+      MaxLength2: el.formatMaxLengthError,
+      MaxLength64: el.formatMaxLengthError,
+      MaxLength100: el.formatMaxLengthError,
+      MaxLength1000: el.formatMaxLengthError,
+      MinLength1: el.formatMinLengthError,
+      MinLength2: el.formatMinLengthError,
+      MinLength8: el.formatMinLengthError,
+      Mnemonic: el.formatMnemonicError,
+      MultipleOf2: el.formatMultipleOfError,
+      Name: el.formatNameError,
+      Negative: el.formatNegativeError,
+      NegativeDecimalString: el.formatNegativeDecimalStringError,
+      Never: el.formatNeverError,
+      NonNaN: el.formatNonNaNError,
+      NonNegative: el.formatNonNegativeError,
+      NonNegativeDecimalString: el.formatNonNegativeDecimalStringError,
+      NonPositive: el.formatNonPositiveError,
+      NonPositiveDecimalString: el.formatNonPositiveDecimalStringError,
+      Number: el.formatNumberError,
+      Object: el.formatObjectError,
+      ObjectTag: el.formatObjectTagError,
+      Positive: el.formatPositiveError,
+      PositiveDecimalString: el.formatPositiveDecimalStringError,
+      Record: el.formatRecordError,
+      RecordKey: el.formatRegexError,
+      Regex: el.formatRegexError,
+      Set: el.formatSetError,
+      String: el.formatStringError,
+      Symbol: el.formatSymbolError,
+      TableId: el.formatTableIdError,
+      TemplateLiteral: el.formatTemplateLiteralError,
+      Trimmed: el.formatTrimmedError,
+      Tuple: el.formatTupleError,
+      UInt64: el.formatUInt64Error,
+      Union: el.formatUnionError,
+      UrlSafeString: el.formatRegexError,
+    },
+    es: {
+      Array: es.formatArrayError,
+      Base64Url: es.formatBase64UrlError,
+      [Between1And2.name]: es.formatBetweenError,
+      BigInt: es.formatBigIntError,
+      Boolean: es.formatBooleanError,
+      Capitalized: es.formatCapitalizedError,
+      DateIso: es.formatDateIsoError,
+      DateIsoFromDate: es.formatDateIsoFromDateError,
+      DecimalString: es.formatDecimalStringError,
+      DiscriminatedUnion: es.formatDiscriminatedUnionError,
+      EvoluType: es.formatEvoluTypeError,
+      Finite: es.formatFiniteError,
+      Function: es.formatFunctionError,
+      GreaterThan1: es.formatGreaterThanError,
+      GreaterThanOrEqualTo1: es.formatGreaterThanOrEqualToError,
+      Id: es.formatIdError,
+      InstanceOf: es.formatInstanceOfError,
+      Int: es.formatIntError,
+      Int64: es.formatInt64Error,
+      Int64String: es.formatInt64StringError,
+      Json: es.formatJsonError,
+      JsonValue: es.formatJsonValueError,
+      Length2: es.formatLengthError,
+      Length16: es.formatLengthError,
+      LessThan1: es.formatLessThanError,
+      LessThan200: es.formatLessThanError,
+      LessThanOrEqualTo1: es.formatLessThanOrEqualToError,
+      Literal: es.formatLiteralError,
+      Map: es.formatMapError,
+      MaxLength2: es.formatMaxLengthError,
+      MaxLength64: es.formatMaxLengthError,
+      MaxLength100: es.formatMaxLengthError,
+      MaxLength1000: es.formatMaxLengthError,
+      MinLength1: es.formatMinLengthError,
+      MinLength2: es.formatMinLengthError,
+      MinLength8: es.formatMinLengthError,
+      Mnemonic: es.formatMnemonicError,
+      MultipleOf2: es.formatMultipleOfError,
+      Name: es.formatNameError,
+      Negative: es.formatNegativeError,
+      NegativeDecimalString: es.formatNegativeDecimalStringError,
+      Never: es.formatNeverError,
+      NonNaN: es.formatNonNaNError,
+      NonNegative: es.formatNonNegativeError,
+      NonNegativeDecimalString: es.formatNonNegativeDecimalStringError,
+      NonPositive: es.formatNonPositiveError,
+      NonPositiveDecimalString: es.formatNonPositiveDecimalStringError,
+      Number: es.formatNumberError,
+      Object: es.formatObjectError,
+      ObjectTag: es.formatObjectTagError,
+      Positive: es.formatPositiveError,
+      PositiveDecimalString: es.formatPositiveDecimalStringError,
+      Record: es.formatRecordError,
+      RecordKey: es.formatRegexError,
+      Regex: es.formatRegexError,
+      Set: es.formatSetError,
+      String: es.formatStringError,
+      Symbol: es.formatSymbolError,
+      TableId: es.formatTableIdError,
+      TemplateLiteral: es.formatTemplateLiteralError,
+      Trimmed: es.formatTrimmedError,
+      Tuple: es.formatTupleError,
+      UInt64: es.formatUInt64Error,
+      Union: es.formatUnionError,
+      UrlSafeString: es.formatRegexError,
+    },
+    fa: {
+      Array: fa.formatArrayError,
+      Base64Url: fa.formatBase64UrlError,
+      [Between1And2.name]: fa.formatBetweenError,
+      BigInt: fa.formatBigIntError,
+      Boolean: fa.formatBooleanError,
+      Capitalized: fa.formatCapitalizedError,
+      DateIso: fa.formatDateIsoError,
+      DateIsoFromDate: fa.formatDateIsoFromDateError,
+      DecimalString: fa.formatDecimalStringError,
+      DiscriminatedUnion: fa.formatDiscriminatedUnionError,
+      EvoluType: fa.formatEvoluTypeError,
+      Finite: fa.formatFiniteError,
+      Function: fa.formatFunctionError,
+      GreaterThan1: fa.formatGreaterThanError,
+      GreaterThanOrEqualTo1: fa.formatGreaterThanOrEqualToError,
+      Id: fa.formatIdError,
+      InstanceOf: fa.formatInstanceOfError,
+      Int: fa.formatIntError,
+      Int64: fa.formatInt64Error,
+      Int64String: fa.formatInt64StringError,
+      Json: fa.formatJsonError,
+      JsonValue: fa.formatJsonValueError,
+      Length2: fa.formatLengthError,
+      Length16: fa.formatLengthError,
+      LessThan1: fa.formatLessThanError,
+      LessThan200: fa.formatLessThanError,
+      LessThanOrEqualTo1: fa.formatLessThanOrEqualToError,
+      Literal: fa.formatLiteralError,
+      Map: fa.formatMapError,
+      MaxLength2: fa.formatMaxLengthError,
+      MaxLength64: fa.formatMaxLengthError,
+      MaxLength100: fa.formatMaxLengthError,
+      MaxLength1000: fa.formatMaxLengthError,
+      MinLength1: fa.formatMinLengthError,
+      MinLength2: fa.formatMinLengthError,
+      MinLength8: fa.formatMinLengthError,
+      Mnemonic: fa.formatMnemonicError,
+      MultipleOf2: fa.formatMultipleOfError,
+      Name: fa.formatNameError,
+      Negative: fa.formatNegativeError,
+      NegativeDecimalString: fa.formatNegativeDecimalStringError,
+      Never: fa.formatNeverError,
+      NonNaN: fa.formatNonNaNError,
+      NonNegative: fa.formatNonNegativeError,
+      NonNegativeDecimalString: fa.formatNonNegativeDecimalStringError,
+      NonPositive: fa.formatNonPositiveError,
+      NonPositiveDecimalString: fa.formatNonPositiveDecimalStringError,
+      Number: fa.formatNumberError,
+      Object: fa.formatObjectError,
+      ObjectTag: fa.formatObjectTagError,
+      Positive: fa.formatPositiveError,
+      PositiveDecimalString: fa.formatPositiveDecimalStringError,
+      Record: fa.formatRecordError,
+      RecordKey: fa.formatRegexError,
+      Regex: fa.formatRegexError,
+      Set: fa.formatSetError,
+      String: fa.formatStringError,
+      Symbol: fa.formatSymbolError,
+      TableId: fa.formatTableIdError,
+      TemplateLiteral: fa.formatTemplateLiteralError,
+      Trimmed: fa.formatTrimmedError,
+      Tuple: fa.formatTupleError,
+      UInt64: fa.formatUInt64Error,
+      Union: fa.formatUnionError,
+      UrlSafeString: fa.formatRegexError,
+    },
+    fi: {
+      Array: fi.formatArrayError,
+      Base64Url: fi.formatBase64UrlError,
+      [Between1And2.name]: fi.formatBetweenError,
+      BigInt: fi.formatBigIntError,
+      Boolean: fi.formatBooleanError,
+      Capitalized: fi.formatCapitalizedError,
+      DateIso: fi.formatDateIsoError,
+      DateIsoFromDate: fi.formatDateIsoFromDateError,
+      DecimalString: fi.formatDecimalStringError,
+      DiscriminatedUnion: fi.formatDiscriminatedUnionError,
+      EvoluType: fi.formatEvoluTypeError,
+      Finite: fi.formatFiniteError,
+      Function: fi.formatFunctionError,
+      GreaterThan1: fi.formatGreaterThanError,
+      GreaterThanOrEqualTo1: fi.formatGreaterThanOrEqualToError,
+      Id: fi.formatIdError,
+      InstanceOf: fi.formatInstanceOfError,
+      Int: fi.formatIntError,
+      Int64: fi.formatInt64Error,
+      Int64String: fi.formatInt64StringError,
+      Json: fi.formatJsonError,
+      JsonValue: fi.formatJsonValueError,
+      Length2: fi.formatLengthError,
+      Length16: fi.formatLengthError,
+      LessThan1: fi.formatLessThanError,
+      LessThan200: fi.formatLessThanError,
+      LessThanOrEqualTo1: fi.formatLessThanOrEqualToError,
+      Literal: fi.formatLiteralError,
+      Map: fi.formatMapError,
+      MaxLength2: fi.formatMaxLengthError,
+      MaxLength64: fi.formatMaxLengthError,
+      MaxLength100: fi.formatMaxLengthError,
+      MaxLength1000: fi.formatMaxLengthError,
+      MinLength1: fi.formatMinLengthError,
+      MinLength2: fi.formatMinLengthError,
+      MinLength8: fi.formatMinLengthError,
+      Mnemonic: fi.formatMnemonicError,
+      MultipleOf2: fi.formatMultipleOfError,
+      Name: fi.formatNameError,
+      Negative: fi.formatNegativeError,
+      NegativeDecimalString: fi.formatNegativeDecimalStringError,
+      Never: fi.formatNeverError,
+      NonNaN: fi.formatNonNaNError,
+      NonNegative: fi.formatNonNegativeError,
+      NonNegativeDecimalString: fi.formatNonNegativeDecimalStringError,
+      NonPositive: fi.formatNonPositiveError,
+      NonPositiveDecimalString: fi.formatNonPositiveDecimalStringError,
+      Number: fi.formatNumberError,
+      Object: fi.formatObjectError,
+      ObjectTag: fi.formatObjectTagError,
+      Positive: fi.formatPositiveError,
+      PositiveDecimalString: fi.formatPositiveDecimalStringError,
+      Record: fi.formatRecordError,
+      RecordKey: fi.formatRegexError,
+      Regex: fi.formatRegexError,
+      Set: fi.formatSetError,
+      String: fi.formatStringError,
+      Symbol: fi.formatSymbolError,
+      TableId: fi.formatTableIdError,
+      TemplateLiteral: fi.formatTemplateLiteralError,
+      Trimmed: fi.formatTrimmedError,
+      Tuple: fi.formatTupleError,
+      UInt64: fi.formatUInt64Error,
+      Union: fi.formatUnionError,
+      UrlSafeString: fi.formatRegexError,
+    },
+    fil: {
+      Array: fil.formatArrayError,
+      Base64Url: fil.formatBase64UrlError,
+      [Between1And2.name]: fil.formatBetweenError,
+      BigInt: fil.formatBigIntError,
+      Boolean: fil.formatBooleanError,
+      Capitalized: fil.formatCapitalizedError,
+      DateIso: fil.formatDateIsoError,
+      DateIsoFromDate: fil.formatDateIsoFromDateError,
+      DecimalString: fil.formatDecimalStringError,
+      DiscriminatedUnion: fil.formatDiscriminatedUnionError,
+      EvoluType: fil.formatEvoluTypeError,
+      Finite: fil.formatFiniteError,
+      Function: fil.formatFunctionError,
+      GreaterThan1: fil.formatGreaterThanError,
+      GreaterThanOrEqualTo1: fil.formatGreaterThanOrEqualToError,
+      Id: fil.formatIdError,
+      InstanceOf: fil.formatInstanceOfError,
+      Int: fil.formatIntError,
+      Int64: fil.formatInt64Error,
+      Int64String: fil.formatInt64StringError,
+      Json: fil.formatJsonError,
+      JsonValue: fil.formatJsonValueError,
+      Length2: fil.formatLengthError,
+      Length16: fil.formatLengthError,
+      LessThan1: fil.formatLessThanError,
+      LessThan200: fil.formatLessThanError,
+      LessThanOrEqualTo1: fil.formatLessThanOrEqualToError,
+      Literal: fil.formatLiteralError,
+      Map: fil.formatMapError,
+      MaxLength2: fil.formatMaxLengthError,
+      MaxLength64: fil.formatMaxLengthError,
+      MaxLength100: fil.formatMaxLengthError,
+      MaxLength1000: fil.formatMaxLengthError,
+      MinLength1: fil.formatMinLengthError,
+      MinLength2: fil.formatMinLengthError,
+      MinLength8: fil.formatMinLengthError,
+      Mnemonic: fil.formatMnemonicError,
+      MultipleOf2: fil.formatMultipleOfError,
+      Name: fil.formatNameError,
+      Negative: fil.formatNegativeError,
+      NegativeDecimalString: fil.formatNegativeDecimalStringError,
+      Never: fil.formatNeverError,
+      NonNaN: fil.formatNonNaNError,
+      NonNegative: fil.formatNonNegativeError,
+      NonNegativeDecimalString: fil.formatNonNegativeDecimalStringError,
+      NonPositive: fil.formatNonPositiveError,
+      NonPositiveDecimalString: fil.formatNonPositiveDecimalStringError,
+      Number: fil.formatNumberError,
+      Object: fil.formatObjectError,
+      ObjectTag: fil.formatObjectTagError,
+      Positive: fil.formatPositiveError,
+      PositiveDecimalString: fil.formatPositiveDecimalStringError,
+      Record: fil.formatRecordError,
+      RecordKey: fil.formatRegexError,
+      Regex: fil.formatRegexError,
+      Set: fil.formatSetError,
+      String: fil.formatStringError,
+      Symbol: fil.formatSymbolError,
+      TableId: fil.formatTableIdError,
+      TemplateLiteral: fil.formatTemplateLiteralError,
+      Trimmed: fil.formatTrimmedError,
+      Tuple: fil.formatTupleError,
+      UInt64: fil.formatUInt64Error,
+      Union: fil.formatUnionError,
+      UrlSafeString: fil.formatRegexError,
+    },
+    fr: {
+      Array: fr.formatArrayError,
+      Base64Url: fr.formatBase64UrlError,
+      [Between1And2.name]: fr.formatBetweenError,
+      BigInt: fr.formatBigIntError,
+      Boolean: fr.formatBooleanError,
+      Capitalized: fr.formatCapitalizedError,
+      DateIso: fr.formatDateIsoError,
+      DateIsoFromDate: fr.formatDateIsoFromDateError,
+      DecimalString: fr.formatDecimalStringError,
+      DiscriminatedUnion: fr.formatDiscriminatedUnionError,
+      EvoluType: fr.formatEvoluTypeError,
+      Finite: fr.formatFiniteError,
+      Function: fr.formatFunctionError,
+      GreaterThan1: fr.formatGreaterThanError,
+      GreaterThanOrEqualTo1: fr.formatGreaterThanOrEqualToError,
+      Id: fr.formatIdError,
+      InstanceOf: fr.formatInstanceOfError,
+      Int: fr.formatIntError,
+      Int64: fr.formatInt64Error,
+      Int64String: fr.formatInt64StringError,
+      Json: fr.formatJsonError,
+      JsonValue: fr.formatJsonValueError,
+      Length2: fr.formatLengthError,
+      Length16: fr.formatLengthError,
+      LessThan1: fr.formatLessThanError,
+      LessThan200: fr.formatLessThanError,
+      LessThanOrEqualTo1: fr.formatLessThanOrEqualToError,
+      Literal: fr.formatLiteralError,
+      Map: fr.formatMapError,
+      MaxLength2: fr.formatMaxLengthError,
+      MaxLength64: fr.formatMaxLengthError,
+      MaxLength100: fr.formatMaxLengthError,
+      MaxLength1000: fr.formatMaxLengthError,
+      MinLength1: fr.formatMinLengthError,
+      MinLength2: fr.formatMinLengthError,
+      MinLength8: fr.formatMinLengthError,
+      Mnemonic: fr.formatMnemonicError,
+      MultipleOf2: fr.formatMultipleOfError,
+      Name: fr.formatNameError,
+      Negative: fr.formatNegativeError,
+      NegativeDecimalString: fr.formatNegativeDecimalStringError,
+      Never: fr.formatNeverError,
+      NonNaN: fr.formatNonNaNError,
+      NonNegative: fr.formatNonNegativeError,
+      NonNegativeDecimalString: fr.formatNonNegativeDecimalStringError,
+      NonPositive: fr.formatNonPositiveError,
+      NonPositiveDecimalString: fr.formatNonPositiveDecimalStringError,
+      Number: fr.formatNumberError,
+      Object: fr.formatObjectError,
+      ObjectTag: fr.formatObjectTagError,
+      Positive: fr.formatPositiveError,
+      PositiveDecimalString: fr.formatPositiveDecimalStringError,
+      Record: fr.formatRecordError,
+      RecordKey: fr.formatRegexError,
+      Regex: fr.formatRegexError,
+      Set: fr.formatSetError,
+      String: fr.formatStringError,
+      Symbol: fr.formatSymbolError,
+      TableId: fr.formatTableIdError,
+      TemplateLiteral: fr.formatTemplateLiteralError,
+      Trimmed: fr.formatTrimmedError,
+      Tuple: fr.formatTupleError,
+      UInt64: fr.formatUInt64Error,
+      Union: fr.formatUnionError,
+      UrlSafeString: fr.formatRegexError,
+    },
+    he: {
+      Array: he.formatArrayError,
+      Base64Url: he.formatBase64UrlError,
+      [Between1And2.name]: he.formatBetweenError,
+      BigInt: he.formatBigIntError,
+      Boolean: he.formatBooleanError,
+      Capitalized: he.formatCapitalizedError,
+      DateIso: he.formatDateIsoError,
+      DateIsoFromDate: he.formatDateIsoFromDateError,
+      DecimalString: he.formatDecimalStringError,
+      DiscriminatedUnion: he.formatDiscriminatedUnionError,
+      EvoluType: he.formatEvoluTypeError,
+      Finite: he.formatFiniteError,
+      Function: he.formatFunctionError,
+      GreaterThan1: he.formatGreaterThanError,
+      GreaterThanOrEqualTo1: he.formatGreaterThanOrEqualToError,
+      Id: he.formatIdError,
+      InstanceOf: he.formatInstanceOfError,
+      Int: he.formatIntError,
+      Int64: he.formatInt64Error,
+      Int64String: he.formatInt64StringError,
+      Json: he.formatJsonError,
+      JsonValue: he.formatJsonValueError,
+      Length2: he.formatLengthError,
+      Length16: he.formatLengthError,
+      LessThan1: he.formatLessThanError,
+      LessThan200: he.formatLessThanError,
+      LessThanOrEqualTo1: he.formatLessThanOrEqualToError,
+      Literal: he.formatLiteralError,
+      Map: he.formatMapError,
+      MaxLength2: he.formatMaxLengthError,
+      MaxLength64: he.formatMaxLengthError,
+      MaxLength100: he.formatMaxLengthError,
+      MaxLength1000: he.formatMaxLengthError,
+      MinLength1: he.formatMinLengthError,
+      MinLength2: he.formatMinLengthError,
+      MinLength8: he.formatMinLengthError,
+      Mnemonic: he.formatMnemonicError,
+      MultipleOf2: he.formatMultipleOfError,
+      Name: he.formatNameError,
+      Negative: he.formatNegativeError,
+      NegativeDecimalString: he.formatNegativeDecimalStringError,
+      Never: he.formatNeverError,
+      NonNaN: he.formatNonNaNError,
+      NonNegative: he.formatNonNegativeError,
+      NonNegativeDecimalString: he.formatNonNegativeDecimalStringError,
+      NonPositive: he.formatNonPositiveError,
+      NonPositiveDecimalString: he.formatNonPositiveDecimalStringError,
+      Number: he.formatNumberError,
+      Object: he.formatObjectError,
+      ObjectTag: he.formatObjectTagError,
+      Positive: he.formatPositiveError,
+      PositiveDecimalString: he.formatPositiveDecimalStringError,
+      Record: he.formatRecordError,
+      RecordKey: he.formatRegexError,
+      Regex: he.formatRegexError,
+      Set: he.formatSetError,
+      String: he.formatStringError,
+      Symbol: he.formatSymbolError,
+      TableId: he.formatTableIdError,
+      TemplateLiteral: he.formatTemplateLiteralError,
+      Trimmed: he.formatTrimmedError,
+      Tuple: he.formatTupleError,
+      UInt64: he.formatUInt64Error,
+      Union: he.formatUnionError,
+      UrlSafeString: he.formatRegexError,
+    },
+    hi: {
+      Array: hi.formatArrayError,
+      Base64Url: hi.formatBase64UrlError,
+      [Between1And2.name]: hi.formatBetweenError,
+      BigInt: hi.formatBigIntError,
+      Boolean: hi.formatBooleanError,
+      Capitalized: hi.formatCapitalizedError,
+      DateIso: hi.formatDateIsoError,
+      DateIsoFromDate: hi.formatDateIsoFromDateError,
+      DecimalString: hi.formatDecimalStringError,
+      DiscriminatedUnion: hi.formatDiscriminatedUnionError,
+      EvoluType: hi.formatEvoluTypeError,
+      Finite: hi.formatFiniteError,
+      Function: hi.formatFunctionError,
+      GreaterThan1: hi.formatGreaterThanError,
+      GreaterThanOrEqualTo1: hi.formatGreaterThanOrEqualToError,
+      Id: hi.formatIdError,
+      InstanceOf: hi.formatInstanceOfError,
+      Int: hi.formatIntError,
+      Int64: hi.formatInt64Error,
+      Int64String: hi.formatInt64StringError,
+      Json: hi.formatJsonError,
+      JsonValue: hi.formatJsonValueError,
+      Length2: hi.formatLengthError,
+      Length16: hi.formatLengthError,
+      LessThan1: hi.formatLessThanError,
+      LessThan200: hi.formatLessThanError,
+      LessThanOrEqualTo1: hi.formatLessThanOrEqualToError,
+      Literal: hi.formatLiteralError,
+      Map: hi.formatMapError,
+      MaxLength2: hi.formatMaxLengthError,
+      MaxLength64: hi.formatMaxLengthError,
+      MaxLength100: hi.formatMaxLengthError,
+      MaxLength1000: hi.formatMaxLengthError,
+      MinLength1: hi.formatMinLengthError,
+      MinLength2: hi.formatMinLengthError,
+      MinLength8: hi.formatMinLengthError,
+      Mnemonic: hi.formatMnemonicError,
+      MultipleOf2: hi.formatMultipleOfError,
+      Name: hi.formatNameError,
+      Negative: hi.formatNegativeError,
+      NegativeDecimalString: hi.formatNegativeDecimalStringError,
+      Never: hi.formatNeverError,
+      NonNaN: hi.formatNonNaNError,
+      NonNegative: hi.formatNonNegativeError,
+      NonNegativeDecimalString: hi.formatNonNegativeDecimalStringError,
+      NonPositive: hi.formatNonPositiveError,
+      NonPositiveDecimalString: hi.formatNonPositiveDecimalStringError,
+      Number: hi.formatNumberError,
+      Object: hi.formatObjectError,
+      ObjectTag: hi.formatObjectTagError,
+      Positive: hi.formatPositiveError,
+      PositiveDecimalString: hi.formatPositiveDecimalStringError,
+      Record: hi.formatRecordError,
+      RecordKey: hi.formatRegexError,
+      Regex: hi.formatRegexError,
+      Set: hi.formatSetError,
+      String: hi.formatStringError,
+      Symbol: hi.formatSymbolError,
+      TableId: hi.formatTableIdError,
+      TemplateLiteral: hi.formatTemplateLiteralError,
+      Trimmed: hi.formatTrimmedError,
+      Tuple: hi.formatTupleError,
+      UInt64: hi.formatUInt64Error,
+      Union: hi.formatUnionError,
+      UrlSafeString: hi.formatRegexError,
+    },
+    hr: {
+      Array: hr.formatArrayError,
+      Base64Url: hr.formatBase64UrlError,
+      [Between1And2.name]: hr.formatBetweenError,
+      BigInt: hr.formatBigIntError,
+      Boolean: hr.formatBooleanError,
+      Capitalized: hr.formatCapitalizedError,
+      DateIso: hr.formatDateIsoError,
+      DateIsoFromDate: hr.formatDateIsoFromDateError,
+      DecimalString: hr.formatDecimalStringError,
+      DiscriminatedUnion: hr.formatDiscriminatedUnionError,
+      EvoluType: hr.formatEvoluTypeError,
+      Finite: hr.formatFiniteError,
+      Function: hr.formatFunctionError,
+      GreaterThan1: hr.formatGreaterThanError,
+      GreaterThanOrEqualTo1: hr.formatGreaterThanOrEqualToError,
+      Id: hr.formatIdError,
+      InstanceOf: hr.formatInstanceOfError,
+      Int: hr.formatIntError,
+      Int64: hr.formatInt64Error,
+      Int64String: hr.formatInt64StringError,
+      Json: hr.formatJsonError,
+      JsonValue: hr.formatJsonValueError,
+      Length2: hr.formatLengthError,
+      Length16: hr.formatLengthError,
+      LessThan1: hr.formatLessThanError,
+      LessThan200: hr.formatLessThanError,
+      LessThanOrEqualTo1: hr.formatLessThanOrEqualToError,
+      Literal: hr.formatLiteralError,
+      Map: hr.formatMapError,
+      MaxLength2: hr.formatMaxLengthError,
+      MaxLength64: hr.formatMaxLengthError,
+      MaxLength100: hr.formatMaxLengthError,
+      MaxLength1000: hr.formatMaxLengthError,
+      MinLength1: hr.formatMinLengthError,
+      MinLength2: hr.formatMinLengthError,
+      MinLength8: hr.formatMinLengthError,
+      Mnemonic: hr.formatMnemonicError,
+      MultipleOf2: hr.formatMultipleOfError,
+      Name: hr.formatNameError,
+      Negative: hr.formatNegativeError,
+      NegativeDecimalString: hr.formatNegativeDecimalStringError,
+      Never: hr.formatNeverError,
+      NonNaN: hr.formatNonNaNError,
+      NonNegative: hr.formatNonNegativeError,
+      NonNegativeDecimalString: hr.formatNonNegativeDecimalStringError,
+      NonPositive: hr.formatNonPositiveError,
+      NonPositiveDecimalString: hr.formatNonPositiveDecimalStringError,
+      Number: hr.formatNumberError,
+      Object: hr.formatObjectError,
+      ObjectTag: hr.formatObjectTagError,
+      Positive: hr.formatPositiveError,
+      PositiveDecimalString: hr.formatPositiveDecimalStringError,
+      Record: hr.formatRecordError,
+      RecordKey: hr.formatRegexError,
+      Regex: hr.formatRegexError,
+      Set: hr.formatSetError,
+      String: hr.formatStringError,
+      Symbol: hr.formatSymbolError,
+      TableId: hr.formatTableIdError,
+      TemplateLiteral: hr.formatTemplateLiteralError,
+      Trimmed: hr.formatTrimmedError,
+      Tuple: hr.formatTupleError,
+      UInt64: hr.formatUInt64Error,
+      Union: hr.formatUnionError,
+      UrlSafeString: hr.formatRegexError,
+    },
+    hu: {
+      Array: hu.formatArrayError,
+      Base64Url: hu.formatBase64UrlError,
+      [Between1And2.name]: hu.formatBetweenError,
+      BigInt: hu.formatBigIntError,
+      Boolean: hu.formatBooleanError,
+      Capitalized: hu.formatCapitalizedError,
+      DateIso: hu.formatDateIsoError,
+      DateIsoFromDate: hu.formatDateIsoFromDateError,
+      DecimalString: hu.formatDecimalStringError,
+      DiscriminatedUnion: hu.formatDiscriminatedUnionError,
+      EvoluType: hu.formatEvoluTypeError,
+      Finite: hu.formatFiniteError,
+      Function: hu.formatFunctionError,
+      GreaterThan1: hu.formatGreaterThanError,
+      GreaterThanOrEqualTo1: hu.formatGreaterThanOrEqualToError,
+      Id: hu.formatIdError,
+      InstanceOf: hu.formatInstanceOfError,
+      Int: hu.formatIntError,
+      Int64: hu.formatInt64Error,
+      Int64String: hu.formatInt64StringError,
+      Json: hu.formatJsonError,
+      JsonValue: hu.formatJsonValueError,
+      Length2: hu.formatLengthError,
+      Length16: hu.formatLengthError,
+      LessThan1: hu.formatLessThanError,
+      LessThan200: hu.formatLessThanError,
+      LessThanOrEqualTo1: hu.formatLessThanOrEqualToError,
+      Literal: hu.formatLiteralError,
+      Map: hu.formatMapError,
+      MaxLength2: hu.formatMaxLengthError,
+      MaxLength64: hu.formatMaxLengthError,
+      MaxLength100: hu.formatMaxLengthError,
+      MaxLength1000: hu.formatMaxLengthError,
+      MinLength1: hu.formatMinLengthError,
+      MinLength2: hu.formatMinLengthError,
+      MinLength8: hu.formatMinLengthError,
+      Mnemonic: hu.formatMnemonicError,
+      MultipleOf2: hu.formatMultipleOfError,
+      Name: hu.formatNameError,
+      Negative: hu.formatNegativeError,
+      NegativeDecimalString: hu.formatNegativeDecimalStringError,
+      Never: hu.formatNeverError,
+      NonNaN: hu.formatNonNaNError,
+      NonNegative: hu.formatNonNegativeError,
+      NonNegativeDecimalString: hu.formatNonNegativeDecimalStringError,
+      NonPositive: hu.formatNonPositiveError,
+      NonPositiveDecimalString: hu.formatNonPositiveDecimalStringError,
+      Number: hu.formatNumberError,
+      Object: hu.formatObjectError,
+      ObjectTag: hu.formatObjectTagError,
+      Positive: hu.formatPositiveError,
+      PositiveDecimalString: hu.formatPositiveDecimalStringError,
+      Record: hu.formatRecordError,
+      RecordKey: hu.formatRegexError,
+      Regex: hu.formatRegexError,
+      Set: hu.formatSetError,
+      String: hu.formatStringError,
+      Symbol: hu.formatSymbolError,
+      TableId: hu.formatTableIdError,
+      TemplateLiteral: hu.formatTemplateLiteralError,
+      Trimmed: hu.formatTrimmedError,
+      Tuple: hu.formatTupleError,
+      UInt64: hu.formatUInt64Error,
+      Union: hu.formatUnionError,
+      UrlSafeString: hu.formatRegexError,
+    },
+    id: {
+      Array: id.formatArrayError,
+      Base64Url: id.formatBase64UrlError,
+      [Between1And2.name]: id.formatBetweenError,
+      BigInt: id.formatBigIntError,
+      Boolean: id.formatBooleanError,
+      Capitalized: id.formatCapitalizedError,
+      DateIso: id.formatDateIsoError,
+      DateIsoFromDate: id.formatDateIsoFromDateError,
+      DecimalString: id.formatDecimalStringError,
+      DiscriminatedUnion: id.formatDiscriminatedUnionError,
+      EvoluType: id.formatEvoluTypeError,
+      Finite: id.formatFiniteError,
+      Function: id.formatFunctionError,
+      GreaterThan1: id.formatGreaterThanError,
+      GreaterThanOrEqualTo1: id.formatGreaterThanOrEqualToError,
+      Id: id.formatIdError,
+      InstanceOf: id.formatInstanceOfError,
+      Int: id.formatIntError,
+      Int64: id.formatInt64Error,
+      Int64String: id.formatInt64StringError,
+      Json: id.formatJsonError,
+      JsonValue: id.formatJsonValueError,
+      Length2: id.formatLengthError,
+      Length16: id.formatLengthError,
+      LessThan1: id.formatLessThanError,
+      LessThan200: id.formatLessThanError,
+      LessThanOrEqualTo1: id.formatLessThanOrEqualToError,
+      Literal: id.formatLiteralError,
+      Map: id.formatMapError,
+      MaxLength2: id.formatMaxLengthError,
+      MaxLength64: id.formatMaxLengthError,
+      MaxLength100: id.formatMaxLengthError,
+      MaxLength1000: id.formatMaxLengthError,
+      MinLength1: id.formatMinLengthError,
+      MinLength2: id.formatMinLengthError,
+      MinLength8: id.formatMinLengthError,
+      Mnemonic: id.formatMnemonicError,
+      MultipleOf2: id.formatMultipleOfError,
+      Name: id.formatNameError,
+      Negative: id.formatNegativeError,
+      NegativeDecimalString: id.formatNegativeDecimalStringError,
+      Never: id.formatNeverError,
+      NonNaN: id.formatNonNaNError,
+      NonNegative: id.formatNonNegativeError,
+      NonNegativeDecimalString: id.formatNonNegativeDecimalStringError,
+      NonPositive: id.formatNonPositiveError,
+      NonPositiveDecimalString: id.formatNonPositiveDecimalStringError,
+      Number: id.formatNumberError,
+      Object: id.formatObjectError,
+      ObjectTag: id.formatObjectTagError,
+      Positive: id.formatPositiveError,
+      PositiveDecimalString: id.formatPositiveDecimalStringError,
+      Record: id.formatRecordError,
+      RecordKey: id.formatRegexError,
+      Regex: id.formatRegexError,
+      Set: id.formatSetError,
+      String: id.formatStringError,
+      Symbol: id.formatSymbolError,
+      TableId: id.formatTableIdError,
+      TemplateLiteral: id.formatTemplateLiteralError,
+      Trimmed: id.formatTrimmedError,
+      Tuple: id.formatTupleError,
+      UInt64: id.formatUInt64Error,
+      Union: id.formatUnionError,
+      UrlSafeString: id.formatRegexError,
+    },
+    it: {
+      Array: it.formatArrayError,
+      Base64Url: it.formatBase64UrlError,
+      [Between1And2.name]: it.formatBetweenError,
+      BigInt: it.formatBigIntError,
+      Boolean: it.formatBooleanError,
+      Capitalized: it.formatCapitalizedError,
+      DateIso: it.formatDateIsoError,
+      DateIsoFromDate: it.formatDateIsoFromDateError,
+      DecimalString: it.formatDecimalStringError,
+      DiscriminatedUnion: it.formatDiscriminatedUnionError,
+      EvoluType: it.formatEvoluTypeError,
+      Finite: it.formatFiniteError,
+      Function: it.formatFunctionError,
+      GreaterThan1: it.formatGreaterThanError,
+      GreaterThanOrEqualTo1: it.formatGreaterThanOrEqualToError,
+      Id: it.formatIdError,
+      InstanceOf: it.formatInstanceOfError,
+      Int: it.formatIntError,
+      Int64: it.formatInt64Error,
+      Int64String: it.formatInt64StringError,
+      Json: it.formatJsonError,
+      JsonValue: it.formatJsonValueError,
+      Length2: it.formatLengthError,
+      Length16: it.formatLengthError,
+      LessThan1: it.formatLessThanError,
+      LessThan200: it.formatLessThanError,
+      LessThanOrEqualTo1: it.formatLessThanOrEqualToError,
+      Literal: it.formatLiteralError,
+      Map: it.formatMapError,
+      MaxLength2: it.formatMaxLengthError,
+      MaxLength64: it.formatMaxLengthError,
+      MaxLength100: it.formatMaxLengthError,
+      MaxLength1000: it.formatMaxLengthError,
+      MinLength1: it.formatMinLengthError,
+      MinLength2: it.formatMinLengthError,
+      MinLength8: it.formatMinLengthError,
+      Mnemonic: it.formatMnemonicError,
+      MultipleOf2: it.formatMultipleOfError,
+      Name: it.formatNameError,
+      Negative: it.formatNegativeError,
+      NegativeDecimalString: it.formatNegativeDecimalStringError,
+      Never: it.formatNeverError,
+      NonNaN: it.formatNonNaNError,
+      NonNegative: it.formatNonNegativeError,
+      NonNegativeDecimalString: it.formatNonNegativeDecimalStringError,
+      NonPositive: it.formatNonPositiveError,
+      NonPositiveDecimalString: it.formatNonPositiveDecimalStringError,
+      Number: it.formatNumberError,
+      Object: it.formatObjectError,
+      ObjectTag: it.formatObjectTagError,
+      Positive: it.formatPositiveError,
+      PositiveDecimalString: it.formatPositiveDecimalStringError,
+      Record: it.formatRecordError,
+      RecordKey: it.formatRegexError,
+      Regex: it.formatRegexError,
+      Set: it.formatSetError,
+      String: it.formatStringError,
+      Symbol: it.formatSymbolError,
+      TableId: it.formatTableIdError,
+      TemplateLiteral: it.formatTemplateLiteralError,
+      Trimmed: it.formatTrimmedError,
+      Tuple: it.formatTupleError,
+      UInt64: it.formatUInt64Error,
+      Union: it.formatUnionError,
+      UrlSafeString: it.formatRegexError,
+    },
+    ja: {
+      Array: ja.formatArrayError,
+      Base64Url: ja.formatBase64UrlError,
+      [Between1And2.name]: ja.formatBetweenError,
+      BigInt: ja.formatBigIntError,
+      Boolean: ja.formatBooleanError,
+      Capitalized: ja.formatCapitalizedError,
+      DateIso: ja.formatDateIsoError,
+      DateIsoFromDate: ja.formatDateIsoFromDateError,
+      DecimalString: ja.formatDecimalStringError,
+      DiscriminatedUnion: ja.formatDiscriminatedUnionError,
+      EvoluType: ja.formatEvoluTypeError,
+      Finite: ja.formatFiniteError,
+      Function: ja.formatFunctionError,
+      GreaterThan1: ja.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ja.formatGreaterThanOrEqualToError,
+      Id: ja.formatIdError,
+      InstanceOf: ja.formatInstanceOfError,
+      Int: ja.formatIntError,
+      Int64: ja.formatInt64Error,
+      Int64String: ja.formatInt64StringError,
+      Json: ja.formatJsonError,
+      JsonValue: ja.formatJsonValueError,
+      Length2: ja.formatLengthError,
+      Length16: ja.formatLengthError,
+      LessThan1: ja.formatLessThanError,
+      LessThan200: ja.formatLessThanError,
+      LessThanOrEqualTo1: ja.formatLessThanOrEqualToError,
+      Literal: ja.formatLiteralError,
+      Map: ja.formatMapError,
+      MaxLength2: ja.formatMaxLengthError,
+      MaxLength64: ja.formatMaxLengthError,
+      MaxLength100: ja.formatMaxLengthError,
+      MaxLength1000: ja.formatMaxLengthError,
+      MinLength1: ja.formatMinLengthError,
+      MinLength2: ja.formatMinLengthError,
+      MinLength8: ja.formatMinLengthError,
+      Mnemonic: ja.formatMnemonicError,
+      MultipleOf2: ja.formatMultipleOfError,
+      Name: ja.formatNameError,
+      Negative: ja.formatNegativeError,
+      NegativeDecimalString: ja.formatNegativeDecimalStringError,
+      Never: ja.formatNeverError,
+      NonNaN: ja.formatNonNaNError,
+      NonNegative: ja.formatNonNegativeError,
+      NonNegativeDecimalString: ja.formatNonNegativeDecimalStringError,
+      NonPositive: ja.formatNonPositiveError,
+      NonPositiveDecimalString: ja.formatNonPositiveDecimalStringError,
+      Number: ja.formatNumberError,
+      Object: ja.formatObjectError,
+      ObjectTag: ja.formatObjectTagError,
+      Positive: ja.formatPositiveError,
+      PositiveDecimalString: ja.formatPositiveDecimalStringError,
+      Record: ja.formatRecordError,
+      RecordKey: ja.formatRegexError,
+      Regex: ja.formatRegexError,
+      Set: ja.formatSetError,
+      String: ja.formatStringError,
+      Symbol: ja.formatSymbolError,
+      TableId: ja.formatTableIdError,
+      TemplateLiteral: ja.formatTemplateLiteralError,
+      Trimmed: ja.formatTrimmedError,
+      Tuple: ja.formatTupleError,
+      UInt64: ja.formatUInt64Error,
+      Union: ja.formatUnionError,
+      UrlSafeString: ja.formatRegexError,
+    },
+    ko: {
+      Array: ko.formatArrayError,
+      Base64Url: ko.formatBase64UrlError,
+      [Between1And2.name]: ko.formatBetweenError,
+      BigInt: ko.formatBigIntError,
+      Boolean: ko.formatBooleanError,
+      Capitalized: ko.formatCapitalizedError,
+      DateIso: ko.formatDateIsoError,
+      DateIsoFromDate: ko.formatDateIsoFromDateError,
+      DecimalString: ko.formatDecimalStringError,
+      DiscriminatedUnion: ko.formatDiscriminatedUnionError,
+      EvoluType: ko.formatEvoluTypeError,
+      Finite: ko.formatFiniteError,
+      Function: ko.formatFunctionError,
+      GreaterThan1: ko.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ko.formatGreaterThanOrEqualToError,
+      Id: ko.formatIdError,
+      InstanceOf: ko.formatInstanceOfError,
+      Int: ko.formatIntError,
+      Int64: ko.formatInt64Error,
+      Int64String: ko.formatInt64StringError,
+      Json: ko.formatJsonError,
+      JsonValue: ko.formatJsonValueError,
+      Length2: ko.formatLengthError,
+      Length16: ko.formatLengthError,
+      LessThan1: ko.formatLessThanError,
+      LessThan200: ko.formatLessThanError,
+      LessThanOrEqualTo1: ko.formatLessThanOrEqualToError,
+      Literal: ko.formatLiteralError,
+      Map: ko.formatMapError,
+      MaxLength2: ko.formatMaxLengthError,
+      MaxLength64: ko.formatMaxLengthError,
+      MaxLength100: ko.formatMaxLengthError,
+      MaxLength1000: ko.formatMaxLengthError,
+      MinLength1: ko.formatMinLengthError,
+      MinLength2: ko.formatMinLengthError,
+      MinLength8: ko.formatMinLengthError,
+      Mnemonic: ko.formatMnemonicError,
+      MultipleOf2: ko.formatMultipleOfError,
+      Name: ko.formatNameError,
+      Negative: ko.formatNegativeError,
+      NegativeDecimalString: ko.formatNegativeDecimalStringError,
+      Never: ko.formatNeverError,
+      NonNaN: ko.formatNonNaNError,
+      NonNegative: ko.formatNonNegativeError,
+      NonNegativeDecimalString: ko.formatNonNegativeDecimalStringError,
+      NonPositive: ko.formatNonPositiveError,
+      NonPositiveDecimalString: ko.formatNonPositiveDecimalStringError,
+      Number: ko.formatNumberError,
+      Object: ko.formatObjectError,
+      ObjectTag: ko.formatObjectTagError,
+      Positive: ko.formatPositiveError,
+      PositiveDecimalString: ko.formatPositiveDecimalStringError,
+      Record: ko.formatRecordError,
+      RecordKey: ko.formatRegexError,
+      Regex: ko.formatRegexError,
+      Set: ko.formatSetError,
+      String: ko.formatStringError,
+      Symbol: ko.formatSymbolError,
+      TableId: ko.formatTableIdError,
+      TemplateLiteral: ko.formatTemplateLiteralError,
+      Trimmed: ko.formatTrimmedError,
+      Tuple: ko.formatTupleError,
+      UInt64: ko.formatUInt64Error,
+      Union: ko.formatUnionError,
+      UrlSafeString: ko.formatRegexError,
+    },
+    ml: {
+      Array: ml.formatArrayError,
+      Base64Url: ml.formatBase64UrlError,
+      [Between1And2.name]: ml.formatBetweenError,
+      BigInt: ml.formatBigIntError,
+      Boolean: ml.formatBooleanError,
+      Capitalized: ml.formatCapitalizedError,
+      DateIso: ml.formatDateIsoError,
+      DateIsoFromDate: ml.formatDateIsoFromDateError,
+      DecimalString: ml.formatDecimalStringError,
+      DiscriminatedUnion: ml.formatDiscriminatedUnionError,
+      EvoluType: ml.formatEvoluTypeError,
+      Finite: ml.formatFiniteError,
+      Function: ml.formatFunctionError,
+      GreaterThan1: ml.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ml.formatGreaterThanOrEqualToError,
+      Id: ml.formatIdError,
+      InstanceOf: ml.formatInstanceOfError,
+      Int: ml.formatIntError,
+      Int64: ml.formatInt64Error,
+      Int64String: ml.formatInt64StringError,
+      Json: ml.formatJsonError,
+      JsonValue: ml.formatJsonValueError,
+      Length2: ml.formatLengthError,
+      Length16: ml.formatLengthError,
+      LessThan1: ml.formatLessThanError,
+      LessThan200: ml.formatLessThanError,
+      LessThanOrEqualTo1: ml.formatLessThanOrEqualToError,
+      Literal: ml.formatLiteralError,
+      Map: ml.formatMapError,
+      MaxLength2: ml.formatMaxLengthError,
+      MaxLength64: ml.formatMaxLengthError,
+      MaxLength100: ml.formatMaxLengthError,
+      MaxLength1000: ml.formatMaxLengthError,
+      MinLength1: ml.formatMinLengthError,
+      MinLength2: ml.formatMinLengthError,
+      MinLength8: ml.formatMinLengthError,
+      Mnemonic: ml.formatMnemonicError,
+      MultipleOf2: ml.formatMultipleOfError,
+      Name: ml.formatNameError,
+      Negative: ml.formatNegativeError,
+      NegativeDecimalString: ml.formatNegativeDecimalStringError,
+      Never: ml.formatNeverError,
+      NonNaN: ml.formatNonNaNError,
+      NonNegative: ml.formatNonNegativeError,
+      NonNegativeDecimalString: ml.formatNonNegativeDecimalStringError,
+      NonPositive: ml.formatNonPositiveError,
+      NonPositiveDecimalString: ml.formatNonPositiveDecimalStringError,
+      Number: ml.formatNumberError,
+      Object: ml.formatObjectError,
+      ObjectTag: ml.formatObjectTagError,
+      Positive: ml.formatPositiveError,
+      PositiveDecimalString: ml.formatPositiveDecimalStringError,
+      Record: ml.formatRecordError,
+      RecordKey: ml.formatRegexError,
+      Regex: ml.formatRegexError,
+      Set: ml.formatSetError,
+      String: ml.formatStringError,
+      Symbol: ml.formatSymbolError,
+      TableId: ml.formatTableIdError,
+      TemplateLiteral: ml.formatTemplateLiteralError,
+      Trimmed: ml.formatTrimmedError,
+      Tuple: ml.formatTupleError,
+      UInt64: ml.formatUInt64Error,
+      Union: ml.formatUnionError,
+      UrlSafeString: ml.formatRegexError,
+    },
+    mr: {
+      Array: mr.formatArrayError,
+      Base64Url: mr.formatBase64UrlError,
+      [Between1And2.name]: mr.formatBetweenError,
+      BigInt: mr.formatBigIntError,
+      Boolean: mr.formatBooleanError,
+      Capitalized: mr.formatCapitalizedError,
+      DateIso: mr.formatDateIsoError,
+      DateIsoFromDate: mr.formatDateIsoFromDateError,
+      DecimalString: mr.formatDecimalStringError,
+      DiscriminatedUnion: mr.formatDiscriminatedUnionError,
+      EvoluType: mr.formatEvoluTypeError,
+      Finite: mr.formatFiniteError,
+      Function: mr.formatFunctionError,
+      GreaterThan1: mr.formatGreaterThanError,
+      GreaterThanOrEqualTo1: mr.formatGreaterThanOrEqualToError,
+      Id: mr.formatIdError,
+      InstanceOf: mr.formatInstanceOfError,
+      Int: mr.formatIntError,
+      Int64: mr.formatInt64Error,
+      Int64String: mr.formatInt64StringError,
+      Json: mr.formatJsonError,
+      JsonValue: mr.formatJsonValueError,
+      Length2: mr.formatLengthError,
+      Length16: mr.formatLengthError,
+      LessThan1: mr.formatLessThanError,
+      LessThan200: mr.formatLessThanError,
+      LessThanOrEqualTo1: mr.formatLessThanOrEqualToError,
+      Literal: mr.formatLiteralError,
+      Map: mr.formatMapError,
+      MaxLength2: mr.formatMaxLengthError,
+      MaxLength64: mr.formatMaxLengthError,
+      MaxLength100: mr.formatMaxLengthError,
+      MaxLength1000: mr.formatMaxLengthError,
+      MinLength1: mr.formatMinLengthError,
+      MinLength2: mr.formatMinLengthError,
+      MinLength8: mr.formatMinLengthError,
+      Mnemonic: mr.formatMnemonicError,
+      MultipleOf2: mr.formatMultipleOfError,
+      Name: mr.formatNameError,
+      Negative: mr.formatNegativeError,
+      NegativeDecimalString: mr.formatNegativeDecimalStringError,
+      Never: mr.formatNeverError,
+      NonNaN: mr.formatNonNaNError,
+      NonNegative: mr.formatNonNegativeError,
+      NonNegativeDecimalString: mr.formatNonNegativeDecimalStringError,
+      NonPositive: mr.formatNonPositiveError,
+      NonPositiveDecimalString: mr.formatNonPositiveDecimalStringError,
+      Number: mr.formatNumberError,
+      Object: mr.formatObjectError,
+      ObjectTag: mr.formatObjectTagError,
+      Positive: mr.formatPositiveError,
+      PositiveDecimalString: mr.formatPositiveDecimalStringError,
+      Record: mr.formatRecordError,
+      RecordKey: mr.formatRegexError,
+      Regex: mr.formatRegexError,
+      Set: mr.formatSetError,
+      String: mr.formatStringError,
+      Symbol: mr.formatSymbolError,
+      TableId: mr.formatTableIdError,
+      TemplateLiteral: mr.formatTemplateLiteralError,
+      Trimmed: mr.formatTrimmedError,
+      Tuple: mr.formatTupleError,
+      UInt64: mr.formatUInt64Error,
+      Union: mr.formatUnionError,
+      UrlSafeString: mr.formatRegexError,
+    },
+    ms: {
+      Array: ms.formatArrayError,
+      Base64Url: ms.formatBase64UrlError,
+      [Between1And2.name]: ms.formatBetweenError,
+      BigInt: ms.formatBigIntError,
+      Boolean: ms.formatBooleanError,
+      Capitalized: ms.formatCapitalizedError,
+      DateIso: ms.formatDateIsoError,
+      DateIsoFromDate: ms.formatDateIsoFromDateError,
+      DecimalString: ms.formatDecimalStringError,
+      DiscriminatedUnion: ms.formatDiscriminatedUnionError,
+      EvoluType: ms.formatEvoluTypeError,
+      Finite: ms.formatFiniteError,
+      Function: ms.formatFunctionError,
+      GreaterThan1: ms.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ms.formatGreaterThanOrEqualToError,
+      Id: ms.formatIdError,
+      InstanceOf: ms.formatInstanceOfError,
+      Int: ms.formatIntError,
+      Int64: ms.formatInt64Error,
+      Int64String: ms.formatInt64StringError,
+      Json: ms.formatJsonError,
+      JsonValue: ms.formatJsonValueError,
+      Length2: ms.formatLengthError,
+      Length16: ms.formatLengthError,
+      LessThan1: ms.formatLessThanError,
+      LessThan200: ms.formatLessThanError,
+      LessThanOrEqualTo1: ms.formatLessThanOrEqualToError,
+      Literal: ms.formatLiteralError,
+      Map: ms.formatMapError,
+      MaxLength2: ms.formatMaxLengthError,
+      MaxLength64: ms.formatMaxLengthError,
+      MaxLength100: ms.formatMaxLengthError,
+      MaxLength1000: ms.formatMaxLengthError,
+      MinLength1: ms.formatMinLengthError,
+      MinLength2: ms.formatMinLengthError,
+      MinLength8: ms.formatMinLengthError,
+      Mnemonic: ms.formatMnemonicError,
+      MultipleOf2: ms.formatMultipleOfError,
+      Name: ms.formatNameError,
+      Negative: ms.formatNegativeError,
+      NegativeDecimalString: ms.formatNegativeDecimalStringError,
+      Never: ms.formatNeverError,
+      NonNaN: ms.formatNonNaNError,
+      NonNegative: ms.formatNonNegativeError,
+      NonNegativeDecimalString: ms.formatNonNegativeDecimalStringError,
+      NonPositive: ms.formatNonPositiveError,
+      NonPositiveDecimalString: ms.formatNonPositiveDecimalStringError,
+      Number: ms.formatNumberError,
+      Object: ms.formatObjectError,
+      ObjectTag: ms.formatObjectTagError,
+      Positive: ms.formatPositiveError,
+      PositiveDecimalString: ms.formatPositiveDecimalStringError,
+      Record: ms.formatRecordError,
+      RecordKey: ms.formatRegexError,
+      Regex: ms.formatRegexError,
+      Set: ms.formatSetError,
+      String: ms.formatStringError,
+      Symbol: ms.formatSymbolError,
+      TableId: ms.formatTableIdError,
+      TemplateLiteral: ms.formatTemplateLiteralError,
+      Trimmed: ms.formatTrimmedError,
+      Tuple: ms.formatTupleError,
+      UInt64: ms.formatUInt64Error,
+      Union: ms.formatUnionError,
+      UrlSafeString: ms.formatRegexError,
+    },
+    nb: {
+      Array: nb.formatArrayError,
+      Base64Url: nb.formatBase64UrlError,
+      [Between1And2.name]: nb.formatBetweenError,
+      BigInt: nb.formatBigIntError,
+      Boolean: nb.formatBooleanError,
+      Capitalized: nb.formatCapitalizedError,
+      DateIso: nb.formatDateIsoError,
+      DateIsoFromDate: nb.formatDateIsoFromDateError,
+      DecimalString: nb.formatDecimalStringError,
+      DiscriminatedUnion: nb.formatDiscriminatedUnionError,
+      EvoluType: nb.formatEvoluTypeError,
+      Finite: nb.formatFiniteError,
+      Function: nb.formatFunctionError,
+      GreaterThan1: nb.formatGreaterThanError,
+      GreaterThanOrEqualTo1: nb.formatGreaterThanOrEqualToError,
+      Id: nb.formatIdError,
+      InstanceOf: nb.formatInstanceOfError,
+      Int: nb.formatIntError,
+      Int64: nb.formatInt64Error,
+      Int64String: nb.formatInt64StringError,
+      Json: nb.formatJsonError,
+      JsonValue: nb.formatJsonValueError,
+      Length2: nb.formatLengthError,
+      Length16: nb.formatLengthError,
+      LessThan1: nb.formatLessThanError,
+      LessThan200: nb.formatLessThanError,
+      LessThanOrEqualTo1: nb.formatLessThanOrEqualToError,
+      Literal: nb.formatLiteralError,
+      Map: nb.formatMapError,
+      MaxLength2: nb.formatMaxLengthError,
+      MaxLength64: nb.formatMaxLengthError,
+      MaxLength100: nb.formatMaxLengthError,
+      MaxLength1000: nb.formatMaxLengthError,
+      MinLength1: nb.formatMinLengthError,
+      MinLength2: nb.formatMinLengthError,
+      MinLength8: nb.formatMinLengthError,
+      Mnemonic: nb.formatMnemonicError,
+      MultipleOf2: nb.formatMultipleOfError,
+      Name: nb.formatNameError,
+      Negative: nb.formatNegativeError,
+      NegativeDecimalString: nb.formatNegativeDecimalStringError,
+      Never: nb.formatNeverError,
+      NonNaN: nb.formatNonNaNError,
+      NonNegative: nb.formatNonNegativeError,
+      NonNegativeDecimalString: nb.formatNonNegativeDecimalStringError,
+      NonPositive: nb.formatNonPositiveError,
+      NonPositiveDecimalString: nb.formatNonPositiveDecimalStringError,
+      Number: nb.formatNumberError,
+      Object: nb.formatObjectError,
+      ObjectTag: nb.formatObjectTagError,
+      Positive: nb.formatPositiveError,
+      PositiveDecimalString: nb.formatPositiveDecimalStringError,
+      Record: nb.formatRecordError,
+      RecordKey: nb.formatRegexError,
+      Regex: nb.formatRegexError,
+      Set: nb.formatSetError,
+      String: nb.formatStringError,
+      Symbol: nb.formatSymbolError,
+      TableId: nb.formatTableIdError,
+      TemplateLiteral: nb.formatTemplateLiteralError,
+      Trimmed: nb.formatTrimmedError,
+      Tuple: nb.formatTupleError,
+      UInt64: nb.formatUInt64Error,
+      Union: nb.formatUnionError,
+      UrlSafeString: nb.formatRegexError,
+    },
+    nl: {
+      Array: nl.formatArrayError,
+      Base64Url: nl.formatBase64UrlError,
+      [Between1And2.name]: nl.formatBetweenError,
+      BigInt: nl.formatBigIntError,
+      Boolean: nl.formatBooleanError,
+      Capitalized: nl.formatCapitalizedError,
+      DateIso: nl.formatDateIsoError,
+      DateIsoFromDate: nl.formatDateIsoFromDateError,
+      DecimalString: nl.formatDecimalStringError,
+      DiscriminatedUnion: nl.formatDiscriminatedUnionError,
+      EvoluType: nl.formatEvoluTypeError,
+      Finite: nl.formatFiniteError,
+      Function: nl.formatFunctionError,
+      GreaterThan1: nl.formatGreaterThanError,
+      GreaterThanOrEqualTo1: nl.formatGreaterThanOrEqualToError,
+      Id: nl.formatIdError,
+      InstanceOf: nl.formatInstanceOfError,
+      Int: nl.formatIntError,
+      Int64: nl.formatInt64Error,
+      Int64String: nl.formatInt64StringError,
+      Json: nl.formatJsonError,
+      JsonValue: nl.formatJsonValueError,
+      Length2: nl.formatLengthError,
+      Length16: nl.formatLengthError,
+      LessThan1: nl.formatLessThanError,
+      LessThan200: nl.formatLessThanError,
+      LessThanOrEqualTo1: nl.formatLessThanOrEqualToError,
+      Literal: nl.formatLiteralError,
+      Map: nl.formatMapError,
+      MaxLength2: nl.formatMaxLengthError,
+      MaxLength64: nl.formatMaxLengthError,
+      MaxLength100: nl.formatMaxLengthError,
+      MaxLength1000: nl.formatMaxLengthError,
+      MinLength1: nl.formatMinLengthError,
+      MinLength2: nl.formatMinLengthError,
+      MinLength8: nl.formatMinLengthError,
+      Mnemonic: nl.formatMnemonicError,
+      MultipleOf2: nl.formatMultipleOfError,
+      Name: nl.formatNameError,
+      Negative: nl.formatNegativeError,
+      NegativeDecimalString: nl.formatNegativeDecimalStringError,
+      Never: nl.formatNeverError,
+      NonNaN: nl.formatNonNaNError,
+      NonNegative: nl.formatNonNegativeError,
+      NonNegativeDecimalString: nl.formatNonNegativeDecimalStringError,
+      NonPositive: nl.formatNonPositiveError,
+      NonPositiveDecimalString: nl.formatNonPositiveDecimalStringError,
+      Number: nl.formatNumberError,
+      Object: nl.formatObjectError,
+      ObjectTag: nl.formatObjectTagError,
+      Positive: nl.formatPositiveError,
+      PositiveDecimalString: nl.formatPositiveDecimalStringError,
+      Record: nl.formatRecordError,
+      RecordKey: nl.formatRegexError,
+      Regex: nl.formatRegexError,
+      Set: nl.formatSetError,
+      String: nl.formatStringError,
+      Symbol: nl.formatSymbolError,
+      TableId: nl.formatTableIdError,
+      TemplateLiteral: nl.formatTemplateLiteralError,
+      Trimmed: nl.formatTrimmedError,
+      Tuple: nl.formatTupleError,
+      UInt64: nl.formatUInt64Error,
+      Union: nl.formatUnionError,
+      UrlSafeString: nl.formatRegexError,
+    },
+    pa: {
+      Array: pa.formatArrayError,
+      Base64Url: pa.formatBase64UrlError,
+      [Between1And2.name]: pa.formatBetweenError,
+      BigInt: pa.formatBigIntError,
+      Boolean: pa.formatBooleanError,
+      Capitalized: pa.formatCapitalizedError,
+      DateIso: pa.formatDateIsoError,
+      DateIsoFromDate: pa.formatDateIsoFromDateError,
+      DecimalString: pa.formatDecimalStringError,
+      DiscriminatedUnion: pa.formatDiscriminatedUnionError,
+      EvoluType: pa.formatEvoluTypeError,
+      Finite: pa.formatFiniteError,
+      Function: pa.formatFunctionError,
+      GreaterThan1: pa.formatGreaterThanError,
+      GreaterThanOrEqualTo1: pa.formatGreaterThanOrEqualToError,
+      Id: pa.formatIdError,
+      InstanceOf: pa.formatInstanceOfError,
+      Int: pa.formatIntError,
+      Int64: pa.formatInt64Error,
+      Int64String: pa.formatInt64StringError,
+      Json: pa.formatJsonError,
+      JsonValue: pa.formatJsonValueError,
+      Length2: pa.formatLengthError,
+      Length16: pa.formatLengthError,
+      LessThan1: pa.formatLessThanError,
+      LessThan200: pa.formatLessThanError,
+      LessThanOrEqualTo1: pa.formatLessThanOrEqualToError,
+      Literal: pa.formatLiteralError,
+      Map: pa.formatMapError,
+      MaxLength2: pa.formatMaxLengthError,
+      MaxLength64: pa.formatMaxLengthError,
+      MaxLength100: pa.formatMaxLengthError,
+      MaxLength1000: pa.formatMaxLengthError,
+      MinLength1: pa.formatMinLengthError,
+      MinLength2: pa.formatMinLengthError,
+      MinLength8: pa.formatMinLengthError,
+      Mnemonic: pa.formatMnemonicError,
+      MultipleOf2: pa.formatMultipleOfError,
+      Name: pa.formatNameError,
+      Negative: pa.formatNegativeError,
+      NegativeDecimalString: pa.formatNegativeDecimalStringError,
+      Never: pa.formatNeverError,
+      NonNaN: pa.formatNonNaNError,
+      NonNegative: pa.formatNonNegativeError,
+      NonNegativeDecimalString: pa.formatNonNegativeDecimalStringError,
+      NonPositive: pa.formatNonPositiveError,
+      NonPositiveDecimalString: pa.formatNonPositiveDecimalStringError,
+      Number: pa.formatNumberError,
+      Object: pa.formatObjectError,
+      ObjectTag: pa.formatObjectTagError,
+      Positive: pa.formatPositiveError,
+      PositiveDecimalString: pa.formatPositiveDecimalStringError,
+      Record: pa.formatRecordError,
+      RecordKey: pa.formatRegexError,
+      Regex: pa.formatRegexError,
+      Set: pa.formatSetError,
+      String: pa.formatStringError,
+      Symbol: pa.formatSymbolError,
+      TableId: pa.formatTableIdError,
+      TemplateLiteral: pa.formatTemplateLiteralError,
+      Trimmed: pa.formatTrimmedError,
+      Tuple: pa.formatTupleError,
+      UInt64: pa.formatUInt64Error,
+      Union: pa.formatUnionError,
+      UrlSafeString: pa.formatRegexError,
+    },
+    pl: {
+      Array: pl.formatArrayError,
+      Base64Url: pl.formatBase64UrlError,
+      [Between1And2.name]: pl.formatBetweenError,
+      BigInt: pl.formatBigIntError,
+      Boolean: pl.formatBooleanError,
+      Capitalized: pl.formatCapitalizedError,
+      DateIso: pl.formatDateIsoError,
+      DateIsoFromDate: pl.formatDateIsoFromDateError,
+      DecimalString: pl.formatDecimalStringError,
+      DiscriminatedUnion: pl.formatDiscriminatedUnionError,
+      EvoluType: pl.formatEvoluTypeError,
+      Finite: pl.formatFiniteError,
+      Function: pl.formatFunctionError,
+      GreaterThan1: pl.formatGreaterThanError,
+      GreaterThanOrEqualTo1: pl.formatGreaterThanOrEqualToError,
+      Id: pl.formatIdError,
+      InstanceOf: pl.formatInstanceOfError,
+      Int: pl.formatIntError,
+      Int64: pl.formatInt64Error,
+      Int64String: pl.formatInt64StringError,
+      Json: pl.formatJsonError,
+      JsonValue: pl.formatJsonValueError,
+      Length2: pl.formatLengthError,
+      Length16: pl.formatLengthError,
+      LessThan1: pl.formatLessThanError,
+      LessThan200: pl.formatLessThanError,
+      LessThanOrEqualTo1: pl.formatLessThanOrEqualToError,
+      Literal: pl.formatLiteralError,
+      Map: pl.formatMapError,
+      MaxLength2: pl.formatMaxLengthError,
+      MaxLength64: pl.formatMaxLengthError,
+      MaxLength100: pl.formatMaxLengthError,
+      MaxLength1000: pl.formatMaxLengthError,
+      MinLength1: pl.formatMinLengthError,
+      MinLength2: pl.formatMinLengthError,
+      MinLength8: pl.formatMinLengthError,
+      Mnemonic: pl.formatMnemonicError,
+      MultipleOf2: pl.formatMultipleOfError,
+      Name: pl.formatNameError,
+      Negative: pl.formatNegativeError,
+      NegativeDecimalString: pl.formatNegativeDecimalStringError,
+      Never: pl.formatNeverError,
+      NonNaN: pl.formatNonNaNError,
+      NonNegative: pl.formatNonNegativeError,
+      NonNegativeDecimalString: pl.formatNonNegativeDecimalStringError,
+      NonPositive: pl.formatNonPositiveError,
+      NonPositiveDecimalString: pl.formatNonPositiveDecimalStringError,
+      Number: pl.formatNumberError,
+      Object: pl.formatObjectError,
+      ObjectTag: pl.formatObjectTagError,
+      Positive: pl.formatPositiveError,
+      PositiveDecimalString: pl.formatPositiveDecimalStringError,
+      Record: pl.formatRecordError,
+      RecordKey: pl.formatRegexError,
+      Regex: pl.formatRegexError,
+      Set: pl.formatSetError,
+      String: pl.formatStringError,
+      Symbol: pl.formatSymbolError,
+      TableId: pl.formatTableIdError,
+      TemplateLiteral: pl.formatTemplateLiteralError,
+      Trimmed: pl.formatTrimmedError,
+      Tuple: pl.formatTupleError,
+      UInt64: pl.formatUInt64Error,
+      Union: pl.formatUnionError,
+      UrlSafeString: pl.formatRegexError,
+    },
+    pt: {
+      Array: pt.formatArrayError,
+      Base64Url: pt.formatBase64UrlError,
+      [Between1And2.name]: pt.formatBetweenError,
+      BigInt: pt.formatBigIntError,
+      Boolean: pt.formatBooleanError,
+      Capitalized: pt.formatCapitalizedError,
+      DateIso: pt.formatDateIsoError,
+      DateIsoFromDate: pt.formatDateIsoFromDateError,
+      DecimalString: pt.formatDecimalStringError,
+      DiscriminatedUnion: pt.formatDiscriminatedUnionError,
+      EvoluType: pt.formatEvoluTypeError,
+      Finite: pt.formatFiniteError,
+      Function: pt.formatFunctionError,
+      GreaterThan1: pt.formatGreaterThanError,
+      GreaterThanOrEqualTo1: pt.formatGreaterThanOrEqualToError,
+      Id: pt.formatIdError,
+      InstanceOf: pt.formatInstanceOfError,
+      Int: pt.formatIntError,
+      Int64: pt.formatInt64Error,
+      Int64String: pt.formatInt64StringError,
+      Json: pt.formatJsonError,
+      JsonValue: pt.formatJsonValueError,
+      Length2: pt.formatLengthError,
+      Length16: pt.formatLengthError,
+      LessThan1: pt.formatLessThanError,
+      LessThan200: pt.formatLessThanError,
+      LessThanOrEqualTo1: pt.formatLessThanOrEqualToError,
+      Literal: pt.formatLiteralError,
+      Map: pt.formatMapError,
+      MaxLength2: pt.formatMaxLengthError,
+      MaxLength64: pt.formatMaxLengthError,
+      MaxLength100: pt.formatMaxLengthError,
+      MaxLength1000: pt.formatMaxLengthError,
+      MinLength1: pt.formatMinLengthError,
+      MinLength2: pt.formatMinLengthError,
+      MinLength8: pt.formatMinLengthError,
+      Mnemonic: pt.formatMnemonicError,
+      MultipleOf2: pt.formatMultipleOfError,
+      Name: pt.formatNameError,
+      Negative: pt.formatNegativeError,
+      NegativeDecimalString: pt.formatNegativeDecimalStringError,
+      Never: pt.formatNeverError,
+      NonNaN: pt.formatNonNaNError,
+      NonNegative: pt.formatNonNegativeError,
+      NonNegativeDecimalString: pt.formatNonNegativeDecimalStringError,
+      NonPositive: pt.formatNonPositiveError,
+      NonPositiveDecimalString: pt.formatNonPositiveDecimalStringError,
+      Number: pt.formatNumberError,
+      Object: pt.formatObjectError,
+      ObjectTag: pt.formatObjectTagError,
+      Positive: pt.formatPositiveError,
+      PositiveDecimalString: pt.formatPositiveDecimalStringError,
+      Record: pt.formatRecordError,
+      RecordKey: pt.formatRegexError,
+      Regex: pt.formatRegexError,
+      Set: pt.formatSetError,
+      String: pt.formatStringError,
+      Symbol: pt.formatSymbolError,
+      TableId: pt.formatTableIdError,
+      TemplateLiteral: pt.formatTemplateLiteralError,
+      Trimmed: pt.formatTrimmedError,
+      Tuple: pt.formatTupleError,
+      UInt64: pt.formatUInt64Error,
+      Union: pt.formatUnionError,
+      UrlSafeString: pt.formatRegexError,
+    },
+    ptBR: {
+      Array: ptBR.formatArrayError,
+      Base64Url: ptBR.formatBase64UrlError,
+      [Between1And2.name]: ptBR.formatBetweenError,
+      BigInt: ptBR.formatBigIntError,
+      Boolean: ptBR.formatBooleanError,
+      Capitalized: ptBR.formatCapitalizedError,
+      DateIso: ptBR.formatDateIsoError,
+      DateIsoFromDate: ptBR.formatDateIsoFromDateError,
+      DecimalString: ptBR.formatDecimalStringError,
+      DiscriminatedUnion: ptBR.formatDiscriminatedUnionError,
+      EvoluType: ptBR.formatEvoluTypeError,
+      Finite: ptBR.formatFiniteError,
+      Function: ptBR.formatFunctionError,
+      GreaterThan1: ptBR.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ptBR.formatGreaterThanOrEqualToError,
+      Id: ptBR.formatIdError,
+      InstanceOf: ptBR.formatInstanceOfError,
+      Int: ptBR.formatIntError,
+      Int64: ptBR.formatInt64Error,
+      Int64String: ptBR.formatInt64StringError,
+      Json: ptBR.formatJsonError,
+      JsonValue: ptBR.formatJsonValueError,
+      Length2: ptBR.formatLengthError,
+      Length16: ptBR.formatLengthError,
+      LessThan1: ptBR.formatLessThanError,
+      LessThan200: ptBR.formatLessThanError,
+      LessThanOrEqualTo1: ptBR.formatLessThanOrEqualToError,
+      Literal: ptBR.formatLiteralError,
+      Map: ptBR.formatMapError,
+      MaxLength2: ptBR.formatMaxLengthError,
+      MaxLength64: ptBR.formatMaxLengthError,
+      MaxLength100: ptBR.formatMaxLengthError,
+      MaxLength1000: ptBR.formatMaxLengthError,
+      MinLength1: ptBR.formatMinLengthError,
+      MinLength2: ptBR.formatMinLengthError,
+      MinLength8: ptBR.formatMinLengthError,
+      Mnemonic: ptBR.formatMnemonicError,
+      MultipleOf2: ptBR.formatMultipleOfError,
+      Name: ptBR.formatNameError,
+      Negative: ptBR.formatNegativeError,
+      NegativeDecimalString: ptBR.formatNegativeDecimalStringError,
+      Never: ptBR.formatNeverError,
+      NonNaN: ptBR.formatNonNaNError,
+      NonNegative: ptBR.formatNonNegativeError,
+      NonNegativeDecimalString: ptBR.formatNonNegativeDecimalStringError,
+      NonPositive: ptBR.formatNonPositiveError,
+      NonPositiveDecimalString: ptBR.formatNonPositiveDecimalStringError,
+      Number: ptBR.formatNumberError,
+      Object: ptBR.formatObjectError,
+      ObjectTag: ptBR.formatObjectTagError,
+      Positive: ptBR.formatPositiveError,
+      PositiveDecimalString: ptBR.formatPositiveDecimalStringError,
+      Record: ptBR.formatRecordError,
+      RecordKey: ptBR.formatRegexError,
+      Regex: ptBR.formatRegexError,
+      Set: ptBR.formatSetError,
+      String: ptBR.formatStringError,
+      Symbol: ptBR.formatSymbolError,
+      TableId: ptBR.formatTableIdError,
+      TemplateLiteral: ptBR.formatTemplateLiteralError,
+      Trimmed: ptBR.formatTrimmedError,
+      Tuple: ptBR.formatTupleError,
+      UInt64: ptBR.formatUInt64Error,
+      Union: ptBR.formatUnionError,
+      UrlSafeString: ptBR.formatRegexError,
+    },
+    ro: {
+      Array: ro.formatArrayError,
+      Base64Url: ro.formatBase64UrlError,
+      [Between1And2.name]: ro.formatBetweenError,
+      BigInt: ro.formatBigIntError,
+      Boolean: ro.formatBooleanError,
+      Capitalized: ro.formatCapitalizedError,
+      DateIso: ro.formatDateIsoError,
+      DateIsoFromDate: ro.formatDateIsoFromDateError,
+      DecimalString: ro.formatDecimalStringError,
+      DiscriminatedUnion: ro.formatDiscriminatedUnionError,
+      EvoluType: ro.formatEvoluTypeError,
+      Finite: ro.formatFiniteError,
+      Function: ro.formatFunctionError,
+      GreaterThan1: ro.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ro.formatGreaterThanOrEqualToError,
+      Id: ro.formatIdError,
+      InstanceOf: ro.formatInstanceOfError,
+      Int: ro.formatIntError,
+      Int64: ro.formatInt64Error,
+      Int64String: ro.formatInt64StringError,
+      Json: ro.formatJsonError,
+      JsonValue: ro.formatJsonValueError,
+      Length2: ro.formatLengthError,
+      Length16: ro.formatLengthError,
+      LessThan1: ro.formatLessThanError,
+      LessThan200: ro.formatLessThanError,
+      LessThanOrEqualTo1: ro.formatLessThanOrEqualToError,
+      Literal: ro.formatLiteralError,
+      Map: ro.formatMapError,
+      MaxLength2: ro.formatMaxLengthError,
+      MaxLength64: ro.formatMaxLengthError,
+      MaxLength100: ro.formatMaxLengthError,
+      MaxLength1000: ro.formatMaxLengthError,
+      MinLength1: ro.formatMinLengthError,
+      MinLength2: ro.formatMinLengthError,
+      MinLength8: ro.formatMinLengthError,
+      Mnemonic: ro.formatMnemonicError,
+      MultipleOf2: ro.formatMultipleOfError,
+      Name: ro.formatNameError,
+      Negative: ro.formatNegativeError,
+      NegativeDecimalString: ro.formatNegativeDecimalStringError,
+      Never: ro.formatNeverError,
+      NonNaN: ro.formatNonNaNError,
+      NonNegative: ro.formatNonNegativeError,
+      NonNegativeDecimalString: ro.formatNonNegativeDecimalStringError,
+      NonPositive: ro.formatNonPositiveError,
+      NonPositiveDecimalString: ro.formatNonPositiveDecimalStringError,
+      Number: ro.formatNumberError,
+      Object: ro.formatObjectError,
+      ObjectTag: ro.formatObjectTagError,
+      Positive: ro.formatPositiveError,
+      PositiveDecimalString: ro.formatPositiveDecimalStringError,
+      Record: ro.formatRecordError,
+      RecordKey: ro.formatRegexError,
+      Regex: ro.formatRegexError,
+      Set: ro.formatSetError,
+      String: ro.formatStringError,
+      Symbol: ro.formatSymbolError,
+      TableId: ro.formatTableIdError,
+      TemplateLiteral: ro.formatTemplateLiteralError,
+      Trimmed: ro.formatTrimmedError,
+      Tuple: ro.formatTupleError,
+      UInt64: ro.formatUInt64Error,
+      Union: ro.formatUnionError,
+      UrlSafeString: ro.formatRegexError,
+    },
+    sk: {
+      Array: sk.formatArrayError,
+      Base64Url: sk.formatBase64UrlError,
+      [Between1And2.name]: sk.formatBetweenError,
+      BigInt: sk.formatBigIntError,
+      Boolean: sk.formatBooleanError,
+      Capitalized: sk.formatCapitalizedError,
+      DateIso: sk.formatDateIsoError,
+      DateIsoFromDate: sk.formatDateIsoFromDateError,
+      DecimalString: sk.formatDecimalStringError,
+      DiscriminatedUnion: sk.formatDiscriminatedUnionError,
+      EvoluType: sk.formatEvoluTypeError,
+      Finite: sk.formatFiniteError,
+      Function: sk.formatFunctionError,
+      GreaterThan1: sk.formatGreaterThanError,
+      GreaterThanOrEqualTo1: sk.formatGreaterThanOrEqualToError,
+      Id: sk.formatIdError,
+      InstanceOf: sk.formatInstanceOfError,
+      Int: sk.formatIntError,
+      Int64: sk.formatInt64Error,
+      Int64String: sk.formatInt64StringError,
+      Json: sk.formatJsonError,
+      JsonValue: sk.formatJsonValueError,
+      Length2: sk.formatLengthError,
+      Length16: sk.formatLengthError,
+      LessThan1: sk.formatLessThanError,
+      LessThan200: sk.formatLessThanError,
+      LessThanOrEqualTo1: sk.formatLessThanOrEqualToError,
+      Literal: sk.formatLiteralError,
+      Map: sk.formatMapError,
+      MaxLength2: sk.formatMaxLengthError,
+      MaxLength64: sk.formatMaxLengthError,
+      MaxLength100: sk.formatMaxLengthError,
+      MaxLength1000: sk.formatMaxLengthError,
+      MinLength1: sk.formatMinLengthError,
+      MinLength2: sk.formatMinLengthError,
+      MinLength8: sk.formatMinLengthError,
+      Mnemonic: sk.formatMnemonicError,
+      MultipleOf2: sk.formatMultipleOfError,
+      Name: sk.formatNameError,
+      Negative: sk.formatNegativeError,
+      NegativeDecimalString: sk.formatNegativeDecimalStringError,
+      Never: sk.formatNeverError,
+      NonNaN: sk.formatNonNaNError,
+      NonNegative: sk.formatNonNegativeError,
+      NonNegativeDecimalString: sk.formatNonNegativeDecimalStringError,
+      NonPositive: sk.formatNonPositiveError,
+      NonPositiveDecimalString: sk.formatNonPositiveDecimalStringError,
+      Number: sk.formatNumberError,
+      Object: sk.formatObjectError,
+      ObjectTag: sk.formatObjectTagError,
+      Positive: sk.formatPositiveError,
+      PositiveDecimalString: sk.formatPositiveDecimalStringError,
+      Record: sk.formatRecordError,
+      RecordKey: sk.formatRegexError,
+      Regex: sk.formatRegexError,
+      Set: sk.formatSetError,
+      String: sk.formatStringError,
+      Symbol: sk.formatSymbolError,
+      TableId: sk.formatTableIdError,
+      TemplateLiteral: sk.formatTemplateLiteralError,
+      Trimmed: sk.formatTrimmedError,
+      Tuple: sk.formatTupleError,
+      UInt64: sk.formatUInt64Error,
+      Union: sk.formatUnionError,
+      UrlSafeString: sk.formatRegexError,
+    },
+    sl: {
+      Array: sl.formatArrayError,
+      Base64Url: sl.formatBase64UrlError,
+      [Between1And2.name]: sl.formatBetweenError,
+      BigInt: sl.formatBigIntError,
+      Boolean: sl.formatBooleanError,
+      Capitalized: sl.formatCapitalizedError,
+      DateIso: sl.formatDateIsoError,
+      DateIsoFromDate: sl.formatDateIsoFromDateError,
+      DecimalString: sl.formatDecimalStringError,
+      DiscriminatedUnion: sl.formatDiscriminatedUnionError,
+      EvoluType: sl.formatEvoluTypeError,
+      Finite: sl.formatFiniteError,
+      Function: sl.formatFunctionError,
+      GreaterThan1: sl.formatGreaterThanError,
+      GreaterThanOrEqualTo1: sl.formatGreaterThanOrEqualToError,
+      Id: sl.formatIdError,
+      InstanceOf: sl.formatInstanceOfError,
+      Int: sl.formatIntError,
+      Int64: sl.formatInt64Error,
+      Int64String: sl.formatInt64StringError,
+      Json: sl.formatJsonError,
+      JsonValue: sl.formatJsonValueError,
+      Length2: sl.formatLengthError,
+      Length16: sl.formatLengthError,
+      LessThan1: sl.formatLessThanError,
+      LessThan200: sl.formatLessThanError,
+      LessThanOrEqualTo1: sl.formatLessThanOrEqualToError,
+      Literal: sl.formatLiteralError,
+      Map: sl.formatMapError,
+      MaxLength2: sl.formatMaxLengthError,
+      MaxLength64: sl.formatMaxLengthError,
+      MaxLength100: sl.formatMaxLengthError,
+      MaxLength1000: sl.formatMaxLengthError,
+      MinLength1: sl.formatMinLengthError,
+      MinLength2: sl.formatMinLengthError,
+      MinLength8: sl.formatMinLengthError,
+      Mnemonic: sl.formatMnemonicError,
+      MultipleOf2: sl.formatMultipleOfError,
+      Name: sl.formatNameError,
+      Negative: sl.formatNegativeError,
+      NegativeDecimalString: sl.formatNegativeDecimalStringError,
+      Never: sl.formatNeverError,
+      NonNaN: sl.formatNonNaNError,
+      NonNegative: sl.formatNonNegativeError,
+      NonNegativeDecimalString: sl.formatNonNegativeDecimalStringError,
+      NonPositive: sl.formatNonPositiveError,
+      NonPositiveDecimalString: sl.formatNonPositiveDecimalStringError,
+      Number: sl.formatNumberError,
+      Object: sl.formatObjectError,
+      ObjectTag: sl.formatObjectTagError,
+      Positive: sl.formatPositiveError,
+      PositiveDecimalString: sl.formatPositiveDecimalStringError,
+      Record: sl.formatRecordError,
+      RecordKey: sl.formatRegexError,
+      Regex: sl.formatRegexError,
+      Set: sl.formatSetError,
+      String: sl.formatStringError,
+      Symbol: sl.formatSymbolError,
+      TableId: sl.formatTableIdError,
+      TemplateLiteral: sl.formatTemplateLiteralError,
+      Trimmed: sl.formatTrimmedError,
+      Tuple: sl.formatTupleError,
+      UInt64: sl.formatUInt64Error,
+      Union: sl.formatUnionError,
+      UrlSafeString: sl.formatRegexError,
+    },
+    sv: {
+      Array: sv.formatArrayError,
+      Base64Url: sv.formatBase64UrlError,
+      [Between1And2.name]: sv.formatBetweenError,
+      BigInt: sv.formatBigIntError,
+      Boolean: sv.formatBooleanError,
+      Capitalized: sv.formatCapitalizedError,
+      DateIso: sv.formatDateIsoError,
+      DateIsoFromDate: sv.formatDateIsoFromDateError,
+      DecimalString: sv.formatDecimalStringError,
+      DiscriminatedUnion: sv.formatDiscriminatedUnionError,
+      EvoluType: sv.formatEvoluTypeError,
+      Finite: sv.formatFiniteError,
+      Function: sv.formatFunctionError,
+      GreaterThan1: sv.formatGreaterThanError,
+      GreaterThanOrEqualTo1: sv.formatGreaterThanOrEqualToError,
+      Id: sv.formatIdError,
+      InstanceOf: sv.formatInstanceOfError,
+      Int: sv.formatIntError,
+      Int64: sv.formatInt64Error,
+      Int64String: sv.formatInt64StringError,
+      Json: sv.formatJsonError,
+      JsonValue: sv.formatJsonValueError,
+      Length2: sv.formatLengthError,
+      Length16: sv.formatLengthError,
+      LessThan1: sv.formatLessThanError,
+      LessThan200: sv.formatLessThanError,
+      LessThanOrEqualTo1: sv.formatLessThanOrEqualToError,
+      Literal: sv.formatLiteralError,
+      Map: sv.formatMapError,
+      MaxLength2: sv.formatMaxLengthError,
+      MaxLength64: sv.formatMaxLengthError,
+      MaxLength100: sv.formatMaxLengthError,
+      MaxLength1000: sv.formatMaxLengthError,
+      MinLength1: sv.formatMinLengthError,
+      MinLength2: sv.formatMinLengthError,
+      MinLength8: sv.formatMinLengthError,
+      Mnemonic: sv.formatMnemonicError,
+      MultipleOf2: sv.formatMultipleOfError,
+      Name: sv.formatNameError,
+      Negative: sv.formatNegativeError,
+      NegativeDecimalString: sv.formatNegativeDecimalStringError,
+      Never: sv.formatNeverError,
+      NonNaN: sv.formatNonNaNError,
+      NonNegative: sv.formatNonNegativeError,
+      NonNegativeDecimalString: sv.formatNonNegativeDecimalStringError,
+      NonPositive: sv.formatNonPositiveError,
+      NonPositiveDecimalString: sv.formatNonPositiveDecimalStringError,
+      Number: sv.formatNumberError,
+      Object: sv.formatObjectError,
+      ObjectTag: sv.formatObjectTagError,
+      Positive: sv.formatPositiveError,
+      PositiveDecimalString: sv.formatPositiveDecimalStringError,
+      Record: sv.formatRecordError,
+      RecordKey: sv.formatRegexError,
+      Regex: sv.formatRegexError,
+      Set: sv.formatSetError,
+      String: sv.formatStringError,
+      Symbol: sv.formatSymbolError,
+      TableId: sv.formatTableIdError,
+      TemplateLiteral: sv.formatTemplateLiteralError,
+      Trimmed: sv.formatTrimmedError,
+      Tuple: sv.formatTupleError,
+      UInt64: sv.formatUInt64Error,
+      Union: sv.formatUnionError,
+      UrlSafeString: sv.formatRegexError,
+    },
+    sw: {
+      Array: sw.formatArrayError,
+      Base64Url: sw.formatBase64UrlError,
+      [Between1And2.name]: sw.formatBetweenError,
+      BigInt: sw.formatBigIntError,
+      Boolean: sw.formatBooleanError,
+      Capitalized: sw.formatCapitalizedError,
+      DateIso: sw.formatDateIsoError,
+      DateIsoFromDate: sw.formatDateIsoFromDateError,
+      DecimalString: sw.formatDecimalStringError,
+      DiscriminatedUnion: sw.formatDiscriminatedUnionError,
+      EvoluType: sw.formatEvoluTypeError,
+      Finite: sw.formatFiniteError,
+      Function: sw.formatFunctionError,
+      GreaterThan1: sw.formatGreaterThanError,
+      GreaterThanOrEqualTo1: sw.formatGreaterThanOrEqualToError,
+      Id: sw.formatIdError,
+      InstanceOf: sw.formatInstanceOfError,
+      Int: sw.formatIntError,
+      Int64: sw.formatInt64Error,
+      Int64String: sw.formatInt64StringError,
+      Json: sw.formatJsonError,
+      JsonValue: sw.formatJsonValueError,
+      Length2: sw.formatLengthError,
+      Length16: sw.formatLengthError,
+      LessThan1: sw.formatLessThanError,
+      LessThan200: sw.formatLessThanError,
+      LessThanOrEqualTo1: sw.formatLessThanOrEqualToError,
+      Literal: sw.formatLiteralError,
+      Map: sw.formatMapError,
+      MaxLength2: sw.formatMaxLengthError,
+      MaxLength64: sw.formatMaxLengthError,
+      MaxLength100: sw.formatMaxLengthError,
+      MaxLength1000: sw.formatMaxLengthError,
+      MinLength1: sw.formatMinLengthError,
+      MinLength2: sw.formatMinLengthError,
+      MinLength8: sw.formatMinLengthError,
+      Mnemonic: sw.formatMnemonicError,
+      MultipleOf2: sw.formatMultipleOfError,
+      Name: sw.formatNameError,
+      Negative: sw.formatNegativeError,
+      NegativeDecimalString: sw.formatNegativeDecimalStringError,
+      Never: sw.formatNeverError,
+      NonNaN: sw.formatNonNaNError,
+      NonNegative: sw.formatNonNegativeError,
+      NonNegativeDecimalString: sw.formatNonNegativeDecimalStringError,
+      NonPositive: sw.formatNonPositiveError,
+      NonPositiveDecimalString: sw.formatNonPositiveDecimalStringError,
+      Number: sw.formatNumberError,
+      Object: sw.formatObjectError,
+      ObjectTag: sw.formatObjectTagError,
+      Positive: sw.formatPositiveError,
+      PositiveDecimalString: sw.formatPositiveDecimalStringError,
+      Record: sw.formatRecordError,
+      RecordKey: sw.formatRegexError,
+      Regex: sw.formatRegexError,
+      Set: sw.formatSetError,
+      String: sw.formatStringError,
+      Symbol: sw.formatSymbolError,
+      TableId: sw.formatTableIdError,
+      TemplateLiteral: sw.formatTemplateLiteralError,
+      Trimmed: sw.formatTrimmedError,
+      Tuple: sw.formatTupleError,
+      UInt64: sw.formatUInt64Error,
+      Union: sw.formatUnionError,
+      UrlSafeString: sw.formatRegexError,
+    },
+    ta: {
+      Array: ta.formatArrayError,
+      Base64Url: ta.formatBase64UrlError,
+      [Between1And2.name]: ta.formatBetweenError,
+      BigInt: ta.formatBigIntError,
+      Boolean: ta.formatBooleanError,
+      Capitalized: ta.formatCapitalizedError,
+      DateIso: ta.formatDateIsoError,
+      DateIsoFromDate: ta.formatDateIsoFromDateError,
+      DecimalString: ta.formatDecimalStringError,
+      DiscriminatedUnion: ta.formatDiscriminatedUnionError,
+      EvoluType: ta.formatEvoluTypeError,
+      Finite: ta.formatFiniteError,
+      Function: ta.formatFunctionError,
+      GreaterThan1: ta.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ta.formatGreaterThanOrEqualToError,
+      Id: ta.formatIdError,
+      InstanceOf: ta.formatInstanceOfError,
+      Int: ta.formatIntError,
+      Int64: ta.formatInt64Error,
+      Int64String: ta.formatInt64StringError,
+      Json: ta.formatJsonError,
+      JsonValue: ta.formatJsonValueError,
+      Length2: ta.formatLengthError,
+      Length16: ta.formatLengthError,
+      LessThan1: ta.formatLessThanError,
+      LessThan200: ta.formatLessThanError,
+      LessThanOrEqualTo1: ta.formatLessThanOrEqualToError,
+      Literal: ta.formatLiteralError,
+      Map: ta.formatMapError,
+      MaxLength2: ta.formatMaxLengthError,
+      MaxLength64: ta.formatMaxLengthError,
+      MaxLength100: ta.formatMaxLengthError,
+      MaxLength1000: ta.formatMaxLengthError,
+      MinLength1: ta.formatMinLengthError,
+      MinLength2: ta.formatMinLengthError,
+      MinLength8: ta.formatMinLengthError,
+      Mnemonic: ta.formatMnemonicError,
+      MultipleOf2: ta.formatMultipleOfError,
+      Name: ta.formatNameError,
+      Negative: ta.formatNegativeError,
+      NegativeDecimalString: ta.formatNegativeDecimalStringError,
+      Never: ta.formatNeverError,
+      NonNaN: ta.formatNonNaNError,
+      NonNegative: ta.formatNonNegativeError,
+      NonNegativeDecimalString: ta.formatNonNegativeDecimalStringError,
+      NonPositive: ta.formatNonPositiveError,
+      NonPositiveDecimalString: ta.formatNonPositiveDecimalStringError,
+      Number: ta.formatNumberError,
+      Object: ta.formatObjectError,
+      ObjectTag: ta.formatObjectTagError,
+      Positive: ta.formatPositiveError,
+      PositiveDecimalString: ta.formatPositiveDecimalStringError,
+      Record: ta.formatRecordError,
+      RecordKey: ta.formatRegexError,
+      Regex: ta.formatRegexError,
+      Set: ta.formatSetError,
+      String: ta.formatStringError,
+      Symbol: ta.formatSymbolError,
+      TableId: ta.formatTableIdError,
+      TemplateLiteral: ta.formatTemplateLiteralError,
+      Trimmed: ta.formatTrimmedError,
+      Tuple: ta.formatTupleError,
+      UInt64: ta.formatUInt64Error,
+      Union: ta.formatUnionError,
+      UrlSafeString: ta.formatRegexError,
+    },
+    te: {
+      Array: te.formatArrayError,
+      Base64Url: te.formatBase64UrlError,
+      [Between1And2.name]: te.formatBetweenError,
+      BigInt: te.formatBigIntError,
+      Boolean: te.formatBooleanError,
+      Capitalized: te.formatCapitalizedError,
+      DateIso: te.formatDateIsoError,
+      DateIsoFromDate: te.formatDateIsoFromDateError,
+      DecimalString: te.formatDecimalStringError,
+      DiscriminatedUnion: te.formatDiscriminatedUnionError,
+      EvoluType: te.formatEvoluTypeError,
+      Finite: te.formatFiniteError,
+      Function: te.formatFunctionError,
+      GreaterThan1: te.formatGreaterThanError,
+      GreaterThanOrEqualTo1: te.formatGreaterThanOrEqualToError,
+      Id: te.formatIdError,
+      InstanceOf: te.formatInstanceOfError,
+      Int: te.formatIntError,
+      Int64: te.formatInt64Error,
+      Int64String: te.formatInt64StringError,
+      Json: te.formatJsonError,
+      JsonValue: te.formatJsonValueError,
+      Length2: te.formatLengthError,
+      Length16: te.formatLengthError,
+      LessThan1: te.formatLessThanError,
+      LessThan200: te.formatLessThanError,
+      LessThanOrEqualTo1: te.formatLessThanOrEqualToError,
+      Literal: te.formatLiteralError,
+      Map: te.formatMapError,
+      MaxLength2: te.formatMaxLengthError,
+      MaxLength64: te.formatMaxLengthError,
+      MaxLength100: te.formatMaxLengthError,
+      MaxLength1000: te.formatMaxLengthError,
+      MinLength1: te.formatMinLengthError,
+      MinLength2: te.formatMinLengthError,
+      MinLength8: te.formatMinLengthError,
+      Mnemonic: te.formatMnemonicError,
+      MultipleOf2: te.formatMultipleOfError,
+      Name: te.formatNameError,
+      Negative: te.formatNegativeError,
+      NegativeDecimalString: te.formatNegativeDecimalStringError,
+      Never: te.formatNeverError,
+      NonNaN: te.formatNonNaNError,
+      NonNegative: te.formatNonNegativeError,
+      NonNegativeDecimalString: te.formatNonNegativeDecimalStringError,
+      NonPositive: te.formatNonPositiveError,
+      NonPositiveDecimalString: te.formatNonPositiveDecimalStringError,
+      Number: te.formatNumberError,
+      Object: te.formatObjectError,
+      ObjectTag: te.formatObjectTagError,
+      Positive: te.formatPositiveError,
+      PositiveDecimalString: te.formatPositiveDecimalStringError,
+      Record: te.formatRecordError,
+      RecordKey: te.formatRegexError,
+      Regex: te.formatRegexError,
+      Set: te.formatSetError,
+      String: te.formatStringError,
+      Symbol: te.formatSymbolError,
+      TableId: te.formatTableIdError,
+      TemplateLiteral: te.formatTemplateLiteralError,
+      Trimmed: te.formatTrimmedError,
+      Tuple: te.formatTupleError,
+      UInt64: te.formatUInt64Error,
+      Union: te.formatUnionError,
+      UrlSafeString: te.formatRegexError,
+    },
+    th: {
+      Array: th.formatArrayError,
+      Base64Url: th.formatBase64UrlError,
+      [Between1And2.name]: th.formatBetweenError,
+      BigInt: th.formatBigIntError,
+      Boolean: th.formatBooleanError,
+      Capitalized: th.formatCapitalizedError,
+      DateIso: th.formatDateIsoError,
+      DateIsoFromDate: th.formatDateIsoFromDateError,
+      DecimalString: th.formatDecimalStringError,
+      DiscriminatedUnion: th.formatDiscriminatedUnionError,
+      EvoluType: th.formatEvoluTypeError,
+      Finite: th.formatFiniteError,
+      Function: th.formatFunctionError,
+      GreaterThan1: th.formatGreaterThanError,
+      GreaterThanOrEqualTo1: th.formatGreaterThanOrEqualToError,
+      Id: th.formatIdError,
+      InstanceOf: th.formatInstanceOfError,
+      Int: th.formatIntError,
+      Int64: th.formatInt64Error,
+      Int64String: th.formatInt64StringError,
+      Json: th.formatJsonError,
+      JsonValue: th.formatJsonValueError,
+      Length2: th.formatLengthError,
+      Length16: th.formatLengthError,
+      LessThan1: th.formatLessThanError,
+      LessThan200: th.formatLessThanError,
+      LessThanOrEqualTo1: th.formatLessThanOrEqualToError,
+      Literal: th.formatLiteralError,
+      Map: th.formatMapError,
+      MaxLength2: th.formatMaxLengthError,
+      MaxLength64: th.formatMaxLengthError,
+      MaxLength100: th.formatMaxLengthError,
+      MaxLength1000: th.formatMaxLengthError,
+      MinLength1: th.formatMinLengthError,
+      MinLength2: th.formatMinLengthError,
+      MinLength8: th.formatMinLengthError,
+      Mnemonic: th.formatMnemonicError,
+      MultipleOf2: th.formatMultipleOfError,
+      Name: th.formatNameError,
+      Negative: th.formatNegativeError,
+      NegativeDecimalString: th.formatNegativeDecimalStringError,
+      Never: th.formatNeverError,
+      NonNaN: th.formatNonNaNError,
+      NonNegative: th.formatNonNegativeError,
+      NonNegativeDecimalString: th.formatNonNegativeDecimalStringError,
+      NonPositive: th.formatNonPositiveError,
+      NonPositiveDecimalString: th.formatNonPositiveDecimalStringError,
+      Number: th.formatNumberError,
+      Object: th.formatObjectError,
+      ObjectTag: th.formatObjectTagError,
+      Positive: th.formatPositiveError,
+      PositiveDecimalString: th.formatPositiveDecimalStringError,
+      Record: th.formatRecordError,
+      RecordKey: th.formatRegexError,
+      Regex: th.formatRegexError,
+      Set: th.formatSetError,
+      String: th.formatStringError,
+      Symbol: th.formatSymbolError,
+      TableId: th.formatTableIdError,
+      TemplateLiteral: th.formatTemplateLiteralError,
+      Trimmed: th.formatTrimmedError,
+      Tuple: th.formatTupleError,
+      UInt64: th.formatUInt64Error,
+      Union: th.formatUnionError,
+      UrlSafeString: th.formatRegexError,
+    },
+    tr: {
+      Array: tr.formatArrayError,
+      Base64Url: tr.formatBase64UrlError,
+      [Between1And2.name]: tr.formatBetweenError,
+      BigInt: tr.formatBigIntError,
+      Boolean: tr.formatBooleanError,
+      Capitalized: tr.formatCapitalizedError,
+      DateIso: tr.formatDateIsoError,
+      DateIsoFromDate: tr.formatDateIsoFromDateError,
+      DecimalString: tr.formatDecimalStringError,
+      DiscriminatedUnion: tr.formatDiscriminatedUnionError,
+      EvoluType: tr.formatEvoluTypeError,
+      Finite: tr.formatFiniteError,
+      Function: tr.formatFunctionError,
+      GreaterThan1: tr.formatGreaterThanError,
+      GreaterThanOrEqualTo1: tr.formatGreaterThanOrEqualToError,
+      Id: tr.formatIdError,
+      InstanceOf: tr.formatInstanceOfError,
+      Int: tr.formatIntError,
+      Int64: tr.formatInt64Error,
+      Int64String: tr.formatInt64StringError,
+      Json: tr.formatJsonError,
+      JsonValue: tr.formatJsonValueError,
+      Length2: tr.formatLengthError,
+      Length16: tr.formatLengthError,
+      LessThan1: tr.formatLessThanError,
+      LessThan200: tr.formatLessThanError,
+      LessThanOrEqualTo1: tr.formatLessThanOrEqualToError,
+      Literal: tr.formatLiteralError,
+      Map: tr.formatMapError,
+      MaxLength2: tr.formatMaxLengthError,
+      MaxLength64: tr.formatMaxLengthError,
+      MaxLength100: tr.formatMaxLengthError,
+      MaxLength1000: tr.formatMaxLengthError,
+      MinLength1: tr.formatMinLengthError,
+      MinLength2: tr.formatMinLengthError,
+      MinLength8: tr.formatMinLengthError,
+      Mnemonic: tr.formatMnemonicError,
+      MultipleOf2: tr.formatMultipleOfError,
+      Name: tr.formatNameError,
+      Negative: tr.formatNegativeError,
+      NegativeDecimalString: tr.formatNegativeDecimalStringError,
+      Never: tr.formatNeverError,
+      NonNaN: tr.formatNonNaNError,
+      NonNegative: tr.formatNonNegativeError,
+      NonNegativeDecimalString: tr.formatNonNegativeDecimalStringError,
+      NonPositive: tr.formatNonPositiveError,
+      NonPositiveDecimalString: tr.formatNonPositiveDecimalStringError,
+      Number: tr.formatNumberError,
+      Object: tr.formatObjectError,
+      ObjectTag: tr.formatObjectTagError,
+      Positive: tr.formatPositiveError,
+      PositiveDecimalString: tr.formatPositiveDecimalStringError,
+      Record: tr.formatRecordError,
+      RecordKey: tr.formatRegexError,
+      Regex: tr.formatRegexError,
+      Set: tr.formatSetError,
+      String: tr.formatStringError,
+      Symbol: tr.formatSymbolError,
+      TableId: tr.formatTableIdError,
+      TemplateLiteral: tr.formatTemplateLiteralError,
+      Trimmed: tr.formatTrimmedError,
+      Tuple: tr.formatTupleError,
+      UInt64: tr.formatUInt64Error,
+      Union: tr.formatUnionError,
+      UrlSafeString: tr.formatRegexError,
+    },
+    uk: {
+      Array: uk.formatArrayError,
+      Base64Url: uk.formatBase64UrlError,
+      [Between1And2.name]: uk.formatBetweenError,
+      BigInt: uk.formatBigIntError,
+      Boolean: uk.formatBooleanError,
+      Capitalized: uk.formatCapitalizedError,
+      DateIso: uk.formatDateIsoError,
+      DateIsoFromDate: uk.formatDateIsoFromDateError,
+      DecimalString: uk.formatDecimalStringError,
+      DiscriminatedUnion: uk.formatDiscriminatedUnionError,
+      EvoluType: uk.formatEvoluTypeError,
+      Finite: uk.formatFiniteError,
+      Function: uk.formatFunctionError,
+      GreaterThan1: uk.formatGreaterThanError,
+      GreaterThanOrEqualTo1: uk.formatGreaterThanOrEqualToError,
+      Id: uk.formatIdError,
+      InstanceOf: uk.formatInstanceOfError,
+      Int: uk.formatIntError,
+      Int64: uk.formatInt64Error,
+      Int64String: uk.formatInt64StringError,
+      Json: uk.formatJsonError,
+      JsonValue: uk.formatJsonValueError,
+      Length2: uk.formatLengthError,
+      Length16: uk.formatLengthError,
+      LessThan1: uk.formatLessThanError,
+      LessThan200: uk.formatLessThanError,
+      LessThanOrEqualTo1: uk.formatLessThanOrEqualToError,
+      Literal: uk.formatLiteralError,
+      Map: uk.formatMapError,
+      MaxLength2: uk.formatMaxLengthError,
+      MaxLength64: uk.formatMaxLengthError,
+      MaxLength100: uk.formatMaxLengthError,
+      MaxLength1000: uk.formatMaxLengthError,
+      MinLength1: uk.formatMinLengthError,
+      MinLength2: uk.formatMinLengthError,
+      MinLength8: uk.formatMinLengthError,
+      Mnemonic: uk.formatMnemonicError,
+      MultipleOf2: uk.formatMultipleOfError,
+      Name: uk.formatNameError,
+      Negative: uk.formatNegativeError,
+      NegativeDecimalString: uk.formatNegativeDecimalStringError,
+      Never: uk.formatNeverError,
+      NonNaN: uk.formatNonNaNError,
+      NonNegative: uk.formatNonNegativeError,
+      NonNegativeDecimalString: uk.formatNonNegativeDecimalStringError,
+      NonPositive: uk.formatNonPositiveError,
+      NonPositiveDecimalString: uk.formatNonPositiveDecimalStringError,
+      Number: uk.formatNumberError,
+      Object: uk.formatObjectError,
+      ObjectTag: uk.formatObjectTagError,
+      Positive: uk.formatPositiveError,
+      PositiveDecimalString: uk.formatPositiveDecimalStringError,
+      Record: uk.formatRecordError,
+      RecordKey: uk.formatRegexError,
+      Regex: uk.formatRegexError,
+      Set: uk.formatSetError,
+      String: uk.formatStringError,
+      Symbol: uk.formatSymbolError,
+      TableId: uk.formatTableIdError,
+      TemplateLiteral: uk.formatTemplateLiteralError,
+      Trimmed: uk.formatTrimmedError,
+      Tuple: uk.formatTupleError,
+      UInt64: uk.formatUInt64Error,
+      Union: uk.formatUnionError,
+      UrlSafeString: uk.formatRegexError,
+    },
+    ur: {
+      Array: ur.formatArrayError,
+      Base64Url: ur.formatBase64UrlError,
+      [Between1And2.name]: ur.formatBetweenError,
+      BigInt: ur.formatBigIntError,
+      Boolean: ur.formatBooleanError,
+      Capitalized: ur.formatCapitalizedError,
+      DateIso: ur.formatDateIsoError,
+      DateIsoFromDate: ur.formatDateIsoFromDateError,
+      DecimalString: ur.formatDecimalStringError,
+      DiscriminatedUnion: ur.formatDiscriminatedUnionError,
+      EvoluType: ur.formatEvoluTypeError,
+      Finite: ur.formatFiniteError,
+      Function: ur.formatFunctionError,
+      GreaterThan1: ur.formatGreaterThanError,
+      GreaterThanOrEqualTo1: ur.formatGreaterThanOrEqualToError,
+      Id: ur.formatIdError,
+      InstanceOf: ur.formatInstanceOfError,
+      Int: ur.formatIntError,
+      Int64: ur.formatInt64Error,
+      Int64String: ur.formatInt64StringError,
+      Json: ur.formatJsonError,
+      JsonValue: ur.formatJsonValueError,
+      Length2: ur.formatLengthError,
+      Length16: ur.formatLengthError,
+      LessThan1: ur.formatLessThanError,
+      LessThan200: ur.formatLessThanError,
+      LessThanOrEqualTo1: ur.formatLessThanOrEqualToError,
+      Literal: ur.formatLiteralError,
+      Map: ur.formatMapError,
+      MaxLength2: ur.formatMaxLengthError,
+      MaxLength64: ur.formatMaxLengthError,
+      MaxLength100: ur.formatMaxLengthError,
+      MaxLength1000: ur.formatMaxLengthError,
+      MinLength1: ur.formatMinLengthError,
+      MinLength2: ur.formatMinLengthError,
+      MinLength8: ur.formatMinLengthError,
+      Mnemonic: ur.formatMnemonicError,
+      MultipleOf2: ur.formatMultipleOfError,
+      Name: ur.formatNameError,
+      Negative: ur.formatNegativeError,
+      NegativeDecimalString: ur.formatNegativeDecimalStringError,
+      Never: ur.formatNeverError,
+      NonNaN: ur.formatNonNaNError,
+      NonNegative: ur.formatNonNegativeError,
+      NonNegativeDecimalString: ur.formatNonNegativeDecimalStringError,
+      NonPositive: ur.formatNonPositiveError,
+      NonPositiveDecimalString: ur.formatNonPositiveDecimalStringError,
+      Number: ur.formatNumberError,
+      Object: ur.formatObjectError,
+      ObjectTag: ur.formatObjectTagError,
+      Positive: ur.formatPositiveError,
+      PositiveDecimalString: ur.formatPositiveDecimalStringError,
+      Record: ur.formatRecordError,
+      RecordKey: ur.formatRegexError,
+      Regex: ur.formatRegexError,
+      Set: ur.formatSetError,
+      String: ur.formatStringError,
+      Symbol: ur.formatSymbolError,
+      TableId: ur.formatTableIdError,
+      TemplateLiteral: ur.formatTemplateLiteralError,
+      Trimmed: ur.formatTrimmedError,
+      Tuple: ur.formatTupleError,
+      UInt64: ur.formatUInt64Error,
+      Union: ur.formatUnionError,
+      UrlSafeString: ur.formatRegexError,
+    },
+    vi: {
+      Array: vi.formatArrayError,
+      Base64Url: vi.formatBase64UrlError,
+      [Between1And2.name]: vi.formatBetweenError,
+      BigInt: vi.formatBigIntError,
+      Boolean: vi.formatBooleanError,
+      Capitalized: vi.formatCapitalizedError,
+      DateIso: vi.formatDateIsoError,
+      DateIsoFromDate: vi.formatDateIsoFromDateError,
+      DecimalString: vi.formatDecimalStringError,
+      DiscriminatedUnion: vi.formatDiscriminatedUnionError,
+      EvoluType: vi.formatEvoluTypeError,
+      Finite: vi.formatFiniteError,
+      Function: vi.formatFunctionError,
+      GreaterThan1: vi.formatGreaterThanError,
+      GreaterThanOrEqualTo1: vi.formatGreaterThanOrEqualToError,
+      Id: vi.formatIdError,
+      InstanceOf: vi.formatInstanceOfError,
+      Int: vi.formatIntError,
+      Int64: vi.formatInt64Error,
+      Int64String: vi.formatInt64StringError,
+      Json: vi.formatJsonError,
+      JsonValue: vi.formatJsonValueError,
+      Length2: vi.formatLengthError,
+      Length16: vi.formatLengthError,
+      LessThan1: vi.formatLessThanError,
+      LessThan200: vi.formatLessThanError,
+      LessThanOrEqualTo1: vi.formatLessThanOrEqualToError,
+      Literal: vi.formatLiteralError,
+      Map: vi.formatMapError,
+      MaxLength2: vi.formatMaxLengthError,
+      MaxLength64: vi.formatMaxLengthError,
+      MaxLength100: vi.formatMaxLengthError,
+      MaxLength1000: vi.formatMaxLengthError,
+      MinLength1: vi.formatMinLengthError,
+      MinLength2: vi.formatMinLengthError,
+      MinLength8: vi.formatMinLengthError,
+      Mnemonic: vi.formatMnemonicError,
+      MultipleOf2: vi.formatMultipleOfError,
+      Name: vi.formatNameError,
+      Negative: vi.formatNegativeError,
+      NegativeDecimalString: vi.formatNegativeDecimalStringError,
+      Never: vi.formatNeverError,
+      NonNaN: vi.formatNonNaNError,
+      NonNegative: vi.formatNonNegativeError,
+      NonNegativeDecimalString: vi.formatNonNegativeDecimalStringError,
+      NonPositive: vi.formatNonPositiveError,
+      NonPositiveDecimalString: vi.formatNonPositiveDecimalStringError,
+      Number: vi.formatNumberError,
+      Object: vi.formatObjectError,
+      ObjectTag: vi.formatObjectTagError,
+      Positive: vi.formatPositiveError,
+      PositiveDecimalString: vi.formatPositiveDecimalStringError,
+      Record: vi.formatRecordError,
+      RecordKey: vi.formatRegexError,
+      Regex: vi.formatRegexError,
+      Set: vi.formatSetError,
+      String: vi.formatStringError,
+      Symbol: vi.formatSymbolError,
+      TableId: vi.formatTableIdError,
+      TemplateLiteral: vi.formatTemplateLiteralError,
+      Trimmed: vi.formatTrimmedError,
+      Tuple: vi.formatTupleError,
+      UInt64: vi.formatUInt64Error,
+      Union: vi.formatUnionError,
+      UrlSafeString: vi.formatRegexError,
+    },
+    zhCN: {
+      Array: zhCN.formatArrayError,
+      Base64Url: zhCN.formatBase64UrlError,
+      [Between1And2.name]: zhCN.formatBetweenError,
+      BigInt: zhCN.formatBigIntError,
+      Boolean: zhCN.formatBooleanError,
+      Capitalized: zhCN.formatCapitalizedError,
+      DateIso: zhCN.formatDateIsoError,
+      DateIsoFromDate: zhCN.formatDateIsoFromDateError,
+      DecimalString: zhCN.formatDecimalStringError,
+      DiscriminatedUnion: zhCN.formatDiscriminatedUnionError,
+      EvoluType: zhCN.formatEvoluTypeError,
+      Finite: zhCN.formatFiniteError,
+      Function: zhCN.formatFunctionError,
+      GreaterThan1: zhCN.formatGreaterThanError,
+      GreaterThanOrEqualTo1: zhCN.formatGreaterThanOrEqualToError,
+      Id: zhCN.formatIdError,
+      InstanceOf: zhCN.formatInstanceOfError,
+      Int: zhCN.formatIntError,
+      Int64: zhCN.formatInt64Error,
+      Int64String: zhCN.formatInt64StringError,
+      Json: zhCN.formatJsonError,
+      JsonValue: zhCN.formatJsonValueError,
+      Length2: zhCN.formatLengthError,
+      Length16: zhCN.formatLengthError,
+      LessThan1: zhCN.formatLessThanError,
+      LessThan200: zhCN.formatLessThanError,
+      LessThanOrEqualTo1: zhCN.formatLessThanOrEqualToError,
+      Literal: zhCN.formatLiteralError,
+      Map: zhCN.formatMapError,
+      MaxLength2: zhCN.formatMaxLengthError,
+      MaxLength64: zhCN.formatMaxLengthError,
+      MaxLength100: zhCN.formatMaxLengthError,
+      MaxLength1000: zhCN.formatMaxLengthError,
+      MinLength1: zhCN.formatMinLengthError,
+      MinLength2: zhCN.formatMinLengthError,
+      MinLength8: zhCN.formatMinLengthError,
+      Mnemonic: zhCN.formatMnemonicError,
+      MultipleOf2: zhCN.formatMultipleOfError,
+      Name: zhCN.formatNameError,
+      Negative: zhCN.formatNegativeError,
+      NegativeDecimalString: zhCN.formatNegativeDecimalStringError,
+      Never: zhCN.formatNeverError,
+      NonNaN: zhCN.formatNonNaNError,
+      NonNegative: zhCN.formatNonNegativeError,
+      NonNegativeDecimalString: zhCN.formatNonNegativeDecimalStringError,
+      NonPositive: zhCN.formatNonPositiveError,
+      NonPositiveDecimalString: zhCN.formatNonPositiveDecimalStringError,
+      Number: zhCN.formatNumberError,
+      Object: zhCN.formatObjectError,
+      ObjectTag: zhCN.formatObjectTagError,
+      Positive: zhCN.formatPositiveError,
+      PositiveDecimalString: zhCN.formatPositiveDecimalStringError,
+      Record: zhCN.formatRecordError,
+      RecordKey: zhCN.formatRegexError,
+      Regex: zhCN.formatRegexError,
+      Set: zhCN.formatSetError,
+      String: zhCN.formatStringError,
+      Symbol: zhCN.formatSymbolError,
+      TableId: zhCN.formatTableIdError,
+      TemplateLiteral: zhCN.formatTemplateLiteralError,
+      Trimmed: zhCN.formatTrimmedError,
+      Tuple: zhCN.formatTupleError,
+      UInt64: zhCN.formatUInt64Error,
+      Union: zhCN.formatUnionError,
+      UrlSafeString: zhCN.formatRegexError,
+    },
+    zhTW: {
+      Array: zhTW.formatArrayError,
+      Base64Url: zhTW.formatBase64UrlError,
+      [Between1And2.name]: zhTW.formatBetweenError,
+      BigInt: zhTW.formatBigIntError,
+      Boolean: zhTW.formatBooleanError,
+      Capitalized: zhTW.formatCapitalizedError,
+      DateIso: zhTW.formatDateIsoError,
+      DateIsoFromDate: zhTW.formatDateIsoFromDateError,
+      DecimalString: zhTW.formatDecimalStringError,
+      DiscriminatedUnion: zhTW.formatDiscriminatedUnionError,
+      EvoluType: zhTW.formatEvoluTypeError,
+      Finite: zhTW.formatFiniteError,
+      Function: zhTW.formatFunctionError,
+      GreaterThan1: zhTW.formatGreaterThanError,
+      GreaterThanOrEqualTo1: zhTW.formatGreaterThanOrEqualToError,
+      Id: zhTW.formatIdError,
+      InstanceOf: zhTW.formatInstanceOfError,
+      Int: zhTW.formatIntError,
+      Int64: zhTW.formatInt64Error,
+      Int64String: zhTW.formatInt64StringError,
+      Json: zhTW.formatJsonError,
+      JsonValue: zhTW.formatJsonValueError,
+      Length2: zhTW.formatLengthError,
+      Length16: zhTW.formatLengthError,
+      LessThan1: zhTW.formatLessThanError,
+      LessThan200: zhTW.formatLessThanError,
+      LessThanOrEqualTo1: zhTW.formatLessThanOrEqualToError,
+      Literal: zhTW.formatLiteralError,
+      Map: zhTW.formatMapError,
+      MaxLength2: zhTW.formatMaxLengthError,
+      MaxLength64: zhTW.formatMaxLengthError,
+      MaxLength100: zhTW.formatMaxLengthError,
+      MaxLength1000: zhTW.formatMaxLengthError,
+      MinLength1: zhTW.formatMinLengthError,
+      MinLength2: zhTW.formatMinLengthError,
+      MinLength8: zhTW.formatMinLengthError,
+      Mnemonic: zhTW.formatMnemonicError,
+      MultipleOf2: zhTW.formatMultipleOfError,
+      Name: zhTW.formatNameError,
+      Negative: zhTW.formatNegativeError,
+      NegativeDecimalString: zhTW.formatNegativeDecimalStringError,
+      Never: zhTW.formatNeverError,
+      NonNaN: zhTW.formatNonNaNError,
+      NonNegative: zhTW.formatNonNegativeError,
+      NonNegativeDecimalString: zhTW.formatNonNegativeDecimalStringError,
+      NonPositive: zhTW.formatNonPositiveError,
+      NonPositiveDecimalString: zhTW.formatNonPositiveDecimalStringError,
+      Number: zhTW.formatNumberError,
+      Object: zhTW.formatObjectError,
+      ObjectTag: zhTW.formatObjectTagError,
+      Positive: zhTW.formatPositiveError,
+      PositiveDecimalString: zhTW.formatPositiveDecimalStringError,
+      Record: zhTW.formatRecordError,
+      RecordKey: zhTW.formatRegexError,
+      Regex: zhTW.formatRegexError,
+      Set: zhTW.formatSetError,
+      String: zhTW.formatStringError,
+      Symbol: zhTW.formatSymbolError,
+      TableId: zhTW.formatTableIdError,
+      TemplateLiteral: zhTW.formatTemplateLiteralError,
+      Trimmed: zhTW.formatTrimmedError,
+      Tuple: zhTW.formatTupleError,
+      UInt64: zhTW.formatUInt64Error,
+      Union: zhTW.formatUnionError,
+      UrlSafeString: zhTW.formatRegexError,
+    },
+  },
+);
+
+describe("Type localization", () => {
+  test("defines localized types", () => {
+    assertNotUndefined(typesByLocale);
+    assertLength(Object.keys(typesByLocale), 43);
+  });
+
+  test("formats Czech symbol property errors", () => {
+    const key = Symbol("key");
+
+    assertEqual(
+      cs.formatObjectError({
+        type: "Object",
+        reason: {
+          kind: "Properties",
+          errors: { [key]: { type: "ObjectExcessProperty" } },
+        },
+      }),
+      "Klíč vlastnosti typu Object musí být text. Odstraňte symbolovou vlastnost nebo použijte jiný Type.",
+    );
+  });
+
+  test("formats Czech Map errors", () => {
+    assertEqual(
+      cs.formatMapError({
+        type: "Map",
+        reason: { kind: "NotMap", value: null },
+      }),
+      "Hodnota null není Map.",
+    );
+    assertEqual(
+      cs.formatMapError({
+        type: "Map",
+        reason: {
+          kind: "Entries",
+          issues: [{ kind: "ExcessProperty", key: "metadata" }],
+        },
+      }),
+      'Map obsahuje nepovolenou vlastní vlastnost "metadata".',
+    );
+    assertEqual(
+      cs.formatMapError({
+        type: "Map",
+        reason: {
+          kind: "Entries",
+          issues: [
+            {
+              kind: "Collision",
+              index: 1,
+              key: "a",
+              previousIndex: 0,
+              previousKey: "A",
+              outputKey: "a",
+            },
+          ],
+        },
+      }),
+      'Klíče Mapu "A" a "a" se dekódují na stejný klíč "a".',
+    );
+  });
+});