@warlock.js/seal 4.0.171 → 4.1.1

package/esm/validators/array-validator.mjs

@@ -0,0 +1,176 @@
+import { applyNullable, getRuleOptions } from "../standard-schema/json-schema.mjs";
+import { setKeyPath } from "../helpers/path-helpers.mjs";
+import "../helpers/index.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+import { flipArrayMutator, sortArrayMutator, uniqueArrayMutator } from "../mutators/array-mutators.mjs";
+import "../mutators/index.mjs";
+import { betweenLengthRule, lengthRule, maxLengthRule, minLengthRule } from "../rules/length/length-rules.mjs";
+import { sortedArrayRule, uniqueArrayRule } from "../rules/array/array-rules.mjs";
+import { arrayRule } from "../rules/common/type-rules.mjs";
+import "../rules/index.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/array-validator.ts
+/**
+* Array validator class
+*/
+var ArrayValidator = class extends BaseValidator {
+	constructor(validator, errorMessage) {
+		super();
+		this.validator = validator;
+		this.addMutableRule(arrayRule, errorMessage);
+	}
+	/**
+	* Check if value is an array type
+	*/
+	matchesType(value) {
+		return Array.isArray(value);
+	}
+	/**
+	* Clone the validator
+	*/
+	clone() {
+		const cloned = super.clone();
+		cloned.validator = this.validator.clone();
+		return cloned;
+	}
+	/** Reverse array order */
+	flip() {
+		return this.addMutator(flipArrayMutator);
+	}
+	/** Reverse array order (alias) */
+	reverse() {
+		return this.addMutator(flipArrayMutator);
+	}
+	/** Make it has only unique values */
+	onlyUnique() {
+		return this.addMutator(uniqueArrayMutator);
+	}
+	/** Sort array */
+	sort(direction = "asc", key) {
+		return this.addMutator(sortArrayMutator, {
+			direction,
+			key
+		});
+	}
+	/** Array length must be greater than the given length */
+	minLength(length, errorMessage) {
+		return this.addRule(minLengthRule, errorMessage, { minLength: length });
+	}
+	/** Array length must be less than the given length */
+	maxLength(length, errorMessage) {
+		return this.addRule(maxLengthRule, errorMessage, { maxLength: length });
+	}
+	/** Array length must be of the given length */
+	length(length, errorMessage) {
+		return this.addRule(lengthRule, errorMessage, { length });
+	}
+	/**
+	* Array length must be between min and max (inclusive)
+	*
+	* @param min - Minimum length (inclusive)
+	* @param max - Maximum length (inclusive)
+	*
+	* @example
+	* ```ts
+	* v.array(v.string()).between(1, 10)  // Array must have 1 to 10 items
+	* v.array(v.number()).lengthBetween(5, 20)  // Same using alias
+	* ```
+	*
+	* @category Validation Rule
+	*/
+	between(min, max, errorMessage) {
+		return this.addRule(betweenLengthRule, errorMessage, {
+			minLength: min,
+			maxLength: max
+		});
+	}
+	/**
+	* Alias for between() - array length between min and max
+	*/
+	lengthBetween(min, max, errorMessage) {
+		return this.between(min, max, errorMessage);
+	}
+	/** Array must have unique values */
+	unique(errorMessage) {
+		return this.addRule(uniqueArrayRule, errorMessage);
+	}
+	/** Array must be sorted */
+	sorted(direction = "asc", errorMessage) {
+		return this.addRule(sortedArrayRule, errorMessage, { direction });
+	}
+	/** Mutate the data */
+	mutate(data, context) {
+		if (!Array.isArray(data)) return data;
+		return super.mutate([...data], context);
+	}
+	/** Validate array
+	*
+	* Absent input (and absent without `.default()`) propagates as `data: undefined`
+	* so the parent ObjectValidator can omit the key. Without this, optional array
+	* fields would silently materialise as `[]` in the validated output.
+	*/
+	async validate(data, context) {
+		const valueForRules = data ?? this.getDefaultValue();
+		const mutatedData = await this.mutate(valueForRules, context);
+		const result = await super.validate(data, context);
+		if (result.isValid === false) return result;
+		if (mutatedData === void 0 || mutatedData === null) return result;
+		if (!Array.isArray(mutatedData)) return result;
+		const errors = [];
+		const validationPromises = mutatedData.map(async (value, index) => {
+			const childContext = {
+				...context,
+				parent: mutatedData,
+				value,
+				key: index.toString(),
+				path: setKeyPath(context.path, index.toString())
+			};
+			const childResult = await this.validator.validate(value, childContext);
+			mutatedData[index] = childResult.data;
+			if (childResult.isValid === false) errors.push(...childResult.errors);
+		});
+		await Promise.all(validationPromises);
+		return {
+			isValid: errors.length === 0,
+			errors,
+			data: await this.startTransformationPipeline(mutatedData, context)
+		};
+	}
+	/**
+	* @inheritdoc
+	*
+	* Recursively generates JSON Schema for the array items.
+	*
+	* @example
+	* ```ts
+	* v.array(v.string().min(1)).minLength(1).toJsonSchema("draft-2020-12")
+	* // → { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 }
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		const schema = {
+			type: "array",
+			items: this.validator.toJsonSchema(target)
+		};
+		const minOpts = getRuleOptions(this.rules, "minLength");
+		if (minOpts?.minLength !== void 0) schema.minItems = minOpts.minLength;
+		const maxOpts = getRuleOptions(this.rules, "maxLength");
+		if (maxOpts?.maxLength !== void 0) schema.maxItems = maxOpts.maxLength;
+		const betweenOpts = getRuleOptions(this.rules, "betweenLength");
+		if (betweenOpts) {
+			if (betweenOpts.minLength !== void 0) schema.minItems = betweenOpts.minLength;
+			if (betweenOpts.maxLength !== void 0) schema.maxItems = betweenOpts.maxLength;
+		}
+		const lengthOpts = getRuleOptions(this.rules, "length");
+		if (lengthOpts?.length !== void 0) {
+			schema.minItems = lengthOpts.length;
+			schema.maxItems = lengthOpts.length;
+		}
+		if (this.isNullable) applyNullable(schema, target);
+		return schema;
+	}
+};
+
+//#endregion
+export { ArrayValidator };
+//# sourceMappingURL=array-validator.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array-validator.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/array-validator.ts"],"sourcesContent":["import { setKeyPath } from \"../helpers\";\r\nimport { flipArrayMutator, sortArrayMutator, uniqueArrayMutator } from \"../mutators\";\r\nimport {\r\n  arrayRule,\r\n  betweenLengthRule,\r\n  lengthRule,\r\n  maxLengthRule,\r\n  minLengthRule,\r\n  sortedArrayRule,\r\n  uniqueArrayRule,\r\n} from \"../rules\";\r\nimport type { SchemaContext, ValidationResult } from \"../types\";\r\nimport { BaseValidator } from \"./base-validator\";\r\nimport { applyNullable, getRuleOptions } from \"../standard-schema/json-schema\";\r\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\n\r\n/**\r\n * Array validator class\r\n */\r\nexport class ArrayValidator extends BaseValidator {\r\n  public constructor(\r\n    public validator: BaseValidator,\r\n    errorMessage?: string,\r\n  ) {\r\n    super();\r\n    this.addMutableRule(arrayRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Check if value is an array type\r\n   */\r\n  public matchesType(value: any): boolean {\r\n    return Array.isArray(value);\r\n  }\r\n\r\n  /**\r\n   * Clone the validator\r\n   */\r\n  public override clone(): this {\r\n    const cloned = super.clone();\r\n\r\n    cloned.validator = this.validator.clone();\r\n\r\n    return cloned;\r\n  }\r\n\r\n  /** Reverse array order */\r\n  public flip() {\r\n    return this.addMutator(flipArrayMutator);\r\n  }\r\n\r\n  /** Reverse array order (alias) */\r\n  public reverse() {\r\n    return this.addMutator(flipArrayMutator);\r\n  }\r\n\r\n  /** Make it has only unique values */\r\n  public onlyUnique() {\r\n    return this.addMutator(uniqueArrayMutator);\r\n  }\r\n\r\n  /** Sort array */\r\n  public sort(direction: \"asc\" | \"desc\" = \"asc\", key?: string) {\r\n    return this.addMutator(sortArrayMutator, { direction, key });\r\n  }\r\n\r\n  /** Array length must be greater than the given length */\r\n  public minLength(length: number, errorMessage?: string) {\r\n    return this.addRule(minLengthRule, errorMessage, { minLength: length });\r\n  }\r\n\r\n  /** Array length must be less than the given length */\r\n  public maxLength(length: number, errorMessage?: string) {\r\n    return this.addRule(maxLengthRule, errorMessage, { maxLength: length });\r\n  }\r\n\r\n  /** Array length must be of the given length */\r\n  public length(length: number, errorMessage?: string) {\r\n    return this.addRule(lengthRule, errorMessage, { length });\r\n  }\r\n\r\n  /**\r\n   * Array length must be between min and max (inclusive)\r\n   *\r\n   * @param min - Minimum length (inclusive)\r\n   * @param max - Maximum length (inclusive)\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.array(v.string()).between(1, 10)  // Array must have 1 to 10 items\r\n   * v.array(v.number()).lengthBetween(5, 20)  // Same using alias\r\n   * ```\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public between(min: number, max: number, errorMessage?: string) {\r\n    return this.addRule(betweenLengthRule, errorMessage, {\r\n      minLength: min,\r\n      maxLength: max,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Alias for between() - array length between min and max\r\n   */\r\n  public lengthBetween(min: number, max: number, errorMessage?: string) {\r\n    return this.between(min, max, errorMessage);\r\n  }\r\n\r\n  /** Array must have unique values */\r\n  public unique(errorMessage?: string) {\r\n    return this.addRule(uniqueArrayRule, errorMessage);\r\n  }\r\n\r\n  /** Array must be sorted */\r\n  public sorted(direction: \"asc\" | \"desc\" = \"asc\", errorMessage?: string) {\r\n    return this.addRule(sortedArrayRule, errorMessage, { direction });\r\n  }\r\n\r\n  /** Mutate the data */\r\n  public mutate(data: any, context: SchemaContext) {\r\n    if (!Array.isArray(data)) return data;\r\n    return super.mutate([...data], context);\r\n  }\r\n\r\n  /** Validate array\r\n   *\r\n   * Absent input (and absent without `.default()`) propagates as `data: undefined`\r\n   * so the parent ObjectValidator can omit the key. Without this, optional array\r\n   * fields would silently materialise as `[]` in the validated output.\r\n   */\r\n  public async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\r\n    // Apply default when absent, then mutate. Mirrors BaseValidator's\r\n    // `valueForRules = data ?? this.getDefaultValue()` so `.default([...])`\r\n    // works on arrays too.\r\n    const valueForRules = data ?? this.getDefaultValue();\r\n    const mutatedData = await this.mutate(valueForRules, context);\r\n\r\n    const result = await super.validate(data, context);\r\n\r\n    if (result.isValid === false) return result;\r\n\r\n    // Nothing to iterate for absent (no default) or null (nullable) inputs —\r\n    // propagate so the parent ObjectValidator can omit the key.\r\n    if (mutatedData === undefined || mutatedData === null) return result;\r\n\r\n    // Defensive: type rule (arrayRule) should have failed for non-arrays.\r\n    if (!Array.isArray(mutatedData)) return result;\r\n\r\n    const errors: ValidationResult[\"errors\"] = [];\r\n\r\n    // Validate all items in parallel (consistent with ObjectValidator)\r\n    const validationPromises = mutatedData.map(async (value: any, index: number) => {\r\n      const childContext: SchemaContext = {\r\n        ...context,\r\n        parent: mutatedData,\r\n        value,\r\n        key: index.toString(),\r\n        path: setKeyPath(context.path, index.toString()),\r\n      };\r\n\r\n      const childResult = await this.validator.validate(value, childContext);\r\n\r\n      // Update mutated data with validated result\r\n      mutatedData[index] = childResult.data;\r\n\r\n      // Collect errors from this element\r\n      if (childResult.isValid === false) {\r\n        errors.push(...childResult.errors);\r\n      }\r\n    });\r\n\r\n    await Promise.all(validationPromises);\r\n\r\n    return {\r\n      isValid: errors.length === 0,\r\n      errors,\r\n      data: await this.startTransformationPipeline(mutatedData, context),\r\n    };\r\n  }\r\n\r\n  /**\r\n   * @inheritdoc\r\n   *\r\n   * Recursively generates JSON Schema for the array items.\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.array(v.string().min(1)).minLength(1).toJsonSchema(\"draft-2020-12\")\r\n   * // → { type: \"array\", items: { type: \"string\", minLength: 1 }, minItems: 1 }\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    const schema: JsonSchemaResult = {\r\n      type: \"array\",\r\n      items: this.validator.toJsonSchema(target),\r\n    };\r\n\r\n    const minOpts = getRuleOptions(this.rules, \"minLength\");\r\n    if (minOpts?.minLength !== undefined) schema.minItems = minOpts.minLength;\r\n\r\n    const maxOpts = getRuleOptions(this.rules, \"maxLength\");\r\n    if (maxOpts?.maxLength !== undefined) schema.maxItems = maxOpts.maxLength;\r\n\r\n    const betweenOpts = getRuleOptions(this.rules, \"betweenLength\");\r\n    if (betweenOpts) {\r\n      if (betweenOpts.minLength !== undefined) schema.minItems = betweenOpts.minLength;\r\n      if (betweenOpts.maxLength !== undefined) schema.maxItems = betweenOpts.maxLength;\r\n    }\r\n\r\n    const lengthOpts = getRuleOptions(this.rules, \"length\");\r\n    if (lengthOpts?.length !== undefined) {\r\n      schema.minItems = lengthOpts.length;\r\n      schema.maxItems = lengthOpts.length;\r\n    }\r\n\r\n    if (this.isNullable) applyNullable(schema, target);\r\n\r\n    return schema;\r\n  }\r\n}\r\n"],"mappings":"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"}

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

@@ -0,0 +1,491 @@
+import { StandardJSONSchemaV1 } from "../standard-schema/types.mjs";
+import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
+import { ContextualSchemaRule, SchemaRule, SchemaRuleOptions, ValidationAttributesList } from "../types/rule-types.mjs";
+import { SchemaContext } from "../types/context-types.mjs";
+import { ValidationResult } from "../types/result-types.mjs";
+import { ContextualizedMutator, Mutator } from "../types/mutator-types.mjs";
+import { ContextualizedTransformer, SimpleTransformerCallback, TransformerCallback } from "../types/data-transformer-types.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/base-validator.d.ts
+/**
+ * Base validator class - foundation for all validators
+ */
+declare class BaseValidator<TInput = unknown, TOutput = TInput> {
+  rules: ContextualSchemaRule[];
+  mutators: ContextualizedMutator[];
+  protected defaultValue: any | (() => any);
+  protected description?: string;
+  protected shouldOmit: boolean;
+  protected isNullable: boolean;
+  protected isMutable: boolean;
+  /**
+   * Catch state — when `hasCatch` is true and validation fails, `catchValue`
+   * (or its callback result) substitutes for the failed value, and the public
+   * result reports `isValid: true` with no errors.
+   *
+   * See `.catch()` for semantics and the v1 scope (leaf-only).
+   */
+  protected catchValue: any | ((errors: ValidationResult["errors"], originalInput: any) => any | Promise<any>);
+  protected hasCatch: boolean;
+  /**
+   * Whether the field is optional.
+   * - false (default): field is required unless a requiredRule governs the condition.
+   * - true: field can be absent or empty — set by calling .optional().
+   *
+   * Also used as a TypeScript literal brand via the optional() return type.
+   */
+  isOptional: boolean;
+  /**
+   * The single required-condition rule for this field.
+   * - null: field uses strict default (always required when not optional).
+   * - set: the rule governs when the field is required (e.g., requiredIf).
+   *
+   * Stored separately from rules[] and prepended at validate() time.
+   */
+  requiredRule: ContextualSchemaRule | null;
+  /**
+   * Pipeline to transform the mutated/original data before returning it
+   */
+  protected dataTransformers: ContextualizedTransformer[];
+  /**
+   * Attributes text to be replaced on translations
+   * If the value is an object, it will be used as the attributes list for the rule
+   * If the value is a string, it will be used as the attributes list for the rule
+   */
+  protected attributesText: ValidationAttributesList;
+  /**
+   * Attributed that will be always using the attribute translator
+   */
+  protected translatedAttributes: Record<string, string>;
+  /**
+   * Mark the validator as mutable
+   */
+  get mutable(): this;
+  /**
+   * Mark the validator as immutable
+   */
+  get immutable(): this;
+  /**
+   * Get the instance to apply changes to.
+   * By default (immutable), returns a clone so the original is unchanged.
+   * When `.mutable` is set, returns `this` to mutate in place.
+   */
+  protected get instance(): this;
+  /**
+   * Get the default value
+   * Supports lazy evaluation via callbacks
+   */
+  getDefaultValue(): any;
+  /**
+   * Allow null as a valid value.
+   *
+   * Brands the return type with `{ isNullable: true }` so `Infer<>` widens
+   * the inferred output to include `| null`.
+   */
+  nullable(): this & {
+    isNullable: true;
+  };
+  /**
+   * Explicitly disallow null values after calling nullable.
+   *
+   * Brands the return type with `{ isNullable: false }` to cancel any prior
+   * `.nullable()` at the type level.
+   */
+  notNullable(): this & {
+    isNullable: false;
+  };
+  /**
+   * Add transformer with optional options
+   *
+   * @param transform - The transformer callback function
+   * @param options - Optional options to pass to the transformer
+   *
+   * @example
+   * ```ts
+   * // Without options
+   * v.date().addTransformer(data => data.toISOString())
+   *
+   * // With options
+   * v.date().addTransformer(
+   *   (data, { options }) => dayjs(data).format(options.format),
+   *   { format: 'YYYY-MM-DD' }
+   * )
+   * ```
+   */
+  addTransformer(transform: TransformerCallback, options?: any): this;
+  /**
+   * Add transformer with optional options
+   *
+   * @param transform - The transformer callback function
+   * @param options - Optional options to pass to the transformer
+   *
+   * @example
+   * ```ts
+   * // Without options
+   * v.date().addTransformer(data => data.toISOString())
+   *
+   * // With options
+   * v.date().addTransformer(
+   *   (data, { options }) => dayjs(data).format(options.format),
+   *   { format: 'YYYY-MM-DD' }
+   * )
+   * ```
+   */
+  addMutableTransformer(transform: TransformerCallback, options?: any): void;
+  /**
+   * Transform the output value - simple one-time transformation
+   *
+   * @param callback - Simple callback receiving data and context
+   *
+   * @example
+   * ```ts
+   * // Simple transformation
+   * v.string().outputAs(data => data.toUpperCase())
+   *
+   * // With context
+   * v.string().outputAs((data, context) => {
+   *   console.log(`Transforming ${context.path}`);
+   *   return data.toLowerCase();
+   * })
+   * ```
+   */
+  outputAs(callback: SimpleTransformerCallback): this;
+  /**
+   * Transform output to JSON string
+   *
+   * Works with any validator type (string, number, date, object, array, etc.)
+   *
+   * @param indent - Optional indentation for pretty printing (default: 0 for compact)
+   *
+   * @example
+   * ```ts
+   * // Compact JSON
+   * v.object({ name: v.string() }).toJSON()
+   * // Output: '{"name":"John"}'
+   *
+   * // Pretty-printed JSON
+   * v.array(v.object({...})).toJSON(2)
+   * // Output:
+   * // [
+   * //   {
+   * //     "name": "John"
+   * //   }
+   * // ]
+   *
+   * // Works with any type
+   * v.string().toJSON()  // '"hello"'
+   * v.number().toJSON()  // '42'
+   * v.date().toJSON()    // '"2024-10-26T00:00:00.000Z"'
+   * ```
+   *
+   * @category Transformer
+   */
+  toJSON(indent?: number): this;
+  /**
+   * Start data transformation pipeline
+   * Context is passed at runtime, not stored
+   */
+  startTransformationPipeline(data: any, context: SchemaContext): Promise<any>;
+  /**
+   * Set attributes text to be replaced on translations
+   * If the value is an object, it will be used as the attributes list for the rule
+   * If the value is a string, it will be used as the attributes list for the rule
+   *
+   * @example
+   * v.string().attributes({
+   *   name: "Name",
+   *   email: "Email",
+   * });
+   * // Example 2: Add custom attributes for matches
+   * v.string().matches("confirmPassword").attributes({
+   *   matches: {
+   *     confirmPassword: "Confirm Password",
+   *   },
+   * });
+   */
+  attributes(attributes: Record<string, string | Record<string, string>>): this;
+  /**
+   * Define a lazy getter property for each attribute in the given object and use the config attribute translator
+   */
+  transAttributes(attributes: Record<string, string>): this;
+  /**
+   * Add description to the validator
+   */
+  describe(description: string): this;
+  /**
+   * Check if this validator can handle the given value's type
+   * Override this in specific validators to enable type-based routing in union validators
+   *
+   * Default: returns true (validator will attempt to validate any type)
+   *
+   * @param value - The value to check
+   * @returns True if this validator can handle this type
+   *
+   * @example
+   * ```ts
+   * // StringValidator
+   * public matchesType(value: any): boolean {
+   *   return typeof value === 'string';
+   * }
+   *
+   * // Custom FileValidator
+   * public matchesType(value: any): boolean {
+   *   return value instanceof UploadedFile;
+   * }
+   * ```
+   */
+  matchesType(_value: any): boolean;
+  /**
+   * Create a copy of this validator with the same configuration
+   * Copies all rules, mutators, transformers, default values, and settings
+   *
+   * @returns A new validator instance with copied configuration
+   *
+   * @example
+   * ```ts
+   * // Create reusable validator templates
+   * const baseString = v.string().required().trim().min(3);
+   * const emailField = baseString.clone().email();
+   * const usernameField = baseString.clone().alphanumeric().max(20);
+   *
+   * // Works with all validators
+   * const positiveInt = v.int().positive().required();
+   * const ageField = positiveInt.clone().min(18).max(120);
+   * ```
+   */
+  clone(): this;
+  /**
+   * @deprecated This method is no longer needed and does nothing.
+   * Empty values are now automatically skipped for validation rules by default.
+   * Only presence validators (required, present, etc.) will check empty values.
+   * You can safely remove this call from your code.
+   */
+  ignoreEmptyValue(_ignoreEmptyValue?: boolean): this;
+  /**
+   * Omit this field from the validated data output
+   *
+   * Field will still be validated but not included in the final result.
+   * Useful for confirmation fields, captcha, terms acceptance, etc.
+   *
+   * @example
+   * ```ts
+   * v.object({
+   *   password: v.string().required(),
+   *   confirmPassword: v.string().required().sameAs("password").omit(),
+   *   acceptTerms: v.boolean().required().omit(),
+   * });
+   * // Output: { password: "..." }
+   * // confirmPassword and acceptTerms validated but omitted
+   * ```
+   */
+  omit(): this;
+  /**
+   * @alias omit
+   */
+  exclude(): this;
+  /**
+   * Check if this field should be omitted from the output
+   */
+  isOmitted(): boolean;
+  /**
+   * Add rule to the validator
+   */
+  addRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, errorMessage?: string, options?: T): this;
+  /**
+   * Set the required-condition rule for this field.
+   *
+   * Unlike addRule(), this does NOT push to rules[]. The rule is stored in the
+   * dedicated `requiredRule` slot and is prepended to the validation pipeline
+   * at runtime. Only one required rule can be active per field — this replaces
+   * any previously set required rule.
+   *
+   * Also marks the field as not optional (isOptional = false).
+   *
+   * @example
+   * ```ts
+   * // Used internally by required(), requiredIf(), requiredWith(), etc.
+   * BaseValidator.prototype.required = function(msg) {
+   *   return this.setRequiredRule(requiredRule, msg);
+   * };
+   * ```
+   */
+  setRequiredRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, errorMessage?: string, options?: T): this;
+  /**
+   * Add mutable rule
+   */
+  addMutableRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, errorMessage?: string, options?: T): ContextualSchemaRule<T>;
+  /**
+   * Create new rule
+   */
+  protected createRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, errorMessage?: string, options?: T): ContextualSchemaRule<T>;
+  /**
+   * Use a custom or pre-built validation rule
+   *
+   * @param rule - The validation rule to apply
+   * @param options - Rule options including errorMessage and any rule-specific options
+   *
+   * @example
+   * ```ts
+   * import { hexColorRule } from "@warlock.js/seal";
+   *
+   * v.string().useRule(hexColorRule, { errorMessage: "Invalid color" });
+   * ```
+   *
+   * @example
+   * ```ts
+   * // With rule options
+   * v.string().useRule(myCustomRule, {
+   *   customOption: true,
+   *   errorMessage: "Custom validation failed"
+   * });
+   * ```
+   */
+  useRule<T extends SchemaRuleOptions = SchemaRuleOptions>(rule: SchemaRule<T>, options?: T & {
+    errorMessage?: string;
+  }): this;
+  /**
+   * Define custom rule
+   */
+  refine(callback: (value: any, context: SchemaContext) => Promise<string | undefined> | string | undefined): this;
+  /**
+   * Add mutator to the validator
+   */
+  addMutator(mutator: Mutator, options?: any): this;
+  /**
+   * Add mutable mutator
+   */
+  addMutableMutator(mutator: Mutator, options?: any): void;
+  /**
+   * Set default value for the field. The default is used when the input is
+   * absent (`undefined`); it then flows through the rule pipeline.
+   *
+   * Brands the return type with `{ hasDefault: true }` so `Infer<>` treats
+   * the field as guaranteed-present even when chained with `.optional()`.
+   */
+  default(value: any): this & {
+    hasDefault: true;
+  };
+  /**
+   * Fallback to a value when validation fails.
+   *
+   * Complementary to `.default()`: `.default(x)` fires when input is **absent**,
+   * `.catch(y)` fires when input is **present but invalid**. Combine them when
+   * you want both behaviours: `.optional().default(x).catch(y)`.
+   *
+   * The fallback can be a value or a callback `(errors, originalInput) => fallback`.
+   * The callback variant is the only side-channel for the swallowed errors —
+   * use it to log/alert before the fallback substitutes.
+   *
+   * Brands the return type with `{ hasCatch: true }` so `Infer<>` treats the
+   * field as guaranteed-present (the catch ensures a value will always exist).
+   *
+   * **Scope (v1).** Catch is honoured for **leaf validators** (string, number,
+   * boolean, date, …) and for fields inside containers. It is a **no-op on
+   * container validators themselves** (`v.object`, `v.array`, `v.record`,
+   * `v.tuple`, `v.discriminatedUnion`) — those use their own iteration logic
+   * that bypasses the catch hook in `BaseValidator.validate()`.
+   *
+   * @example
+   * ```ts
+   * v.int().min(0).catch(3)                   // bad number → 3
+   * v.string().in(["us", "eu"]).catch("us")   // unknown enum → "us"
+   * v.string().catch((errors, input) => {
+   *   console.warn(`bad user value: ${JSON.stringify(input)}`, errors);
+   *   return "anonymous";
+   * })
+   * ```
+   */
+  catch(fallback: any | ((errors: ValidationResult["errors"], originalInput: any) => any | Promise<any>)): this & {
+    hasCatch: true;
+  };
+  /**
+   * Mutate the data
+   */
+  mutate(data: any, context: SchemaContext): Promise<any>;
+  /**
+   * Set the label for the validator that will be matching the :input attribute
+   */
+  label(label: string): this;
+  /**
+   * Validate the data
+   */
+  validate(data: any, context: SchemaContext): Promise<ValidationResult>;
+  /**
+   * Set rule attributes list
+   */
+  protected setRuleAttributesList(rule: ContextualSchemaRule): void;
+  /**
+   * Standard Schema V1 compliance.
+   *
+   * Allows this validator to be used with any Standard Schema-aware library
+   * (OpenAI structured outputs, LangGraph, TanStack Form, Conform, Valibot adapters, etc.)
+   * without extra adapters.
+   *
+   * Delegates to the `validate()` factory so all `configureSeal()` options
+   * (translations, firstErrorOnly) are picked up automatically at call time.
+   *
+   * Includes Standard JSON Schema support via `jsonSchema.input()` / `jsonSchema.output()`.
+   *
+   * ## How Standard Schema libraries consume this
+   *
+   * You pass the **schema object itself** to the library — they internally read
+   * `schema["~standard"]`. Do NOT pass `schema["~standard"]` directly.
+   *
+   * @example
+   * ```ts
+   * const schema = v.object({ name: v.string().required() });
+   *
+   * // TanStack Form — pass schema, library reads ["~standard"] internally
+   * const form = useForm({ validators: { onChange: schema } });
+   *
+   * // Conform (Remix) — same pattern
+   * const [form] = useForm({ onValidate({ formData }) {
+   *   return parseWithStandardSchema(formData, { schema });
+   * }});
+   *
+   * // Direct validation (lower level — most apps don't need this)
+   * const result = await schema["~standard"].validate({ name: "Hasan" });
+   * // → { value: { name: "Hasan" } }  on success
+   * // → { issues: [{ message: "...", path: [{ key: "name" }] }] }  on failure
+   *
+   * // JSON Schema for OpenAI / LangChain tool calling
+   * const parameters = schema["~standard"].jsonSchema.input({ target: "openai-strict" });
+   * // → { type: "object", properties: {...}, required: [...], additionalProperties: false }
+   * ```
+   *
+   * @note Cross-field rules (sameAs, requiredIf, requiredWith) rely on sibling values
+   * available in the full validation context. When called on a standalone scalar validator,
+   * sibling data is absent and those rules will not evaluate correctly.
+   * Always call on the parent ObjectValidator for full-payload validation.
+   */
+  get ["~standard"](): StandardJSONSchemaV1.Props<TInput, TOutput>;
+  /**
+   * Generate a JSON Schema representation of this validator.
+   *
+   * Supports targets: `"draft-2020-12"` (default), `"draft-07"`, `"openapi-3.0"`.
+   *
+   * Subclasses override this to describe their specific constraints.
+   * The base implementation returns `{}` (permissive — accepts anything),
+   * which is correct for validators with no representable JSON Schema constraints.
+   *
+   * @note Rules that cannot be expressed in JSON Schema are silently omitted:
+   * - Cross-field rules: sameAs, requiredIf, requiredWith, requiredWithout
+   * - Custom callbacks: refine()
+   * - Framework-specific runtime rules (core/cascade plugins)
+   * These rules still run normally at validation time — only absent from JSON Schema.
+   *
+   * @example
+   * ```ts
+   * v.string().min(3).max(50).toJsonSchema("draft-2020-12")
+   * // → { type: "string", minLength: 3, maxLength: 50 }
+   *
+   * v.object({ name: v.string().required(), age: v.int().optional() })
+   *   .toJsonSchema("draft-07")
+   * // → { type: "object", properties: { name: { type: "string" }, age: { type: "integer" } }, required: ["name"] }
+   * ```
+   */
+  toJsonSchema(_target?: JsonSchemaTarget): JsonSchemaResult;
+}
+//#endregion
+export { BaseValidator };
+//# sourceMappingURL=base-validator.d.mts.map