@versionzero/schema 1.0.0

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

@@ -0,0 +1,26 @@
+/**
+ * ## $date-range
+ *
+ * Validates that a date value falls within the specified range (inclusive).
+ * Can specify minimum, maximum, or both bounds.  Bounds are parsed using
+ * the same rules as the `date` schema normalizer, so strings, numbers,
+ * and Date objects are all accepted.
+ *
+ * ### Parameters
+ * - `min` (optional): Minimum date (inclusive). If omitted, no lower bound.
+ * - `max` (optional): Maximum date (inclusive). If omitted, no upper bound.
+ *
+ * ### Example
+ * ```js
+ * // Object form with named parameters
+ * new Schema('date').validator({'$date-range': {min: '2024-01-01', max: '2024-12-31'}})
+ *
+ * // Cross-reference: end date must be >= start date
+ * new Schema('object')
+ *   .property('start', new Schema('date'))
+ *   .property('end', new Schema('date').validator({'$date-range': {min: {$reference: '^start'}}}))
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const DATE_RANGE_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,20 @@
+/**
+ * ## $defined
+ *
+ * Allow any value, as long as it's defined.
+ *
+ * ### Example
+ * ```js
+ * // Ensure an optional field, when supplied, is not undefined
+ * new Schema('any').validator('$defined')
+ *
+ * // Gate a sub-pipeline: only run if the value is defined
+ * new Schema('any').normalizer({$gate: ['$defined', '$trim']})
+ *
+ * // Require a computed result to be defined
+ * new Schema('string').validator({$require: {$get: {path: 'nested.key'}}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const DEFINED_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,34 @@
+/**
+ * ## $each
+ *
+ * Applies a processor to each element of an array. The processor can be any valid
+ * processor specification (RegExp, function, keyword, or parameterized processor).
+ * If any element fails validation, the entire array is rejected.
+ *
+ * This operator is useful for applying consistent validation or transformation rules
+ * across all array elements without requiring explicit array element schemas.
+ *
+ * ### Parameters
+ * - `processor` (any valid processor spec, required): The processor to apply to each element.
+ *   Can be a RegExp, function, string keyword (e.g., `'$numeric'`), or parameterized processor object.
+ *
+ * ### Example
+ * ```js
+ * // Trim whitespace from every string in an array
+ * new Schema('array').transformer({$each: '$trim'})
+ *
+ * // Validate that every element is numeric
+ * new Schema('array').validator({$each: '$numeric'})
+ *
+ * // Validate that each element is within a range
+ * new Schema('array').validator({$each: {$range: {min: 0, max: 100}}})
+ *
+ * // Normalize every tag: trim and lowercase
+ * new Schema('object', {
+ *   tags: new Schema('array').transformer({$each: ['$trim', '$lowercase']}),
+ * })
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const EACH_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,54 @@
+/**
+ * ## $email
+ *
+ * Validates that a string matches a practical email address format (local-part@domain.tld).
+ *
+ * **Username (local part):**
+ * - Allowed characters: letters, digits, `.`, `_`, `%`, `+`, `-`
+ * - Must not start or end with a dot
+ * - Must not contain consecutive dots
+ *
+ * **Domain:**
+ * - Must consist of at least two dot-separated labels (e.g. `example.com`)
+ * - Labels may contain letters, digits, and hyphens (no leading/trailing hyphens)
+ * - Must not contain consecutive dots
+ * - Must end in a TLD of 2+ letters
+ *
+ * **Not supported (by design):** quoted local parts, comments, IP address literals, emoji,
+ * non-ASCII characters.  This processor is intended to handle addresses as they are typically
+ * used.  If you need to support all the madness that the official RFC allows, you'll need to
+ * write your own version.
+ *
+ * The default behavior is to convert the address to lower case for consistency, but this
+ * can be overridden.
+ *
+ * ### Parameters
+ * - `case` (string, default `'lower'`): Case conversion applied to the domain portion,
+ *   and (unless overridden by `case-sensitive`) to the username portion as well.
+ *   Accepts `'lower'` or `'upper'`, or if falsey, doesn't do any conversion.
+ * - `case-sensitive` (boolean, default `false`): When `true`, preserve the original case of
+ *   the username portion. When `false`, the username is converted using the `case` parameter.
+ *   (Rationale: RFC 5321 technically allows case-sensitive local parts, but virtually all
+ *   providers treat them as case-insensitive.)
+ * - `filter` (boolean, default `false`): When `true`, strip plus-addressing
+ *   (e.g. `user+tag@` becomes `user@`), and for `gmail.com` domains, additionally remove
+ *   all dots from the username (since Gmail ignores them).
+ *
+ * ### Example
+ * ```js
+ * // Basic validation only
+ * new Schema('string').validator('$email')
+ *
+ * // Normalize to lowercase, strip plus-addressing
+ * new Schema('string').validator({'$email': {filter: true}})
+ *
+ * // Preserve username case
+ * new Schema('string').validator({'$email': {'case-sensitive': true}})
+ *
+ * // Work for the government and like to shout at people?
+ * new Schema('string').validator({'$email': {'case': 'upper'}}
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const EMAIL_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,13 @@
+/**
+ * ## $entries
+ *
+ * Returns the enumerable own properties of an object as an array of `[key, value]` pairs,
+ * matching the output of `Object.entries()`.
+ *
+ * The resulting array can be reconstructed back into an object with `$object`.
+ *
+ * Throws if the input is not a plain object.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const ENTRIES_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,20 @@
+/**
+ * ## $eq
+ *
+ * Do a deep equality check between the value and the provided constraint value.
+ *
+ * ### Parameters
+ * - `value` (any, required): The value to compare against using deep equality.
+ *
+ * ### Example
+ * ```js
+ * // Ensure a status field can only be 'active'
+ * new Schema('string').validator({$eq: 'active'})
+ *
+ * // Ensure an object matches an exact structure
+ * new Schema('object').validator({$eq: {type: 'config', version: 1}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}*
+ */
+export const EQ_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,35 @@
+/**
+ * ## $filter
+ *
+ * Runs a processor on each element of the input array, keeping elements for which the processor
+ * succeeds and returning the processor's output value (consistent with standard processor semantics).
+ * Elements are filtered out if the processor throws or returns undefined.
+ * (Note that processor results are not checked for truthiness — only for definedness.)
+ *
+ * Non-arrays are "filtered" as an empty array.
+ *
+ * ### Parameters
+ * - `processor` (any valid processor spec, optional): The processor to apply to each element.
+ *   Elements where the processor returns undefined or throws are excluded from the result.
+ *   If omitted, null/undefined elements are removed.
+ *
+ * ### Example
+ * ```js
+ * // Remove null and undefined values from an array
+ * new Schema('array').transformer('$filter')
+ *
+ * // Keep only numeric strings
+ * new Schema('array').transformer({$filter: '$numeric'})
+ *
+ * // Keep only values within range
+ * new Schema('array').transformer({$filter: {$range: {min: 0, max: 100}}})
+ *
+ * // Filter out non-email strings from a list
+ * new Schema('object', {
+ *   recipients: new Schema('array').transformer({$filter: '$email'}),
+ * })
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const FILTER_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/find-schema-operator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ## $find-schema
+ *
+ * Find a schema in the schema hierarchy based on a dotted path.  Returns the current schema by default.
+ * The provided path is interpreted relative to the currently active schema but supports navigation
+ * to the root schema using '/' and parent schema using '^'.
+ *
+ * ### Parameters
+ * - `path` (string | number, required): Dot-separated property path or array index.
+ *
+ * Example paths:
+ * - '': The current schema.
+ * - '/': The root schema.
+ * - 'xyzzy': Find the 'xyzzy' child of the current schema.
+ * - 'xyzzy.plugh': Find the 'plugh' child of the 'xyzzy' child of the current schema.
+ * - 'child.^': The current schema if and only if the child exists.
+ * - `/.foo.bar`: Find the 'bar' property in the 'foo' child of the root.
+ * - `^`: Return the parent schema
+ * - `^^jim`: Get the grandparent schema's child named 'jim' (uncle jim)
+ * - `^.^.jim`: Same thing (extra dots are ignored.)
+ *
+ * ```js
+ * new Schema('any').transformer({'$metadata': {name: 'description', schema: {'$find-schema': '^'}}})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const FIND_SCHEMA_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,26 @@
+/**
+ * ## $flatten
+ *
+ * Returns a new array with sub-array elements flattened to the specified depth.
+ * Throws if the input is not an array.
+ *
+ * ### Parameters
+ * - `depth` (number, optional, default `1`): The depth to flatten. Use `Infinity` to flatten completely.
+ *
+ * ### Example
+ * ```js
+ * // Flatten one level of nesting
+ * new Schema('array').transformer('$flatten')
+ * // [[1, 2], [3, 4]] → [1, 2, 3, 4]
+ *
+ * // Flatten all levels
+ * new Schema('array').transformer({$flatten: {depth: Infinity}})
+ * // [1, [2, [3, [4]]]] → [1, 2, 3, 4]
+ *
+ * // Flatten exactly 2 levels
+ * new Schema('array').transformer({$flatten: {depth: 2}})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const FLATTEN_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,33 @@
+/**
+ * ## $floor
+ *
+ * Rounds a numeric value down to the specified number of decimal places.
+ * Non-numeric values are passed through unchanged. Safe to use in normalize phase (non-throwing).
+ *
+ * ### Parameters
+ * - `precision` (number, optional): Number of decimal places to preserve. Defaults to 0 (round to integer).
+ *
+ * **Input/Output Examples**:
+ * - `$floor`: `3.7` → `3`, `9.99` → `9`, `-2.3` → `-3`
+ * - `{$floor: 2}`: `3.14159` → `3.14`, `99.999` → `99.99`, `5.1` → `5.1`
+ * - `{$floor: 1}`: `3.76` → `3.7`, `9.01` → `9.0`
+ *
+ * ### Example
+ * ```js
+ * // Truncate to integer (floor toward zero for positive numbers)
+ * new Schema('number').transformer('$floor')
+ * // 9.99 → 9
+ *
+ * // Preserve 2 decimal places, discarding extra precision
+ * new Schema('number').transformer({$floor: {precision: 2}})
+ * // 3.14159 → 3.14
+ *
+ * // Strip sub-cent precision from a price field
+ * new Schema('object', {
+ *   price: new Schema('number').transformer({$floor: {precision: 2}}),
+ * })
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const FLOOR_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,31 @@
+/**
+ * ## $get
+ *
+ * Extracts a value from the input using a dot-separated path (for objects) or a numeric
+ * index (for arrays). Does not require the path to be declared as a schema property —
+ * use `$property` when schema-awareness is needed.
+ *
+ * Returns `undefined` if the path does not resolve.
+ *
+ * ### Parameters
+ * - `path` (string | number, required): Dot-separated property path or array index.
+ *
+ * ### Example
+ * ```js
+ * // Extract a nested property from an object
+ * new Schema('object').transformer({$get: {path: 'database.host'}})
+ * // {database: {host: 'localhost'}} → 'localhost'
+ *
+ * // Extract an array element by index
+ * new Schema('array').transformer({$get: {path: 0}})
+ * // ['first', 'second'] → 'first'
+ *
+ * // Use as a conditional predicate — only proceed if the path exists
+ * new Schema('object').transformer({
+ *   $when: [{$get: {path: 'config.timeout'}}]
+ * })
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const GET_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/group-by-operator.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ## $group-by
+ *
+ * Groups an array of objects by a key, returning an object whose values are arrays of elements
+ * that share that key value.
+ *
+ * - `{'$group-by': 'key'}` — groups by the named property on each element
+ * - `{'$group-by': processor}` — groups by the result of executing the processor against each element
+ *   (any compiled processor spec, e.g. `'$type'`, `{$get: 'field'}`, or a function)
+ *
+ * Elements where the extracted key is `undefined` are omitted from the result.
+ * Insertion order is preserved within each group.
+ *
+ * ### Parameters
+ * - `key` (string or processor, required): Property name to group by, or a processor that extracts
+ *   the grouping key from each element. Plain strings (no leading `$`) are treated as property names;
+ *   all other processor specs are executed as extractors.
+ *
+ * ### Example
+ * ```js
+ * // Group an array of log entries by their severity level
+ * new Schema('array').transformer({'$group-by': 'level'})
+ * // [{level:'error', msg:'...'}, {level:'info', msg:'...'}]
+ * // → {error: [{level:'error', ...}], info: [{level:'info', ...}]}
+ *
+ * // Group by a computed key (the JS type of each element)
+ * new Schema('array').transformer({'$group-by': '$type'})
+ * // [1, 'a', 2, 'b'] → {number: [1, 2], string: ['a', 'b']}
+ *
+ * // Group by a nested property using $get
+ * new Schema('array').transformer({'$group-by': {$get: 'meta.region'}})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const GROUP_BY_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/has-prefix-constraint.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ## $has-prefix
+ *
+ * Check that the provided string value starts with the prefix value
+ *
+ * ### Parameters
+ * - `match` (string, required): The required prefix string.
+ *
+ * ### Example
+ * ```js
+ * // Require all feature flag names to start with 'ff_'
+ * new Schema('string').validator({'$has-prefix': 'ff_'})
+ *
+ * // Require environment variables to start with 'APP_'
+ * new Schema('object', {
+ *   envKey: new Schema('string').validator({'$has-prefix': 'APP_'}),
+ * })
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}*
+ */
+export const HAS_PREFIX_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/has-suffix-constraint.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ## $has-suffix
+ *
+ * Check that the provided string value ends with the suffix value
+ *
+ * ### Parameters
+ * - `match` (string, required): The required suffix string.
+ *
+ * ### Example
+ * ```js
+ * // Require file paths to end with '.json'
+ * new Schema('string').validator({'$has-suffix': '.json'})
+ *
+ * // Require callback URLs to end with '/callback'
+ * new Schema('string').validator({'$has-suffix': '/callback'})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}*
+ */
+export const HAS_SUFFIX_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,9 @@
+/**
+ * ## $hex
+ *
+ * Validates that a string contains only valid hexadecimal characters (0-9, a-f, A-F).
+ * Does not require or validate a "0x" prefix - the value should be the raw hex digits.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const HEX_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,11 @@
+/**
+ * ## $hostname
+ *
+ * Validates that a string matches valid hostname format according to RFC 1123.
+ * Hostnames must start and end with alphanumeric characters and may contain
+ * hyphens between labels. Each label (section between dots) can be up to 63
+ * characters long.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const HOSTNAME_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/http-url-constraint.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ## $http-url
+ *
+ * Validates that a string is a valid HTTP or HTTPS URL. Uses the URL Web API for
+ * validation and specifically requires the protocol to be either `http:` or `https:`.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const HTTP_URL_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,27 @@
+/** @import {ValueProcessor, ValueProcessorDefinition} from '../../value-processor/value-processor.js' */
+/**
+ * ## $in
+ *
+ * Validates that a value is included in an allowed list of values.
+ * Uses strict equality (===) for comparison.
+ *
+ * ### Parameters
+ * The parameter is an array (not an object) of allowed values passed directly to the processor.
+ * - Array of values (array, required): The allowed values to match against using strict equality
+ *
+ * ### Example
+ * ```js
+ * // Restrict a log level to known values
+ * new Schema('string').validator({$in: ['debug', 'info', 'warn', 'error']})
+ *
+ * // Accept only specific HTTP methods
+ * new Schema('string').normalizer('$uppercase').validator({$in: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']})
+ *
+ * // Restrict a numeric status code to expected values
+ * new Schema('number').validator({$in: [200, 201, 204, 400, 401, 403, 404, 500]})
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const IN_CONSTRAINT: ValueProcessorDefinition;
+import type { ValueProcessorDefinition } from '../../value-processor/value-processor.js';

package/types/core-library/processors/index-by-operator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ## $index-by
+ *
+ * Groups an array of objects by a unique key, returning an object whose value is the single array element value
+ * that has that key.  If the keys are not unique, throws an error.
+ *
+ * - `{'$index-by': 'key'}` — indexes by the named property on each element
+ * - `{'$index-by': processor}` — indexes by the result of executing the processor against each element
+ *
+ * Elements where the extracted key is `undefined` are omitted from the result.
+ *
+ * ### Parameters
+ * - `key` (string): Property name to group by, or a processor that extracts
+ *   the grouping key from each element.  If you use a bare argument or a single element array,
+ *   it is assumed to be the key.
+ * - `processor`: Must be passed via object parameter.  Must be a processor that will parse the provided
+ *   element and return the index key.  The outer collection is passed to the processor as `options.input`.
+ *
+ * ### Example
+ * ```js
+ * // TODO
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const INDEX_BY_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get all built-in value processor definitions
+ * @returns {ValueProcessorDefinition[]}
+ */
+export function getBuiltinProcessors(): ValueProcessorDefinition[];
+/** @type {ValueProcessorDefinition[]} */
+export const BUILTIN_PROCESSORS: ValueProcessorDefinition[];
+import type { ValueProcessorDefinition } from '../../value-processor/value-processor.js';

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

@@ -0,0 +1,20 @@
+/**
+ * ## $input
+ *
+ * Returns the input value passed to the processor.  Acts as a declarative "pass-through".
+ * Useful for passing the input to processor arguments that don't normally use the input as a default,
+ * or as a placeholder in array arguments.
+ *
+ * ### Example
+ * ```js
+ * //
+ * new Schema('string')
+ *   .transformer([['{', '$input', '}']])
+ *   .transformer({'$join': ''})
+ *
+ * "hello" -> "{hello}"
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const INPUT_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,23 @@
+/**
+ * ## $instanceof
+ *
+ * Validates that the input is an instance of the specified constructor.
+ *
+ * ### Parameters
+ * - `clazz` (Function, required): The constructor function to test against.
+ *
+ * ### Example
+ * ```js
+ * // Validate that a value is an instance of a custom class
+ * new Schema('any').validator({$instanceof: MyClass})
+ *
+ * // Validate that a value is a Map
+ * new Schema('any').validator({$instanceof: Map})
+ *
+ * // Validate that a value is an Error
+ * new Schema('any').validator({$instanceof: Error})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const INSTANCEOF_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,9 @@
+/**
+ * ## $integer
+ *
+ * Validates that a numeric value is an integer (no fractional part).
+ * Input must already be a number; use `$number` in a prior normalizer if coercion from string is needed.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const INTEGER_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,12 @@
+/**
+ * ## $invoke
+ *
+ * Calls a provided processor and passes it arguments (if any).
+ *
+ * ### Parameters
+ * - `processor` (any valid processor spec, required): The processor to invoke.
+ * - `arguments` (optional; any extra values to pass to the processor in `options.args`)
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const INVOKE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,37 @@
+/**
+ * ## $ipv4
+ *
+ * Validates that a string is a valid IPv4 address in dotted-decimal notation.
+ *
+ * ### Parameters
+ * - `in` (string, optional): Network range to validate against. Accepts CIDR
+ *   notation (e.g. `'192.168.1.0/24'`) or a named range: `rfc1918`, `loopback`,
+ *   `link-local`, `rfc6598`, `multicast`, `non-routable`.
+ * - `min` (string, optional): Minimum IPv4 address (inclusive).
+ * - `max` (string, optional): Maximum IPv4 address (inclusive).
+ * - `format` (string, optional): Output format — `'integer'` emits the address
+ *   as a uint32. Default passes through the original dotted-decimal string.
+ *
+ * Use either `in` OR `min`/`max`, not both.
+ *
+ * ### Example
+ * ```js
+ * // Format-only validation
+ * new Schema('string').validator('$ipv4')
+ *
+ * // CIDR range (positional `in`)
+ * new Schema('string').validator({$ipv4: '192.168.1.0/24'})
+ *
+ * // Named range
+ * new Schema('string').validator({$ipv4: 'rfc1918'})
+ *
+ * // Explicit min/max
+ * new Schema('string').validator({$ipv4: {min: '192.168.1.1', max: '192.168.1.254'}})
+ *
+ * // Output as uint32
+ * new Schema('string').validator({$ipv4: {in: 'rfc1918', format: 'integer'}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const IPV4_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,34 @@
+/**
+ * ## $ipv6
+ *
+ * Validates that a string is a properly formatted IPv6 address. Supports all standard
+ * notation formats including full, compressed (::), link-local with zone identifiers,
+ * and IPv4-mapped addresses.
+ *
+ * ### Parameters
+ * - `in` (string, optional): Network range to validate against. Accepts CIDR
+ *   notation (e.g. `'fe80::/10'`) or a named range: `loopback`, `link-local`,
+ *   `unique-local`, `multicast`, `non-routable`.
+ * - `min` (string, optional): Minimum IPv6 address (inclusive).
+ * - `max` (string, optional): Maximum IPv6 address (inclusive).
+ *
+ * Use either `in` OR `min`/`max`, not both.
+ *
+ * ### Example
+ * ```js
+ * // Format-only validation
+ * new Schema('string').validator('$ipv6')
+ *
+ * // CIDR range (positional `in`)
+ * new Schema('string').validator({$ipv6: '2001:db8::/32'})
+ *
+ * // Named range
+ * new Schema('string').validator({$ipv6: 'unique-local'})
+ *
+ * // Explicit min/max
+ * new Schema('string').validator({$ipv6: {min: '2001:db8::1', max: '2001:db8::ffff'}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const IPV6_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;