@modulify/validator 0.2.1 → 0.3.1

package/dist/metadata.cjs

@@ -1,8 +1,99 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const metadata = require("./metadata.cjs.js");
-exports.attachConstraintDescriptor = metadata.attachConstraintDescriptor;
-exports.custom = metadata.custom;
-exports.describe = metadata.describe;
-exports.describeConstraints = metadata.describeConstraints;
-exports.meta = metadata.meta;
+const require_constraints = require("./constraints.cjs");
+//#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 (!require_constraints.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 = require_constraints.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 (require_constraints.isValidator(constraint)) return withMetadata({ kind: "validator" }, metadata);
+	return withMetadata(inferAssertionDescriptor(constraint), metadata);
+};
+//#endregion
+exports.attachConstraintDescriptor = attachConstraintDescriptor;
+exports.custom = custom;
+exports.describe = describe;
+exports.describeConstraints = describeConstraints;
+exports.meta = meta;

package/dist/metadata.d.cts

@@ -0,0 +1,8 @@
+import { Constraint, ConstraintDescriptor, ConstraintMetadata, DescribeConstraint, DescribeConstraints, MaybeMany, Validator } from './types/index.cjs';
+type DescriptorFactory = () => ConstraintDescriptor;
+export declare const attachConstraintDescriptor: <C extends Constraint>(constraint: C, describe: DescriptorFactory) => C;
+export declare const meta: <const C extends Constraint, const M extends ConstraintMetadata>(constraint: C, metadata: M) => C;
+export declare const custom: <const V extends Validator>(validator: V) => V;
+export declare const describeConstraints: <const C extends MaybeMany<Constraint>>(constraints: C) => DescribeConstraints<C>;
+export declare const describe: <const C extends Constraint>(constraint: C) => DescribeConstraint<C>;
+export {};

package/dist/metadata.d.mts

@@ -0,0 +1,8 @@
+import { Constraint, ConstraintDescriptor, ConstraintMetadata, DescribeConstraint, DescribeConstraints, MaybeMany, Validator } from './types/index.mjs';
+type DescriptorFactory = () => ConstraintDescriptor;
+export declare const attachConstraintDescriptor: <C extends Constraint>(constraint: C, describe: DescriptorFactory) => C;
+export declare const meta: <const C extends Constraint, const M extends ConstraintMetadata>(constraint: C, metadata: M) => C;
+export declare const custom: <const V extends Validator>(validator: V) => V;
+export declare const describeConstraints: <const C extends MaybeMany<Constraint>>(constraints: C) => DescribeConstraints<C>;
+export declare const describe: <const C extends Constraint>(constraint: C) => DescribeConstraint<C>;
+export {};

package/dist/metadata.d.ts

@@ -1,8 +1,8 @@
-import { Constraint, ConstraintDescriptor, ConstraintMetadata, DescribeConstraint, DescribeMaybeMany, MaybeMany, Validator } from '../types';
+import { Constraint, ConstraintDescriptor, ConstraintMetadata, DescribeConstraint, DescribeConstraints, MaybeMany, Validator } from './types/index.js';
 type DescriptorFactory = () => ConstraintDescriptor;
 export declare const attachConstraintDescriptor: <C extends Constraint>(constraint: C, describe: DescriptorFactory) => C;
 export declare const meta: <const C extends Constraint, const M extends ConstraintMetadata>(constraint: C, metadata: M) => C;
 export declare const custom: <const V extends Validator>(validator: V) => V;
-export declare const describeConstraints: <const C extends MaybeMany<Constraint>>(constraints: C) => DescribeMaybeMany<C>;
+export declare const describeConstraints: <const C extends MaybeMany<Constraint>>(constraints: C) => DescribeConstraints<C>;
 export declare const describe: <const C extends Constraint>(constraint: C) => DescribeConstraint<C>;
 export {};

package/dist/metadata.mjs

@@ -1,8 +1,94 @@
-import { e, c, b, d, m } from "./metadata.es.js";
-export {
-  e as attachConstraintDescriptor,
-  c as custom,
-  b as describe,
-  d as describeConstraints,
-  m as meta
+import { arrayify, isValidator } from "./constraints.mjs";
+//#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
+export { attachConstraintDescriptor, custom, describe, describeConstraints, meta };

package/dist/predicates.cjs

@@ -1,95 +1,145 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/predicates.ts
+/** Checks if a value has a property */
 function hasProperty(key) {
-  return (value) => {
-    return isObject(value) && !isNull(value) && Object.prototype.hasOwnProperty.call(value, key);
-  };
+	return (value) => {
+		return isObject(value) && !isNull(value) && Object.prototype.hasOwnProperty.call(value, key);
+	};
 }
+/** Checks if a value is an array */
 function isArray(value) {
-  return Array.isArray(value);
+	return Array.isArray(value);
 }
+/** Checks if a value is a boolean */
 function isBoolean(value) {
-  return typeof value === "boolean";
+	return typeof value === "boolean";
 }
+/** Checks if a value is a bigint */
 function isBigInt(value) {
-  return typeof value === "bigint";
+	return typeof value === "bigint";
 }
+/** Checks if a value is a Blob */
 function isBlob(value) {
-  return typeof Blob !== "undefined" && value instanceof Blob;
+	return typeof Blob !== "undefined" && value instanceof Blob;
 }
+/** Checks if value is Date */
 function isDate(value) {
-  return value instanceof Date;
+	return value instanceof Date;
 }
+/** Checks if value is a valid Date */
+function isValidDate(value) {
+	return isDate(value) && !Number.isNaN(value.getTime());
+}
+/** Checks if a value is an email */
 function isEmail(value) {
-  const pattern = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i;
-  return isString(value) && pattern.test(value);
+	return isString(value) && /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i.test(value);
 }
+/** Creates a predicate that checks if a value is equal to specified */
 function isExact(exact) {
-  return (value) => value === exact;
+	return (value) => value === exact;
 }
+/** Checks if a value is a File */
 function isFile(value) {
-  return typeof File !== "undefined" && value instanceof File;
+	return typeof File !== "undefined" && value instanceof File;
+}
+/** Checks if a value is an Error */
+function isError(value) {
+	return value instanceof Error;
 }
+/** Checks if a value is a function */
 function isFunction(value) {
-  return typeof value === "function";
+	return typeof value === "function";
 }
+/** Checks if a value is a Map */
 function isMap(value) {
-  return value instanceof Map;
+	return value instanceof Map;
 }
+/** Checks if a value is NaN */
 function isNaN(value) {
-  return typeof value === "number" && Number.isNaN(value);
+	return typeof value === "number" && Number.isNaN(value);
 }
+/** Checks if a value is null */
 function isNull(value) {
-  return value === null;
+	return value === null;
 }
+/** Checks if a value is a number */
 function isNumber(value) {
-  return typeof value === "number" && !isNaN(value);
+	return typeof value === "number" && !isNaN(value);
+}
+/** Checks if a value is a finite number */
+function isFiniteNumber(value) {
+	return isNumber(value) && Number.isFinite(value);
+}
+/** Checks if a value is an integer */
+function isInteger(value) {
+	return isNumber(value) && Number.isInteger(value);
 }
+/** Checks if a value is an object, excluding null value */
 function isObject(value) {
-  return typeof value === "object" && value !== null;
+	return typeof value === "object" && value !== null;
 }
+/** Checks if a value is promise-like */
+function isPromiseLike(value) {
+	return (isObject(value) || isFunction(value)) && "then" in value && isFunction(value.then);
+}
+/** Checks if a value is a regular expression */
+function isRegExp(value) {
+	return value instanceof RegExp;
+}
+/** Check if a value is a record like Record<PropertyKey, unknown> */
 function isRecord(value) {
-  return isObject(value) && !isNull(value) && constructorOf(value) === Object && Object.keys(prototypeOf(value)).length === 0;
+	return isObject(value) && !isNull(value) && constructorOf(value) === Object && Object.keys(prototypeOf(value)).length === 0;
+}
+/** Checks if a value is a safe integer */
+function isSafeInteger(value) {
+	return isNumber(value) && Number.isSafeInteger(value);
 }
+/** Checks if a value is a Set */
 function isSet(value) {
-  return value instanceof Set;
+	return value instanceof Set;
 }
+/** Checks if a value is a string */
 function isString(value) {
-  return typeof value === "string";
+	return typeof value === "string";
 }
+/** Checks if a value is a symbol */
 function isSymbol(value) {
-  return typeof value === "symbol";
+	return typeof value === "symbol";
 }
+/** Checks if a value is undefined */
 function isUndefined(value) {
-  return typeof value === "undefined";
+	return typeof value === "undefined";
 }
 function constructorOf(value) {
-  return prototypeOf(value).constructor;
+	return prototypeOf(value).constructor;
 }
 function prototypeOf(value) {
-  return Object.getPrototypeOf(value);
+	return Object.getPrototypeOf(value);
 }
 function And(...predicates) {
-  return (value) => {
-    return predicates.every((predicate) => predicate(value));
-  };
+	return (value) => {
+		return predicates.every((predicate) => predicate(value));
+	};
 }
 function Or(...predicates) {
-  return (value) => {
-    return predicates.some((predicate) => predicate(value));
-  };
+	return (value) => {
+		return predicates.some((predicate) => predicate(value));
+	};
 }
 function Not(predicate) {
-  return (value) => !predicate(value);
-}
-const isShape = (shape) => {
-  const properties = Object.keys(shape);
-  return (value) => isObject(value) && properties.every((p) => {
-    const config = shape[p];
-    const [predicate, required] = isArray(config) ? config : [config, true];
-    return p in value && value[p] !== void 0 && predicate(value[p]) || !required;
-  });
+	return (value) => !predicate(value);
+}
+/** Checks present fields with their predicates; optional fields may be absent. */
+var isShape = (shape) => {
+	const properties = Object.keys(shape);
+	return (value) => isObject(value) && properties.every((p) => {
+		const config = shape[p];
+		const [predicate, required] = isArray(config) ? config : [config, true];
+		if (!(p in value)) return !required;
+		return predicate(value[p]);
+	});
 };
+//#endregion
 exports.And = And;
 exports.Not = Not;
 exports.Or = Or;
@@ -100,17 +150,24 @@ exports.isBlob = isBlob;
 exports.isBoolean = isBoolean;
 exports.isDate = isDate;
 exports.isEmail = isEmail;
+exports.isError = isError;
 exports.isExact = isExact;
 exports.isFile = isFile;
+exports.isFiniteNumber = isFiniteNumber;
 exports.isFunction = isFunction;
+exports.isInteger = isInteger;
 exports.isMap = isMap;
 exports.isNaN = isNaN;
 exports.isNull = isNull;
 exports.isNumber = isNumber;
 exports.isObject = isObject;
+exports.isPromiseLike = isPromiseLike;
 exports.isRecord = isRecord;
+exports.isRegExp = isRegExp;
+exports.isSafeInteger = isSafeInteger;
 exports.isSet = isSet;
 exports.isShape = isShape;
 exports.isString = isString;
 exports.isSymbol = isSymbol;
 exports.isUndefined = isUndefined;
+exports.isValidDate = isValidDate;

package/dist/predicates.d.cts

@@ -0,0 +1,77 @@
+import { Intersect, Predicate } from './types/index.cjs';
+/** Checks if a value has a property */
+export declare function hasProperty<K extends PropertyKey = PropertyKey>(key: K): (value: unknown) => value is { [k in K]: unknown; };
+/** Checks if a value is an array */
+export declare function isArray(value: unknown): value is unknown[];
+/** Checks if a value is a boolean */
+export declare function isBoolean(value: unknown): value is boolean;
+/** Checks if a value is a bigint */
+export declare function isBigInt(value: unknown): value is bigint;
+/** Checks if a value is a Blob */
+export declare function isBlob(value: unknown): value is Blob;
+/** Checks if value is Date */
+export declare function isDate(value: unknown): value is Date;
+/** Checks if value is a valid Date */
+export declare function isValidDate(value: unknown): value is Date;
+/** Checks if a value is an email */
+export declare function isEmail(value: unknown): value is string;
+/** Creates a predicate that checks if a value is equal to specified */
+export declare function isExact<T = unknown>(exact: T): (value: unknown) => value is T;
+/** Checks if a value is a File */
+export declare function isFile(value: unknown): value is File;
+/** Checks if a value is an Error */
+export declare function isError(value: unknown): value is Error;
+/** Checks if a value is a function */
+export declare function isFunction<T extends (...args: never[]) => unknown = (...args: never[]) => unknown>(value: unknown): value is T;
+/** Checks if a value is a Map */
+export declare function isMap<K = unknown, V = unknown>(value: unknown): value is Map<K, V>;
+/** Checks if a value is NaN */
+export declare function isNaN(value: unknown): value is number;
+/** Checks if a value is null */
+export declare function isNull(value: unknown): value is null;
+/** Checks if a value is a number */
+export declare function isNumber(value: unknown): value is number;
+/** Checks if a value is a finite number */
+export declare function isFiniteNumber(value: unknown): value is number;
+/** Checks if a value is an integer */
+export declare function isInteger(value: unknown): value is number;
+/** Checks if a value is an object, excluding null value */
+export declare function isObject(value: unknown): value is object;
+/** Checks if a value is promise-like */
+export declare function isPromiseLike<T = unknown>(value: unknown): value is PromiseLike<T>;
+/** Checks if a value is a regular expression */
+export declare function isRegExp(value: unknown): value is RegExp;
+/** Check if a value is a record like Record<PropertyKey, unknown> */
+export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
+/** Checks if a value is a safe integer */
+export declare function isSafeInteger(value: unknown): value is number;
+/** Checks if a value is a Set */
+export declare function isSet<T = unknown>(value: unknown): value is Set<T>;
+/** Checks if a value is a string */
+export declare function isString(value: unknown): value is string;
+/** Checks if a value is a symbol */
+export declare function isSymbol(value: unknown): value is symbol;
+/** Checks if a value is undefined */
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function And<T extends unknown[]>(...predicates: [...{
+    [K in keyof T]: Predicate<T[K]>;
+}]): Predicate<Intersect<T>>;
+export declare function Or<T extends unknown[]>(...predicates: [...{
+    [K in keyof T]: Predicate<T[K]>;
+}]): Predicate<T[number]>;
+export declare function Not<T>(predicate: Predicate<T>): Predicate;
+export type Shape<T extends object> = {
+    [K in keyof T]: [Predicate<T[K]>, boolean] | Predicate<T[K]>;
+};
+type ShapePropertyType<Config> = Config extends Predicate<infer U> ? U : Config extends [Predicate<infer U>, boolean] ? U : never;
+type OptionalShapeKeys<T> = {
+    [K in keyof T]: T[K] extends [Predicate, infer Required] ? false extends Required ? K : never : never;
+}[keyof T];
+type ExtractType<T> = {
+    [K in Exclude<keyof T, OptionalShapeKeys<T>>]: ShapePropertyType<T[K]>;
+} & {
+    [K in OptionalShapeKeys<T>]?: ShapePropertyType<T[K]>;
+};
+/** Checks present fields with their predicates; optional fields may be absent. */
+export declare const isShape: <S extends Shape<any>>(shape: S) => (value: unknown) => value is ExtractType<S>;
+export {};

package/dist/predicates.d.mts

@@ -0,0 +1,77 @@
+import { Intersect, Predicate } from './types/index.mjs';
+/** Checks if a value has a property */
+export declare function hasProperty<K extends PropertyKey = PropertyKey>(key: K): (value: unknown) => value is { [k in K]: unknown; };
+/** Checks if a value is an array */
+export declare function isArray(value: unknown): value is unknown[];
+/** Checks if a value is a boolean */
+export declare function isBoolean(value: unknown): value is boolean;
+/** Checks if a value is a bigint */
+export declare function isBigInt(value: unknown): value is bigint;
+/** Checks if a value is a Blob */
+export declare function isBlob(value: unknown): value is Blob;
+/** Checks if value is Date */
+export declare function isDate(value: unknown): value is Date;
+/** Checks if value is a valid Date */
+export declare function isValidDate(value: unknown): value is Date;
+/** Checks if a value is an email */
+export declare function isEmail(value: unknown): value is string;
+/** Creates a predicate that checks if a value is equal to specified */
+export declare function isExact<T = unknown>(exact: T): (value: unknown) => value is T;
+/** Checks if a value is a File */
+export declare function isFile(value: unknown): value is File;
+/** Checks if a value is an Error */
+export declare function isError(value: unknown): value is Error;
+/** Checks if a value is a function */
+export declare function isFunction<T extends (...args: never[]) => unknown = (...args: never[]) => unknown>(value: unknown): value is T;
+/** Checks if a value is a Map */
+export declare function isMap<K = unknown, V = unknown>(value: unknown): value is Map<K, V>;
+/** Checks if a value is NaN */
+export declare function isNaN(value: unknown): value is number;
+/** Checks if a value is null */
+export declare function isNull(value: unknown): value is null;
+/** Checks if a value is a number */
+export declare function isNumber(value: unknown): value is number;
+/** Checks if a value is a finite number */
+export declare function isFiniteNumber(value: unknown): value is number;
+/** Checks if a value is an integer */
+export declare function isInteger(value: unknown): value is number;
+/** Checks if a value is an object, excluding null value */
+export declare function isObject(value: unknown): value is object;
+/** Checks if a value is promise-like */
+export declare function isPromiseLike<T = unknown>(value: unknown): value is PromiseLike<T>;
+/** Checks if a value is a regular expression */
+export declare function isRegExp(value: unknown): value is RegExp;
+/** Check if a value is a record like Record<PropertyKey, unknown> */
+export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
+/** Checks if a value is a safe integer */
+export declare function isSafeInteger(value: unknown): value is number;
+/** Checks if a value is a Set */
+export declare function isSet<T = unknown>(value: unknown): value is Set<T>;
+/** Checks if a value is a string */
+export declare function isString(value: unknown): value is string;
+/** Checks if a value is a symbol */
+export declare function isSymbol(value: unknown): value is symbol;
+/** Checks if a value is undefined */
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function And<T extends unknown[]>(...predicates: [...{
+    [K in keyof T]: Predicate<T[K]>;
+}]): Predicate<Intersect<T>>;
+export declare function Or<T extends unknown[]>(...predicates: [...{
+    [K in keyof T]: Predicate<T[K]>;
+}]): Predicate<T[number]>;
+export declare function Not<T>(predicate: Predicate<T>): Predicate;
+export type Shape<T extends object> = {
+    [K in keyof T]: [Predicate<T[K]>, boolean] | Predicate<T[K]>;
+};
+type ShapePropertyType<Config> = Config extends Predicate<infer U> ? U : Config extends [Predicate<infer U>, boolean] ? U : never;
+type OptionalShapeKeys<T> = {
+    [K in keyof T]: T[K] extends [Predicate, infer Required] ? false extends Required ? K : never : never;
+}[keyof T];
+type ExtractType<T> = {
+    [K in Exclude<keyof T, OptionalShapeKeys<T>>]: ShapePropertyType<T[K]>;
+} & {
+    [K in OptionalShapeKeys<T>]?: ShapePropertyType<T[K]>;
+};
+/** Checks present fields with their predicates; optional fields may be absent. */
+export declare const isShape: <S extends Shape<any>>(shape: S) => (value: unknown) => value is ExtractType<S>;
+export {};