@bgord/tools 1.3.24 → 1.4.1

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

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const MoneyAmountError: {
     Type: string;
     Invalid: string;
 };
-export declare const MoneyAmount: z.core.$ZodBranded<z.ZodNumber, "MoneyAmount", "out">;
-export type MoneyAmountType = z.infer<typeof MoneyAmount>;
+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/money-amount.vo.js

@@ -1,9 +1,5 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const MoneyAmountError = { Type: "money.amount.type", Invalid: "money.amount.invalid" };
-// Stryker disable all
-export const MoneyAmount = z
-    // Stryker restore all
-    .number(MoneyAmountError.Type)
-    .int(MoneyAmountError.Type)
-    .min(0, MoneyAmountError.Invalid)
-    .brand("MoneyAmount");
+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

@@ -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/month-iso-id.vo.d.ts

@@ -1,8 +1,8 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const MonthIsoIdError: {
     Type: string;
     BadChars: string;
     Invalid: string;
 };
-export declare const MonthIsoId: z.core.$ZodBranded<z.ZodString, "MonthIsoId", "out">;
-export type MonthIsoIdType = z.infer<typeof MonthIsoId>;
+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

@@ -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

@@ -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/multiplication-factor.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const MultiplicationFactorError: {
     Type: string;
     Invalid: string;
 };
-export declare const MultiplicationFactor: z.core.$ZodBranded<z.ZodNumber, "MultiplicationFactor", "out">;
-export type MultiplicationFactorType = z.infer<typeof MultiplicationFactor>;
+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/multiplication-factor.vo.js

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

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

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const ObjectKeyError: {
     Type: string;
     LeadingSlash: string;
@@ -7,5 +7,5 @@ export declare const ObjectKeyError: {
     BadChars: string;
     DotSegments: string;
 };
-export declare const ObjectKey: z.core.$ZodBranded<z.ZodString, "ObjectKey", "out">;
-export type ObjectKeyType = z.infer<typeof ObjectKey>;
+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/object-key.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const ObjectKeyError = {
     Type: "object.key.type",
     LeadingSlash: "object.key.leading.slash",
@@ -10,15 +10,10 @@ export const ObjectKeyError = {
 // Lowercase letters, digits, dots, underscores, and hyphens
 const OBJECT_KEY_SEGMENT_CHARS_WHITELIST = /^[a-z0-9._-]+$/;
 const DOT_SEGMENTS = [".", ".."];
-// Stryker disable all
-export const ObjectKey = z
-    // Stryker restore all
-    .string(ObjectKeyError.Type)
-    .min(1, ObjectKeyError.Empty)
-    .max(256, ObjectKeyError.TooLong)
-    .refine((value) => !value.startsWith("/"), ObjectKeyError.LeadingSlash)
-    // Allow only known characters for users/avatars/1234567890/avatar.png segments
-    .refine((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
-    .refine((value) => value.split("/").every((segment) => !DOT_SEGMENTS.includes(segment)), ObjectKeyError.DotSegments)
-    .brand("ObjectKey");
+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/package-version-schema.vo.d.ts

@@ -1,8 +1,8 @@
-import * as z from "zod/v4";
+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: z.core.$ZodBranded<z.ZodString, "PackageVersionSchema", "out">;
-export type PackageVersionSchemaType = z.infer<typeof PackageVersionSchema>;
+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

@@ -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

@@ -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/pagination-page.vo.d.ts

@@ -1,6 +1,6 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const PaginationPageError: {
     Type: string;
 };
-export declare const Page: z.ZodDefault<z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodTransform<number, number>>>;
-export type PageType = z.infer<typeof Page>;
+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/pagination-page.vo.js

@@ -1,7 +1,3 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const PaginationPageError = { Type: "pagination.page.type" };
-export const Page = z.coerce
-    .number(PaginationPageError.Type)
-    .int(PaginationPageError.Type)
-    .transform((value) => (value <= 0 ? 1 : value))
-    .default(1);
+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/pagination-skip.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const PaginationSkipError: {
     Type: string;
     Invalid: string;
 };
-export declare const Skip: z.ZodNumber;
-export type SkipType = z.infer<typeof Skip>;
+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>;

package/dist/pagination-skip.vo.js

@@ -1,6 +1,3 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const PaginationSkipError = { Type: "pagination.skip.type", Invalid: "pagination.skip.invalid" };
-export const Skip = z
-    .number(PaginationSkipError.Type)
-    .int(PaginationSkipError.Type)
-    .gte(0, PaginationSkipError.Invalid);
+export const Skip = v.pipe(v.number(PaginationSkipError.Type), v.integer(PaginationSkipError.Type), v.minValue(0, PaginationSkipError.Invalid));

package/dist/pagination-take.vo.d.ts

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

package/dist/pagination-take.vo.js

@@ -1,6 +1,3 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const PaginationTakeError = { Type: "pagination.take.type", Invalid: "pagination.take.invalid" };
-export const Take = z
-    .number(PaginationTakeError.Type)
-    .int(PaginationTakeError.Type)
-    .gte(1, PaginationTakeError.Invalid);
+export const Take = v.pipe(v.number(PaginationTakeError.Type), v.integer(PaginationTakeError.Type), v.minValue(1, PaginationTakeError.Invalid));

package/dist/pagination.service.js

@@ -1,20 +1,21 @@
+import * as v from "valibot";
 import { Page } from "./pagination-page.vo";
 import { Skip } from "./pagination-skip.vo";
 import { Take } from "./pagination-take.vo";
 import { RoundingUpStrategy } from "./rounding-up.strategy";
 export class Pagination {
     static parse(values, _take) {
-        const page = Page.parse(values.page);
-        const take = Take.parse(_take);
-        const skip = Skip.parse((page - 1) * take);
+        const page = v.parse(Page, values.page);
+        const take = v.parse(Take, _take);
+        const skip = v.parse(Skip, (page - 1) * take);
         return { values: { take, skip }, page };
     }
     static prepare(config) {
         const exhausted = Pagination.isExhausted(config);
         const currentPage = config.pagination.page;
         const lastPage = Pagination.getLastPage(config);
-        const previousPage = currentPage > 1 ? Page.parse(currentPage - 1) : undefined;
-        const nextPage = currentPage < lastPage ? Page.parse(currentPage + 1) : undefined;
+        const previousPage = currentPage > 1 ? v.parse(Page, currentPage - 1) : undefined;
+        const nextPage = currentPage < lastPage ? v.parse(Page, currentPage + 1) : undefined;
         return {
             result: config.result,
             meta: { exhausted, currentPage, previousPage, nextPage, lastPage, total: config.total },
@@ -24,7 +25,7 @@ export class Pagination {
         return Pagination.getLastPage(config) <= config.pagination.page;
     }
     static getLastPage(config) {
-        return Page.parse(new RoundingUpStrategy().round(config.total / config.pagination.values.take));
+        return v.parse(Page, new RoundingUpStrategy().round(config.total / config.pagination.values.take));
     }
     static empty = {
         result: [],
@@ -38,6 +39,6 @@ export class Pagination {
         },
     };
     static getFirstPage(input) {
-        return { values: { take: Take.parse(input.take), skip: Skip.parse(0) }, page: Page.parse(1) };
+        return { values: { take: v.parse(Take, input.take), skip: v.parse(Skip, 0) }, page: v.parse(Page, 1) };
     }
 }

package/dist/quarter-iso-id.vo.d.ts

@@ -1,7 +1,8 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const QuarterIsoIdError: {
     Type: string;
     BadChars: string;
 };
-export declare const QuarterIsoId: z.core.$ZodBranded<z.ZodString, "QuarterIsoId", "out">;
-export type QuarterIsoIdType = z.infer<typeof QuarterIsoId>;
+export declare const QUARTER_ISO_ID_CHARS_WHITELIST: RegExp;
+export declare const QuarterIsoId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.BrandAction<string, "QuarterIsoId">]>;
+export type QuarterIsoIdType = v.InferOutput<typeof QuarterIsoId>;

package/dist/quarter-iso-id.vo.js

@@ -1,11 +1,7 @@
-import * as z from "zod/v4";
-export const QuarterIsoIdError = {
-    Type: "quarter.iso.id.type",
-    BadChars: "quarter.iso.id.bad.chars",
-};
-// Stryker disable all
-export const QuarterIsoId = z
-    // Stryker restore all
-    .string(QuarterIsoIdError.Type)
-    .regex(/^\d{4}-Q[1-4]$/, QuarterIsoIdError.BadChars)
-    .brand("QuarterIsoId");
+import * as v from "valibot";
+export const QuarterIsoIdError = { Type: "quarter.iso.id.type", BadChars: "quarter.iso.id.bad.chars" };
+// 4 digits, hyphen, Q, digits from 1 to 4
+export const QUARTER_ISO_ID_CHARS_WHITELIST = /^\d{4}-Q[1-4]$/;
+export const QuarterIsoId = v.pipe(v.string(QuarterIsoIdError.Type), v.regex(QUARTER_ISO_ID_CHARS_WHITELIST, QuarterIsoIdError.BadChars), 
+// Stryker disable next-line StringLiteral
+v.brand("QuarterIsoId"));

package/dist/quarter.vo.js

@@ -1,4 +1,5 @@
 import { endOfQuarter, getQuarter, getYear, startOfQuarter } from "date-fns";
+import * as v from "valibot";
 import { DateRange } from "./date-range.vo";
 import { QuarterIsoId } from "./quarter-iso-id.vo";
 import { Timestamp } from "./timestamp.vo";
@@ -15,13 +16,13 @@ export class Quarter extends DateRange {
         return Quarter.fromTimestamp(now);
     }
     static fromIsoId(isoId) {
-        const [year, quarter] = QuarterIsoId.parse(isoId).split("-Q").map(Number);
+        const [year, quarter] = v.parse(QuarterIsoId, isoId).split("-Q").map(Number);
         return Quarter.fromTimestamp(Timestamp.fromNumber(Date.UTC(year, (quarter - 1) * 3, 1)));
     }
     toIsoId() {
         const year = getYear(this.getStart().ms);
         const quarter = getQuarter(this.getStart().ms);
-        return QuarterIsoId.parse(`${year}-Q${quarter}`);
+        return v.parse(QuarterIsoId, `${year}-Q${quarter}`);
     }
     toString() {
         return this.toIsoId();

package/dist/reordering-item-position-value.vo.d.ts

@@ -1,6 +1,6 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const ReorderingItemPositionValueError: {
     Invalid: string;
 };
-export declare const ReorderingItemPositionValue: z.ZodNumber;
-export type ReorderingItemPositionValueType = z.infer<typeof ReorderingItemPositionValue>;
+export declare const ReorderingItemPositionValue: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>]>;
+export type ReorderingItemPositionValueType = v.InferOutput<typeof ReorderingItemPositionValue>;

package/dist/reordering-item-position-value.vo.js

@@ -1,6 +1,3 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const ReorderingItemPositionValueError = { Invalid: "reordering.position.type" };
-export const ReorderingItemPositionValue = z
-    .number(ReorderingItemPositionValueError.Invalid)
-    .int(ReorderingItemPositionValueError.Invalid)
-    .min(0, ReorderingItemPositionValueError.Invalid);
+export const ReorderingItemPositionValue = v.pipe(v.number(ReorderingItemPositionValueError.Invalid), v.integer(ReorderingItemPositionValueError.Invalid), v.minValue(0, ReorderingItemPositionValueError.Invalid));

package/dist/reordering.service.d.ts

@@ -1,18 +1,18 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { type ReorderingItemPositionValueType } from "./reordering-item-position-value.vo";
 export declare const ReorderingError: {
     CannotFindItem: string;
     CannotFindCurrent: string;
     CannotFindTarget: string;
 };
-export declare const ReorderingId: z.ZodString;
-export type ReorderingItemIdType = z.infer<typeof ReorderingId>;
-export declare const Reordering: z.ZodObject<{
-    correlationId: z.ZodString;
-    id: z.ZodString;
-    position: z.ZodNumber;
-}, z.core.$strip>;
-export type ReorderingType = z.infer<typeof Reordering>;
+export declare const ReorderingId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>]>;
+export type ReorderingItemIdType = v.InferOutput<typeof ReorderingId>;
+export declare const Reordering: v.ObjectSchema<{
+    readonly correlationId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>]>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>]>;
+    readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>]>;
+}, undefined>;
+export type ReorderingType = v.InferOutput<typeof Reordering>;
 export type WithReorderingPositionValue<T> = T & {
     position: ReorderingItemPositionValueType;
 };

package/dist/reordering.service.js

@@ -1,5 +1,5 @@
 // Stryker disable all
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { DoublyLinkedList, Node } from "./dll.service";
 import { ReorderingItemPositionValue, } from "./reordering-item-position-value.vo";
 export const ReorderingError = {
@@ -8,8 +8,8 @@ export const ReorderingError = {
     CannotFindTarget: "reordering.cannot.find.target",
 };
 const ReorderingIdError = { Type: "reordering.id.type" };
-export const ReorderingId = z.string(ReorderingIdError.Type).min(1, ReorderingIdError.Type);
-export const Reordering = z.object({
+export const ReorderingId = v.pipe(v.string(ReorderingIdError.Type), v.minLength(1, ReorderingIdError.Type));
+export const Reordering = v.object({
     correlationId: ReorderingId,
     id: ReorderingId,
     position: ReorderingItemPositionValue,
@@ -17,7 +17,7 @@ export const Reordering = z.object({
 export class ReorderingPosition {
     value;
     constructor(value) {
-        this.value = ReorderingItemPositionValue.parse(value);
+        this.value = v.parse(ReorderingItemPositionValue, value);
     }
     eq(another) {
         return this.value === another.value;
@@ -71,7 +71,7 @@ export class ReorderingCalculator {
     }
     add(id) {
         const size = this.dll.getSize();
-        const position = new ReorderingPosition(ReorderingItemPositionValue.parse(size));
+        const position = new ReorderingPosition(v.parse(ReorderingItemPositionValue, size));
         const item = new ReorderingItem(id, position);
         const node = new Node(item);
         this.dll.append(node);
@@ -114,7 +114,7 @@ export class ReorderingCalculator {
         let index = 0;
         for (const node of this.dll) {
             const id = node.data.id;
-            const position = new ReorderingPosition(ReorderingItemPositionValue.parse(index));
+            const position = new ReorderingPosition(v.parse(ReorderingItemPositionValue, index));
             node.data = new ReorderingItem(id, position);
             index += 1;
         }
@@ -124,7 +124,7 @@ export class ReorderingIntegrator {
     static appendPosition(reordering) {
         return function (item) {
             const found = reordering.find((x) => x.id === item.id);
-            const positionValue = ReorderingItemPositionValue.parse(found?.position ?? 0);
+            const positionValue = v.parse(ReorderingItemPositionValue, found?.position ?? 0);
             return { ...item, position: positionValue };
         };
     }

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

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

package/dist/revision-value.vo.js

@@ -1,6 +1,3 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const RevisionValueError = { Type: "revision.value.type", Invalid: "revision.value.invalid" };
-export const RevisionValue = z
-    .number(RevisionValueError.Type)
-    .int(RevisionValueError.Type)
-    .min(0, RevisionValueError.Invalid);
+export const RevisionValue = v.pipe(v.number(RevisionValueError.Type), v.integer(RevisionValueError.Type), v.minValue(0, RevisionValueError.Invalid));

package/dist/revision.vo.js

@@ -1,10 +1,11 @@
+import * as v from "valibot";
 import { RevisionValue } from "./revision-value.vo";
 export const RevisionError = { Missing: "revision.missing", Mismatch: "revision.mismatch" };
 export class Revision {
-    static INITIAL = RevisionValue.parse(0);
+    static INITIAL = v.parse(RevisionValue, 0);
     value;
     constructor(value) {
-        this.value = RevisionValue.parse(value);
+        this.value = v.parse(RevisionValue, value);
     }
     equals(another) {
         return this.value === another;

package/dist/rounding-decimal.strategy.d.ts

@@ -1,10 +1,10 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import type { RoundingStrategy } from "./rounding.strategy";
 export declare const RoundingDecimalError: {
     Type: string;
     Invalid: string;
 };
-export declare const RoundingDecimal: z.core.$ZodBranded<z.ZodNumber, "RoundingDecimal", "out">;
+export declare const RoundingDecimal: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 1, string>, v.MaxValueAction<number, 100, string>, v.BrandAction<number, "RoundingDecimal">]>;
 export declare class RoundingDecimalStrategy implements RoundingStrategy {
     private readonly decimals;
     constructor(candidate: number);

package/dist/rounding-decimal.strategy.js

@@ -1,17 +1,12 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const RoundingDecimalError = { Type: "rounding.decimal.type", Invalid: "rounding.decimal.invalid" };
-// Stryker disable all
-export const RoundingDecimal = z
-    // Stryker restore all
-    .number(RoundingDecimalError.Type)
-    .int(RoundingDecimalError.Invalid)
-    .min(1, RoundingDecimalError.Invalid)
-    .max(100, RoundingDecimalError.Invalid)
-    .brand("RoundingDecimal");
+export const RoundingDecimal = v.pipe(v.number(RoundingDecimalError.Type), v.integer(RoundingDecimalError.Invalid), v.minValue(1, RoundingDecimalError.Invalid), v.maxValue(100, RoundingDecimalError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("RoundingDecimal"));
 export class RoundingDecimalStrategy {
     decimals;
     constructor(candidate) {
-        this.decimals = RoundingDecimal.parse(candidate);
+        this.decimals = v.parse(RoundingDecimal, candidate);
     }
     round(value) {
         return Number.parseFloat(value.toFixed(this.decimals));