@bgord/tools 1.3.24 → 1.4.0

package/dist/{filename-from-string.vo.js → src/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 → src/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/src/height-milimiters.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const HeightMillimetersError: {
+    Type: string;
+    Invalid: string;
+};
+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/src/height-milimiters.vo.js

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+export const HeightMillimetersError = {
+    Type: "height.millimeters.type",
+    Invalid: "height.millimeters.invalid",
+};
+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 → src/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/src/hour-value.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const HourValueError: {
+    Type: string;
+    Invalid: string;
+};
+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/src/hour-value.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const HourValueError = { Type: "hour.value.type", Invalid: "hour.value.invalid" };
+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 → src/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/src/iban-schema.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const IbanSchemaError: {
+    Type: string;
+    Invalid: string;
+};
+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/src/iban-schema.vo.js

@@ -0,0 +1,7 @@
+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}$/;
+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 → src/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/src/image.vo.d.ts

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+export declare const ImageWidthError: {
+    Type: string;
+    Length: string;
+};
+export declare const ImageHeightError: {
+    Type: string;
+    Length: string;
+};
+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/src/image.vo.js

@@ -0,0 +1,10 @@
+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 };
+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/src/integer-non-negative.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const IntegerNonNegativeError: {
+    Type: string;
+    Invalid: string;
+};
+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/src/integer-non-negative.vo.js

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+export const IntegerNonNegativeError = {
+    Type: "integer.non.negative.type",
+    Invalid: "integer.non.negative.invalid",
+};
+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/src/integer-positive.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const IntegerPositiveError: {
+    Type: string;
+    Invalid: string;
+};
+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/src/integer-positive.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const IntegerPositiveError = { Type: "integer.positive.type", Invalid: "integer.positive.invalid" };
+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/src/integer.vo.d.ts

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export declare const IntegerError: {
+    Type: string;
+};
+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/src/integer.vo.js

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

package/dist/src/language.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const LanguageError: {
+    Type: string;
+    BadChars: string;
+};
+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 → src/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/src/mime-value.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const MimeValueError: {
+    Type: string;
+    Invalid: string;
+};
+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 → src/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 → src/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/src/mimes.js

@@ -0,0 +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"), [v.parse(Extension, "csv")]),
+    jpg: new MimeRegistryEntry(Mime.fromString("image/jpeg"), [
+        v.parse(Extension, "jpg"),
+        v.parse(Extension, "jpeg"),
+    ]),
+    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/src/minute-value.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const MinuteValueError: {
+    Type: string;
+    Invalid: string;
+};
+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/src/minute-value.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const MinuteValueError = { Type: "minute.value.type", Invalid: "minute.value.invalid" };
+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 → src/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));

package/dist/src/money-amount.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const MoneyAmountError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const MoneyAmount: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "MoneyAmount">]>;
+export type MoneyAmountType = v.InferOutput<typeof MoneyAmount>;

package/dist/src/money-amount.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const MoneyAmountError = { Type: "money.amount.type", Invalid: "money.amount.invalid" };
+export const MoneyAmount = v.pipe(v.number(MoneyAmountError.Type), v.integer(MoneyAmountError.Type), v.minValue(0, MoneyAmountError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("MoneyAmount"));

package/dist/{money.vo.js → src/money.vo.js}

@@ -1,14 +1,15 @@
+import * as v from "valibot";
 import { MoneyAmount } from "./money-amount.vo";
 import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
 export const MoneyError = { SubtractResultLessThanZero: "money.subtract.result.less.than.zero" };
 export class Money {
     amount;
-    static ZERO = MoneyAmount.parse(0);
+    static ZERO = v.parse(MoneyAmount, 0);
     constructor(amount) {
         this.amount = amount;
     }
     static fromAmount(candidate) {
-        return new Money(MoneyAmount.parse(candidate));
+        return new Money(v.parse(MoneyAmount, candidate));
     }
     static fromAmountSafe(candidate) {
         return new Money(candidate);
@@ -20,19 +21,19 @@ export class Money {
         return this.amount;
     }
     add(money) {
-        return new Money(MoneyAmount.parse(this.amount + money.getAmount()));
+        return new Money(v.parse(MoneyAmount, this.amount + money.getAmount()));
     }
     multiply(factor, rounding = new RoundingToNearestStrategy()) {
-        return new Money(MoneyAmount.parse(rounding.round(this.amount * factor)));
+        return new Money(v.parse(MoneyAmount, rounding.round(this.amount * factor)));
     }
     subtract(money) {
         const result = this.amount - money.getAmount();
         if (result < Money.ZERO)
             throw new Error(MoneyError.SubtractResultLessThanZero);
-        return new Money(MoneyAmount.parse(result));
+        return new Money(v.parse(MoneyAmount, result));
     }
     divide(factor, rounding = new RoundingToNearestStrategy()) {
-        return new Money(MoneyAmount.parse(rounding.round(this.amount / factor)));
+        return new Money(v.parse(MoneyAmount, rounding.round(this.amount / factor)));
     }
     equals(another) {
         return this.amount === another.getAmount();

package/dist/src/month-iso-id.vo.d.ts

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+export declare const MonthIsoIdError: {
+    Type: string;
+    BadChars: string;
+    Invalid: string;
+};
+export declare const MonthIsoId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "MonthIsoId">]>;
+export type MonthIsoIdType = v.InferOutput<typeof MonthIsoId>;

package/dist/{month-iso-id.vo.js → src/month-iso-id.vo.js}

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const MonthIsoIdError = {
     Type: "month.iso.id.type",
     BadChars: "month.iso.id.bad.chars",
@@ -6,13 +6,9 @@ export const MonthIsoIdError = {
 };
 // Four digits, hyphen, two digits
 const MONTH_ISO_ID_CHARS_WHITELIST = /^\d{4}-\d{2}$/;
-// Stryker disable all
-export const MonthIsoId = z
-    // Stryker restore all
-    .string(MonthIsoIdError.Type)
-    .regex(MONTH_ISO_ID_CHARS_WHITELIST, MonthIsoIdError.BadChars)
-    .refine((value) => {
+export const MonthIsoId = v.pipe(v.string(MonthIsoIdError.Type), v.regex(MONTH_ISO_ID_CHARS_WHITELIST, MonthIsoIdError.BadChars), v.check((value) => {
     const month = value.split("-").map(Number)[1];
     return month >= 1 && month <= 12;
-}, MonthIsoIdError.Invalid)
-    .brand("MonthIsoId");
+}, MonthIsoIdError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("MonthIsoId"));

package/dist/{month.vo.js → src/month.vo.js}

@@ -1,4 +1,5 @@
 import { endOfMonth, format, startOfMonth } from "date-fns";
+import * as v from "valibot";
 import { DateRange } from "./date-range.vo";
 import { Integer } from "./integer.vo";
 import { MonthIsoId } from "./month-iso-id.vo";
@@ -16,18 +17,18 @@ export class Month extends DateRange {
         return Month.fromTimestamp(now);
     }
     static fromIsoId(iso) {
-        const [year, month] = MonthIsoId.parse(iso).split("-").map(Number);
+        const [year, month] = v.parse(MonthIsoId, iso).split("-").map(Number);
         const reference = Timestamp.fromNumber(Date.UTC(year, month - 1, 1));
         return Month.fromTimestamp(reference);
     }
     toIsoId() {
-        return MonthIsoId.parse(format(this.getStart().ms, "yyyy-MM"));
+        return v.parse(MonthIsoId, format(this.getStart().ms, "yyyy-MM"));
     }
     previous() {
-        return this.shift(Integer.parse(-1));
+        return this.shift(v.parse(Integer, -1));
     }
     next() {
-        return this.shift(Integer.parse(1));
+        return this.shift(v.parse(Integer, 1));
     }
     shift(count) {
         const start = new Date(this.getStart().ms);

package/dist/src/multiplication-factor.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const MultiplicationFactorError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const MultiplicationFactor: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "MultiplicationFactor">]>;
+export type MultiplicationFactorType = v.InferOutput<typeof MultiplicationFactor>;

package/dist/src/multiplication-factor.vo.js

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+export const MultiplicationFactorError = {
+    Type: "multiplication.factor.type",
+    Invalid: "multiplication.factor.invalid",
+};
+export const MultiplicationFactor = v.pipe(v.number(MultiplicationFactorError.Type), v.minValue(0, MultiplicationFactorError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("MultiplicationFactor"));

package/dist/src/object-key.vo.d.ts

@@ -0,0 +1,11 @@
+import * as v from "valibot";
+export declare const ObjectKeyError: {
+    Type: string;
+    LeadingSlash: string;
+    Empty: string;
+    TooLong: string;
+    BadChars: string;
+    DotSegments: string;
+};
+export declare const ObjectKey: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 256, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "ObjectKey">]>;
+export type ObjectKeyType = v.InferOutput<typeof ObjectKey>;

package/dist/src/object-key.vo.js

@@ -0,0 +1,19 @@
+import * as v from "valibot";
+export const ObjectKeyError = {
+    Type: "object.key.type",
+    LeadingSlash: "object.key.leading.slash",
+    Empty: "object.key.empty",
+    TooLong: "object.key.too.long",
+    BadChars: "object.key.bad.chars",
+    DotSegments: "object.key.dot.segments",
+};
+// Lowercase letters, digits, dots, underscores, and hyphens
+const OBJECT_KEY_SEGMENT_CHARS_WHITELIST = /^[a-z0-9._-]+$/;
+const DOT_SEGMENTS = [".", ".."];
+export const ObjectKey = v.pipe(v.string(ObjectKeyError.Type), v.minLength(1, ObjectKeyError.Empty), v.maxLength(256, ObjectKeyError.TooLong), v.check((value) => !value.startsWith("/"), ObjectKeyError.LeadingSlash), 
+// Allow only known characters for users/avatars/1234567890/avatar.png segments
+v.check((value) => value.split("/").every((segment) => OBJECT_KEY_SEGMENT_CHARS_WHITELIST.test(segment)), ObjectKeyError.BadChars), 
+// Reject object keys like users/./avatar.png or users/../avatar.png
+v.check((value) => value.split("/").every((segment) => !DOT_SEGMENTS.includes(segment)), ObjectKeyError.DotSegments), 
+// Stryker disable next-line StringLiteral
+v.brand("ObjectKey"));

package/dist/src/package-version-schema.vo.d.ts

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+export declare const PackageVersionSchemaError: {
+    Type: string;
+    BadChars: string;
+};
+export declare const PACKAGE_VERSIONS_CHARS_WHITELIST: RegExp;
+export declare const PackageVersionSchema: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.BrandAction<string, "PackageVersionSchema">]>;
+export type PackageVersionSchemaType = v.InferOutput<typeof PackageVersionSchema>;

package/dist/{package-version-schema.vo.js → src/package-version-schema.vo.js}

@@ -1,13 +1,10 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const PackageVersionSchemaError = {
     Type: "package.version.schema.error",
     BadChars: "package.version.schema.bad.chars",
 };
 // v, 1-4 digits, dot, 1-4 digits, dot, 1-4 digits - () for capturing groups
 export const PACKAGE_VERSIONS_CHARS_WHITELIST = /^v([0-9]{1,4})\.([0-9]{1,4})\.([0-9]{1,4})$/;
-// Stryker disable all
-export const PackageVersionSchema = z
-    // Stryker restore all
-    .string(PackageVersionSchemaError.Type)
-    .regex(PACKAGE_VERSIONS_CHARS_WHITELIST, PackageVersionSchemaError.BadChars)
-    .brand("PackageVersionSchema");
+export const PackageVersionSchema = v.pipe(v.string(PackageVersionSchemaError.Type), v.regex(PACKAGE_VERSIONS_CHARS_WHITELIST, PackageVersionSchemaError.BadChars), 
+// Stryker disable next-line StringLiteral
+v.brand("PackageVersionSchema"));

package/dist/{package-version.vo.js → src/package-version.vo.js}

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { PACKAGE_VERSIONS_CHARS_WHITELIST, PackageVersionSchema, } from "./package-version-schema.vo";
 export class PackageVersion {
     major;
@@ -9,16 +10,14 @@ export class PackageVersion {
         this.patch = patch;
     }
     static fromVersionString(candidate) {
-        const version = PackageVersionSchema.parse(candidate);
-        return PackageVersion.fromVersionStringSafe(version);
+        return PackageVersion.fromVersionStringSafe(v.parse(PackageVersionSchema, candidate));
     }
     static fromVersionStringSafe(candidate) {
         const [, major, minor, patch] = PACKAGE_VERSIONS_CHARS_WHITELIST.exec(candidate).map(Number);
         return new PackageVersion(major, minor, patch);
     }
     static fromString(candidate) {
-        const version = PackageVersionSchema.parse(`v${candidate}`);
-        return PackageVersion.fromVersionStringSafe(version);
+        return PackageVersion.fromVersionStringSafe(v.parse(PackageVersionSchema, `v${candidate}`));
     }
     compareTo(another) {
         if (this.major > another.major)

package/dist/src/pagination-page.vo.d.ts

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export declare const PaginationPageError: {
+    Type: string;
+};
+export declare const Page: v.SchemaWithPipe<readonly [v.UnknownSchema, v.TransformAction<unknown, number>, v.NumberSchema<string>, v.IntegerAction<number, string>, v.TransformAction<number, number>]>;
+export type PageType = v.InferOutput<typeof Page>;

package/dist/src/pagination-page.vo.js

@@ -0,0 +1,3 @@
+import * as v from "valibot";
+export const PaginationPageError = { Type: "pagination.page.type" };
+export const Page = v.pipe(v.unknown(), v.transform((value) => (value === undefined ? 1 : Number(value))), v.number(PaginationPageError.Type), v.integer(PaginationPageError.Type), v.transform((value) => (value <= 0 ? 1 : value)));

package/dist/src/pagination-skip.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const PaginationSkipError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const Skip: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>]>;
+export type SkipType = v.InferOutput<typeof Skip>;