@bgord/tools 1.1.2 → 1.1.4

package/dist/age.vo.d.ts

@@ -1,4 +1,4 @@
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export declare const AgeError: {
     readonly FutureBirthdate: "age.future.birthdate";
 };
@@ -9,12 +9,12 @@ export declare class Age {
     private constructor();
     static fromValue(candidate: number): Age;
     static fromBirthdateTimestamp(params: {
-        birthdate: TimestampVO;
-        now: TimestampVO;
+        birthdate: Timestamp;
+        now: Timestamp;
     }): Age;
     static fromBirthdate(candidate: {
         birthdate: string;
-        now: TimestampVO;
+        now: Timestamp;
     }): Age;
     get(): number;
     equals(other: Age): boolean;

package/dist/age.vo.js

@@ -1,6 +1,6 @@
 import { differenceInYears } from "date-fns";
 import { AgeYears, AgeYearsConstraints } from "./age-years.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export const AgeError = { FutureBirthdate: "age.future.birthdate" };
 export class Age {
     value;
@@ -18,7 +18,7 @@ export class Age {
         return Age.fromValue(differenceInYears(params.now.ms, params.birthdate.ms));
     }
     static fromBirthdate(candidate) {
-        const birthdate = TimestampVO.fromNumber(new Date(candidate.birthdate).getTime());
+        const birthdate = Timestamp.fromNumber(new Date(candidate.birthdate).getTime());
         if (birthdate.isAfter(candidate.now))
             throw new Error(AgeError.FutureBirthdate);
         return Age.fromValue(differenceInYears(candidate.now.ms, birthdate.ms));

package/dist/clock.vo.d.ts

@@ -3,13 +3,13 @@ import { Hour } from "./hour.vo";
 import type { HourSchemaType } from "./hour-schema.vo";
 import { Minute } from "./minute.vo";
 import type { MinuteSchemaType } from "./minute-schema.vo";
-import type { TimestampVO } from "./timestamp.vo";
+import type { Timestamp } from "./timestamp.vo";
 export declare class Clock {
     private readonly hour;
     private readonly minute;
     private readonly formatter;
     constructor(hour: Hour, minute: Minute, formatter?: ClockFormatter);
-    static fromTimestamp(timestamp: TimestampVO, formatter?: ClockFormatter): Clock;
+    static fromTimestamp(timestamp: Timestamp, formatter?: ClockFormatter): Clock;
     get(): {
         hour: HourSchemaType;
         minute: MinuteSchemaType;

package/dist/date-calculator.service.d.ts

@@ -1,10 +1,10 @@
 import { Duration } from "./duration.service";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 type GetStartOfDayTsInTzConfigType = {
-    now: TimestampVO;
+    now: Timestamp;
     timeZoneOffset: Duration;
 };
 export declare class DateCalculator {
-    static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType): TimestampVO;
+    static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType): Timestamp;
 }
 export {};

package/dist/date-calculator.service.js

@@ -1,9 +1,9 @@
 import { Duration } from "./duration.service";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export class DateCalculator {
     static getStartOfDayTsInTz(config) {
         const dayMs = Duration.Days(1).ms;
-        const utcMidnightOfNow = TimestampVO.fromNumber(Math.floor(config.now.ms / dayMs) * dayMs);
+        const utcMidnightOfNow = Timestamp.fromNumber(Math.floor(config.now.ms / dayMs) * dayMs);
         let startOfDayInTz = utcMidnightOfNow.add(config.timeZoneOffset);
         if (startOfDayInTz.isAfter(config.now))
             startOfDayInTz = startOfDayInTz.subtract(Duration.Days(1));

package/dist/date-range.vo.d.ts

@@ -1,15 +1,15 @@
-import type { TimestampVO } from "./timestamp.vo";
+import type { Timestamp } from "./timestamp.vo";
 export declare const DateRangeError: {
     readonly Invalid: "date.range.invalid";
 };
 export declare class DateRange {
     private readonly start;
     private readonly end;
-    constructor(start: TimestampVO, end: TimestampVO);
-    getStart(): TimestampVO;
-    getEnd(): TimestampVO;
-    toRange(): [TimestampVO, TimestampVO];
-    contains(timestamp: TimestampVO): boolean;
+    constructor(start: Timestamp, end: Timestamp);
+    getStart(): Timestamp;
+    getEnd(): Timestamp;
+    toRange(): [Timestamp, Timestamp];
+    contains(timestamp: Timestamp): boolean;
     equals(other: DateRange): boolean;
     toJSON(): {
         start: number;

package/dist/day.vo.d.ts

@@ -1,11 +1,11 @@
 import { DateRange } from "./date-range.vo";
 import { type DayIsoIdType } from "./day-iso-id.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Day extends DateRange {
-    static fromTimestamp(timestamp: TimestampVO): Day;
+    static fromTimestamp(timestamp: Timestamp): Day;
     static fromTimestampValue(timestamp: TimestampValueType): Day;
-    static fromNow(now: TimestampVO): Day;
+    static fromNow(now: Timestamp): Day;
     static fromIsoId(isoId: DayIsoIdType): Day;
     toIsoId(): DayIsoIdType;
     previous(): Day;

package/dist/day.vo.js

@@ -2,23 +2,23 @@ import { formatISO } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { DayIsoId } from "./day-iso-id.vo";
 import { Duration } from "./duration.service";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export class Day extends DateRange {
     static fromTimestamp(timestamp) {
         const date = new Date(timestamp.ms);
-        const startUtc = TimestampVO.fromNumber(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+        const startUtc = Timestamp.fromNumber(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
         const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
         return new Day(startUtc, endUtc);
     }
     static fromTimestampValue(timestamp) {
-        return Day.fromTimestamp(TimestampVO.fromValue(timestamp));
+        return Day.fromTimestamp(Timestamp.fromValue(timestamp));
     }
     static fromNow(now) {
         return Day.fromTimestamp(now);
     }
     static fromIsoId(isoId) {
         const [year, month, day] = DayIsoId.parse(isoId).split("-").map(Number);
-        const startUtc = TimestampVO.fromNumber(Date.UTC(year, month - 1, day));
+        const startUtc = Timestamp.fromNumber(Date.UTC(year, month - 1, day));
         const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
         return new Day(startUtc, endUtc);
     }

package/dist/duration.service.d.ts

@@ -25,4 +25,5 @@ export declare class Duration {
     equals(other: Duration): boolean;
     add(another: Duration): Duration;
     subtract(another: Duration): Duration;
+    toAbolute(): Duration;
 }

package/dist/duration.service.js

@@ -62,4 +62,7 @@ export class Duration {
     subtract(another) {
         return Duration.Ms(this.internal - another.internal);
     }
+    toAbolute() {
+        return Duration.Ms(Math.abs(this.internal));
+    }
 }

package/dist/hour.vo.d.ts

@@ -1,13 +1,13 @@
 import { type HourFormatter } from "./hour-format.service";
 import { type HourSchemaType } from "./hour-schema.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Hour {
     private readonly value;
     static readonly ZERO: Hour;
     static readonly MAX: Hour;
     constructor(candidate: number);
-    static fromTimestamp(timestamp: TimestampVO): Hour;
+    static fromTimestamp(timestamp: Timestamp): Hour;
     static fromTimestampValue(timestamp: TimestampValueType): Hour;
     get(): HourSchemaType;
     format(formatter: HourFormatter): string;

package/dist/hour.vo.js

@@ -1,6 +1,6 @@
 import { HourFormatters } from "./hour-format.service";
 import { HourSchema } from "./hour-schema.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export class Hour {
     value;
     static ZERO = new Hour(0);
@@ -12,7 +12,7 @@ export class Hour {
         return new Hour(new Date(timestamp.ms).getUTCHours());
     }
     static fromTimestampValue(timestamp) {
-        return Hour.fromTimestamp(TimestampVO.fromValue(timestamp));
+        return Hour.fromTimestamp(Timestamp.fromValue(timestamp));
     }
     get() {
         return this.value;

package/dist/minute.vo.d.ts

@@ -1,12 +1,12 @@
 import { type MinuteSchemaType } from "./minute-schema.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Minute {
     private readonly value;
     static readonly ZERO: Minute;
     static readonly MAX: Minute;
     constructor(candidate: number);
-    static fromTimestamp(timestamp: TimestampVO): Minute;
+    static fromTimestamp(timestamp: Timestamp): Minute;
     static fromTimestampValue(timestamp: TimestampValueType): Minute;
     get(): MinuteSchemaType;
     equals(another: Minute): boolean;

package/dist/minute.vo.js

@@ -1,5 +1,5 @@
 import { MinuteSchema } from "./minute-schema.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export class Minute {
     value;
     static ZERO = new Minute(0);
@@ -11,7 +11,7 @@ export class Minute {
         return new Minute(new Date(timestamp.ms).getUTCMinutes());
     }
     static fromTimestampValue(timestamp) {
-        return Minute.fromTimestamp(TimestampVO.fromValue(timestamp));
+        return Minute.fromTimestamp(Timestamp.fromValue(timestamp));
     }
     get() {
         return this.value;

package/dist/month.vo.d.ts

@@ -1,11 +1,11 @@
 import { DateRange } from "./date-range.vo";
 import { type MonthIsoIdType } from "./month-iso-id.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Month extends DateRange {
-    static fromTimestamp(timestamp: TimestampVO): Month;
+    static fromTimestamp(timestamp: Timestamp): Month;
     static fromTimestampValue(timestamp: TimestampValueType): Month;
-    static fromNow(now: TimestampVO): Month;
+    static fromNow(now: Timestamp): Month;
     static fromIsoId(iso: MonthIsoIdType): Month;
     toIsoId(): MonthIsoIdType;
     previous(): Month;

package/dist/month.vo.js

@@ -1,15 +1,15 @@
 import { endOfMonth, format, getMonth, setMonth, startOfMonth } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { MonthIsoId } from "./month-iso-id.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export class Month extends DateRange {
     static fromTimestamp(timestamp) {
-        const start = TimestampVO.fromNumber(startOfMonth(timestamp.ms).getTime());
-        const end = TimestampVO.fromNumber(endOfMonth(timestamp.ms).getTime());
+        const start = Timestamp.fromNumber(startOfMonth(timestamp.ms).getTime());
+        const end = Timestamp.fromNumber(endOfMonth(timestamp.ms).getTime());
         return new Month(start, end);
     }
     static fromTimestampValue(timestamp) {
-        return Month.fromTimestamp(TimestampVO.fromValue(timestamp));
+        return Month.fromTimestamp(Timestamp.fromValue(timestamp));
     }
     static fromNow(now) {
         return Month.fromTimestamp(now);
@@ -17,7 +17,7 @@ export class Month extends DateRange {
     static fromIsoId(iso) {
         const [year, month] = MonthIsoId.parse(iso).split("-").map(Number);
         const reference = setMonth(Date.UTC(year), month - 1).getTime();
-        return Month.fromTimestamp(TimestampVO.fromNumber(reference));
+        return Month.fromTimestamp(Timestamp.fromNumber(reference));
     }
     toIsoId() {
         return MonthIsoId.parse(format(this.getStart().ms, "yyyy-MM"));
@@ -30,7 +30,7 @@ export class Month extends DateRange {
     }
     shift(count) {
         const shifted = setMonth(this.getStart().ms, getMonth(this.getStart().ms) + count).getTime();
-        return Month.fromTimestamp(TimestampVO.fromNumber(shifted));
+        return Month.fromTimestamp(Timestamp.fromNumber(shifted));
     }
     toString() {
         return this.toIsoId();

package/dist/quarter.vo.d.ts

@@ -1,11 +1,11 @@
 import { DateRange } from "./date-range.vo";
 import { type QuarterIsoIdType } from "./quarter-iso-id.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Quarter extends DateRange {
-    static fromTimestamp(timestamp: TimestampVO): Quarter;
+    static fromTimestamp(timestamp: Timestamp): Quarter;
     static fromTimestampValue(timestamp: TimestampValueType): Quarter;
-    static fromNow(now: TimestampVO): Quarter;
+    static fromNow(now: Timestamp): Quarter;
     static fromIsoId(isoId: QuarterIsoIdType): Quarter;
     toIsoId(): QuarterIsoIdType;
     toString(): string;

package/dist/quarter.vo.js

@@ -1,15 +1,15 @@
 import { endOfQuarter, getQuarter, getYear, setQuarter, startOfQuarter } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { QuarterIsoId } from "./quarter-iso-id.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export class Quarter extends DateRange {
     static fromTimestamp(timestamp) {
-        const start = TimestampVO.fromNumber(startOfQuarter(timestamp.ms).getTime());
-        const end = TimestampVO.fromNumber(endOfQuarter(timestamp.ms).getTime());
+        const start = Timestamp.fromNumber(startOfQuarter(timestamp.ms).getTime());
+        const end = Timestamp.fromNumber(endOfQuarter(timestamp.ms).getTime());
         return new Quarter(start, end);
     }
     static fromTimestampValue(timestamp) {
-        return Quarter.fromTimestamp(TimestampVO.fromValue(timestamp));
+        return Quarter.fromTimestamp(Timestamp.fromValue(timestamp));
     }
     static fromNow(now) {
         return Quarter.fromTimestamp(now);
@@ -17,7 +17,7 @@ export class Quarter extends DateRange {
     static fromIsoId(isoId) {
         const [year, quarter] = QuarterIsoId.parse(isoId).split("-Q").map(Number);
         const reference = setQuarter(Date.UTC(year), quarter).getTime();
-        return Quarter.fromTimestamp(TimestampVO.fromNumber(reference));
+        return Quarter.fromTimestamp(Timestamp.fromNumber(reference));
     }
     toIsoId() {
         const year = getYear(this.getStart().ms);

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

@@ -1,5 +1,5 @@
 import type { Duration } from "./duration.service";
-import type { TimestampVO } from "./timestamp.vo";
+import type { Timestamp } from "./timestamp.vo";
 type RateLimiterResultSuccessType = {
     allowed: true;
 };
@@ -12,6 +12,6 @@ export declare class RateLimiter {
     private readonly duration;
     private lastInvocation;
     constructor(duration: Duration);
-    verify(now: TimestampVO): RateLimiterResultType;
+    verify(now: Timestamp): RateLimiterResultType;
 }
 export {};

package/dist/relative-date.vo.d.ts

@@ -1,4 +1,4 @@
-import type { TimestampVO } from "./timestamp.vo";
+import type { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 import type { Falsy } from "./ts-utils";
 type RelativeDateType = {
@@ -6,8 +6,8 @@ type RelativeDateType = {
     relative: string;
 };
 export declare class RelativeDate {
-    static truthy(timestamp: TimestampVO): RelativeDateType;
-    static falsy(timestamp: Falsy<TimestampVO>): RelativeDateType | null;
+    static truthy(timestamp: Timestamp): RelativeDateType;
+    static falsy(timestamp: Falsy<Timestamp>): RelativeDateType | null;
     private static _format;
 }
 export {};

package/dist/stopwatch.service.d.ts

@@ -1,5 +1,5 @@
 import type { Duration } from "./duration.service";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export declare const StopwatchError: {
     readonly AlreadyStopped: "stopwatch.already.stopped";
 };
@@ -7,6 +7,6 @@ export type StopwatchResultType = Duration;
 export declare class Stopwatch {
     private readonly start;
     private state;
-    constructor(start: TimestampVO);
+    constructor(start: Timestamp);
     stop(): StopwatchResultType;
 }

package/dist/stopwatch.service.js

@@ -1,4 +1,4 @@
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export const StopwatchError = { AlreadyStopped: "stopwatch.already.stopped" };
 var StopwatchState;
 (function (StopwatchState) {
@@ -15,6 +15,6 @@ export class Stopwatch {
         if (this.state === StopwatchState.stopped)
             throw new Error(StopwatchError.AlreadyStopped);
         this.state = StopwatchState.stopped;
-        return TimestampVO.fromNumber(Date.now()).difference(this.start);
+        return Timestamp.fromNumber(Date.now()).difference(this.start);
     }
 }

package/dist/timestamp.vo.d.ts

@@ -1,18 +1,18 @@
 import { Duration } from "./duration.service";
 import { type TimestampValueType } from "./timestamp-value.vo";
-export declare class TimestampVO {
+export declare class Timestamp {
     private readonly value;
     constructor(value: TimestampValueType);
-    static fromValue(value: TimestampValueType): TimestampVO;
-    static fromNumber(value: number): TimestampVO;
-    add(duration: Duration): TimestampVO;
-    subtract(duration: Duration): TimestampVO;
-    difference(another: TimestampVO): Duration;
-    isBefore(another: TimestampVO): boolean;
-    isBeforeOrEqual(another: TimestampVO): boolean;
-    isAfter(another: TimestampVO): boolean;
-    isAfterOrEqual(another: TimestampVO): boolean;
-    equals(another: TimestampVO): boolean;
+    static fromValue(value: TimestampValueType): Timestamp;
+    static fromNumber(value: number): Timestamp;
+    add(duration: Duration): Timestamp;
+    subtract(duration: Duration): Timestamp;
+    difference(another: Timestamp): Duration;
+    isBefore(another: Timestamp): boolean;
+    isBeforeOrEqual(another: Timestamp): boolean;
+    isAfter(another: Timestamp): boolean;
+    isAfterOrEqual(another: Timestamp): boolean;
+    equals(another: Timestamp): boolean;
     get ms(): TimestampValueType;
     toJSON(): TimestampValueType;
     toString(): string;

package/dist/timestamp.vo.js

@@ -1,21 +1,21 @@
 import { Duration } from "./duration.service";
 import { TimestampValue } from "./timestamp-value.vo";
-export class TimestampVO {
+export class Timestamp {
     value;
     constructor(value) {
         this.value = value;
     }
     static fromValue(value) {
-        return new TimestampVO(value);
+        return new Timestamp(value);
     }
     static fromNumber(value) {
-        return new TimestampVO(TimestampValue.parse(value));
+        return new Timestamp(TimestampValue.parse(value));
     }
     add(duration) {
-        return TimestampVO.fromNumber(this.value + duration.ms);
+        return Timestamp.fromNumber(this.value + duration.ms);
     }
     subtract(duration) {
-        return TimestampVO.fromNumber(this.value - duration.ms);
+        return Timestamp.fromNumber(this.value - duration.ms);
     }
     difference(another) {
         return Duration.Ms(this.value - another.value);

package/dist/week.vo.d.ts

@@ -1,11 +1,11 @@
 import { DateRange } from "./date-range.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 import { type WeekIsoIdType } from "./week-iso-id.vo";
 export declare class Week extends DateRange {
-    static fromTimestamp(timestamp: TimestampVO): Week;
+    static fromTimestamp(timestamp: Timestamp): Week;
     static fromTimestampValue(timestamp: TimestampValueType): Week;
-    static fromNow(now: TimestampVO): Week;
+    static fromNow(now: Timestamp): Week;
     static fromIsoId(isoId: WeekIsoIdType): Week;
     toIsoId(): WeekIsoIdType;
     previous(): Week;

package/dist/week.vo.js

@@ -1,15 +1,15 @@
 import { addWeeks, endOfISOWeek, getISOWeek, getISOWeekYear, setISOWeek, startOfISOWeek } from "date-fns";
 import { DateRange } from "./date-range.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import { WeekIsoId } from "./week-iso-id.vo";
 export class Week extends DateRange {
     static fromTimestamp(timestamp) {
-        const start = TimestampVO.fromNumber(startOfISOWeek(timestamp.ms).getTime());
-        const end = TimestampVO.fromNumber(endOfISOWeek(timestamp.ms).getTime());
+        const start = Timestamp.fromNumber(startOfISOWeek(timestamp.ms).getTime());
+        const end = Timestamp.fromNumber(endOfISOWeek(timestamp.ms).getTime());
         return new Week(start, end);
     }
     static fromTimestampValue(timestamp) {
-        return Week.fromTimestamp(TimestampVO.fromValue(timestamp));
+        return Week.fromTimestamp(Timestamp.fromValue(timestamp));
     }
     static fromNow(now) {
         return Week.fromTimestamp(now);
@@ -18,7 +18,7 @@ export class Week extends DateRange {
         const [year, week] = WeekIsoId.parse(isoId).split("-W").map(Number);
         // ISO-8601 rule: Jan 4 is always in week 01 of the ISO week-year.
         const reference = setISOWeek(Date.UTC(year, 0, 4), week).getTime();
-        return Week.fromTimestamp(TimestampVO.fromNumber(reference));
+        return Week.fromTimestamp(Timestamp.fromNumber(reference));
     }
     toIsoId() {
         const year = getISOWeekYear(this.getStart().ms);
@@ -33,7 +33,7 @@ export class Week extends DateRange {
     }
     shift(count) {
         const shifted = addWeeks(this.getStart().ms, count).getTime();
-        return Week.fromTimestamp(TimestampVO.fromNumber(shifted));
+        return Week.fromTimestamp(Timestamp.fromNumber(shifted));
     }
     toString() {
         return this.toIsoId();

package/dist/weekday.vo.d.ts

@@ -1,4 +1,4 @@
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 export type WeekdayFormatter = (value: Weekday["value"]) => string;
 export declare enum WeekdayFormatterEnum {
@@ -20,7 +20,7 @@ export declare class Weekday {
     static readonly FRIDAY: Weekday;
     static readonly SATURDAY: Weekday;
     constructor(candidate: number, formatter?: WeekdayFormatter);
-    static fromTimestamp(timestamp: TimestampVO, formatter?: WeekdayFormatter): Weekday;
+    static fromTimestamp(timestamp: Timestamp, formatter?: WeekdayFormatter): Weekday;
     static fromTimestampValue(timestamp: TimestampValueType): Weekday;
     get(): number;
     format(): string;

package/dist/weekday.vo.js

@@ -1,4 +1,4 @@
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 export var WeekdayFormatterEnum;
 (function (WeekdayFormatterEnum) {
     WeekdayFormatterEnum["FULL"] = "FULL";
@@ -46,7 +46,7 @@ export class Weekday {
         return new Weekday(dayZeroBased, formatter);
     }
     static fromTimestampValue(timestamp) {
-        return Weekday.fromTimestamp(TimestampVO.fromValue(timestamp));
+        return Weekday.fromTimestamp(Timestamp.fromValue(timestamp));
     }
     get() {
         return this.value;

package/dist/year.vo.d.ts

@@ -1,11 +1,11 @@
 import { DateRange } from "./date-range.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 import { type YearIsoIdType } from "./year-iso-id.vo";
 export declare class Year extends DateRange {
-    static fromTimestamp(timestamp: TimestampVO): Year;
+    static fromTimestamp(timestamp: Timestamp): Year;
     static fromTimestampValue(timestamp: TimestampValueType): Year;
-    static fromNow(now: TimestampVO): Year;
+    static fromNow(now: Timestamp): Year;
     static fromNumber(candidate: number): Year;
     static fromIsoId(isoId: YearIsoIdType): Year;
     toIsoId(): YearIsoIdType;

package/dist/year.vo.js

@@ -1,15 +1,15 @@
 import { addYears, endOfYear, getYear, startOfYear } from "date-fns";
 import { DateRange } from "./date-range.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import { YearIsoId } from "./year-iso-id.vo";
 export class Year extends DateRange {
     static fromTimestamp(timestamp) {
-        const start = TimestampVO.fromNumber(startOfYear(timestamp.ms).getTime());
-        const end = TimestampVO.fromNumber(endOfYear(timestamp.ms).getTime());
+        const start = Timestamp.fromNumber(startOfYear(timestamp.ms).getTime());
+        const end = Timestamp.fromNumber(endOfYear(timestamp.ms).getTime());
         return new Year(start, end);
     }
     static fromTimestampValue(timestamp) {
-        return Year.fromTimestamp(TimestampVO.fromValue(timestamp));
+        return Year.fromTimestamp(Timestamp.fromValue(timestamp));
     }
     static fromNow(now) {
         return Year.fromTimestamp(now);
@@ -19,7 +19,7 @@ export class Year extends DateRange {
     }
     static fromIsoId(isoId) {
         const reference = Date.UTC(Number(isoId));
-        return Year.fromTimestamp(TimestampVO.fromNumber(reference));
+        return Year.fromTimestamp(Timestamp.fromNumber(reference));
     }
     toIsoId() {
         return YearIsoId.parse(String(getYear(this.getStart().ms)));
@@ -36,7 +36,7 @@ export class Year extends DateRange {
     }
     shift(count) {
         const shifted = addYears(this.getStart().ms, count).getTime();
-        return Year.fromTimestamp(TimestampVO.fromNumber(shifted));
+        return Year.fromTimestamp(Timestamp.fromNumber(shifted));
     }
     toString() {
         return this.toIsoId();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/tools",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "type": "module",
   "license": "MIT",
   "author": "Bartosz Gordon",
@@ -21,13 +21,13 @@
     "preinstall": "bunx only-allow bun"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.2",
+    "@biomejs/biome": "2.3.3",
     "@commitlint/cli": "20.1.0",
     "@commitlint/config-conventional": "20.0.0",
     "@types/bun": "1.3.1",
     "@types/mime-types": "3.0.1",
     "cspell": "9.2.2",
-    "knip": "5.67.0",
+    "knip": "5.67.1",
     "lefthook": "2.0.2",
     "only-allow": "1.2.1",
     "shellcheck": "4.1.0",

package/src/age.vo.ts

@@ -1,6 +1,6 @@
 import { differenceInYears } from "date-fns";
 import { AgeYears, AgeYearsConstraints, type AgeYearsType } from "./age-years.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 
 export const AgeError = { FutureBirthdate: "age.future.birthdate" } as const;
 
@@ -14,13 +14,13 @@ export class Age {
     return new Age(AgeYears.parse(candidate));
   }
 
-  static fromBirthdateTimestamp(params: { birthdate: TimestampVO; now: TimestampVO }): Age {
+  static fromBirthdateTimestamp(params: { birthdate: Timestamp; now: Timestamp }): Age {
     if (params.birthdate.isAfter(params.now)) throw new Error(AgeError.FutureBirthdate);
     return Age.fromValue(differenceInYears(params.now.ms, params.birthdate.ms));
   }
 
-  static fromBirthdate(candidate: { birthdate: string; now: TimestampVO }): Age {
-    const birthdate = TimestampVO.fromNumber(new Date(candidate.birthdate).getTime());
+  static fromBirthdate(candidate: { birthdate: string; now: Timestamp }): Age {
+    const birthdate = Timestamp.fromNumber(new Date(candidate.birthdate).getTime());
 
     if (birthdate.isAfter(candidate.now)) throw new Error(AgeError.FutureBirthdate);
     return Age.fromValue(differenceInYears(candidate.now.ms, birthdate.ms));

package/src/clock.vo.ts

@@ -3,7 +3,7 @@ import { Hour } from "./hour.vo";
 import type { HourSchemaType } from "./hour-schema.vo";
 import { Minute } from "./minute.vo";
 import type { MinuteSchemaType } from "./minute-schema.vo";
-import type { TimestampVO } from "./timestamp.vo";
+import type { Timestamp } from "./timestamp.vo";
 
 export class Clock {
   private readonly formatter: ClockFormatter;
@@ -16,7 +16,7 @@ export class Clock {
     this.formatter = formatter ?? ClockFormatters.TWENTY_FOUR_HOURS;
   }
 
-  static fromTimestamp(timestamp: TimestampVO, formatter?: ClockFormatter): Clock {
+  static fromTimestamp(timestamp: Timestamp, formatter?: ClockFormatter): Clock {
     const hour = Hour.fromTimestamp(timestamp);
     const minute = Minute.fromTimestamp(timestamp);
 

package/src/date-calculator.service.ts

@@ -1,13 +1,13 @@
 import { Duration } from "./duration.service";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 
-type GetStartOfDayTsInTzConfigType = { now: TimestampVO; timeZoneOffset: Duration };
+type GetStartOfDayTsInTzConfigType = { now: Timestamp; timeZoneOffset: Duration };
 
 export class DateCalculator {
-  static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType): TimestampVO {
+  static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType): Timestamp {
     const dayMs = Duration.Days(1).ms;
 
-    const utcMidnightOfNow = TimestampVO.fromNumber(Math.floor(config.now.ms / dayMs) * dayMs);
+    const utcMidnightOfNow = Timestamp.fromNumber(Math.floor(config.now.ms / dayMs) * dayMs);
 
     let startOfDayInTz = utcMidnightOfNow.add(config.timeZoneOffset);
 

package/src/date-range.vo.ts

@@ -1,28 +1,28 @@
-import type { TimestampVO } from "./timestamp.vo";
+import type { Timestamp } from "./timestamp.vo";
 
 export const DateRangeError = { Invalid: "date.range.invalid" } as const;
 
 export class DateRange {
   constructor(
-    private readonly start: TimestampVO,
-    private readonly end: TimestampVO,
+    private readonly start: Timestamp,
+    private readonly end: Timestamp,
   ) {
     if (start.isAfter(end)) throw new Error(DateRangeError.Invalid);
   }
 
-  getStart(): TimestampVO {
+  getStart(): Timestamp {
     return this.start;
   }
 
-  getEnd(): TimestampVO {
+  getEnd(): Timestamp {
     return this.end;
   }
 
-  toRange(): [TimestampVO, TimestampVO] {
+  toRange(): [Timestamp, Timestamp] {
     return [this.start, this.end];
   }
 
-  contains(timestamp: TimestampVO): boolean {
+  contains(timestamp: Timestamp): boolean {
     return timestamp.isAfterOrEqual(this.start) && timestamp.isBeforeOrEqual(this.end);
   }
 

package/src/day.vo.ts

@@ -2,14 +2,14 @@ import { formatISO } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { DayIsoId, type DayIsoIdType } from "./day-iso-id.vo";
 import { Duration } from "./duration.service";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Day extends DateRange {
-  static fromTimestamp(timestamp: TimestampVO): Day {
+  static fromTimestamp(timestamp: Timestamp): Day {
     const date = new Date(timestamp.ms);
 
-    const startUtc = TimestampVO.fromNumber(
+    const startUtc = Timestamp.fromNumber(
       Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
     );
     const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
@@ -18,17 +18,17 @@ export class Day extends DateRange {
   }
 
   static fromTimestampValue(timestamp: TimestampValueType): Day {
-    return Day.fromTimestamp(TimestampVO.fromValue(timestamp));
+    return Day.fromTimestamp(Timestamp.fromValue(timestamp));
   }
 
-  static fromNow(now: TimestampVO): Day {
+  static fromNow(now: Timestamp): Day {
     return Day.fromTimestamp(now);
   }
 
   static fromIsoId(isoId: DayIsoIdType): Day {
     const [year, month, day] = DayIsoId.parse(isoId).split("-").map(Number);
 
-    const startUtc = TimestampVO.fromNumber(Date.UTC(year, month - 1, day));
+    const startUtc = Timestamp.fromNumber(Date.UTC(year, month - 1, day));
     const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
 
     return new Day(startUtc, endUtc);

package/src/duration.service.ts

@@ -72,4 +72,8 @@ export class Duration {
   subtract(another: Duration): Duration {
     return Duration.Ms(this.internal - another.internal);
   }
+
+  toAbolute(): Duration {
+    return Duration.Ms(Math.abs(this.internal));
+  }
 }

package/src/hour.vo.ts

@@ -1,6 +1,6 @@
 import { type HourFormatter, HourFormatters } from "./hour-format.service";
 import { HourSchema, type HourSchemaType } from "./hour-schema.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Hour {
@@ -13,12 +13,12 @@ export class Hour {
     this.value = HourSchema.parse(candidate);
   }
 
-  static fromTimestamp(timestamp: TimestampVO): Hour {
+  static fromTimestamp(timestamp: Timestamp): Hour {
     return new Hour(new Date(timestamp.ms).getUTCHours());
   }
 
   static fromTimestampValue(timestamp: TimestampValueType): Hour {
-    return Hour.fromTimestamp(TimestampVO.fromValue(timestamp));
+    return Hour.fromTimestamp(Timestamp.fromValue(timestamp));
   }
 
   get(): HourSchemaType {

package/src/minute.vo.ts

@@ -1,5 +1,5 @@
 import { MinuteSchema, type MinuteSchemaType } from "./minute-schema.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Minute {
@@ -12,12 +12,12 @@ export class Minute {
     this.value = MinuteSchema.parse(candidate);
   }
 
-  static fromTimestamp(timestamp: TimestampVO): Minute {
+  static fromTimestamp(timestamp: Timestamp): Minute {
     return new Minute(new Date(timestamp.ms).getUTCMinutes());
   }
 
   static fromTimestampValue(timestamp: TimestampValueType): Minute {
-    return Minute.fromTimestamp(TimestampVO.fromValue(timestamp));
+    return Minute.fromTimestamp(Timestamp.fromValue(timestamp));
   }
 
   get(): MinuteSchemaType {

package/src/month.vo.ts

@@ -1,22 +1,22 @@
 import { endOfMonth, format, getMonth, setMonth, startOfMonth } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { MonthIsoId, type MonthIsoIdType } from "./month-iso-id.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Month extends DateRange {
-  static fromTimestamp(timestamp: TimestampVO): Month {
-    const start = TimestampVO.fromNumber(startOfMonth(timestamp.ms).getTime());
-    const end = TimestampVO.fromNumber(endOfMonth(timestamp.ms).getTime());
+  static fromTimestamp(timestamp: Timestamp): Month {
+    const start = Timestamp.fromNumber(startOfMonth(timestamp.ms).getTime());
+    const end = Timestamp.fromNumber(endOfMonth(timestamp.ms).getTime());
 
     return new Month(start, end);
   }
 
   static fromTimestampValue(timestamp: TimestampValueType): Month {
-    return Month.fromTimestamp(TimestampVO.fromValue(timestamp));
+    return Month.fromTimestamp(Timestamp.fromValue(timestamp));
   }
 
-  static fromNow(now: TimestampVO): Month {
+  static fromNow(now: Timestamp): Month {
     return Month.fromTimestamp(now);
   }
 
@@ -25,7 +25,7 @@ export class Month extends DateRange {
 
     const reference = setMonth(Date.UTC(year), month - 1).getTime();
 
-    return Month.fromTimestamp(TimestampVO.fromNumber(reference));
+    return Month.fromTimestamp(Timestamp.fromNumber(reference));
   }
 
   toIsoId(): MonthIsoIdType {
@@ -43,7 +43,7 @@ export class Month extends DateRange {
   shift(count: number): Month {
     const shifted = setMonth(this.getStart().ms, getMonth(this.getStart().ms) + count).getTime();
 
-    return Month.fromTimestamp(TimestampVO.fromNumber(shifted));
+    return Month.fromTimestamp(Timestamp.fromNumber(shifted));
   }
 
   toString(): string {

package/src/quarter.vo.ts

@@ -1,22 +1,22 @@
 import { endOfQuarter, getQuarter, getYear, setQuarter, startOfQuarter } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { QuarterIsoId, type QuarterIsoIdType } from "./quarter-iso-id.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Quarter extends DateRange {
-  static fromTimestamp(timestamp: TimestampVO): Quarter {
-    const start = TimestampVO.fromNumber(startOfQuarter(timestamp.ms).getTime());
-    const end = TimestampVO.fromNumber(endOfQuarter(timestamp.ms).getTime());
+  static fromTimestamp(timestamp: Timestamp): Quarter {
+    const start = Timestamp.fromNumber(startOfQuarter(timestamp.ms).getTime());
+    const end = Timestamp.fromNumber(endOfQuarter(timestamp.ms).getTime());
 
     return new Quarter(start, end);
   }
 
   static fromTimestampValue(timestamp: TimestampValueType): Quarter {
-    return Quarter.fromTimestamp(TimestampVO.fromValue(timestamp));
+    return Quarter.fromTimestamp(Timestamp.fromValue(timestamp));
   }
 
-  static fromNow(now: TimestampVO): Quarter {
+  static fromNow(now: Timestamp): Quarter {
     return Quarter.fromTimestamp(now);
   }
 
@@ -25,7 +25,7 @@ export class Quarter extends DateRange {
 
     const reference = setQuarter(Date.UTC(year), quarter).getTime();
 
-    return Quarter.fromTimestamp(TimestampVO.fromNumber(reference));
+    return Quarter.fromTimestamp(Timestamp.fromNumber(reference));
   }
 
   toIsoId(): QuarterIsoIdType {

package/src/rate-limiter.service.ts

@@ -1,16 +1,16 @@
 import type { Duration } from "./duration.service";
-import type { TimestampVO } from "./timestamp.vo";
+import type { Timestamp } from "./timestamp.vo";
 
 type RateLimiterResultSuccessType = { allowed: true };
 type RateLimiterResultErrorType = { allowed: false; remaining: Duration };
 type RateLimiterResultType = RateLimiterResultSuccessType | RateLimiterResultErrorType;
 
 export class RateLimiter {
-  private lastInvocation: TimestampVO | null = null;
+  private lastInvocation: Timestamp | null = null;
 
   constructor(private readonly duration: Duration) {}
 
-  verify(now: TimestampVO): RateLimiterResultType {
+  verify(now: Timestamp): RateLimiterResultType {
     if (this.lastInvocation == null) {
       this.lastInvocation = now;
 

package/src/relative-date.vo.ts

@@ -1,21 +1,21 @@
 import { DateFormatters } from "./date-formatter.service";
-import type { TimestampVO } from "./timestamp.vo";
+import type { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 import type { Falsy } from "./ts-utils";
 
 type RelativeDateType = { raw: TimestampValueType; relative: string };
 
 export class RelativeDate {
-  static truthy(timestamp: TimestampVO): RelativeDateType {
+  static truthy(timestamp: Timestamp): RelativeDateType {
     return RelativeDate._format(timestamp);
   }
 
-  static falsy(timestamp: Falsy<TimestampVO>): RelativeDateType | null {
+  static falsy(timestamp: Falsy<Timestamp>): RelativeDateType | null {
     if (!timestamp) return null;
     return RelativeDate._format(timestamp);
   }
 
-  private static _format(timestamp: TimestampVO): RelativeDateType {
+  private static _format(timestamp: Timestamp): RelativeDateType {
     return { raw: timestamp.ms, relative: DateFormatters.relative(timestamp.ms) };
   }
 }

package/src/stopwatch.service.ts

@@ -1,5 +1,5 @@
 import type { Duration } from "./duration.service";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 
 export const StopwatchError = { AlreadyStopped: "stopwatch.already.stopped" } as const;
 
@@ -13,13 +13,13 @@ export type StopwatchResultType = Duration;
 export class Stopwatch {
   private state: StopwatchState = StopwatchState.started;
 
-  constructor(private readonly start: TimestampVO) {}
+  constructor(private readonly start: Timestamp) {}
 
   stop(): StopwatchResultType {
     if (this.state === StopwatchState.stopped) throw new Error(StopwatchError.AlreadyStopped);
 
     this.state = StopwatchState.stopped;
 
-    return TimestampVO.fromNumber(Date.now()).difference(this.start);
+    return Timestamp.fromNumber(Date.now()).difference(this.start);
   }
 }

package/src/timestamp.vo.ts

@@ -1,46 +1,46 @@
 import { Duration } from "./duration.service";
 import { TimestampValue, type TimestampValueType } from "./timestamp-value.vo";
 
-export class TimestampVO {
+export class Timestamp {
   constructor(private readonly value: TimestampValueType) {}
 
-  static fromValue(value: TimestampValueType): TimestampVO {
-    return new TimestampVO(value);
+  static fromValue(value: TimestampValueType): Timestamp {
+    return new Timestamp(value);
   }
 
-  static fromNumber(value: number): TimestampVO {
-    return new TimestampVO(TimestampValue.parse(value));
+  static fromNumber(value: number): Timestamp {
+    return new Timestamp(TimestampValue.parse(value));
   }
 
-  add(duration: Duration): TimestampVO {
-    return TimestampVO.fromNumber(this.value + duration.ms);
+  add(duration: Duration): Timestamp {
+    return Timestamp.fromNumber(this.value + duration.ms);
   }
 
-  subtract(duration: Duration): TimestampVO {
-    return TimestampVO.fromNumber(this.value - duration.ms);
+  subtract(duration: Duration): Timestamp {
+    return Timestamp.fromNumber(this.value - duration.ms);
   }
 
-  difference(another: TimestampVO): Duration {
+  difference(another: Timestamp): Duration {
     return Duration.Ms(this.value - another.value);
   }
 
-  isBefore(another: TimestampVO): boolean {
+  isBefore(another: Timestamp): boolean {
     return this.value < another.value;
   }
 
-  isBeforeOrEqual(another: TimestampVO): boolean {
+  isBeforeOrEqual(another: Timestamp): boolean {
     return this.value <= another.value;
   }
 
-  isAfter(another: TimestampVO): boolean {
+  isAfter(another: Timestamp): boolean {
     return this.value > another.value;
   }
 
-  isAfterOrEqual(another: TimestampVO): boolean {
+  isAfterOrEqual(another: Timestamp): boolean {
     return this.value >= another.value;
   }
 
-  equals(another: TimestampVO): boolean {
+  equals(another: Timestamp): boolean {
     return this.value === another.value;
   }
 

package/src/week.vo.ts

@@ -1,22 +1,22 @@
 import { addWeeks, endOfISOWeek, getISOWeek, getISOWeekYear, setISOWeek, startOfISOWeek } from "date-fns";
 import { DateRange } from "./date-range.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 import { WeekIsoId, type WeekIsoIdType } from "./week-iso-id.vo";
 
 export class Week extends DateRange {
-  static fromTimestamp(timestamp: TimestampVO): Week {
-    const start = TimestampVO.fromNumber(startOfISOWeek(timestamp.ms).getTime());
-    const end = TimestampVO.fromNumber(endOfISOWeek(timestamp.ms).getTime());
+  static fromTimestamp(timestamp: Timestamp): Week {
+    const start = Timestamp.fromNumber(startOfISOWeek(timestamp.ms).getTime());
+    const end = Timestamp.fromNumber(endOfISOWeek(timestamp.ms).getTime());
 
     return new Week(start, end);
   }
 
   static fromTimestampValue(timestamp: TimestampValueType): Week {
-    return Week.fromTimestamp(TimestampVO.fromValue(timestamp));
+    return Week.fromTimestamp(Timestamp.fromValue(timestamp));
   }
 
-  static fromNow(now: TimestampVO): Week {
+  static fromNow(now: Timestamp): Week {
     return Week.fromTimestamp(now);
   }
 
@@ -26,7 +26,7 @@ export class Week extends DateRange {
     // ISO-8601 rule: Jan 4 is always in week 01 of the ISO week-year.
     const reference = setISOWeek(Date.UTC(year, 0, 4), week).getTime();
 
-    return Week.fromTimestamp(TimestampVO.fromNumber(reference));
+    return Week.fromTimestamp(Timestamp.fromNumber(reference));
   }
 
   toIsoId(): WeekIsoIdType {
@@ -47,7 +47,7 @@ export class Week extends DateRange {
   shift(count: number): Week {
     const shifted = addWeeks(this.getStart().ms, count).getTime();
 
-    return Week.fromTimestamp(TimestampVO.fromNumber(shifted));
+    return Week.fromTimestamp(Timestamp.fromNumber(shifted));
   }
 
   toString(): string {

package/src/weekday.vo.ts

@@ -1,4 +1,4 @@
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 
 export type WeekdayFormatter = (value: Weekday["value"]) => string;
@@ -53,13 +53,13 @@ export class Weekday {
     this.formatter = formatter ?? WeekdayFormatters.FULL;
   }
 
-  static fromTimestamp(timestamp: TimestampVO, formatter?: WeekdayFormatter): Weekday {
+  static fromTimestamp(timestamp: Timestamp, formatter?: WeekdayFormatter): Weekday {
     const dayZeroBased = new Date(timestamp.ms).getUTCDay(); // 0..6
     return new Weekday(dayZeroBased, formatter);
   }
 
   static fromTimestampValue(timestamp: TimestampValueType): Weekday {
-    return Weekday.fromTimestamp(TimestampVO.fromValue(timestamp));
+    return Weekday.fromTimestamp(Timestamp.fromValue(timestamp));
   }
 
   get(): number {

package/src/year.vo.ts

@@ -1,22 +1,22 @@
 import { addYears, endOfYear, getYear, startOfYear } from "date-fns";
 import { DateRange } from "./date-range.vo";
-import { TimestampVO } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import type { TimestampValueType } from "./timestamp-value.vo";
 import { YearIsoId, type YearIsoIdType } from "./year-iso-id.vo";
 
 export class Year extends DateRange {
-  static fromTimestamp(timestamp: TimestampVO): Year {
-    const start = TimestampVO.fromNumber(startOfYear(timestamp.ms).getTime());
-    const end = TimestampVO.fromNumber(endOfYear(timestamp.ms).getTime());
+  static fromTimestamp(timestamp: Timestamp): Year {
+    const start = Timestamp.fromNumber(startOfYear(timestamp.ms).getTime());
+    const end = Timestamp.fromNumber(endOfYear(timestamp.ms).getTime());
 
     return new Year(start, end);
   }
 
   static fromTimestampValue(timestamp: TimestampValueType): Year {
-    return Year.fromTimestamp(TimestampVO.fromValue(timestamp));
+    return Year.fromTimestamp(Timestamp.fromValue(timestamp));
   }
 
-  static fromNow(now: TimestampVO): Year {
+  static fromNow(now: Timestamp): Year {
     return Year.fromTimestamp(now);
   }
 
@@ -27,7 +27,7 @@ export class Year extends DateRange {
   static fromIsoId(isoId: YearIsoIdType): Year {
     const reference = Date.UTC(Number(isoId));
 
-    return Year.fromTimestamp(TimestampVO.fromNumber(reference));
+    return Year.fromTimestamp(Timestamp.fromNumber(reference));
   }
 
   toIsoId(): YearIsoIdType {
@@ -51,7 +51,7 @@ export class Year extends DateRange {
   shift(count: number): Year {
     const shifted = addYears(this.getStart().ms, count).getTime();
 
-    return Year.fromTimestamp(TimestampVO.fromNumber(shifted));
+    return Year.fromTimestamp(Timestamp.fromNumber(shifted));
   }
 
   toString(): string {