@bgord/tools 1.3.24 → 1.4.1

package/dist/file-path-relative-schema.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { DirectoryPathRelativeSchema } from "./directory-path-relative.vo";
 import { Filename } from "./filename.vo";
 export const FilePathRelativeSchemaError = {
@@ -8,20 +8,13 @@ export const FilePathRelativeSchemaError = {
     RequiresDirectory: "file.path.relative.requires.directory",
     Empty: "file.path.relative.empty",
 };
-// Stryker disable all
-export const FilePathRelativeSchema = z
-    // Stryker restore all
-    .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) => {
+export const FilePathRelativeSchema = v.pipe(v.string(FilePathRelativeSchemaError.Type), v.minLength(1, FilePathRelativeSchemaError.Empty), v.check((value) => !value.startsWith("/"), FilePathRelativeSchemaError.LeadingSlash), v.check((value) => !value.includes("\\"), FilePathRelativeSchemaError.BackslashForbidden), v.check((value) => value.includes("/"), FilePathRelativeSchemaError.RequiresDirectory), v.transform((normalized) => {
     const lastSlashIndex = normalized.lastIndexOf("/");
     const directoryCandidate = normalized.slice(0, lastSlashIndex);
     const filenameCandidate = normalized.slice(lastSlashIndex + 1);
-    const directory = DirectoryPathRelativeSchema.parse(directoryCandidate);
+    const directory = v.parse(DirectoryPathRelativeSchema, directoryCandidate);
     const filename = Filename.fromString(filenameCandidate);
     return { directory, filename };
-})
-    .brand("FilePathRelativeSchema");
+}), 
+// Stryker disable next-line StringLiteral
+v.brand("FilePathRelativeSchema"));

package/dist/file-path.vo.js

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { DirectoryPathAbsoluteSchema } from "./directory-path-absolute.vo";
 import { DirectoryPathRelativeSchema } from "./directory-path-relative.vo";
 import { FilePathAbsoluteSchema } from "./file-path-absolute-schema.vo";
@@ -10,14 +11,14 @@ export class FilePathRelative {
         this.filename = filename;
     }
     static fromParts(directoryCandidate, filename) {
-        const directory = DirectoryPathRelativeSchema.parse(directoryCandidate);
+        const directory = v.parse(DirectoryPathRelativeSchema, directoryCandidate);
         return new FilePathRelative(directory, filename);
     }
     static fromPartsSafe(directory, filename) {
         return new FilePathRelative(directory, filename);
     }
     static fromString(candidate) {
-        const schema = FilePathRelativeSchema.parse(candidate);
+        const schema = v.parse(FilePathRelativeSchema, candidate);
         return new FilePathRelative(schema.directory, schema.filename);
     }
     get() {
@@ -47,14 +48,14 @@ export class FilePathAbsolute {
         this.filename = filename;
     }
     static fromParts(directoryCandidate, filename) {
-        const directory = DirectoryPathAbsoluteSchema.parse(directoryCandidate);
+        const directory = v.parse(DirectoryPathAbsoluteSchema, directoryCandidate);
         return new FilePathAbsolute(directory, filename);
     }
     static fromPartsSafe(directory, filename) {
         return new FilePathAbsolute(directory, filename);
     }
     static fromString(candidate) {
-        const schema = FilePathAbsoluteSchema.parse(candidate);
+        const schema = v.parse(FilePathAbsoluteSchema, candidate);
         return new FilePathAbsolute(schema.directory, schema.filename);
     }
     get() {

package/dist/filename-affix.vo.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare enum FilenameAffixStrategy {
     prefix = "prefix",
     suffix = "suffix"
@@ -9,5 +9,5 @@ export declare const FilenameAffixError: {
     TooLong: string;
     BadChars: string;
 };
-export declare const FilenameAffix: z.core.$ZodBranded<z.ZodString, "FilenameAffix", "out">;
-export type FilenameAffixType = z.infer<typeof FilenameAffix>;
+export declare const FilenameAffix: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 32, string>, v.RegexAction<string, string>, v.BrandAction<string, "FilenameAffix">]>;
+export type FilenameAffixType = v.InferOutput<typeof FilenameAffix>;

package/dist/filename-affix.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export var FilenameAffixStrategy;
 (function (FilenameAffixStrategy) {
     FilenameAffixStrategy["prefix"] = "prefix";
@@ -12,11 +12,6 @@ export const FilenameAffixError = {
 };
 // Letters, digits, underscores, and hyphens allowed
 const FILENAME_AFFIX_WHITELIST = /^[a-zA-Z0-9_-]+$/;
-// Stryker disable all
-export const FilenameAffix = z
-    // Stryker restore all
-    .string(FilenameAffixError.Type)
-    .min(1, FilenameAffixError.Empty)
-    .max(32, FilenameAffixError.TooLong)
-    .regex(FILENAME_AFFIX_WHITELIST, FilenameAffixError.BadChars)
-    .brand("FilenameAffix");
+export const FilenameAffix = v.pipe(v.string(FilenameAffixError.Type), v.minLength(1, FilenameAffixError.Empty), v.maxLength(32, FilenameAffixError.TooLong), v.regex(FILENAME_AFFIX_WHITELIST, FilenameAffixError.BadChars), 
+// Stryker disable next-line StringLiteral
+v.brand("FilenameAffix"));

package/dist/filename-from-string.vo.d.ts

@@ -1,10 +1,10 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const FilenameFromStringError: {
     Type: string;
     Invalid: string;
 };
-export declare const FilenameFromString: z.ZodPipe<z.ZodString, z.ZodTransform<{
-    basename: string & z.core.$brand<"Basename">;
-    extension: string & z.core.$brand<"Extension">;
-}, string>>;
-export type FilenameFromStringType = z.infer<typeof FilenameFromString>;
+export declare const FilenameFromString: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.TransformAction<string, {
+    basename: string & v.Brand<"Basename">;
+    extension: string & v.Brand<"Extension">;
+}>]>;
+export type FilenameFromStringType = v.InferOutput<typeof FilenameFromString>;

package/dist/filename-from-string.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { Basename } from "./basename.vo";
 import { Extension } from "./extension.vo";
 export const FilenameFromStringError = {
@@ -9,12 +9,9 @@ export const FilenameFromStringError = {
 // .
 // .+ at least one character
 const DOT_WITH_SIDES = /^.+\..+$/;
-export const FilenameFromString = z
-    .string(FilenameFromStringError.Type)
-    .regex(DOT_WITH_SIDES, FilenameFromStringError.Invalid)
-    .transform((value) => {
+export const FilenameFromString = v.pipe(v.string(FilenameFromStringError.Type), v.regex(DOT_WITH_SIDES, FilenameFromStringError.Invalid), v.transform((value) => {
     const index = value.lastIndexOf(".");
-    const basename = Basename.parse(value.slice(0, index));
-    const extension = Extension.parse(value.slice(index + 1));
+    const basename = v.parse(Basename, value.slice(0, index));
+    const extension = v.parse(Extension, value.slice(index + 1));
     return { basename, extension };
-});
+}));

package/dist/filename.vo.js

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { Basename } from "./basename.vo";
 import { Extension } from "./extension.vo";
 import { FilenameAffix, FilenameAffixStrategy } from "./filename-affix.vo";
@@ -10,13 +11,13 @@ export class Filename {
         this.extension = extension;
     }
     static fromParts(basename, extension) {
-        return new Filename(Basename.parse(basename), Extension.parse(extension));
+        return new Filename(v.parse(Basename, basename), v.parse(Extension, extension));
     }
     static fromPartsSafe(basename, extension) {
         return new Filename(basename, extension);
     }
     static fromString(candidate) {
-        const filename = FilenameFromString.parse(candidate);
+        const filename = v.parse(FilenameFromString, candidate);
         return new Filename(filename.basename, filename.extension);
     }
     get() {
@@ -35,17 +36,17 @@ export class Filename {
         return new Filename(basename, this.extension);
     }
     withAffix(candidate, strategy) {
-        const affix = FilenameAffix.parse(candidate);
+        const affix = v.parse(FilenameAffix, candidate);
         if (strategy === FilenameAffixStrategy.prefix) {
-            return new Filename(Basename.parse(`${affix}${this.basename}`), this.extension);
+            return new Filename(v.parse(Basename, `${affix}${this.basename}`), this.extension);
         }
-        return new Filename(Basename.parse(`${this.basename}${affix}`), this.extension);
+        return new Filename(v.parse(Basename, `${this.basename}${affix}`), this.extension);
     }
     withAffixSafe(affix, strategy) {
         if (strategy === FilenameAffixStrategy.prefix) {
-            return new Filename(Basename.parse(`${affix}${this.basename}`), this.extension);
+            return new Filename(v.parse(Basename, `${affix}${this.basename}`), this.extension);
         }
-        return new Filename(Basename.parse(`${this.basename}${affix}`), this.extension);
+        return new Filename(v.parse(Basename, `${this.basename}${affix}`), this.extension);
     }
     withSuffix(candidate) {
         return this.withAffix(candidate, FilenameAffixStrategy.suffix);

package/dist/height-milimiters.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const HeightMillimetersError: {
     Type: string;
     Invalid: string;
 };
-export declare const HeightMillimeters: z.core.$ZodBranded<z.ZodNumber, "HeightMillimeters", "out">;
-export type HeightMillimetersType = z.infer<typeof HeightMillimeters>;
+export declare const HeightMillimeters: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "HeightMillimeters">]>;
+export type HeightMillimetersType = v.InferOutput<typeof HeightMillimeters>;

package/dist/height-milimiters.vo.js

@@ -1,12 +1,8 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const HeightMillimetersError = {
     Type: "height.millimeters.type",
     Invalid: "height.millimeters.invalid",
 };
-// Stryker disable all
-export const HeightMillimeters = z
-    // Stryker restore all
-    .number(HeightMillimetersError.Type)
-    .int(HeightMillimetersError.Type)
-    .min(0, HeightMillimetersError.Invalid)
-    .brand("HeightMillimeters");
+export const HeightMillimeters = v.pipe(v.number(HeightMillimetersError.Type), v.integer(HeightMillimetersError.Type), v.minValue(0, HeightMillimetersError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("HeightMillimeters"));

package/dist/height.vo.js

@@ -1,21 +1,22 @@
+import * as v from "valibot";
 import { HeightMillimeters } from "./height-milimiters.vo";
 import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
 export class Height {
     millimeters;
-    static ZERO = HeightMillimeters.parse(0);
+    static ZERO = v.parse(HeightMillimeters, 0);
     static MILLIMETERS_PER_CENTIMETER = 10;
     constructor(millimeters) {
         this.millimeters = millimeters;
     }
     static fromMillimeters(millimeters) {
-        return new Height(HeightMillimeters.parse(millimeters));
+        return new Height(v.parse(HeightMillimeters, millimeters));
     }
     static fromMillimetersSafe(millimeters) {
         return new Height(millimeters);
     }
     static fromCentimeters(centimeters, rounding = new RoundingToNearestStrategy()) {
         const millimeters = rounding.round(centimeters * Height.MILLIMETERS_PER_CENTIMETER);
-        return new Height(HeightMillimeters.parse(millimeters));
+        return new Height(v.parse(HeightMillimeters, millimeters));
     }
     static zero() {
         return Height.fromMillimetersSafe(Height.ZERO);

package/dist/hour-value.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const HourValueError: {
     Type: string;
     Invalid: string;
 };
-export declare const HourValue: z.core.$ZodBranded<z.ZodNumber, "HourSchema", "out">;
-export type HourValueType = z.infer<typeof HourValue>;
+export declare const HourValue: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.MaxValueAction<number, 23, string>, v.BrandAction<number, "HourSchema">]>;
+export type HourValueType = v.InferOutput<typeof HourValue>;

package/dist/hour-value.vo.js

@@ -1,10 +1,5 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const HourValueError = { Type: "hour.value.type", Invalid: "hour.value.invalid" };
-// Stryker disable all
-export const HourValue = z
-    // Stryker restore all
-    .number(HourValueError.Type)
-    .int(HourValueError.Type)
-    .gte(0, HourValueError.Invalid)
-    .lte(23, HourValueError.Invalid)
-    .brand("HourSchema");
+export const HourValue = v.pipe(v.number(HourValueError.Type), v.integer(HourValueError.Type), v.minValue(0, HourValueError.Invalid), v.maxValue(23, HourValueError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("HourSchema"));

package/dist/hour.vo.js

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { HourValue } from "./hour-value.vo";
 import { Timestamp } from "./timestamp.vo";
 export class Hour {
@@ -6,13 +7,13 @@ export class Hour {
         this.value = value;
     }
     static fromValue(candidate) {
-        return new Hour(HourValue.parse(candidate));
+        return new Hour(v.parse(HourValue, candidate));
     }
     static fromValueSafe(candidate) {
         return new Hour(candidate);
     }
     static fromTimestamp(timestamp) {
-        return new Hour(HourValue.parse(new Date(timestamp.ms).getUTCHours()));
+        return new Hour(v.parse(HourValue, new Date(timestamp.ms).getUTCHours()));
     }
     static fromTimestampValue(timestamp) {
         return Hour.fromTimestamp(Timestamp.fromValue(timestamp));

package/dist/iban-schema.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const IbanSchemaError: {
     Type: string;
     Invalid: string;
 };
-export declare const IbanSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "IbanSchema", "out">;
-export type IbanSchemaType = z.infer<typeof IbanSchema>;
+export declare const IbanSchema: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.ToUpperCaseAction, v.TransformAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "IbanSchema">]>;
+export type IbanSchemaType = v.InferOutput<typeof IbanSchema>;

package/dist/iban-schema.vo.js

@@ -1,12 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const IbanSchemaError = { Type: "iban.schema.type", Invalid: "iban.schema.invalid" };
 // 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}$/;
-// Stryker disable all
-export const IbanSchema = z
-    // Stryker restore all
-    .string(IbanSchemaError.Type)
-    .toUpperCase()
-    .transform((value) => value.replaceAll(" ", ""))
-    .refine((value) => IBAN_CHARS_WHITELIST.test(value), IbanSchemaError.Invalid)
-    .brand("IbanSchema");
+export const IbanSchema = v.pipe(v.string(IbanSchemaError.Type), v.toUpperCase(), v.transform((value) => value.replaceAll(" ", "")), v.check((value) => IBAN_CHARS_WHITELIST.test(value), IbanSchemaError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("IbanSchema"));

package/dist/iban.vo.js

@@ -1,8 +1,9 @@
+import * as v from "valibot";
 import { IbanSchema } from "./iban-schema.vo";
 export class IBAN {
     value;
     constructor(candidate) {
-        this.value = IbanSchema.parse(candidate);
+        this.value = v.parse(IbanSchema, candidate);
     }
     toString() {
         return this.value;

package/dist/image.vo.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const ImageWidthError: {
     Type: string;
     Length: string;
@@ -7,7 +7,7 @@ export declare const ImageHeightError: {
     Type: string;
     Length: string;
 };
-export declare const ImageWidth: z.core.$ZodBranded<z.ZodNumber, "ImageWidth", "out">;
-export type ImageWidthType = z.infer<typeof ImageWidth>;
-export declare const ImageHeight: z.core.$ZodBranded<z.ZodNumber, "ImageHeight", "out">;
-export type ImageHeightType = z.infer<typeof ImageHeight>;
+export declare const ImageWidth: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, number, string>, v.MaxValueAction<number, number, string>, v.BrandAction<number, "ImageWidth">]>;
+export type ImageWidthType = v.InferOutput<typeof ImageWidth>;
+export declare const ImageHeight: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, number, string>, v.MaxValueAction<number, number, string>, v.BrandAction<number, "ImageHeight">]>;
+export type ImageHeightType = v.InferOutput<typeof ImageHeight>;

package/dist/image.vo.js

@@ -1,20 +1,10 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const ImageWidthError = { Type: "image.width.type", Length: "image.width.length" };
 export const ImageHeightError = { Type: "image.height.type", Length: "image.height.length" };
 const IMAGE_DIMENSIONS_CONSTRAINTS = { min: 1, max: 10_000 };
-// Stryker disable all
-export const ImageWidth = z
-    // Stryker restore all
-    .number(ImageWidthError.Type)
-    .int(ImageWidthError.Type)
-    .min(IMAGE_DIMENSIONS_CONSTRAINTS.min, ImageWidthError.Length)
-    .max(IMAGE_DIMENSIONS_CONSTRAINTS.max, ImageWidthError.Length)
-    .brand("ImageWidth");
-// Stryker disable all
-export const ImageHeight = z
-    // Stryker restore all
-    .number(ImageHeightError.Type)
-    .int(ImageHeightError.Type)
-    .min(IMAGE_DIMENSIONS_CONSTRAINTS.min, ImageHeightError.Length)
-    .max(IMAGE_DIMENSIONS_CONSTRAINTS.max, ImageHeightError.Length)
-    .brand("ImageHeight");
+export const ImageWidth = v.pipe(v.number(ImageWidthError.Type), v.integer(ImageWidthError.Type), v.minValue(IMAGE_DIMENSIONS_CONSTRAINTS.min, ImageWidthError.Length), v.maxValue(IMAGE_DIMENSIONS_CONSTRAINTS.max, ImageWidthError.Length), 
+// Stryker disable next-line StringLiteral
+v.brand("ImageWidth"));
+export const ImageHeight = v.pipe(v.number(ImageHeightError.Type), v.integer(ImageHeightError.Type), v.minValue(IMAGE_DIMENSIONS_CONSTRAINTS.min, ImageHeightError.Length), v.maxValue(IMAGE_DIMENSIONS_CONSTRAINTS.max, ImageHeightError.Length), 
+// Stryker disable next-line StringLiteral
+v.brand("ImageHeight"));

package/dist/integer-non-negative.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const IntegerNonNegativeError: {
     Type: string;
     Invalid: string;
 };
-export declare const IntegerNonNegative: z.core.$ZodBranded<z.ZodNumber, "IntegerNonNegative", "out">;
-export type IntegerNonNegativeType = z.infer<typeof IntegerNonNegative>;
+export declare const IntegerNonNegative: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "IntegerNonNegative">]>;
+export type IntegerNonNegativeType = v.InferOutput<typeof IntegerNonNegative>;

package/dist/integer-non-negative.vo.js

@@ -1,12 +1,8 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const IntegerNonNegativeError = {
     Type: "integer.non.negative.type",
     Invalid: "integer.non.negative.invalid",
 };
-// Stryker disable all
-export const IntegerNonNegative = z
-    // Stryker restore all
-    .number(IntegerNonNegativeError.Type)
-    .int(IntegerNonNegativeError.Type)
-    .min(0, IntegerNonNegativeError.Invalid)
-    .brand("IntegerNonNegative");
+export const IntegerNonNegative = v.pipe(v.number(IntegerNonNegativeError.Type), v.integer(IntegerNonNegativeError.Type), v.minValue(0, IntegerNonNegativeError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("IntegerNonNegative"));

package/dist/integer-positive.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const IntegerPositiveError: {
     Type: string;
     Invalid: string;
 };
-export declare const IntegerPositive: z.core.$ZodBranded<z.ZodNumber, "IntegerPositive", "out">;
-export type IntegerPositiveType = z.infer<typeof IntegerPositive>;
+export declare const IntegerPositive: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 1, string>, v.BrandAction<number, "IntegerPositive">]>;
+export type IntegerPositiveType = v.InferOutput<typeof IntegerPositive>;

package/dist/integer-positive.vo.js

@@ -1,9 +1,5 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const IntegerPositiveError = { Type: "integer.positive.type", Invalid: "integer.positive.invalid" };
-// Stryker disable all
-export const IntegerPositive = z
-    // Stryker restore all
-    .number(IntegerPositiveError.Type)
-    .int(IntegerPositiveError.Type)
-    .min(1, IntegerPositiveError.Invalid)
-    .brand("IntegerPositive");
+export const IntegerPositive = v.pipe(v.number(IntegerPositiveError.Type), v.integer(IntegerPositiveError.Type), v.minValue(1, IntegerPositiveError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("IntegerPositive"));

package/dist/integer.vo.d.ts

@@ -1,6 +1,6 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const IntegerError: {
     Type: string;
 };
-export declare const Integer: z.core.$ZodBranded<z.ZodNumber, "Integer", "out">;
-export type IntegerType = z.infer<typeof Integer>;
+export declare const Integer: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.BrandAction<number, "Integer">]>;
+export type IntegerType = v.InferOutput<typeof Integer>;

package/dist/integer.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const IntegerError = { Type: "integer.type" };
-// Stryker disable all
-export const Integer = z.number(IntegerError.Type).int(IntegerError.Type).brand("Integer");
+// Stryker disable next-line StringLiteral
+export const Integer = v.pipe(v.number(IntegerError.Type), v.integer(IntegerError.Type), v.brand("Integer"));

package/dist/language.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const LanguageError: {
     Type: string;
     BadChars: string;
 };
-export declare const Language: z.ZodString;
-export type LanguageType = z.infer<typeof Language>;
+export declare const Language: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>]>;
+export type LanguageType = v.InferOutput<typeof Language>;

package/dist/language.vo.js

@@ -1,5 +1,5 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const LanguageError = { Type: "language.type", BadChars: "language.bad.chars" };
 // Two lowercase letters
 const LANGUAGE_CHARS_WHITELIST = /^[a-z]{2}$/;
-export const Language = z.string(LanguageError.Type).regex(LANGUAGE_CHARS_WHITELIST, LanguageError.BadChars);
+export const Language = v.pipe(v.string(LanguageError.Type), v.regex(LANGUAGE_CHARS_WHITELIST, LanguageError.BadChars));

package/dist/mime-value.vo.d.ts

@@ -1,6 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const MimeValueError: {
     Type: string;
     Invalid: string;
 };
-export declare const MimeValue: z.core.$ZodBranded<z.ZodString, "MimeValue", "out">;
+export declare const MimeValue: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.BrandAction<string, "MimeValue">]>;
+export type MimeValueType = v.InferOutput<typeof MimeValue>;

package/dist/mime-value.vo.js

@@ -1,10 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const MimeValueError = { Type: "mime.value.type", Invalid: "mime.value.invalid" };
 // One to twenty four lowercase letters, asterisk or hyphen, forward slash, one to seventy two lowercase letters, digits, asterisk, hyphen, plus, dot or underscore
 const MIME_VALUE_CHARS_WHITELIST = /^[a-z*-]{1,24}\/[a-z0-9*+-_.]{1,72}$/;
-// Stryker disable all
-export const MimeValue = z
-    // Stryker restore all
-    .string(MimeValueError.Type)
-    .regex(MIME_VALUE_CHARS_WHITELIST, MimeValueError.Invalid)
-    .brand("MimeValue");
+export const MimeValue = v.pipe(v.string(MimeValueError.Type), v.regex(MIME_VALUE_CHARS_WHITELIST, MimeValueError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("MimeValue"));

package/dist/mime.vo.js

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { MimeValue } from "./mime-value.vo";
 export class Mime {
     type;
@@ -7,7 +8,7 @@ export class Mime {
         this.subtype = subtype;
     }
     static fromString(candidate) {
-        const value = MimeValue.parse(candidate.split(";")[0].trim());
+        const value = v.parse(MimeValue, candidate.split(";")[0].trim());
         const [type, subtype] = value.split("/");
         return new Mime(type, subtype);
     }

package/dist/mimes.js

@@ -1,18 +1,19 @@
+import * as v from "valibot";
 import { Extension } from "./extension.vo";
 import { Mime } from "./mime.vo";
 import { MimeRegistryEntry } from "./mime-registry-entry.vo";
 export const Mimes = {
-    csv: new MimeRegistryEntry(Mime.fromString("text/csv"), [Extension.parse("csv")]),
+    csv: new MimeRegistryEntry(Mime.fromString("text/csv"), [v.parse(Extension, "csv")]),
     jpg: new MimeRegistryEntry(Mime.fromString("image/jpeg"), [
-        Extension.parse("jpg"),
-        Extension.parse("jpeg"),
+        v.parse(Extension, "jpg"),
+        v.parse(Extension, "jpeg"),
     ]),
-    markdown: new MimeRegistryEntry(Mime.fromString("text/markdown"), [Extension.parse("md")]),
-    mp4: new MimeRegistryEntry(Mime.fromString("video/mp4"), [Extension.parse("mp4")]),
-    pdf: new MimeRegistryEntry(Mime.fromString("application/pdf"), [Extension.parse("pdf")]),
-    png: new MimeRegistryEntry(Mime.fromString("image/png"), [Extension.parse("png")]),
-    text: new MimeRegistryEntry(Mime.fromString("text/plain"), [Extension.parse("txt")]),
-    webp: new MimeRegistryEntry(Mime.fromString("image/webp"), [Extension.parse("webp")]),
-    wav: new MimeRegistryEntry(Mime.fromString("audio/wav"), [Extension.parse("wav")]),
-    zip: new MimeRegistryEntry(Mime.fromString("application/zip"), [Extension.parse("zip")]),
+    markdown: new MimeRegistryEntry(Mime.fromString("text/markdown"), [v.parse(Extension, "md")]),
+    mp4: new MimeRegistryEntry(Mime.fromString("video/mp4"), [v.parse(Extension, "mp4")]),
+    pdf: new MimeRegistryEntry(Mime.fromString("application/pdf"), [v.parse(Extension, "pdf")]),
+    png: new MimeRegistryEntry(Mime.fromString("image/png"), [v.parse(Extension, "png")]),
+    text: new MimeRegistryEntry(Mime.fromString("text/plain"), [v.parse(Extension, "txt")]),
+    webp: new MimeRegistryEntry(Mime.fromString("image/webp"), [v.parse(Extension, "webp")]),
+    wav: new MimeRegistryEntry(Mime.fromString("audio/wav"), [v.parse(Extension, "wav")]),
+    zip: new MimeRegistryEntry(Mime.fromString("application/zip"), [v.parse(Extension, "zip")]),
 };

package/dist/minute-value.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const MinuteValueError: {
     Type: string;
     Invalid: string;
 };
-export declare const MinuteValue: z.core.$ZodBranded<z.ZodNumber, "MinuteValue", "out">;
-export type MinuteValueType = z.infer<typeof MinuteValue>;
+export declare const MinuteValue: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.MaxValueAction<number, 59, string>, v.BrandAction<number, "MinuteValue">]>;
+export type MinuteValueType = v.InferOutput<typeof MinuteValue>;

package/dist/minute-value.vo.js

@@ -1,10 +1,5 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const MinuteValueError = { Type: "minute.value.type", Invalid: "minute.value.invalid" };
-// Stryker disable all
-export const MinuteValue = z
-    // Stryker restore all
-    .number(MinuteValueError.Type)
-    .int(MinuteValueError.Type)
-    .gte(0, MinuteValueError.Invalid)
-    .lte(59, MinuteValueError.Invalid)
-    .brand("MinuteValue");
+export const MinuteValue = v.pipe(v.number(MinuteValueError.Type), v.integer(MinuteValueError.Type), v.minValue(0, MinuteValueError.Invalid), v.maxValue(59, MinuteValueError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("MinuteValue"));

package/dist/minute.vo.js

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { MinuteValue } from "./minute-value.vo";
 import { Timestamp } from "./timestamp.vo";
 export class Minute {
@@ -6,13 +7,13 @@ export class Minute {
         this.value = value;
     }
     static fromValue(candidate) {
-        return new Minute(MinuteValue.parse(candidate));
+        return new Minute(v.parse(MinuteValue, candidate));
     }
     static fromValueSafe(candidate) {
         return new Minute(candidate);
     }
     static fromTimestamp(timestamp) {
-        return new Minute(MinuteValue.parse(new Date(timestamp.ms).getUTCMinutes()));
+        return new Minute(v.parse(MinuteValue, new Date(timestamp.ms).getUTCMinutes()));
     }
     static fromTimestampValue(timestamp) {
         return Minute.fromTimestamp(Timestamp.fromValue(timestamp));