@warlock.js/notifications 4.16.0 → 5.0.1

package/esm/seal/src/validators/date-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/date-validator.ts"],"sourcesContent":["import dayjs from \"dayjs\";\r\nimport {\r\n  addDaysMutator,\r\n  addHoursMutator,\r\n  addMonthsMutator,\r\n  addYearsMutator,\r\n  dateMutator,\r\n  toEndOfDayMutator,\r\n  toEndOfMonthMutator,\r\n  toEndOfYearMutator,\r\n  toStartOfDayMutator,\r\n  toStartOfMonthMutator,\r\n  toStartOfYearMutator,\r\n  toUTCMutator,\r\n} from \"../mutators\";\r\nimport {\r\n  afterFieldRule,\r\n  afterTodayRule,\r\n  ageRule,\r\n  beforeFieldRule,\r\n  beforeHourRule,\r\n  beforeMinuteRule,\r\n  beforeTodayRule,\r\n  betweenAgeRule,\r\n  betweenDatesRule,\r\n  betweenDaysRule,\r\n  betweenHoursRule,\r\n  betweenMinutesRule,\r\n  betweenMonthsRule,\r\n  betweenTimesRule,\r\n  betweenYearsRule,\r\n  birthdayRule,\r\n  businessDayRule,\r\n  dateRule,\r\n  fromHourRule,\r\n  fromMinuteRule,\r\n  fromTodayRule,\r\n  futureRule,\r\n  leapYearRule,\r\n  maxAgeRule,\r\n  maxDateRule,\r\n  maxDayRule,\r\n  maxMonthRule,\r\n  maxYearRule,\r\n  minAgeRule,\r\n  minDateRule,\r\n  minDayRule,\r\n  minMonthRule,\r\n  minYearRule,\r\n  Month,\r\n  monthRule,\r\n  pastRule,\r\n  quarterRule,\r\n  sameAsFieldDateRule,\r\n  todayRule,\r\n  weekDayRule,\r\n  weekdaysRule,\r\n  weekendRule,\r\n  withinDaysRule,\r\n  withinFutureDaysRule,\r\n  withinPastDaysRule,\r\n  yearRule,\r\n} from \"../rules\";\r\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\nimport { applyNullable, getRuleOptions } from \"../standard-schema/json-schema\";\r\nimport type { WeekDay } from \"../types/date-types\";\r\nimport { isDateValue } from \"./../helpers/date-helpers\";\r\nimport { BaseValidator } from \"./base-validator\";\r\n\r\n/**\r\n * Date validator class\r\n */\r\nexport class DateValidator extends BaseValidator {\r\n  public constructor(errorMessage?: string) {\r\n    super();\r\n    this.addMutableMutator(dateMutator); // Normalize to Date object first\r\n    this.addMutableRule(dateRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Check if value is a Date type\r\n   */\r\n  public matchesType(value: any): boolean {\r\n    return isDateValue(value);\r\n  }\r\n\r\n  // ==================== Output Transformers ====================\r\n  // These transform the Date after validation into different formats\r\n\r\n  /**\r\n   * Convert date to ISO string format\r\n   * @category transformer\r\n   */\r\n  public toISOString() {\r\n    return this.addTransformer((data) => (data instanceof Date ? data.toISOString() : data));\r\n  }\r\n\r\n  /** Convert date to Unix timestamp (milliseconds) */\r\n  public toTimestamp() {\r\n    return this.addTransformer((data) => (data instanceof Date ? data.getTime() : data));\r\n  }\r\n\r\n  // ==================== String Format Transformers ====================\r\n  // These convert Date to formatted strings after validation\r\n\r\n  /** Convert date to specific format using dayjs */\r\n  public toFormat(format: string) {\r\n    return this.addTransformer(\r\n      (data, { options }) => (data instanceof Date ? dayjs(data).format(options.format) : data),\r\n      { format },\r\n    );\r\n  }\r\n\r\n  /** Convert to date only (remove time, returns YYYY-MM-DD) */\r\n  public toDateOnly() {\r\n    return this.addTransformer(\r\n      (data) => (data instanceof Date ? dayjs(data).format(\"YYYY-MM-DD\") : data),\r\n      { __jsonSchemaFormat: \"date\" },\r\n    );\r\n  }\r\n\r\n  /** Convert to time only (returns HH:MM:SS) */\r\n  public toTimeOnly() {\r\n    return this.addTransformer(\r\n      (data) => (data instanceof Date ? dayjs(data).format(\"HH:mm:ss\") : data),\r\n      { __jsonSchemaFormat: \"time\" },\r\n    );\r\n  }\r\n\r\n  // ==================== Date Mutators ====================\r\n  // These modify the Date object before validation\r\n\r\n  /**\r\n   * Convert date to start of day (00:00:00)\r\n   * @category mutator\r\n   */\r\n  public toStartOfDay() {\r\n    return this.addMutator(toStartOfDayMutator);\r\n  }\r\n\r\n  /** Convert date to end of day (23:59:59.999) */\r\n  public toEndOfDay() {\r\n    return this.addMutator(toEndOfDayMutator);\r\n  }\r\n\r\n  /** Add or subtract days from date */\r\n  public addDays(days: number) {\r\n    return this.addMutator(addDaysMutator, { days });\r\n  }\r\n\r\n  /** Add or subtract months from date */\r\n  public addMonths(months: number) {\r\n    return this.addMutator(addMonthsMutator, { months });\r\n  }\r\n\r\n  /** Add or subtract years from date */\r\n  public addYears(years: number) {\r\n    return this.addMutator(addYearsMutator, { years });\r\n  }\r\n\r\n  /** Add or subtract hours from date */\r\n  public addHours(hours: number) {\r\n    return this.addMutator(addHoursMutator, { hours });\r\n  }\r\n\r\n  /** Convert date to UTC */\r\n  public toUTC() {\r\n    return this.addMutator(toUTCMutator);\r\n  }\r\n\r\n  // ==================== Date Range Mutators ====================\r\n\r\n  /** Set to start of month */\r\n  public toStartOfMonth() {\r\n    return this.addMutator(toStartOfMonthMutator);\r\n  }\r\n\r\n  /** Set to end of month */\r\n  public toEndOfMonth() {\r\n    return this.addMutator(toEndOfMonthMutator);\r\n  }\r\n\r\n  /** Set to start of year */\r\n  public toStartOfYear() {\r\n    return this.addMutator(toStartOfYearMutator);\r\n  }\r\n\r\n  /** Set to end of year */\r\n  public toEndOfYear() {\r\n    return this.addMutator(toEndOfYearMutator);\r\n  }\r\n\r\n  // ==================== Date Comparison ====================\r\n\r\n  /**\r\n   * Date must be greater than or equal to the given date or field (inclusive)\r\n   *\r\n   * Smart detection:\r\n   * - Date instance, timestamp, or date string (with - or /) → value comparison\r\n   * - Plain string → field comparison\r\n   *\r\n   * @param dateOrField - Date, timestamp, date string, or field name\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * // Value comparison\r\n   * v.date().min('2024-01-01')\r\n   * v.date().min(new Date())\r\n   * v.date().min(1698278400000)\r\n   *\r\n   * // Field comparison\r\n   * v.date().min('startsAt')\r\n   * ```\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public min(dateOrField: Date | string | number, errorMessage?: string): this {\r\n    return this.addRule(minDateRule, errorMessage, {\r\n      dateOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be less than or equal to the given date or field (inclusive)\r\n   *\r\n   * Smart detection:\r\n   * - Date instance, timestamp, or date string (with - or /) → value comparison\r\n   * - Plain string → field comparison\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public max(dateOrField: Date | string | number, errorMessage?: string): this {\r\n    return this.addRule(maxDateRule, errorMessage, {\r\n      dateOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be strictly less than the given date or field (exclusive)\r\n   *\r\n   * Smart detection:\r\n   * - Date instance, timestamp, or date string (with - or /) → value comparison\r\n   * - Plain string → field comparison\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public before(dateOrField: Date | string | number, errorMessage?: string): this {\r\n    return this.addRule(beforeFieldRule, errorMessage, {\r\n      dateOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be strictly greater than the given date or field (exclusive)\r\n   *\r\n   * Smart detection:\r\n   * - Date instance, timestamp, or date string (with - or /) → value comparison\r\n   * - Plain string → field comparison\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public after(dateOrField: Date | string | number, errorMessage?: string): this {\r\n    return this.addRule(afterFieldRule, errorMessage, {\r\n      dateOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /** Date must be between start and end dates */\r\n  public between(startDate: Date, endDate: Date, errorMessage?: string) {\r\n    return this.addRule(betweenDatesRule, errorMessage, { startDate, endDate });\r\n  }\r\n\r\n  /** Date must be exactly today */\r\n  public today(errorMessage?: string) {\r\n    return this.addRule(todayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be today or in the future */\r\n  public fromToday(errorMessage?: string) {\r\n    return this.addRule(fromTodayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be before today */\r\n  public beforeToday(errorMessage?: string) {\r\n    return this.addRule(beforeTodayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be after today (not including today) */\r\n  public afterToday(errorMessage?: string) {\r\n    return this.addRule(afterTodayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be in the past */\r\n  public past(errorMessage?: string) {\r\n    return this.addRule(pastRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be in the future */\r\n  public future(errorMessage?: string) {\r\n    return this.addRule(futureRule, errorMessage);\r\n  }\r\n\r\n  // ==================== Sibling Field Comparison ====================\r\n  // Explicit sibling scope methods\r\n\r\n  /**\r\n   * Date must be >= sibling field value (inclusive)\r\n   * @category Validation Rule\r\n   */\r\n  public minSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(minDateRule, errorMessage, {\r\n      dateOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be <= sibling field value (inclusive)\r\n   * @category Validation Rule\r\n   */\r\n  public maxSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(maxDateRule, errorMessage, {\r\n      dateOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be < sibling field value (exclusive)\r\n   * @category Validation Rule\r\n   */\r\n  public beforeSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(beforeFieldRule, errorMessage, {\r\n      dateOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be > sibling field value (exclusive)\r\n   * @category Validation Rule\r\n   */\r\n  public afterSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(afterFieldRule, errorMessage, {\r\n      dateOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /** Date must be the same as another field's date */\r\n  public sameAsField(field: string, errorMessage?: string) {\r\n    return this.addRule(sameAsFieldDateRule, errorMessage, {\r\n      field,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /** Date must be the same as another sibling field's date */\r\n  public sameAsFieldSibling(field: string, errorMessage?: string) {\r\n    return this.addRule(sameAsFieldDateRule, errorMessage, {\r\n      field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  // ==================== Time Validation ====================\r\n\r\n  /** Time must be from specific hour onwards (0-23) */\r\n  public fromHour(hour: number, errorMessage?: string) {\r\n    return this.addRule(fromHourRule, errorMessage, { hour });\r\n  }\r\n\r\n  /** Time must be before specific hour (0-23) */\r\n  public beforeHour(hour: number, errorMessage?: string) {\r\n    return this.addRule(beforeHourRule, errorMessage, { hour });\r\n  }\r\n\r\n  /** Time must be between start and end hours (0-23) */\r\n  public betweenHours(startHour: number, endHour: number, errorMessage?: string) {\r\n    return this.addRule(betweenHoursRule, errorMessage, { startHour, endHour });\r\n  }\r\n\r\n  /** Time must be from specific minute onwards (0-59) */\r\n  public fromMinute(minute: number, errorMessage?: string) {\r\n    return this.addRule(fromMinuteRule, errorMessage, { minute });\r\n  }\r\n\r\n  /** Time must be before specific minute (0-59) */\r\n  public beforeMinute(minute: number, errorMessage?: string) {\r\n    return this.addRule(beforeMinuteRule, errorMessage, { minute });\r\n  }\r\n\r\n  /** Time must be between start and end minutes (0-59) */\r\n  public betweenMinutes(startMinute: number, endMinute: number, errorMessage?: string) {\r\n    return this.addRule(betweenMinutesRule, errorMessage, {\r\n      startMinute,\r\n      endMinute,\r\n    });\r\n  }\r\n\r\n  /** Time must be between start and end times (HH:MM format) */\r\n  public betweenTimes(startTime: string, endTime: string, errorMessage?: string) {\r\n    return this.addRule(betweenTimesRule, errorMessage, { startTime, endTime });\r\n  }\r\n\r\n  // ==================== Age Validation ====================\r\n\r\n  /** Age must be exactly the given years */\r\n  public age(years: number, errorMessage?: string) {\r\n    return this.addRule(ageRule, errorMessage, { years });\r\n  }\r\n\r\n  /** Minimum age requirement */\r\n  public minAge(years: number, errorMessage?: string) {\r\n    return this.addRule(minAgeRule, errorMessage, { years });\r\n  }\r\n\r\n  /** Maximum age requirement */\r\n  public maxAge(years: number, errorMessage?: string) {\r\n    return this.addRule(maxAgeRule, errorMessage, { years });\r\n  }\r\n\r\n  /** Age must be between min and max years */\r\n  public betweenAge(minAge: number, maxAge: number, errorMessage?: string) {\r\n    return this.addRule(betweenAgeRule, errorMessage, { minAge, maxAge });\r\n  }\r\n\r\n  // ==================== Day Validation ====================\r\n\r\n  /** Date must be specific weekday */\r\n  public weekDay(day: WeekDay, errorMessage?: string) {\r\n    return this.addRule(weekDayRule, errorMessage, { day });\r\n  }\r\n\r\n  /** Date must be one of specified weekdays */\r\n  public weekdays(days: WeekDay[], errorMessage?: string) {\r\n    return this.addRule(weekdaysRule, errorMessage, { days });\r\n  }\r\n\r\n  /** Date must be a weekend (Saturday or Sunday) */\r\n  public weekend(errorMessage?: string) {\r\n    return this.addRule(weekendRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be a business day (Monday-Friday) */\r\n  public businessDay(errorMessage?: string) {\r\n    return this.addRule(businessDayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must match specific format */\r\n  public format(format: string, errorMessage?: string) {\r\n    return this.addRule(dateRule, errorMessage, { format });\r\n  }\r\n\r\n  // ==================== Relative Date Validation ====================\r\n\r\n  /** Date must be within X days from now (past or future) */\r\n  public withinDays(days: number, errorMessage?: string) {\r\n    return this.addRule(withinDaysRule, errorMessage, { days });\r\n  }\r\n\r\n  /** Date must be within X days in the past */\r\n  public withinPastDays(days: number, errorMessage?: string) {\r\n    return this.addRule(withinPastDaysRule, errorMessage, { days });\r\n  }\r\n\r\n  /** Date must be within X days in the future */\r\n  public withinFutureDays(days: number, errorMessage?: string) {\r\n    return this.addRule(withinFutureDaysRule, errorMessage, { days });\r\n  }\r\n\r\n  // ==================== Period Validation ====================\r\n\r\n  /** Date must be in specific month (1-12) */\r\n  public month(month: Month, errorMessage?: string) {\r\n    return this.addRule(monthRule, errorMessage, { month });\r\n  }\r\n\r\n  /** Date must be in specific year */\r\n  public year(year: number, errorMessage?: string) {\r\n    return this.addRule(yearRule, errorMessage, { year });\r\n  }\r\n\r\n  /**\r\n   * Date must be between start and end years\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public betweenYears(startYear: number | string, endYear: number | string, errorMessage?: string) {\r\n    return this.addRule(betweenYearsRule, errorMessage, {\r\n      startYear,\r\n      endYear,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between start and end months (1-12)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public betweenMonths(\r\n    startMonth: Month | string,\r\n    endMonth: Month | string,\r\n    errorMessage?: string,\r\n  ) {\r\n    return this.addRule(betweenMonthsRule, errorMessage, {\r\n      startMonth,\r\n      endMonth,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between start and end days (1-31)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public betweenDays(startDay: number | string, endDay: number | string, errorMessage?: string) {\r\n    return this.addRule(betweenDaysRule, errorMessage, {\r\n      startDay,\r\n      endDay,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between sibling field years\r\n   * @category Validation Rule\r\n   */\r\n  public betweenYearsSibling(startYearField: string, endYearField: string, errorMessage?: string) {\r\n    return this.addRule(betweenYearsRule, errorMessage, {\r\n      startYear: startYearField,\r\n      endYear: endYearField,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between sibling field months\r\n   * @category Validation Rule\r\n   */\r\n  public betweenMonthsSibling(\r\n    startMonthField: string,\r\n    endMonthField: string,\r\n    errorMessage?: string,\r\n  ) {\r\n    return this.addRule(betweenMonthsRule, errorMessage, {\r\n      startMonth: startMonthField,\r\n      endMonth: endMonthField,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between sibling field days\r\n   * @category Validation Rule\r\n   */\r\n  public betweenDaysSibling(startDayField: string, endDayField: string, errorMessage?: string) {\r\n    return this.addRule(betweenDaysRule, errorMessage, {\r\n      startDay: startDayField,\r\n      endDay: endDayField,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Year must be >= given year or field\r\n   * Smart detection: number or field name\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * // Value comparison\r\n   * v.date().minYear(2024)\r\n   *\r\n   * // Field comparison\r\n   * v.date().minYear('startYear')\r\n   * ```\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public minYear(yearOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(minYearRule, errorMessage, {\r\n      yearOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Year must be <= given year or field\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public maxYear(yearOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(maxYearRule, errorMessage, {\r\n      yearOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Month must be >= given month or field (1-12)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public minMonth(monthOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(minMonthRule, errorMessage, {\r\n      monthOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Month must be <= given month or field (1-12)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public maxMonth(monthOrField: Month | string, errorMessage?: string): this {\r\n    return this.addRule(maxMonthRule, errorMessage, {\r\n      monthOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Day must be >= given day or field (1-31)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public minDay(dayOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(minDayRule, errorMessage, {\r\n      dayOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Day must be <= given day or field (1-31)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public maxDay(dayOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(maxDayRule, errorMessage, {\r\n      dayOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Year must be >= sibling field year\r\n   * @category Validation Rule\r\n   */\r\n  public minYearSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(minYearRule, errorMessage, {\r\n      yearOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Year must be <= sibling field year\r\n   * @category Validation Rule\r\n   */\r\n  public maxYearSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(maxYearRule, errorMessage, {\r\n      yearOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Month must be >= sibling field month\r\n   * @category Validation Rule\r\n   */\r\n  public minMonthSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(minMonthRule, errorMessage, {\r\n      monthOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Month must be <= sibling field month\r\n   * @category Validation Rule\r\n   */\r\n  public maxMonthSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(maxMonthRule, errorMessage, {\r\n      monthOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Day must be >= sibling field day\r\n   * @category Validation Rule\r\n   */\r\n  public minDaySibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(minDayRule, errorMessage, {\r\n      dayOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Day must be <= sibling field day\r\n   * @category Validation Rule\r\n   */\r\n  public maxDaySibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(maxDayRule, errorMessage, {\r\n      dayOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /** Date must be in specific quarter (1-4) */\r\n  public quarter(quarter: 1 | 2 | 3 | 4, errorMessage?: string) {\r\n    return this.addRule(quarterRule, errorMessage, { quarter });\r\n  }\r\n\r\n  // ==================== Special Validation ====================\r\n\r\n  /** Valid birthday (not in future, reasonable age) */\r\n  public birthday(minAge?: number, maxAge?: number, errorMessage?: string) {\r\n    return this.addRule(birthdayRule, errorMessage, { minAge, maxAge });\r\n  }\r\n\r\n  /** Date must be in a leap year */\r\n  public leapYear(errorMessage?: string) {\r\n    return this.addRule(leapYearRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Set default value as current time of exeuction\r\n   */\r\n  public defaultNow() {\r\n    return this.default(() => new Date());\r\n  }\r\n\r\n  /**\r\n   * @inheritdoc\r\n   *\r\n   * Maps DateValidator to JSON Schema format keywords.\r\n   * Default is `date-time`. If `.toDateOnly()` or `.toTimeOnly()` are used,\r\n   * falls back to `date` or `time` formats respectively.\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.date().toJsonSchema(\"draft-2020-12\")\r\n   * // → { type: \"string\", format: \"date-time\" }\r\n   *\r\n   * v.date().toDateOnly().toJsonSchema(\"draft-2020-12\")\r\n   * // → { type: \"string\", format: \"date\" }\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    const schema: JsonSchemaResult = { type: \"string\", format: \"date-time\" };\r\n\r\n    // Check if an explicit format rule was applied via v.date().format()\r\n    const dateOpts = getRuleOptions(this.rules, \"date\");\r\n    if (dateOpts?.format === \"YYYY-MM-DD\") {\r\n      schema.format = \"date\";\r\n    } else if (dateOpts?.format === \"HH:mm:ss\") {\r\n      schema.format = \"time\";\r\n    }\r\n\r\n    // Transformer-based detection (marker-driven; minifier-safe).\r\n    // toDateOnly/toTimeOnly tag their options bag with __jsonSchemaFormat.\r\n    // toFormat() exposes the user-supplied format string in options.format.\r\n    if (schema.format === \"date-time\") {\r\n      for (const t of this.dataTransformers) {\r\n        const hint = t.options?.__jsonSchemaFormat;\r\n        if (hint === \"date\" || hint === \"time\") {\r\n          schema.format = hint;\r\n          break;\r\n        }\r\n\r\n        const userFormat = t.options?.format;\r\n\r\n        if (userFormat === \"YYYY-MM-DD\") {\r\n          schema.format = \"date\";\r\n          break;\r\n        }\r\n\r\n        if (userFormat === \"HH:mm:ss\") {\r\n          schema.format = \"time\";\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    if (this.isNullable) applyNullable(schema, target);\r\n\r\n    return schema;\r\n  }\r\n}\r\n"],"mappings":"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"}

package/esm/seal/src/validators/discriminated-union-validator.mjs

@@ -0,0 +1,129 @@
+import { applyNullable, wrapNullableStrict } from "../standard-schema/json-schema.mjs";
+import { isPlainObject } from "../../../node_modules/@mongez/supportive-is/esm/index.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+import { LiteralValidator } from "./literal-validator.mjs";
+
+//#region ../seal/src/validators/discriminated-union-validator.ts
+/**
+* Discriminated union validator — routes payloads by a shared discriminator field.
+*
+* Plain `v.union()` falls back to `matchesType()` to pick a branch, which is
+* coarse for object-vs-object unions (every branch matches "is plain object").
+* Discriminated union reads a known field's value and routes directly to the
+* matching branch, producing precise errors instead of confused mash from the
+* wrong branch.
+*
+* **Construction-time validation.** Every branch must:
+* - Be an `ObjectValidator`
+* - Declare the discriminator field
+* - Type the discriminator as `v.literal(...)` (single or multi-literal both work)
+* - Not collide with another branch's literal values
+*
+* Misconfigurations throw eagerly so tests catch them at schema-build time.
+*
+* @example
+* ```ts
+* const email = v.object({ type: v.literal("email"), email: v.string().email() });
+* const sms   = v.object({ type: v.literal("sms"),   phone: v.string() });
+* const push  = v.object({ type: v.literal("push"),  deviceId: v.string() });
+*
+* const notif = v.discriminatedUnion("type", [email, sms, push]);
+*
+* await validate(notif, { type: "sms", phone: "555-1234" });
+* // → routes to sms branch only; errors (if any) come from sms
+* ```
+*
+* @see `domains/seal/plans/2026-05-12-discriminated-union.md`
+*/
+var DiscriminatedUnionValidator = class DiscriminatedUnionValidator extends BaseValidator {
+	discriminator;
+	validators;
+	/** Map from discriminator literal value → matching branch validator. */
+	branches;
+	constructor(discriminator, validators) {
+		super();
+		this.discriminator = discriminator;
+		this.validators = validators;
+		this.branches = DiscriminatedUnionValidator.buildBranchMap(discriminator, validators);
+	}
+	/**
+	* Walk every branch, pull out the discriminator's literal values, and build
+	* the lookup map. Throws on misconfiguration (missing discriminator,
+	* non-literal discriminator, duplicate literal value).
+	*/
+	static buildBranchMap(discriminator, validators) {
+		const map = /* @__PURE__ */ new Map();
+		for (const branch of validators) {
+			const discriminatorValidator = branch.schema?.[discriminator];
+			if (!discriminatorValidator) throw new Error(`[Seal] discriminatedUnion: branch missing discriminator field "${discriminator}"`);
+			if (!(discriminatorValidator instanceof LiteralValidator)) throw new Error(`[Seal] discriminatedUnion: discriminator "${discriminator}" must be v.literal(...) on every branch`);
+			for (const value of discriminatorValidator.values) {
+				if (map.has(value)) throw new Error(`[Seal] discriminatedUnion: duplicate discriminator value "${String(value)}"`);
+				map.set(value, branch);
+			}
+		}
+		return map;
+	}
+	matchesType(value) {
+		return isPlainObject(value);
+	}
+	async validate(data, context) {
+		if (data === null && this.isNullable) return {
+			isValid: true,
+			errors: [],
+			data: null
+		};
+		if (!isPlainObject(data)) return {
+			isValid: false,
+			errors: [{
+				type: "discriminatedUnion",
+				error: `Expected object with discriminator field "${this.discriminator}"`,
+				input: context.key || context.path || "value"
+			}],
+			data: void 0
+		};
+		const discriminatorValue = data[this.discriminator];
+		const branch = this.branches.get(discriminatorValue);
+		if (!branch) {
+			const allowed = [...this.branches.keys()].map((k) => String(k)).join(", ");
+			return {
+				isValid: false,
+				errors: [{
+					type: "discriminatedUnion",
+					error: `Field "${this.discriminator}" must be one of: ${allowed}`,
+					input: this.discriminator
+				}],
+				data: void 0
+			};
+		}
+		return branch.validate(data, context);
+	}
+	clone() {
+		const cloned = super.clone();
+		cloned.discriminator = this.discriminator;
+		cloned.validators = this.validators.map((v) => v.clone());
+		cloned.branches = DiscriminatedUnionValidator.buildBranchMap(cloned.discriminator, cloned.validators);
+		return cloned;
+	}
+	/**
+	* Emit `oneOf` of branch schemas. Each branch's own `toJsonSchema()` handles
+	* its `properties.{discriminator}.const` and the surrounding required/optional
+	* structure — we just enumerate.
+	*
+	* For `openai-strict`: the per-branch ObjectValidator already inflates
+	* `required` to include every field; `oneOf` is OpenAI-accepted as long as
+	* each branch passes strict rules independently.
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		const schema = { oneOf: this.validators.map((v) => v.toJsonSchema(target)) };
+		if (this.isNullable) {
+			if (target === "openai-strict") return wrapNullableStrict(schema);
+			applyNullable(schema, target);
+		}
+		return schema;
+	}
+};
+
+//#endregion
+export { DiscriminatedUnionValidator };
+//# sourceMappingURL=discriminated-union-validator.mjs.map

package/esm/seal/src/validators/discriminated-union-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminated-union-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/discriminated-union-validator.ts"],"sourcesContent":["import { isPlainObject } from \"@mongez/supportive-is\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { applyNullable, wrapNullableStrict } from \"../standard-schema/json-schema\";\nimport type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\nimport { LiteralValidator } from \"./literal-validator\";\nimport { ObjectValidator } from \"./object-validator\";\n\n/**\n * Discriminated union validator — routes payloads by a shared discriminator field.\n *\n * Plain `v.union()` falls back to `matchesType()` to pick a branch, which is\n * coarse for object-vs-object unions (every branch matches \"is plain object\").\n * Discriminated union reads a known field's value and routes directly to the\n * matching branch, producing precise errors instead of confused mash from the\n * wrong branch.\n *\n * **Construction-time validation.** Every branch must:\n * - Be an `ObjectValidator`\n * - Declare the discriminator field\n * - Type the discriminator as `v.literal(...)` (single or multi-literal both work)\n * - Not collide with another branch's literal values\n *\n * Misconfigurations throw eagerly so tests catch them at schema-build time.\n *\n * @example\n * ```ts\n * const email = v.object({ type: v.literal(\"email\"), email: v.string().email() });\n * const sms   = v.object({ type: v.literal(\"sms\"),   phone: v.string() });\n * const push  = v.object({ type: v.literal(\"push\"),  deviceId: v.string() });\n *\n * const notif = v.discriminatedUnion(\"type\", [email, sms, push]);\n *\n * await validate(notif, { type: \"sms\", phone: \"555-1234\" });\n * // → routes to sms branch only; errors (if any) come from sms\n * ```\n *\n * @see `domains/seal/plans/2026-05-12-discriminated-union.md`\n */\nexport class DiscriminatedUnionValidator<\n  K extends string = string,\n  Branches extends ReadonlyArray<ObjectValidator<any>> = ReadonlyArray<ObjectValidator<any>>,\n> extends BaseValidator {\n  /** Map from discriminator literal value → matching branch validator. */\n  private branches: Map<string | number | boolean, ObjectValidator<any>>;\n\n  public constructor(\n    public discriminator: K,\n    public validators: Branches,\n  ) {\n    super();\n\n    this.branches = DiscriminatedUnionValidator.buildBranchMap(discriminator, validators);\n  }\n\n  /**\n   * Walk every branch, pull out the discriminator's literal values, and build\n   * the lookup map. Throws on misconfiguration (missing discriminator,\n   * non-literal discriminator, duplicate literal value).\n   */\n  private static buildBranchMap(\n    discriminator: string,\n    validators: ReadonlyArray<ObjectValidator<any>>,\n  ): Map<string | number | boolean, ObjectValidator<any>> {\n    const map = new Map<string | number | boolean, ObjectValidator<any>>();\n\n    for (const branch of validators) {\n      const discriminatorValidator = branch.schema?.[discriminator];\n\n      if (!discriminatorValidator) {\n        throw new Error(\n          `[Seal] discriminatedUnion: branch missing discriminator field \"${discriminator}\"`,\n        );\n      }\n\n      if (!(discriminatorValidator instanceof LiteralValidator)) {\n        throw new Error(\n          `[Seal] discriminatedUnion: discriminator \"${discriminator}\" must be v.literal(...) on every branch`,\n        );\n      }\n\n      for (const value of discriminatorValidator.values) {\n        if (map.has(value)) {\n          throw new Error(\n            `[Seal] discriminatedUnion: duplicate discriminator value \"${String(value)}\"`,\n          );\n        }\n        map.set(value, branch);\n      }\n    }\n\n    return map;\n  }\n\n  public override matchesType(value: any): boolean {\n    return isPlainObject(value);\n  }\n\n  public override async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    if (data === null && this.isNullable) {\n      return { isValid: true, errors: [], data: null };\n    }\n\n    if (!isPlainObject(data)) {\n      return {\n        isValid: false,\n        errors: [\n          {\n            type: \"discriminatedUnion\",\n            error: `Expected object with discriminator field \"${this.discriminator}\"`,\n            input: context.key || context.path || \"value\",\n          },\n        ],\n        data: undefined,\n      };\n    }\n\n    const discriminatorValue = data[this.discriminator];\n    const branch = this.branches.get(discriminatorValue);\n\n    if (!branch) {\n      const allowed = [...this.branches.keys()].map((k) => String(k)).join(\", \");\n      return {\n        isValid: false,\n        errors: [\n          {\n            type: \"discriminatedUnion\",\n            error: `Field \"${this.discriminator}\" must be one of: ${allowed}`,\n            input: this.discriminator,\n          },\n        ],\n        data: undefined,\n      };\n    }\n\n    return branch.validate(data, context);\n  }\n\n  public override clone(): this {\n    const cloned = super.clone() as any;\n    cloned.discriminator = this.discriminator;\n    cloned.validators = this.validators.map((v: ObjectValidator<any>) => v.clone());\n    cloned.branches = DiscriminatedUnionValidator.buildBranchMap(\n      cloned.discriminator,\n      cloned.validators,\n    );\n    return cloned;\n  }\n\n  /**\n   * Emit `oneOf` of branch schemas. Each branch's own `toJsonSchema()` handles\n   * its `properties.{discriminator}.const` and the surrounding required/optional\n   * structure — we just enumerate.\n   *\n   * For `openai-strict`: the per-branch ObjectValidator already inflates\n   * `required` to include every field; `oneOf` is OpenAI-accepted as long as\n   * each branch passes strict rules independently.\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const oneOf = this.validators.map((v) => v.toJsonSchema(target));\n    const schema: JsonSchemaResult = { oneOf };\n\n    if (this.isNullable) {\n      if (target === \"openai-strict\") {\n        return wrapNullableStrict(schema);\n      }\n      applyNullable(schema, target);\n    }\n\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,8BAAb,MAAa,oCAGH,cAAc;CAKb;CACA;;CAJT,AAAQ;CAER,AAAO,YACL,AAAO,eACP,AAAO,YACP;EACA,MAAM;EAHC;EACA;EAIP,KAAK,WAAW,4BAA4B,eAAe,eAAe,UAAU;CACtF;;;;;;CAOA,OAAe,eACb,eACA,YACsD;EACtD,MAAM,sBAAM,IAAI,IAAqD;EAErE,KAAK,MAAM,UAAU,YAAY;GAC/B,MAAM,yBAAyB,OAAO,SAAS;GAE/C,IAAI,CAAC,wBACH,MAAM,IAAI,MACR,kEAAkE,cAAc,EAClF;GAGF,IAAI,EAAE,kCAAkC,mBACtC,MAAM,IAAI,MACR,6CAA6C,cAAc,yCAC7D;GAGF,KAAK,MAAM,SAAS,uBAAuB,QAAQ;IACjD,IAAI,IAAI,IAAI,KAAK,GACf,MAAM,IAAI,MACR,6DAA6D,OAAO,KAAK,EAAE,EAC7E;IAEF,IAAI,IAAI,OAAO,MAAM;GACvB;EACF;EAEA,OAAO;CACT;CAEA,AAAgB,YAAY,OAAqB;EAC/C,OAAO,cAAc,KAAK;CAC5B;CAEA,MAAsB,SAAS,MAAW,SAAmD;EAC3F,IAAI,SAAS,QAAQ,KAAK,YACxB,OAAO;GAAE,SAAS;GAAM,QAAQ,CAAC;GAAG,MAAM;EAAK;EAGjD,IAAI,CAAC,cAAc,IAAI,GACrB,OAAO;GACL,SAAS;GACT,QAAQ,CACN;IACE,MAAM;IACN,OAAO,6CAA6C,KAAK,cAAc;IACvE,OAAO,QAAQ,OAAO,QAAQ,QAAQ;GACxC,CACF;GACA,MAAM;EACR;EAGF,MAAM,qBAAqB,KAAK,KAAK;EACrC,MAAM,SAAS,KAAK,SAAS,IAAI,kBAAkB;EAEnD,IAAI,CAAC,QAAQ;GACX,MAAM,UAAU,CAAC,GAAG,KAAK,SAAS,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;GACzE,OAAO;IACL,SAAS;IACT,QAAQ,CACN;KACE,MAAM;KACN,OAAO,UAAU,KAAK,cAAc,oBAAoB;KACxD,OAAO,KAAK;IACd,CACF;IACA,MAAM;GACR;EACF;EAEA,OAAO,OAAO,SAAS,MAAM,OAAO;CACtC;CAEA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAC3B,OAAO,gBAAgB,KAAK;EAC5B,OAAO,aAAa,KAAK,WAAW,KAAK,MAA4B,EAAE,MAAM,CAAC;EAC9E,OAAO,WAAW,4BAA4B,eAC5C,OAAO,eACP,OAAO,UACT;EACA,OAAO;CACT;;;;;;;;;;CAWA,AAAgB,aAAa,SAA2B,iBAAmC;EAEzF,MAAM,SAA2B,EAAE,OADrB,KAAK,WAAW,KAAK,MAAM,EAAE,aAAa,MAAM,CACvB,EAAE;EAEzC,IAAI,KAAK,YAAY;GACnB,IAAI,WAAW,iBACb,OAAO,mBAAmB,MAAM;GAElC,cAAc,QAAQ,MAAM;EAC9B;EAEA,OAAO;CACT;AACF"}

package/esm/seal/src/validators/float-validator.mjs

@@ -0,0 +1,18 @@
+import { floatRule } from "../rules/common/type-rules.mjs";
+import "../rules/index.mjs";
+import { NumberValidator } from "./number-validator.mjs";
+
+//#region ../seal/src/validators/float-validator.ts
+/**
+* Float validator class
+*/
+var FloatValidator = class extends NumberValidator {
+	constructor(errorMessage) {
+		super();
+		this.addMutableRule(floatRule, errorMessage);
+	}
+};
+
+//#endregion
+export { FloatValidator };
+//# sourceMappingURL=float-validator.mjs.map

package/esm/seal/src/validators/float-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"float-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/float-validator.ts"],"sourcesContent":["import { floatRule } from \"../rules\";\r\nimport { NumberValidator } from \"./number-validator\";\r\n\r\n/**\r\n * Float validator class\r\n */\r\nexport class FloatValidator extends NumberValidator {\r\n  public constructor(errorMessage?: string) {\r\n    super();\r\n    this.addMutableRule(floatRule, errorMessage);\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;AAMA,IAAa,iBAAb,cAAoC,gBAAgB;CAClD,AAAO,YAAY,cAAuB;EACxC,MAAM;EACN,KAAK,eAAe,WAAW,YAAY;CAC7C;AACF"}

package/esm/seal/src/validators/index.mjs

@@ -0,0 +1,28 @@
+import { BaseValidator } from "./base-validator.mjs";
+import { AnyValidator } from "./any-validator.mjs";
+import { ArrayValidator } from "./array-validator.mjs";
+import "./methods/equality-conditional-methods.mjs";
+import "./methods/forbidden-methods.mjs";
+import "./methods/present-methods.mjs";
+import "./methods/required-methods.mjs";
+import { PrimitiveValidator } from "./primitive-validator.mjs";
+import { BooleanValidator } from "./boolean-validator.mjs";
+import { ComputedValidator } from "./computed-validator.mjs";
+import { DateValidator } from "./date-validator.mjs";
+import { LiteralValidator } from "./literal-validator.mjs";
+import { DiscriminatedUnionValidator } from "./discriminated-union-validator.mjs";
+import { NumberValidator } from "./number-validator.mjs";
+import { FloatValidator } from "./float-validator.mjs";
+import { InstanceOfValidator } from "./instanceof-validator.mjs";
+import { IntValidator } from "./int-validator.mjs";
+import { LazyValidator } from "./lazy-validator.mjs";
+import { ManagedValidator } from "./managed-validator.mjs";
+import { NumericValidator } from "./numeric-validator.mjs";
+import { ObjectValidator } from "./object-validator.mjs";
+import { RecordValidator } from "./record-validator.mjs";
+import { ScalarValidator } from "./scalar-validator.mjs";
+import { StringValidator } from "./string-validator.mjs";
+import { TupleValidator } from "./tuple-validator.mjs";
+import { UnionValidator } from "./union-validator.mjs";
+
+export {  };

package/esm/seal/src/validators/instanceof-validator.mjs

@@ -0,0 +1,64 @@
+import { BaseValidator } from "./base-validator.mjs";
+import { instanceofRule } from "../rules/common/instanceof.mjs";
+
+//#region ../seal/src/validators/instanceof-validator.ts
+/**
+* InstanceOf validator class
+*
+* Validates that the value is an instance of the given constructor (`value instanceof Ctor`).
+* Useful for File uploads, Buffer/Uint8Array payloads, and custom domain classes —
+* anywhere a runtime class identity is the right contract.
+*
+* Note: `Date` is already covered by `v.date()` with richer date-specific rules;
+* reach for `v.instanceof(Date)` only when you specifically want raw `instanceof`
+* semantics with no normalization.
+*
+* @example
+* v.instanceof(File)        // type: File
+* v.instanceof(Buffer)      // type: Buffer
+* v.instanceof(MyClass)     // type: MyClass
+*/
+var InstanceOfValidator = class extends BaseValidator {
+	ctor;
+	constructor(ctor, errorMessage) {
+		super();
+		this.ctor = ctor;
+		this.addMutableRule(instanceofRule, errorMessage, {
+			ctor,
+			name: ctor.name || "instance"
+		});
+	}
+	/**
+	* Check if value is an instance of the configured constructor
+	*/
+	matchesType(value) {
+		return value instanceof this.ctor;
+	}
+	/**
+	* Clone the validator, preserving the target constructor.
+	*
+	* The base `clone()` only copies `BaseValidator` fields, so without this
+	* override a cloned `instanceof` validator loses its `ctor` reference and
+	* `matchesType()` would throw on the next call.
+	*/
+	clone() {
+		const cloned = super.clone();
+		cloned.ctor = this.ctor;
+		return cloned;
+	}
+	/**
+	* @inheritdoc
+	*
+	* Class instances are not representable in JSON Schema — returns an empty
+	* schema (permissive). Consumers serializing to OpenAPI should attach an
+	* appropriate format manually if needed (e.g. `{ type: "string", format: "binary" }`
+	* for `File`).
+	*/
+	toJsonSchema(_target = "draft-2020-12") {
+		return {};
+	}
+};
+
+//#endregion
+export { InstanceOfValidator };
+//# sourceMappingURL=instanceof-validator.mjs.map

package/esm/seal/src/validators/instanceof-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanceof-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/instanceof-validator.ts"],"sourcesContent":["import { instanceofRule } from \"../rules/common/instanceof\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * InstanceOf validator class\n *\n * Validates that the value is an instance of the given constructor (`value instanceof Ctor`).\n * Useful for File uploads, Buffer/Uint8Array payloads, and custom domain classes —\n * anywhere a runtime class identity is the right contract.\n *\n * Note: `Date` is already covered by `v.date()` with richer date-specific rules;\n * reach for `v.instanceof(Date)` only when you specifically want raw `instanceof`\n * semantics with no normalization.\n *\n * @example\n * v.instanceof(File)        // type: File\n * v.instanceof(Buffer)      // type: Buffer\n * v.instanceof(MyClass)     // type: MyClass\n */\nexport class InstanceOfValidator<T = unknown> extends BaseValidator {\n  public ctor: new (...args: any[]) => T;\n\n  public constructor(ctor: new (...args: any[]) => T, errorMessage?: string) {\n    super();\n    this.ctor = ctor;\n    this.addMutableRule(instanceofRule, errorMessage, { ctor, name: ctor.name || \"instance\" });\n  }\n\n  /**\n   * Check if value is an instance of the configured constructor\n   */\n  public matchesType(value: any): boolean {\n    return value instanceof this.ctor;\n  }\n\n  /**\n   * Clone the validator, preserving the target constructor.\n   *\n   * The base `clone()` only copies `BaseValidator` fields, so without this\n   * override a cloned `instanceof` validator loses its `ctor` reference and\n   * `matchesType()` would throw on the next call.\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n    cloned.ctor = this.ctor;\n    return cloned;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Class instances are not representable in JSON Schema — returns an empty\n   * schema (permissive). Consumers serializing to OpenAPI should attach an\n   * appropriate format manually if needed (e.g. `{ type: \"string\", format: \"binary\" }`\n   * for `File`).\n   */\n  public override toJsonSchema(_target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return {};\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,IAAa,sBAAb,cAAsD,cAAc;CAClE,AAAO;CAEP,AAAO,YAAY,MAAiC,cAAuB;EACzE,MAAM;EACN,KAAK,OAAO;EACZ,KAAK,eAAe,gBAAgB,cAAc;GAAE;GAAM,MAAM,KAAK,QAAQ;EAAW,CAAC;CAC3F;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAO,iBAAiB,KAAK;CAC/B;;;;;;;;CASA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAC3B,OAAO,OAAO,KAAK;EACnB,OAAO;CACT;;;;;;;;;CAUA,AAAgB,aAAa,UAA4B,iBAAmC;EAC1F,OAAO,CAAC;CACV;AACF"}

package/esm/seal/src/validators/int-validator.mjs

@@ -0,0 +1,30 @@
+import { intRule } from "../rules/common/type-rules.mjs";
+import "../rules/index.mjs";
+import { NumberValidator } from "./number-validator.mjs";
+
+//#region ../seal/src/validators/int-validator.ts
+/**
+* Integer validator class
+*/
+var IntValidator = class extends NumberValidator {
+	constructor(errorMessage) {
+		super();
+		this.addMutableRule(intRule, errorMessage);
+	}
+	/**
+	* @inheritdoc — returns `{ type: "integer" }` instead of `{ type: "number" }`
+	*
+	* @example
+	* ```ts
+	* v.int().min(1).max(100).toJsonSchema("draft-2020-12")
+	* // → { type: "integer", minimum: 1, maximum: 100 }
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		return this.buildNumberJsonSchema("integer", target);
+	}
+};
+
+//#endregion
+export { IntValidator };
+//# sourceMappingURL=int-validator.mjs.map

package/esm/seal/src/validators/int-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"int-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/int-validator.ts"],"sourcesContent":["import { intRule } from \"../rules\";\r\nimport { NumberValidator } from \"./number-validator\";\r\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\n\r\n/**\r\n * Integer validator class\r\n */\r\nexport class IntValidator extends NumberValidator {\r\n  public constructor(errorMessage?: string) {\r\n    super();\r\n    this.addMutableRule(intRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * @inheritdoc — returns `{ type: \"integer\" }` instead of `{ type: \"number\" }`\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.int().min(1).max(100).toJsonSchema(\"draft-2020-12\")\r\n   * // → { type: \"integer\", minimum: 1, maximum: 100 }\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    return this.buildNumberJsonSchema(\"integer\", target);\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;AAOA,IAAa,eAAb,cAAkC,gBAAgB;CAChD,AAAO,YAAY,cAAuB;EACxC,MAAM;EACN,KAAK,eAAe,SAAS,YAAY;CAC3C;;;;;;;;;;CAWA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,OAAO,KAAK,sBAAsB,WAAW,MAAM;CACrD;AACF"}

package/esm/seal/src/validators/lazy-validator.mjs

@@ -0,0 +1,87 @@
+import { BaseValidator } from "./base-validator.mjs";
+
+//#region ../seal/src/validators/lazy-validator.ts
+/**
+* Lazy validator — defers resolution of the inner validator until validate-time.
+*
+* Solves the chicken-and-egg of self-referencing schemas. JavaScript evaluates
+* an object literal before the `const` binding completes, so this can't work:
+*
+* ```ts
+* const categorySchema = v.object({
+*   name: v.string(),
+*   children: v.array(categorySchema),  // ❌ ReferenceError
+* });
+* ```
+*
+* Wrap the recursive reference in `v.lazy(() => …)` — the thunk isn't invoked
+* during construction, only when `validate()` is called:
+*
+* ```ts
+* type Category = { name: string; children: Category[] };
+*
+* const categorySchema: ObjectValidator<...> = v.object({
+*   name: v.string(),
+*   children: v.array(v.lazy(() => categorySchema)),
+* });
+*
+* type T = Infer<typeof categorySchema>;
+* // { name: string; children: T[] }   ← recursive type
+* ```
+*
+* The thunk is memoized — it's invoked once on the first validate (or
+* `matchesType` / `toJsonSchema`) call and the result is cached. The thunk is
+* expected to return a stable validator; calling it on every validate would be
+* wasteful and could mask bugs where the user accidentally returns a fresh
+* validator each time.
+*
+* **JSON Schema caveat.** v1 uses simple resolve-and-delegate — recursive
+* schemas will infinite-loop in `toJsonSchema()`. If you need JSON Schema for
+* a recursive shape, generate it manually with `$defs` + `$ref` until v2 lands.
+*
+* @see `domains/seal/plans/2026-05-12-lazy-validator.md`
+*/
+var LazyValidator = class extends BaseValidator {
+	thunk;
+	resolvedValidator;
+	constructor(thunk) {
+		super();
+		this.thunk = thunk;
+		this.requiredRule = null;
+		this.isOptional = true;
+	}
+	/**
+	* Resolve the inner validator. Memoizes the result so subsequent calls
+	* don't re-execute the thunk.
+	*/
+	resolve() {
+		if (this.resolvedValidator === void 0) this.resolvedValidator = this.thunk();
+		return this.resolvedValidator;
+	}
+	async validate(data, context) {
+		return this.resolve().validate(data, context);
+	}
+	matchesType(value) {
+		return this.resolve().matchesType(value);
+	}
+	clone() {
+		const cloned = super.clone();
+		cloned.thunk = this.thunk;
+		cloned.resolvedValidator = void 0;
+		return cloned;
+	}
+	/**
+	* JSON Schema generation — simple resolve-and-delegate.
+	*
+	* **Recursive schemas will infinite-loop.** Until v2 adds `$ref` + `$defs`
+	* generation, callers needing JSON Schema for recursive shapes must build
+	* the schema manually.
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		return this.resolve().toJsonSchema(target);
+	}
+};
+
+//#endregion
+export { LazyValidator };
+//# sourceMappingURL=lazy-validator.mjs.map

package/esm/seal/src/validators/lazy-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/lazy-validator.ts"],"sourcesContent":["import type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Lazy validator — defers resolution of the inner validator until validate-time.\n *\n * Solves the chicken-and-egg of self-referencing schemas. JavaScript evaluates\n * an object literal before the `const` binding completes, so this can't work:\n *\n * ```ts\n * const categorySchema = v.object({\n *   name: v.string(),\n *   children: v.array(categorySchema),  // ❌ ReferenceError\n * });\n * ```\n *\n * Wrap the recursive reference in `v.lazy(() => …)` — the thunk isn't invoked\n * during construction, only when `validate()` is called:\n *\n * ```ts\n * type Category = { name: string; children: Category[] };\n *\n * const categorySchema: ObjectValidator<...> = v.object({\n *   name: v.string(),\n *   children: v.array(v.lazy(() => categorySchema)),\n * });\n *\n * type T = Infer<typeof categorySchema>;\n * // { name: string; children: T[] }   ← recursive type\n * ```\n *\n * The thunk is memoized — it's invoked once on the first validate (or\n * `matchesType` / `toJsonSchema`) call and the result is cached. The thunk is\n * expected to return a stable validator; calling it on every validate would be\n * wasteful and could mask bugs where the user accidentally returns a fresh\n * validator each time.\n *\n * **JSON Schema caveat.** v1 uses simple resolve-and-delegate — recursive\n * schemas will infinite-loop in `toJsonSchema()`. If you need JSON Schema for\n * a recursive shape, generate it manually with `$defs` + `$ref` until v2 lands.\n *\n * @see `domains/seal/plans/2026-05-12-lazy-validator.md`\n */\nexport class LazyValidator<T extends BaseValidator = BaseValidator> extends BaseValidator {\n  private resolvedValidator: T | undefined;\n\n  public constructor(private thunk: () => T) {\n    super();\n    // Lazy itself defers required handling to the inner validator —\n    // mark the wrapper as optional so the required check doesn't fire here.\n    this.requiredRule = null;\n    this.isOptional = true;\n  }\n\n  /**\n   * Resolve the inner validator. Memoizes the result so subsequent calls\n   * don't re-execute the thunk.\n   */\n  private resolve(): T {\n    if (this.resolvedValidator === undefined) {\n      this.resolvedValidator = this.thunk();\n    }\n\n    return this.resolvedValidator;\n  }\n\n  public override async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    return this.resolve().validate(data, context);\n  }\n\n  public override matchesType(value: any): boolean {\n    return this.resolve().matchesType(value);\n  }\n\n  public override clone(): this {\n    const cloned = super.clone();\n    // Share the thunk reference; reset the memo so the clone resolves\n    // independently on its first call (in case the thunk closure resolves\n    // differently in a different context — unlikely but cheap insurance).\n    cloned.thunk = this.thunk;\n    cloned.resolvedValidator = undefined;\n\n    return cloned;\n  }\n\n  /**\n   * JSON Schema generation — simple resolve-and-delegate.\n   *\n   * **Recursive schemas will infinite-loop.** Until v2 adds `$ref` + `$defs`\n   * generation, callers needing JSON Schema for recursive shapes must build\n   * the schema manually.\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return this.resolve().toJsonSchema(target);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,gBAAb,cAA4E,cAAc;CAG7D;CAF3B,AAAQ;CAER,AAAO,YAAY,AAAQ,OAAgB;EACzC,MAAM;EADmB;EAIzB,KAAK,eAAe;EACpB,KAAK,aAAa;CACpB;;;;;CAMA,AAAQ,UAAa;EACnB,IAAI,KAAK,sBAAsB,QAC7B,KAAK,oBAAoB,KAAK,MAAM;EAGtC,OAAO,KAAK;CACd;CAEA,MAAsB,SAAS,MAAW,SAAmD;EAC3F,OAAO,KAAK,QAAQ,CAAC,CAAC,SAAS,MAAM,OAAO;CAC9C;CAEA,AAAgB,YAAY,OAAqB;EAC/C,OAAO,KAAK,QAAQ,CAAC,CAAC,YAAY,KAAK;CACzC;CAEA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAI3B,OAAO,QAAQ,KAAK;EACpB,OAAO,oBAAoB;EAE3B,OAAO;CACT;;;;;;;;CASA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,OAAO,KAAK,QAAQ,CAAC,CAAC,aAAa,MAAM;CAC3C;AACF"}

package/esm/seal/src/validators/literal-validator.mjs

@@ -0,0 +1,71 @@
+import { applyNullable } from "../standard-schema/json-schema.mjs";
+import { isEmptyValue } from "../helpers/is-empty-value.mjs";
+import { presentRule } from "../rules/core/required.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+import { literalRule } from "../rules/common/literal.mjs";
+
+//#region ../seal/src/validators/literal-validator.ts
+/**
+* Literal validator class
+*
+* Accepts a fixed tuple of primitive literal values (string, number, boolean).
+* The TypeScript type narrows to the union of those literals — `v.literal("a", "b")`
+* infers as `"a" | "b"`, not `string`. Use for discriminator fields, enum-like
+* unions of constants, and any case where `oneOf([...])` would lose literal types.
+*
+* @example
+* v.literal("items")               // type: "items"
+* v.literal("draft", "published")  // type: "draft" | "published"
+* v.literal(1, 2, 3)               // type: 1 | 2 | 3
+* v.literal(true)                  // type: true
+*/
+var LiteralValidator = class extends BaseValidator {
+	values;
+	constructor(values, errorMessage) {
+		super();
+		this.values = values;
+		this.addMutableRule(literalRule, errorMessage, { values });
+		if (values.some((value) => isEmptyValue(value))) this.requiredRule = this.createRule(presentRule);
+	}
+	/**
+	* Check if value is one of the configured literals
+	*/
+	matchesType(value) {
+		return this.values.includes(value);
+	}
+	/**
+	* Clone the validator, preserving the literal `values` set.
+	*
+	* The base `clone()` only copies `BaseValidator` fields, so without this
+	* override a cloned literal loses its public `values` array — which breaks
+	* any consumer that reads it (e.g. `discriminatedUnion` branch routing).
+	*/
+	clone() {
+		const cloned = super.clone();
+		cloned.values = this.values;
+		return cloned;
+	}
+	/**
+	* @inheritdoc
+	*
+	* Single literal → `{ const: <value> }`. Multiple → `{ enum: [...] }`.
+	*
+	* @example
+	* ```ts
+	* v.literal("items").toJsonSchema()
+	* // → { const: "items" }
+	*
+	* v.literal("draft", "published").toJsonSchema()
+	* // → { enum: ["draft", "published"] }
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		const schema = this.values.length === 1 ? { const: this.values[0] } : { enum: [...this.values] };
+		if (this.isNullable) applyNullable(schema, target);
+		return schema;
+	}
+};
+
+//#endregion
+export { LiteralValidator };
+//# sourceMappingURL=literal-validator.mjs.map

package/esm/seal/src/validators/literal-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/literal-validator.ts"],"sourcesContent":["import { isEmptyValue } from \"../helpers/is-empty-value\";\nimport { literalRule } from \"../rules/common/literal\";\nimport { presentRule } from \"../rules/core/required\";\nimport { applyNullable } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Literal validator class\n *\n * Accepts a fixed tuple of primitive literal values (string, number, boolean).\n * The TypeScript type narrows to the union of those literals — `v.literal(\"a\", \"b\")`\n * infers as `\"a\" | \"b\"`, not `string`. Use for discriminator fields, enum-like\n * unions of constants, and any case where `oneOf([...])` would lose literal types.\n *\n * @example\n * v.literal(\"items\")               // type: \"items\"\n * v.literal(\"draft\", \"published\")  // type: \"draft\" | \"published\"\n * v.literal(1, 2, 3)               // type: 1 | 2 | 3\n * v.literal(true)                  // type: true\n */\nexport class LiteralValidator<\n  T extends readonly (string | number | boolean)[] = readonly (string | number | boolean)[],\n> extends BaseValidator {\n  public values: T;\n\n  public constructor(values: T, errorMessage?: string) {\n    super();\n    this.values = values;\n    this.addMutableRule(literalRule, errorMessage, { values });\n\n    // `\"\"` is a value, not an absence. Every validator is required by default,\n    // and `required` rejects anything `isEmptyValue` calls empty — including the\n    // empty string — so `v.literal(\"\")` could never pass. When the author has\n    // explicitly listed an empty value as acceptable, swap `required` for\n    // `present`: the key must still exist, but judging the value is the literal\n    // set's job, and it is already the stricter statement of intent.\n    //\n    // Dropping the rule entirely instead would make a missing key valid, which\n    // is the opposite mistake — `alt=\"\"` and no `alt` at all are different\n    // things to a screen reader, and to anything else reading the schema.\n    if (values.some(value => isEmptyValue(value))) {\n      this.requiredRule = this.createRule(presentRule);\n    }\n  }\n\n  /**\n   * Check if value is one of the configured literals\n   */\n  public matchesType(value: any): boolean {\n    return (this.values as readonly any[]).includes(value);\n  }\n\n  /**\n   * Clone the validator, preserving the literal `values` set.\n   *\n   * The base `clone()` only copies `BaseValidator` fields, so without this\n   * override a cloned literal loses its public `values` array — which breaks\n   * any consumer that reads it (e.g. `discriminatedUnion` branch routing).\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n    cloned.values = this.values;\n    return cloned;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Single literal → `{ const: <value> }`. Multiple → `{ enum: [...] }`.\n   *\n   * @example\n   * ```ts\n   * v.literal(\"items\").toJsonSchema()\n   * // → { const: \"items\" }\n   *\n   * v.literal(\"draft\", \"published\").toJsonSchema()\n   * // → { enum: [\"draft\", \"published\"] }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult =\n      this.values.length === 1 ? { const: this.values[0] } : { enum: [...this.values] };\n    if (this.isNullable) applyNullable(schema, target);\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,mBAAb,cAEU,cAAc;CACtB,AAAO;CAEP,AAAO,YAAY,QAAW,cAAuB;EACnD,MAAM;EACN,KAAK,SAAS;EACd,KAAK,eAAe,aAAa,cAAc,EAAE,OAAO,CAAC;EAYzD,IAAI,OAAO,MAAK,UAAS,aAAa,KAAK,CAAC,GAC1C,KAAK,eAAe,KAAK,WAAW,WAAW;CAEnD;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAQ,KAAK,OAA0B,SAAS,KAAK;CACvD;;;;;;;;CASA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAC3B,OAAO,SAAS,KAAK;EACrB,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SACJ,KAAK,OAAO,WAAW,IAAI,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,EAAE,MAAM,CAAC,GAAG,KAAK,MAAM,EAAE;EAClF,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}

package/esm/seal/src/validators/managed-validator.mjs

@@ -0,0 +1,39 @@
+import { ComputedValidator } from "./computed-validator.mjs";
+
+//#region ../seal/src/validators/managed-validator.ts
+/**
+* Managed field validator
+*
+* The callback is optional - if not provided, the framework can inject the value.
+* @example
+* ```ts
+* // With callback (framework executes it)
+* const schema = v.object({
+*   name: v.string(),
+*   createdAt: v.managed(() => new Date()),
+*   updatedAt: v.managed(() => new Date()),
+* });
+*
+* // Without callback (framework injects value)
+* const schema = v.object({
+*   name: v.string(),
+*   id: v.managed(() => 1),
+* });
+* ```
+*/
+var ManagedValidator = class extends ComputedValidator {
+	/**
+	* Create a new managed field validator
+	*
+	* @param callback - Optional function to generate the value
+	* @param resultValidator - Optional validator to validate the generated result
+	*/
+	constructor(callback, resultValidator) {
+		const computedCallback = (_data, context) => callback(context);
+		super(computedCallback, resultValidator);
+	}
+};
+
+//#endregion
+export { ManagedValidator };
+//# sourceMappingURL=managed-validator.mjs.map

package/esm/seal/src/validators/managed-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/managed-validator.ts"],"sourcesContent":["import type { SchemaContext } from \"../types\";\nimport type { BaseValidator } from \"./base-validator\";\nimport { ComputedValidator, type ComputedCallback } from \"./computed-validator\";\n\n/**\n * Callback function for managed fields\n * Receives only schema context (no data dependency)\n */\nexport type ManagedCallback<TResult = any> = (context: SchemaContext) => TResult | Promise<TResult>;\n\n/**\n * Managed field validator\n *\n * The callback is optional - if not provided, the framework can inject the value.\n * @example\n * ```ts\n * // With callback (framework executes it)\n * const schema = v.object({\n *   name: v.string(),\n *   createdAt: v.managed(() => new Date()),\n *   updatedAt: v.managed(() => new Date()),\n * });\n *\n * // Without callback (framework injects value)\n * const schema = v.object({\n *   name: v.string(),\n *   id: v.managed(() => 1),\n * });\n * ```\n */\nexport class ManagedValidator<TResult = any> extends ComputedValidator<TResult> {\n  /**\n   * Create a new managed field validator\n   *\n   * @param callback - Optional function to generate the value\n   * @param resultValidator - Optional validator to validate the generated result\n   */\n  constructor(callback: ManagedCallback<TResult>, resultValidator?: BaseValidator) {\n    // Convert ManagedCallback to ComputedCallback\n    // Managed callbacks don't receive data, only context\n    const computedCallback: ComputedCallback<TResult> = (_data, context) => callback(context);\n\n    super(computedCallback, resultValidator);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,mBAAb,cAAqD,kBAA2B;;;;;;;CAO9E,YAAY,UAAoC,iBAAiC;EAG/E,MAAM,oBAA+C,OAAO,YAAY,SAAS,OAAO;EAExF,MAAM,kBAAkB,eAAe;CACzC;AACF"}