@bgord/tools 0.17.2 → 1.0.0

package/src/etags.vo.ts

@@ -1,7 +1,4 @@
-import { z } from "zod/v4";
-
-const RevisionValue = z.number().int().min(0);
-type RevisionValueType = z.infer<typeof RevisionValue>;
+import { RevisionValue, type RevisionValueType } from "./revision-value.vo";
 
 type ETagValueType = string;
 
@@ -28,6 +25,8 @@ export class ETag {
 
 export type WeakETagValueType = string;
 
+export const WeakETagError = { Invalid: "weak.etag.invalid" } as const;
+
 export class WeakETag {
   static HEADER_NAME = "ETag";
 
@@ -40,7 +39,7 @@ export class WeakETag {
   }
 
   static fromHeader(value?: WeakETagValueType): WeakETag | null {
-    if (!value?.startsWith("W/")) throw Error("Invalid WeakETag");
+    if (!value?.startsWith("W/")) throw new Error(WeakETagError.Invalid);
 
     const candidate = Number(value.split("W/")[1]);
 

package/src/extension.vo.ts

@@ -1,18 +1,25 @@
 import { z } from "zod/v4";
 
-export const ExtensionTypeError = "extension.not.string" as const;
-export const ExtensionEmptyError = "extension.empty" as const;
-export const ExtensionTooLongError = "extension.too.long" as const;
-export const ExtensionBadCharsError = "extension.bad.chars" as const;
+export const ExtensionError = {
+  Type: "extension.type",
+  Empty: "extension.empty",
+  TooLong: "extension.too.long",
+  BadChars: "extension.bad.chars",
+} as const;
+
+// Lowercase letters and digits allowed
+const EXTENSION_WHITELIST = /^[a-z0-9]+$/;
+
+const LEADING_DOT_FILE = /^\./;
 
 export const Extension = z
-  .string(ExtensionTypeError)
-  .trim()
+  .string(ExtensionError.Type)
   .toLowerCase()
-  .transform((value) => (value.startsWith(".") ? value.slice(1) : value))
-  .refine((value) => value.length >= 1, ExtensionEmptyError)
-  .refine((value) => value.length <= 16, ExtensionTooLongError)
-  .refine((value) => /^[a-z0-9]+$/.test(value), ExtensionBadCharsError)
+  .min(2, ExtensionError.Empty)
+  .max(16, ExtensionError.TooLong)
+  // Transform ".png" -> "png"
+  .transform((value) => value.replace(LEADING_DOT_FILE, ""))
+  .refine((value) => EXTENSION_WHITELIST.test(value), ExtensionError.BadChars)
   .brand("Extension");
 
 export type ExtensionType = z.infer<typeof Extension>;

package/src/feature-flag-value.vo.ts

@@ -0,0 +1,12 @@
+import { z } from "zod/v4";
+
+export const FeatureFlagValueError = { Invalid: "feature.flag.value.invalid" } as const;
+
+export enum FeatureFlagEnum {
+  yes = "yes",
+  no = "no",
+}
+
+export const FeatureFlagValue = z.enum(FeatureFlagEnum, FeatureFlagValueError.Invalid);
+
+export type FeatureFlagValueType = z.infer<typeof FeatureFlagValue>;

package/src/feature-flag.vo.ts

@@ -1,12 +1,4 @@
-import { z } from "zod/v4";
-
-export enum FeatureFlagEnum {
-  yes = "yes",
-  no = "no",
-}
-
-export const FeatureFlagValue = z.enum(FeatureFlagEnum);
-export type FeatureFlagValueType = z.infer<typeof FeatureFlagValue>;
+import { FeatureFlagEnum, type FeatureFlagValueType } from "./feature-flag-value.vo";
 
 export class FeatureFlag {
   static isEnabled(flag: FeatureFlagValueType): boolean {

package/src/file-path-absolute-schema.vo.ts

@@ -2,30 +2,31 @@ import { z } from "zod/v4";
 import { DirectoryPathAbsoluteSchema } from "./directory-path-absolute.vo";
 import { Filename } from "./filename.vo";
 
-export const AbsFilePathTypeError = "abs.file.path.not.string" as const;
-export const AbsFilePathMustStartWithSlashError = "abs_file_path_must_start_with_slash" as const;
-export const AbsFilePathBackslashForbiddenError = "abs_file_path_backslash_forbidden" as const;
-export const AbsFilePathMissingFilenameError = "abs_file_path_missing_filename" as const;
+export const FilePathAbsoluteSchemaError = {
+  Type: "file.path.absolute.type",
+  LeadingSlash: "file.path.absolute.leading.slash",
+  TrailingSlash: "file.path.absolute.trailing.slash",
+  BackslashForbidden: "file.path.absolute.backslash.forbidden",
+  Empty: "file.path.absolute.empty",
+} as const;
 
 export const FilePathAbsoluteSchema = z
-  .string(AbsFilePathTypeError)
-  .trim()
-  .refine((value) => value.startsWith("/"), AbsFilePathMustStartWithSlashError)
-  .refine((value) => !value.includes("\\"), AbsFilePathBackslashForbiddenError)
-  // collapse duplicate slashes
-  .transform((value) => value.replace(/\/{2,}/g, "/"))
-  // keep "/" as-is; otherwise remove a trailing slash
-  .transform((value) => (value !== "/" && value.endsWith("/") ? value.slice(0, -1) : value))
-  .refine((value) => value !== "/", AbsFilePathMissingFilenameError)
+  .string(FilePathAbsoluteSchemaError.Type)
+  .min(1, FilePathAbsoluteSchemaError.Empty)
+  .refine((value) => value.startsWith("/"), FilePathAbsoluteSchemaError.LeadingSlash)
+  .refine((value) => !value.endsWith("/"), FilePathAbsoluteSchemaError.TrailingSlash)
+  .refine((value) => !value.includes("\\"), FilePathAbsoluteSchemaError.BackslashForbidden)
   .transform((normalized) => {
-    const lastSlashIndex = normalized.lastIndexOf("/");
-    const directoryCandidate = lastSlashIndex === 0 ? "/" : normalized.slice(0, lastSlashIndex);
-    const filenameCandidate = normalized.slice(lastSlashIndex + 1);
+    const index = normalized.lastIndexOf("/");
+
+    const directoryCandidate = index === 0 ? "/" : normalized.slice(0, index);
+    const filenameCandidate = normalized.slice(index + 1);
 
     const directory = DirectoryPathAbsoluteSchema.parse(directoryCandidate);
     const filename = Filename.fromString(filenameCandidate);
 
     return { directory, filename };
-  });
+  })
+  .brand("FilePathAbsoluteSchema");
 
 export type FilePathAbsoluteType = z.infer<typeof FilePathAbsoluteSchema>;

package/src/file-path-relative-schema.vo.ts

@@ -2,21 +2,23 @@ import { z } from "zod/v4";
 import { DirectoryPathRelativeSchema } from "./directory-path-relative.vo";
 import { Filename } from "./filename.vo";
 
-export const RelFilePathTypeError = "rel.file.path.not.string" as const;
-export const RelFilePathMustNotStartWithSlashError = "rel_file_path_must_not_start_with_slash" as const;
-export const RelFilePathBackslashForbiddenError = "rel_file_path_backslash_forbidden" as const;
-export const RelFilePathRequiresDirectoryError = "rel_file_path_requires_directory" as const;
+export const FilePathRelativeSchemaError = {
+  Type: "file.path.relative.type",
+  LeadingSlash: "file.path.relative.leading.slash",
+  BackslashForbidden: "file.path.relative.backslash.forbidden",
+  RequiresDirectory: "file.path.relative.requires.directory",
+  Empty: "file.path.relative.empty",
+} as const;
 
 export const FilePathRelativeSchema = z
-  .string(RelFilePathTypeError)
-  .trim()
-  .refine((value) => !value.startsWith("/"), RelFilePathMustNotStartWithSlashError)
-  .refine((value) => !value.includes("\\"), RelFilePathBackslashForbiddenError)
-  // collapse duplicate slashes, then trim leading/trailing slashes
-  .transform((value) => value.replace(/\/{2,}/g, "/").replace(/^\/+|\/+$/g, ""))
-  .refine((value) => value.includes("/"), RelFilePathRequiresDirectoryError)
+  .string(FilePathRelativeSchemaError.Type)
+  .min(1, FilePathRelativeSchemaError.Empty)
+  .refine((value) => !value.startsWith("/"), FilePathRelativeSchemaError.LeadingSlash)
+  .refine((value) => !value.includes("\\"), FilePathRelativeSchemaError.BackslashForbidden)
+  .refine((value) => value.includes("/"), FilePathRelativeSchemaError.RequiresDirectory)
   .transform((normalized) => {
     const lastSlashIndex = normalized.lastIndexOf("/");
+
     const directoryCandidate = normalized.slice(0, lastSlashIndex);
     const filenameCandidate = normalized.slice(lastSlashIndex + 1);
 
@@ -24,6 +26,7 @@ export const FilePathRelativeSchema = z
     const filename = Filename.fromString(filenameCandidate);
 
     return { directory, filename };
-  });
+  })
+  .brand("FilePathRelativeSchema");
 
 export type FilePathRelativeType = z.infer<typeof FilePathRelativeSchema>;

package/src/file-path.vo.ts

@@ -20,10 +20,10 @@ export class FilePathRelative {
     return new FilePathRelative(directory, filename);
   }
 
-  static fromString(pathCandidate: string): FilePathRelative {
-    const parsed = FilePathRelativeSchema.parse(pathCandidate);
+  static fromString(candidate: string): FilePathRelative {
+    const schema = FilePathRelativeSchema.parse(candidate);
 
-    return new FilePathRelative(parsed.directory, parsed.filename);
+    return new FilePathRelative(schema.directory, schema.filename);
   }
 
   get(): string {
@@ -38,7 +38,7 @@ export class FilePathRelative {
     return this.filename;
   }
 
-  withDirectoryRelative(newDirectory: DirectoryPathRelativeType): FilePathRelative {
+  withDirectory(newDirectory: DirectoryPathRelativeType): FilePathRelative {
     return new FilePathRelative(newDirectory, this.filename);
   }
 
@@ -67,10 +67,10 @@ export class FilePathAbsolute {
     return new FilePathAbsolute(directory, filename);
   }
 
-  static fromString(pathCandidate: string): FilePathAbsolute {
-    const parsed = FilePathAbsoluteSchema.parse(pathCandidate);
+  static fromString(candidate: string): FilePathAbsolute {
+    const schema = FilePathAbsoluteSchema.parse(candidate);
 
-    return new FilePathAbsolute(parsed.directory, parsed.filename);
+    return new FilePathAbsolute(schema.directory, schema.filename);
   }
 
   get(): string {
@@ -86,7 +86,7 @@ export class FilePathAbsolute {
     return this.filename;
   }
 
-  withDirectoryAbsolute(newDirectory: DirectoryPathAbsoluteType): FilePathAbsolute {
+  withDirectory(newDirectory: DirectoryPathAbsoluteType): FilePathAbsolute {
     return new FilePathAbsolute(newDirectory, this.filename);
   }
 

package/src/filename-from-string.vo.ts

@@ -2,19 +2,22 @@ import { z } from "zod/v4";
 import { Basename } from "./basename.vo";
 import { Extension } from "./extension.vo";
 
-export const FilenameTypeError = "filename.not.string" as const;
-export const FilenameInvalidError = "filename.invalid" as const;
+export const FilenameFromStringError = {
+  Type: "filename.from.string.type",
+  Invalid: "filename.from.string.Invalid",
+} as const;
 
-export const FilenameFromString = z
-  .string(FilenameTypeError)
-  .trim()
-  .refine((value) => {
-    const index = value.lastIndexOf(".");
+// .+ at least one character, advances to the last dot
+// .
+// .+ at least one character
+const DOT_WITH_SIDES = /^.+\..+$/;
 
-    return index > 0 && index < value.length - 1;
-  }, FilenameInvalidError)
+export const FilenameFromString = z
+  .string(FilenameFromStringError.Type)
+  .regex(DOT_WITH_SIDES, FilenameFromStringError.Invalid)
   .transform((value) => {
     const index = value.lastIndexOf(".");
+
     const basename = Basename.parse(value.slice(0, index));
     const extension = Extension.parse(value.slice(index + 1));
 

package/src/filename-suffix.vo.ts

@@ -1,13 +1,20 @@
 import { z } from "zod/v4";
 
-export const FilenameSuffixTypeError = "suffix.not.string" as const;
-export const FilenameSuffixTooLongError = "suffix_too_long" as const;
+export const FilenameSuffixError = {
+  Type: "suffix.type",
+  Empty: "suffix.empty",
+  TooLong: "suffix.too.long",
+  BadChars: "suffix.bad.chars",
+} as const;
+
+// Letters, digits, underscores, and hyphens allowed
+const FILENAME_SUFFIX_WHITELIST = /^[a-zA-Z0-9_-]+$/;
 
 export const FilenameSuffix = z
-  .string(FilenameSuffixTypeError)
-  .trim()
-  .transform((value) => value.replace(/[^A-Za-z0-9_-]/g, ""))
-  .refine((value) => value.length <= 32, FilenameSuffixTooLongError)
-  .brand("basename_suffix");
+  .string(FilenameSuffixError.Type)
+  .min(1, FilenameSuffixError.Empty)
+  .max(32, FilenameSuffixError.TooLong)
+  .regex(FILENAME_SUFFIX_WHITELIST, FilenameSuffixError.BadChars)
+  .brand("FilenameSuffix");
 
 export type FilenameSuffixType = z.infer<typeof FilenameSuffix>;

package/src/filename.vo.ts

@@ -18,8 +18,9 @@ export class Filename {
   }
 
   static fromString(candidate: string): Filename {
-    const { basename, extension } = FilenameFromString.parse(candidate);
-    return new Filename(basename, extension);
+    const filename = FilenameFromString.parse(candidate);
+
+    return new Filename(filename.basename, filename.extension);
   }
 
   get(): string {
@@ -54,4 +55,12 @@ export class Filename {
 
     return new Filename(basename, this.extension);
   }
+
+  toString(): string {
+    return this.get();
+  }
+
+  toJSON(): string {
+    return this.get();
+  }
 }

package/src/height-milimiters.vo.ts

@@ -0,0 +1,12 @@
+import { z } from "zod/v4";
+
+export const HeightMillimetersError = {
+  Type: "height.millimeters.type",
+  Invalid: "height.millimeters.invalid",
+} as const;
+
+export const HeightMillimeters = z
+  .number(HeightMillimetersError.Type)
+  .int(HeightMillimetersError.Type)
+  .min(0, HeightMillimetersError.Invalid)
+  .brand("HeightMillimeters");

package/src/height.vo.ts

@@ -1,64 +1,20 @@
-import { z } from "zod/v4";
+import { HeightMillimeters } from "./height-milimiters.vo";
 import { RoundToDecimal, RoundToNearest } from "./rounding.adapter";
 import type { RoundingPort } from "./rounding.port";
 
-const NonFiniteNumberError = { error: "number.non_finite" } as const;
-const NumberNegativeError = { error: "number.negative" } as const;
-const MillimetersIntegerNonNegativeError = { error: "millimeters.integer_non_negative" } as const;
-const IntegerNonNegativeError = { error: "integer.non_negative" } as const;
-
-const HeightFiniteNumber = z.number(NonFiniteNumberError).refine(Number.isFinite, NonFiniteNumberError);
-
-const HeightNonNegativeQuantity = HeightFiniteNumber.min(0, NumberNegativeError);
-
-const HeightCanonicalMillimeters = HeightFiniteNumber.int(MillimetersIntegerNonNegativeError).min(
-  0,
-  MillimetersIntegerNonNegativeError,
-);
-
-const HeightRoundedWholeInches = HeightFiniteNumber.int(IntegerNonNegativeError).min(
-  0,
-  IntegerNonNegativeError,
-);
-
-export enum HeightUnit {
-  cm = "cm",
-  ft_in = "ft_in",
-}
-
 export class Height {
   private static readonly MILLIMETERS_PER_CENTIMETER = 10;
-  private static readonly MILLIMETERS_PER_INCH = 25.4;
-  private static readonly INCHES_PER_FOOT = 12;
 
   private constructor(private readonly millimeters: number) {}
 
   static fromCentimeters(centimeters: number, rounding: RoundingPort = new RoundToNearest()): Height {
-    const validatedCentimeters = HeightNonNegativeQuantity.parse(centimeters);
-    const millimetersFloat = validatedCentimeters * Height.MILLIMETERS_PER_CENTIMETER;
-    const millimetersRounded = rounding.round(millimetersFloat);
-    const validatedMillimeters = HeightCanonicalMillimeters.parse(millimetersRounded);
+    const millimeters = rounding.round(centimeters * Height.MILLIMETERS_PER_CENTIMETER);
 
-    return new Height(validatedMillimeters);
+    return new Height(HeightMillimeters.parse(millimeters));
   }
 
-  static fromFeetInches(feet: number, inches = 0, rounding: RoundingPort = new RoundToNearest()): Height {
-    const validatedFeet = HeightNonNegativeQuantity.parse(feet);
-    const validatedInches = HeightNonNegativeQuantity.parse(inches);
-    const totalInches = validatedFeet * Height.INCHES_PER_FOOT + validatedInches;
-    const millimetersFloat = totalInches * Height.MILLIMETERS_PER_INCH;
-    const millimetersRounded = rounding.round(millimetersFloat);
-    const validatedMillimeters = HeightCanonicalMillimeters.parse(millimetersRounded);
-
-    return new Height(validatedMillimeters);
-  }
-
-  static fromMillimeters(millimeters: number, rounding: RoundingPort = new RoundToNearest()): Height {
-    const validatedMillimetersInput = HeightNonNegativeQuantity.parse(millimeters);
-    const millimetersRounded = rounding.round(validatedMillimetersInput);
-    const validatedMillimeters = HeightCanonicalMillimeters.parse(millimetersRounded);
-
-    return new Height(validatedMillimeters);
+  static fromMillimeters(millimeters: number): Height {
+    return new Height(HeightMillimeters.parse(millimeters));
   }
 
   static zero(): Height {
@@ -80,44 +36,21 @@ export class Height {
     return centimeters;
   }
 
-  toFeetInches(rounding: RoundingPort = new RoundToNearest()): { feet: number; inches: number } {
-    const totalInchesFloat = this.millimeters / Height.MILLIMETERS_PER_INCH;
-    const totalInchesRounded = rounding.round(totalInchesFloat);
-    const totalWholeInches = HeightRoundedWholeInches.parse(totalInchesRounded);
+  format(rounding?: RoundingPort): string {
+    const chosen = rounding ?? new RoundToDecimal(1);
+    const value = this.toCentimeters(chosen);
 
-    const feet = Math.floor(totalWholeInches / Height.INCHES_PER_FOOT);
-    const inches = totalWholeInches % Height.INCHES_PER_FOOT;
-
-    return { feet, inches };
-  }
-
-  format(unit: HeightUnit, rounding?: RoundingPort): string {
-    if (unit === HeightUnit.cm) {
-      const chosen = rounding ?? new RoundToDecimal(1);
-      const value = this.toCentimeters(chosen);
-
-      return `${value} cm`;
-    }
-
-    const chosen = rounding ?? new RoundToNearest();
-    const parts = this.toFeetInches(chosen);
-
-    return `${parts.feet}′${parts.inches}″`;
+    return `${value} cm`;
   }
 
   toString(): string {
-    return this.format(HeightUnit.cm, new RoundToDecimal(1));
+    return this.format(new RoundToDecimal(1));
   }
 
   equals(another: Height): boolean {
     return this.millimeters === another.millimeters;
   }
 
-  compare(another: Height): -1 | 0 | 1 {
-    if (this.equals(another)) return 0;
-    return this.millimeters < another.millimeters ? -1 : 1;
-  }
-
   greaterThan(another: Height): boolean {
     return this.millimeters > another.millimeters;
   }
@@ -130,11 +63,7 @@ export class Height {
     return this.millimeters === 0;
   }
 
-  toJSON(): { mm: number } {
-    return { mm: this.millimeters };
-  }
-
-  static fromJSON(input: { mm: number }): Height {
-    return Height.fromMillimeters(input.mm);
+  toJSON(): number {
+    return this.millimeters;
   }
 }

package/src/hour-format.service.ts

@@ -12,8 +12,9 @@ export const HourFormatters: Record<HourFormatterEnum, HourFormatter> = {
   TWENTY_FOUR_HOURS: (value) => value.toString().padStart(2, "0"),
   TWENTY_FOUR_HOURS_WO_PADDING: (value) => value.toString(),
   AM_PM: (value) => {
-    const twelveHourValue = value % 12 || 12;
     const suffix = value < 12 ? "a.m." : "p.m.";
+    const twelveHourValue = value % 12 || 12;
+
     return `${twelveHourValue} ${suffix}`;
   },
   TWELVE_HOURS: (value) => (value % 12 || 12).toString().padStart(2, "0"),

package/src/hour-schema.vo.ts

@@ -0,0 +1,12 @@
+import { z } from "zod/v4";
+
+export const HourSchemaError = { Type: "hour.schema.error", Invalid: "hour.schema.invalid" };
+
+export const HourSchema = z
+  .number(HourSchemaError.Type)
+  .int(HourSchemaError.Type)
+  .gte(0, HourSchemaError.Invalid)
+  .lte(23, HourSchemaError.Invalid)
+  .brand("HourSchema");
+
+export type HourSchemaType = z.infer<typeof HourSchema>;

package/src/hour.vo.ts

@@ -1,33 +1,25 @@
 import { type HourFormatter, HourFormatters } from "./hour-format.service";
+import { HourSchema, type HourSchemaType } from "./hour-schema.vo";
 import type { TimestampType } from "./timestamp.vo";
 
-export const HourValueError = "invalid.hour" as const;
-
 export class Hour {
-  private readonly value: number;
+  private readonly value: HourSchemaType;
 
   static readonly ZERO = new Hour(0);
   static readonly MAX = new Hour(23);
 
   constructor(candidate: number) {
-    if (!Number.isInteger(candidate) || candidate < 0 || candidate >= 24) {
-      throw new Error(HourValueError);
-    }
-    this.value = candidate;
+    this.value = HourSchema.parse(candidate);
   }
 
   static fromEpochMs(timestamp: TimestampType): Hour {
     return new Hour(new Date(timestamp).getUTCHours());
   }
 
-  get(): number {
+  get(): HourSchemaType {
     return this.value;
   }
 
-  toString(): string {
-    return HourFormatters.TWENTY_FOUR_HOURS(this.value);
-  }
-
   format(formatter: HourFormatter): string {
     return formatter(this.value);
   }
@@ -47,4 +39,12 @@ export class Hour {
   static list(): readonly Hour[] {
     return Array.from({ length: 24 }, (_, index) => new Hour(index));
   }
+
+  toString(): string {
+    return HourFormatters.TWENTY_FOUR_HOURS(this.value);
+  }
+
+  toJSON(): number {
+    return this.value;
+  }
 }

package/src/iban-mask.service.ts

@@ -1,16 +1,14 @@
 import type { IBAN } from "./iban.vo";
 
-type IbanMaskedType = string;
-
 export class IbanMask {
-  static censor(iban: IBAN): IbanMaskedType {
+  static censor(iban: IBAN): string {
     const value = iban.format();
 
     const FIRST_SPACE_INDEX = 4;
-    const LAST_SPACE_START_INDEX = value.length - 5;
+    const LAST_SPACE_INDEX = value.length - 5;
 
     const start = value.slice(0, FIRST_SPACE_INDEX);
-    const middle = value.slice(FIRST_SPACE_INDEX + 1, LAST_SPACE_START_INDEX);
+    const middle = value.slice(FIRST_SPACE_INDEX + 1, LAST_SPACE_INDEX);
     const end = value.slice(-4);
 
     const maskedMiddle = middle.replace(/[A-Z0-9]/g, "*");

package/src/iban-schema.vo.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/v4";
+
+export const IbanSchemaError = { Type: "iban.schema.type", Invalid: "iban.schema.invalid" } as const;
+
+// Two letters for country code, two digits, 11–30 uppercase letters or digits
+const IBAN_CHARS_WHITELIST = /^[A-Z]{2}[0-9]{2}[A-Z0-9]{11,30}$/;
+
+export const IbanSchema = z
+  .string(IbanSchemaError.Type)
+  .toUpperCase()
+  .transform((value) => value.replaceAll(" ", ""))
+  .refine((value) => IBAN_CHARS_WHITELIST.test(value), IbanSchemaError.Invalid)
+  .brand("IbanSchema");
+
+export type IbanSchemaType = z.infer<typeof IbanSchema>;

package/src/iban.vo.ts

@@ -1,37 +1,24 @@
-import { z } from "zod/v4";
-
-export const IBANError = { error: "invalid.iban.format" } as const;
-
-// 2-letter country code + 2 digits + 11–30 alphanumerics (overall 15–34 chars)
-const IBAN_REGEX = /^[A-Z]{2}[0-9]{2}[A-Z0-9]{11,30}$/;
-
-export const IBANValue = z
-  .string(IBANError)
-  .trim()
-  .toUpperCase()
-  .transform((val) => val.replace(/\s+/g, ""))
-  .refine((iban) => IBAN_REGEX.test(iban), IBANError)
-  .brand("IBAN");
-
-export type IBANValueType = z.infer<typeof IBANValue>;
-export type IBANCountryCode = string;
+import { IbanSchema, type IbanSchemaType } from "./iban-schema.vo";
 
 export class IBAN {
-  private readonly value: IBANValueType;
+  private readonly value: IbanSchemaType;
 
-  constructor(value: string) {
-    this.value = IBANValue.parse(value);
+  constructor(candidate: string) {
+    this.value = IbanSchema.parse(candidate);
   }
 
-  toString(): IBANValueType {
+  toString(): IbanSchemaType {
     return this.value;
   }
 
   format(): string {
+    // (.{4}) - capture any four characters
+    // (?=.) - positive lookahead, at least one more character after the match
+    // "$1 " - replace each match with the group and a space
     return this.value.replace(/(.{4})(?=.)/g, "$1 ");
   }
 
-  get countryCode(): IBANCountryCode {
+  get countryCode(): string {
     return this.value.slice(0, 2);
   }