@warlock.js/seal 5.10.0 → 5.12.0

package/esm/index.d.mts

@@ -87,7 +87,7 @@ import { getFieldValue } from "./helpers/get-field-value.mjs";
 import { setKeyPath } from "./helpers/path-helpers.mjs";
 import { VALID_RULE, invalidRule, resolveTranslation } from "./helpers/validation-helpers.mjs";
 import { flipArrayMutator, removeEmptyArrayElementsMutator, reverseArrayMutator, sortArrayMutator, uniqueArrayMutator } from "./mutators/array-mutators.mjs";
-import { booleanCoerceMutator } from "./mutators/boolean-mutators.mjs";
+import { booleanCoerceMutator, formBooleanMutator } from "./mutators/boolean-mutators.mjs";
 import { addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, dateMutator, toDateOnlyMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toFormatMutator, toISOStringMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toTimeOnlyMutator, toTimestampMutator, toUTCMutator } from "./mutators/date-mutators.mjs";
 import { absMutator, booleanMutator, ceilMutator, floorMutator, numberMutator, numericMutator, roundMutator, roundNumberMutator, toFixedMutator } from "./mutators/number-mutators.mjs";
 import { jsonMutator, objectTrimMutator, stripUnknownMutator } from "./mutators/object-mutators.mjs";
@@ -98,7 +98,7 @@ import { ValidateOptions, ValidatorV, v } from "./factory/validators.mjs";
 import { validate } from "./factory/validate.mjs";
 import { PluginContext, SealPlugin, getInstalledPlugins, hasPlugin, registerPlugin, unregisterPlugin } from "./plugins/plugin-system.mjs";
 import { mapToStandardResult } from "./standard-schema/map-result.mjs";
-export { AnyValidator, ArrayValidator, AttributeTranslation, BaseValidator, BooleanValidator, ComputedCallback, ComputedValidator, ContextualSchemaRule, ContextualizedMutator, ContextualizedTransformer, DateValidator, DiscriminatedUnionValidator, FileSizeOption, FloatValidator, Infer, InferInput, InferInputObjectShape, InferObjectShape, InferOutput, InferOutputObjectShape, InstanceOfValidator, IntValidator, IsInputOptionalKey, IsOptionalKey, IsOutputOptionalKey, JsonSchemaResult, JsonSchemaTarget, LazyValidator, LiteralValidator, ManagedCallback, ManagedValidator, Month, Mutator, MutatorContext, NumberValidator, NumericValidator, ObjectValidator, PluginContext, PrimitiveValidator, RecordValidator, RuleResult, RuleTranslation, ScalarValidator, Schema, SchemaContext, SchemaRule, SchemaRuleOptions, SealConfig, SealPlugin, SimpleTransformerCallback, StandardJSONSchemaV1, StandardSchemaV1, StringValidator, TransformerCallback, TranslateAttributeCallback, TranslateRuleCallback, TupleValidator, UUIDVersion, UnionValidator, VALID_RULE, ValidateOptions, ValidationAttributesList, ValidationResult, ValidatorV, WEEK_DAYS, WeekDay, WhenRuleOptions, absMutator, addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, afterFieldRule, afterTodayRule, ageRule, allowedValuesRule, alphaNumericRule, alphaOnlyMutator, alphaRule, alphanumericOnlyMutator, appendMutator, applyNullable, arrayRule, base64DecodeMutator, base64EncodeMutator, beforeFieldRule, beforeHourRule, beforeMinuteRule, beforeTodayRule, betweenAgeRule, betweenDatesRule, betweenDaysRule, betweenHoursRule, betweenLengthRule, betweenMinutesRule, betweenMonthsRule, betweenNumbersRule, betweenTimesRule, betweenYearsRule, birthdayRule, booleanCoerceMutator, booleanMutator, booleanRule, businessDayRule, camelCaseMutator, capitalizeMutator, ceilMutator, colorRule, configureSeal, containsRule, cuidRule, darkColorRule, dateMutator, dateRule, emailRule, endsWithRule, enumRule, equalRule, equalityConditionalMethodsApplied, equalsFieldRule, evenRule, flipArrayMutator, floatRule, floorMutator, forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule, forbiddenMethodsApplied, forbiddenRule, fromHourRule, fromMinuteRule, fromTodayRule, futureRule, getFieldValue, getInstalledPlugins, getRuleOptions, getSealConfig, greaterThanRule, hasPlugin, hexColorRule, hslColorRule, htmlEscapeMutator, humanizeSize, inRule, instanceofRule, intRule, invalidRule, ip4Rule, ip6Rule, ipRule, isCreditCardRule, isDateValue, isIP, isIPv4, isIPv6, isNumericRule, jsonMutator, kebabCaseMutator, leapYearRule, lengthRule, lessThanRule, lightColorRule, literalRule, lowercaseMutator, ltrimMutator, mapToStandardResult, maskMutator, matchesRule, maxAgeRule, maxDateRule, maxDayRule, maxFileSizeRule, maxHeightRule, maxLengthRule, maxMonthRule, maxRule, maxWidthRule, maxWordsRule, maxYearRule, minAgeRule, minDateRule, minDayRule, minFileSizeRule, minHeightRule, minLengthRule, minMonthRule, minRule, minWidthRule, minWordsRule, minYearRule, moduloRule, monthRule, nanoidRule, negativeRule, notAllowedValuesRule, notContainsRule, notEqualsFieldRule, numberMutator, numberRule, numericMutator, objectRule, objectTrimMutator, oddRule, padEndMutator, padStartMutator, pascalCaseMutator, pastRule, patternRule, plainObjectRule, positiveRule, prependMutator, presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule, presentMethodsApplied, presentRule, presentUnlessRule, presentWithAllRule, presentWithAnyRule, presentWithRule, presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule, quarterRule, registerPlugin, removeEmptyArrayElementsMutator, removeNumbersMutator, removeSpecialCharactersMutator, repeatMutator, replaceAllMutator, replaceMutator, requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule, requiredMethodsApplied, requiredRule, requiredUnlessRule, requiredWhenRule, requiredWithAllRule, requiredWithAnyRule, requiredWithRule, requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule, resetSealConfig, resolveFileSize, resolveTranslation, reverseArrayMutator, reverseMutator, rgbColorRule, rgbaColorRule, roundMutator, roundNumberMutator, rtrimMutator, safeHtmlMutator, sameAsFieldDateRule, scalarRule, setKeyPath, slugMutator, snakeCaseMutator, sortArrayMutator, sortedArrayRule, startsWithRule, stringMutator, stringRule, stringifyMutator, stripTagsMutator, stripUnknownMutator, strongPasswordRule, titleCaseMutator, toDateOnlyMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toFixedMutator, toFormatMutator, toISOStringMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toTimeOnlyMutator, toTimestampMutator, toUTCMutator, todayRule, trimMultipleWhitespaceMutator, trimMutator, truncateMutator, ulidRule, unescapeHtmlMutator, unionRule, uniqueArrayMutator, uniqueArrayRule, unknownKeyRule, unregisterPlugin, uppercaseMutator, urlDecodeMutator, urlEncodeMutator, urlRule, uuidRule, v, validate, weekDayRule, weekdayRule, weekdaysRule, weekendRule, whenRule, withinDaysRule, withinFutureDaysRule, withinPastDaysRule, withoutWhitespaceRule, wordsRule, wrapNullableStrict, yearRule };
+export { AnyValidator, ArrayValidator, AttributeTranslation, BaseValidator, BooleanValidator, ComputedCallback, ComputedValidator, ContextualSchemaRule, ContextualizedMutator, ContextualizedTransformer, DateValidator, DiscriminatedUnionValidator, FileSizeOption, FloatValidator, Infer, InferInput, InferInputObjectShape, InferObjectShape, InferOutput, InferOutputObjectShape, InstanceOfValidator, IntValidator, IsInputOptionalKey, IsOptionalKey, IsOutputOptionalKey, JsonSchemaResult, JsonSchemaTarget, LazyValidator, LiteralValidator, ManagedCallback, ManagedValidator, Month, Mutator, MutatorContext, NumberValidator, NumericValidator, ObjectValidator, PluginContext, PrimitiveValidator, RecordValidator, RuleResult, RuleTranslation, ScalarValidator, Schema, SchemaContext, SchemaRule, SchemaRuleOptions, SealConfig, SealPlugin, SimpleTransformerCallback, StandardJSONSchemaV1, StandardSchemaV1, StringValidator, TransformerCallback, TranslateAttributeCallback, TranslateRuleCallback, TupleValidator, UUIDVersion, UnionValidator, VALID_RULE, ValidateOptions, ValidationAttributesList, ValidationResult, ValidatorV, WEEK_DAYS, WeekDay, WhenRuleOptions, absMutator, addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, afterFieldRule, afterTodayRule, ageRule, allowedValuesRule, alphaNumericRule, alphaOnlyMutator, alphaRule, alphanumericOnlyMutator, appendMutator, applyNullable, arrayRule, base64DecodeMutator, base64EncodeMutator, beforeFieldRule, beforeHourRule, beforeMinuteRule, beforeTodayRule, betweenAgeRule, betweenDatesRule, betweenDaysRule, betweenHoursRule, betweenLengthRule, betweenMinutesRule, betweenMonthsRule, betweenNumbersRule, betweenTimesRule, betweenYearsRule, birthdayRule, booleanCoerceMutator, booleanMutator, booleanRule, businessDayRule, camelCaseMutator, capitalizeMutator, ceilMutator, colorRule, configureSeal, containsRule, cuidRule, darkColorRule, dateMutator, dateRule, emailRule, endsWithRule, enumRule, equalRule, equalityConditionalMethodsApplied, equalsFieldRule, evenRule, flipArrayMutator, floatRule, floorMutator, forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule, forbiddenMethodsApplied, forbiddenRule, formBooleanMutator, fromHourRule, fromMinuteRule, fromTodayRule, futureRule, getFieldValue, getInstalledPlugins, getRuleOptions, getSealConfig, greaterThanRule, hasPlugin, hexColorRule, hslColorRule, htmlEscapeMutator, humanizeSize, inRule, instanceofRule, intRule, invalidRule, ip4Rule, ip6Rule, ipRule, isCreditCardRule, isDateValue, isIP, isIPv4, isIPv6, isNumericRule, jsonMutator, kebabCaseMutator, leapYearRule, lengthRule, lessThanRule, lightColorRule, literalRule, lowercaseMutator, ltrimMutator, mapToStandardResult, maskMutator, matchesRule, maxAgeRule, maxDateRule, maxDayRule, maxFileSizeRule, maxHeightRule, maxLengthRule, maxMonthRule, maxRule, maxWidthRule, maxWordsRule, maxYearRule, minAgeRule, minDateRule, minDayRule, minFileSizeRule, minHeightRule, minLengthRule, minMonthRule, minRule, minWidthRule, minWordsRule, minYearRule, moduloRule, monthRule, nanoidRule, negativeRule, notAllowedValuesRule, notContainsRule, notEqualsFieldRule, numberMutator, numberRule, numericMutator, objectRule, objectTrimMutator, oddRule, padEndMutator, padStartMutator, pascalCaseMutator, pastRule, patternRule, plainObjectRule, positiveRule, prependMutator, presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule, presentMethodsApplied, presentRule, presentUnlessRule, presentWithAllRule, presentWithAnyRule, presentWithRule, presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule, quarterRule, registerPlugin, removeEmptyArrayElementsMutator, removeNumbersMutator, removeSpecialCharactersMutator, repeatMutator, replaceAllMutator, replaceMutator, requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule, requiredMethodsApplied, requiredRule, requiredUnlessRule, requiredWhenRule, requiredWithAllRule, requiredWithAnyRule, requiredWithRule, requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule, resetSealConfig, resolveFileSize, resolveTranslation, reverseArrayMutator, reverseMutator, rgbColorRule, rgbaColorRule, roundMutator, roundNumberMutator, rtrimMutator, safeHtmlMutator, sameAsFieldDateRule, scalarRule, setKeyPath, slugMutator, snakeCaseMutator, sortArrayMutator, sortedArrayRule, startsWithRule, stringMutator, stringRule, stringifyMutator, stripTagsMutator, stripUnknownMutator, strongPasswordRule, titleCaseMutator, toDateOnlyMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toFixedMutator, toFormatMutator, toISOStringMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toTimeOnlyMutator, toTimestampMutator, toUTCMutator, todayRule, trimMultipleWhitespaceMutator, trimMutator, truncateMutator, ulidRule, unescapeHtmlMutator, unionRule, uniqueArrayMutator, uniqueArrayRule, unknownKeyRule, unregisterPlugin, uppercaseMutator, urlDecodeMutator, urlEncodeMutator, urlRule, uuidRule, v, validate, weekDayRule, weekdayRule, weekdaysRule, weekendRule, whenRule, withinDaysRule, withinFutureDaysRule, withinPastDaysRule, withoutWhitespaceRule, wordsRule, wrapNullableStrict, yearRule };
 import "./validators/methods/equality-conditional-methods.mjs";
 import "./validators/methods/forbidden-methods.mjs";
 import "./validators/methods/present-methods.mjs";

package/esm/index.mjs

@@ -12,7 +12,7 @@ import { mapToStandardResult } from "./standard-schema/map-result.mjs";
 import { BaseValidator } from "./validators/base-validator.mjs";
 import { AnyValidator } from "./validators/any-validator.mjs";
 import { flipArrayMutator, removeEmptyArrayElementsMutator, reverseArrayMutator, sortArrayMutator, uniqueArrayMutator } from "./mutators/array-mutators.mjs";
-import { booleanCoerceMutator } from "./mutators/boolean-mutators.mjs";
+import { booleanCoerceMutator, formBooleanMutator } from "./mutators/boolean-mutators.mjs";
 import { addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, dateMutator, toDateOnlyMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toFormatMutator, toISOStringMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toTimeOnlyMutator, toTimestampMutator, toUTCMutator } from "./mutators/date-mutators.mjs";
 import { absMutator, booleanMutator, ceilMutator, floorMutator, numberMutator, numericMutator, roundMutator, roundNumberMutator, toFixedMutator } from "./mutators/number-mutators.mjs";
 import { jsonMutator, objectTrimMutator, stripUnknownMutator } from "./mutators/object-mutators.mjs";
@@ -94,4 +94,4 @@ import { v } from "./factory/validators.mjs";
 import "./factory/index.mjs";
 import { getInstalledPlugins, hasPlugin, registerPlugin, unregisterPlugin } from "./plugins/plugin-system.mjs";
 
-export { AnyValidator, ArrayValidator, BaseValidator, BooleanValidator, ComputedValidator, DateValidator, DiscriminatedUnionValidator, FloatValidator, InstanceOfValidator, IntValidator, LazyValidator, LiteralValidator, ManagedValidator, NumberValidator, NumericValidator, ObjectValidator, PrimitiveValidator, RecordValidator, ScalarValidator, StringValidator, TupleValidator, UnionValidator, VALID_RULE, WEEK_DAYS, absMutator, addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, afterFieldRule, afterTodayRule, ageRule, allowedValuesRule, alphaNumericRule, alphaOnlyMutator, alphaRule, alphanumericOnlyMutator, appendMutator, applyNullable, arrayRule, base64DecodeMutator, base64EncodeMutator, beforeFieldRule, beforeHourRule, beforeMinuteRule, beforeTodayRule, betweenAgeRule, betweenDatesRule, betweenDaysRule, betweenHoursRule, betweenLengthRule, betweenMinutesRule, betweenMonthsRule, betweenNumbersRule, betweenTimesRule, betweenYearsRule, birthdayRule, booleanCoerceMutator, booleanMutator, booleanRule, businessDayRule, camelCaseMutator, capitalizeMutator, ceilMutator, colorRule, configureSeal, containsRule, cuidRule, darkColorRule, dateMutator, dateRule, emailRule, endsWithRule, enumRule, equalRule, equalityConditionalMethodsApplied, equalsFieldRule, evenRule, flipArrayMutator, floatRule, floorMutator, forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule, forbiddenMethodsApplied, forbiddenRule, fromHourRule, fromMinuteRule, fromTodayRule, futureRule, getFieldValue, getInstalledPlugins, getRuleOptions, getSealConfig, greaterThanRule, hasPlugin, hexColorRule, hslColorRule, htmlEscapeMutator, humanizeSize, inRule, instanceofRule, intRule, invalidRule, ip4Rule, ip6Rule, ipRule, isCreditCardRule, isDateValue, isIP, isIPv4, isIPv6, isNumericRule, jsonMutator, kebabCaseMutator, leapYearRule, lengthRule, lessThanRule, lightColorRule, literalRule, lowercaseMutator, ltrimMutator, mapToStandardResult, maskMutator, matchesRule, maxAgeRule, maxDateRule, maxDayRule, maxFileSizeRule, maxHeightRule, maxLengthRule, maxMonthRule, maxRule, maxWidthRule, maxWordsRule, maxYearRule, minAgeRule, minDateRule, minDayRule, minFileSizeRule, minHeightRule, minLengthRule, minMonthRule, minRule, minWidthRule, minWordsRule, minYearRule, moduloRule, monthRule, nanoidRule, negativeRule, notAllowedValuesRule, notContainsRule, notEqualsFieldRule, numberMutator, numberRule, numericMutator, objectRule, objectTrimMutator, oddRule, padEndMutator, padStartMutator, pascalCaseMutator, pastRule, patternRule, plainObjectRule, positiveRule, prependMutator, presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule, presentMethodsApplied, presentRule, presentUnlessRule, presentWithAllRule, presentWithAnyRule, presentWithRule, presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule, quarterRule, registerPlugin, removeEmptyArrayElementsMutator, removeNumbersMutator, removeSpecialCharactersMutator, repeatMutator, replaceAllMutator, replaceMutator, requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule, requiredMethodsApplied, requiredRule, requiredUnlessRule, requiredWhenRule, requiredWithAllRule, requiredWithAnyRule, requiredWithRule, requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule, resetSealConfig, resolveFileSize, resolveTranslation, reverseArrayMutator, reverseMutator, rgbColorRule, rgbaColorRule, roundMutator, roundNumberMutator, rtrimMutator, safeHtmlMutator, sameAsFieldDateRule, scalarRule, setKeyPath, slugMutator, snakeCaseMutator, sortArrayMutator, sortedArrayRule, startsWithRule, stringMutator, stringRule, stringifyMutator, stripTagsMutator, stripUnknownMutator, strongPasswordRule, titleCaseMutator, toDateOnlyMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toFixedMutator, toFormatMutator, toISOStringMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toTimeOnlyMutator, toTimestampMutator, toUTCMutator, todayRule, trimMultipleWhitespaceMutator, trimMutator, truncateMutator, ulidRule, unescapeHtmlMutator, unionRule, uniqueArrayMutator, uniqueArrayRule, unknownKeyRule, unregisterPlugin, uppercaseMutator, urlDecodeMutator, urlEncodeMutator, urlRule, uuidRule, v, validate, weekDayRule, weekdayRule, weekdaysRule, weekendRule, whenRule, withinDaysRule, withinFutureDaysRule, withinPastDaysRule, withoutWhitespaceRule, wordsRule, wrapNullableStrict, yearRule };
+export { AnyValidator, ArrayValidator, BaseValidator, BooleanValidator, ComputedValidator, DateValidator, DiscriminatedUnionValidator, FloatValidator, InstanceOfValidator, IntValidator, LazyValidator, LiteralValidator, ManagedValidator, NumberValidator, NumericValidator, ObjectValidator, PrimitiveValidator, RecordValidator, ScalarValidator, StringValidator, TupleValidator, UnionValidator, VALID_RULE, WEEK_DAYS, absMutator, addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, afterFieldRule, afterTodayRule, ageRule, allowedValuesRule, alphaNumericRule, alphaOnlyMutator, alphaRule, alphanumericOnlyMutator, appendMutator, applyNullable, arrayRule, base64DecodeMutator, base64EncodeMutator, beforeFieldRule, beforeHourRule, beforeMinuteRule, beforeTodayRule, betweenAgeRule, betweenDatesRule, betweenDaysRule, betweenHoursRule, betweenLengthRule, betweenMinutesRule, betweenMonthsRule, betweenNumbersRule, betweenTimesRule, betweenYearsRule, birthdayRule, booleanCoerceMutator, booleanMutator, booleanRule, businessDayRule, camelCaseMutator, capitalizeMutator, ceilMutator, colorRule, configureSeal, containsRule, cuidRule, darkColorRule, dateMutator, dateRule, emailRule, endsWithRule, enumRule, equalRule, equalityConditionalMethodsApplied, equalsFieldRule, evenRule, flipArrayMutator, floatRule, floorMutator, forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule, forbiddenMethodsApplied, forbiddenRule, formBooleanMutator, fromHourRule, fromMinuteRule, fromTodayRule, futureRule, getFieldValue, getInstalledPlugins, getRuleOptions, getSealConfig, greaterThanRule, hasPlugin, hexColorRule, hslColorRule, htmlEscapeMutator, humanizeSize, inRule, instanceofRule, intRule, invalidRule, ip4Rule, ip6Rule, ipRule, isCreditCardRule, isDateValue, isIP, isIPv4, isIPv6, isNumericRule, jsonMutator, kebabCaseMutator, leapYearRule, lengthRule, lessThanRule, lightColorRule, literalRule, lowercaseMutator, ltrimMutator, mapToStandardResult, maskMutator, matchesRule, maxAgeRule, maxDateRule, maxDayRule, maxFileSizeRule, maxHeightRule, maxLengthRule, maxMonthRule, maxRule, maxWidthRule, maxWordsRule, maxYearRule, minAgeRule, minDateRule, minDayRule, minFileSizeRule, minHeightRule, minLengthRule, minMonthRule, minRule, minWidthRule, minWordsRule, minYearRule, moduloRule, monthRule, nanoidRule, negativeRule, notAllowedValuesRule, notContainsRule, notEqualsFieldRule, numberMutator, numberRule, numericMutator, objectRule, objectTrimMutator, oddRule, padEndMutator, padStartMutator, pascalCaseMutator, pastRule, patternRule, plainObjectRule, positiveRule, prependMutator, presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule, presentMethodsApplied, presentRule, presentUnlessRule, presentWithAllRule, presentWithAnyRule, presentWithRule, presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule, quarterRule, registerPlugin, removeEmptyArrayElementsMutator, removeNumbersMutator, removeSpecialCharactersMutator, repeatMutator, replaceAllMutator, replaceMutator, requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule, requiredMethodsApplied, requiredRule, requiredUnlessRule, requiredWhenRule, requiredWithAllRule, requiredWithAnyRule, requiredWithRule, requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule, resetSealConfig, resolveFileSize, resolveTranslation, reverseArrayMutator, reverseMutator, rgbColorRule, rgbaColorRule, roundMutator, roundNumberMutator, rtrimMutator, safeHtmlMutator, sameAsFieldDateRule, scalarRule, setKeyPath, slugMutator, snakeCaseMutator, sortArrayMutator, sortedArrayRule, startsWithRule, stringMutator, stringRule, stringifyMutator, stripTagsMutator, stripUnknownMutator, strongPasswordRule, titleCaseMutator, toDateOnlyMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toFixedMutator, toFormatMutator, toISOStringMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toTimeOnlyMutator, toTimestampMutator, toUTCMutator, todayRule, trimMultipleWhitespaceMutator, trimMutator, truncateMutator, ulidRule, unescapeHtmlMutator, unionRule, uniqueArrayMutator, uniqueArrayRule, unknownKeyRule, unregisterPlugin, uppercaseMutator, urlDecodeMutator, urlEncodeMutator, urlRule, uuidRule, v, validate, weekDayRule, weekdayRule, weekdaysRule, weekendRule, whenRule, withinDaysRule, withinFutureDaysRule, withinPastDaysRule, withoutWhitespaceRule, wordsRule, wrapNullableStrict, yearRule };

package/esm/mutators/boolean-mutators.d.mts

@@ -9,6 +9,22 @@ import { Mutator } from "../types/mutator-types.mjs";
  * `2`, `null`, etc.) passes through unchanged so the boolean type rule rejects it.
  */
 declare const booleanCoerceMutator: Mutator;
+/**
+ * Parse form-shaped boolean values into a real boolean, ahead of the type
+ * rule.
+ *
+ * Opted into by calling any `accepted*`/`declined*` method on
+ * `v.boolean()` (see `BooleanValidator`'s `withFormBooleanMutator`). Converts
+ * every value in `ACCEPTED_VALUES` (`1`, `"1"`, `true`, `"true"`, `"yes"`,
+ * `"y"`, `"on"`, `"Yes"`, `"Y"`, `"On"`) to `true`, and every value in
+ * `DECLINED_VALUES` (`0`, `"0"`, `false`, `"false"`, `"no"`, `"n"`, `"off"`,
+ * `"No"`, `"N"`, `"Off"`) to `false`. Any other value passes through
+ * unchanged so the boolean type rule still rejects it.
+ *
+ * Named (not anonymous) so callers can detect whether it has already been
+ * added — see the idempotence check in `BooleanValidator`.
+ */
+declare const formBooleanMutator: Mutator;
 //#endregion
-export { booleanCoerceMutator };
+export { booleanCoerceMutator, formBooleanMutator };
 //# sourceMappingURL=boolean-mutators.d.mts.map

package/esm/mutators/boolean-mutators.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"boolean-mutators.d.mts","names":[],"sources":["../../../../../../../seal/src/mutators/boolean-mutators.ts"],"mappings":";;;;;AASA;;;;AAUC;cAVY,oBAAA,EAAsB,OAUlC"}
+{"version":3,"file":"boolean-mutators.d.mts","names":[],"sources":["../../../../../../../seal/src/mutators/boolean-mutators.ts"],"mappings":";;;;;AAWA;;;;AAUC;cAVY,oBAAA,EAAsB,OAUlC;;;;AA2BA;;;;;;;;;;;;cAVY,kBAAA,EAAoB,OAUhC"}

package/esm/mutators/boolean-mutators.mjs

@@ -1,3 +1,6 @@
+import { ACCEPTED_VALUES } from "../rules/scalar/accepted-rule.mjs";
+import { DECLINED_VALUES } from "../rules/scalar/declined-rule.mjs";
+
 //#region ../seal/src/mutators/boolean-mutators.ts
 /**
 * Coerce a query-string-shaped boolean into a real boolean.
@@ -11,7 +14,27 @@ const booleanCoerceMutator = async (value) => {
 	if (value === "false" || value === "0" || value === 0) return false;
 	return value;
 };
+/**
+* Parse form-shaped boolean values into a real boolean, ahead of the type
+* rule.
+*
+* Opted into by calling any `accepted*`/`declined*` method on
+* `v.boolean()` (see `BooleanValidator`'s `withFormBooleanMutator`). Converts
+* every value in `ACCEPTED_VALUES` (`1`, `"1"`, `true`, `"true"`, `"yes"`,
+* `"y"`, `"on"`, `"Yes"`, `"Y"`, `"On"`) to `true`, and every value in
+* `DECLINED_VALUES` (`0`, `"0"`, `false`, `"false"`, `"no"`, `"n"`, `"off"`,
+* `"No"`, `"N"`, `"Off"`) to `false`. Any other value passes through
+* unchanged so the boolean type rule still rejects it.
+*
+* Named (not anonymous) so callers can detect whether it has already been
+* added — see the idempotence check in `BooleanValidator`.
+*/
+const formBooleanMutator = async (value) => {
+	if (ACCEPTED_VALUES.includes(value)) return true;
+	if (DECLINED_VALUES.includes(value)) return false;
+	return value;
+};
 
 //#endregion
-export { booleanCoerceMutator };
+export { booleanCoerceMutator, formBooleanMutator };
 //# sourceMappingURL=boolean-mutators.mjs.map

package/esm/mutators/boolean-mutators.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"boolean-mutators.mjs","names":[],"sources":["../../../../../../../seal/src/mutators/boolean-mutators.ts"],"sourcesContent":["import type { Mutator } from \"../types\";\n\n/**\n * Coerce a query-string-shaped boolean into a real boolean.\n *\n * Converts exactly: `\"true\"` / `\"1\"` / `1` → `true`, `\"false\"` / `\"0\"` / `0` → `false`.\n * Case-sensitive, no trimming. Any other value (`\"yes\"`, `\"on\"`, `\"TRUE\"`, `\"\"`,\n * `2`, `null`, etc.) passes through unchanged so the boolean type rule rejects it.\n */\nexport const booleanCoerceMutator: Mutator = async (value) => {\n  if (value === \"true\" || value === \"1\" || value === 1) {\n    return true;\n  }\n\n  if (value === \"false\" || value === \"0\" || value === 0) {\n    return false;\n  }\n\n  return value;\n};\n"],"mappings":";;;;;;;;AASA,MAAa,uBAAgC,OAAO,UAAU;CAC5D,IAAI,UAAU,UAAU,UAAU,OAAO,UAAU,GACjD,OAAO;CAGT,IAAI,UAAU,WAAW,UAAU,OAAO,UAAU,GAClD,OAAO;CAGT,OAAO;AACT"}
+{"version":3,"file":"boolean-mutators.mjs","names":[],"sources":["../../../../../../../seal/src/mutators/boolean-mutators.ts"],"sourcesContent":["import { ACCEPTED_VALUES } from \"../rules/scalar/accepted-rule\";\nimport { DECLINED_VALUES } from \"../rules/scalar/declined-rule\";\nimport type { Mutator } from \"../types\";\n\n/**\n * Coerce a query-string-shaped boolean into a real boolean.\n *\n * Converts exactly: `\"true\"` / `\"1\"` / `1` → `true`, `\"false\"` / `\"0\"` / `0` → `false`.\n * Case-sensitive, no trimming. Any other value (`\"yes\"`, `\"on\"`, `\"TRUE\"`, `\"\"`,\n * `2`, `null`, etc.) passes through unchanged so the boolean type rule rejects it.\n */\nexport const booleanCoerceMutator: Mutator = async (value) => {\n  if (value === \"true\" || value === \"1\" || value === 1) {\n    return true;\n  }\n\n  if (value === \"false\" || value === \"0\" || value === 0) {\n    return false;\n  }\n\n  return value;\n};\n\n/**\n * Parse form-shaped boolean values into a real boolean, ahead of the type\n * rule.\n *\n * Opted into by calling any `accepted*`/`declined*` method on\n * `v.boolean()` (see `BooleanValidator`'s `withFormBooleanMutator`). Converts\n * every value in `ACCEPTED_VALUES` (`1`, `\"1\"`, `true`, `\"true\"`, `\"yes\"`,\n * `\"y\"`, `\"on\"`, `\"Yes\"`, `\"Y\"`, `\"On\"`) to `true`, and every value in\n * `DECLINED_VALUES` (`0`, `\"0\"`, `false`, `\"false\"`, `\"no\"`, `\"n\"`, `\"off\"`,\n * `\"No\"`, `\"N\"`, `\"Off\"`) to `false`. Any other value passes through\n * unchanged so the boolean type rule still rejects it.\n *\n * Named (not anonymous) so callers can detect whether it has already been\n * added — see the idempotence check in `BooleanValidator`.\n */\nexport const formBooleanMutator: Mutator = async (value) => {\n  if (ACCEPTED_VALUES.includes(value)) {\n    return true;\n  }\n\n  if (DECLINED_VALUES.includes(value)) {\n    return false;\n  }\n\n  return value;\n};\n"],"mappings":";;;;;;;;;;;AAWA,MAAa,uBAAgC,OAAO,UAAU;CAC5D,IAAI,UAAU,UAAU,UAAU,OAAO,UAAU,GACjD,OAAO;CAGT,IAAI,UAAU,WAAW,UAAU,OAAO,UAAU,GAClD,OAAO;CAGT,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,MAAa,qBAA8B,OAAO,UAAU;CAC1D,IAAI,gBAAgB,SAAS,KAAK,GAChC,OAAO;CAGT,IAAI,gBAAgB,SAAS,KAAK,GAChC,OAAO;CAGT,OAAO;AACT"}

package/esm/mutators/index.mjs

@@ -1,5 +1,5 @@
 import { flipArrayMutator, removeEmptyArrayElementsMutator, reverseArrayMutator, sortArrayMutator, uniqueArrayMutator } from "./array-mutators.mjs";
-import { booleanCoerceMutator } from "./boolean-mutators.mjs";
+import { booleanCoerceMutator, formBooleanMutator } from "./boolean-mutators.mjs";
 import { addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, dateMutator, toDateOnlyMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toFormatMutator, toISOStringMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toTimeOnlyMutator, toTimestampMutator, toUTCMutator } from "./date-mutators.mjs";
 import { absMutator, booleanMutator, ceilMutator, floorMutator, numberMutator, numericMutator, roundMutator, roundNumberMutator, toFixedMutator } from "./number-mutators.mjs";
 import { jsonMutator, objectTrimMutator, stripUnknownMutator } from "./object-mutators.mjs";

package/esm/rules/scalar/accepted-rule.mjs

@@ -4,19 +4,26 @@ import "../../helpers/index.mjs";
 import { isEmptyValue } from "../../helpers/is-empty-value.mjs";
 
 //#region ../seal/src/rules/scalar/accepted-rule.ts
+/**
+* The full set of values treated as "accepted" by `acceptedRule` and its
+* conditional variants. Shared with `formBooleanMutator` (see
+* `../../mutators/boolean-mutators`) so `v.boolean().accepted()` recognizes
+* exactly this list — single source of truth, no duplicated literals.
+*/
+const ACCEPTED_VALUES = [
+	"1",
+	"true",
+	"yes",
+	"y",
+	"on",
+	1,
+	true,
+	"Yes",
+	"Y",
+	"On"
+];
 const isAcceptedValue = (value) => {
-	return [
-		"1",
-		"true",
-		"yes",
-		"y",
-		"on",
-		1,
-		true,
-		"Yes",
-		"Y",
-		"On"
-	].includes(value);
+	return ACCEPTED_VALUES.includes(value);
 };
 /**
 * Validate value as accepted if it equals:
@@ -112,5 +119,5 @@ const acceptedWithoutRule = {
 };
 
 //#endregion
-export { acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule };
+export { ACCEPTED_VALUES, acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule };
 //# sourceMappingURL=accepted-rule.mjs.map

package/esm/rules/scalar/accepted-rule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"accepted-rule.mjs","names":[],"sources":["../../../../../../../../seal/src/rules/scalar/accepted-rule.ts"],"sourcesContent":["import { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport { isEmptyValue } from \"../../helpers/is-empty-value\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\nconst isAcceptedValue = (value: any) => {\r\n  return [\"1\", \"true\", \"yes\", \"y\", \"on\", 1, true, \"Yes\", \"Y\", \"On\"].includes(value);\r\n};\r\n\r\n/**\r\n * Validate value as accepted if it equals:\r\n * 1 | \"1\" | true | \"true\" | \"yes\" | \"y\" | \"on\"\r\n */\r\nexport const acceptedRule: SchemaRule = {\r\n  name: \"accepted\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  description:\r\n    \"The value must be accepted if it equals: 1 | '1' | true | 'true' | 'yes' | 'y' | 'on' | 1 | true | 'Yes' | 'Y' | 'On'\",\r\n  async validate(value: any, context) {\r\n    if (isAcceptedValue(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted value if another field's value equals to a specific value\r\n */\r\nexport const acceptedIfRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"acceptedIf\",\r\n  description: \"The field must be accepted if :field's value equals to :value\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n    if (fieldValue !== expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted if another field is not equal to the given value\r\n */\r\nexport const acceptedUnlessRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"acceptedUnless\",\r\n  description: \"The field must be accepted if :field's value is not equal to :value\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    if (fieldValue === expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted if another field is required\r\n */\r\nexport const acceptedIfRequiredRule: SchemaRule<{ field: string }> = {\r\n  name: \"acceptedIfRequired\",\r\n  description: \"The field must be accepted if :field is required\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (isEmptyValue(fieldValue)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted if another field is present\r\n */\r\nexport const acceptedIfPresentRule: SchemaRule<{ field: string }> = {\r\n  name: \"acceptedIfPresent\",\r\n  description: \"The field must be accepted if :field is present\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue === undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted if another field is missing\r\n */\r\nexport const acceptedWithoutRule: SchemaRule<{ field: string }> = {\r\n  name: \"acceptedWithout\",\r\n  description: \"The field must be accepted if :field is missing\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue !== undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;AAIA,MAAM,mBAAmB,UAAe;CACtC,OAAO;EAAC;EAAK;EAAQ;EAAO;EAAK;EAAM;EAAG;EAAM;EAAO;EAAK;CAAI,CAAC,CAAC,SAAS,KAAK;AAClF;;;;;AAMA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,aACE;CACF,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,gBAAgB,KAAK,GACvB,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,iBAA4D;CACvE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,qBAAgE;CAC3E,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,yBAAwD;CACnE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,aAAa,UAAU,GACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,wBAAuD;CAClE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,sBAAqD;CAChE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}
+{"version":3,"file":"accepted-rule.mjs","names":[],"sources":["../../../../../../../../seal/src/rules/scalar/accepted-rule.ts"],"sourcesContent":["import { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport { isEmptyValue } from \"../../helpers/is-empty-value\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * The full set of values treated as \"accepted\" by `acceptedRule` and its\r\n * conditional variants. Shared with `formBooleanMutator` (see\r\n * `../../mutators/boolean-mutators`) so `v.boolean().accepted()` recognizes\r\n * exactly this list — single source of truth, no duplicated literals.\r\n */\r\nexport const ACCEPTED_VALUES: readonly unknown[] = [\r\n  \"1\",\r\n  \"true\",\r\n  \"yes\",\r\n  \"y\",\r\n  \"on\",\r\n  1,\r\n  true,\r\n  \"Yes\",\r\n  \"Y\",\r\n  \"On\",\r\n];\r\n\r\nconst isAcceptedValue = (value: any) => {\r\n  return ACCEPTED_VALUES.includes(value);\r\n};\r\n\r\n/**\r\n * Validate value as accepted if it equals:\r\n * 1 | \"1\" | true | \"true\" | \"yes\" | \"y\" | \"on\"\r\n */\r\nexport const acceptedRule: SchemaRule = {\r\n  name: \"accepted\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  description:\r\n    \"The value must be accepted if it equals: 1 | '1' | true | 'true' | 'yes' | 'y' | 'on' | 1 | true | 'Yes' | 'Y' | 'On'\",\r\n  async validate(value: any, context) {\r\n    if (isAcceptedValue(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted value if another field's value equals to a specific value\r\n */\r\nexport const acceptedIfRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"acceptedIf\",\r\n  description: \"The field must be accepted if :field's value equals to :value\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n    if (fieldValue !== expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted if another field is not equal to the given value\r\n */\r\nexport const acceptedUnlessRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"acceptedUnless\",\r\n  description: \"The field must be accepted if :field's value is not equal to :value\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    if (fieldValue === expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted if another field is required\r\n */\r\nexport const acceptedIfRequiredRule: SchemaRule<{ field: string }> = {\r\n  name: \"acceptedIfRequired\",\r\n  description: \"The field must be accepted if :field is required\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (isEmptyValue(fieldValue)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted if another field is present\r\n */\r\nexport const acceptedIfPresentRule: SchemaRule<{ field: string }> = {\r\n  name: \"acceptedIfPresent\",\r\n  description: \"The field must be accepted if :field is present\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue === undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Accepted if another field is missing\r\n */\r\nexport const acceptedWithoutRule: SchemaRule<{ field: string }> = {\r\n  name: \"acceptedWithout\",\r\n  description: \"The field must be accepted if :field is missing\",\r\n  defaultErrorMessage: \"The :input must be accepted\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue !== undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isAcceptedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;;;AAUA,MAAa,kBAAsC;CACjD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,mBAAmB,UAAe;CACtC,OAAO,gBAAgB,SAAS,KAAK;AACvC;;;;;AAMA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,aACE;CACF,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,gBAAgB,KAAK,GACvB,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,iBAA4D;CACvE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,qBAAgE;CAC3E,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,yBAAwD;CACnE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,aAAa,UAAU,GACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,wBAAuD;CAClE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,sBAAqD;CAChE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/rules/scalar/declined-rule.mjs

@@ -4,19 +4,26 @@ import "../../helpers/index.mjs";
 import { isEmptyValue } from "../../helpers/is-empty-value.mjs";
 
 //#region ../seal/src/rules/scalar/declined-rule.ts
+/**
+* The full set of values treated as "declined" by `declinedRule` and its
+* conditional variants. Shared with `formBooleanMutator` (see
+* `../../mutators/boolean-mutators`) so `v.boolean().declined()` recognizes
+* exactly this list — single source of truth, no duplicated literals.
+*/
+const DECLINED_VALUES = [
+	"0",
+	"false",
+	"no",
+	"n",
+	"off",
+	0,
+	false,
+	"No",
+	"N",
+	"Off"
+];
 const isDeclinedValue = (value) => {
-	return [
-		"0",
-		"false",
-		"no",
-		"n",
-		"off",
-		0,
-		false,
-		"No",
-		"N",
-		"Off"
-	].includes(value);
+	return DECLINED_VALUES.includes(value);
 };
 /**
 * Validate value as declined if it equals:
@@ -112,5 +119,5 @@ const declinedWithoutRule = {
 };
 
 //#endregion
-export { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule };
+export { DECLINED_VALUES, declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule };
 //# sourceMappingURL=declined-rule.mjs.map

package/esm/rules/scalar/declined-rule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"declined-rule.mjs","names":[],"sources":["../../../../../../../../seal/src/rules/scalar/declined-rule.ts"],"sourcesContent":["import { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport { isEmptyValue } from \"../../helpers/is-empty-value\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\nconst isDeclinedValue = (value: any) => {\r\n  return [\"0\", \"false\", \"no\", \"n\", \"off\", 0, false, \"No\", \"N\", \"Off\"].includes(value);\r\n};\r\n\r\n/**\r\n * Validate value as declined if it equals:\r\n * 0 | \"0\" | false | \"false\" | \"no\" | \"n\" | \"off\" | 0 | false | \"No\" | \"N\" | \"Off\"\r\n */\r\nexport const declinedRule: SchemaRule = {\r\n  name: \"declined\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  description:\r\n    \"The value must be declined if it equals: 0 | '0' | false | 'false' | 'no' | 'n' | 'off' | 0 | false | 'No' | 'N' | 'Off'\",\r\n  async validate(value: any, context) {\r\n    if (isDeclinedValue(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Declined value if another field's value equals to a specific value\r\n */\r\nexport const declinedIfRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"declinedIf\",\r\n  description: \"The field must be declined if :field's value equals to :value\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    if (fieldValue !== expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is not equal to the given value\r\n */\r\nexport const declinedUnlessRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"declinedUnless\",\r\n  description: \"The field must be declined if :field's value is not equal to :value\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n    if (fieldValue === expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is required\r\n */\r\nexport const declinedIfRequiredRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedIfRequired\",\r\n  description: \"The field must be declined if :field is required\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (isEmptyValue(fieldValue)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is present\r\n */\r\nexport const declinedIfPresentRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedIfPresent\",\r\n  description: \"The field must be declined if :field is present\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue === undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is missing\r\n */\r\nexport const declinedWithoutRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedWithout\",\r\n  description: \"The field must be declined if :field is missing\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue !== undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;AAIA,MAAM,mBAAmB,UAAe;CACtC,OAAO;EAAC;EAAK;EAAS;EAAM;EAAK;EAAO;EAAG;EAAO;EAAM;EAAK;CAAK,CAAC,CAAC,SAAS,KAAK;AACpF;;;;;AAMA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,aACE;CACF,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,gBAAgB,KAAK,GACvB,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,iBAA4D;CACvE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,qBAAgE;CAC3E,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,yBAAwD;CACnE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,aAAa,UAAU,GACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,wBAAuD;CAClE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,sBAAqD;CAChE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}
+{"version":3,"file":"declined-rule.mjs","names":[],"sources":["../../../../../../../../seal/src/rules/scalar/declined-rule.ts"],"sourcesContent":["import { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport { isEmptyValue } from \"../../helpers/is-empty-value\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * The full set of values treated as \"declined\" by `declinedRule` and its\r\n * conditional variants. Shared with `formBooleanMutator` (see\r\n * `../../mutators/boolean-mutators`) so `v.boolean().declined()` recognizes\r\n * exactly this list — single source of truth, no duplicated literals.\r\n */\r\nexport const DECLINED_VALUES: readonly unknown[] = [\r\n  \"0\",\r\n  \"false\",\r\n  \"no\",\r\n  \"n\",\r\n  \"off\",\r\n  0,\r\n  false,\r\n  \"No\",\r\n  \"N\",\r\n  \"Off\",\r\n];\r\n\r\nconst isDeclinedValue = (value: any) => {\r\n  return DECLINED_VALUES.includes(value);\r\n};\r\n\r\n/**\r\n * Validate value as declined if it equals:\r\n * 0 | \"0\" | false | \"false\" | \"no\" | \"n\" | \"off\" | 0 | false | \"No\" | \"N\" | \"Off\"\r\n */\r\nexport const declinedRule: SchemaRule = {\r\n  name: \"declined\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  description:\r\n    \"The value must be declined if it equals: 0 | '0' | false | 'false' | 'no' | 'n' | 'off' | 0 | false | 'No' | 'N' | 'Off'\",\r\n  async validate(value: any, context) {\r\n    if (isDeclinedValue(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Declined value if another field's value equals to a specific value\r\n */\r\nexport const declinedIfRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"declinedIf\",\r\n  description: \"The field must be declined if :field's value equals to :value\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    if (fieldValue !== expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is not equal to the given value\r\n */\r\nexport const declinedUnlessRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"declinedUnless\",\r\n  description: \"The field must be declined if :field's value is not equal to :value\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n    if (fieldValue === expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is required\r\n */\r\nexport const declinedIfRequiredRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedIfRequired\",\r\n  description: \"The field must be declined if :field is required\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (isEmptyValue(fieldValue)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is present\r\n */\r\nexport const declinedIfPresentRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedIfPresent\",\r\n  description: \"The field must be declined if :field is present\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue === undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is missing\r\n */\r\nexport const declinedWithoutRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedWithout\",\r\n  description: \"The field must be declined if :field is missing\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue !== undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;;;AAUA,MAAa,kBAAsC;CACjD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,mBAAmB,UAAe;CACtC,OAAO,gBAAgB,SAAS,KAAK;AACvC;;;;;AAMA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,aACE;CACF,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,gBAAgB,KAAK,GACvB,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,iBAA4D;CACvE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,qBAAgE;CAC3E,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,yBAAwD;CACnE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,aAAa,UAAU,GACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,wBAAuD;CAClE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,sBAAqD;CAChE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/rules/scalar/index.mjs

@@ -1,4 +1,4 @@
-import { acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule } from "./accepted-rule.mjs";
-import { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule } from "./declined-rule.mjs";
+import { ACCEPTED_VALUES, acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule } from "./accepted-rule.mjs";
+import { DECLINED_VALUES, declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule } from "./declined-rule.mjs";
 
 export {  };

package/esm/validators/boolean-validator.d.mts

@@ -15,7 +15,26 @@ declare class BooleanValidator extends PrimitiveValidator {
    * Check if value is a boolean type
    */
   matchesType(value: any): boolean;
-  /** Value must be accepted (true, "yes", 1, "on", etc.) */
+  /**
+   * Add a rule from the accepted/declined family, opting the validator into
+   * form-boolean parsing.
+   *
+   * Calling ANY `accepted*`/`declined*` method on `v.boolean()` adds (once,
+   * idempotently — checked by mutator identity so chaining several of these
+   * methods never stacks duplicates) `formBooleanMutator`, which runs before
+   * the type rule and converts the accepted set (`1`, `"1"`, `true`,
+   * `"true"`, `"yes"`, `"y"`, `"on"`, `"Yes"`, `"Y"`, `"On"`) to `true` and
+   * the declined set (`0`, `"0"`, `false`, `"false"`, `"no"`, `"n"`, `"off"`,
+   * `"No"`, `"N"`, `"Off"`) to `false`; any other value passes through
+   * unchanged and is rejected by the strict type rule as before.
+   *
+   * The mutator and the rule are added to the SAME resolved instance in one
+   * pass — resolving `this.instance` twice (once per `addRule`/`addMutator`
+   * call) would clone twice on an immutable validator and silently drop one
+   * of the two additions.
+   */
+  private addFormBooleanRule;
+  /** Value must be accepted (true, "yes", 1, "on", etc. — form strings are parsed into a real boolean first) */
   accepted(errorMessage?: string): this;
   /** Value must be accepted if another field equals a value */
   acceptedIf(field: string, value: any, errorMessage?: string): this;
@@ -27,7 +46,7 @@ declare class BooleanValidator extends PrimitiveValidator {
   acceptedIfPresent(field: string, errorMessage?: string): this;
   /** Value must be accepted if another field is missing */
   acceptedWithout(field: string, errorMessage?: string): this;
-  /** Value must be declined (false, "no", 0, "off", etc.) */
+  /** Value must be declined (false, "no", 0, "off", etc. — form strings are parsed into a real boolean first) */
   declined(errorMessage?: string): this;
   /** Value must be declined if another field equals a value */
   declinedIf(field: string, value: any, errorMessage?: string): this;
@@ -49,7 +68,9 @@ declare class BooleanValidator extends PrimitiveValidator {
    * `2` all pass through unchanged and fail the type rule. `v.boolean()` does
    * **not** coerce by default; this only takes effect when explicitly chained.
    * For form-style truthy strings like `"yes"` / `"on"`, use `.accepted()` /
-   * `.declined()` instead — those are separate pass/fail rules, not coercion.
+   * `.declined()` instead — those methods opt into their own form-boolean
+   * parsing (a wider value set, case-insensitive on a few forms) and then
+   * apply the accepted/declined pass-fail rule on top of the parsed boolean.
    *
    * The output type is unchanged (`Infer<>` keys off the validator class), so
    * `v.boolean().coerce()` still infers `boolean`.

package/esm/validators/boolean-validator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"boolean-validator.d.mts","names":[],"sources":["../../../../../../../seal/src/validators/boolean-validator.ts"],"mappings":";;;;;;AA2BA;;;;;cAAa,gBAAA,SAAyB,kBAAA;cACjB,YAAA;EADmC;;;EAS/C,WAAA,CAAY,KAAA;EAAZ;EAOA,QAAA,CAAS,YAAA;EAAT;EAKA,UAAA,CAAW,KAAA,UAAe,KAAA,OAAY,YAAA;EAAtC;EAKA,cAAA,CAAe,KAAA,UAAe,KAAA,OAAY,YAAA;EALhB;EAU1B,kBAAA,CAAmB,KAAA,UAAe,YAAA;EALlC;EAUA,iBAAA,CAAkB,KAAA,UAAe,YAAA;EAVH;EAe9B,eAAA,CAAgB,KAAA,UAAe,YAAA;EAV/B;EAiBA,QAAA,CAAS,YAAA;EAjByB;EAsBlC,UAAA,CAAW,KAAA,UAAe,KAAA,OAAY,YAAA;EAjBpB;EAsBlB,cAAA,CAAe,KAAA,UAAe,KAAA,OAAY,YAAA;EAjB1C;EAsBA,kBAAA,CAAmB,KAAA,UAAe,YAAA;EAtBH;EA2B/B,iBAAA,CAAkB,KAAA,UAAe,YAAA;EApBxB;EAyBT,eAAA,CAAgB,KAAA,UAAe,YAAA;EApBpB;;;;;;;;;;;;;;;;;;EA4CX,MAAA;IACoD,SAAA;EAAA;EAiBxC;;;;EARZ,UAAA,CAAW,YAAA;EA2BwE;AAAA;;;EAnBnF,WAAA,CAAY,YAAA;;;;;;;;;;;;;;;;EAmBH,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}
+{"version":3,"file":"boolean-validator.d.mts","names":[],"sources":["../../../../../../../seal/src/validators/boolean-validator.ts"],"mappings":";;;;;;AA4BA;;;;;cAAa,gBAAA,SAAyB,kBAAA;cACjB,YAAA;EADmC;;;EAS/C,WAAA,CAAY,KAAA;EAAZ;;;;;;;;;;;;;;;;;;EAAA,QAsBC,kBAAA;EA4CD;EAzBA,QAAA,CAAS,YAAA;EAyBsB;EApB/B,UAAA,CAAW,KAAA,UAAe,KAAA,OAAY,YAAA;EA2B7B;EAtBT,cAAA,CAAe,KAAA,UAAe,KAAA,OAAY,YAAA;EA2B/B;EAtBX,kBAAA,CAAmB,KAAA,UAAe,YAAA;EAsBI;EAjBtC,iBAAA,CAAkB,KAAA,UAAe,YAAA;EAsBlB;EAjBf,eAAA,CAAgB,KAAA,UAAe,YAAA;EAiBW;EAV1C,QAAA,CAAS,YAAA;EAeU;EAVnB,UAAA,CAAW,KAAA,UAAe,KAAA,OAAY,YAAA;EAetC;EAVA,cAAA,CAAe,KAAA,UAAe,KAAA,OAAY,YAAA;EAUT;EALjC,kBAAA,CAAmB,KAAA,UAAe,YAAA;EAUlB;EALhB,iBAAA,CAAkB,KAAA,UAAe,YAAA;EA+BjC;EA1BA,eAAA,CAAgB,KAAA,UAAe,YAAA;EAoC/B;;;;;;;;;AA2BmF;;;;;;;;;;;EArCnF,MAAA;IACoD,SAAA;EAAA;;;;;EASpD,UAAA,CAAW,YAAA;;;;;EAQX,WAAA,CAAY,YAAA;;;;;;;;;;;;;;;;EAmBH,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}

package/esm/validators/boolean-validator.mjs

@@ -1,10 +1,10 @@
 import { applyNullable } from "../standard-schema/json-schema.mjs";
-import { booleanCoerceMutator } from "../mutators/boolean-mutators.mjs";
+import { acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule } from "../rules/scalar/accepted-rule.mjs";
+import { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule } from "../rules/scalar/declined-rule.mjs";
+import { booleanCoerceMutator, formBooleanMutator } from "../mutators/boolean-mutators.mjs";
 import { booleanRule } from "../rules/common/type-rules.mjs";
 import "../rules/index.mjs";
 import { PrimitiveValidator } from "./primitive-validator.mjs";
-import { acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule } from "../rules/scalar/accepted-rule.mjs";
-import { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule } from "../rules/scalar/declined-rule.mjs";
 import "../rules/scalar/index.mjs";
 
 //#region ../seal/src/validators/boolean-validator.ts
@@ -26,65 +26,89 @@ var BooleanValidator = class extends PrimitiveValidator {
 	matchesType(value) {
 		return typeof value === "boolean";
 	}
-	/** Value must be accepted (true, "yes", 1, "on", etc.) */
+	/**
+	* Add a rule from the accepted/declined family, opting the validator into
+	* form-boolean parsing.
+	*
+	* Calling ANY `accepted*`/`declined*` method on `v.boolean()` adds (once,
+	* idempotently — checked by mutator identity so chaining several of these
+	* methods never stacks duplicates) `formBooleanMutator`, which runs before
+	* the type rule and converts the accepted set (`1`, `"1"`, `true`,
+	* `"true"`, `"yes"`, `"y"`, `"on"`, `"Yes"`, `"Y"`, `"On"`) to `true` and
+	* the declined set (`0`, `"0"`, `false`, `"false"`, `"no"`, `"n"`, `"off"`,
+	* `"No"`, `"N"`, `"Off"`) to `false`; any other value passes through
+	* unchanged and is rejected by the strict type rule as before.
+	*
+	* The mutator and the rule are added to the SAME resolved instance in one
+	* pass — resolving `this.instance` twice (once per `addRule`/`addMutator`
+	* call) would clone twice on an immutable validator and silently drop one
+	* of the two additions.
+	*/
+	addFormBooleanRule(rule, errorMessage, options = {}) {
+		const instance = this.instance;
+		if (!instance.mutators.some((mutator) => mutator.mutate === formBooleanMutator)) instance.addMutableMutator(formBooleanMutator);
+		instance.addMutableRule(rule, errorMessage, options);
+		return instance;
+	}
+	/** Value must be accepted (true, "yes", 1, "on", etc. — form strings are parsed into a real boolean first) */
 	accepted(errorMessage) {
-		return this.addRule(acceptedRule, errorMessage);
+		return this.addFormBooleanRule(acceptedRule, errorMessage);
 	}
 	/** Value must be accepted if another field equals a value */
 	acceptedIf(field, value, errorMessage) {
-		return this.addRule(acceptedIfRule, errorMessage, {
+		return this.addFormBooleanRule(acceptedIfRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be accepted unless another field equals a value */
 	acceptedUnless(field, value, errorMessage) {
-		return this.addRule(acceptedUnlessRule, errorMessage, {
+		return this.addFormBooleanRule(acceptedUnlessRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be accepted if another field is required */
 	acceptedIfRequired(field, errorMessage) {
-		return this.addRule(acceptedIfRequiredRule, errorMessage, { field });
+		return this.addFormBooleanRule(acceptedIfRequiredRule, errorMessage, { field });
 	}
 	/** Value must be accepted if another field is present */
 	acceptedIfPresent(field, errorMessage) {
-		return this.addRule(acceptedIfPresentRule, errorMessage, { field });
+		return this.addFormBooleanRule(acceptedIfPresentRule, errorMessage, { field });
 	}
 	/** Value must be accepted if another field is missing */
 	acceptedWithout(field, errorMessage) {
-		return this.addRule(acceptedWithoutRule, errorMessage, { field });
+		return this.addFormBooleanRule(acceptedWithoutRule, errorMessage, { field });
 	}
-	/** Value must be declined (false, "no", 0, "off", etc.) */
+	/** Value must be declined (false, "no", 0, "off", etc. — form strings are parsed into a real boolean first) */
 	declined(errorMessage) {
-		return this.addRule(declinedRule, errorMessage);
+		return this.addFormBooleanRule(declinedRule, errorMessage);
 	}
 	/** Value must be declined if another field equals a value */
 	declinedIf(field, value, errorMessage) {
-		return this.addRule(declinedIfRule, errorMessage, {
+		return this.addFormBooleanRule(declinedIfRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be declined unless another field equals a value */
 	declinedUnless(field, value, errorMessage) {
-		return this.addRule(declinedUnlessRule, errorMessage, {
+		return this.addFormBooleanRule(declinedUnlessRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be declined if another field is required */
 	declinedIfRequired(field, errorMessage) {
-		return this.addRule(declinedIfRequiredRule, errorMessage, { field });
+		return this.addFormBooleanRule(declinedIfRequiredRule, errorMessage, { field });
 	}
 	/** Value must be declined if another field is present */
 	declinedIfPresent(field, errorMessage) {
-		return this.addRule(declinedIfPresentRule, errorMessage, { field });
+		return this.addFormBooleanRule(declinedIfPresentRule, errorMessage, { field });
 	}
 	/** Value must be declined if another field is missing */
 	declinedWithout(field, errorMessage) {
-		return this.addRule(declinedWithoutRule, errorMessage, { field });
+		return this.addFormBooleanRule(declinedWithoutRule, errorMessage, { field });
 	}
 	/**
 	* Opt in to coercion: an exact query-string-shaped boolean is converted to a
@@ -96,7 +120,9 @@ var BooleanValidator = class extends PrimitiveValidator {
 	* `2` all pass through unchanged and fail the type rule. `v.boolean()` does
 	* **not** coerce by default; this only takes effect when explicitly chained.
 	* For form-style truthy strings like `"yes"` / `"on"`, use `.accepted()` /
-	* `.declined()` instead — those are separate pass/fail rules, not coercion.
+	* `.declined()` instead — those methods opt into their own form-boolean
+	* parsing (a wider value set, case-insensitive on a few forms) and then
+	* apply the accepted/declined pass-fail rule on top of the parsed boolean.
 	*
 	* The output type is unchanged (`Infer<>` keys off the validator class), so
 	* `v.boolean().coerce()` still infers `boolean`.

package/esm/validators/boolean-validator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"boolean-validator.mjs","names":[],"sources":["../../../../../../../seal/src/validators/boolean-validator.ts"],"sourcesContent":["import { booleanCoerceMutator } from \"../mutators/boolean-mutators\";\nimport {\n  acceptedIfPresentRule,\n  acceptedIfRequiredRule,\n  acceptedIfRule,\n  acceptedRule,\n  acceptedUnlessRule,\n  acceptedWithoutRule,\n  declinedIfPresentRule,\n  declinedIfRequiredRule,\n  declinedIfRule,\n  declinedRule,\n  declinedUnlessRule,\n  declinedWithoutRule,\n} from \"../rules/scalar\";\nimport { booleanRule } from \"../rules\";\nimport { PrimitiveValidator } from \"./primitive-validator\";\nimport { applyNullable } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\n\n/**\n * Boolean validator class\n *\n * Extends PrimitiveValidator — inherits enum/in/oneOf/allowsOnly/forbids/notIn.\n * Defines accepted/declined directly as real methods (not ScalarValidator field copies)\n * so they survive cloning correctly.\n */\nexport class BooleanValidator extends PrimitiveValidator {\n  public constructor(errorMessage?: string) {\n    super();\n    this.addMutableRule(booleanRule, errorMessage);\n  }\n\n  /**\n   * Check if value is a boolean type\n   */\n  public matchesType(value: any): boolean {\n    return typeof value === \"boolean\";\n  }\n\n  // ==================== Accepted ====================\n\n  /** Value must be accepted (true, \"yes\", 1, \"on\", etc.) */\n  public accepted(errorMessage?: string) {\n    return this.addRule(acceptedRule, errorMessage);\n  }\n\n  /** Value must be accepted if another field equals a value */\n  public acceptedIf(field: string, value: any, errorMessage?: string) {\n    return this.addRule(acceptedIfRule, errorMessage, { field, value });\n  }\n\n  /** Value must be accepted unless another field equals a value */\n  public acceptedUnless(field: string, value: any, errorMessage?: string) {\n    return this.addRule(acceptedUnlessRule, errorMessage, { field, value });\n  }\n\n  /** Value must be accepted if another field is required */\n  public acceptedIfRequired(field: string, errorMessage?: string) {\n    return this.addRule(acceptedIfRequiredRule, errorMessage, { field });\n  }\n\n  /** Value must be accepted if another field is present */\n  public acceptedIfPresent(field: string, errorMessage?: string) {\n    return this.addRule(acceptedIfPresentRule, errorMessage, { field });\n  }\n\n  /** Value must be accepted if another field is missing */\n  public acceptedWithout(field: string, errorMessage?: string) {\n    return this.addRule(acceptedWithoutRule, errorMessage, { field });\n  }\n\n  // ==================== Declined ====================\n\n  /** Value must be declined (false, \"no\", 0, \"off\", etc.) */\n  public declined(errorMessage?: string) {\n    return this.addRule(declinedRule, errorMessage);\n  }\n\n  /** Value must be declined if another field equals a value */\n  public declinedIf(field: string, value: any, errorMessage?: string) {\n    return this.addRule(declinedIfRule, errorMessage, { field, value });\n  }\n\n  /** Value must be declined unless another field equals a value */\n  public declinedUnless(field: string, value: any, errorMessage?: string) {\n    return this.addRule(declinedUnlessRule, errorMessage, { field, value });\n  }\n\n  /** Value must be declined if another field is required */\n  public declinedIfRequired(field: string, errorMessage?: string) {\n    return this.addRule(declinedIfRequiredRule, errorMessage, { field });\n  }\n\n  /** Value must be declined if another field is present */\n  public declinedIfPresent(field: string, errorMessage?: string) {\n    return this.addRule(declinedIfPresentRule, errorMessage, { field });\n  }\n\n  /** Value must be declined if another field is missing */\n  public declinedWithout(field: string, errorMessage?: string) {\n    return this.addRule(declinedWithoutRule, errorMessage, { field });\n  }\n\n  // ==================== Coercion ====================\n\n  /**\n   * Opt in to coercion: an exact query-string-shaped boolean is converted to a\n   * real boolean **before** the type rules run; any other value passes through\n   * unchanged so bad input still fails the type rule.\n   *\n   * Converts exactly `\"true\"` / `\"1\"` / `1` → `true` and `\"false\"` / `\"0\"` / `0`\n   * → `false`. Case-sensitive, no trimming — `\"TRUE\"`, `\"yes\"`, `\"on\"`, `\"\"`, and\n   * `2` all pass through unchanged and fail the type rule. `v.boolean()` does\n   * **not** coerce by default; this only takes effect when explicitly chained.\n   * For form-style truthy strings like `\"yes\"` / `\"on\"`, use `.accepted()` /\n   * `.declined()` instead — those are separate pass/fail rules, not coercion.\n   *\n   * The output type is unchanged (`Infer<>` keys off the validator class), so\n   * `v.boolean().coerce()` still infers `boolean`.\n   *\n   * @example\n   * v.boolean().coerce()   // \"true\" → true; \"1\" → true; \"0\" → false; \"yes\" → invalid\n   */\n  public coerce() {\n    return this.addMutator(booleanCoerceMutator) as this & { isCoerced: true };\n  }\n\n  // ==================== Strict boolean checks ====================\n\n  /**\n   * Value must be strictly true (not \"yes\", \"on\", 1, etc.)\n   * @alias accepted - strict version\n   */\n  public mustBeTrue(errorMessage?: string) {\n    return this.equal(true, errorMessage);\n  }\n\n  /**\n   * Value must be strictly false (not \"no\", \"off\", 0, etc.)\n   * @alias declined - strict version\n   */\n  public mustBeFalse(errorMessage?: string) {\n    return this.equal(false, errorMessage);\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * @note accepted/declined rules and all cross-field boolean rules\n   * are not representable in JSON Schema and are silently omitted.\n   *\n   * @example\n   * ```ts\n   * v.boolean().toJsonSchema(\"draft-2020-12\")\n   * // → { type: \"boolean\" }\n   *\n   * v.boolean().nullable().toJsonSchema(\"openapi-3.0\")\n   * // → { type: \"boolean\", nullable: true }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult = { type: \"boolean\" };\n    if (this.isNullable) applyNullable(schema, target);\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA2BA,IAAa,mBAAb,cAAsC,mBAAmB;CACvD,AAAO,YAAY,cAAuB;EACxC,MAAM;EACN,KAAK,eAAe,aAAa,YAAY;CAC/C;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAO,OAAO,UAAU;CAC1B;;CAKA,AAAO,SAAS,cAAuB;EACrC,OAAO,KAAK,QAAQ,cAAc,YAAY;CAChD;;CAGA,AAAO,WAAW,OAAe,OAAY,cAAuB;EAClE,OAAO,KAAK,QAAQ,gBAAgB,cAAc;GAAE;GAAO;EAAM,CAAC;CACpE;;CAGA,AAAO,eAAe,OAAe,OAAY,cAAuB;EACtE,OAAO,KAAK,QAAQ,oBAAoB,cAAc;GAAE;GAAO;EAAM,CAAC;CACxE;;CAGA,AAAO,mBAAmB,OAAe,cAAuB;EAC9D,OAAO,KAAK,QAAQ,wBAAwB,cAAc,EAAE,MAAM,CAAC;CACrE;;CAGA,AAAO,kBAAkB,OAAe,cAAuB;EAC7D,OAAO,KAAK,QAAQ,uBAAuB,cAAc,EAAE,MAAM,CAAC;CACpE;;CAGA,AAAO,gBAAgB,OAAe,cAAuB;EAC3D,OAAO,KAAK,QAAQ,qBAAqB,cAAc,EAAE,MAAM,CAAC;CAClE;;CAKA,AAAO,SAAS,cAAuB;EACrC,OAAO,KAAK,QAAQ,cAAc,YAAY;CAChD;;CAGA,AAAO,WAAW,OAAe,OAAY,cAAuB;EAClE,OAAO,KAAK,QAAQ,gBAAgB,cAAc;GAAE;GAAO;EAAM,CAAC;CACpE;;CAGA,AAAO,eAAe,OAAe,OAAY,cAAuB;EACtE,OAAO,KAAK,QAAQ,oBAAoB,cAAc;GAAE;GAAO;EAAM,CAAC;CACxE;;CAGA,AAAO,mBAAmB,OAAe,cAAuB;EAC9D,OAAO,KAAK,QAAQ,wBAAwB,cAAc,EAAE,MAAM,CAAC;CACrE;;CAGA,AAAO,kBAAkB,OAAe,cAAuB;EAC7D,OAAO,KAAK,QAAQ,uBAAuB,cAAc,EAAE,MAAM,CAAC;CACpE;;CAGA,AAAO,gBAAgB,OAAe,cAAuB;EAC3D,OAAO,KAAK,QAAQ,qBAAqB,cAAc,EAAE,MAAM,CAAC;CAClE;;;;;;;;;;;;;;;;;;;CAsBA,AAAO,SAAS;EACd,OAAO,KAAK,WAAW,oBAAoB;CAC7C;;;;;CAQA,AAAO,WAAW,cAAuB;EACvC,OAAO,KAAK,MAAM,MAAM,YAAY;CACtC;;;;;CAMA,AAAO,YAAY,cAAuB;EACxC,OAAO,KAAK,MAAM,OAAO,YAAY;CACvC;;;;;;;;;;;;;;;;CAiBA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SAA2B,EAAE,MAAM,UAAU;EACnD,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}
+{"version":3,"file":"boolean-validator.mjs","names":[],"sources":["../../../../../../../seal/src/validators/boolean-validator.ts"],"sourcesContent":["import { booleanCoerceMutator, formBooleanMutator } from \"../mutators/boolean-mutators\";\nimport {\n  acceptedIfPresentRule,\n  acceptedIfRequiredRule,\n  acceptedIfRule,\n  acceptedRule,\n  acceptedUnlessRule,\n  acceptedWithoutRule,\n  declinedIfPresentRule,\n  declinedIfRequiredRule,\n  declinedIfRule,\n  declinedRule,\n  declinedUnlessRule,\n  declinedWithoutRule,\n} from \"../rules/scalar\";\nimport { booleanRule } from \"../rules\";\nimport { PrimitiveValidator } from \"./primitive-validator\";\nimport { applyNullable } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport type { SchemaRule, SchemaRuleOptions } from \"../types\";\n\n/**\n * Boolean validator class\n *\n * Extends PrimitiveValidator — inherits enum/in/oneOf/allowsOnly/forbids/notIn.\n * Defines accepted/declined directly as real methods (not ScalarValidator field copies)\n * so they survive cloning correctly.\n */\nexport class BooleanValidator extends PrimitiveValidator {\n  public constructor(errorMessage?: string) {\n    super();\n    this.addMutableRule(booleanRule, errorMessage);\n  }\n\n  /**\n   * Check if value is a boolean type\n   */\n  public matchesType(value: any): boolean {\n    return typeof value === \"boolean\";\n  }\n\n  /**\n   * Add a rule from the accepted/declined family, opting the validator into\n   * form-boolean parsing.\n   *\n   * Calling ANY `accepted*`/`declined*` method on `v.boolean()` adds (once,\n   * idempotently — checked by mutator identity so chaining several of these\n   * methods never stacks duplicates) `formBooleanMutator`, which runs before\n   * the type rule and converts the accepted set (`1`, `\"1\"`, `true`,\n   * `\"true\"`, `\"yes\"`, `\"y\"`, `\"on\"`, `\"Yes\"`, `\"Y\"`, `\"On\"`) to `true` and\n   * the declined set (`0`, `\"0\"`, `false`, `\"false\"`, `\"no\"`, `\"n\"`, `\"off\"`,\n   * `\"No\"`, `\"N\"`, `\"Off\"`) to `false`; any other value passes through\n   * unchanged and is rejected by the strict type rule as before.\n   *\n   * The mutator and the rule are added to the SAME resolved instance in one\n   * pass — resolving `this.instance` twice (once per `addRule`/`addMutator`\n   * call) would clone twice on an immutable validator and silently drop one\n   * of the two additions.\n   */\n  private addFormBooleanRule<T extends SchemaRuleOptions = SchemaRuleOptions>(\n    rule: SchemaRule<T>,\n    errorMessage?: string,\n    options: T = {} as T,\n  ): this {\n    const instance = this.instance;\n\n    if (!instance.mutators.some((mutator) => mutator.mutate === formBooleanMutator)) {\n      instance.addMutableMutator(formBooleanMutator);\n    }\n\n    instance.addMutableRule(rule, errorMessage, options);\n\n    return instance;\n  }\n\n  // ==================== Accepted ====================\n\n  /** Value must be accepted (true, \"yes\", 1, \"on\", etc. — form strings are parsed into a real boolean first) */\n  public accepted(errorMessage?: string) {\n    return this.addFormBooleanRule(acceptedRule, errorMessage);\n  }\n\n  /** Value must be accepted if another field equals a value */\n  public acceptedIf(field: string, value: any, errorMessage?: string) {\n    return this.addFormBooleanRule(acceptedIfRule, errorMessage, { field, value });\n  }\n\n  /** Value must be accepted unless another field equals a value */\n  public acceptedUnless(field: string, value: any, errorMessage?: string) {\n    return this.addFormBooleanRule(acceptedUnlessRule, errorMessage, { field, value });\n  }\n\n  /** Value must be accepted if another field is required */\n  public acceptedIfRequired(field: string, errorMessage?: string) {\n    return this.addFormBooleanRule(acceptedIfRequiredRule, errorMessage, { field });\n  }\n\n  /** Value must be accepted if another field is present */\n  public acceptedIfPresent(field: string, errorMessage?: string) {\n    return this.addFormBooleanRule(acceptedIfPresentRule, errorMessage, { field });\n  }\n\n  /** Value must be accepted if another field is missing */\n  public acceptedWithout(field: string, errorMessage?: string) {\n    return this.addFormBooleanRule(acceptedWithoutRule, errorMessage, { field });\n  }\n\n  // ==================== Declined ====================\n\n  /** Value must be declined (false, \"no\", 0, \"off\", etc. — form strings are parsed into a real boolean first) */\n  public declined(errorMessage?: string) {\n    return this.addFormBooleanRule(declinedRule, errorMessage);\n  }\n\n  /** Value must be declined if another field equals a value */\n  public declinedIf(field: string, value: any, errorMessage?: string) {\n    return this.addFormBooleanRule(declinedIfRule, errorMessage, { field, value });\n  }\n\n  /** Value must be declined unless another field equals a value */\n  public declinedUnless(field: string, value: any, errorMessage?: string) {\n    return this.addFormBooleanRule(declinedUnlessRule, errorMessage, { field, value });\n  }\n\n  /** Value must be declined if another field is required */\n  public declinedIfRequired(field: string, errorMessage?: string) {\n    return this.addFormBooleanRule(declinedIfRequiredRule, errorMessage, { field });\n  }\n\n  /** Value must be declined if another field is present */\n  public declinedIfPresent(field: string, errorMessage?: string) {\n    return this.addFormBooleanRule(declinedIfPresentRule, errorMessage, { field });\n  }\n\n  /** Value must be declined if another field is missing */\n  public declinedWithout(field: string, errorMessage?: string) {\n    return this.addFormBooleanRule(declinedWithoutRule, errorMessage, { field });\n  }\n\n  // ==================== Coercion ====================\n\n  /**\n   * Opt in to coercion: an exact query-string-shaped boolean is converted to a\n   * real boolean **before** the type rules run; any other value passes through\n   * unchanged so bad input still fails the type rule.\n   *\n   * Converts exactly `\"true\"` / `\"1\"` / `1` → `true` and `\"false\"` / `\"0\"` / `0`\n   * → `false`. Case-sensitive, no trimming — `\"TRUE\"`, `\"yes\"`, `\"on\"`, `\"\"`, and\n   * `2` all pass through unchanged and fail the type rule. `v.boolean()` does\n   * **not** coerce by default; this only takes effect when explicitly chained.\n   * For form-style truthy strings like `\"yes\"` / `\"on\"`, use `.accepted()` /\n   * `.declined()` instead — those methods opt into their own form-boolean\n   * parsing (a wider value set, case-insensitive on a few forms) and then\n   * apply the accepted/declined pass-fail rule on top of the parsed boolean.\n   *\n   * The output type is unchanged (`Infer<>` keys off the validator class), so\n   * `v.boolean().coerce()` still infers `boolean`.\n   *\n   * @example\n   * v.boolean().coerce()   // \"true\" → true; \"1\" → true; \"0\" → false; \"yes\" → invalid\n   */\n  public coerce() {\n    return this.addMutator(booleanCoerceMutator) as this & { isCoerced: true };\n  }\n\n  // ==================== Strict boolean checks ====================\n\n  /**\n   * Value must be strictly true (not \"yes\", \"on\", 1, etc.)\n   * @alias accepted - strict version\n   */\n  public mustBeTrue(errorMessage?: string) {\n    return this.equal(true, errorMessage);\n  }\n\n  /**\n   * Value must be strictly false (not \"no\", \"off\", 0, etc.)\n   * @alias declined - strict version\n   */\n  public mustBeFalse(errorMessage?: string) {\n    return this.equal(false, errorMessage);\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * @note accepted/declined rules and all cross-field boolean rules\n   * are not representable in JSON Schema and are silently omitted.\n   *\n   * @example\n   * ```ts\n   * v.boolean().toJsonSchema(\"draft-2020-12\")\n   * // → { type: \"boolean\" }\n   *\n   * v.boolean().nullable().toJsonSchema(\"openapi-3.0\")\n   * // → { type: \"boolean\", nullable: true }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult = { type: \"boolean\" };\n    if (this.isNullable) applyNullable(schema, target);\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA4BA,IAAa,mBAAb,cAAsC,mBAAmB;CACvD,AAAO,YAAY,cAAuB;EACxC,MAAM;EACN,KAAK,eAAe,aAAa,YAAY;CAC/C;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAO,OAAO,UAAU;CAC1B;;;;;;;;;;;;;;;;;;;CAoBA,AAAQ,mBACN,MACA,cACA,UAAa,CAAC,GACR;EACN,MAAM,WAAW,KAAK;EAEtB,IAAI,CAAC,SAAS,SAAS,MAAM,YAAY,QAAQ,WAAW,kBAAkB,GAC5E,SAAS,kBAAkB,kBAAkB;EAG/C,SAAS,eAAe,MAAM,cAAc,OAAO;EAEnD,OAAO;CACT;;CAKA,AAAO,SAAS,cAAuB;EACrC,OAAO,KAAK,mBAAmB,cAAc,YAAY;CAC3D;;CAGA,AAAO,WAAW,OAAe,OAAY,cAAuB;EAClE,OAAO,KAAK,mBAAmB,gBAAgB,cAAc;GAAE;GAAO;EAAM,CAAC;CAC/E;;CAGA,AAAO,eAAe,OAAe,OAAY,cAAuB;EACtE,OAAO,KAAK,mBAAmB,oBAAoB,cAAc;GAAE;GAAO;EAAM,CAAC;CACnF;;CAGA,AAAO,mBAAmB,OAAe,cAAuB;EAC9D,OAAO,KAAK,mBAAmB,wBAAwB,cAAc,EAAE,MAAM,CAAC;CAChF;;CAGA,AAAO,kBAAkB,OAAe,cAAuB;EAC7D,OAAO,KAAK,mBAAmB,uBAAuB,cAAc,EAAE,MAAM,CAAC;CAC/E;;CAGA,AAAO,gBAAgB,OAAe,cAAuB;EAC3D,OAAO,KAAK,mBAAmB,qBAAqB,cAAc,EAAE,MAAM,CAAC;CAC7E;;CAKA,AAAO,SAAS,cAAuB;EACrC,OAAO,KAAK,mBAAmB,cAAc,YAAY;CAC3D;;CAGA,AAAO,WAAW,OAAe,OAAY,cAAuB;EAClE,OAAO,KAAK,mBAAmB,gBAAgB,cAAc;GAAE;GAAO;EAAM,CAAC;CAC/E;;CAGA,AAAO,eAAe,OAAe,OAAY,cAAuB;EACtE,OAAO,KAAK,mBAAmB,oBAAoB,cAAc;GAAE;GAAO;EAAM,CAAC;CACnF;;CAGA,AAAO,mBAAmB,OAAe,cAAuB;EAC9D,OAAO,KAAK,mBAAmB,wBAAwB,cAAc,EAAE,MAAM,CAAC;CAChF;;CAGA,AAAO,kBAAkB,OAAe,cAAuB;EAC7D,OAAO,KAAK,mBAAmB,uBAAuB,cAAc,EAAE,MAAM,CAAC;CAC/E;;CAGA,AAAO,gBAAgB,OAAe,cAAuB;EAC3D,OAAO,KAAK,mBAAmB,qBAAqB,cAAc,EAAE,MAAM,CAAC;CAC7E;;;;;;;;;;;;;;;;;;;;;CAwBA,AAAO,SAAS;EACd,OAAO,KAAK,WAAW,oBAAoB;CAC7C;;;;;CAQA,AAAO,WAAW,cAAuB;EACvC,OAAO,KAAK,MAAM,MAAM,YAAY;CACtC;;;;;CAMA,AAAO,YAAY,cAAuB;EACxC,OAAO,KAAK,MAAM,OAAO,YAAY;CACvC;;;;;;;;;;;;;;;;CAiBA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SAA2B,EAAE,MAAM,UAAU;EACnD,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}

package/esm/validators/scalar-validator.mjs

@@ -1,12 +1,12 @@
 import { getRuleOptions } from "../standard-schema/json-schema.mjs";
 import { VALID_RULE, invalidRule } from "../helpers/validation-helpers.mjs";
 import "../helpers/index.mjs";
+import { acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule } from "../rules/scalar/accepted-rule.mjs";
+import { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule } from "../rules/scalar/declined-rule.mjs";
 import { numberMutator } from "../mutators/number-mutators.mjs";
 import { stringMutator } from "../mutators/scalar-mutators.mjs";
 import "../mutators/index.mjs";
 import { PrimitiveValidator } from "./primitive-validator.mjs";
-import { acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule } from "../rules/scalar/accepted-rule.mjs";
-import { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule } from "../rules/scalar/declined-rule.mjs";
 import "../rules/scalar/index.mjs";
 
 //#region ../seal/src/validators/scalar-validator.ts