@warlock.js/seal 4.0.174 → 4.1.2

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

@@ -0,0 +1,253 @@
+import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
+import { Schema } from "../types/schema-types.mjs";
+import { SchemaContext } from "../types/context-types.mjs";
+import { ValidationResult } from "../types/result-types.mjs";
+import { InferInputObjectShape, InferOutputObjectShape } from "../types/inference-types.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/object-validator.d.ts
+/**
+ * Object validator class with generic schema type for proper type inference.
+ *
+ * Threads two distinct inferred shapes into `BaseValidator`'s `TInput`/`TOutput`:
+ *
+ * - `TInput`  = `InferInputObjectShape<TSchema>`  — what `~standard.validate()`
+ *               accepts (caller's pre-validation payload; defaults/catches make
+ *               keys optional)
+ * - `TOutput` = `InferOutputObjectShape<TSchema>` — what `~standard.validate()`
+ *               returns on success (post-default, post-catch shape; guaranteed
+ *               keys are required)
+ *
+ * Both helpers are used directly (not the full `Infer.*` walker) to avoid a
+ * recursive class-base evaluation that would otherwise occur when the
+ * brand-aware widening tries to inspect the class type.
+ */
+declare class ObjectValidator<TSchema extends Schema = Schema> extends BaseValidator<InferInputObjectShape<TSchema>, InferOutputObjectShape<TSchema>> {
+  schema: TSchema;
+  protected shouldAllowUnknown: boolean;
+  protected allowedKeys: string[];
+  protected hasUnknownKeyRule: boolean;
+  constructor(schema: TSchema, errorMessage?: string);
+  /**
+   * Check if value is an object type (plain object, not array or date)
+   */
+  matchesType(value: any): boolean;
+  /** Strip unknown keys from the data */
+  stripUnknown(): this;
+  /** Add list of allowed keys that could be in the data but not necessarily validated */
+  allow(...keys: string[]): this;
+  /** Trim values of the object properties */
+  trim(recursive?: boolean): this;
+  /** Whether to allow unknown properties
+   * Please note it will allow only unknown direct children keys, not nested children keys
+   */
+  allowUnknown(allow?: boolean): this;
+  /**
+   * Create a copy of this object validator with the same configuration
+   * Copies schema, rules, mutators, transformers, and object-specific settings
+   *
+   * @returns A new ObjectValidator instance with copied configuration
+   *
+   * @example
+   * ```ts
+   * const baseUser = v.object({ name: v.string() }).allowUnknown();
+   * const userCopy = baseUser.clone();
+   * // userCopy has the same schema and allowUnknown setting
+   * ```
+   */
+  clone(keys?: string[]): this;
+  /**
+   * Extend this schema with additional fields
+   * Clones the current validator and adds new fields to the schema
+   * **Keeps original configuration** (allowUnknown, stripUnknown, etc.)
+   *
+   * If an ObjectValidator is provided, only its schema is used - its configuration is ignored.
+   * This is useful for creating reusable field collections that can be added to different schemas.
+   *
+   * @param schemaOrValidator - Plain schema object or ObjectValidator to extend with
+   * @returns A new ObjectValidator with merged schema and original configuration
+   *
+   * @example
+   * ```ts
+   * // Extend with plain schema
+   * const baseUser = v.object({
+   *   name: v.string().required(),
+   *   email: v.string().email().required()
+   * }).allowUnknown();
+   *
+   * const adminUser = baseUser.extend({
+   *   role: v.string().in(['admin', 'superadmin']).required()
+   * });
+   * // adminUser has: name, email, role
+   * // adminUser keeps: allowUnknown() from base ✅
+   *
+   * // Extend with ObjectValidator (only schema is used)
+   * const auditFields = v.object({
+   *   createdAt: v.date().required(),
+   *   updatedAt: v.date().required()
+   * }).stripUnknown(); // This config is ignored!
+   *
+   * const fullUser = baseUser.extend(auditFields);
+   * // fullUser has: name, email, createdAt, updatedAt
+   * // fullUser keeps: allowUnknown() from base (NOT stripUnknown from auditFields) ✅
+   *
+   * // Chain multiple extends
+   * const complexSchema = baseUser
+   *   .extend(auditFields)
+   *   .extend({ metadata: v.object({}) });
+   * ```
+   */
+  extend<TExtension extends Schema>(schemaOrValidator: TExtension | ObjectValidator<TExtension>): ObjectValidator<TSchema & TExtension>;
+  /**
+   * Merge with another ObjectValidator
+   * Clones current validator, merges schemas, and **overrides configuration** with other validator's config
+   *
+   * Unlike extend(), merge() combines both schemas AND configurations.
+   * The other validator's configuration (allowUnknown, stripUnknown, etc.) takes precedence.
+   *
+   * @param validator - Another ObjectValidator to merge with
+   * @returns A new ObjectValidator with merged schema and configuration
+   *
+   * @example
+   * ```ts
+   * const baseUser = v.object({
+   *   name: v.string().required()
+   * }).allowUnknown();
+   *
+   * const timestamps = v.object({
+   *   createdAt: v.date().required(),
+   *   updatedAt: v.date().required()
+   * }).stripUnknown();
+   *
+   * const merged = baseUser.merge(timestamps);
+   * // merged has: name, createdAt, updatedAt
+   * // merged config: stripUnknown() from timestamps (overrides allowUnknown) ✅
+   *
+   * // Chain multiple merges
+   * const full = baseUser.merge(timestamps).merge(softDeleteSchema);
+   * ```
+   */
+  merge<TMerge extends Schema>(validator: ObjectValidator<TMerge>): ObjectValidator<TSchema & TMerge>;
+  /**
+   * Create a new schema with only the specified fields
+   * Clones the current validator and keeps only the selected fields
+   * **Preserves all configuration** (allowUnknown, stripUnknown, etc.)
+   *
+   * @param keys - Field names to keep in the schema
+   * @returns A new ObjectValidator with only the picked fields
+   *
+   * @example
+   * ```ts
+   * const fullUser = v.object({
+   *   id: v.int().required(),
+   *   name: v.string().required(),
+   *   email: v.string().email().required(),
+   *   password: v.string().required(),
+   *   role: v.string()
+   * }).allowUnknown();
+   *
+   * // For login - only need email and password
+   * const loginSchema = fullUser.pick('email', 'password');
+   * // loginSchema has: { email, password }
+   * // loginSchema keeps: allowUnknown() ✅
+   *
+   * // For public profile
+   * const publicSchema = fullUser.pick('id', 'name', 'role');
+   * // publicSchema has: { id, name, role }
+   * ```
+   */
+  pick<K extends keyof TSchema>(...keys: K[]): ObjectValidator<Pick<TSchema, K>>;
+  /**
+   * Mark all or the given schema fields as optional
+   */
+  partial<K extends keyof TSchema>(...keys: K[]): this;
+  /**
+   * Make the all or the given fields as required
+   */
+  requiredFields<K extends keyof TSchema>(...keys: K[]): this;
+  /**
+   * Create a new schema excluding the specified fields
+   * Clones the current validator and removes the specified fields
+   * **Preserves all configuration** (allowUnknown, stripUnknown, etc.)
+   *
+   * @param keys - Field names to exclude from the schema
+   * @returns A new ObjectValidator without the excluded fields
+   *
+   * @example
+   * ```ts
+   * const fullUser = v.object({
+   *   id: v.int().required(),
+   *   name: v.string().required(),
+   *   email: v.string().email().required(),
+   *   password: v.string().required(),
+   *   role: v.string()
+   * }).allowUnknown();
+   *
+   * // For updates - exclude id
+   * const updateSchema = fullUser.without('id');
+   * // updateSchema has: { name, email, password, role }
+   * // updateSchema keeps: allowUnknown() ✅
+   *
+   * // For public API - exclude sensitive fields
+   * const publicSchema = fullUser.without('password', 'role');
+   * // publicSchema has: { id, name, email }
+   *
+   * // Combine with other methods
+   * const patchSchema = fullUser.without('id', 'password');
+   * // patchSchema has: { name, email, role }
+   * ```
+   */
+  without<K extends keyof TSchema>(...keys: K[]): ObjectValidator<Omit<TSchema, K>>;
+  /** Mutate the data */
+  mutate(data: any, context: SchemaContext): any;
+  /** Validate the data */
+  validate(data: any, context?: SchemaContext): Promise<ValidationResult>;
+  /**
+   * Check if a validator is a computed or managed field
+   * ManagedValidator extends ComputedValidator, so instanceof catches both
+   */
+  private isComputedValidator;
+  /**
+   * Get all computed/managed fields from the schema
+   */
+  private getComputedFields;
+  /**
+   * @inheritdoc
+   *
+   * Recursively generates JSON Schema for all input fields in the schema.
+   * Computed/managed fields are skipped — they have no input representation.
+   *
+   * **Standard targets** (`draft-2020-12`, `draft-07`, `openapi-3.0`):
+   * - Fields marked `.optional()` are excluded from `required`.
+   *
+   * **`openai-strict` target** (OpenAI Structured Outputs):
+   * - ALL fields appear in `required` — OpenAI rejects schemas with optional fields.
+   * - Optional fields are instead expressed as nullable types:
+   *   `{ type: ["string", "null"] }` so the model can output `null` for them.
+   * - Recursively applies `openai-strict` to all nested objects.
+   *
+   * @example
+   * ```ts
+   * v.object({
+   *   name: v.string().required(),
+   *   age: v.int().optional(),
+   * }).toJsonSchema("draft-2020-12")
+   * // → { type: "object",
+   * //     properties: { name: { type: "string" }, age: { type: "integer" } },
+   * //     required: ["name"], additionalProperties: false }
+   *
+   * v.object({
+   *   name: v.string().required(),
+   *   age: v.int().optional(),
+   * }).toJsonSchema("openai-strict")
+   * // → { type: "object",
+   * //     properties: { name: { type: "string" }, age: { type: ["integer", "null"] } },
+   * //     required: ["name", "age"],   ← all fields
+   * //     additionalProperties: false }
+   * ```
+   */
+  toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
+}
+//#endregion
+export { ObjectValidator };
+//# sourceMappingURL=object-validator.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"object-validator.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/object-validator.ts"],"mappings":";;;;;;;;;;;;AA+BA;;;;;;;;;;;;cAAa,eAAA,iBAAgC,MAAA,GAAS,MAAA,UAAgB,aAAA,CACpE,qBAAA,CAAsB,OAAA,GACtB,sBAAA,CAAuB,OAAA;EAOd,MAAA,EAAQ,OAAA;EAAA,UALP,kBAAA;EAAA,UACA,WAAA;EAAA,UACA,iBAAA;cAGD,MAAA,EAAQ,OAAA,EACf,YAAA;EAyK0B;;;EAhKrB,WAAA,CAAY,KAAA;EAkKU;EA7JtB,YAAA,CAAA;EAyNqB;EA/MrB,KAAA,CAAA,GAAS,IAAA;EA+MyD;EAxMlE,IAAA,CAAK,SAAA;EAwMwD;;;EAhM7D,YAAA,CAAa,KAAA;EAqOkB;;;;;;;;;;;;;EAlNtB,KAAA,CAAM,IAAA;EApE8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoI7D,MAAA,oBAA0B,MAAA,CAAA,CAC/B,iBAAA,EAAmB,UAAA,GAAa,eAAA,CAAgB,UAAA,IAC/C,eAAA,CAAgB,OAAA,GAAU,UAAA;EA6ChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAN,KAAA,gBAAqB,MAAA,CAAA,CAC1B,SAAA,EAAW,eAAA,CAAgB,MAAA,IAC1B,eAAA,CAAgB,OAAA,GAAU,MAAA;EA+Ic;;;;;;;;;;;;;;;;;;;;;;;AAiN+C;;;;;EApSnF,IAAA,iBAAqB,OAAA,CAAA,CAAA,GAAY,IAAA,EAAM,CAAA,KAAM,eAAA,CAAgB,IAAA,CAAK,OAAA,EAAS,CAAA;;;;EAoB3E,OAAA,iBAAwB,OAAA,CAAA,CAAA,GAAY,IAAA,EAAM,CAAA;;;;EAiB1C,cAAA,iBAA+B,OAAA,CAAA,CAAA,GAAY,IAAA,EAAM,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8CjD,OAAA,iBAAwB,OAAA,CAAA,CAAA,GAAY,IAAA,EAAM,CAAA,KAAM,eAAA,CAAgB,IAAA,CAAK,OAAA,EAAS,CAAA;;EAkB9E,MAAA,CAAO,IAAA,OAAW,OAAA,EAAS,aAAA;;EAMrB,QAAA,CACX,IAAA,OACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,gBAAA;;;;;UAgIH,mBAAA;;;;UAOA,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+CQ,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}

package/esm/validators/object-validator.mjs

@@ -0,0 +1,440 @@
+import { applyNullable, wrapNullableStrict } from "../standard-schema/json-schema.mjs";
+import { setKeyPath } from "../helpers/path-helpers.mjs";
+import "../helpers/index.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+import { objectTrimMutator, stripUnknownMutator } from "../mutators/object-mutators.mjs";
+import "../mutators/index.mjs";
+import { objectRule } from "../rules/common/type-rules.mjs";
+import { unknownKeyRule } from "../rules/common/unknown-key.mjs";
+import "../rules/index.mjs";
+import { ComputedValidator } from "./computed-validator.mjs";
+import { except } from "@mongez/reinforcements";
+import { isPlainObject } from "@mongez/supportive-is";
+
+//#region ../../@warlock.js/seal/src/validators/object-validator.ts
+/**
+* Object validator class with generic schema type for proper type inference.
+*
+* Threads two distinct inferred shapes into `BaseValidator`'s `TInput`/`TOutput`:
+*
+* - `TInput`  = `InferInputObjectShape<TSchema>`  — what `~standard.validate()`
+*               accepts (caller's pre-validation payload; defaults/catches make
+*               keys optional)
+* - `TOutput` = `InferOutputObjectShape<TSchema>` — what `~standard.validate()`
+*               returns on success (post-default, post-catch shape; guaranteed
+*               keys are required)
+*
+* Both helpers are used directly (not the full `Infer.*` walker) to avoid a
+* recursive class-base evaluation that would otherwise occur when the
+* brand-aware widening tries to inspect the class type.
+*/
+var ObjectValidator = class ObjectValidator extends BaseValidator {
+	constructor(schema, errorMessage) {
+		super();
+		this.schema = schema;
+		this.shouldAllowUnknown = false;
+		this.allowedKeys = [];
+		this.hasUnknownKeyRule = false;
+		this.addMutableRule(objectRule, errorMessage);
+	}
+	/**
+	* Check if value is an object type (plain object, not array or date)
+	*/
+	matchesType(value) {
+		return isPlainObject(value);
+	}
+	/** Strip unknown keys from the data */
+	stripUnknown() {
+		const validator = this.instance;
+		return validator.addMutator(stripUnknownMutator, { get allowedKeys() {
+			return validator.allowedKeys;
+		} });
+	}
+	/** Add list of allowed keys that could be in the data but not necessarily validated */
+	allow(...keys) {
+		const validator = this.instance;
+		validator.allowedKeys.push(...keys);
+		return validator;
+	}
+	/** Trim values of the object properties */
+	trim(recursive = true) {
+		return this.instance.addMutator(objectTrimMutator, { recursive });
+	}
+	/** Whether to allow unknown properties
+	* Please note it will allow only unknown direct children keys, not nested children keys
+	*/
+	allowUnknown(allow = true) {
+		const validator = this.instance;
+		validator.shouldAllowUnknown = allow;
+		return validator;
+	}
+	/**
+	* Create a copy of this object validator with the same configuration
+	* Copies schema, rules, mutators, transformers, and object-specific settings
+	*
+	* @returns A new ObjectValidator instance with copied configuration
+	*
+	* @example
+	* ```ts
+	* const baseUser = v.object({ name: v.string() }).allowUnknown();
+	* const userCopy = baseUser.clone();
+	* // userCopy has the same schema and allowUnknown setting
+	* ```
+	*/
+	clone(keys) {
+		const cloned = super.clone();
+		const newSchema = {};
+		for (const key in this.schema) {
+			if (keys && !keys.includes(key)) continue;
+			newSchema[key] = this.schema[key].clone();
+		}
+		cloned.schema = newSchema;
+		cloned.shouldAllowUnknown = this.shouldAllowUnknown;
+		cloned.allowedKeys = [...this.allowedKeys];
+		return cloned;
+	}
+	/**
+	* Extend this schema with additional fields
+	* Clones the current validator and adds new fields to the schema
+	* **Keeps original configuration** (allowUnknown, stripUnknown, etc.)
+	*
+	* If an ObjectValidator is provided, only its schema is used - its configuration is ignored.
+	* This is useful for creating reusable field collections that can be added to different schemas.
+	*
+	* @param schemaOrValidator - Plain schema object or ObjectValidator to extend with
+	* @returns A new ObjectValidator with merged schema and original configuration
+	*
+	* @example
+	* ```ts
+	* // Extend with plain schema
+	* const baseUser = v.object({
+	*   name: v.string().required(),
+	*   email: v.string().email().required()
+	* }).allowUnknown();
+	*
+	* const adminUser = baseUser.extend({
+	*   role: v.string().in(['admin', 'superadmin']).required()
+	* });
+	* // adminUser has: name, email, role
+	* // adminUser keeps: allowUnknown() from base ✅
+	*
+	* // Extend with ObjectValidator (only schema is used)
+	* const auditFields = v.object({
+	*   createdAt: v.date().required(),
+	*   updatedAt: v.date().required()
+	* }).stripUnknown(); // This config is ignored!
+	*
+	* const fullUser = baseUser.extend(auditFields);
+	* // fullUser has: name, email, createdAt, updatedAt
+	* // fullUser keeps: allowUnknown() from base (NOT stripUnknown from auditFields) ✅
+	*
+	* // Chain multiple extends
+	* const complexSchema = baseUser
+	*   .extend(auditFields)
+	*   .extend({ metadata: v.object({}) });
+	* ```
+	*/
+	extend(schemaOrValidator) {
+		const extended = this.clone();
+		const schemaToAdd = schemaOrValidator instanceof ObjectValidator ? schemaOrValidator.schema : schemaOrValidator;
+		for (const key in schemaToAdd) extended.schema[key] = schemaToAdd[key].clone();
+		return extended;
+	}
+	/**
+	* Merge with another ObjectValidator
+	* Clones current validator, merges schemas, and **overrides configuration** with other validator's config
+	*
+	* Unlike extend(), merge() combines both schemas AND configurations.
+	* The other validator's configuration (allowUnknown, stripUnknown, etc.) takes precedence.
+	*
+	* @param validator - Another ObjectValidator to merge with
+	* @returns A new ObjectValidator with merged schema and configuration
+	*
+	* @example
+	* ```ts
+	* const baseUser = v.object({
+	*   name: v.string().required()
+	* }).allowUnknown();
+	*
+	* const timestamps = v.object({
+	*   createdAt: v.date().required(),
+	*   updatedAt: v.date().required()
+	* }).stripUnknown();
+	*
+	* const merged = baseUser.merge(timestamps);
+	* // merged has: name, createdAt, updatedAt
+	* // merged config: stripUnknown() from timestamps (overrides allowUnknown) ✅
+	*
+	* // Chain multiple merges
+	* const full = baseUser.merge(timestamps).merge(softDeleteSchema);
+	* ```
+	*/
+	merge(validator) {
+		const merged = this.clone();
+		for (const key in validator.schema) merged.schema[key] = validator.schema[key].clone();
+		merged.shouldAllowUnknown = validator.shouldAllowUnknown;
+		merged.allowedKeys = [...merged.allowedKeys, ...validator.allowedKeys];
+		merged.rules.push(...validator.rules);
+		merged.mutators.push(...validator.mutators);
+		merged.dataTransformers.push(...validator.dataTransformers);
+		merged.attributesText = {
+			...merged.attributesText,
+			...validator.attributesText
+		};
+		merged.translatedAttributes = {
+			...merged.translatedAttributes,
+			...validator.translatedAttributes
+		};
+		return merged;
+	}
+	/**
+	* Create a new schema with only the specified fields
+	* Clones the current validator and keeps only the selected fields
+	* **Preserves all configuration** (allowUnknown, stripUnknown, etc.)
+	*
+	* @param keys - Field names to keep in the schema
+	* @returns A new ObjectValidator with only the picked fields
+	*
+	* @example
+	* ```ts
+	* const fullUser = v.object({
+	*   id: v.int().required(),
+	*   name: v.string().required(),
+	*   email: v.string().email().required(),
+	*   password: v.string().required(),
+	*   role: v.string()
+	* }).allowUnknown();
+	*
+	* // For login - only need email and password
+	* const loginSchema = fullUser.pick('email', 'password');
+	* // loginSchema has: { email, password }
+	* // loginSchema keeps: allowUnknown() ✅
+	*
+	* // For public profile
+	* const publicSchema = fullUser.pick('id', 'name', 'role');
+	* // publicSchema has: { id, name, role }
+	* ```
+	*/
+	pick(...keys) {
+		const picked = this.clone();
+		const newSchema = {};
+		for (const key of keys) if (key in picked.schema) newSchema[key] = picked.schema[key];
+		picked.schema = newSchema;
+		return picked;
+	}
+	/**
+	* Mark all or the given schema fields as optional
+	*/
+	partial(...keys) {
+		const validationSchema = this.clone();
+		if (keys.length === 0) keys = Object.keys(validationSchema.schema);
+		for (const key of keys) validationSchema.schema[key] = validationSchema.schema[key].optional();
+		return validationSchema;
+	}
+	/**
+	* Make the all or the given fields as required
+	*/
+	requiredFields(...keys) {
+		const validationSchema = this.clone();
+		if (keys.length === 0) keys = Object.keys(validationSchema.schema);
+		for (const key of keys) validationSchema.schema[key] = validationSchema.schema[key].required();
+		return validationSchema;
+	}
+	/**
+	* Create a new schema excluding the specified fields
+	* Clones the current validator and removes the specified fields
+	* **Preserves all configuration** (allowUnknown, stripUnknown, etc.)
+	*
+	* @param keys - Field names to exclude from the schema
+	* @returns A new ObjectValidator without the excluded fields
+	*
+	* @example
+	* ```ts
+	* const fullUser = v.object({
+	*   id: v.int().required(),
+	*   name: v.string().required(),
+	*   email: v.string().email().required(),
+	*   password: v.string().required(),
+	*   role: v.string()
+	* }).allowUnknown();
+	*
+	* // For updates - exclude id
+	* const updateSchema = fullUser.without('id');
+	* // updateSchema has: { name, email, password, role }
+	* // updateSchema keeps: allowUnknown() ✅
+	*
+	* // For public API - exclude sensitive fields
+	* const publicSchema = fullUser.without('password', 'role');
+	* // publicSchema has: { id, name, email }
+	*
+	* // Combine with other methods
+	* const patchSchema = fullUser.without('id', 'password');
+	* // patchSchema has: { name, email, role }
+	* ```
+	*/
+	without(...keys) {
+		const filtered = this.clone();
+		const newSchema = {};
+		for (const key in filtered.schema) if (!keys.includes(key)) newSchema[key] = filtered.schema[key];
+		filtered.schema = newSchema;
+		return filtered;
+	}
+	/** Mutate the data */
+	mutate(data, context) {
+		if (!isPlainObject(data)) return data;
+		return super.mutate({ ...data }, context);
+	}
+	/** Validate the data */
+	async validate(data, context = { path: "" }) {
+		context.schema = this.schema;
+		const mutatedData = await this.mutate(data, context);
+		if (this.shouldAllowUnknown === false && !this.hasUnknownKeyRule) {
+			this.hasUnknownKeyRule = true;
+			const rule = this.addMutableRule(unknownKeyRule, void 0, {
+				allowedKeys: this.allowedKeys,
+				schema: this.schema
+			});
+			this.setRuleAttributesList(rule);
+		}
+		const result = await super.validate(mutatedData, context);
+		if (result.isValid === false) return result;
+		if (data === void 0) return result;
+		const errors = [];
+		const validatedData = {};
+		const validationPromises = Object.keys(this.schema).filter((key) => !this.isComputedValidator(this.schema[key])).map(async (key) => {
+			const validator = this.schema[key];
+			const value = mutatedData?.[key] !== void 0 ? mutatedData[key] : validator.getDefaultValue();
+			const childContext = {
+				...context,
+				parent: mutatedData,
+				value,
+				key,
+				path: setKeyPath(context.path, key)
+			};
+			const childResult = await validator.validate(value, childContext);
+			if (childResult.data !== void 0 && !validator.isOmitted()) validatedData[key] = childResult.data;
+			if (childResult.isValid === false) errors.push(...childResult.errors);
+		});
+		await Promise.all(validationPromises);
+		if (errors.length > 0) return {
+			isValid: false,
+			errors,
+			data: void 0
+		};
+		const computedFields = this.getComputedFields();
+		const computedPromises = Object.keys(computedFields).map(async (key) => {
+			const validator = computedFields[key];
+			const childContext = {
+				...context,
+				parent: validatedData,
+				value: void 0
+			};
+			const childResult = await validator.validate(validatedData, childContext);
+			if (childResult.data !== void 0 && !validator.isOmitted()) validatedData[key] = childResult.data;
+			if (childResult.isValid === false) errors.push(...childResult.errors);
+		});
+		await Promise.all(computedPromises);
+		if (errors.length > 0) return {
+			isValid: false,
+			errors,
+			data: void 0
+		};
+		const cleanedData = removeUndefinedValues(validatedData);
+		const transformedData = await this.startTransformationPipeline(cleanedData, context);
+		return {
+			isValid: true,
+			errors: [],
+			data: this.shouldAllowUnknown === false ? transformedData : {
+				...transformedData,
+				...except(mutatedData, Object.keys(this.schema))
+			}
+		};
+	}
+	/**
+	* Check if a validator is a computed or managed field
+	* ManagedValidator extends ComputedValidator, so instanceof catches both
+	*/
+	isComputedValidator(validator) {
+		return validator instanceof ComputedValidator;
+	}
+	/**
+	* Get all computed/managed fields from the schema
+	*/
+	getComputedFields() {
+		const computed = {};
+		for (const [key, validator] of Object.entries(this.schema)) if (validator instanceof ComputedValidator) computed[key] = validator;
+		return computed;
+	}
+	/**
+	* @inheritdoc
+	*
+	* Recursively generates JSON Schema for all input fields in the schema.
+	* Computed/managed fields are skipped — they have no input representation.
+	*
+	* **Standard targets** (`draft-2020-12`, `draft-07`, `openapi-3.0`):
+	* - Fields marked `.optional()` are excluded from `required`.
+	*
+	* **`openai-strict` target** (OpenAI Structured Outputs):
+	* - ALL fields appear in `required` — OpenAI rejects schemas with optional fields.
+	* - Optional fields are instead expressed as nullable types:
+	*   `{ type: ["string", "null"] }` so the model can output `null` for them.
+	* - Recursively applies `openai-strict` to all nested objects.
+	*
+	* @example
+	* ```ts
+	* v.object({
+	*   name: v.string().required(),
+	*   age: v.int().optional(),
+	* }).toJsonSchema("draft-2020-12")
+	* // → { type: "object",
+	* //     properties: { name: { type: "string" }, age: { type: "integer" } },
+	* //     required: ["name"], additionalProperties: false }
+	*
+	* v.object({
+	*   name: v.string().required(),
+	*   age: v.int().optional(),
+	* }).toJsonSchema("openai-strict")
+	* // → { type: "object",
+	* //     properties: { name: { type: "string" }, age: { type: ["integer", "null"] } },
+	* //     required: ["name", "age"],   ← all fields
+	* //     additionalProperties: false }
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		const properties = {};
+		const required = [];
+		const isOpenAIStrict = target === "openai-strict";
+		for (const [key, validator] of Object.entries(this.schema)) {
+			if (validator instanceof ComputedValidator) continue;
+			let fieldSchema = validator.toJsonSchema(target);
+			if (isOpenAIStrict) {
+				if (validator.isOptional) fieldSchema = wrapNullableStrict(fieldSchema);
+				required.push(key);
+			} else if (!validator.isOptional) required.push(key);
+			properties[key] = fieldSchema;
+		}
+		const schema = {
+			type: "object",
+			properties
+		};
+		if (required.length > 0) schema.required = required;
+		if (!this.shouldAllowUnknown) schema.additionalProperties = false;
+		if (this.isNullable) applyNullable(schema, target);
+		return schema;
+	}
+};
+/** Recursively remove undefined values from an object */
+function removeUndefinedValues(obj, visited = /* @__PURE__ */ new WeakMap()) {
+	if (obj === null) return obj;
+	if (Array.isArray(obj)) return obj.map((item) => removeUndefinedValues(item, visited));
+	if (!isPlainObject(obj)) return obj;
+	if (visited.has(obj)) return visited.get(obj);
+	const result = {};
+	visited.set(obj, result);
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) result[key] = removeUndefinedValues(value, visited);
+	return result;
+}
+
+//#endregion
+export { ObjectValidator };
+//# sourceMappingURL=object-validator.mjs.map