@modulify/validator 0.2.1 → 0.3.1

package/dist/constraints.cjs

@@ -0,0 +1,23 @@
+const require_assert = require("./assert.cjs");
+//#region src/constraints.ts
+var isValidator = (constraint) => "run" in constraint;
+function arrayify(value) {
+	return Array.isArray(value) ? [...value] : [value];
+}
+function matchesConstraints(value, constraints) {
+	let establishedDomain = false;
+	return arrayify(constraints).every((constraint) => {
+		if (isValidator(constraint)) {
+			establishedDomain = false;
+			return constraint.check(value);
+		}
+		if (!establishedDomain && require_assert.isRefinementAssertion(constraint)) return false;
+		const matched = establishedDomain && require_assert.isRefinementAssertion(constraint) ? require_assert.checkRefinementAssertion(constraint, value) : constraint.check(value);
+		if (matched) establishedDomain = true;
+		return matched;
+	});
+}
+//#endregion
+exports.arrayify = arrayify;
+exports.isValidator = isValidator;
+exports.matchesConstraints = matchesConstraints;

package/dist/constraints.d.cts

@@ -0,0 +1,4 @@
+import { CompatibleConstraints, Constraint, InferConstraints, MaybeMany, Validator } from './types/index.cjs';
+export declare const isValidator: <T = unknown>(constraint: Constraint<T>) => constraint is Validator<T>;
+export declare function arrayify<T>(value: MaybeMany<T>): T[];
+export declare function matchesConstraints<C extends MaybeMany<Constraint>>(value: unknown, constraints: CompatibleConstraints<C>): value is InferConstraints<C>;

package/dist/constraints.d.mts

@@ -0,0 +1,4 @@
+import { CompatibleConstraints, Constraint, InferConstraints, MaybeMany, Validator } from './types/index.mjs';
+export declare const isValidator: <T = unknown>(constraint: Constraint<T>) => constraint is Validator<T>;
+export declare function arrayify<T>(value: MaybeMany<T>): T[];
+export declare function matchesConstraints<C extends MaybeMany<Constraint>>(value: unknown, constraints: CompatibleConstraints<C>): value is InferConstraints<C>;

package/dist/constraints.d.ts

@@ -1,4 +1,4 @@
-import { Constraint, InferConstraints, MaybeMany, Validator } from '../types';
+import { CompatibleConstraints, Constraint, InferConstraints, MaybeMany, Validator } from './types/index.js';
 export declare const isValidator: <T = unknown>(constraint: Constraint<T>) => constraint is Validator<T>;
 export declare function arrayify<T>(value: MaybeMany<T>): T[];
-export declare function matchesConstraints<C extends MaybeMany<Constraint>>(value: unknown, constraints: C): value is InferConstraints<C>;
+export declare function matchesConstraints<C extends MaybeMany<Constraint>>(value: unknown, constraints: CompatibleConstraints<C>): value is InferConstraints<C>;

package/dist/constraints.mjs

@@ -0,0 +1,21 @@
+import { checkRefinementAssertion, isRefinementAssertion } from "./assert.mjs";
+//#region src/constraints.ts
+var isValidator = (constraint) => "run" in constraint;
+function arrayify(value) {
+	return Array.isArray(value) ? [...value] : [value];
+}
+function matchesConstraints(value, constraints) {
+	let establishedDomain = false;
+	return arrayify(constraints).every((constraint) => {
+		if (isValidator(constraint)) {
+			establishedDomain = false;
+			return constraint.check(value);
+		}
+		if (!establishedDomain && isRefinementAssertion(constraint)) return false;
+		const matched = establishedDomain && isRefinementAssertion(constraint) ? checkRefinementAssertion(constraint, value) : constraint.check(value);
+		if (matched) establishedDomain = true;
+		return matched;
+	});
+}
+//#endregion
+export { arrayify, isValidator, matchesConstraints };

package/dist/extractors.cjs

@@ -0,0 +1,6 @@
+//#region src/extractors.ts
+var length = (value) => value.length;
+var size = (value) => value.size;
+//#endregion
+exports.length = length;
+exports.size = size;

package/dist/extractors.d.cts

@@ -0,0 +1,2 @@
+export declare const length: <T extends unknown[] | string>(value: T) => number;
+export declare const size: <T extends Map<unknown, unknown> | Set<unknown>>(value: T) => number;

package/dist/extractors.d.mts

@@ -0,0 +1,2 @@
+export declare const length: <T extends unknown[] | string>(value: T) => number;
+export declare const size: <T extends Map<unknown, unknown> | Set<unknown>>(value: T) => number;

package/dist/extractors.mjs

@@ -0,0 +1,5 @@
+//#region src/extractors.ts
+var length = (value) => value.length;
+var size = (value) => value.size;
+//#endregion
+export { length, size };

package/dist/index.cjs

@@ -1,230 +1,151 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const assertions = require("./assertions.cjs");
-const combinators = require("./combinators.cjs");
-const metadata = require("./metadata.cjs.js");
-const assert = require("./assert.cjs");
-const ROOT_PATH = Object.freeze([]);
-const normalizePath = (path) => path ?? ROOT_PATH;
-const isSamePath = (left, right = ROOT_PATH) => {
-  const normalizedLeft = normalizePath(left);
-  if (normalizedLeft.length !== right.length) {
-    return false;
-  }
-  return normalizedLeft.every((part, index) => Object.is(part, right[index]));
+const require_constraints = require("./constraints.cjs");
+const require_metadata = require("./metadata.cjs");
+const require_assert = require("./assert.cjs");
+const require_assertions = require("./assertions.cjs");
+const require_combinators = require("./combinators.cjs");
+const require_violations = require("./violations.cjs");
+//#region src/index.ts
+var collectViolations = async (value, constraints, path = []) => {
+	const validations = [];
+	let establishedAssertionDomain = false;
+	for (const c of require_constraints.arrayify(constraints)) {
+		if (require_constraints.isValidator(c)) {
+			establishedAssertionDomain = false;
+			validations.push(...c.run(collectViolations, value, path).map((v) => v instanceof Promise ? v : Promise.resolve(v)));
+			continue;
+		}
+		if (!establishedAssertionDomain && require_assert.isRefinementAssertion(c)) throw new Error(`Refinement ${String(c.name)} requires a compatible preceding guard`);
+		const v = establishedAssertionDomain && require_assert.isRefinementAssertion(c) ? require_assert.runRefinementAssertion(c, value) : c(value);
+		if (v instanceof Promise) {
+			establishedAssertionDomain = false;
+			if (c.bail) {
+				const awaited = await v;
+				if (awaited) {
+					validations.push(Promise.resolve([Object.assign(awaited, { path: [...path] })]));
+					break;
+				}
+			} else validations.push(v.then((v) => v ? [Object.assign(v, { path: [...path] })] : []));
+		} else if (v) {
+			establishedAssertionDomain = false;
+			validations.push(Promise.resolve([Object.assign(v, { path: [...path] })]));
+			if (c.bail) break;
+		} else establishedAssertionDomain = true;
+	}
+	return settle(value, path, validations);
 };
-const isPathPrefix = (path, prefix) => {
-  if (prefix.length > path.length) {
-    return false;
-  }
-  return prefix.every((part, index) => Object.is(part, path[index]));
-};
-const createTreeState = (path) => ({
-  path: Object.freeze([...path]),
-  self: [],
-  subtree: [],
-  children: /* @__PURE__ */ new Map()
-});
-class TreeNode {
-  constructor(state) {
-    this.path = state.path;
-    this.self = new ViolationCollection(state.self);
-    this.subtree = new ViolationCollection(state.subtree);
-    this.children = new Map(
-      [...state.children.entries()].map(([key, child]) => [key, new TreeNode(child)])
-    );
-  }
-  at(path) {
-    if (!isPathPrefix(path, this.path)) {
-      return void 0;
-    }
-    if (path.length === this.path.length) {
-      return this;
-    }
-    const child = this.children.get(path[this.path.length]);
-    return child?.at(path);
-  }
-}
-const buildTree = (violations) => {
-  const root = createTreeState(ROOT_PATH);
-  violations.forEach((violation) => {
-    const path = normalizePath(violation.path);
-    root.subtree.push(violation);
-    if (path.length === 0) {
-      root.self.push(violation);
-      return;
-    }
-    let current = root;
-    const currentPath = [];
-    path.forEach((segment, index) => {
-      currentPath.push(segment);
-      let child = current.children.get(segment);
-      if (!child) {
-        child = createTreeState(currentPath);
-        current.children.set(segment, child);
-      }
-      child.subtree.push(violation);
-      if (index === path.length - 1) {
-        child.self.push(violation);
-      }
-      current = child;
-    });
-  });
-  return new TreeNode(root);
-};
-class ViolationCollection {
-  constructor(violations) {
-    this.violations = [...violations];
-    this.size = this.violations.length;
-  }
-  [Symbol.iterator]() {
-    return this.violations[Symbol.iterator]();
-  }
-  forEach(callback) {
-    this.violations.forEach((violation, index) => callback(violation, index, this));
-  }
-  map(callback) {
-    return this.violations.map((violation, index) => callback(violation, index, this));
-  }
-  at(path) {
-    return new ViolationCollection(this.violations.filter((violation) => isSamePath(violation.path, path)));
-  }
-  tree() {
-    return buildTree(this.violations);
-  }
-}
-const collection = (violations) => new ViolationCollection(violations);
-const collectViolations = async (value, constraints, path = []) => {
-  const validations = [];
-  for (const c of metadata.arrayify(constraints)) {
-    if (metadata.isValidator(c)) {
-      validations.push(...c.run(collectViolations, value, path).map((v2) => v2 instanceof Promise ? v2 : Promise.resolve(v2)));
-      continue;
-    }
-    const v = c(value);
-    if (v instanceof Promise) {
-      if (c.bail) {
-        const awaited = await v;
-        if (awaited) {
-          validations.push(Promise.resolve([Object.assign(awaited, { path: [...path] })]));
-          break;
-        }
-      } else {
-        validations.push(v.then((v2) => v2 ? [Object.assign(v2, { path: [...path] })] : []));
-      }
-    } else if (v) {
-      validations.push(Promise.resolve([Object.assign(v, { path: [...path] })]));
-      if (c.bail) {
-        break;
-      }
-    }
-  }
-  return settle(value, path, validations);
-};
-const collectViolationsSync = (value, constraints, path = []) => {
-  const violations = [];
-  for (const c of metadata.arrayify(constraints)) {
-    if (metadata.isValidator(c)) {
-      violations.push(...c.run(collectViolationsSync, value, path));
-      continue;
-    }
-    const v = c(value);
-    if (v instanceof Promise) {
-      throw new Error("Found asynchronous validator " + String(c.name));
-    } else if (v) {
-      violations.push(Object.assign(v, { path: [...path] }));
-      if (c.bail) break;
-    }
-  }
-  return flatten(violations);
+collectViolations.sync = false;
+var collectViolationsSync = (value, constraints, path = []) => {
+	const violations = [];
+	let establishedAssertionDomain = false;
+	for (const c of require_constraints.arrayify(constraints)) {
+		if (require_constraints.isValidator(c)) {
+			establishedAssertionDomain = false;
+			violations.push(...c.run(collectViolationsSync, value, path));
+			continue;
+		}
+		if (!establishedAssertionDomain && require_assert.isRefinementAssertion(c)) throw new Error(`Refinement ${String(c.name)} requires a compatible preceding guard`);
+		const v = establishedAssertionDomain && require_assert.isRefinementAssertion(c) ? require_assert.runRefinementAssertion(c, value) : c(value);
+		if (v instanceof Promise) throw new Error("Found asynchronous validator " + String(c.name));
+		else if (v) {
+			establishedAssertionDomain = false;
+			violations.push(Object.assign(v, { path: [...path] }));
+			if (c.bail) break;
+		} else establishedAssertionDomain = true;
+	}
+	return flatten(violations);
 };
+collectViolationsSync.sync = true;
 function toResult(value, violations) {
-  return violations.length === 0 ? [true, value, []] : [false, value, violations];
+	return violations.length === 0 ? [
+		true,
+		value,
+		[]
+	] : [
+		false,
+		value,
+		violations
+	];
 }
 function flatten(recursive) {
-  const flattened = [];
-  recursive.forEach((element) => {
-    flattened.push(...Array.isArray(element) ? flatten(element) : [element]);
-  });
-  return flattened;
+	const flattened = [];
+	recursive.forEach((element) => {
+		flattened.push(...Array.isArray(element) ? flatten(element) : [element]);
+	});
+	return flattened;
 }
 async function settle(value, path, validations) {
-  const violations = [];
-  const settled = await Promise.allSettled(validations);
-  settled.forEach((result) => {
-    if (result.status === "fulfilled") {
-      violations.push(...result.value);
-    } else {
-      violations.push({
-        value,
-        path,
-        violates: { kind: "runtime", name: "validate", code: "runtime.rejection", args: [result.reason] }
-      });
-    }
-  });
-  return violations;
+	const violations = [];
+	(await Promise.allSettled(validations)).forEach((result) => {
+		if (result.status === "fulfilled") violations.push(...result.value);
+		else violations.push({
+			value,
+			path,
+			violates: {
+				kind: "runtime",
+				name: "validate",
+				code: "runtime.rejection",
+				args: [result.reason]
+			}
+		});
+	});
+	return violations;
 }
-const matches = {
-  sync(value, constraints) {
-    return collectViolationsSync(value, constraints).length === 0;
-  }
-};
-const validate = Object.assign(
-  async (value, constraints) => {
-    const violations = await collectViolations(value, constraints);
-    return toResult(
-      value,
-      violations
-    );
-  },
-  {
-    sync(value, constraints) {
-      const violations = collectViolationsSync(value, constraints);
-      return toResult(
-        value,
-        violations
-      );
-    }
-  }
-);
-exports.endsWith = assertions.endsWith;
-exports.hasLength = assertions.hasLength;
-exports.hasPattern = assertions.hasPattern;
-exports.hasSize = assertions.hasSize;
-exports.hasValue = assertions.hasValue;
-exports.isBigInt = assertions.isBigInt;
-exports.isBlob = assertions.isBlob;
-exports.isBoolean = assertions.isBoolean;
-exports.isDate = assertions.isDate;
-exports.isDefined = assertions.isDefined;
-exports.isEmail = assertions.isEmail;
-exports.isFile = assertions.isFile;
-exports.isFunction = assertions.isFunction;
-exports.isMap = assertions.isMap;
-exports.isNaN = assertions.isNaN;
-exports.isNull = assertions.isNull;
-exports.isNumber = assertions.isNumber;
-exports.isSet = assertions.isSet;
-exports.isString = assertions.isString;
-exports.isSymbol = assertions.isSymbol;
-exports.multipleOf = assertions.multipleOf;
-exports.oneOf = assertions.oneOf;
-exports.startsWith = assertions.startsWith;
-exports.discriminatedUnion = combinators.discriminatedUnion;
-exports.each = combinators.each;
-exports.exact = combinators.exact;
-exports.nullable = combinators.nullable;
-exports.nullish = combinators.nullish;
-exports.optional = combinators.optional;
-exports.record = combinators.record;
-exports.shape = combinators.shape;
-exports.tuple = combinators.tuple;
-exports.union = combinators.union;
-exports.custom = metadata.custom;
-exports.describe = metadata.describe;
-exports.meta = metadata.meta;
-exports.assert = assert.assert;
-exports.ViolationCollection = ViolationCollection;
-exports.collection = collection;
+var matches = { sync(value, constraints) {
+	return collectViolationsSync(value, constraints).length === 0;
+} };
+var validate = /* @__PURE__ */ Object.assign(async (value, constraints) => {
+	return toResult(value, await collectViolations(value, constraints));
+}, { sync(value, constraints) {
+	return toResult(value, collectViolationsSync(value, constraints));
+} });
+//#endregion
+exports.ViolationCollection = require_violations.ViolationCollection;
+exports.assert = require_assert.assert;
+exports.collection = require_violations.collection;
+exports.custom = require_metadata.custom;
+exports.describe = require_metadata.describe;
+exports.discriminatedUnion = require_combinators.discriminatedUnion;
+exports.each = require_combinators.each;
+exports.endsWith = require_assertions.endsWith;
+exports.exact = require_combinators.exact;
+exports.hasLength = require_assertions.hasLength;
+exports.hasPattern = require_assertions.hasPattern;
+exports.hasSize = require_assertions.hasSize;
+exports.hasValue = require_assertions.hasValue;
+exports.isBigInt = require_assertions.isBigInt;
+exports.isBlob = require_assertions.isBlob;
+exports.isBoolean = require_assertions.isBoolean;
+exports.isDate = require_assertions.isDate;
+exports.isDefined = require_assertions.isDefined;
+exports.isEmail = require_assertions.isEmail;
+exports.isError = require_assertions.isError;
+exports.isFile = require_assertions.isFile;
+exports.isFiniteNumber = require_assertions.isFiniteNumber;
+exports.isFunction = require_assertions.isFunction;
+exports.isInteger = require_assertions.isInteger;
+exports.isMap = require_assertions.isMap;
+exports.isNaN = require_assertions.isNaN;
+exports.isNull = require_assertions.isNull;
+exports.isNumber = require_assertions.isNumber;
+exports.isPromiseLike = require_assertions.isPromiseLike;
+exports.isRegExp = require_assertions.isRegExp;
+exports.isSafeInteger = require_assertions.isSafeInteger;
+exports.isSet = require_assertions.isSet;
+exports.isString = require_assertions.isString;
+exports.isSymbol = require_assertions.isSymbol;
+exports.isValidDate = require_assertions.isValidDate;
 exports.matches = matches;
+exports.meta = require_metadata.meta;
+exports.multipleOf = require_assertions.multipleOf;
+exports.nullable = require_combinators.nullable;
+exports.nullish = require_combinators.nullish;
+exports.oneOf = require_assertions.oneOf;
+exports.optional = require_combinators.optional;
+exports.record = require_combinators.record;
+exports.refine = require_assert.refine;
+exports.shape = require_combinators.shape;
+exports.startsWith = require_assertions.startsWith;
+exports.tuple = require_combinators.tuple;
+exports.union = require_combinators.union;
 exports.validate = validate;

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+import { CompatibleConstraints, Constraint, InferConstraints, InferViolations, MaybeMany, ValidationResult } from './types/index.cjs';
+export * from './assertions.cjs';
+export * from './combinators.cjs';
+export { collection, ViolationCollection, } from './violations.cjs';
+export { custom, describe, meta, } from './metadata.cjs';
+export type { AllOfConstraintDescriptor, AssertionDescriptor, AssertionStage, AssertionConstraintDescriptor, AsyncObjectShapeRuleDescriptor, BaseConstraintDescriptor, CompatibleConstraints, CompatibleConstraintTuple, CompatibleShapeDescriptor, Constraint, ConstraintDescriptor, ConstraintMetadata, CustomConstraintDescriptor, DescribeAssertionConstraint, DescribeAssertionConstraintTuple, DescribeConstraint, DescribeConstraintTuple, DescribeConstraints, DescribeShapeDescriptor, DescribedValidator, DiscriminatedUnionValidator, EachValidator, FieldsMatchObjectShapeRuleDescriptor, Guard, InferShape, InferConstraint, InferConstraints, InferConstraintViolations, InferViolations, MergeShapeDescriptors, OpaqueValidatorDescriptor, PartialShapeDescriptor, DiscriminatedUnionConstraintDescriptor, EachConstraintDescriptor, NullableValidator, NullishValidator, KnownViolationCode, KnownViolationSubject, ObjectShapeRuleDescriptor, ObjectShapeRuleDescriptorBase, OptionalValidator, RecordValidator, Refinement, RecordConstraintDescriptor, ShapeDescriptor, ShapeFieldSelector, ShapeRefinement, ShapeRefineMethod, ShapeRefineMethodSync, ShapeRefinementViolationInput, ShapeConstraintDescriptor, SyncObjectShapeRuleDescriptor, SyncShapeRefinement, TupleValidator, TupleConstraintDescriptor, UnionValidator, ValidationFailure, ValidationSuccess, ViolationArgs, ViolationCode, ViolationCodeEntry, ViolationCodeRegistry, ViolationEntry, ViolationKind, ViolationKindOf, ViolationNameOf, ViolationSubject, ViolationTreeNode, UnionConstraintDescriptor, ValidationResult, Validator, Violation, WrapperConstraintDescriptor, } from './types/index.cjs';
+export declare const matches: {
+    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C & CompatibleConstraints<C>): value is InferConstraints<C>;
+};
+export declare const validate: (<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C & CompatibleConstraints<C>) => Promise<ValidationResult<InferConstraints<C>, InferViolations<C>>>) & {
+    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C & CompatibleConstraints<C>): ValidationResult<InferConstraints<C>, InferViolations<C>>;
+};

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+import { CompatibleConstraints, Constraint, InferConstraints, InferViolations, MaybeMany, ValidationResult } from './types/index.mjs';
+export * from './assertions.mjs';
+export * from './combinators.mjs';
+export { collection, ViolationCollection, } from './violations.mjs';
+export { custom, describe, meta, } from './metadata.mjs';
+export type { AllOfConstraintDescriptor, AssertionDescriptor, AssertionStage, AssertionConstraintDescriptor, AsyncObjectShapeRuleDescriptor, BaseConstraintDescriptor, CompatibleConstraints, CompatibleConstraintTuple, CompatibleShapeDescriptor, Constraint, ConstraintDescriptor, ConstraintMetadata, CustomConstraintDescriptor, DescribeAssertionConstraint, DescribeAssertionConstraintTuple, DescribeConstraint, DescribeConstraintTuple, DescribeConstraints, DescribeShapeDescriptor, DescribedValidator, DiscriminatedUnionValidator, EachValidator, FieldsMatchObjectShapeRuleDescriptor, Guard, InferShape, InferConstraint, InferConstraints, InferConstraintViolations, InferViolations, MergeShapeDescriptors, OpaqueValidatorDescriptor, PartialShapeDescriptor, DiscriminatedUnionConstraintDescriptor, EachConstraintDescriptor, NullableValidator, NullishValidator, KnownViolationCode, KnownViolationSubject, ObjectShapeRuleDescriptor, ObjectShapeRuleDescriptorBase, OptionalValidator, RecordValidator, Refinement, RecordConstraintDescriptor, ShapeDescriptor, ShapeFieldSelector, ShapeRefinement, ShapeRefineMethod, ShapeRefineMethodSync, ShapeRefinementViolationInput, ShapeConstraintDescriptor, SyncObjectShapeRuleDescriptor, SyncShapeRefinement, TupleValidator, TupleConstraintDescriptor, UnionValidator, ValidationFailure, ValidationSuccess, ViolationArgs, ViolationCode, ViolationCodeEntry, ViolationCodeRegistry, ViolationEntry, ViolationKind, ViolationKindOf, ViolationNameOf, ViolationSubject, ViolationTreeNode, UnionConstraintDescriptor, ValidationResult, Validator, Violation, WrapperConstraintDescriptor, } from './types/index.mjs';
+export declare const matches: {
+    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C & CompatibleConstraints<C>): value is InferConstraints<C>;
+};
+export declare const validate: (<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C & CompatibleConstraints<C>) => Promise<ValidationResult<InferConstraints<C>, InferViolations<C>>>) & {
+    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C & CompatibleConstraints<C>): ValidationResult<InferConstraints<C>, InferViolations<C>>;
+};

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { Constraint, InferConstraints, InferMaybeManyViolations, MaybeMany, ValidationTuple } from '../types';
-export * from './assertions';
-export * from './combinators';
-export { collection, ViolationCollection, } from './violations';
-export { custom, describe, meta, } from './metadata';
-export type { AllOfConstraintDescriptor, AssertionDescriptor, AssertionDescriptorConstraint, Constraint, ConstraintDescriptor, ConstraintDescriptorBase, ConstraintMetadata, CustomConstraintDescriptor, DescribeAssertionConstraint, DescribeAssertionConstraintTuple, DescribeConstraint, DescribeConstraintTuple, DescribeMaybeMany, DescribeObjectDescriptor, DescribedValidator, DiscriminatedUnionValidator, EachValidator, FieldsMatchObjectShapeRuleDescriptor, GenericObjectShapeRuleDescriptor, InferConstraint, InferConstraints, InferConstraintViolations, InferMaybeManyViolations, DiscriminatedUnionConstraintDescriptor, EachConstraintDescriptor, NullableValidator, NullishValidator, KnownViolationCode, KnownViolationSubject, ObjectShapeFieldSelector, ObjectShapeRefinement, ObjectShapeRefinementIssue, ObjectShapeRuleDescriptor, ObjectShapeRuleDescriptorBase, OptionalValidator, RecordValidator, RecordConstraintDescriptor, ShapeConstraintDescriptor, TupleValidator, TupleConstraintDescriptor, UnionValidator, ValidationFailure, ValidationSuccess, ViolationArgs, ViolationCode, ViolationCodeEntry, ViolationCodeRegistry, ViolationEntry, ViolationKind, ViolationKindOf, ViolationNameOf, ViolationSubject, ViolationTreeNode, UnionConstraintDescriptor, ValidationTuple, ValidationResult, Validator, ValidatorDescriptor, Violation, WrapperConstraintDescriptor, } from '../types';
+import { CompatibleConstraints, Constraint, InferConstraints, InferViolations, MaybeMany, ValidationResult } from './types/index.js';
+export * from './assertions.js';
+export * from './combinators.js';
+export { collection, ViolationCollection, } from './violations.js';
+export { custom, describe, meta, } from './metadata.js';
+export type { AllOfConstraintDescriptor, AssertionDescriptor, AssertionStage, AssertionConstraintDescriptor, AsyncObjectShapeRuleDescriptor, BaseConstraintDescriptor, CompatibleConstraints, CompatibleConstraintTuple, CompatibleShapeDescriptor, Constraint, ConstraintDescriptor, ConstraintMetadata, CustomConstraintDescriptor, DescribeAssertionConstraint, DescribeAssertionConstraintTuple, DescribeConstraint, DescribeConstraintTuple, DescribeConstraints, DescribeShapeDescriptor, DescribedValidator, DiscriminatedUnionValidator, EachValidator, FieldsMatchObjectShapeRuleDescriptor, Guard, InferShape, InferConstraint, InferConstraints, InferConstraintViolations, InferViolations, MergeShapeDescriptors, OpaqueValidatorDescriptor, PartialShapeDescriptor, DiscriminatedUnionConstraintDescriptor, EachConstraintDescriptor, NullableValidator, NullishValidator, KnownViolationCode, KnownViolationSubject, ObjectShapeRuleDescriptor, ObjectShapeRuleDescriptorBase, OptionalValidator, RecordValidator, Refinement, RecordConstraintDescriptor, ShapeDescriptor, ShapeFieldSelector, ShapeRefinement, ShapeRefineMethod, ShapeRefineMethodSync, ShapeRefinementViolationInput, ShapeConstraintDescriptor, SyncObjectShapeRuleDescriptor, SyncShapeRefinement, TupleValidator, TupleConstraintDescriptor, UnionValidator, ValidationFailure, ValidationSuccess, ViolationArgs, ViolationCode, ViolationCodeEntry, ViolationCodeRegistry, ViolationEntry, ViolationKind, ViolationKindOf, ViolationNameOf, ViolationSubject, ViolationTreeNode, UnionConstraintDescriptor, ValidationResult, Validator, Violation, WrapperConstraintDescriptor, } from './types/index.js';
 export declare const matches: {
-    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C): value is InferConstraints<C>;
+    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C & CompatibleConstraints<C>): value is InferConstraints<C>;
 };
-export declare const validate: (<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C) => Promise<ValidationTuple<InferConstraints<C>, InferMaybeManyViolations<C>>>) & {
-    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C): ValidationTuple<InferConstraints<C>, InferMaybeManyViolations<C>>;
+export declare const validate: (<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C & CompatibleConstraints<C>) => Promise<ValidationResult<InferConstraints<C>, InferViolations<C>>>) & {
+    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C & CompatibleConstraints<C>): ValidationResult<InferConstraints<C>, InferViolations<C>>;
 };