@exyconn/common 1.0.0

package/dist/shared/index.mjs

@@ -0,0 +1,612 @@
+import { parseISO, isValid, format, formatDistance, formatDistanceToNow, isToday, isYesterday, isTomorrow, isThisWeek, isThisYear, intervalToDuration, formatDuration, differenceInMinutes, addYears, addMonths, addWeeks, addDays, addHours, addMinutes, subYears, subMonths, subWeeks, subDays, subHours, subMinutes, differenceInYears, differenceInMonths, differenceInWeeks, differenceInDays, differenceInHours, differenceInSeconds, eachDayOfInterval, eachWeekOfInterval, eachMonthOfInterval, endOfDay, startOfDay, endOfWeek, startOfWeek, endOfMonth, startOfMonth, endOfYear, startOfYear, isAfter, isEqual, isBefore, getDay, setHours, setMinutes, setSeconds, getSeconds, getMinutes, getHours } from 'date-fns';
+export { addDays, addHours, addMinutes, addMonths, addWeeks, addYears, differenceInDays, differenceInHours, differenceInMinutes, differenceInMonths, differenceInSeconds, differenceInWeeks, differenceInYears, eachDayOfInterval, eachMonthOfInterval, eachWeekOfInterval, endOfDay, endOfMonth, endOfWeek, endOfYear, format, formatDistance, formatDistanceToNow, formatDuration, formatRelative, getDate, getDay, getHours, getMinutes, getMonth, getSeconds, getYear, intervalToDuration, isAfter, isBefore, isEqual, isFuture, isPast, isSameDay, isSameMonth, isSameWeek, isSameYear, isThisMonth, isThisWeek, isThisYear, isToday, isTomorrow, isValid, isYesterday, parseISO, setHours, setMinutes, setSeconds, startOfDay, startOfMonth, startOfWeek, startOfYear, subDays, subHours, subMinutes, subMonths, subWeeks, subYears } from 'date-fns';
+import { formatInTimeZone, toZonedTime, fromZonedTime } from 'date-fns-tz';
+export { formatInTimeZone, fromZonedTime, toZonedTime } from 'date-fns-tz';
+
+// src/shared/config/env.ts
+var getEnv = (key, defaultValue) => {
+  const value = process.env[key];
+  if (value === void 0) {
+    if (defaultValue !== void 0) {
+      return defaultValue;
+    }
+    throw new Error(`Environment variable ${key} is required but not defined`);
+  }
+  if (typeof defaultValue === "number") {
+    return Number(value);
+  }
+  if (typeof defaultValue === "boolean") {
+    return value === "true" || value === "1";
+  }
+  return value;
+};
+var getEnvOptional = (key, defaultValue) => {
+  const value = process.env[key];
+  if (value === void 0) {
+    return defaultValue;
+  }
+  if (typeof defaultValue === "number") {
+    return Number(value);
+  }
+  if (typeof defaultValue === "boolean") {
+    return value === "true" || value === "1";
+  }
+  return value;
+};
+var isProd = () => {
+  return process.env.NODE_ENV === "production";
+};
+var isDev = () => {
+  return process.env.NODE_ENV === "development";
+};
+var isTest = () => {
+  return process.env.NODE_ENV === "test";
+};
+var validateEnv = (requiredVars) => {
+  const missing = requiredVars.filter((key) => !process.env[key]);
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required environment variables: ${missing.join(", ")}`
+    );
+  }
+};
+
+// src/shared/constants/status-codes.ts
+var HTTP_STATUS = {
+  // Success
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  // Redirection
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  // Client Errors
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  CONFLICT: 409,
+  GONE: 410,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  // Server Errors
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+var HTTP_STATUS_MESSAGES = {
+  [HTTP_STATUS.OK]: "OK",
+  [HTTP_STATUS.CREATED]: "Created",
+  [HTTP_STATUS.ACCEPTED]: "Accepted",
+  [HTTP_STATUS.NO_CONTENT]: "No Content",
+  [HTTP_STATUS.BAD_REQUEST]: "Bad Request",
+  [HTTP_STATUS.UNAUTHORIZED]: "Unauthorized",
+  [HTTP_STATUS.FORBIDDEN]: "Forbidden",
+  [HTTP_STATUS.NOT_FOUND]: "Not Found",
+  [HTTP_STATUS.METHOD_NOT_ALLOWED]: "Method Not Allowed",
+  [HTTP_STATUS.CONFLICT]: "Conflict",
+  [HTTP_STATUS.UNPROCESSABLE_ENTITY]: "Unprocessable Entity",
+  [HTTP_STATUS.TOO_MANY_REQUESTS]: "Too Many Requests",
+  [HTTP_STATUS.INTERNAL_SERVER_ERROR]: "Internal Server Error",
+  [HTTP_STATUS.SERVICE_UNAVAILABLE]: "Service Unavailable"
+};
+var STATUS = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  PENDING: "pending",
+  APPROVED: "approved",
+  REJECTED: "rejected",
+  DELETED: "deleted",
+  ARCHIVED: "archived",
+  DRAFT: "draft",
+  PUBLISHED: "published",
+  SUSPENDED: "suspended"
+};
+var USER_STATUS = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  PENDING: "pending",
+  SUSPENDED: "suspended",
+  BANNED: "banned"
+};
+var ROLES = {
+  ADMIN: "admin",
+  USER: "user",
+  MODERATOR: "moderator",
+  GUEST: "guest",
+  SUPER_ADMIN: "super_admin"
+};
+var PAGINATION = {
+  DEFAULT_PAGE: 1,
+  DEFAULT_LIMIT: 10,
+  MAX_LIMIT: 100
+};
+var TOKEN_TYPES = {
+  ACCESS: "access",
+  REFRESH: "refresh",
+  RESET_PASSWORD: "reset_password",
+  EMAIL_VERIFICATION: "email_verification"
+};
+var parseDate = (date) => {
+  if (date instanceof Date) return date;
+  if (typeof date === "string") return parseISO(date);
+  return new Date(date);
+};
+var isValidDate = (date) => {
+  const parsed = parseDate(date);
+  return isValid(parsed);
+};
+var DATE_FORMATS = {
+  // Date only
+  DATE_SHORT: "MM/dd/yyyy",
+  // 01/15/2026
+  DATE_MEDIUM: "MMM d, yyyy",
+  // Jan 15, 2026
+  DATE_LONG: "MMMM d, yyyy",
+  // January 15, 2026
+  DATE_FULL: "EEEE, MMMM d, yyyy",
+  // Friday, January 15, 2026
+  DATE_ISO: "yyyy-MM-dd",
+  // 2026-01-15
+  // Time only
+  TIME_SHORT: "h:mm a",
+  // 3:30 PM
+  TIME_MEDIUM: "h:mm:ss a",
+  // 3:30:45 PM
+  TIME_24H: "HH:mm",
+  // 15:30
+  TIME_24H_FULL: "HH:mm:ss",
+  // 15:30:45
+  // Date and time
+  DATETIME_SHORT: "MM/dd/yyyy h:mm a",
+  // 01/15/2026 3:30 PM
+  DATETIME_MEDIUM: "MMM d, yyyy h:mm a",
+  // Jan 15, 2026 3:30 PM
+  DATETIME_LONG: "MMMM d, yyyy h:mm a",
+  // January 15, 2026 3:30 PM
+  DATETIME_FULL: "EEEE, MMMM d, yyyy h:mm a",
+  // Friday, January 15, 2026 3:30 PM
+  DATETIME_ISO: "yyyy-MM-dd'T'HH:mm:ss",
+  // 2026-01-15T15:30:45
+  // Special formats
+  MONTH_YEAR: "MMMM yyyy",
+  // January 2026
+  MONTH_DAY: "MMM d",
+  // Jan 15
+  DAY_MONTH: "d MMM",
+  // 15 Jan
+  WEEKDAY: "EEEE",
+  // Friday
+  WEEKDAY_SHORT: "EEE"
+  // Fri
+};
+var formatDate = (date, formatStr = DATE_FORMATS.DATE_MEDIUM) => {
+  return format(parseDate(date), formatStr);
+};
+var formatDateTime = (date, formatStr = DATE_FORMATS.DATETIME_MEDIUM) => {
+  return format(parseDate(date), formatStr);
+};
+var formatDateInTimezone = (date, timezone, formatStr = DATE_FORMATS.DATETIME_MEDIUM) => {
+  return formatInTimeZone(parseDate(date), timezone, formatStr);
+};
+var formatRelativeTime = (date, baseDate) => {
+  const parsed = parseDate(date);
+  if (baseDate) {
+    return formatDistance(parsed, parseDate(baseDate), { addSuffix: true });
+  }
+  return formatDistanceToNow(parsed, { addSuffix: true });
+};
+var formatSmartDate = (date) => {
+  const parsed = parseDate(date);
+  if (isToday(parsed)) {
+    return `Today at ${format(parsed, DATE_FORMATS.TIME_SHORT)}`;
+  }
+  if (isYesterday(parsed)) {
+    return `Yesterday at ${format(parsed, DATE_FORMATS.TIME_SHORT)}`;
+  }
+  if (isTomorrow(parsed)) {
+    return `Tomorrow at ${format(parsed, DATE_FORMATS.TIME_SHORT)}`;
+  }
+  if (isThisWeek(parsed)) {
+    return format(parsed, "EEEE 'at' h:mm a");
+  }
+  if (isThisYear(parsed)) {
+    return format(parsed, "MMM d 'at' h:mm a");
+  }
+  return format(parsed, DATE_FORMATS.DATETIME_MEDIUM);
+};
+var formatDateRange = (start, end) => {
+  const duration = intervalToDuration({
+    start: parseDate(start),
+    end: parseDate(end)
+  });
+  return formatDuration(duration, {
+    format: ["years", "months", "days", "hours", "minutes"]
+  });
+};
+var toTimezone = (date, timezone) => {
+  return toZonedTime(parseDate(date), timezone);
+};
+var fromTimezone = (date, timezone) => {
+  return fromZonedTime(parseDate(date), timezone);
+};
+var nowInTimezone = (timezone) => {
+  return toZonedTime(/* @__PURE__ */ new Date(), timezone);
+};
+var getTimezoneDifference = (timezone1, timezone2) => {
+  const now = /* @__PURE__ */ new Date();
+  const time1 = toZonedTime(now, timezone1);
+  const time2 = toZonedTime(now, timezone2);
+  const diffMinutes = differenceInMinutes(time1, time2);
+  const hours = Math.floor(Math.abs(diffMinutes) / 60);
+  const minutes = Math.abs(diffMinutes) % 60;
+  const sign = diffMinutes >= 0 ? "+" : "-";
+  if (minutes === 0) {
+    return `${sign}${hours}h`;
+  }
+  return `${sign}${hours}h ${minutes}m`;
+};
+var addTime = (date, amount, unit) => {
+  const parsed = parseDate(date);
+  switch (unit) {
+    case "minutes":
+      return addMinutes(parsed, amount);
+    case "hours":
+      return addHours(parsed, amount);
+    case "days":
+      return addDays(parsed, amount);
+    case "weeks":
+      return addWeeks(parsed, amount);
+    case "months":
+      return addMonths(parsed, amount);
+    case "years":
+      return addYears(parsed, amount);
+  }
+};
+var subtractTime = (date, amount, unit) => {
+  const parsed = parseDate(date);
+  switch (unit) {
+    case "minutes":
+      return subMinutes(parsed, amount);
+    case "hours":
+      return subHours(parsed, amount);
+    case "days":
+      return subDays(parsed, amount);
+    case "weeks":
+      return subWeeks(parsed, amount);
+    case "months":
+      return subMonths(parsed, amount);
+    case "years":
+      return subYears(parsed, amount);
+  }
+};
+var getDateDifference = (date1, date2, unit) => {
+  const d1 = parseDate(date1);
+  const d2 = parseDate(date2);
+  switch (unit) {
+    case "seconds":
+      return differenceInSeconds(d1, d2);
+    case "minutes":
+      return differenceInMinutes(d1, d2);
+    case "hours":
+      return differenceInHours(d1, d2);
+    case "days":
+      return differenceInDays(d1, d2);
+    case "weeks":
+      return differenceInWeeks(d1, d2);
+    case "months":
+      return differenceInMonths(d1, d2);
+    case "years":
+      return differenceInYears(d1, d2);
+  }
+};
+var getDaysInRange = (start, end) => {
+  return eachDayOfInterval({
+    start: parseDate(start),
+    end: parseDate(end)
+  });
+};
+var getWeeksInRange = (start, end) => {
+  return eachWeekOfInterval({
+    start: parseDate(start),
+    end: parseDate(end)
+  });
+};
+var getMonthsInRange = (start, end) => {
+  return eachMonthOfInterval({
+    start: parseDate(start),
+    end: parseDate(end)
+  });
+};
+var getDayBoundaries = (date) => {
+  const parsed = parseDate(date);
+  return {
+    start: startOfDay(parsed),
+    end: endOfDay(parsed)
+  };
+};
+var getWeekBoundaries = (date, weekStartsOn = 0) => {
+  const parsed = parseDate(date);
+  return {
+    start: startOfWeek(parsed, { weekStartsOn }),
+    end: endOfWeek(parsed, { weekStartsOn })
+  };
+};
+var getMonthBoundaries = (date) => {
+  const parsed = parseDate(date);
+  return {
+    start: startOfMonth(parsed),
+    end: endOfMonth(parsed)
+  };
+};
+var getYearBoundaries = (date) => {
+  const parsed = parseDate(date);
+  return {
+    start: startOfYear(parsed),
+    end: endOfYear(parsed)
+  };
+};
+var isDateBetween = (date, start, end) => {
+  const d = parseDate(date);
+  const s = parseDate(start);
+  const e = parseDate(end);
+  return (isAfter(d, s) || isEqual(d, s)) && (isBefore(d, e) || isEqual(d, e));
+};
+var doDateRangesOverlap = (range1Start, range1End, range2Start, range2End) => {
+  const r1s = parseDate(range1Start);
+  const r1e = parseDate(range1End);
+  const r2s = parseDate(range2Start);
+  const r2e = parseDate(range2End);
+  return isBefore(r1s, r2e) && isAfter(r1e, r2s);
+};
+var getAge = (birthDate) => {
+  return differenceInYears(/* @__PURE__ */ new Date(), parseDate(birthDate));
+};
+var isWeekend = (date) => {
+  const day = getDay(parseDate(date));
+  return day === 0 || day === 6;
+};
+var isWeekday = (date) => {
+  return !isWeekend(date);
+};
+var daysUntil = (date) => {
+  return differenceInDays(parseDate(date), /* @__PURE__ */ new Date());
+};
+var daysSince = (date) => {
+  return differenceInDays(/* @__PURE__ */ new Date(), parseDate(date));
+};
+var toDateInputValue = (date) => {
+  return format(parseDate(date), DATE_FORMATS.DATE_ISO);
+};
+var toDateTimeInputValue = (date) => {
+  return format(parseDate(date), "yyyy-MM-dd'T'HH:mm");
+};
+var toTimeInputValue = (date) => {
+  return format(parseDate(date), DATE_FORMATS.TIME_24H);
+};
+var setTime = (date, hours, minutes, seconds = 0) => {
+  let result = parseDate(date);
+  result = setHours(result, hours);
+  result = setMinutes(result, minutes);
+  result = setSeconds(result, seconds);
+  return result;
+};
+var combineDateAndTime = (dateInput, timeInput) => {
+  const date = parseDate(dateInput);
+  const time = parseDate(timeInput);
+  return setTime(date, getHours(time), getMinutes(time), getSeconds(time));
+};
+var date_time_default = {
+  // Core
+  parseDate,
+  isValidDate,
+  DATE_FORMATS,
+  // Format
+  formatDate,
+  formatDateTime,
+  formatDateInTimezone,
+  formatRelativeTime,
+  formatSmartDate,
+  formatDateRange,
+  // Timezone
+  toTimezone,
+  fromTimezone,
+  nowInTimezone,
+  getTimezoneDifference,
+  // Arithmetic
+  addTime,
+  subtractTime,
+  getDateDifference,
+  // Ranges
+  getDaysInRange,
+  getWeeksInRange,
+  getMonthsInRange,
+  // Boundaries
+  getDayBoundaries,
+  getWeekBoundaries,
+  getMonthBoundaries,
+  getYearBoundaries,
+  // Comparison
+  isDateBetween,
+  doDateRangesOverlap,
+  // Utilities
+  getAge,
+  isWeekend,
+  isWeekday,
+  daysUntil,
+  daysSince,
+  toDateInputValue,
+  toDateTimeInputValue,
+  toTimeInputValue,
+  setTime,
+  combineDateAndTime
+};
+
+// src/shared/validation/index.ts
+var VALIDATION_PATTERNS = {
+  /** Email pattern (RFC 5322 simplified) */
+  EMAIL: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  /** Strong password: min 8 chars, uppercase, lowercase, number, special char */
+  PASSWORD_STRONG: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/,
+  /** Medium password: min 8 chars, uppercase, lowercase, number */
+  PASSWORD_MEDIUM: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d@$!%*?&]{8,}$/,
+  /** Basic password: min 8 chars */
+  PASSWORD_BASIC: /^.{8,}$/,
+  /** Phone number (international) */
+  PHONE_INTERNATIONAL: /^\+?[\d\s\-().]{10,}$/,
+  /** Phone number (US) */
+  PHONE_US: /^\(?([0-9]{3})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/,
+  /** Phone number (India) */
+  PHONE_INDIA: /^[6-9]\d{9}$/,
+  /** URL pattern */
+  URL: /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/,
+  /** URL with required protocol */
+  URL_STRICT: /^https?:\/\/([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/,
+  /** Alphanumeric only */
+  ALPHANUMERIC: /^[a-zA-Z0-9]+$/,
+  /** Letters only */
+  LETTERS_ONLY: /^[a-zA-Z]+$/,
+  /** Numbers only */
+  NUMBERS_ONLY: /^\d+$/,
+  /** Slug pattern (kebab-case) */
+  SLUG: /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
+  /** Username pattern (alphanumeric, underscore, hyphen) */
+  USERNAME: /^[a-zA-Z0-9_-]{3,30}$/,
+  /** Credit card (basic validation) */
+  CREDIT_CARD: /^\d{13,19}$/,
+  /** CVV (3 or 4 digits) */
+  CVV: /^\d{3,4}$/,
+  /** ZIP code (US) */
+  ZIP_US: /^\d{5}(-\d{4})?$/,
+  /** Postal code (India) */
+  POSTAL_INDIA: /^\d{6}$/,
+  /** IP Address (IPv4) */
+  IPV4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
+  /** Hex color */
+  HEX_COLOR: /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/,
+  /** Date (YYYY-MM-DD) */
+  DATE_ISO: /^\d{4}-\d{2}-\d{2}$/,
+  /** Time (HH:MM or HH:MM:SS) */
+  TIME: /^([01]\d|2[0-3]):([0-5]\d)(:[0-5]\d)?$/
+};
+var isValidEmail = (email) => {
+  return VALIDATION_PATTERNS.EMAIL.test(email.trim());
+};
+var isValidPassword = (password, strength = "medium") => {
+  switch (strength) {
+    case "strong":
+      return VALIDATION_PATTERNS.PASSWORD_STRONG.test(password);
+    case "medium":
+      return VALIDATION_PATTERNS.PASSWORD_MEDIUM.test(password);
+    case "basic":
+    default:
+      return VALIDATION_PATTERNS.PASSWORD_BASIC.test(password);
+  }
+};
+var isValidPhone = (phone, format2 = "international") => {
+  const cleaned = phone.replace(/\s/g, "");
+  switch (format2) {
+    case "us":
+      return VALIDATION_PATTERNS.PHONE_US.test(cleaned);
+    case "india":
+      return VALIDATION_PATTERNS.PHONE_INDIA.test(cleaned);
+    case "international":
+    default:
+      return VALIDATION_PATTERNS.PHONE_INTERNATIONAL.test(cleaned);
+  }
+};
+var isValidUrl = (url, requireProtocol = false) => {
+  if (requireProtocol) {
+    return VALIDATION_PATTERNS.URL_STRICT.test(url);
+  }
+  return VALIDATION_PATTERNS.URL.test(url);
+};
+var isValidUsername = (username) => {
+  return VALIDATION_PATTERNS.USERNAME.test(username);
+};
+var isValidSlug = (slug) => {
+  return VALIDATION_PATTERNS.SLUG.test(slug);
+};
+var VALIDATION_MESSAGES = {
+  // Required fields
+  REQUIRED: "This field is required",
+  REQUIRED_FIELD: (field) => `${field} is required`,
+  // Email
+  EMAIL_INVALID: "Please enter a valid email address",
+  EMAIL_REQUIRED: "Email is required",
+  // Password
+  PASSWORD_REQUIRED: "Password is required",
+  PASSWORD_MIN_LENGTH: (length) => `Password must be at least ${length} characters`,
+  PASSWORD_WEAK: "Password is too weak",
+  PASSWORD_MEDIUM: "Password must contain uppercase, lowercase, and number",
+  PASSWORD_STRONG: "Password must contain uppercase, lowercase, number, and special character",
+  PASSWORD_MISMATCH: "Passwords do not match",
+  // Name
+  NAME_REQUIRED: "Name is required",
+  FIRST_NAME_REQUIRED: "First name is required",
+  LAST_NAME_REQUIRED: "Last name is required",
+  NAME_MIN_LENGTH: (length) => `Name must be at least ${length} characters`,
+  NAME_MAX_LENGTH: (length) => `Name must be at most ${length} characters`,
+  // Phone
+  PHONE_INVALID: "Please enter a valid phone number",
+  PHONE_REQUIRED: "Phone number is required",
+  // URL
+  URL_INVALID: "Please enter a valid URL",
+  // Username
+  USERNAME_INVALID: "Username can only contain letters, numbers, underscores, and hyphens",
+  USERNAME_MIN_LENGTH: "Username must be at least 3 characters",
+  USERNAME_MAX_LENGTH: "Username must be at most 30 characters",
+  USERNAME_TAKEN: "This username is already taken",
+  // General
+  MIN_LENGTH: (field, length) => `${field} must be at least ${length} characters`,
+  MAX_LENGTH: (field, length) => `${field} must be at most ${length} characters`,
+  MIN_VALUE: (field, value) => `${field} must be at least ${value}`,
+  MAX_VALUE: (field, value) => `${field} must be at most ${value}`,
+  INVALID_FORMAT: "Invalid format",
+  TERMS_REQUIRED: "You must accept the terms and conditions"
+};
+var VALIDATION_RULES = {
+  email: {
+    pattern: VALIDATION_PATTERNS.EMAIL,
+    message: VALIDATION_MESSAGES.EMAIL_INVALID
+  },
+  password: {
+    minLength: 8,
+    pattern: VALIDATION_PATTERNS.PASSWORD_MEDIUM,
+    message: VALIDATION_MESSAGES.PASSWORD_MEDIUM
+  },
+  passwordStrong: {
+    minLength: 8,
+    pattern: VALIDATION_PATTERNS.PASSWORD_STRONG,
+    message: VALIDATION_MESSAGES.PASSWORD_STRONG
+  },
+  name: {
+    minLength: 2,
+    maxLength: 50
+  },
+  username: {
+    minLength: 3,
+    maxLength: 30,
+    pattern: VALIDATION_PATTERNS.USERNAME,
+    message: VALIDATION_MESSAGES.USERNAME_INVALID
+  },
+  phone: {
+    pattern: VALIDATION_PATTERNS.PHONE_INTERNATIONAL,
+    message: VALIDATION_MESSAGES.PHONE_INVALID
+  },
+  url: {
+    pattern: VALIDATION_PATTERNS.URL,
+    message: VALIDATION_MESSAGES.URL_INVALID
+  }
+};
+
+export { DATE_FORMATS, HTTP_STATUS, HTTP_STATUS_MESSAGES, PAGINATION, ROLES, STATUS, TOKEN_TYPES, USER_STATUS, VALIDATION_MESSAGES, VALIDATION_PATTERNS, VALIDATION_RULES, addTime, combineDateAndTime, date_time_default as dateTime, daysSince, daysUntil, doDateRangesOverlap, formatDate, formatDateInTimezone, formatDateRange, formatDateTime, formatRelativeTime, formatSmartDate, fromTimezone, getAge, getDateDifference, getDayBoundaries, getDaysInRange, getEnv, getEnvOptional, getMonthBoundaries, getMonthsInRange, getTimezoneDifference, getWeekBoundaries, getWeeksInRange, getYearBoundaries, isDateBetween, isDev, isProd, isTest, isValidDate, isValidEmail, isValidPassword, isValidPhone, isValidSlug, isValidUrl, isValidUsername, isWeekday, isWeekend, nowInTimezone, parseDate, setTime, subtractTime, toDateInputValue, toDateTimeInputValue, toTimeInputValue, toTimezone, validateEnv };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map