import { Buffer } from "buffer";
//#region src/errors/BaseError.d.ts
export declare class BaseError extends Error {
  private readonly isBaseError;
  static isBaseError(error: unknown): boolean;
  constructor(message: string, prototype?: object);
  toString(): string;
  getStack(): string;
}
//#endregion
//#region src/errors/DomainError.d.ts
export declare class DomainError extends BaseError {
  protected readonly isDomainError = true;
  static isDomainError(error: unknown): boolean;
  constructor(message: string);
}
//#endregion
//#region src/errors/InvalidColorError.d.ts
export declare class InvalidColorError extends DomainError {
  constructor(value: string);
}
//#endregion
//#region src/errors/InvalidDayError.d.ts
export declare class InvalidDayError extends DomainError {
  constructor(invalidDay: unknown);
}
//#endregion
//#region src/errors/InvalidDayFormatError.d.ts
export declare class InvalidDayFormatError extends DomainError {
  constructor(invalidDate: string);
}
//#endregion
//#region src/errors/InvalidHourError.d.ts
export declare class InvalidHourError extends DomainError {
  constructor();
}
//#endregion
//#region src/errors/InvalidEmailError.d.ts
export declare class InvalidEmailError extends DomainError {
  constructor(value: string);
}
//#endregion
//#region src/errors/InvalidFormatError.d.ts
export declare class InvalidFormatError extends DomainError {
  constructor(value?: string);
}
//#endregion
//#region src/errors/InvalidHashError.d.ts
export declare class InvalidHashError extends DomainError {
  constructor(type: string, value: string);
}
//#endregion
//#region src/errors/InvalidIntegerError.d.ts
export declare class InvalidIntegerError extends DomainError {
  constructor(value: number);
}
//#endregion
//#region src/errors/InvalidLatitudeError.d.ts
export declare class InvalidLatitudeError extends DomainError {
  constructor(value: number);
}
//#endregion
//#region src/errors/InvalidLongitudeError.d.ts
export declare class InvalidLongitudeError extends DomainError {
  constructor(value: number);
}
//#endregion
//#region src/errors/InvalidMinutesError.d.ts
export declare class InvalidMinutesError extends DomainError {
  constructor();
}
//#endregion
//#region src/errors/InvalidNumberError.d.ts
export declare class InvalidNumberError extends DomainError {
  constructor(invalidNumber: unknown);
}
//#endregion
//#region src/errors/InvalidPasswordError.d.ts
export declare class InvalidPasswordError extends DomainError {
  constructor(minLength: number, maxLength: number);
}
//#endregion
//#region src/errors/InvalidPositiveNumberError.d.ts
export declare class InvalidPositiveNumberError extends DomainError {
  constructor();
}
//#endregion
//#region src/errors/InvalidStringLengthError.d.ts
export declare class InvalidStringLengthError extends DomainError {
  constructor(value: string, length: number);
}
//#endregion
//#region src/types/Primitive.d.ts
export type Primitive = string | number | boolean | bigint | symbol | null | undefined;
//#endregion
//#region src/types/Nullish.d.ts
export type Nullish = null | undefined;
//#endregion
//#region src/value-objects/ValueObject.d.ts
export declare abstract class ValueObject<T extends Primitive = Primitive> {
  private static nullObjectCreationEnabled;
  protected readonly value: T;
  static disableNullObjectCreation(): void;
  static enableNullObjectCreation(): void;
  constructor(value: T | Nullish);
  private isNullish;
  protected clone(value: T): this;
  hasValue(other: unknown): boolean;
  isEqual(other: unknown): boolean;
  isNotEqual(other: unknown): boolean;
  valueOf(): T;
  toString(): string;
}
//#endregion
//#region src/value-objects/NumberValueObject.d.ts
export declare class NumberValueObject extends ValueObject<number> {
  constructor(value: number | NumberValueObject);
  private isValidNumber;
  isZero(): boolean;
  isGreaterThan(other: number | NumberValueObject): boolean;
  isGreaterOrEqualThan(other: number | NumberValueObject): boolean;
  isLessThan(other: number | NumberValueObject): boolean;
  isLessOrEqualThan(other: number | NumberValueObject): boolean;
  add(other: number | NumberValueObject): NumberValueObject;
  subtract(other: number | NumberValueObject): NumberValueObject;
  multiply(other: number | NumberValueObject): NumberValueObject;
  divide(other: number | NumberValueObject): NumberValueObject;
}
//#endregion
//#region src/value-objects/Integer.d.ts
export declare class Integer extends NumberValueObject {
  constructor(value: number | NumberValueObject);
  private ensureIsInteger;
}
//#endregion
//#region src/value-objects/time/Day.d.ts
export declare class Day extends Integer {
  constructor(value: number | NumberValueObject);
  private ensureIsValidDay;
}
//#endregion
//#region src/value-objects/Enum.d.ts
export declare abstract class Enum<T extends Primitive = Primitive> extends ValueObject<T> {
  constructor(value: T);
  abstract getValues(): T[];
  private ensureIsValidValue;
}
//#endregion
//#region src/value-objects/time/DayOfWeek.d.ts
export declare enum EDaysOfWeek {
  MONDAY = "monday",
  TUESDAY = "tuesday",
  WEDNESDAY = "wednesday",
  THURSDAY = "thursday",
  FRIDAY = "friday",
  SATURDAY = "saturday",
  SUNDAY = "sunday"
}
export declare const timeStampDayToDaysMap: {
  friday: number;
  monday: number;
  saturday: number;
  sunday: number;
  thursday: number;
  tuesday: number;
  wednesday: number;
};
export declare class DayOfWeek extends Enum {
  static MONDAY: DayOfWeek;
  static TUESDAY: DayOfWeek;
  static WEDNESDAY: DayOfWeek;
  static THURSDAY: DayOfWeek;
  static FRIDAY: DayOfWeek;
  static SATURDAY: DayOfWeek;
  static SUNDAY: DayOfWeek;
  static fromNumber(day: number): DayOfWeek;
  static fromTimestamp(timestamp: Timestamp): DayOfWeek;
  getValues(): string[];
  toNumber(): number;
}
//#endregion
//#region src/value-objects/time/Month.d.ts
export declare class Month extends Enum<number> {
  static readonly JANUARY: Month;
  static readonly FEBRUARY: Month;
  static readonly MARCH: Month;
  static readonly APRIL: Month;
  static readonly MAY: Month;
  static readonly JUNE: Month;
  static readonly JULY: Month;
  static readonly AUGUST: Month;
  static readonly SEPTEMBER: Month;
  static readonly OCTOBER: Month;
  static readonly NOVEMBER: Month;
  static readonly DECEMBER: Month;
  getValues(): number[];
  getIndex(): number;
}
//#endregion
//#region src/interfaces/PrimitiveOf.d.ts
type SerializedValue = Primitive | SerializedValue[] | {
  [key: string]: SerializedValue;
};
export type PrimitiveOf<T extends {
  toPrimitives(): SerializedValue;
}> = ReturnType<T['toPrimitives']>;
//#endregion
//#region src/value-objects/time/Duration.d.ts
export declare class Duration extends NumberValueObject {
  private static readonly MILLISECOND_FACTOR;
  private static readonly SECOND_UNITS;
  private static readonly millisecondFactors;
  static fromDays(days: number | NumberValueObject): Duration;
  static fromHours(hours: number | NumberValueObject): Duration;
  static fromMinutes(minutes: number | NumberValueObject): Duration;
  static fromSeconds(seconds: number | NumberValueObject): Duration;
  static fromMilliseconds(milliseconds: number | NumberValueObject): Duration;
  constructor(milliseconds: NumberValueObject | Duration);
  getTotalDays(): NumberValueObject;
  getTotalHours(): NumberValueObject;
  getTotalMinutes(): NumberValueObject;
  getTotalSeconds(): NumberValueObject;
  getTotalMilliseconds(): NumberValueObject;
  getDays(): NumberValueObject;
  getHours(): NumberValueObject;
  getMinutes(): NumberValueObject;
  getSeconds(): NumberValueObject;
  getMilliseconds(): NumberValueObject;
}
//#endregion
//#region src/value-objects/time/TimestampInterval.d.ts
export declare class TimestampInterval extends ValueObject<string> {
  private readonly start;
  private readonly end;
  static fromPrimitives(primitives: PrimitiveOf<TimestampInterval>): TimestampInterval;
  constructor(start: Timestamp, end: Timestamp);
  toPrimitives(): {
    end: number;
    start: number;
  };
  getStart(): Timestamp;
  getEnd(): Timestamp;
  getDuration(): Duration;
  getTotalDaysOfWeek(dayOfWeek: DayOfWeek): number;
  getDaysBetweenInterval(): CalendarDay[];
  getOverlappingInterval(searchInterval: TimestampInterval): TimestampInterval | null;
  includes(timestamp: Timestamp): boolean;
}
//#endregion
//#region src/value-objects/time/Year.d.ts
export declare class Year extends Integer {
  private static readonly YEAR_DAYS;
  private static readonly LEAP_YEAR_DAYS;
  constructor(value: number | NumberValueObject);
  isLeapYear(): boolean;
  getNumberOfDays(): number;
}
//#endregion
//#region src/value-objects/time/MonthOfYear.d.ts
export declare class MonthOfYear extends ValueObject<string> {
  private readonly month;
  private readonly year;
  static fromTimestamp(timestamp: Timestamp): MonthOfYear;
  static fromString(value: string): MonthOfYear;
  constructor(month: number | Month, year: number | Year);
  getMonth(): Month;
  getYear(): Year;
  getNumberOfDays(): number;
  getTimestampInterval(): TimestampInterval;
}
//#endregion
//#region src/value-objects/time/CalendarDay.d.ts
export declare class CalendarDay extends ValueObject<string> {
  private readonly year;
  private readonly month;
  private readonly day;
  private static ensureIsValidString;
  private static generateStringValue;
  private static ensureIsValidDate;
  private static timestampFromString;
  private static timestampFromValue;
  constructor(value?: string | Date | number | Timestamp);
  isAfter(date: CalendarDay): boolean;
  isBefore(date: CalendarDay): boolean;
  getYear(): number;
  getMonth(): Month;
  getMonthOfYear(): MonthOfYear;
  getDay(): Day;
  getDayOfWeek(): DayOfWeek;
  toTimestamp(): Timestamp;
}
//#endregion
//#region src/value-objects/time/Timestamp.d.ts
type TimestampValue = number | Date | Timestamp | string;
export declare class Timestamp extends ValueObject<number> {
  private static readonly FACTORS;
  private static valueMilliseconds;
  private static getLastDayOfUtcMonth;
  private static ensureCalendarDelta;
  private static createUtcCalendarValue;
  static new(value: TimestampValue): Timestamp;
  static now(): Timestamp;
  static fromSeconds(seconds: number | NumberValueObject): Timestamp;
  constructor(value?: TimestampValue);
  toExactHour(): Timestamp;
  toMilliseconds(): number;
  toSeconds(): number;
  toDate(): Date;
  toString(): string;
  isBefore(other: Timestamp): boolean;
  isAfter(other: Timestamp): boolean;
  isBeforeOrEqual(other: Timestamp): boolean;
  isAfterOrEqual(other: Timestamp): boolean;
  addMilliseconds(milliseconds: number | NumberValueObject): Timestamp;
  addSeconds(seconds: number | NumberValueObject): Timestamp;
  addMinutes(minutes: number | NumberValueObject): Timestamp;
  addHours(hours: number | NumberValueObject): Timestamp;
  addDays(days: number | NumberValueObject): Timestamp;
  addWeeks(weeks: number | NumberValueObject): Timestamp;
  addMonths(months: number | NumberValueObject): Timestamp;
  addYears(years: number | NumberValueObject): Timestamp;
  addDuration(duration: Duration): Timestamp;
  isSameDay(other: Timestamp): boolean;
  isSameMonth(other: Timestamp): boolean;
  isSameYear(other: Timestamp): boolean;
  getCalendarDay(): CalendarDay;
  getDay(): Day;
  getMonth(): Month;
  getYear(): Year;
  getHours(): number;
  getMinutes(): number;
  getSeconds(): number;
  getMilliseconds(): number;
  getDayOfWeek(): number;
  getMonthOfYear(): MonthOfYear;
}
//#endregion
//#region src/errors/InvalidTimestampIntervalError.d.ts
export declare class InvalidTimestampIntervalError extends DomainError {
  constructor(start: Timestamp, end: Timestamp);
}
//#endregion
//#region src/errors/InvalidLengthError.d.ts
export declare class InvalidLengthError extends DomainError {
  constructor(value: unknown, length: number);
}
//#endregion
//#region src/errors/NullObjectCreationDisabledError.d.ts
export declare class NullObjectCreationDisabledError extends DomainError {
  constructor(valueObjectName: string);
}
//#endregion
//#region src/errors/NullObjectError.d.ts
export declare class NullObjectError extends DomainError {
  constructor(message: string);
}
//#endregion
//#region src/errors/ValueNotInEnumError.d.ts
export declare class ValueNotInEnumError extends DomainError {
  constructor(value: unknown, enumerate: unknown);
}
//#endregion
//#region src/patterns/Assert.d.ts
export type Errors = Error | BaseError | DomainError | string;
export declare function assert(condition: boolean | unknown | undefined, error: string | Errors): asserts condition;
//#endregion
//#region src/value-objects/StringValueObject.d.ts
export declare class StringValueObject extends ValueObject<string> {
  constructor(value: string | StringValueObject, maxLength?: number);
  private ensureDoesNotExceedsMaxLength;
  isEmpty(): boolean;
}
//#endregion
//#region src/value-objects/coordinates/Latitude.d.ts
export declare class Latitude extends NumberValueObject {
  private static MIN_VALUE;
  private static MAX_VALUE;
  private static isValid;
  constructor(value: number | NumberValueObject);
}
//#endregion
//#region src/value-objects/coordinates/Longitude.d.ts
export declare class Longitude extends NumberValueObject {
  private static MIN_VALUE;
  private static MAX_VALUE;
  private static isValid;
  constructor(value: number | NumberValueObject);
}
//#endregion
//#region src/value-objects/coordinates/Coordinates.d.ts
export declare class Coordinates extends StringValueObject {
  private latitude;
  private longitude;
  static fromString(value: string): Coordinates;
  constructor(latitude: number | Latitude, longitude: number | Longitude);
  getLatitude(): Latitude;
  getLongitude(): Longitude;
}
//#endregion
//#region src/value-objects/hashes/Hash.d.ts
export declare abstract class Hash extends ValueObject<string> {
  constructor(source: string | StringValueObject);
  toBase64(): StringValueObject;
}
//#endregion
//#region src/value-objects/hashes/MD5Hash.d.ts
export declare class MD5Hash extends Hash {
  static isValid(hash: string | StringValueObject): boolean;
  constructor(source: string | StringValueObject);
}
//#endregion
//#region src/value-objects/hashes/SHA256Hash.d.ts
export declare class SHA256Hash extends ValueObject<string> {
  static isValid(hash: string | StringValueObject): boolean;
  constructor(source: string | StringValueObject);
  toBase64(): StringValueObject;
}
//#endregion
//#region src/value-objects/hashes/SHA512Hash.d.ts
export declare class SHA512Hash extends ValueObject<string> {
  static isValid(hash: string | StringValueObject): boolean;
  constructor(source: string | StringValueObject);
  toBase64(): StringValueObject;
}
//#endregion
//#region src/value-objects/ids/ShortId.d.ts
export declare class ShortId extends ValueObject<string> {
  private static readonly LENGTH;
  private static readonly PATTERN;
  private static generateObjectIdHex;
  static generate(): ShortId;
  constructor(value: string | StringValueObject);
  private ensureIsShortId;
}
//#endregion
//#region src/value-objects/ids/UUID.d.ts
export declare class UUID extends ValueObject<string> {
  private static readonly LENGTH;
  private static readonly PATTERN;
  private static readonly SENTINEL_PATTERN;
  static generate(): UUID;
  constructor(value: string | StringValueObject);
  private ensureIsUUID;
}
//#endregion
//#region src/value-objects/media/Media.d.ts
export declare class Media extends ValueObject<string> {
  private readonly buffer?;
  constructor(value: string | Buffer);
  getBuffer(): Buffer;
  getSize(): number;
  getBase64(): string;
  hasValue(other: unknown): boolean;
}
//#endregion
//#region src/value-objects/time/Hour.d.ts
export declare class Hour extends StringValueObject {
  private readonly minutes;
  private readonly hours;
  private static addTrailZero;
  private static normalizeMinutes;
  private static parseFromNumber;
  private static parseFromString;
  constructor(value: string);
  constructor(value: number, minutes?: number);
  addMinutes(minutes: number): Hour;
  diffInMinutes(other: Hour): number;
  getMinutes(): number;
  getHours(): number;
  isGreaterThan(hour: Hour): boolean;
  isLessThan(hour: Hour): boolean;
}
//#endregion
//#region src/value-objects/Color.d.ts
export declare class Color extends StringValueObject {
  static readonly RED: Color;
  static readonly GREEN: Color;
  static readonly BLUE: Color;
  static readonly BLACK: Color;
  static readonly WHITE: Color;
  static readonly YELLOW: Color;
  static readonly CYAN: Color;
  static readonly MAGENTA: Color;
  static readonly ORANGE: Color;
  static readonly PURPLE: Color;
  static readonly PINK: Color;
  static readonly BROWN: Color;
  constructor(value: string | StringValueObject);
  private ensureIsValidColor;
  hasValue(other: unknown): boolean;
}
//#endregion
//#region src/value-objects/Email.d.ts
export declare class Email extends StringValueObject {
  private static readonly PATTERN;
  constructor(value: string | StringValueObject);
  private ensureIsValidEmail;
}
//#endregion
//#region src/value-objects/Password.d.ts
export declare class Password extends StringValueObject {
  private static readonly MAX_LENGTH;
  private static readonly MIN_LENGTH;
  constructor(value: string | StringValueObject);
  private isValidPassword;
}
//#endregion
//#region src/value-objects/PositiveNumber.d.ts
export declare class PositiveNumber extends NumberValueObject {
  constructor(value: number | NumberValueObject);
  private ensureIsPositive;
}
//#endregion
//#region src/value-objects/NullObject.d.ts
type Constructor<T> = abstract new (...args: any[]) => T;
export declare abstract class NullObject {
  private static setFakeProps;
  static new<T>(klass: Constructor<T>): T;
  static isNullObject(nullable: unknown): boolean;
}
//#endregion
//#region src/value-objects/UniqueObjectArray.d.ts
interface ComparableItem {
  isEqual(item: unknown): boolean;
}
export declare class UniqueObjectArray<T extends ComparableItem> implements Iterable<T> {
  private items;
  static fromArray<T extends ComparableItem>(array: T[]): UniqueObjectArray<T>;
  includes(item: T): boolean;
  push(item: T): boolean;
  remove(item: T): boolean;
  [Symbol.iterator](): Iterator<T>;
  length(): number;
  toArray(): T[];
}
//#endregion
//# sourceMappingURL=index.d.cts.map