@versionzero/schema 1.0.0

package/types/core-library/processors/not-constraint.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ## $not
+ *
+ * Inverts a processor result - returns true if the wrapped processor throws or returns a falsey value.
+ * Throw a constraint error if the wrapped processor returns a truthy value.
+ *
+ * This is useful for expressing negative constraints (e.g., "must not be a hostname").
+ *
+ * See `$never` to require the processor returns undefined or throws an exception.
+ *
+ * ### Parameters
+ * - `value` (ProcessorSpec, required): The processor specification to negate.
+ *
+ * ### Example
+ * ```js
+ * // Reject anything that looks like an IP address (accept hostnames only)
+ * new Schema('string').validator({$not: '$ipv4'})
+ *
+ * // Ensure a string is not a reserved word
+ * new Schema('string').validator({$not: {$in: ['admin', 'root', 'system']}})
+ *
+ * // Require a URL that is NOT an HTTP URL (i.e., must be HTTPS or another scheme)
+ * new Schema('string').validator({$not: '$http-url'}).validator('$url')
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}*
+ */
+export const NOT_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/number-operator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ## $number
+ *
+ * Validates and coerces values to numbers. Accepts numeric strings, integers, and floats.
+ * Rejects NaN, Infinity, and non-numeric values.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const NUMBER_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/numeric-constraint.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ## $numeric
+ *
+ * Validates that a string contains only numeric digits (0-9).
+ * The value is coerced to a string before validation, so numbers are accepted
+ * but must not contain decimal points, signs, or scientific notation.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const NUMERIC_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/object-operator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ## $object
+ *
+ * Attempts to normalize the input value as an object.
+ *
+ * See `$is-object` for strict object validation.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const OBJECT_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/omit-operator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ## $omit
+ *
+ * Returns a new object or dense array with the specified keys/indices removed.
+ * Keys not present in the input are silently ignored.
+ * For arrays, numeric indices are excluded and the result is a dense (packed) array.
+ *
+ * ### Parameters
+ * - Array of key names or indices (string[]|number[], required): The keys/indices to exclude.
+ *
+ * ### Example
+ * ```js
+ * // Remove internal fields before returning a user object
+ * new Schema('object').transformer({$omit: ['password', 'salt', '_internalId']})
+ * // {id: 1, name: 'Alice', password: '...', _internalId: 42} → {id: 1, name: 'Alice'}
+ *
+ * // Remove the first element from an array
+ * new Schema('array').transformer({$omit: [0]})
+ * // ['header', 'row1', 'row2'] → ['row1', 'row2']
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const OMIT_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/parallel-operator.d.ts

@@ -0,0 +1,41 @@
+/** @import {ValueProcessorDefinition} from '../../value-processor/value-processor.js' */
+/**
+ * ## $parallel
+ *
+ * Applies an array of processors concurrently to the same input value, returning an array
+ * of all results in the same order as the processors.
+ *
+ * When all processors are synchronous, execution is sequential and the result is a plain array.
+ * When any processor is asynchronous, all are run via `Promise.all`, giving true concurrent
+ * execution — useful for I/O-bound processors such as HTTP fetches or secret lookups.
+ *
+ * Errors propagate immediately (fail-fast). Wrap individual processors in `$gate` or `$try`
+ * to trap errors and return a fallback instead.
+ *
+ * ### Parameters
+ * - `processors` (Array, required): Array of processor specifications to run concurrently.
+ *
+ * ### Example
+ * ```js
+ * // Fan out to two transforms and collect both results
+ * new Schema('string').transformer({$parallel: ['$uppercase', '$trim']})
+ * // '  hello  ' → ['HELLO', 'hello']
+ *
+ * // Concurrent async lookups (both execute at the same time via Promise.all)
+ * new Schema('string').transformer({$parallel: [fetchUserFlags, fetchUserPermissions]})
+ * // → [flagsResult, permissionsResult]
+ *
+ * // Fan out validation across multiple schemas and collect results
+ * new Schema('object').transformer({
+ *   $parallel: [
+ *     {$get: 'id'},
+ *     {$get: 'name'},
+ *     {$get: 'email'},
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const PARALLEL_OPERATOR: ValueProcessorDefinition;
+import type { ValueProcessorDefinition } from '../../value-processor/value-processor.js';

package/types/core-library/processors/pascal-case-operator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ## $pascal-case
+ *
+ * Converts a string value to PascalCase format (first letter of each word capitalized, no separators).
+ * Safe to use in normalize phase (non-throwing).
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const PASCAL_CASE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/phone-constraint.d.ts

@@ -0,0 +1,65 @@
+/**
+ * ## $phone
+ *
+ * Validates and normalizes a phone number string.
+ *
+ * Strips common formatting (spaces, dashes, dots, parentheses, slashes) and
+ * validates the remaining digits against country-specific rules when available,
+ * or generic E.164 length rules otherwise.
+ *
+ * **Output format** is controlled by the `international` parameter:
+ * - When `false` (default): national format for the default country
+ *   (e.g. `(212) 555-1234` for country code `1`).
+ * - When `true`: international format with country code prefix
+ *   (e.g. `+1 212 555 1234`).
+ *
+ * Numbers without a `+` prefix are assumed to belong to the default `country`.
+ * A leading country code without `+` is recognized when it produces a valid
+ * subscriber length (e.g. `12125551234` is treated as `+1 2125551234`).
+ *
+ * **NANP validation (country code `1`):** area codes and exchanges must not
+ * start with `0` or `1`, matching North American Numbering Plan rules.
+ *
+ * **Not supported:** extensions, vanity letters (1-800-FLOWERS), international
+ * dialing prefixes (`00`, `011`), short codes, or emergency numbers. This
+ * processor targets typical subscriber phone numbers as entered in forms or
+ * configuration files.
+ *
+ * ### Parameters
+ * - `international` (boolean, default `false`): When `false`, only numbers
+ *   matching the default `country` code are accepted, and output uses the
+ *   national format. When `true`, any valid international number is accepted,
+ *   and output uses the international format with `+CC` prefix.
+ * - `country` (string, default `'1'`): Default country calling code applied
+ *   to numbers entered without a `+` prefix.
+ * - `countries` (object, default `null`): Optional map of country calling
+ *   codes to rule objects, merged over the built-in rules.  Each rule object
+ *   may contain:
+ *   - `lengths` (number[]) — accepted subscriber digit counts
+ *   - `validate` (RegExp, optional) — pattern the subscriber digits must match
+ *   - `national` (string) — `#`-template for national formatting
+ *   - `international` (string) — `#`-template for international formatting
+ *
+ * ### Example
+ * ```js
+ * // Basic US number validation and national formatting
+ * new Schema('string').validator('$phone')
+ *
+ * // Accept international numbers
+ * new Schema('string').validator({'$phone': {international: true}})
+ *
+ * // Default to UK numbers
+ * new Schema('string').validator({'$phone': {
+ *   country: '44',
+ *   countries: {
+ *     '44': {lengths: [10], national: '#### ### ####', international: '#### ### ####'}
+ *   }
+ * }})
+ *
+ * // Compact storage: compose with space/punctuation stripping
+ * new Schema('string').normalizer({$pipeline: ['$trim', '$phone']})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const PHONE_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/pick-operator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ## $pick
+ *
+ * Returns a new object or dense array containing only the specified keys/indices from the input.
+ * Keys not present in the input are silently omitted from the result.
+ * For arrays, numeric indices are selected and the result is a dense (packed) array.
+ *
+ * ### Parameters
+ * - Array of key names or indices (string[]|number[], required): The keys/indices to retain.
+ *
+ * ### Example
+ * ```js
+ * // Retain only 'id' and 'name' from an object
+ * new Schema('object').transformer({$pick: ['id', 'name']})
+ * // {id: 1, name: 'Alice', secret: 'xyz'} → {id: 1, name: 'Alice'}
+ *
+ * // Select the first and third elements from an array
+ * new Schema('array').transformer({$pick: [0, 2]})
+ * // ['a', 'b', 'c', 'd'] → ['a', 'c']
+ *
+ * // Strip sensitive fields from a user record before returning
+ * new Schema('object').transformer({$pick: ['id', 'username', 'email', 'role']})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const PICK_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/pipeline-operator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @import {ValueProcessorDefinition} from '../../value-processor/value-processor.js'
+ */
+/**
+ * ## $pipeline
+ *
+ * Executes a sequence of processors in order, passing the output of each processor
+ * as input to the next. The final processor's output becomes the result.
+ *
+ * **Note**: Handler arrays (normalizers, validators, etc.) implicitly create pipelines,
+ * so this processor is rarely used directly. It's primarily used internally by the
+ * schema compiler to aggregate handler arrays into single compiled processors.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications to execute in sequence.
+ *   Each element can be a string keyword (e.g., `'$trim'`), a parameterized processor object
+ *   (e.g., `{$range: {min: 0}}`), a RegExp, or a function.
+ *
+ * **Behavior**: Processors execute left-to-right. If any processor throws an error, the pipeline
+ * stops and the error propagates. Each processor receives the output of the previous processor
+ * as its input value.
+ *
+ * ### Example
+ * ```js
+ * // Explicit pipeline (equivalent to passing an array to .normalizer())
+ * new Schema('string').normalizer({$pipeline: ['$trim', '$lowercase', '$alphanum']})
+ *
+ * // Use $pipeline inside a conditional to chain processors on a branch
+ * new Schema('string').transformer({
+ *   $if: [
+ *     '$numeric',
+ *     {$pipeline: ['$number', {$clamp: {min: 0, max: 100}}]},
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const PIPELINE_OPERATOR: ValueProcessorDefinition;
+import type { ValueProcessorDefinition } from '../../value-processor/value-processor.js';

package/types/core-library/processors/port-constraint.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ## $port
+ *
+ * Validates that a value is a valid TCP/UDP port number (1-65535).
+ * Accepts numeric values or strings that can be converted to numbers.
+ * Returns the value as a number or a string, depending on the underlying schema.
+ * (defaults to a number).
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const PORT_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/positive-constraint.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ## $positive
+ *
+ * Validates that a numeric value is positive (greater than 0).
+ * Input must already be a number; use `$number` in a prior normalizer if coercion from string is needed.
+ *
+ * See also:
+ * - `$negative` to enforce the opposite constraint
+ * - `$range` if you want "non-negative" ( greater than or equal to 0) semantics.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const POSITIVE_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/process-operator.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ## $process
+ *
+ * Process the incoming value according to the provided schema
+ *
+ * Important note: the provided schema is run in isolation in a private local context, which means
+ * that it (and its handlers) have no access to the outer schema or the global target value, and all
+ * paths are relative to the root of the provided schema.
+ *
+ * ### Parameters
+ * - `schema` (CompiledSchema, required): the compiled schema to apply to the input value.
+ *   Any `Schema` found in a handler pipeline will be automatically compiled;
+ *   Use `$compile` to produce a `CompiledSchema` from a `Schema` literal value.
+ *
+ * ### Example
+ * ```js
+ * import { Schema, SchemaResolver } from '@versionzero/schema';
+ *
+ * // Compile a reusable sub-schema and run values through it
+ * const resolver = new SchemaResolver();
+ * const portSchema = await resolver.compile(
+ *   new Schema('number').validator({$range: {min: 1, max: 65535}})
+ * );
+ *
+ * // portSchema is automatically compiled:
+ * new Schema('object', {
+ *   port: new Schema('any').validator({$process: {schema: portSchema}}),
+ * })
+ *
+ * // Use $compile inline to compile-then-process in a single pipeline
+ * const mySchema = new Schema('string').validator('$non-empty');
+ * new Schema('any').normalizer([{$compile: {$literal: mySchema}}, '$process'])
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const PROCESS_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/property-operator.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ## $property
+ *
+ * Extracts a named property value from an object. This operator is useful for accessing
+ * nested properties or extracting specific fields during processing pipelines.
+ *
+ * Returns `undefined` if the current value is not an object or if the property doesn't exist.
+ * Throws a `SchemaError` if the specified property name is not defined in the schema.
+ *
+ * ### Parameters
+ * - `name` (string, required): The name of the schema-defined property to extract from the input object.
+ *   The property must be declared in the current schema; use `$get` for arbitrary path access without
+ *   schema awareness.
+ *
+ * ### Example
+ * ```js
+ * // Conditionally require 'apiKey' only when 'useApiKey' is true
+ * new Schema('object', {
+ *   useApiKey: new Schema('boolean'),
+ *   apiKey: new Schema('string').validator({
+ *     $if: [{$property: 'useApiKey'}, '$non-empty']
+ *   }),
+ * })
+ *
+ * // Discriminate a union using a schema property value
+ * new Schema('object', {
+ *   type: new Schema('string'),
+ *   config: new Schema('any'),
+ * }).discriminator({$property: 'type'})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const PROPERTY_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/range-constraint.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ## $range
+ *
+ * Validates that a numeric value falls within the specified range (inclusive).
+ * Can specify minimum, maximum, or both bounds.
+ *
+ * ### Parameters
+ * - `min` (number, optional): Minimum value (inclusive). If omitted, no lower bound.
+ * - `max` (number, optional): Maximum value (inclusive). If omitted, no upper bound.
+ *
+ * ### Example
+ * ```js
+ * // Object form with named parameters
+ * new Schema('number').validator({$range: {min: 1, max: 100}})
+ *
+ * // Array form [min, max]
+ * new Schema('number').validator({$range: [1, 65535]})
+ *
+ * // Only a lower bound (percentage, must be non-negative)
+ * new Schema('number').validator({$range: {min: 0}})
+ *
+ * // Only an upper bound
+ * new Schema('number').validator({$range: {max: 255}})
+ * ```
+ *
+ * See also: `$positive` and `$negative` for common named ranges.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const RANGE_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/reference-operator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ## $reference
+ *
+ * Returns the value at the referenced path (relative to the current schema) in the target data, or undefined if not set.
+ *
+ * Throws a `SchemaError` if the specified path is not defined in the schema.
+ *
+ * ### Parameters
+ * - `path` (string, required): path from the current schema into the top-level target object; must be a valid
+ *   schema path (dot-separated, supports / for absolute or ^ for parents).
+ * - `pending` (boolean, optional, default: false): If true will fall back to any pending value not yet in the target data.
+ * - `completed` (boolean, optional, default: false): If true, will only return a value if the reference is completed (useful for checking if all children are handled).
+ *
+ * ### Example
+ * ```js
+ * // Validate 'port' is within range only when 'ssl' is enabled at the top level
+ * new Schema('object', {
+ *   ssl: new Schema('boolean'),
+ *   port: new Schema('number').validator({
+ *     $if: [{$reference: 'ssl'}, {$range: {min: 443, max: 443}}]
+ *   }),
+ * })
+ *
+ * // Cross-field consistency: confirm 'passwordConfirm' matches 'password'
+ * new Schema('object', {
+ *   password: new Schema('string'),
+ *   passwordConfirm: new Schema('string').validator(
+ *     (value, target) => value === target.password || undefined
+ *   ),
+ * })
+ * ```
+ * ### See Also
+ * - Use `$property` for getting a named child value.
+ * - Use `$get` for getting values under the input value (without the path needing to be in the schema.)
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const REFERENCE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/require-constraint.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ## $require
+ *
+ * Require that the provided processor returns a defined value; return the original input if so.
+ * Throws a constraint error if the processor does not return a defined value.
+ *
+ * May be used inline in a pipeline without parameters, or can have a single processor argument.
+ *
+ * ### Parameters
+ * - `processor` (ProcessorSpec, optional): Processor specification to check for a defined return value.
+ *   If omitted, the input value itself is checked for defined-ness.
+ *
+ * ### Example
+ * ```js
+ * // Require the input to be defined (not undefined)
+ * new Schema('any').validator('$require')
+ *
+ * // Require a lookup to succeed (key must exist in the table)
+ * new Schema('string').validator({
+ *   $require: {$lookup: {$literal: {admin: 1, user: 2, guest: 3}}}
+ * })
+ *
+ * // Require a nested path to resolve
+ * new Schema('object').validator({$require: {$get: 'metadata.version'}})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const REQUIRE_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/reverse-operator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ## $reverse
+ *
+ * Returns a new array with elements in reverse order. Non-mutating.
+ * Throws if the input is not an array.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const REVERSE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/round-operator.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ## $round
+ *
+ * Rounds a numeric value to the nearest integer or to a specified number of decimal places.
+ * Safe to use in normalize phase (non-throwing). Non-numeric values pass through unchanged.
+ *
+ * ### Parameters
+ * - `precision` (number, optional): Number of decimal places. Defaults to 0 (integer rounding).
+ *
+ * **Examples**:
+ * - `3.7` with precision 0 → `4`
+ * - `3.14159` with precision 2 → `3.14`
+ * - `123.456` with precision 1 → `123.5`
+ * - `"not a number"` → `"not a number"` (passes through unchanged)
+ *
+ * ### Example
+ * ```js
+ * // Round to nearest integer
+ * new Schema('number').transformer('$round')
+ * // 3.5 → 4, 3.4 → 3
+ *
+ * // Round a price to 2 decimal places
+ * new Schema('number').transformer({$round: {precision: 2}})
+ * // 9.9950 → 9.99, 9.9951 → 10.00
+ *
+ * // Round a sensor reading to 1 decimal place
+ * new Schema('object', {
+ *   temperature: new Schema('number').transformer({$round: {precision: 1}}),
+ * })
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const ROUND_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/schema-handler-operators.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ## $normalize
+ *
+ * Normalize the incoming value according using the provided schema
+ *
+ * ### Parameters
+ * - `schema` (CompiledSchema, required): the compiled schema to apply to the input value.
+ *   Any `Schema` found in a handler pipeline will be automatically compiled;
+ *   Use `$compile` to produce a `CompiledSchema` from a `Schema` literal value.
+ *
+ * ### Example
+ * ```js
+ * import { Schema, SchemaResolver } from '@versionzero/schema';
+ *
+ * const resolver = new SchemaResolver();
+ *
+ * const  = await resolver.compile(
+ *   new Schema('object')
+ *     .property('collection', new Schema('array')
+ *       .property('*', new Schema('string').normalizer('$trim').normalizer('$lowercase'))
+ *     .property('chosen', new Schema('string').normalizer({$normalize: {'$find-schema': '^.collection.*'}})
+ * );
+ *
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const NORMALIZE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/semver-constraint.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ## $semver
+ *
+ * Validates that a string is a valid semantic version per the semver 2.0.0 spec.
+ *
+ * ### Parameters
+ * - `in` (string, optional): Semver range expression. Supports comparators
+ *   (`>=1.0.0`, `<2.0.0`), caret (`^1.2.3`), tilde (`~1.2.3`), and
+ *   space-separated AND (`>=1.0.0 <2.0.0`).
+ * - `min` (string, optional): Minimum version (inclusive).
+ * - `max` (string, optional): Maximum version (inclusive).
+ *
+ * Use either `in` OR `min`/`max`, not both.
+ *
+ * ### Example
+ * ```js
+ * // Format-only validation
+ * new Schema('string').validator('$semver')
+ *
+ * // Caret range (positional `in`)
+ * new Schema('string').validator({$semver: '^1.2.0'})
+ *
+ * // Tilde range
+ * new Schema('string').validator({$semver: '~1.2.0'})
+ *
+ * // Comparator range
+ * new Schema('string').validator({$semver: '>=1.0.0 <2.0.0'})
+ *
+ * // Explicit min/max (inclusive)
+ * new Schema('string').validator({$semver: {min: '1.0.0', max: '2.0.0'}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const SEMVER_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;
+export type SemVer = {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string[];
+    build: string[];
+};
+export type SemVerPredicate = (v: SemVer) => boolean;