@modulify/validator 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,6 +1,31 @@
 # Changelog
 
-All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+## 0.3.0
+
+### ⚠ BREAKING CHANGE* **types:** Public type names were simplified
+* **types:** Exported public type names were renamed without compatibility aliases.
+* Object shape refinements were made async-first
+* shape.refine(...) was changed to the async-first object-level API. Use shape.refine.sync(...) for explicitly sync-safe object rules.
+* ObjectShapeRefinement now describes the async-first refinement contract. Use ObjectShapeRefinementSync for the explicit sync-only type name.
+* validate.sync(...), matches.sync(...), and shape.check(...) now throw when they encounter async object-level shape refinements.
+
+
+### Features
+
+* Object shape refinements were made async-first ([8877b93](https://github.com/modulify/validator/commit/8877b93fa4a8b7c29c918d5d9df08e90ae816379))
+* Built-in value guards were expanded ([1846c17](https://github.com/modulify/validator/commit/1846c176188182b76074b46a60c12d3a2af790a0))
+
+### Bug Fixes
+
+* **predicates:** Shape field validation and inference were corrected ([b2c0e44](https://github.com/modulify/validator/commit/b2c0e441ecf923c0ed3e3a8cbe432a052fed42ce))
+* **types:** Strict assertion contracts were aligned ([2bdd390](https://github.com/modulify/validator/commit/2bdd39019caff5522821ab3b07d832efdd4ca1ab))
+* **build:** Packed ESM and CommonJS consumers were supported ([6fd0c3b](https://github.com/modulify/validator/commit/6fd0c3b2ad7adca314b321283245f831deb2e160))
+
+### Performance Improvements
+
+* **build:** Tree-shaking hints were added ([29bbc70](https://github.com/modulify/validator/commit/29bbc7017b58ef50927ccda745a7be76a8b73ba4))
+
+All notable changes to this project will be documented in this file. Release notes are generated by [@modulify/conventional-release](https://github.com/modulify/conventional/tree/main/packages/conventional-release) from Conventional Commits.
 
 ### [0.2.1](https://github.com/modulify/validator/compare/v0.2.0...v0.2.1) (2026-03-09)
 
@@ -73,3 +98,4 @@ All notable changes to this project will be documented in this file. See [standa
 * Added meta to OneOf violation ([8dd59fc](https://github.com/modulify/validator/commit/8dd59fc2663df1e791ad95449ba774374b6e0bf8))
 * Added possibility to override initial valitators set ([0192f44](https://github.com/modulify/validator/commit/0192f44e4e9e487cbc1230cd588ea62d926e7143))
 * Asynchronous validation ([1505f41](https://github.com/modulify/validator/commit/1505f417bd869ba762f6a91d1d30a360d2505ad4))
+

package/README.md

@@ -204,7 +204,7 @@ if (ok) {
 
 ## Shape API
 
-`shape(...)` is the reusable object-shape API. It validates nested record-like objects and exposes small immutable helpers such as `strict()`, `pick()`, `omit()`, `partial()`, `extend()`, `merge()`, `refine()`, and `fieldsMatch(...)`.
+`shape(...)` is the reusable object-shape API. It validates nested record-like objects and exposes small immutable helpers such as `strict()`, `pick()`, `omit()`, `partial()`, `extend()`, `merge()`, async-first `refine()`, explicit `refine.sync()`, and `fieldsMatch(...)`.
 
 ```typescript
 import {
@@ -270,11 +270,17 @@ A practical way to think about the library is:
 
 In the current API this usually looks like:
 
-- leaf checks with assertions such as `isString`, `isDefined`, `hasLength`, `oneOf`;
+- guard assertions such as `isString`, `isNumber`, `isDefined`, `oneOf(...)` establish the base domain for a value;
+- refinement assertions such as `hasLength(...)`, `hasPattern(...)`, `startsWith(...)`, `hasValue(...)`, `multipleOf(...)` validate properties inside that domain;
 - schema composition with combinators such as `exact`, `optional`, `nullable`, `nullish`, `shape(...)`, `each(...)`;
 - typed validation through `validate(...)` or `validate.sync(...)`;
 - narrowing of the original sync variable through `matches.sync(...)`.
 
+Sequential assertion arrays are stage-aware. A tuple like `[isString, hasLength({ min: 3 })]` is valid, while incompatible combinations like `[isNumber, hasLength({ min: 3 })]` are rejected by TypeScript.
+Refinement assertions are not meant to be passed to `validate(...)` or `matches.sync(...)` on their own.
+
+`validate(...)` is the default async-first validation entrypoint. `validate.sync(...)` and `matches.sync(...)` are specialized sync APIs and will throw if they encounter async validators or async object-level `shape(...).refine(...)` rules.
+
 ## Violations
 
 `validate(...)` returns machine-readable `Violation[]`, and `collection(...)` can wrap that list into a small helper API for exact path lookups and tree traversal.
@@ -354,6 +360,8 @@ Two additional guides are useful when you want faster practical navigation inste
 - [Common Recipes](./docs/en/06-common-recipes.md) - task-oriented examples for payload validation, wrapper choice, reusable shapes, form error mapping, and JSON Schema export.
 - [AI Reference](./docs/en/07-ai-reference.md) - compact contract summary for agents, tooling, and quick semantic lookup.
 
+- [Migration From 0.2.1](./docs/en/09-migration.md)
+
 ## Notes
 
 - Assertions return structured metadata instead of messages.
@@ -366,3 +374,5 @@ Two additional guides are useful when you want faster practical navigation inste
 ## Translations
 
 - [Russian](./docs/ru/README.md)
+
+Release workflow and npm OIDC setup: [Releasing](docs/RELEASING.md).

package/dist/assert-BDOtHdLx.cjs

@@ -0,0 +1,289 @@
+//#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
+//#region src/metadata.ts
+var constraintDescriptorSymbol = Symbol("modulify.validator.descriptor");
+var constraintMetadataSymbol = Symbol("modulify.validator.metadata");
+var cloneCallableConstraint = (constraint) => {
+	const source = constraint;
+	const cloned = ((value) => source(value));
+	const { length: _length, name: _name, prototype: _prototype, ...descriptors } = Object.getOwnPropertyDescriptors(source);
+	Object.defineProperties(cloned, descriptors);
+	try {
+		Object.defineProperty(cloned, "name", {
+			configurable: true,
+			value: source.name
+		});
+	} catch {}
+	Object.setPrototypeOf(cloned, Object.getPrototypeOf(source));
+	return cloned;
+};
+var cloneConstraint = (constraint) => {
+	if (typeof constraint === "function") return cloneCallableConstraint(constraint);
+	return Object.create(Object.getPrototypeOf(constraint), Object.getOwnPropertyDescriptors(constraint));
+};
+var freezeMetadata = (metadata) => Object.freeze({ ...metadata });
+var getConstraintMetadata = (constraint) => {
+	return constraint[constraintMetadataSymbol];
+};
+var getDescriptorFactory = (constraint) => {
+	return constraint[constraintDescriptorSymbol];
+};
+var getPublicDescriptor = (constraint) => {
+	if (!isValidator(constraint)) return;
+	const { describe } = constraint;
+	return typeof describe === "function" ? describe.call(constraint) : void 0;
+};
+var inferAssertionDescriptor = (assertion) => ({
+	kind: "assertion",
+	name: assertion.name,
+	bail: assertion.bail,
+	code: assertion.name,
+	args: [],
+	constraints: assertion.constraints.map(([, , code, ...args]) => ({
+		code,
+		args
+	}))
+});
+var withMetadata = (descriptor, metadata) => {
+	if (!metadata) return descriptor;
+	return {
+		...descriptor,
+		metadata
+	};
+};
+var attachConstraintDescriptor = (constraint, describe) => {
+	Object.defineProperty(constraint, constraintDescriptorSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: describe,
+		writable: false
+	});
+	return constraint;
+};
+var meta = (constraint, metadata) => {
+	const cloned = cloneConstraint(constraint);
+	const nextMetadata = freezeMetadata({
+		...getConstraintMetadata(constraint) ?? {},
+		...metadata
+	});
+	Object.defineProperty(cloned, constraintMetadataSymbol, {
+		configurable: true,
+		enumerable: false,
+		value: nextMetadata,
+		writable: false
+	});
+	return cloned;
+};
+var custom = (validator) => validator;
+var describeConstraints = (constraints) => {
+	const values = arrayify(constraints);
+	return values.length === 1 ? describe(values[0]) : {
+		kind: "allOf",
+		constraints: values.map((value) => describe(value))
+	};
+};
+var describe = (constraint) => {
+	const factory = getDescriptorFactory(constraint);
+	const metadata = getConstraintMetadata(constraint);
+	if (factory) return withMetadata(factory(), metadata);
+	const publicDescriptor = getPublicDescriptor(constraint);
+	if (publicDescriptor) return withMetadata(publicDescriptor, metadata);
+	if (isValidator(constraint)) return withMetadata({ kind: "validator" }, metadata);
+	return withMetadata(inferAssertionDescriptor(constraint), metadata);
+};
+//#endregion
+//#region src/assert.ts
+var assertionStageSymbol = Symbol("modulify.validator.assertion.stage");
+var runRefinementSymbol = Symbol("modulify.validator.assertion.runRefinement");
+var checkRefinementSymbol = Symbol("modulify.validator.assertion.checkRefinement");
+var createAssertion = (stage, predicate, meta, constraints = []) => {
+	const assertionCode = meta.code ?? meta.name;
+	const assertionArgs = meta.args ?? [];
+	const violationSubject = {
+		kind: "assertion",
+		name: meta.name,
+		code: assertionCode,
+		args: assertionArgs
+	};
+	const runConstraints = (value) => {
+		for (const [extract, check, code, ...args] of constraints) if (!check(extract(value), ...args)) return {
+			value,
+			violates: {
+				kind: "assertion",
+				name: meta.name,
+				code,
+				args
+			}
+		};
+		return null;
+	};
+	const checkConstraints = (value) => !constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args));
+	const assertion = ((value) => {
+		if (!predicate(value)) return {
+			value,
+			violates: violationSubject
+		};
+		return runConstraints(value);
+	});
+	Object.defineProperties(assertion, {
+		name: {
+			configurable: true,
+			value: meta.name
+		},
+		bail: {
+			enumerable: true,
+			value: meta.bail
+		},
+		constraints: {
+			enumerable: true,
+			value: constraints
+		},
+		check: {
+			enumerable: true,
+			value: (value) => predicate(value) && checkConstraints(value)
+		},
+		[assertionStageSymbol]: {
+			enumerable: false,
+			value: stage
+		},
+		[runRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => runConstraints(value)
+		},
+		[checkRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => checkConstraints(value)
+		}
+	});
+	return /* @__PURE__ */ attachConstraintDescriptor(assertion, () => ({
+		kind: "assertion",
+		name: meta.name,
+		bail: meta.bail,
+		code: assertionCode,
+		args: assertionArgs,
+		constraints: constraints.map(([, , code, ...args]) => ({
+			code,
+			args
+		}))
+	}));
+};
+var assert = (predicate, meta, constraints = []) => {
+	return createAssertion("guard", predicate, meta, constraints);
+};
+var isRefinementAssertion = (constraint) => {
+	return typeof constraint === "function" && constraint[assertionStageSymbol] === "refinement";
+};
+var runRefinementAssertion = (constraint, value) => {
+	const runRefinement = constraint[runRefinementSymbol];
+	return runRefinement ? runRefinement(value) : constraint(value);
+};
+var checkRefinementAssertion = (constraint, value) => {
+	const checkRefinement = constraint[checkRefinementSymbol];
+	return checkRefinement ? checkRefinement(value) : constraint.check(value);
+};
+var createRefinement = (meta, constraints = []) => {
+	return createAssertion("refinement", ((value) => true), meta, constraints);
+};
+var refine = createRefinement;
+//#endregion
+Object.defineProperty(exports, "arrayify", {
+	enumerable: true,
+	get: function() {
+		return arrayify;
+	}
+});
+Object.defineProperty(exports, "assert", {
+	enumerable: true,
+	get: function() {
+		return assert;
+	}
+});
+Object.defineProperty(exports, "attachConstraintDescriptor", {
+	enumerable: true,
+	get: function() {
+		return attachConstraintDescriptor;
+	}
+});
+Object.defineProperty(exports, "checkRefinementAssertion", {
+	enumerable: true,
+	get: function() {
+		return checkRefinementAssertion;
+	}
+});
+Object.defineProperty(exports, "createRefinement", {
+	enumerable: true,
+	get: function() {
+		return createRefinement;
+	}
+});
+Object.defineProperty(exports, "custom", {
+	enumerable: true,
+	get: function() {
+		return custom;
+	}
+});
+Object.defineProperty(exports, "describe", {
+	enumerable: true,
+	get: function() {
+		return describe;
+	}
+});
+Object.defineProperty(exports, "describeConstraints", {
+	enumerable: true,
+	get: function() {
+		return describeConstraints;
+	}
+});
+Object.defineProperty(exports, "isRefinementAssertion", {
+	enumerable: true,
+	get: function() {
+		return isRefinementAssertion;
+	}
+});
+Object.defineProperty(exports, "isValidator", {
+	enumerable: true,
+	get: function() {
+		return isValidator;
+	}
+});
+Object.defineProperty(exports, "matchesConstraints", {
+	enumerable: true,
+	get: function() {
+		return matchesConstraints;
+	}
+});
+Object.defineProperty(exports, "meta", {
+	enumerable: true,
+	get: function() {
+		return meta;
+	}
+});
+Object.defineProperty(exports, "refine", {
+	enumerable: true,
+	get: function() {
+		return refine;
+	}
+});
+Object.defineProperty(exports, "runRefinementAssertion", {
+	enumerable: true,
+	get: function() {
+		return runRefinementAssertion;
+	}
+});

package/dist/assert-CzMg5aO7.mjs

@@ -0,0 +1,206 @@
+//#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
+//#region src/metadata.ts
+var constraintDescriptorSymbol = Symbol("modulify.validator.descriptor");
+var constraintMetadataSymbol = Symbol("modulify.validator.metadata");
+var cloneCallableConstraint = (constraint) => {
+	const source = constraint;
+	const cloned = ((value) => source(value));
+	const { length: _length, name: _name, prototype: _prototype, ...descriptors } = Object.getOwnPropertyDescriptors(source);
+	Object.defineProperties(cloned, descriptors);
+	try {
+		Object.defineProperty(cloned, "name", {
+			configurable: true,
+			value: source.name
+		});
+	} catch {}
+	Object.setPrototypeOf(cloned, Object.getPrototypeOf(source));
+	return cloned;
+};
+var cloneConstraint = (constraint) => {
+	if (typeof constraint === "function") return cloneCallableConstraint(constraint);
+	return Object.create(Object.getPrototypeOf(constraint), Object.getOwnPropertyDescriptors(constraint));
+};
+var freezeMetadata = (metadata) => Object.freeze({ ...metadata });
+var getConstraintMetadata = (constraint) => {
+	return constraint[constraintMetadataSymbol];
+};
+var getDescriptorFactory = (constraint) => {
+	return constraint[constraintDescriptorSymbol];
+};
+var getPublicDescriptor = (constraint) => {
+	if (!isValidator(constraint)) return;
+	const { describe } = constraint;
+	return typeof describe === "function" ? describe.call(constraint) : void 0;
+};
+var inferAssertionDescriptor = (assertion) => ({
+	kind: "assertion",
+	name: assertion.name,
+	bail: assertion.bail,
+	code: assertion.name,
+	args: [],
+	constraints: assertion.constraints.map(([, , code, ...args]) => ({
+		code,
+		args
+	}))
+});
+var withMetadata = (descriptor, metadata) => {
+	if (!metadata) return descriptor;
+	return {
+		...descriptor,
+		metadata
+	};
+};
+var attachConstraintDescriptor = (constraint, describe) => {
+	Object.defineProperty(constraint, constraintDescriptorSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: describe,
+		writable: false
+	});
+	return constraint;
+};
+var meta = (constraint, metadata) => {
+	const cloned = cloneConstraint(constraint);
+	const nextMetadata = freezeMetadata({
+		...getConstraintMetadata(constraint) ?? {},
+		...metadata
+	});
+	Object.defineProperty(cloned, constraintMetadataSymbol, {
+		configurable: true,
+		enumerable: false,
+		value: nextMetadata,
+		writable: false
+	});
+	return cloned;
+};
+var custom = (validator) => validator;
+var describeConstraints = (constraints) => {
+	const values = arrayify(constraints);
+	return values.length === 1 ? describe(values[0]) : {
+		kind: "allOf",
+		constraints: values.map((value) => describe(value))
+	};
+};
+var describe = (constraint) => {
+	const factory = getDescriptorFactory(constraint);
+	const metadata = getConstraintMetadata(constraint);
+	if (factory) return withMetadata(factory(), metadata);
+	const publicDescriptor = getPublicDescriptor(constraint);
+	if (publicDescriptor) return withMetadata(publicDescriptor, metadata);
+	if (isValidator(constraint)) return withMetadata({ kind: "validator" }, metadata);
+	return withMetadata(inferAssertionDescriptor(constraint), metadata);
+};
+//#endregion
+//#region src/assert.ts
+var assertionStageSymbol = Symbol("modulify.validator.assertion.stage");
+var runRefinementSymbol = Symbol("modulify.validator.assertion.runRefinement");
+var checkRefinementSymbol = Symbol("modulify.validator.assertion.checkRefinement");
+var createAssertion = (stage, predicate, meta, constraints = []) => {
+	const assertionCode = meta.code ?? meta.name;
+	const assertionArgs = meta.args ?? [];
+	const violationSubject = {
+		kind: "assertion",
+		name: meta.name,
+		code: assertionCode,
+		args: assertionArgs
+	};
+	const runConstraints = (value) => {
+		for (const [extract, check, code, ...args] of constraints) if (!check(extract(value), ...args)) return {
+			value,
+			violates: {
+				kind: "assertion",
+				name: meta.name,
+				code,
+				args
+			}
+		};
+		return null;
+	};
+	const checkConstraints = (value) => !constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args));
+	const assertion = ((value) => {
+		if (!predicate(value)) return {
+			value,
+			violates: violationSubject
+		};
+		return runConstraints(value);
+	});
+	Object.defineProperties(assertion, {
+		name: {
+			configurable: true,
+			value: meta.name
+		},
+		bail: {
+			enumerable: true,
+			value: meta.bail
+		},
+		constraints: {
+			enumerable: true,
+			value: constraints
+		},
+		check: {
+			enumerable: true,
+			value: (value) => predicate(value) && checkConstraints(value)
+		},
+		[assertionStageSymbol]: {
+			enumerable: false,
+			value: stage
+		},
+		[runRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => runConstraints(value)
+		},
+		[checkRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => checkConstraints(value)
+		}
+	});
+	return /* @__PURE__ */ attachConstraintDescriptor(assertion, () => ({
+		kind: "assertion",
+		name: meta.name,
+		bail: meta.bail,
+		code: assertionCode,
+		args: assertionArgs,
+		constraints: constraints.map(([, , code, ...args]) => ({
+			code,
+			args
+		}))
+	}));
+};
+var assert = (predicate, meta, constraints = []) => {
+	return createAssertion("guard", predicate, meta, constraints);
+};
+var isRefinementAssertion = (constraint) => {
+	return typeof constraint === "function" && constraint[assertionStageSymbol] === "refinement";
+};
+var runRefinementAssertion = (constraint, value) => {
+	const runRefinement = constraint[runRefinementSymbol];
+	return runRefinement ? runRefinement(value) : constraint(value);
+};
+var checkRefinementAssertion = (constraint, value) => {
+	const checkRefinement = constraint[checkRefinementSymbol];
+	return checkRefinement ? checkRefinement(value) : constraint.check(value);
+};
+var createRefinement = (meta, constraints = []) => {
+	return createAssertion("refinement", ((value) => true), meta, constraints);
+};
+var refine = createRefinement;
+//#endregion
+export { refine as a, custom as c, meta as d, arrayify as f, isRefinementAssertion as i, describe as l, matchesConstraints as m, checkRefinementAssertion as n, runRefinementAssertion as o, isValidator as p, createRefinement as r, attachConstraintDescriptor as s, assert as t, describeConstraints as u };

package/dist/assert.cjs

@@ -1,66 +1,8 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const metadata = require("./metadata.cjs.js");
-const assert = (predicate, meta, constraints = []) => {
-  const assertionCode = meta.code ?? meta.name;
-  const assertionArgs = meta.args ?? [];
-  const violationSubject = {
-    kind: "assertion",
-    name: meta.name,
-    code: assertionCode,
-    args: assertionArgs
-  };
-  const assertion = ((value) => {
-    if (!predicate(value)) {
-      return {
-        value,
-        violates: violationSubject
-      };
-    }
-    for (const [extract, check, code, ...args] of constraints) {
-      if (!check(extract(value), ...args)) {
-        const constraintSubject = {
-          kind: "assertion",
-          name: meta.name,
-          code,
-          args
-        };
-        return {
-          value,
-          violates: constraintSubject
-        };
-      }
-    }
-    return null;
-  });
-  Object.defineProperties(assertion, {
-    name: {
-      configurable: true,
-      value: meta.name
-    },
-    bail: {
-      enumerable: true,
-      value: meta.bail
-    },
-    constraints: {
-      enumerable: true,
-      value: constraints
-    },
-    check: {
-      enumerable: true,
-      value: (value) => predicate(value) && (!constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args)))
-    }
-  });
-  return metadata.attachConstraintDescriptor(assertion, () => ({
-    kind: "assertion",
-    name: meta.name,
-    bail: meta.bail,
-    code: assertionCode,
-    args: assertionArgs,
-    constraints: constraints.map(([, , code, ...args]) => ({
-      code,
-      args
-    }))
-  }));
-};
-exports.assert = assert;
+const require_assert = require("./assert-BDOtHdLx.cjs");
+exports.assert = require_assert.assert;
+exports.checkRefinementAssertion = require_assert.checkRefinementAssertion;
+exports.createRefinement = require_assert.createRefinement;
+exports.isRefinementAssertion = require_assert.isRefinementAssertion;
+exports.refine = require_assert.refine;
+exports.runRefinementAssertion = require_assert.runRefinementAssertion;

package/dist/assert.d.cts

@@ -0,0 +1,37 @@
+import { Assertion, Constraint, AssertionConstraint, Guard, Predicate, Refinement } from './types/index.cjs';
+type AssertMeta = {
+    name: string;
+    bail: boolean;
+    code?: string;
+    args?: readonly unknown[];
+};
+type ResolveAssertionCode<Name extends string, Code extends string | undefined> = Code extends string ? Code : Name;
+type ResolveAssertionArgs<Args extends readonly unknown[] | undefined> = Args extends readonly unknown[] ? Args : [];
+type ConstraintInputFunction<C extends AssertionConstraint> = C extends unknown ? (value: Parameters<C[0]>[0]) => void : never;
+type ConstraintInput<C extends readonly AssertionConstraint[]> = C extends readonly [] ? unknown : ConstraintInputFunction<C[number]> extends (value: infer Input) => void ? Input : never;
+type ConstraintArgs<C extends AssertionConstraint> = C extends readonly [unknown, unknown, string, ...infer Args] ? Args : never;
+type CompatibleAssertionConstraints<Input, C extends readonly AssertionConstraint[]> = {
+    [K in keyof C]: AssertionConstraint<Input, ReturnType<C[K][0]>, ConstraintArgs<C[K]>, C[K][2]>;
+};
+export declare const assert: <T, const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint<T, any, any[], string>[] = []>(predicate: Predicate<T>, meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<T, C>) => Guard<T, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const isRefinementAssertion: (constraint: Constraint) => constraint is Assertion;
+export declare const runRefinementAssertion: (constraint: Assertion, value: unknown) => ReturnType<Assertion>;
+export declare const checkRefinementAssertion: (constraint: Assertion, value: unknown) => boolean;
+export declare const createRefinement: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const refine: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<ConstraintInput<C>, C>) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export {};