@zudojs/validation 0.1.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zudojs Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -24,6 +24,37 @@ if (!result.success) {
 }
 ```
 
+Structural guards for untrusted payloads:
+
+```typescript
+import {
+  assertDepthWithinLimit,
+  assertSizeWithinLimit,
+  assertNoCircularReference,
+} from "@zudojs/validation";
+
+// Each aborts as soon as its bound is passed, so the cost is bounded by the
+// limit rather than by the size of the input.
+assertDepthWithinLimit(body, 32);
+assertSizeWithinLimit(body, 1_000_000);
+assertNoCircularReference(body);
+```
+
+## Safety Notes
+
+- Constraint failures do **not** carry the rejected value. `ValidationError` is
+  exposed with a 400, so echoing it would return rejected passwords and tokens
+  to the caller and write them to any log that serializes the error.
+- `parseRecord` and `toFieldErrors` build on null-prototype objects, so a
+  `__proto__` key cannot hijack a validated result.
+- `matches()` strips `g` and `y` from the pattern, which otherwise make
+  `test()` stateful and flip the answer on alternate calls.
+- Constraints carry an optional type guard, so wrong-typed input at a trust
+  boundary reports as a validation failure rather than a `TypeError`.
+- The depth and size guards count a shared subtree once per occurrence, the way
+  a serializer expands it, and walk iteratively so deeply nested input cannot
+  exhaust the stack inside the check.
+
 ## Features
 
 - Zod schema integration

package/dist/validationComposer/index.d.ts

@@ -1,7 +1,9 @@
 /**
  * @zudojs/validation/validationComposer
  *
- * Schema composition and merging utilities.
+ * Composition of validation steps into reusable pipelines.
  */
 export * from "./validationComposer.core.js";
+export * from "./validationComposer.combinators.js";
+export * from "./validationComposer.wrappers.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/validationComposer/index.js

@@ -1,7 +1,9 @@
 /**
  * @zudojs/validation/validationComposer
  *
- * Schema composition and merging utilities.
+ * Composition of validation steps into reusable pipelines.
  */
 export * from "./validationComposer.core.js";
+export * from "./validationComposer.combinators.js";
+export * from "./validationComposer.wrappers.js";
 //# sourceMappingURL=index.js.map

package/dist/validationComposer/validationComposer.combinators.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @zudojs/validation — Validation step combinators.
+ *
+ * @module validationComposer/validationComposer.combinators
+ */
+import type { ValidationStep } from "./validationComposer.core.js";
+/** Combines validators using logical AND semantics. Every validator must succeed. */
+export declare function all<T>(...validators: readonly ValidationStep<T>[]): ValidationStep<T>;
+/** Combines validators using logical OR semantics. Succeeds when at least one validator succeeds. */
+export declare function any<T>(...validators: readonly ValidationStep<T>[]): ValidationStep<T>;
+/**
+ * Runs validators sequentially and returns the first successful result.
+ *
+ * Unlike {@link any}, only the *last* failure is reported when none succeed:
+ * a caller asking for the first match wants to know why the final fallback
+ * did not apply, not to read every alternative's complaint.
+ */
+export declare function first<T>(...validators: readonly ValidationStep<T>[]): ValidationStep<T>;
+/** Negates a validation step. */
+export declare function negate<T>(validator: ValidationStep<T>): ValidationStep<T>;
+//# sourceMappingURL=validationComposer.combinators.d.ts.map

package/dist/validationComposer/validationComposer.combinators.js

@@ -0,0 +1,78 @@
+/**
+ * @zudojs/validation — Validation step combinators.
+ *
+ * @module validationComposer/validationComposer.combinators
+ */
+import { failure, success } from "../validationResult/validationResult.type.js";
+/** The issue reported when no alternative accepted the value. */
+function noValidatorSucceeded() {
+    return {
+        path: [],
+        code: "no_validator_succeeded",
+        message: "No validation rule accepted the value.",
+    };
+}
+/** Combines validators using logical AND semantics. Every validator must succeed. */
+export function all(...validators) {
+    return (value) => {
+        const issues = [];
+        for (const validator of validators) {
+            const result = validator(value);
+            if (!result.success)
+                issues.push(...result.issues);
+        }
+        return issues.length > 0 ? failure(issues) : success(value);
+    };
+}
+/** Combines validators using logical OR semantics. Succeeds when at least one validator succeeds. */
+export function any(...validators) {
+    return (value) => {
+        const issues = [];
+        for (const validator of validators) {
+            const result = validator(value);
+            if (result.success)
+                return result;
+            issues.push(...result.issues);
+        }
+        // Never echo the rejected value: issues flow into a 400 response and
+        // into logs, so `received` would hand back the password or token that
+        // was just refused.
+        return failure(issues.length > 0 ? issues : [noValidatorSucceeded()]);
+    };
+}
+/**
+ * Runs validators sequentially and returns the first successful result.
+ *
+ * Unlike {@link any}, only the *last* failure is reported when none succeed:
+ * a caller asking for the first match wants to know why the final fallback
+ * did not apply, not to read every alternative's complaint.
+ */
+export function first(...validators) {
+    return (value) => {
+        let lastIssues = [];
+        for (const validator of validators) {
+            const result = validator(value);
+            if (result.success)
+                return result;
+            lastIssues = result.issues;
+        }
+        return failure(lastIssues.length > 0 ? lastIssues : [noValidatorSucceeded()]);
+    };
+}
+/** Negates a validation step. */
+export function negate(validator) {
+    return (value) => {
+        const result = validator(value);
+        if (result.success) {
+            return failure([
+                {
+                    path: [],
+                    code: "negated_validation_failed",
+                    message: "Value must not satisfy the supplied validation rule.",
+                },
+            ]);
+        }
+        return success(value);
+    };
+}
+//# sourceMappingURL=validationComposer.combinators.js.map

package/dist/validationComposer/validationComposer.core.d.ts

@@ -6,11 +6,21 @@ export type ValidationStep<T> = (value: T) => ValidationResult<T>;
 /** Options for composing validation operations. */
 export interface ValidationComposerOptions {
     readonly name?: string;
+    /**
+     * Stop after the first failing step. Defaults to true.
+     *
+     * Steps in a pipeline normally build on each other: a later step validating
+     * the shape an earlier coercion was supposed to produce will see the raw
+     * value instead if the pipeline runs on. Set to false only for pipelines of
+     * independent checks, where collecting every issue is the point.
+     */
     readonly stopOnFirstError?: boolean;
 }
 /** Reusable composed validator. */
 export interface ValidationComposer<T> {
     readonly name: string;
+    /** Whether the pipeline halts at the first failing step. */
+    readonly stopOnFirstError: boolean;
     validate(value: T): ValidationResult<T>;
     assert(value: T): T;
 }
@@ -24,28 +34,4 @@ export declare function schemaStep<T>(schema: ValidationSchema<T>): ValidationSt
 export declare function constraintStep<T>(constraint: ValidationConstraint<T>): ValidationStep<T>;
 /** Creates a validation step from multiple constraints. */
 export declare function constraintsStep<T>(constraints: readonly ValidationConstraint<T>[]): ValidationStep<T>;
-/** Combines validators using logical AND semantics. Every validator must succeed. */
-export declare function all<T>(...validators: readonly ValidationStep<T>[]): ValidationStep<T>;
-/** Combines validators using logical OR semantics. Succeeds when at least one validator succeeds. */
-export declare function any<T>(...validators: readonly ValidationStep<T>[]): ValidationStep<T>;
-/** Runs validators sequentially and returns the first successful result. */
-export declare function first<T>(...validators: readonly ValidationStep<T>[]): ValidationStep<T>;
-/** Negates a validation step. */
-export declare function negate<T>(validator: ValidationStep<T>): ValidationStep<T>;
-/** Makes a validation step optional. Undefined values bypass the validator. */
-export declare function optional<T>(validator: ValidationStep<T>): ValidationStep<T | undefined>;
-/** Makes a validation step nullable. Null values bypass the validator. */
-export declare function nullable<T>(validator: ValidationStep<T>): ValidationStep<T | null>;
-/** Makes a validation step optional and nullable. */
-export declare function optionalNullable<T>(validator: ValidationStep<T>): ValidationStep<T | null | undefined>;
-/** Adds a custom validation step to an existing pipeline. */
-export declare function append<T>(composer: ValidationComposer<T>, step: ValidationStep<T>, options?: ValidationComposerOptions): ValidationComposer<T>;
-/** Creates a pipeline that validates a value and returns the original value. */
-export declare function tap<T>(validator: ValidationStep<T>): ValidationStep<T>;
-/** Creates a validation step that only runs when a predicate matches. */
-export declare function when<T>(predicate: (value: T) => boolean, validator: ValidationStep<T>): ValidationStep<T>;
-/** Creates a validation step that runs only when a predicate does not match. */
-export declare function unless<T>(predicate: (value: T) => boolean, validator: ValidationStep<T>): ValidationStep<T>;
-/** Applies a mapping operation after successful validation. */
-export declare function mapValidated<T, U>(validator: ValidationStep<T>, mapper: (value: T) => U): ValidationStep<T>;
 //# sourceMappingURL=validationComposer.core.d.ts.map

package/dist/validationComposer/validationComposer.core.js

@@ -5,9 +5,10 @@ import { ConstraintValidationError } from "../validationErrors/validationError.t
 /** Creates a reusable validator from validation steps. */
 export function createValidationComposer(steps, options = {}) {
     const name = options.name ?? "ValidationComposer";
-    const stopOnFirstError = options.stopOnFirstError ?? false;
+    const stopOnFirstError = options.stopOnFirstError ?? true;
     return Object.freeze({
         name,
+        stopOnFirstError,
         validate(value) {
             let current = value;
             const issues = [];
@@ -50,142 +51,4 @@ export function constraintStep(constraint) {
 export function constraintsStep(constraints) {
     return (value) => checkConstraints(constraints, value);
 }
-/** Combines validators using logical AND semantics. Every validator must succeed. */
-export function all(...validators) {
-    return (value) => {
-        const issues = [];
-        for (const validator of validators) {
-            const result = validator(value);
-            if (!result.success)
-                issues.push(...result.issues);
-        }
-        return issues.length > 0 ? failure(issues) : success(value);
-    };
-}
-/** Combines validators using logical OR semantics. Succeeds when at least one validator succeeds. */
-export function any(...validators) {
-    return (value) => {
-        const issues = [];
-        for (const validator of validators) {
-            const result = validator(value);
-            if (result.success)
-                return result;
-            issues.push(...result.issues);
-        }
-        return failure(issues.length > 0
-            ? issues
-            : [
-                {
-                    path: [],
-                    code: "no_validator_succeeded",
-                    message: "No validation rule accepted the value.",
-                    received: value,
-                },
-            ]);
-    };
-}
-/** Runs validators sequentially and returns the first successful result. */
-export function first(...validators) {
-    return (value) => {
-        let issues = [];
-        for (const validator of validators) {
-            const result = validator(value);
-            if (result.success)
-                return result;
-            issues = [...issues, ...result.issues];
-        }
-        return failure(issues.length > 0
-            ? issues
-            : [
-                {
-                    path: [],
-                    code: "no_validator_succeeded",
-                    message: "No validation rule accepted the value.",
-                    received: value,
-                },
-            ]);
-    };
-}
-/** Negates a validation step. */
-export function negate(validator) {
-    return (value) => {
-        const result = validator(value);
-        if (result.success)
-            return failure([
-                {
-                    path: [],
-                    code: "negated_validation_failed",
-                    message: "Value must not satisfy the supplied validation rule.",
-                    received: value,
-                },
-            ]);
-        return success(value);
-    };
-}
-/** Makes a validation step optional. Undefined values bypass the validator. */
-export function optional(validator) {
-    return (value) => {
-        if (value === undefined)
-            return success(undefined);
-        return validator(value);
-    };
-}
-/** Makes a validation step nullable. Null values bypass the validator. */
-export function nullable(validator) {
-    return (value) => {
-        if (value === null)
-            return success(null);
-        return validator(value);
-    };
-}
-/** Makes a validation step optional and nullable. */
-export function optionalNullable(validator) {
-    return (value) => {
-        if (value === null || value === undefined)
-            return success(value);
-        return validator(value);
-    };
-}
-/** Adds a custom validation step to an existing pipeline. */
-export function append(composer, step, options = {}) {
-    return createValidationComposer([composer.validate, step], {
-        ...options,
-        name: options.name ?? composer.name,
-    });
-}
-/** Creates a pipeline that validates a value and returns the original value. */
-export function tap(validator) {
-    return (value) => {
-        const result = validator(value);
-        if (!result.success)
-            return result;
-        return success(value);
-    };
-}
-/** Creates a validation step that only runs when a predicate matches. */
-export function when(predicate, validator) {
-    return (value) => {
-        if (!predicate(value))
-            return success(value);
-        return validator(value);
-    };
-}
-/** Creates a validation step that runs only when a predicate does not match. */
-export function unless(predicate, validator) {
-    return (value) => {
-        if (predicate(value))
-            return success(value);
-        return validator(value);
-    };
-}
-/** Applies a mapping operation after successful validation. */
-export function mapValidated(validator, mapper) {
-    return (value) => {
-        const result = validator(value);
-        if (!result.success)
-            return result;
-        mapper(result.data);
-        return success(result.data);
-    };
-}
 //# sourceMappingURL=validationComposer.core.js.map

package/dist/validationComposer/validationComposer.wrappers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @zudojs/validation — Wrappers that adapt a validation step.
+ *
+ * Optionality, conditionality and post-validation mapping, kept apart from the
+ * combinators that fold several steps into one.
+ *
+ * @module validationComposer/validationComposer.wrappers
+ */
+import type { ValidationResult } from "../validationResult/validationResult.type.js";
+import type { ValidationComposer, ValidationComposerOptions, ValidationStep } from "./validationComposer.core.js";
+/** Makes a validation step optional. Undefined values bypass the validator. */
+export declare function optional<T>(validator: ValidationStep<T>): ValidationStep<T | undefined>;
+/** Makes a validation step nullable. Null values bypass the validator. */
+export declare function nullable<T>(validator: ValidationStep<T>): ValidationStep<T | null>;
+/** Makes a validation step optional and nullable. */
+export declare function optionalNullable<T>(validator: ValidationStep<T>): ValidationStep<T | null | undefined>;
+/** Adds a custom validation step to an existing pipeline. */
+export declare function append<T>(composer: ValidationComposer<T>, step: ValidationStep<T>, options?: ValidationComposerOptions): ValidationComposer<T>;
+/** Creates a pipeline that validates a value and returns the original value. */
+export declare function tap<T>(validator: ValidationStep<T>): ValidationStep<T>;
+/** Creates a validation step that only runs when a predicate matches. */
+export declare function when<T>(predicate: (value: T) => boolean, validator: ValidationStep<T>): ValidationStep<T>;
+/** Creates a validation step that runs only when a predicate does not match. */
+export declare function unless<T>(predicate: (value: T) => boolean, validator: ValidationStep<T>): ValidationStep<T>;
+/**
+ * Applies a mapping operation after successful validation.
+ *
+ * @returns A step producing the mapped value.
+ */
+export declare function mapValidated<T, U>(validator: ValidationStep<T>, mapper: (value: T) => U): (value: T) => ValidationResult<U>;
+/**
+ * Applies a side effect after successful validation, keeping the value.
+ *
+ * The counterpart to {@link mapValidated} for callers that want to observe a
+ * validated value without changing it.
+ */
+export declare function tapValidated<T>(validator: ValidationStep<T>, observe: (value: T) => void): ValidationStep<T>;
+//# sourceMappingURL=validationComposer.wrappers.d.ts.map

package/dist/validationComposer/validationComposer.wrappers.js

@@ -0,0 +1,96 @@
+/**
+ * @zudojs/validation — Wrappers that adapt a validation step.
+ *
+ * Optionality, conditionality and post-validation mapping, kept apart from the
+ * combinators that fold several steps into one.
+ *
+ * @module validationComposer/validationComposer.wrappers
+ */
+import { success } from "../validationResult/validationResult.type.js";
+import { createValidationComposer } from "./validationComposer.core.js";
+/** Makes a validation step optional. Undefined values bypass the validator. */
+export function optional(validator) {
+    return (value) => {
+        if (value === undefined)
+            return success(undefined);
+        return validator(value);
+    };
+}
+/** Makes a validation step nullable. Null values bypass the validator. */
+export function nullable(validator) {
+    return (value) => {
+        if (value === null)
+            return success(null);
+        return validator(value);
+    };
+}
+/** Makes a validation step optional and nullable. */
+export function optionalNullable(validator) {
+    return (value) => {
+        if (value === null || value === undefined)
+            return success(value);
+        return validator(value);
+    };
+}
+/** Adds a custom validation step to an existing pipeline. */
+export function append(composer, step, options = {}) {
+    return createValidationComposer([(value) => composer.validate(value), step], {
+        ...options,
+        name: options.name ?? composer.name,
+        stopOnFirstError: options.stopOnFirstError ?? composer.stopOnFirstError,
+    });
+}
+/** Creates a pipeline that validates a value and returns the original value. */
+export function tap(validator) {
+    return (value) => {
+        const result = validator(value);
+        if (!result.success)
+            return result;
+        return success(value);
+    };
+}
+/** Creates a validation step that only runs when a predicate matches. */
+export function when(predicate, validator) {
+    return (value) => {
+        if (!predicate(value))
+            return success(value);
+        return validator(value);
+    };
+}
+/** Creates a validation step that runs only when a predicate does not match. */
+export function unless(predicate, validator) {
+    return (value) => {
+        if (predicate(value))
+            return success(value);
+        return validator(value);
+    };
+}
+/**
+ * Applies a mapping operation after successful validation.
+ *
+ * @returns A step producing the mapped value.
+ */
+export function mapValidated(validator, mapper) {
+    return (value) => {
+        const result = validator(value);
+        if (!result.success)
+            return result;
+        return success(mapper(result.data));
+    };
+}
+/**
+ * Applies a side effect after successful validation, keeping the value.
+ *
+ * The counterpart to {@link mapValidated} for callers that want to observe a
+ * validated value without changing it.
+ */
+export function tapValidated(validator, observe) {
+    return (value) => {
+        const result = validator(value);
+        if (!result.success)
+            return result;
+        observe(result.data);
+        return success(result.data);
+    };
+}
+//# sourceMappingURL=validationComposer.wrappers.js.map

package/dist/validationConstraints/collection/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @zudojs/validation — Collection constraints.
+ *
+ * @module validationConstraints/collection
+ */
+export * from "./validationConstraints.array.js";
+export * from "./validationConstraints.collection.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/validationConstraints/collection/index.js

@@ -0,0 +1,8 @@
+/**
+ * @zudojs/validation — Collection constraints.
+ *
+ * @module validationConstraints/collection
+ */
+export * from "./validationConstraints.array.js";
+export * from "./validationConstraints.collection.js";
+//# sourceMappingURL=index.js.map

package/dist/validationConstraints/{validationConstraints.array.d.ts → collection/validationConstraints.array.d.ts}

@@ -1,4 +1,4 @@
-import type { ValidationConstraint } from "./validationConstraints.base.js";
+import type { ValidationConstraint } from "../validationConstraints.base.js";
 /**
  * Requires an array to contain at least a given number of items.
  */

package/dist/validationConstraints/{validationConstraints.array.js → collection/validationConstraints.array.js}

@@ -1,4 +1,19 @@
-import { createConstraint, assertNonNegativeInteger, } from "./validationConstraints.base.js";
+import { createConstraint, assertNonNegativeInteger, } from "../validationConstraints.base.js";
+/** Narrows an unknown value to a readonly array. */
+function isArrayOf(value) {
+    return Array.isArray(value);
+}
+/** Runs an item constraint without letting a type mismatch escape. */
+function itemHolds(constraint, value) {
+    if (constraint.guard && !constraint.guard(value))
+        return false;
+    try {
+        return constraint.validate(value);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Requires an array to contain at least a given number of items.
  */
@@ -8,6 +23,7 @@ export function minItems(minimum) {
         name: `min_items_${minimum}`,
         code: "min_items",
         message: `Value must contain at least ${minimum} items.`,
+        guard: isArrayOf,
     });
 }
 /**
@@ -19,6 +35,7 @@ export function maxItems(maximum) {
         name: `max_items_${maximum}`,
         code: "max_items",
         message: `Value must contain at most ${maximum} items.`,
+        guard: isArrayOf,
     });
 }
 /**
@@ -30,26 +47,29 @@ export function exactItems(length) {
         name: `exact_items_${length}`,
         code: "exact_items",
         message: `Value must contain exactly ${length} items.`,
+        guard: isArrayOf,
     });
 }
 /**
  * Requires every array item to satisfy a constraint.
  */
 export function everyItem(constraint) {
-    return createConstraint((values) => values.every((value) => constraint.validate(value)), {
+    return createConstraint((values) => values.every((value) => itemHolds(constraint, value)), {
         name: `every_${constraint.name}`,
         code: "item_constraint_failed",
         message: constraint.message,
+        guard: isArrayOf,
     });
 }
 /**
  * Requires at least one array item to satisfy a constraint.
  */
 export function someItem(constraint) {
-    return createConstraint((values) => values.some((value) => constraint.validate(value)), {
+    return createConstraint((values) => values.some((value) => itemHolds(constraint, value)), {
         name: `some_${constraint.name}`,
         code: "some_item_constraint_failed",
         message: `At least one item must satisfy ${constraint.name}.`,
+        guard: isArrayOf,
     });
 }
 //# sourceMappingURL=validationConstraints.array.js.map

package/dist/validationConstraints/{validationConstraints.collection.d.ts → collection/validationConstraints.collection.d.ts}

@@ -1,4 +1,4 @@
-import type { ValidationConstraint } from "./validationConstraints.base.js";
+import type { ValidationConstraint } from "../validationConstraints.base.js";
 /**
  * Requires a value to belong to a provided collection.
  */

package/dist/validationConstraints/{validationConstraints.collection.js → collection/validationConstraints.collection.js}

@@ -1,4 +1,4 @@
-import { createConstraint, not } from "./validationConstraints.base.js";
+import { createConstraint, not } from "../validationConstraints.base.js";
 /**
  * Requires a value to belong to a provided collection.
  */

package/dist/validationConstraints/index.d.ts

@@ -5,12 +5,7 @@
  */
 export { createConstraint, checkConstraint, checkConstraints, combineConstraints, not, required, assertNonNegativeInteger, } from "./validationConstraints.base.js";
 export type { ValidationConstraint, ConstraintOptions, } from "./validationConstraints.base.js";
-export { nonEmptyString, minLength, maxLength, lengthBetween, matches, email, uuid, httpUrl, ascii, digits, letters, slug, } from "./validationConstraints.string.js";
-export { min, max, between, finiteNumber, integer, positive, nonNegative, even, odd, } from "./validationConstraints.number.js";
-export { oneOf, noneOf } from "./validationConstraints.collection.js";
-export { isoDate, futureDate, pastDate } from "./validationConstraints.date.js";
-export { minItems, maxItems, exactItems, everyItem, someItem, } from "./validationConstraints.array.js";
-export { assertNoCircularReference, hasCircularReference, } from "./validationConstraints.circular.js";
-export { getSerializationDepth, assertDepthWithinLimit, } from "./validationConstraints.depth.js";
-export { estimateSerializedSize, assertSizeWithinLimit, } from "./validationConstraints.size.js";
+export * from "./scalar/index.js";
+export * from "./collection/index.js";
+export * from "./structure/index.js";
 //# sourceMappingURL=index.d.ts.map