@bgord/tools 0.17.2 → 1.0.1

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

@@ -1,8 +1,11 @@
 import { z } from "zod/v4";
-export declare const ObjectKeyMustNotStartWithSlashError: "obj_key_must_not_start_with_slash";
-export declare const ObjectKeyBackslashForbiddenError: "obj_key_backslash_forbidden";
-export declare const ObjectKeyControlCharsForbiddenError: "obj_key_control_chars_forbidden";
-export declare const ObjectKeyEmptyError: "obj_key_empty";
-export declare const ObjectKeyBadSegmentsError: "obj_key_bad_segments";
-export declare const ObjectKey: z.core.$ZodBranded<z.ZodString, "object_key">;
+export declare const ObjectKeyError: {
+    readonly Type: "object.key.type";
+    readonly LeadingSlash: "object.key.leading.slash";
+    readonly Empty: "object.key.empty";
+    readonly TooLong: "object.key.too.long";
+    readonly BadChars: "object.key.bad.chars";
+    readonly DotSegments: "object.key.dot.segments";
+};
+export declare const ObjectKey: z.core.$ZodBranded<z.ZodString, "ObjectKey">;
 export type ObjectKeyType = z.infer<typeof ObjectKey>;

package/dist/object-key.vo.js

@@ -1,21 +1,22 @@
 import { z } from "zod/v4";
-export const ObjectKeyMustNotStartWithSlashError = "obj_key_must_not_start_with_slash";
-export const ObjectKeyBackslashForbiddenError = "obj_key_backslash_forbidden";
-export const ObjectKeyControlCharsForbiddenError = "obj_key_control_chars_forbidden";
-export const ObjectKeyEmptyError = "obj_key_empty";
-export const ObjectKeyBadSegmentsError = "obj_key_bad_segments";
-// biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-const CONTROL_CHARS_REGEX = /[\u0000-\u001F\u007F]/;
-const SEGMENT_ALLOWED_REGEX = /^[a-z0-9._-]+$/;
+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 = z
-    .string()
-    .trim()
-    // fastest early exits first:
-    .refine((value) => value.length > 0, ObjectKeyEmptyError)
-    .refine((value) => !value.startsWith("/"), ObjectKeyMustNotStartWithSlashError)
-    .refine((value) => !value.includes("\\"), ObjectKeyBackslashForbiddenError)
-    .refine((value) => !CONTROL_CHARS_REGEX.test(value), ObjectKeyControlCharsForbiddenError)
-    .refine((value) => value
-    .split("/")
-    .every((segment) => SEGMENT_ALLOWED_REGEX.test(segment) && segment !== "." && segment !== ".."), ObjectKeyBadSegmentsError)
-    .brand("object_key");
+    .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");

package/dist/outlier-detector.service.d.ts

@@ -1,4 +1,6 @@
-export declare const OutlierDetectorMinValuesError: "outlier.detector.min.values";
+export declare const OutlierDetectorError: {
+    readonly NotEnoughValues: "outlier.detector.not.enough.values";
+};
 export declare class OutlierDetector {
     private readonly zScore;
     private readonly threshold;

package/dist/outlier-detector.service.js

@@ -1,11 +1,11 @@
 import { ZScore } from "./z-score.service";
-export const OutlierDetectorMinValuesError = "outlier.detector.min.values";
+export const OutlierDetectorError = { NotEnoughValues: "outlier.detector.not.enough.values" };
 export class OutlierDetector {
     zScore;
     threshold;
     constructor(values, threshold) {
         if (values.length < 2)
-            throw new Error(OutlierDetectorMinValuesError);
+            throw new Error(OutlierDetectorError.NotEnoughValues);
         this.zScore = new ZScore(values);
         this.threshold = Math.abs(threshold);
     }

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

@@ -0,0 +1,11 @@
+import { z } from "zod/v4";
+export declare const PackageVersionSchemaError: {
+    readonly Type: "package.version.schema.error";
+    readonly BadChars: "package.version.schema.bad.chars";
+};
+export declare const PackageVersionSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<{
+    major: number;
+    minor: number;
+    patch: number;
+}, string>>, "PackageVersionSchema">;
+export type PackageVersionSchemaType = z.infer<typeof PackageVersionSchema>;

package/dist/package-version-schema.vo.js

@@ -0,0 +1,15 @@
+import { z } from "zod/v4";
+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
+const PACKAGE_VERSIONS_CHARS_WHITELIST = /^v([0-9]{1,4})\.([0-9]{1,4})\.([0-9]{1,4})$/;
+export const PackageVersionSchema = z
+    .string(PackageVersionSchemaError.Type)
+    .regex(PACKAGE_VERSIONS_CHARS_WHITELIST, PackageVersionSchemaError.BadChars)
+    .transform((value) => {
+    const match = PACKAGE_VERSIONS_CHARS_WHITELIST.exec(value);
+    return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+})
+    .brand("PackageVersionSchema");

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

@@ -1,24 +1,15 @@
-import { z } from "zod/v4";
-type MajorType = number;
-type MinorType = number;
-type PatchType = number;
-export declare const PackageVersionError: {
-    readonly error: "package.version.error";
-};
-export declare const PackageVersionValue: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<{
-    major: number;
-    minor: number;
-    patch: number;
-}, string>>, "PackageVersionValue">;
-export type PackageVersionValueType = z.infer<typeof PackageVersionValue>;
 export declare class PackageVersion {
-    readonly major: MajorType;
-    readonly minor: MinorType;
-    readonly patch: PatchType;
-    constructor(major: MajorType, minor: MinorType, patch: PatchType);
+    private readonly major;
+    private readonly minor;
+    private readonly patch;
+    constructor(major: number, minor: number, patch: number);
+    static fromStringWithV(candidate: string): PackageVersion;
+    static fromString(candidate: string): PackageVersion;
     isGreaterThanOrEqual(another: PackageVersion): boolean;
     toString(): string;
-    static fromStringWithV(value: string): PackageVersion;
-    static fromString(value: string): PackageVersion;
+    toJSON(): {
+        major: number;
+        minor: number;
+        patch: number;
+    };
 }
-export {};

package/dist/package-version.vo.js

@@ -1,16 +1,4 @@
-import { z } from "zod/v4";
-export const PackageVersionError = { error: "package.version.error" };
-export const PackageVersionValue = z
-    .string(PackageVersionError)
-    .regex(/^v(\d+)\.(\d+)\.(\d+)$/, PackageVersionError)
-    .transform((value) => {
-    const match = /^v(\d+)\.(\d+)\.(\d+)$/.exec(value);
-    const major = Number(match[1]);
-    const minor = Number(match[2]);
-    const patch = Number(match[3]);
-    return { major, minor, patch };
-})
-    .brand("PackageVersionValue");
+import { PackageVersionSchema } from "./package-version-schema.vo";
 export class PackageVersion {
     major;
     minor;
@@ -20,6 +8,14 @@ export class PackageVersion {
         this.minor = minor;
         this.patch = patch;
     }
+    static fromStringWithV(candidate) {
+        const version = PackageVersionSchema.parse(candidate);
+        return new PackageVersion(version.major, version.minor, version.patch);
+    }
+    static fromString(candidate) {
+        const version = PackageVersionSchema.parse(`v${candidate}`);
+        return new PackageVersion(version.major, version.minor, version.patch);
+    }
     isGreaterThanOrEqual(another) {
         if (this.major > another.major)
             return true;
@@ -38,12 +34,7 @@ export class PackageVersion {
     toString() {
         return `${this.major}.${this.minor}.${this.patch}`;
     }
-    static fromStringWithV(value) {
-        const parsed = PackageVersionValue.parse(value);
-        return new PackageVersion(parsed.major, parsed.minor, parsed.patch);
-    }
-    static fromString(value) {
-        const parsed = PackageVersionValue.parse(`v${value}`);
-        return new PackageVersion(parsed.major, parsed.minor, parsed.patch);
+    toJSON() {
+        return { major: this.major, minor: this.minor, patch: this.patch };
     }
 }

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

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+export declare const PaginationPageError: {
+    readonly Type: "pagination.page.Type";
+};
+export declare const Page: z.ZodDefault<z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodTransform<number, number>>>;
+export type PageType = z.infer<typeof Page>;

package/dist/pagination-page.vo.js

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+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);

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

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+export declare const PaginationSkipError: {
+    readonly Type: "pagination.skip.type";
+    readonly Invalid: "pagination.skip.invalid";
+};
+export declare const Skip: z.ZodNumber;
+export type SkipType = z.infer<typeof Skip>;

package/dist/pagination-skip.vo.js

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+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);

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

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+export declare const PaginationTakeError: {
+    readonly Type: "pagination.take.type";
+    readonly Invalid: "pagination.take.invalid";
+};
+export declare const Take: z.ZodNumber;
+export type TakeType = z.infer<typeof Take>;

package/dist/pagination-take.vo.js

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+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);

package/dist/pagination.service.d.ts

@@ -1,10 +1,6 @@
-import { z } from "zod/v4";
-declare const Take: z.ZodNumber;
-type TakeType = z.infer<typeof Take>;
-declare const Skip: z.ZodNumber;
-type SkipType = z.infer<typeof Skip>;
-declare const Page: z.ZodDefault<z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodTransform<number, number>>>;
-export type PageType = z.infer<typeof Page>;
+import { type PageType } from "./pagination-page.vo";
+import { type SkipType } from "./pagination-skip.vo";
+import { type TakeType } from "./pagination-take.vo";
 export type PaginationType = {
     values: {
         take: TakeType;
@@ -55,4 +51,3 @@ export type Paged<T> = {
         total: TotalType;
     };
 };
-export {};

package/dist/pagination.service.js

@@ -1,14 +1,7 @@
-import { z } from "zod/v4";
-const PaginationTakeError = { error: "pagination.take.invalid" };
-const PaginationSkipError = { error: "pagination.skip.invalid" };
-const PaginationPageError = { error: "pagination.page.invalid" };
-const Take = z.number(PaginationTakeError).int(PaginationTakeError).gte(1, PaginationTakeError);
-const Skip = z.number(PaginationSkipError).int(PaginationSkipError).gte(0, PaginationSkipError);
-const Page = z.coerce
-    .number(PaginationPageError)
-    .int(PaginationPageError)
-    .transform((value) => (value <= 0 ? 1 : value))
-    .default(1);
+import { Page } from "./pagination-page.vo";
+import { Skip } from "./pagination-skip.vo";
+import { Take } from "./pagination-take.vo";
+import { RoundUp } from "./rounding.adapter";
 export class Pagination {
     static parse(values, _take) {
         const page = Page.parse(values.page);
@@ -31,7 +24,7 @@ export class Pagination {
         return Pagination.getLastPage(config) <= config.pagination.page;
     }
     static getLastPage(config) {
-        return Page.parse(Math.ceil(config.total / config.pagination.values.take));
+        return Page.parse(new RoundUp().round(config.total / config.pagination.values.take));
     }
     static empty = {
         result: [],

package/dist/percentage.service.d.ts

@@ -1,5 +1,7 @@
 import type { RoundingPort } from "./rounding.port";
-export declare const PercentageInvalidDenominatorError: "percentage.invalid.denominator";
+export declare const PercentageError: {
+    readonly InvalidDenominator: "percentage.invalid.denominator";
+};
 export declare class Percentage {
     static of(numerator: number, denominator: number, rounding?: RoundingPort): number;
 }

package/dist/percentage.service.js

@@ -1,9 +1,9 @@
 import { RoundToNearest } from "./rounding.adapter";
-export const PercentageInvalidDenominatorError = "percentage.invalid.denominator";
+export const PercentageError = { InvalidDenominator: "percentage.invalid.denominator" };
 export class Percentage {
     static of(numerator, denominator, rounding = new RoundToNearest()) {
         if (denominator === 0)
-            throw new Error(PercentageInvalidDenominatorError);
+            throw new Error(PercentageError.InvalidDenominator);
         if (numerator === 0)
             return 0;
         return rounding.round((numerator / denominator) * 100);

package/dist/population-standard-deviation.service.d.ts

@@ -1,5 +1,7 @@
 import type { RoundingPort } from "./rounding.port";
-export declare const PopulationStandardDeviationMinValuesError: "population.standard.deviation.min.values";
+export declare const PopulationStandardDeviationError: {
+    readonly NotEnoughValues: "population.standard.deviation.not.enough.values";
+};
 export declare class PopulationStandardDeviation {
     static calculate(values: number[], rounding?: RoundingPort): number;
 }

package/dist/population-standard-deviation.service.js

@@ -1,16 +1,17 @@
 import { Mean } from "./mean.service";
 import { RoundToDecimal } from "./rounding.adapter";
 import { Sum } from "./sum.service";
-export const PopulationStandardDeviationMinValuesError = "population.standard.deviation.min.values";
+export const PopulationStandardDeviationError = {
+    NotEnoughValues: "population.standard.deviation.not.enough.values",
+};
 export class PopulationStandardDeviation {
     static calculate(values, rounding = new RoundToDecimal(2)) {
         if (values.length < 2)
-            throw new Error(PopulationStandardDeviationMinValuesError);
+            throw new Error(PopulationStandardDeviationError.NotEnoughValues);
         const mean = Mean.calculate(values);
         const count = values.length;
         const squaredDifferences = values.map((value) => (value - mean) ** 2);
-        const sumOfSquaredDifferences = Sum.of(squaredDifferences);
-        const variance = sumOfSquaredDifferences / count;
+        const variance = Sum.of(squaredDifferences) / count;
         return rounding.round(Math.sqrt(variance));
     }
 }

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

@@ -1,6 +1,7 @@
 import { z } from "zod/v4";
 export declare const QuarterIsoIdError: {
-    readonly error: "quarter-iso-id.invalid";
+    readonly Type: "quarter.iso.id.type";
+    readonly BadChars: "quarter.iso.id.bad.chars";
 };
-export declare const QuarterIsoId: z.ZodString;
+export declare const QuarterIsoId: z.core.$ZodBranded<z.ZodString, "QuarterIsoId">;
 export type QuarterIsoIdType = z.infer<typeof QuarterIsoId>;

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

@@ -1,11 +1,9 @@
 import { z } from "zod/v4";
-export const QuarterIsoIdError = { error: "quarter-iso-id.invalid" };
+export const QuarterIsoIdError = {
+    Type: "quarter.iso.id.type",
+    BadChars: "quarter.iso.id.bad.chars",
+};
 export const QuarterIsoId = z
-    .string(QuarterIsoIdError)
-    .regex(/^\d{4}-Q[1-4]$/, QuarterIsoIdError)
-    .refine((value) => {
-    const [yearPart, quarterPart] = value.split("-Q");
-    const year = Number(yearPart);
-    const quarter = Number(quarterPart);
-    return Number.isInteger(year) && Number.isInteger(quarter) && quarter >= 1 && quarter <= 4;
-}, QuarterIsoIdError);
+    .string(QuarterIsoIdError.Type)
+    .regex(/^\d{4}-Q[1-4]$/, QuarterIsoIdError.BadChars)
+    .brand("QuarterIsoId");

package/dist/quarter.vo.d.ts

@@ -2,8 +2,9 @@ import { DateRange } from "./date-range.vo";
 import { type QuarterIsoIdType } from "./quarter-iso-id.vo";
 import { type TimestampType } from "./timestamp.vo";
 export declare class Quarter extends DateRange {
-    toIsoId(): QuarterIsoIdType;
     static fromTimestamp(timestamp: TimestampType): Quarter;
     static fromNow(now: TimestampType): Quarter;
     static fromIsoId(isoId: QuarterIsoIdType): Quarter;
+    toIsoId(): QuarterIsoIdType;
+    toString(): string;
 }

package/dist/quarter.vo.js

@@ -3,11 +3,6 @@ import { DateRange } from "./date-range.vo";
 import { QuarterIsoId } from "./quarter-iso-id.vo";
 import { Timestamp } from "./timestamp.vo";
 export class Quarter extends DateRange {
-    toIsoId() {
-        const year = getYear(this.getStart());
-        const quarter = getQuarter(this.getStart());
-        return `${year}-Q${quarter}`;
-    }
     static fromTimestamp(timestamp) {
         const start = Timestamp.parse(startOfQuarter(timestamp).getTime());
         const end = Timestamp.parse(endOfQuarter(timestamp).getTime());
@@ -18,7 +13,15 @@ export class Quarter extends DateRange {
     }
     static fromIsoId(isoId) {
         const [year, quarter] = QuarterIsoId.parse(isoId).split("-Q").map(Number);
-        const reference = setQuarter(new Date(Date.UTC(year, 0, 1)), quarter);
-        return Quarter.fromTimestamp(Timestamp.parse(reference.getTime()));
+        const reference = setQuarter(Date.UTC(year), quarter).getTime();
+        return Quarter.fromTimestamp(Timestamp.parse(reference));
+    }
+    toIsoId() {
+        const year = getYear(this.getStart());
+        const quarter = getQuarter(this.getStart());
+        return QuarterIsoId.parse(`${year}-Q${quarter}`);
+    }
+    toString() {
+        return this.toIsoId();
     }
 }

package/dist/random.service.d.ts

@@ -2,10 +2,9 @@ type RandomGenerateConfigType = {
     min: number;
     max: number;
 };
-export declare const RandomMinNotIntegerError: "random.min.not.integer";
-export declare const RandomMaxNotIntegerError: "random.max.not.integer";
-export declare const RandomMinEqualsMaxError: "random.min.equals.max";
-export declare const RandomMinGreaterThanMaxError: "random.min.greater.than.max";
+export declare const RandomError: {
+    readonly MinMax: "random.min.max";
+};
 export declare class Random {
     private static readonly DEFAULT_MIN;
     private static readonly DEFAULT_MAX;

package/dist/random.service.js

@@ -1,21 +1,15 @@
-export const RandomMinNotIntegerError = "random.min.not.integer";
-export const RandomMaxNotIntegerError = "random.max.not.integer";
-export const RandomMinEqualsMaxError = "random.min.equals.max";
-export const RandomMinGreaterThanMaxError = "random.min.greater.than.max";
+import { RoundDown } from "./rounding.adapter";
+export const RandomError = { MinMax: "random.min.max" };
 export class Random {
     static DEFAULT_MIN = 0;
     static DEFAULT_MAX = 1;
     static generate(config) {
         const min = config ? config.min : Random.DEFAULT_MIN;
         const max = config ? config.max : Random.DEFAULT_MAX;
-        if (!Number.isInteger(min))
-            throw new Error(RandomMinNotIntegerError);
-        if (!Number.isInteger(max))
-            throw new Error(RandomMaxNotIntegerError);
         if (min === max)
-            throw new Error(RandomMinEqualsMaxError);
+            throw new Error(RandomError.MinMax);
         if (min > max)
-            throw new Error(RandomMinGreaterThanMaxError);
-        return Math.floor(Math.random() * (max - min + 1)) + min;
+            throw new Error(RandomError.MinMax);
+        return new RoundDown().round(Math.random() * (max - min + 1)) + min;
     }
 }

package/dist/rate-limiter.service.d.ts

@@ -10,8 +10,8 @@ type RateLimiterResultErrorType = {
 type RateLimiterResultType = RateLimiterResultSuccessType | RateLimiterResultErrorType;
 export declare class RateLimiter {
     private readonly duration;
-    private lastInvocationTimestampMs;
+    private lastInvocation;
     constructor(duration: Duration);
-    verify(currentTimestampMs: TimestampType): RateLimiterResultType;
+    verify(now: TimestampType): RateLimiterResultType;
 }
 export {};

package/dist/rate-limiter.service.js

@@ -1,21 +1,21 @@
 import { Duration } from "./duration.service";
 export class RateLimiter {
     duration;
-    lastInvocationTimestampMs = null;
+    lastInvocation = null;
     constructor(duration) {
         this.duration = duration;
     }
-    verify(currentTimestampMs) {
-        if (this.lastInvocationTimestampMs == null) {
-            this.lastInvocationTimestampMs = currentTimestampMs;
+    verify(now) {
+        if (this.lastInvocation == null) {
+            this.lastInvocation = now;
             return { allowed: true };
         }
-        const nextAllowedTimestampMs = this.lastInvocationTimestampMs + this.duration.ms;
-        if (nextAllowedTimestampMs <= currentTimestampMs) {
-            this.lastInvocationTimestampMs = currentTimestampMs;
+        const nextAllowedTimestamp = this.lastInvocation + this.duration.ms;
+        if (nextAllowedTimestamp <= now) {
+            this.lastInvocation = now;
             return { allowed: true };
         }
-        const remainingDelta = nextAllowedTimestampMs - currentTimestampMs;
+        const remainingDelta = nextAllowedTimestamp - now;
         return { allowed: false, remaining: Duration.Ms(remainingDelta) };
     }
 }

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

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+export declare const ReorderingItemPositionValueError: {
+    readonly Invalid: "reordering.position.type";
+};
+export declare const ReorderingItemPositionValue: z.ZodNumber;
+export type ReorderingItemPositionValueType = z.infer<typeof ReorderingItemPositionValue>;

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

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

package/dist/reordering.service.d.ts

@@ -1,28 +1,12 @@
 import { z } from "zod/v4";
-export declare const ReorderingPositionError: {
-    readonly error: "reordering.position.invalid";
+import { type ReorderingItemPositionValueType } from "./reordering-item-position-value.vo";
+export declare const ReorderingError: {
+    CannotFindItem: string;
+    CannotFindCurrent: string;
+    CannotFindTarget: string;
 };
-export declare const ReorderingCannotFindItemError: {
-    readonly error: "reordering.item.not_found";
-};
-export declare const ReorderingCannotFindCurrentError: {
-    readonly error: "reordering.current_item.not_found";
-};
-export declare const ReorderingCannotFindTargetError: {
-    readonly error: "reordering.target_item.not_found";
-};
-export declare const ReorderingCorrelationIdError: {
-    readonly error: "reordering.correlation_id.invalid";
-};
-export declare const ReorderingItemIdError: {
-    readonly error: "reordering.item_id.invalid";
-};
-export declare const ReorderingItemPositionValue: z.ZodNumber;
-export type ReorderingItemPositionValueType = z.infer<typeof ReorderingItemPositionValue>;
-export declare const ReorderingCorrelationId: z.ZodString;
-export type ReorderingCorrelationIdType = z.infer<typeof ReorderingCorrelationId>;
-export declare const ReorderingItemId: z.ZodString;
-export type ReorderingItemIdType = z.infer<typeof ReorderingItemId>;
+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;