@bgord/tools 0.17.2 → 1.0.1

package/dist/{simple-linear-regression.service.js → linear-regression.service.js}

@@ -1,22 +1,24 @@
 import { RoundToNearest } from "./rounding.adapter";
-export const SLRMinPairsError = "slr.min.pairs";
-export const SLRSumXTooBigError = "slr.sum.x.too.big";
-export const SLRSumYTooBigError = "slr.sum.y.too.big";
-export const SLRSumXSquaredTooBigError = "slr.sum.x.squared.too.big";
-export const SLRSumXTimesYTooBigError = "slr.sum.x.times.y.too.big";
-export const SLRModelCreationError = "slr.model.creation";
-export class SimpleLinearRegression {
+export const LinearRegressionError = {
+    MinPairs: "linear.regression.min.pairs",
+    SumXTooBig: "linear.regression.sum.x.too.big",
+    SumYTooBig: "linear.regression.sum.y.too.big",
+    SumXSquaredTooBig: "linear.regression.sum.x.squared.too.big",
+    SumXTimesYTooBig: "linear.regression.sum.x.times.y.too.big",
+    ModelCreation: "linear.regression.model.creation",
+};
+export class LinearRegression {
     static DEFAULT_ROUNDING = new RoundToNearest();
     params;
     rounding;
     constructor(params, rounding) {
         this.params = params;
-        this.rounding = rounding ?? SimpleLinearRegression.DEFAULT_ROUNDING;
+        this.rounding = rounding ?? LinearRegression.DEFAULT_ROUNDING;
     }
     static fromPairs(pairs, rounding) {
         const count = pairs.length;
         if (count < 2)
-            throw new Error(SLRMinPairsError);
+            throw new Error(LinearRegressionError.MinPairs);
         let sumX = 0;
         let sumY = 0;
         let sumXX = 0;
@@ -29,19 +31,19 @@ export class SimpleLinearRegression {
             sumXY += pair.x * pair.y;
         }
         if (Math.abs(sumX) >= Number.MAX_SAFE_INTEGER)
-            throw new Error(SLRSumXTooBigError);
+            throw new Error(LinearRegressionError.SumXTooBig);
         if (Math.abs(sumY) >= Number.MAX_SAFE_INTEGER)
-            throw new Error(SLRSumYTooBigError);
+            throw new Error(LinearRegressionError.SumYTooBig);
         if (Math.abs(sumXY) >= Number.MAX_SAFE_INTEGER)
-            throw new Error(SLRSumXTimesYTooBigError);
+            throw new Error(LinearRegressionError.SumXTimesYTooBig);
         if (Math.abs(sumXX) >= Number.MAX_SAFE_INTEGER)
-            throw new Error(SLRSumXSquaredTooBigError);
+            throw new Error(LinearRegressionError.SumXSquaredTooBig);
         const bDenominator = sumXX - sumX ** 2 / count;
         if (bDenominator === 0)
-            throw new Error(SLRModelCreationError);
+            throw new Error(LinearRegressionError.ModelCreation);
         const b = (sumXY - (sumX * sumY) / count) / bDenominator;
         const a = (sumY - b * sumX) / count;
-        return new SimpleLinearRegression({ a, b }, rounding);
+        return new LinearRegression({ a, b }, rounding);
     }
     predict(x, rounding) {
         const chosen = rounding ?? this.rounding;

package/dist/mean.service.d.ts

@@ -1,5 +1,7 @@
 import type { RoundingPort } from "./rounding.port";
-export declare const MeanEmptyValuesError: "mean.values.empty";
+export declare const MeanError: {
+    readonly NotEnoughValues: "mean.not.enough.values";
+};
 export declare class Mean {
     private static readonly DEFAULT_ROUNDING;
     static calculate(values: number[], rounding?: RoundingPort): number;

package/dist/mean.service.js

@@ -1,14 +1,13 @@
 import { RoundToDecimal } from "./rounding.adapter";
 import { Sum } from "./sum.service";
-export const MeanEmptyValuesError = "mean.values.empty";
+export const MeanError = { NotEnoughValues: "mean.not.enough.values" };
 export class Mean {
     static DEFAULT_ROUNDING = new RoundToDecimal(2);
     static calculate(values, rounding) {
         if (values.length === 0)
-            throw new Error(MeanEmptyValuesError);
+            throw new Error(MeanError.NotEnoughValues);
         const sum = Sum.of(values);
         const mean = sum / values.length;
-        const chosen = rounding ?? Mean.DEFAULT_ROUNDING;
-        return chosen.round(mean);
+        return (rounding ?? Mean.DEFAULT_ROUNDING).round(mean);
     }
 }

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

@@ -1,2 +1 @@
-import type { MimeRawType } from "./mime.vo";
-export declare const MIME_TYPES: Record<string, MimeRawType[]>;
+export declare const MIME_TYPES: Record<string, string[]>;

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

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+export declare const MimeValueError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const MimeValue: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<{
+    type: string;
+    subtype: string;
+}, string>>, "MimeValue">;

package/dist/mime-value.vo.js

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+export const MimeValueError = { Type: "mime.value.type", Invalid: "mime.value.invalid" };
+// One to twenty four lowercase letters, asterisk or hyphen, forward slash, one to twenty four lowercase letters, asterisk or hyphen
+const MIME_VALUE_CHARS_WHITELIST = /^[a-z*-]{1,24}\/[a-z*-]{1,24}$/;
+export const MimeValue = z
+    .string(MimeValueError.Type)
+    .regex(MIME_VALUE_CHARS_WHITELIST, MimeValueError.Invalid)
+    .transform((value) => ({ type: value.split("/")[0], subtype: value.split("/")[1] }))
+    .brand("MimeValue");

package/dist/mime.vo.d.ts

@@ -1,24 +1,19 @@
 import { type ExtensionType } from "./extension.vo";
-export type MimeRawType = string;
-type MimeTypeType = string;
-type MimeSubtypeType = string;
-export declare const InvalidMimeErrorMessage: "invalid.mime";
-export declare const NotAcceptedMimeErrorMessage: "mime.not.accepted";
+export declare const MimeError: {
+    readonly NotAccepted: "mime.not.accepted";
+};
 export declare class Mime {
-    readonly raw: MimeRawType;
-    readonly type: MimeTypeType;
-    readonly subtype: MimeSubtypeType;
-    constructor(value: MimeRawType);
+    readonly type: string;
+    readonly subtype: string;
+    constructor(candidate: string);
     static fromExtension(extension: ExtensionType): Mime;
     isSatisfiedBy(another: Mime): boolean;
     toExtension(): ExtensionType;
-}
-export declare class InvalidMimeError extends Error {
-    constructor();
-}
-export declare class NotAcceptedMimeError extends Error {
-    mime: MimeRawType;
-    constructor(mimeValue: MimeRawType);
+    toString(): string;
+    toJSON(): {
+        type: string;
+        subtype: string;
+    };
 }
 export declare const MIMES: {
     csv: Mime;
@@ -26,4 +21,3 @@ export declare const MIMES: {
     markdown: Mime;
     pdf: Mime;
 };
-export {};

package/dist/mime.vo.js

@@ -1,18 +1,12 @@
 import * as mime from "mime-types";
 import { Extension } from "./extension.vo";
-export const InvalidMimeErrorMessage = "invalid.mime";
-export const NotAcceptedMimeErrorMessage = "mime.not.accepted";
+import { MimeValue } from "./mime-value.vo";
+export const MimeError = { NotAccepted: "mime.not.accepted" };
 export class Mime {
-    raw;
     type;
     subtype;
-    constructor(value) {
-        const [type, subtype] = value.split("/");
-        if (typeof type !== "string" || type.length === 0)
-            throw new InvalidMimeError();
-        if (typeof subtype !== "string" || subtype.length === 0)
-            throw new InvalidMimeError();
-        this.raw = value;
+    constructor(candidate) {
+        const { type, subtype } = MimeValue.parse(candidate);
         this.type = type;
         this.subtype = subtype;
     }
@@ -20,29 +14,18 @@ export class Mime {
         return new Mime(String(mime.contentType(extension)));
     }
     isSatisfiedBy(another) {
-        if (this.raw === another.raw)
-            return true;
-        const typeMatches = this.type === another.type || this.type === "*";
-        if (!typeMatches)
+        if (!(this.type === another.type || this.type === "*"))
             return false;
         return this.subtype === another.subtype || this.subtype === "*";
     }
     toExtension() {
-        return Extension.parse(mime.extension(this.raw));
+        return Extension.parse(mime.extension(this.toString()));
     }
-}
-export class InvalidMimeError extends Error {
-    constructor() {
-        super(InvalidMimeErrorMessage);
-        Object.setPrototypeOf(this, InvalidMimeError.prototype);
+    toString() {
+        return `${this.type}/${this.subtype}`;
     }
-}
-export class NotAcceptedMimeError extends Error {
-    mime;
-    constructor(mimeValue) {
-        super(NotAcceptedMimeErrorMessage);
-        Object.setPrototypeOf(this, NotAcceptedMimeError.prototype);
-        this.mime = mimeValue;
+    toJSON() {
+        return { type: this.type, subtype: this.subtype };
     }
 }
 export const MIMES = {

package/dist/min-max-scaler.service.d.ts

@@ -9,11 +9,6 @@ type MinMaxScalerConfigType = {
     };
     rounding?: RoundingPort;
 };
-export declare const MinMaxInvalidMinMaxError: "minmax.invalid.minmax";
-export declare const MinMaxInvalidBoundError: "minmax.invalid.bound";
-export declare const MinMaxValueOutOfRangeError: "minmax.value.out.of.range";
-export declare const MinMaxScaledOutOfBoundsError: "minmax.scaled.out.of.bounds";
-export declare const MinMaxEmptyArrayError: "minmax.empty.array";
 type ScaleResult = {
     original: MinMaxScalerValueType;
     scaled: MinMaxScalerValueType;
@@ -26,6 +21,13 @@ type DescaleResult = {
     isLowerBound: boolean;
     isUpperBound: boolean;
 };
+export declare const MinMaxScalerError: {
+    readonly InvalidMinMax: "min.max.scaler.invalid.min.max";
+    readonly InvalidBound: "min.max.scaler.invalid.bound";
+    readonly ValueOutOfRange: "min.max.scaler.value.out.of.range";
+    readonly ScaledOutOfBounds: "min.max.scaler.scaled.out.of.bounds";
+    readonly EmptyArray: "min.max.scaler.empty.array";
+};
 export declare class MinMaxScaler {
     private static readonly DEFAULT_ROUNDING;
     private readonly min;

package/dist/min-max-scaler.service.js

@@ -1,9 +1,11 @@
 import { RoundToDecimal } from "./rounding.adapter";
-export const MinMaxInvalidMinMaxError = "minmax.invalid.minmax";
-export const MinMaxInvalidBoundError = "minmax.invalid.bound";
-export const MinMaxValueOutOfRangeError = "minmax.value.out.of.range";
-export const MinMaxScaledOutOfBoundsError = "minmax.scaled.out.of.bounds";
-export const MinMaxEmptyArrayError = "minmax.empty.array";
+export const MinMaxScalerError = {
+    InvalidMinMax: "min.max.scaler.invalid.min.max",
+    InvalidBound: "min.max.scaler.invalid.bound",
+    ValueOutOfRange: "min.max.scaler.value.out.of.range",
+    ScaledOutOfBounds: "min.max.scaler.scaled.out.of.bounds",
+    EmptyArray: "min.max.scaler.empty.array",
+};
 export class MinMaxScaler {
     static DEFAULT_ROUNDING = new RoundToDecimal(2);
     min;
@@ -15,9 +17,9 @@ export class MinMaxScaler {
         const lower = config.bound?.lower ?? 0;
         const upper = config.bound?.upper ?? 1;
         if (config.max - config.min < 0)
-            throw new Error(MinMaxInvalidMinMaxError);
+            throw new Error(MinMaxScalerError.InvalidMinMax);
         if (upper - lower <= 0)
-            throw new Error(MinMaxInvalidBoundError);
+            throw new Error(MinMaxScalerError.InvalidBound);
         this.rounding = config.rounding ?? MinMaxScaler.DEFAULT_ROUNDING;
         this.min = config.min;
         this.max = config.max;
@@ -27,7 +29,7 @@ export class MinMaxScaler {
     scale(value) {
         const { min, max, lower, upper } = this;
         if (value < min || value > max)
-            throw new Error(MinMaxValueOutOfRangeError);
+            throw new Error(MinMaxScalerError.ValueOutOfRange);
         if (min === max) {
             return { original: value, scaled: (lower + upper) / 2, isMin: value === min, isMax: value === max };
         }
@@ -42,7 +44,7 @@ export class MinMaxScaler {
     descale(scaled) {
         const { min, max, lower, upper } = this;
         if (scaled < lower || scaled > upper)
-            throw new Error(MinMaxScaledOutOfBoundsError);
+            throw new Error(MinMaxScalerError.ScaledOutOfBounds);
         const result = ((scaled - lower) / (upper - lower)) * (max - min) + min;
         return {
             original: this.rounding.round(result),
@@ -53,7 +55,7 @@ export class MinMaxScaler {
     }
     static getMinMax(values) {
         if (values.length === 0)
-            throw new Error(MinMaxEmptyArrayError);
+            throw new Error(MinMaxScalerError.EmptyArray);
         return { min: Math.min(...values), max: Math.max(...values) };
     }
 }

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

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+export declare const MinuteSchemaError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const MinuteSchema: z.core.$ZodBranded<z.ZodNumber, "MinuteSchema">;
+export type MinuteSchemaType = z.infer<typeof MinuteSchema>;

package/dist/minute-schema.vo.js

@@ -0,0 +1,8 @@
+import { z } from "zod/v4";
+export const MinuteSchemaError = { Type: "minute.schema.error", Invalid: "minute.schema.invalid" };
+export const MinuteSchema = z
+    .number(MinuteSchemaError.Type)
+    .int(MinuteSchemaError.Type)
+    .gte(0, MinuteSchemaError.Invalid)
+    .lte(59, MinuteSchemaError.Invalid)
+    .brand("MinuteSchema");

package/dist/minute.vo.d.ts

@@ -1,15 +1,16 @@
+import { type MinuteSchemaType } from "./minute-schema.vo";
 import type { TimestampType } from "./timestamp.vo";
-export declare const MinuteValueError: "invalid.minute";
 export declare class Minute {
     private readonly value;
     static readonly ZERO: Minute;
     static readonly MAX: Minute;
     constructor(candidate: number);
     static fromEpochMs(timestamp: TimestampType): Minute;
-    get(): number;
-    toString(): string;
+    get(): MinuteSchemaType;
     equals(another: Minute): boolean;
     isAfter(another: Minute): boolean;
     isBefore(another: Minute): boolean;
     static list(): readonly Minute[];
+    toString(): string;
+    toJSON(): number;
 }

package/dist/minute.vo.js

@@ -1,13 +1,10 @@
-export const MinuteValueError = "invalid.minute";
+import { MinuteSchema } from "./minute-schema.vo";
 export class Minute {
     value;
     static ZERO = new Minute(0);
     static MAX = new Minute(59);
     constructor(candidate) {
-        if (!Number.isInteger(candidate) || candidate < 0 || candidate >= 60) {
-            throw new Error(MinuteValueError);
-        }
-        this.value = candidate;
+        this.value = MinuteSchema.parse(candidate);
     }
     static fromEpochMs(timestamp) {
         return new Minute(new Date(timestamp).getUTCMinutes());
@@ -15,9 +12,6 @@ export class Minute {
     get() {
         return this.value;
     }
-    toString() {
-        return this.value.toString().padStart(2, "0");
-    }
     equals(another) {
         return this.value === another.value;
     }
@@ -30,4 +24,10 @@ export class Minute {
     static list() {
         return Array.from({ length: 60 }, (_, index) => new Minute(index));
     }
+    toString() {
+        return this.value.toString().padStart(2, "0");
+    }
+    toJSON() {
+        return this.value;
+    }
 }

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

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+export declare const MoneyAmountError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const MoneyAmount: z.core.$ZodBranded<z.ZodNumber, "MoneyAmount">;
+export type MoneyAmountType = z.infer<typeof MoneyAmount>;

package/dist/money-amount.vo.js

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+export const MoneyAmountError = { Type: "money.amount.type", Invalid: "money.amount.invalid" };
+export const MoneyAmount = z
+    .number(MoneyAmountError.Type)
+    .int(MoneyAmountError.Type)
+    .min(0, MoneyAmountError.Invalid)
+    .brand("MoneyAmount");

package/dist/money.vo.d.ts

@@ -1,21 +1,10 @@
-import { z } from "zod/v4";
+import type { DivisionFactorType } from "./division-factor.vo";
+import { type MoneyAmountType } from "./money-amount.vo";
+import type { MultiplicationFactorType } from "./multiplication-factor.vo";
 import type { RoundingPort } from "./rounding.port";
-export declare const MoneyAmountInvalidError: {
-    readonly error: "money.amount.invalid";
+export declare const MoneyError: {
+    readonly SubtractResultLessThanZero: "money.subtract.result.less.than.zero";
 };
-export declare const MoneyMultiplicationFactorInvalidError: {
-    readonly error: "money.multiplication-factor.invalid";
-};
-export declare const MoneyDivisionFactorInvalidError: {
-    readonly error: "money.division-factor.invalid";
-};
-export declare const MoneySubtractLessThanZeroError: "money.subtract.less.than.zero";
-export declare const MoneyAmount: z.core.$ZodBranded<z.ZodNumber, "MoneyAmount">;
-export type MoneyAmountType = z.infer<typeof MoneyAmount>;
-export declare const MoneyMultiplicationFactor: z.core.$ZodBranded<z.ZodNumber, "MoneyMultiplicationFactor">;
-export type MoneyMultiplicationFactorType = z.infer<typeof MoneyMultiplicationFactor>;
-export declare const MoneyDivisionFactor: z.core.$ZodBranded<z.ZodNumber, "MoneyDivisionFactor">;
-export type MoneyDivisionFactorType = z.infer<typeof MoneyDivisionFactor>;
 export declare class Money {
     private static readonly ZERO;
     private static readonly DEFAULT_ROUNDING;
@@ -24,12 +13,14 @@ export declare class Money {
     constructor(value?: number, rounding?: RoundingPort);
     getAmount(): MoneyAmountType;
     add(money: Money): Money;
-    multiply(factor: MoneyMultiplicationFactorType): Money;
+    multiply(factor: MultiplicationFactorType): Money;
     subtract(money: Money): Money;
-    divide(factor: MoneyDivisionFactorType): Money;
+    divide(factor: DivisionFactorType): Money;
     equals(another: Money): boolean;
     isGreaterThan(another: Money): boolean;
     isLessThan(another: Money): boolean;
     isZero(): boolean;
     format(): string;
+    toString(): string;
+    toJSON(): number;
 }

package/dist/money.vo.js

@@ -1,24 +1,6 @@
-import { z } from "zod/v4";
-import { RoundToNearest } from "./rounding.adapter";
-export const MoneyAmountInvalidError = { error: "money.amount.invalid" };
-export const MoneyMultiplicationFactorInvalidError = {
-    error: "money.multiplication-factor.invalid",
-};
-export const MoneyDivisionFactorInvalidError = { error: "money.division-factor.invalid" };
-export const MoneySubtractLessThanZeroError = "money.subtract.less.than.zero";
-export const MoneyAmount = z
-    .number(MoneyAmountInvalidError)
-    .int(MoneyAmountInvalidError)
-    .min(0, MoneyAmountInvalidError)
-    .brand("MoneyAmount");
-export const MoneyMultiplicationFactor = z
-    .number(MoneyMultiplicationFactorInvalidError)
-    .min(0, MoneyMultiplicationFactorInvalidError)
-    .brand("MoneyMultiplicationFactor");
-export const MoneyDivisionFactor = z
-    .number(MoneyDivisionFactorInvalidError)
-    .gt(0, MoneyDivisionFactorInvalidError)
-    .brand("MoneyDivisionFactor");
+import { MoneyAmount } from "./money-amount.vo";
+import { RoundDown, RoundToNearest } from "./rounding.adapter";
+export const MoneyError = { SubtractResultLessThanZero: "money.subtract.result.less.than.zero" };
 export class Money {
     static ZERO = 0;
     static DEFAULT_ROUNDING = new RoundToNearest();
@@ -32,7 +14,7 @@ export class Money {
         return this.amount;
     }
     add(money) {
-        const result = this.rounding.round(this.amount + money.getAmount());
+        const result = this.amount + money.getAmount();
         return new Money(MoneyAmount.parse(result), this.rounding);
     }
     multiply(factor) {
@@ -40,9 +22,9 @@ export class Money {
         return new Money(MoneyAmount.parse(result), this.rounding);
     }
     subtract(money) {
-        const result = this.rounding.round(this.amount - money.getAmount());
+        const result = this.amount - money.getAmount();
         if (result < Money.ZERO)
-            throw new Error(MoneySubtractLessThanZeroError);
+            throw new Error(MoneyError.SubtractResultLessThanZero);
         return new Money(MoneyAmount.parse(result), this.rounding);
     }
     divide(factor) {
@@ -62,9 +44,14 @@ export class Money {
         return this.amount === Money.ZERO;
     }
     format() {
-        const whole = Math.floor(this.amount / 100);
+        const whole = new RoundDown().round(this.amount / 100);
         const fraction = this.amount % 100;
-        const fractionFormatted = fraction.toString().padStart(2, "0");
-        return `${whole}.${fractionFormatted}`;
+        return `${whole}.${fraction.toString().padStart(2, "0")}`;
+    }
+    toString() {
+        return this.format();
+    }
+    toJSON() {
+        return this.amount;
     }
 }

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

@@ -1,6 +1,8 @@
 import { z } from "zod/v4";
 export declare const MonthIsoIdError: {
-    readonly error: "month-iso-id.invalid";
+    readonly Type: "month.iso.id.type";
+    readonly BadChars: "month.iso.id.bad.chars";
+    readonly Invalid: "month.iso.id.invalid";
 };
-export declare const MonthIsoId: z.ZodString;
+export declare const MonthIsoId: z.core.$ZodBranded<z.ZodString, "MonthIsoId">;
 export type MonthIsoIdType = z.infer<typeof MonthIsoId>;

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

@@ -1,10 +1,16 @@
 import { z } from "zod/v4";
-export const MonthIsoIdError = { error: "month-iso-id.invalid" };
+export const MonthIsoIdError = {
+    Type: "month.iso.id.type",
+    BadChars: "month.iso.id.bad.chars",
+    Invalid: "month.iso.id.invalid",
+};
+// Four digits, hyphen, two digits
+const MONTH_ISO_ID_CHARS_WHITELIST = /^\d{4}-\d{2}$/;
 export const MonthIsoId = z
-    .string(MonthIsoIdError)
-    .regex(/^\d{4}-\d{2}$/, MonthIsoIdError)
+    .string(MonthIsoIdError.Type)
+    .regex(MONTH_ISO_ID_CHARS_WHITELIST, MonthIsoIdError.BadChars)
     .refine((value) => {
-    const year = Number(value.slice(0, 4));
-    const month = Number(value.slice(5, 7));
-    return Number.isInteger(year) && Number.isInteger(month) && month >= 1 && month <= 12;
-}, MonthIsoIdError);
+    const month = value.split("-").map(Number)[1];
+    return month >= 1 && month <= 12;
+}, MonthIsoIdError.Invalid)
+    .brand("MonthIsoId");

package/dist/month.vo.d.ts

@@ -2,11 +2,12 @@ import { DateRange } from "./date-range.vo";
 import { type MonthIsoIdType } from "./month-iso-id.vo";
 import { type TimestampType } from "./timestamp.vo";
 export declare class Month extends DateRange {
+    static fromTimestamp(timestamp: TimestampType): Month;
+    static fromNow(now: TimestampType): Month;
+    static fromIsoId(iso: MonthIsoIdType): Month;
     toIsoId(): MonthIsoIdType;
     previous(): Month;
     next(): Month;
     shift(count: number): Month;
-    static fromTimestamp(timestamp: TimestampType): Month;
-    static fromNow(now: TimestampType): Month;
-    static fromIsoId(iso: MonthIsoIdType): Month;
+    toString(): string;
 }

package/dist/month.vo.js

@@ -1,35 +1,35 @@
+import { endOfMonth, format, getMonth, setMonth, startOfMonth } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { MonthIsoId } from "./month-iso-id.vo";
 import { Timestamp } from "./timestamp.vo";
 export class Month extends DateRange {
+    static fromTimestamp(timestamp) {
+        const start = Timestamp.parse(startOfMonth(timestamp).getTime());
+        const end = Timestamp.parse(endOfMonth(timestamp).getTime());
+        return new Month(start, end);
+    }
+    static fromNow(now) {
+        return Month.fromTimestamp(now);
+    }
+    static fromIsoId(iso) {
+        const [year, month] = MonthIsoId.parse(iso).split("-").map(Number);
+        const reference = setMonth(Date.UTC(year), month - 1).getTime();
+        return Month.fromTimestamp(Timestamp.parse(reference));
+    }
     toIsoId() {
-        return new Date(this.getStart()).toISOString().slice(0, 7);
+        return MonthIsoId.parse(format(this.getStart(), "yyyy-MM"));
     }
     previous() {
-        return Month.fromTimestamp(Timestamp.parse(this.getStart() - 1));
+        return this.shift(-1);
     }
     next() {
-        return Month.fromTimestamp(Timestamp.parse(this.getEnd() + 1));
+        return this.shift(1);
     }
     shift(count) {
-        const date = new Date(this.getStart());
-        date.setUTCMonth(date.getUTCMonth() + count);
-        return Month.fromTimestamp(Timestamp.parse(date.getTime()));
+        const shifted = setMonth(this.getStart(), getMonth(this.getStart()) + count).getTime();
+        return Month.fromTimestamp(Timestamp.parse(shifted));
     }
-    static fromTimestamp(timestamp) {
-        const isoMonth = new Date(timestamp).toISOString().slice(0, 7);
-        return Month.fromIsoId(isoMonth);
-    }
-    static fromNow(now) {
-        return Month.fromTimestamp(now);
-    }
-    static fromIsoId(iso) {
-        const validated = MonthIsoId.parse(iso);
-        const year = Number(validated.slice(0, 4));
-        const monthIndex = Number(validated.slice(5, 7)) - 1;
-        const startUtc = Date.UTC(year, monthIndex, 1);
-        const nextStartUtc = Date.UTC(year, monthIndex + 1, 1);
-        const endUtc = nextStartUtc - 1;
-        return new Month(Timestamp.parse(startUtc), Timestamp.parse(endUtc));
+    toString() {
+        return this.toIsoId();
     }
 }

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

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+export declare const MultiplicationFactorError: {
+    readonly Type: "multiplication.factor.type";
+    readonly Invalid: "multiplication.factor.invalid";
+};
+export declare const MultiplicationFactor: z.core.$ZodBranded<z.ZodNumber, "MultiplicationFactor">;
+export type MultiplicationFactorType = z.infer<typeof MultiplicationFactor>;

package/dist/multiplication-factor.vo.js

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+export const MultiplicationFactorError = {
+    Type: "multiplication.factor.type",
+    Invalid: "multiplication.factor.invalid",
+};
+export const MultiplicationFactor = z
+    .number(MultiplicationFactorError.Type)
+    .min(0, MultiplicationFactorError.Invalid)
+    .brand("MultiplicationFactor");