@versionzero/schema 1.0.0

package/types/core-library/processors/is-array-constraint.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ## $is-array
+ *
+ * Validates that the input is a valid array.
+ *
+ * See `$array` for looser array handling that accepts values that can be normalized as arrays.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const IS_ARRAY_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,10 @@
+/**
+ * ## $is-date
+ *
+ * Validates that the input is a valid date.
+ *
+ * See `$date` for looser date handling that accepts values that can be normalized as dates.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const IS_DATE_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/is-number-constraint.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ## $is-number
+ *
+ * Validates that the input is a valid number.
+ *
+ * See `$number` for looser number validation that accepts values that can be normalized as numbers.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const IS_NUMBER_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/is-object-constraint.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ## $is-object
+ *
+ * Validates that the input is a valid object (and not null!)
+ *
+ * See `$object` for looser object handling that accepts values that can be normalized as objects.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const IS_OBJECT_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/is-string-constraint.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ## $is-string
+ *
+ * Validates that the input is a valid string.
+ *
+ * See `$string` for looser validation that accepts values that can be normalized as strings.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const IS_STRING_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,29 @@
+/**
+ * ## $join
+ *
+ * Join the input array elements into a string using the provided separator.
+ *
+ * ### Parameters
+ * - `separator` (string, required): The value to use for joining
+ *
+ * If the input is not an array, it is treated as a single element.
+ * Follows the behavior of JavaScript's Array.prototype.join()
+ *
+ * ### Example
+ * ```js
+ * // Join array elements with a comma (default)
+ * new Schema('array').transformer('$join')
+ * // ['a', 'b', 'c'] → 'a,b,c'
+ *
+ * // Join with a custom separator
+ * new Schema('array').transformer({$join: {separator: ' | '}})
+ * // ['admin', 'read', 'write'] → 'admin | read | write'
+ *
+ * // Split then rejoin with normalized separators
+ * new Schema('string').normalizer([{$split: {separator: /[,;]/}}, {$each: '$trim'}])
+ *   .transformer({$join: {separator: ', '}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}*
+ */
+export const JOIN_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,10 @@
+/**
+ * ## $json
+ *
+ * Validates that a string contains valid JSON that can be parsed by `JSON.parse()`.
+ * The processor does not modify the input - it only validates that the string is
+ * syntactically correct JSON.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const JSON_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/json-decode-operator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ## $json-decode
+ *
+ * Parses a JSON string into a value.
+ * Throws if the input is not a string or is not valid JSON.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const JSON_DECODE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/json-encode-operator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ## $json-encode
+ *
+ * Serializes any value to a JSON string.
+ *
+ * ### Parameters
+ * - `indent` (number, optional, default `0`): Indentation spaces for pretty-printing. `0` produces compact output.
+ *
+ * ### Example
+ * ```js
+ * // Serialize an object to a compact JSON string
+ * new Schema('object').transformer('$json-encode')
+ * // {a: 1} → '{"a":1}'
+ *
+ * // Pretty-print with 2-space indentation
+ * new Schema('object').transformer({'$json-encode': {indent: 2}})
+ * // {a: 1} → '{\n  "a": 1\n}'
+ *
+ * // Encode a nested payload field for storage
+ * new Schema('object', {
+ *   payload: new Schema('object').transformer('$json-encode'),
+ * })
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const JSON_ENCODE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,16 @@
+/**
+ * ## $kebab-case
+ *
+ * Converts a string to kebab-case format (lowercase words separated by hyphens).
+ * Safe to use in normalize phase (non-throwing).
+ *
+ * **Input/Output Examples**:
+ * - `"HelloWorld"` → `"hello-world"`
+ * - `"API_KEY_NAME"` → `"api-key-name"`
+ * - `"some text here"` → `"some-text-here"`
+ * - `"camelCase"` → `"camel-case"`
+ * - `"already-kebab"` → `"already-kebab"`
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const KEBAB_CASE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,9 @@
+/**
+ * ## $keys
+ *
+ * Returns the enumerable own property keys of an object as an array of strings.
+ * Throws if the input is not a plain object.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const KEYS_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,34 @@
+/**
+ * ## $length
+ *
+ * Validates that the length of a string or array falls within specified bounds (inclusive).
+ * Can specify minimum, maximum, exact length, or any combination of min/max.
+ *
+ * For strings, length is measured in characters. For arrays, length is measured in elements.
+ *
+ * ### Parameters
+ * - `exact` (number, optional): Exact required length. If specified, min/max are ignored.
+ * - `min` (number, optional): Minimum length (inclusive). If omitted, no lower bound.
+ * - `max` (number, optional): Maximum length (inclusive). If omitted, no upper bound.
+ *
+ * - With `{min: 3, max: 10}`: strings "abc" to "abcdefghij", arrays with 3-10 elements
+ * - With `{exact: 5}`: string "hello", array [1,2,3,4,5]
+ *
+ * - With `{min: 3, max: 10}`: string "ab" (too short), array with 11 elements (too long)
+ * - With `{exact: 5}`: string "hi" (wrong length), array [1,2,3] (wrong length)
+ *
+ * ### Example
+ * ```js
+ * // Validate a username is between 3 and 32 characters
+ * new Schema('string').validator({$length: {min: 3, max: 32}})
+ *
+ * // Require an exact number of elements in an array
+ * new Schema('array').validator({$length: 3})
+ *
+ * // Validate a fixed-length code (e.g., ISO country code)
+ * new Schema('string').normalizer('$uppercase').validator({$length: {exact: 2}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const LENGTH_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,36 @@
+/**
+ * ## $lookup
+ *
+ * Uses the pipeline value as a key to look up a corresponding value from the argument
+ * collection. This is the inverse of `$get`: the input value is the key, the argument is the
+ * collection.
+ *
+ * Returns `undefined` if the key is not found in the collection.
+ *
+ * ### Parameters
+ * - Object collection (object, required): The key/value lookup table.
+ *
+ * ### Example
+ * ```js
+ * // Map a string value to a numeric code
+ * new Schema('string').transformer({$lookup: {low: 1, medium: 2, high: 3}})
+ * // 'medium' → 2
+ *
+ * // Use a role name to look up its permission set
+ * new Schema('string').transformer({
+ *   $lookup: {$literal: {
+ *     admin: ['read', 'write', 'delete'],
+ *     editor: ['read', 'write'],
+ *     viewer: ['read'],
+ *   }}
+ * })
+ *
+ * // Validate that a key exists in the table (require a defined result)
+ * new Schema('string').validator({
+ *   $require: {$lookup: {$literal: {us: 'United States', uk: 'United Kingdom', ca: 'Canada'}}}
+ * })
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const LOOKUP_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,9 @@
+/**
+ * ## $lowercase
+ *
+ * Converts a string value to lowercase.
+ * Safe to use in normalize phase (non-throwing).
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const LOWERCASE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,38 @@
+/** @import { ValueProcessorDefinition } from '../../value-processor/value-processor.js' */
+/**
+ * ## $map
+ *
+ * Polymorphic map operator. Applies a processor to each element of an array, or to each
+ * value of a plain object. Returns a new collection of the same shape with transformed values.
+ *
+ * - **Array input**: maps over elements; `undefined` results from the processor appear as `undefined` in output.
+ * - **Object input**: maps over values; keys are always preserved in the output.
+ * - **Non-collection input**: throws a `ConstraintError`.
+ *
+ * Note that `null` returned by the processor is the standard prune signal and will remove
+ * the element/entry from the output.
+ *
+ * ### Parameters
+ * - `processor` (any valid processor spec, required): Applied to each element or value.
+ *
+ * ### Example
+ * ```js
+ * // Uppercase every string in an array
+ * new Schema('array').transformer({$map: '$uppercase'})
+ *
+ * // Parse every element as a number
+ * new Schema('array').transformer({$map: '$number'})
+ *
+ * // Apply a pipeline to every value in an object
+ * new Schema('object').transformer({$map: ['$trim', '$lowercase']})
+ * // {name: '  Alice  ', city: '  NYC  '} → {name: 'alice', city: 'nyc'}
+ *
+ * // Extract a nested field from each element
+ * new Schema('array').transformer({$map: {$get: 'id'}})
+ * // [{id: 1, name: 'a'}, {id: 2, name: 'b'}] → [1, 2]
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const MAP_OPERATOR: ValueProcessorDefinition;
+import type { ValueProcessorDefinition } from '../../value-processor/value-processor.js';

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

@@ -0,0 +1,34 @@
+/**
+ * ## $match
+ *
+ * Operator that executes a RegExp match against a string input and returns the extracted result.
+ * Non-string values are passed through unchanged. Returns `undefined` if the string does not match.
+ *
+ * - If the RegExp contains named capture groups (`(?<name>...)`), returns the `groups`
+ *   object (ES2018 named captures) as a plain object.
+ * - Otherwise, returns a plain array of the full match and positional capture groups.
+ *
+ * ### Parameters
+ * - `pattern` (RegExp, required): The pattern to match against.
+ *
+ * ### Example
+ * ```js
+ * // Extract named capture groups from a date string
+ * new Schema('string').transformer({$match: /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/})
+ * // '2026-03-21' → {year: '2026', month: '03', day: '21'}
+ *
+ * // Extract positional captures from a version string
+ * new Schema('string').transformer({$match: /^(\d+)\.(\d+)\.(\d+)$/})
+ * // '1.2.3' → ['1.2.3', '1', '2', '3']
+ *
+ * // Use with $when to only proceed when the pattern matched
+ * new Schema('string').transformer({
+ *   $when: [{$match: /^Bearer (.+)$/}]
+ * })
+ * // 'Bearer abc123' → ['Bearer abc123', 'abc123']
+ * // 'Basic xyz'    → undefined (no match)
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const MATCH_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,29 @@
+/**
+ * ## $matches
+ *
+ * Constraint that tests the string representation of the input against a RegExp.
+ * Throws a `ConstraintError` if the input does not match. Returns the original value unchanged.
+ *
+ * This is the explicit constraint form; bare RegExp values in processor specs are no longer
+ * treated as implicit constraints and must be wrapped with `$matches`.
+ *
+ * ### Parameters
+ * - `pattern` (RegExp, required): The pattern to test against.
+ *
+ * ### Example
+ * ```js
+ * // Validate a semantic version string
+ * new Schema('string').validator({$matches: /^\d+\.\d+\.\d+$/})
+ *
+ * // Validate a slug (lowercase letters, numbers, hyphens only)
+ * new Schema('string').validator({$matches: /^[a-z0-9]+(?:-[a-z0-9]+)*$/})
+ *
+ * // Validate a hex color code
+ * new Schema('object', {
+ *   color: new Schema('string').validator({$matches: /^#[0-9a-fA-F]{6}$/}),
+ * })
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const MATCHES_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/math-operators.d.ts

@@ -0,0 +1,91 @@
+/**
+ * ## $abs
+ *
+ * Returns the absolute value of a number.
+ *
+ * ### Example
+ * ```js
+ * // Normalize a signed offset to always be non-negative
+ * new Schema('number').transformer('$abs')
+ *
+ * // Ensure a distance value is always positive
+ * new Schema('object', {
+ *   distance: new Schema('number').transformer('$abs'),
+ * })
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const ABS_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;
+/**
+ * ## $pow
+ *
+ * Raises a number to a power.
+ *
+ * - `{$pow: exponent}` — raises the input value to the given exponent
+ * - `{$pow: {exponent, base}}` — raises `base` to `exponent`, ignoring the input value
+ *
+ * ### Parameters
+ * - `exponent` (number, required): The exponent.
+ * - `base` (number, optional): Override the base. Defaults to the input value.
+ *
+ * ### Example
+ * ```js
+ * // Square the input value
+ * new Schema('number').transformer({$pow: {exponent: 2}})
+ * // 4 → 16, 3 → 9
+ *
+ * // Compute 2^n where n is the input
+ * new Schema('number').transformer({$pow: {exponent: '$number', base: 2}})
+ *
+ * // Convert bytes to kilobytes using inverse power
+ * new Schema('number').transformer({$pow: {exponent: -1}})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const POW_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;
+/**
+ * ## $sqrt
+ *
+ * Returns the square root of a number.
+ *
+ * ### Example
+ * ```js
+ * // Compute the magnitude of a value
+ * new Schema('number').transformer('$sqrt')
+ *
+ * // Validate then take the square root
+ * new Schema('number').validator('$positive').transformer('$sqrt')
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const SQRT_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;
+/**
+ * ## $clamp
+ *
+ * Constrains a number to a `[min, max]` range by returning the nearest boundary when the value
+ * falls outside. Unlike `$range` (which throws), `$clamp` transforms.
+ *
+ * Both `min` and `max` are optional; omitting either leaves that end unclamped.
+ *
+ * ### Parameters
+ * - `min` (number, optional): Lower bound.
+ * - `max` (number, optional): Upper bound.
+ *
+ * ### Example
+ * ```js
+ * // Clamp a volume setting to [0, 100]
+ * new Schema('number').transformer({$clamp: {min: 0, max: 100}})
+ *
+ * // Clamp retry count to at most 10 (no lower bound)
+ * new Schema('number').transformer({$clamp: {max: 10}})
+ *
+ * // Ensure a timeout is at least 100ms
+ * new Schema('number').transformer({$clamp: {min: 100}})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const CLAMP_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/merge-deep-operator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ## $merge-deep
+ *
+ * Recursively deep-merges the argument object into the input object, returning
+ * a new object. Nested plain objects are merged rather than replaced; arrays
+ * and primitive values are overwritten. The input is not mutated.
+ *
+ * Use `$merge` for shallow (one-level) merging.
+ *
+ * ### Parameters
+ * - Object of fields to deep-merge (object, required): Key/value pairs to apply over the input.
+ *
+ * ### Example
+ * ```js
+ * // Deep-merge default nested config into the user-supplied object
+ * new Schema('object').transformer({
+ *   '$merge-deep': {
+ *     logging: {level: 'info', format: 'json'},
+ *     server: {port: 3000},
+ *   }
+ * })
+ * // {logging: {level: 'debug'}, server: {host: 'localhost'}}
+ * // → {logging: {level: 'debug', format: 'json'}, server: {host: 'localhost', port: 3000}}
+ *
+ * // Inject a nested metadata field without overwriting sibling keys
+ * new Schema('object').transformer({'$merge-deep': {meta: {version: 1}}})
+ * // {meta: {author: 'rg'}} → {meta: {author: 'rg', version: 1}}
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const MERGE_DEEP_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,26 @@
+/**
+ * ## $merge
+ *
+ * Merges the argument object into the input object (shallow). The argument fields take
+ * precedence over same-named fields in the input, consistent with the "apply to the
+ * value being passed through" pattern.
+ *
+ * The input object is not mutated; a new object is returned.
+ *
+ * ### Parameters
+ * - Object of fields to merge (object, required): Key/value pairs to apply over the input.
+ *
+ * ### Example
+ * ```js
+ * // Inject default fields into every output object
+ * new Schema('object').transformer({$merge: {version: 1, active: true}})
+ * // {id: 42} → {id: 42, version: 1, active: true}
+ *
+ * // Overwrite a specific field in the result
+ * new Schema('object').transformer({$merge: {status: 'normalized'}})
+ * // {id: 1, status: 'raw'} → {id: 1, status: 'normalized'}
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const MERGE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,56 @@
+/**
+ * ## $metadata
+ *
+ * Extracts named metadata from a schema, either from the current schema or a parameter.
+ *
+ * Useful for getting standard metadata like `type` or `description`, or as a way to transport information
+ * between schemas that get aggregated together.
+ *
+ * If a schema value is passed, the metadata is retrieved only from that particular schema.
+ * If a schema path is passed, or it is left empty (and thus uses the current schema), $metadata will
+ * search from the current schema to the root and return the first value located.  To suppress this search,
+ * pass `false` to the `inherit` parameter.
+ *
+ * Returns `undefined` if the referenced schema or metadata key does not exist.
+ *
+ * ### Parameters
+ * - `name` (string, required): The name of the metadata to extract from the schema.
+ * - `schema` (CompiledSchema|string, optional): The schema (or a relative path to a schema) to extract metadata from.  Defaults to the current schema.
+ * - `inherit` (boolean, optional): Whether to search for metadata in a parent if not found in implicit schema.
+ *
+ * ### Example
+ * ```js
+ * // Here is an example that will simply propagate the current schema description
+ * new Schema('object')
+ *   .property('description', new Schema('string')
+ *     .required()
+ *     .meta('description', 'This will be pulled into the property value')
+ *     .normalizer({$metadata: 'description'}))
+ *
+ * // Extract metadata from a sibling property using a relative path.
+ * // If 'temperature' lacked a 'unit' meta, $metadata would inherit 'metric' from the parent.
+ * const weatherSchema = await resolver.compile(
+ *   new Schema('object')
+ *     .meta('unit', 'metric')
+ *     .property('temperature', new Schema('number').meta('unit', '°C'))
+ *     .property('unit', new Schema('string')
+ *       .default('')
+ *       .transformer({$metadata: {name: 'unit', schema: '^.temperature'}})
+ *     )
+ * );
+ * const weather = await weatherSchema.process({temperature: 22});
+ * console.log('weather:', weather);
+ * // → {temperature: 22, unit: '°C'}
+ *
+ * // Unlike most other "get a value" operators, $metadata does not use the pipeline input as the source
+ * // because it is focused on the current processor calling context rather than values.  However, you can
+ * // force it to use a compiled schema in the value pipeline by using $input:
+ *
+ * new Schema('string')
+ *   .transformer(new Schema('string').meta('greeting', 'hello world'))
+ *   .transformer({'$metadata': {name: 'greeting', schema: '$input'}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const METADATA_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

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

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

@@ -0,0 +1,26 @@
+/**
+ * ## $never
+ *
+ * Inverts a processor - Returns the input if the wrapped processor throws or returns an undefined value.
+ * Throw a constraint error if the wrapped processor returns a defined value.
+ *
+ * See `$not` to enforce falseyness.
+ *
+ * ### Parameters
+ * - `value` (ProcessorSpec, required): The processor specification to negate (must not return a defined value).
+ *
+ * ### Example
+ * ```js
+ * // Blacklist specific values — reject any input that is found in the lookup table
+ * new Schema('string').validator({$never: {$lookup: {admin: true, root: true}}})
+ *
+ * // Ensure a value does not parse as a number (must be a non-numeric string)
+ * new Schema('string').validator({$never: '$numeric'})
+ *
+ * // Reject any value that resolves from $get (path must NOT exist)
+ * new Schema('object').validator({$never: {$get: 'deprecated.field'}})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}*
+ */
+export const NEVER_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/non-empty-constraint.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ## $non-empty
+ *
+ * Validates that a string, array, or object is not empty. For strings, the value must contain
+ * at least one non-whitespace character. For arrays, the length must be greater than zero.
+ * For objects, the number of keys must be greater than zero.
+ *
+ * ### Example
+ * ```js
+ * // Require a non-blank username
+ * new Schema('string').normalizer('$trim').validator('$non-empty')
+ *
+ * // Require at least one tag
+ * new Schema('array').validator('$non-empty')
+ *
+ * // Require a non-empty configuration object
+ * new Schema('object').validator('$non-empty')
+ *
+ * // Combine trim + non-empty as a common pattern for required text fields
+ * new Schema('object', {
+ *   name: new Schema('string').normalizer('$trim').validator('$non-empty'),
+ *   description: new Schema('string').normalizer('$trim').validator('$non-empty'),
+ * })
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const NON_EMPTY_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;