@versionzero/schema 1.0.0

package/types/constants.d.ts

@@ -0,0 +1 @@
+export const EMPTY: unique symbol;

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

@@ -0,0 +1,7 @@
+/** @import { SchemaResolver } from '../schema-resolver.js' */
+/**
+ * @param {SchemaResolver} resolver
+ * @param {object} options
+ */
+export default function coreLibrary(resolver: SchemaResolver, options: object): void;
+import type { SchemaResolver } from '../schema-resolver.js';

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

@@ -0,0 +1,24 @@
+/**
+ * ## $sum
+ *
+ * Returns the sum of an array of numbers. Returns `0` for an empty array.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const SUM_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;
+/**
+ * ## $min
+ *
+ * Returns the minimum value from an array of numbers. Returns `undefined` for an empty array.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const MIN_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;
+/**
+ * ## $max
+ *
+ * Returns the maximum value from an array of numbers. Returns `undefined` for an empty array.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const MAX_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,9 @@
+/**
+ * ## $alpha
+ *
+ * Validates that a string contains only alphabetic characters (a-z, A-Z).
+ * No spaces, numbers, punctuation, or special characters are allowed.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const ALPHA_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,9 @@
+/**
+ * ## $alphanum
+ *
+ * Validates that a string contains only alphanumeric characters (A-Z, a-z, 0-9).
+ * No spaces, punctuation, or special characters are allowed.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const ALPHANUM_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,12 @@
+/**
+ * ## $array
+ *
+ * Attempt to normalize the input value as an array.
+ *
+ * If the input value is "*", the array will expand to the "values" option defined in the current schema.
+ *
+ * See `$is-array` for strict array validation.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const ARRAY_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,30 @@
+/**
+ * ## $assert
+ *
+ * Require that the provided processor returns a truthy value; return original input.
+ * Throws a constraint exception if not truthy.
+ *
+ * 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 truthiness.
+ *   If omitted, the input value itself is checked.
+ *
+ * ### Example
+ * ```js
+ * // Require the input value itself to be truthy
+ * new Schema('any').validator('$assert')
+ *
+ * // Assert that a referenced sibling field has a truthy value
+ * new Schema('object', {
+ *   enabled: new Schema('boolean'),
+ *   config: new Schema('object').validator({$assert: {$reference: 'enabled'}}),
+ * })
+ *
+ * // Assert that a custom function returns true
+ * new Schema('string').validator({$assert: (value) => value.startsWith('https://')})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const ASSERT_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,11 @@
+/**
+ * ## $base64
+ *
+ * Validates that a string is properly formatted Base64 encoded data.
+ * Checks for valid Base64 character set (A-Z, a-z, 0-9, +, /) and proper
+ * padding with equals signs. If padding is present, the total length must
+ * be a multiple of 4.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const BASE64_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,17 @@
+/**
+ * ## $camel-case
+ *
+ * Converts a string value to camelCase format. Words are identified by spaces,
+ * hyphens, underscores, or case changes. The first letter is lowercased, and
+ * subsequent words are capitalized with no separators.
+ * Safe to use in normalize phase (non-throwing).
+ *
+ * **Input examples**:
+ * - `"hello world"` → **Output**: `"helloWorld"`
+ * - `"foo-bar-baz"` → **Output**: `"fooBarBaz"`
+ * - `"user_name_id"` → **Output**: `"userNameId"`
+ * - `"HTTPSConnection"` → **Output**: `"httpsConnection"`
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const CAMEL_CASE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,11 @@
+/**
+ * ## $capitalize
+ *
+ * Capitalizes the first letter of each word, separated by spaces. Words are split on
+ * non-alphanumeric boundaries (spaces, hyphens, underscores, camelCase transitions, etc.).
+ * Every word is capitalized unconditionally — see `$title-case` for proper title casing
+ * that respects articles and conjunctions.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const CAPITALIZE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,51 @@
+/**
+ * ## $cardnum
+ *
+ * Validates a payment card number (PAN) using the Luhn algorithm and normalizes
+ * its formatting based on the detected card network.
+ *
+ * **Processing steps:**
+ * 1. Strip formatting characters (spaces, dashes, dots)
+ * 2. Validate: digits only, length 12–19 (ISO 7812), Luhn checksum
+ * 3. Detect card network from IIN (Issuer Identification Number) prefix
+ * 4. Format with network-appropriate digit grouping
+ *
+ * **Recognized networks and their grouping:**
+ * - **Amex** (34, 37): `#### ###### #####`
+ * - **Diners Club** (300–305, 36, 38): `#### ###### ####`
+ * - **JCB** (3528–3589): `#### #### #### ####`
+ * - **Discover** (6011, 65, 644–649, 622126–622925): `#### #### #### ####`
+ * - **Mastercard** (51–55, 2221–2720): `#### #### #### ####`
+ * - **Visa** (4): `#### #### #### ####`
+ * - **Unrecognized**: `#### #### #### ####` (default grouping)
+ *
+ * Network detection is best-effort and does not affect validation — any number
+ * that passes the Luhn check with a valid length is accepted. Unrecognized
+ * prefixes receive default 4-4-4-4 grouping.
+ *
+ * ### Parameters
+ * - `mask` (boolean or string, default `false`): When truthy, replaces leading
+ *   digits with a mask character, revealing only the trailing digits.
+ *   `true` uses `'•'`; a string value uses its first character.
+ * - `reveal` (number, default `4`): Number of trailing digits to leave visible
+ *   when `mask` is enabled.
+ *
+ * ### Example
+ * ```js
+ * // Validate and format
+ * new Schema('string').validator('$cardnum')
+ * // '4111111111111111' → '4111 1111 1111 1111'
+ * // '378282246310005'  → '3782 822463 10005'
+ *
+ * // Masked for output (serializer — masking is a lossy presentation transform)
+ * new Schema('string').serializer({'$cardnum': {mask: true}})
+ * // '4111111111111111' → '•••• •••• •••• 1111'
+ *
+ * // Custom mask character, reveal 6 digits
+ * new Schema('string').serializer({'$cardnum': {mask: '*', reveal: 6}})
+ * // '4111111111111111' → '**** **** **11 1111'
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const CARDNUM_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,30 @@
+/** @import {ValueProcessorDefinition} from '../../value-processor/value-processor.js' */
+/**
+ * ## $ceil
+ *
+ * Rounds a numeric value up to the nearest integer or specified decimal precision.
+ * 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).
+ *
+ * ### Example
+ * ```js
+ * // Round up to the nearest integer
+ * new Schema('number').transformer('$ceil')
+ * // 3.14 → 4, 9.01 → 10
+ *
+ * // Round up to 2 decimal places
+ * new Schema('number').transformer({$ceil: {precision: 2}})
+ * // 3.14159 → 3.15
+ *
+ * // Round up memory usage to the nearest MB boundary
+ * new Schema('object', {
+ *   memoryMB: new Schema('number').transformer({$ceil: {precision: 0}}),
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const CEIL_OPERATOR: ValueProcessorDefinition;
+import type { ValueProcessorDefinition } from '../../value-processor/value-processor.js';

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

@@ -0,0 +1,24 @@
+/**
+ * ## $collapse
+ *
+ * Collapses runs of whitespace within a string to a single space, and trims
+ * leading and trailing whitespace. Useful for normalizing messy user input
+ * from forms, textareas, and configuration values.
+ *
+ * Compared to `$trim` (edges only) and `$compact` (removes all formatting),
+ * `$collapse` preserves word boundaries while normalizing irregular spacing.
+ *
+ * ### Example
+ * ```js
+ * // Clean up messy form input
+ * new Schema('string').normalizer('$collapse')
+ * // '  hello   world\n' → 'hello world'
+ *
+ * // Normalize a multi-line address to single line
+ * new Schema('string').normalizer('$collapse')
+ * // '123 Main St\n  Apt 4\n' → '123 Main St Apt 4'
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const COLLAPSE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,29 @@
+/**
+ * ## $compact
+ *
+ * Strips common formatting characters from a string: whitespace, hyphens,
+ * dots, parentheses, and forward slashes. Useful for producing storage-ready
+ * representations of formatted values like phone numbers and card numbers.
+ *
+ * Characters removed: `\\s`, `-`, `.`, `(`, `)`, `/`
+ *
+ * Characters preserved: `+`, digits, letters, and all other characters.
+ *
+ * ### Example
+ * ```js
+ * // Compact a formatted phone number for storage
+ * new Schema('string').normalizer(['$phone', '$compact'])
+ * // '(212) 555-1234' → '2125551234'
+ *
+ * // Compact an international phone number (preserves +)
+ * new Schema('string').normalizer([{'$phone': {international: true}}, '$compact'])
+ * // '+1 212 555 1234' → '+12125551234'
+ *
+ * // Compact a card number for storage
+ * new Schema('string').normalizer(['$cardnum', '$compact'])
+ * // '4111 1111 1111 1111' → '4111111111111111'
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const COMPACT_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,34 @@
+/**
+ * ## $compile
+ *
+ * Compiles a `Schema` (or `CompiledSchema`) into a `CompiledSchema` ready for use
+ * in value processing. If a schema argument is provided, that schema is compiled and
+ * the input value is ignored. If no argument is given, the input value itself is treated
+ * as the schema to compile — useful when a schema is being passed through as data.
+ *
+ * Typically used together with `$process` to dynamically select and apply a schema.
+ *
+ * ### Parameters
+ * - `schema` (Schema|CompiledSchema, optional): The schema to compile. If omitted, the input
+ *   value is compiled instead.
+ *
+ * ### Example
+ * ```js
+ * import { Schema } from '@versionzero/schema';
+ *
+ * // Compile a fixed schema and feed it into $process
+ * const portSchema = new Schema('number').validator({$range: {min: 1, max: 65535}});
+ *
+ * new Schema('object', {
+ *   port: new Schema('any')
+ *     .normalizer({$compile: portSchema})
+ *     .transformer('$process'),
+ * })
+ *
+ * // Compile the input value itself when schemas arrive as data
+ * new Schema('any').transformer(['$compile', '$process'])
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const COMPILE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,23 @@
+/**
+ * ## $concat
+ *
+ * Returns a new array with the specified values appended to the input array.
+ * Throws `SchemaError` at compile time if no arguments are provided.
+ * Throws `ConstraintError` at runtime if the input is not an array.
+ *
+ * ### Parameters
+ * - Array of values to append (required, at least one).
+ *
+ * ### Example
+ * ```js
+ * // Append default scopes to a user-supplied scopes array
+ * new Schema('array').transformer({$concat: ['read:profile', 'read:email']})
+ * // ['custom:scope'] → ['custom:scope', 'read:profile', 'read:email']
+ *
+ * // Always include a sentinel value at the end of an array
+ * new Schema('array').transformer({$concat: [null]})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const CONCAT_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,219 @@
+/**
+ * ## $if
+ *
+ * This is a conditional operator that evaluates a predicate for truthiness.
+ *
+ * If the predicate returns a truthy value, $if will invoke any provided success action
+ * with the original input.  If not provided, the default success action will simply return the original input.
+ *
+ * If the predicate returns a falsey value or rejects/throws, $if will return the result of invoking the failure
+ * action on the original input.  The default failure action will return undefined.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * To pass the predicate results to the actions instead of the input, see $check.
+ * To test for success rather than truthiness, see $gate.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Evaluated for truthiness. If omitted, the input itself is used as the predicate.
+ * - `success` (processor, optional): Invoked with the original input on truthy predicate result. Default: returns input as-is.
+ * - `failure` (processor, optional): Invoked with the original input on falsey predicate result or throw. Default: returns undefined.
+ *
+ * Array form: `{$if: [predicate, success, failure]}`
+ * Object form: `{$if: {predicate: ..., success: ..., failure: ...}}`
+ * Aliases: `predicate` may also be written as `condition` or `cond`.
+ *
+ * ### Example
+ * ```js
+ * // Normalize an optional port — keep it if numeric, otherwise drop it
+ * new Schema('object', {
+ *   port: new Schema('number').normalizer({
+ *     $if: ['$numeric', '$number', null]
+ *   }),
+ * })
+ *
+ * // Conditionally require an API key when a flag is set
+ * new Schema('object', {
+ *   useApiKey: new Schema('boolean'),
+ *   apiKey: new Schema('string').validator({
+ *     $if: [
+ *       {$reference: 'useApiKey'},
+ *       '$non-empty',
+ *     ]
+ *   }),
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const IF_OPERATOR: ValueProcessorDefinition;
+/**
+ * ## $gate
+ *
+ * This is a conditional operator that evaluates a predicate for whether it returns a defined value.
+ *
+ * If the predicate returns a defined value, $gate will return the result of invoking any provided success action
+ * with the original input.  If not provided, the default success action will simply return the original input.
+ *
+ * If the predicate returns undefined or rejects/throws, $gate will return the result of invoking the failure
+ * action on the original input.  The default failure action will return undefined.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * To pass the original input to the actions instead of the predicate results, see $if.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Evaluated for defined-ness. If omitted, the input itself is tested.
+ * - `success` (processor, optional): Invoked with the original input when predicate returns a defined value. Default: returns input as-is.
+ * - `failure` (processor, optional): Invoked with the original input when predicate returns undefined or throws. Default: returns undefined.
+ *
+ * Array form: `{$gate: [predicate, success, failure]}`
+ * Object form: `{$gate: {predicate: ..., success: ..., failure: ...}}`
+ *
+ * ### Example
+ * ```js
+ * // Only process the value through $uppercase if it was provided
+ * new Schema('string').normalizer({
+ *   $gate: ['$defined', '$uppercase']
+ * })
+ *
+ * // Use the first resolvable property as a value
+ * new Schema('object', {
+ *   host: new Schema('string'),
+ *   fallbackHost: new Schema('string'),
+ * }).transformer({
+ *   $gate: [{$property: 'host'}, {$property: 'host'}, {$property: 'fallbackHost'}]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const GATE_OPERATOR: ValueProcessorDefinition;
+/**
+ * ## $check
+ *
+ * This is a conditional operator that evaluates a predicate for truthiness.
+ *
+ * If the predicate returns a truthy value, $check will return the result of invoking any provided success action
+ * with the predicate result.  If not provided, the default success action will simply return the predicate result.
+ *
+ * If the predicate returns a falsey value or rejects/throws, $check will return the result of invoking the failure
+ * action on the predicate result.  The default failure action will return undefined.  Since the predicate result
+ * is already falsey, the failure action is best used to either return a default value or throw an error.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Evaluated for truthiness. The predicate result (not the original input) is passed to success/failure.
+ * - `success` (processor, optional): Invoked with the predicate result on truthy outcome. Default: returns predicate result.
+ * - `failure` (processor, optional): Invoked with the predicate result on falsey outcome or throw. Default: returns undefined.
+ *
+ * Array form: `{$check: [predicate, success, failure]}`
+ * Object form: `{$check: {predicate: ..., success: ..., failure: ...}}`
+ *
+ * ### Example
+ * ```js
+ * // Extract and validate an environment key, returning the matched value or undefined
+ * new Schema('string').transformer({
+ *   $check: [
+ *     {$match: /^(production|staging|development)$/},
+ *   ]
+ * })
+ *
+ * // Validate a regex match and throw on failure
+ * new Schema('string').validator({
+ *   $check: [
+ *     {$match: /^\d{4}-\d{2}-\d{2}$/},
+ *     null,
+ *     () => { throw new Error('Expected YYYY-MM-DD date format') }
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const CHECK_OPERATOR: ValueProcessorDefinition;
+/**
+ * ## $when
+ *
+ * This is a conditional operator that evaluates a predicate for whether it returns a defined value.
+ *
+ * If the predicate returns a defined value, $when will return the result of invoking any provided success action
+ * with the predicate result.  If not provided, the default success action will simply return the predicate result.
+ *
+ * If the predicate returns undefined or rejects/throws, $when will return the result of invoking the failure
+ * action on the predicate result.  The default failure action will return undefined.  Since the predicate result
+ * is undefined, the failure action is best used to either return a default value or throw an error.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * To check truthiness instead of defined/undefined, see $check.
+ * To pass the original input to the actions instead of the predicate result, see $gate.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Evaluated for defined-ness. The predicate result (not the original input) is passed to success/failure.
+ * - `success` (processor, optional): Invoked with the predicate result when it is defined. Default: returns predicate result.
+ * - `failure` (processor, optional): Invoked with the predicate result (undefined) when predicate returns undefined or throws. Default: returns undefined.
+ *
+ * Array form: `{$when: [predicate, success, failure]}`
+ * Object form: `{$when: {predicate: ..., success: ..., failure: ...}}`
+ *
+ * ### Example
+ * ```js
+ * // Extract a nested value, providing a default when not found
+ * new Schema('object').transformer({
+ *   $when: [
+ *     {$get: 'config.timeout'},
+ *     null,
+ *     () => 5000   // default 5s when config.timeout not set
+ *   ]
+ * })
+ *
+ * // Chain: extract the match groups object if the pattern matched, otherwise drop
+ * new Schema('string').transformer({
+ *   $when: [{$match: /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/}]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const WHEN_OPERATOR: ValueProcessorDefinition;
+/**
+ * ## $try
+ *
+ * This is a conditional operator that evaluates a predicate for whether it throws/rejects.
+ *
+ * If the predicate does not throw, $try will return the result of invoking any provided success action
+ * with the predicate result.  If not provided, the default success action will simply return the predicate result.
+ *
+ * If the predicate rejects/throws, $try will return the result of invoking the failure action with the error returned.
+ * The default failure action will return undefined.  Since the predicate result is an error, the failure action is
+ * best used to either intercept errors and return a default value, or to propagate or wrap the error.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Executed and observed for throw/rejection.
+ * - `success` (processor, optional): Invoked with the predicate result if it did not throw. Default: returns predicate result.
+ * - `failure` (processor, optional): Invoked with the thrown error if the predicate threw. Default: returns undefined.
+ *
+ * Array form: `{$try: [predicate, success, failure]}`
+ * Object form: `{$try: {predicate: ..., success: ..., failure: ...}}`
+ *
+ * ### Example
+ * ```js
+ * // Attempt JSON parsing, fall back to raw string on failure
+ * new Schema('string').normalizer({
+ *   $try: ['$json-decode', null, (err) => err.input]
+ * })
+ *
+ * // Attempt to parse a number, silently drop value on error
+ * new Schema('string').normalizer({
+ *   $try: ['$number']
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const TRY_OPERATOR: ValueProcessorDefinition;
+import type { ValueProcessorDefinition } from '../../value-processor/value-processor.js';

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

@@ -0,0 +1,9 @@
+/**
+ * ## $constant-case
+ *
+ * Converts a string to CONSTANT_CASE format (uppercase letters with underscores).
+ * Safe to use in normalize phase (non-throwing).
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const CONSTANT_CASE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/data-size-operator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ## $data-size
+ *
+ * Parses data-size strings (e.g. `'20KiB'`, `'1.5 MB'`, `'512'`) into byte
+ * counts. Bare numbers and numeric strings without a suffix are treated as bytes.
+ *
+ * ### Parameters
+ * - `standard` (string, optional): Which unit standard to accept when parsing.
+ *   `'iec'` (binary: KiB, MiB, ...), `'si'` (decimal: KB, MB, ...), or
+ *   `'any'` (both). Default: `'any'`.
+ * - `format` (string, optional): When set, returns a formatted string instead
+ *   of a byte count. Accepts `'iec'` or `'si'` to control the output standard.
+ *
+ * ### Example
+ * ```js
+ * // Parse to bytes (normalizer)
+ * new Schema().normalizer('$data-size')
+ *
+ * // Strict IEC only
+ * new Schema().normalizer({'$data-size': {standard: 'iec'}})
+ *
+ * // Parse and format back as SI string
+ * new Schema().normalizer({'$data-size': {format: 'si'}})
+ *
+ * // Use as normalizer ahead of number validation
+ * new Schema().normalizer(['$data-size']).validator('$is-number')
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const DATA_SIZE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,16 @@
+/**
+ * ## $date-object
+ *
+ * Expands a Date into a plain object with named calendar fields.
+ *
+ * - `'$date-object'` or `{'$date-object': 'utc'}` — UTC fields (default)
+ * - `{'$date-object': 'local'}` — local-timezone fields
+ *
+ * Output shape: `{year, month, day, hour, minute, second, ms, zone}`
+ * where `month` is 1–12 (not 0-based), and `zone` is `'utc'` or `'local'`.
+ *
+ * The output is accepted by `$date` for round-trip reassembly.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const DATE_OBJECT_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,21 @@
+/**
+ * ## $date
+ *
+ * Normalize the input value as a Date.  Accepts strings, numbers, Date instances, and
+ * date-field objects produced by `$date-object`.
+ *
+ * - `'now'` — returns the current timestamp
+ * - `'+1h'`, `'-30m'`, etc. — relative offsets from now
+ * - ISO strings and numeric epoch values are parsed automatically
+ * - `{year, month, day, ...zone}` — reassembled from a `$date-object` output
+ *
+ * Output type is inferred from the schema's `type` option:
+ * - `'string'` → ISO string
+ * - `'number'` → epoch milliseconds
+ * - otherwise → `Date` instance
+ *
+ * See `$is-date` for strict Date validation.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const DATE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;