@versionzero/schema 1.0.0

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

@@ -0,0 +1,213 @@
+/**
+ * ## $or
+ *
+ * A constraint that checks whether any of the provided processors return a truthy value.
+ *
+ * Returns the first truthy value from the processors, or throws if none are truthy.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$any` if you want to check for success (defined value) instead of truthiness
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, at least one of which must return a truthy value.
+ *
+ * ### Example
+ * ```js
+ * // Accept either a valid hostname or a valid IPv4 address
+ * new Schema('string').validator({$or: ['$hostname', '$ipv4']})
+ *
+ * // Accept a port number OR the string 'auto'
+ * new Schema('any').validator({
+ *   $or: [
+ *     {$range: {min: 1, max: 65535}},
+ *     {$eq: 'auto'},
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const OR_CONSTRAINT: ValueProcessorDefinition;
+/**
+ * ## $and
+ *
+ * A constraint that checks whether all the provided processors return a truthy value.
+ *
+ * Returns the last truthy value from the processors, or throws if any are falsey.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$all` if you want to check for success (defined value) instead of truthiness
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, all of which must return a truthy value.
+ *
+ * ### Example
+ * ```js
+ * // Require a string to be both non-empty and a valid email
+ * new Schema('string').validator({$and: ['$non-empty', '$email']})
+ *
+ * // Require a number to be positive and within range
+ * new Schema('number').validator({
+ *   $and: ['$positive', {$range: {max: 1000}}]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const AND_CONSTRAINT: ValueProcessorDefinition;
+/**
+ * ## $any
+ *
+ * A constraint that checks whether any of the provided processors return a defined value.
+ * (Not to be confused with the unrelated "any" schema!)
+ *
+ * Returns the first defined value from the processors, or throws if none returned a defined value.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$or` if you want to check for truthiness instead of a defined value.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, at least one of which must return a defined value.
+ *
+ * ### Example
+ * ```js
+ * // Accept a value that matches any of several pattern-based normalizations
+ * new Schema('string').normalizer({
+ *   $any: [
+ *     {$match: /^\d+$/},
+ *     {$match: /^[a-f0-9]+$/i},
+ *   ]
+ * })
+ *
+ * // Require a value that can be processed by at least one schema
+ * new Schema('any').validator({$any: ['$numeric', '$boolean', '$date']})
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const ANY_CONSTRAINT: ValueProcessorDefinition;
+/**
+ * ## $all
+ *
+ * A constraint that checks whether all the provided processors return a defined value.
+ *
+ * Returns the last defined value returned from the processors, or throws if any returned undefined or threw an error.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$and` if you want to check for truthiness instead of defined values.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, all of which must return a defined value.
+ *
+ * ### Example
+ * ```js
+ * // Validate that all normalizations succeed for a value that must satisfy multiple constraints
+ * new Schema('string').validator({
+ *   $all: ['$non-empty', '$email', {$matches: /\.com$/}]
+ * })
+ *
+ * // Ensure a value passes both a type check and a range constraint
+ * new Schema('any').validator({$all: ['$numeric', {$range: {min: 0, max: 100}}]})
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const ALL_CONSTRAINT: ValueProcessorDefinition;
+/**
+ * ## $exclusive
+ *
+ * A constraint that checks whether exactly one of the provided processors returns a truthy value.
+ *
+ * Returns the single truthy value, or throws if zero or more than one are truthy.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$one` if you want to check for success (defined value) instead of truthiness.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, exactly one of which must return a truthy value.
+ *
+ * ### Example
+ * ```js
+ * // A form field must have either an email or a phone number, but not both
+ * new Schema('object').validator({
+ *   $exclusive: [
+ *     {$property: 'email'},
+ *     {$property: 'phone'},
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const EXCLUSIVE_CONSTRAINT: ValueProcessorDefinition;
+/**
+ * ## $one
+ *
+ * A constraint that checks whether exactly one of the provided processors returns a defined value.
+ *
+ * Returns the single defined value, or throws if zero or more than one succeed.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$exclusive` if you want to check for truthiness instead of a defined value.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, exactly one of which must return a defined value.
+ *
+ * ### Example
+ * ```js
+ * // Exactly one authentication method must be configured
+ * new Schema('object').validator({
+ *   $one: [
+ *     {$property: 'apiKey'},
+ *     {$property: 'oauth'},
+ *     {$property: 'basicAuth'},
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const ONE_CONSTRAINT: ValueProcessorDefinition;
+/**
+ * ## $first
+ *
+ * An operator that returns the first defined value successfully returned from a sequence of processors.
+ *
+ * Unlike `$any`, no exception is thrown if there are no defined results, it simply returns `undefined`.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * There is no truthy variant of `$first`, as there generally isn't much value in differentiating which
+ * truthy value to return; use constructs like `{$if: {$or: [...]}}` to wrap truthy sequence constraints as operators.
+ * `$first` is basically an alias for `{$gate: {$any: [...]}}`.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications to try in order.
+ *
+ * ### Example
+ * ```js
+ * // Try several environment variable names and return the first one that has a value
+ * new Schema('object').transformer({
+ *   $first: [
+ *     {$reference: 'DATABASE_URL'},
+ *     {$reference: 'DB_URL'},
+ *     {$reference: 'POSTGRES_URL'},
+ *   ]
+ * })
+ *
+ * // Return the first successfully parsed format
+ * new Schema('string').normalizer({
+ *   $first: ['$number', '$date', '$boolean']
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const FIRST_OPERATOR: ValueProcessorDefinition;
+import type { ValueProcessorDefinition } from '../../value-processor/value-processor.js';

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

@@ -0,0 +1,31 @@
+/**
+ * ## $sort
+ *
+ * Returns a new sorted array. Non-mutating. Numbers are compared numerically;
+ * all other values are compared lexicographically as strings.
+ * Throws if the input is not an array.
+ *
+ * ### Parameters
+ * - `key` (string|null, optional, default `null`): Object property key to sort by.
+ * - `direction` (`'asc'`|`'desc'`, optional, default `'asc'`): Sort direction.
+ *
+ * ### Example
+ * ```js
+ * // Sort an array of numbers in ascending order
+ * new Schema('array').transformer('$sort')
+ * // [3, 1, 2] → [1, 2, 3]
+ *
+ * // Sort strings in descending order
+ * new Schema('array').transformer({$sort: {direction: 'desc'}})
+ *
+ * // Sort an array of objects by a property
+ * new Schema('array').transformer({$sort: {key: 'name'}})
+ * // [{name: 'Charlie'}, {name: 'Alice'}] → [{name: 'Alice'}, {name: 'Charlie'}]
+ *
+ * // Sort objects by a numeric property descending
+ * new Schema('array').transformer({$sort: {key: 'score', direction: 'desc'}})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const SORT_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,33 @@
+/**
+ * ## $split
+ *
+ * Stringify the input and split on the provided separator, returning an array.
+ *
+ * ### Parameters
+ * - `separator` (string, optional, defaults to ","): The value to use for splitting
+ * - `limit` (integer, optional): The maximum number of elements to return.
+ *
+ * Note that RegExp separators must be wrapped in a `$literal` to prevent evaluation as constraints.
+ * Otherwise, follows the behavior of JavaScript's String.prototype.split.
+ *
+ * ### Example
+ * ```js
+ * // Split a comma-separated list into an array
+ * new Schema('string').transformer('$split')
+ * // 'a,b,c' → ['a', 'b', 'c']
+ *
+ * // Split on a custom separator
+ * new Schema('string').transformer({$split: {separator: ':'}})
+ * // 'host:port' → ['host', 'port']
+ *
+ * // Split then normalize each element
+ * new Schema('string').normalizer([{$split: {separator: ','}}, {$each: '$trim'}])
+ * // '  a , b , c  ' → ['a', 'b', 'c']
+ *
+ * // Split a PATH-style variable, limiting to 5 segments
+ * new Schema('string').transformer({$split: {separator: '/', limit: 5}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}*
+ */
+export const SPLIT_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

package/types/core-library/processors/string-extra-operators.d.ts

@@ -0,0 +1,83 @@
+/**
+ * ## $replace
+ *
+ * Replaces occurrences of a pattern in a string.
+ *
+ * - Pattern may be a string (replaced globally via `replaceAll`) or a RegExp (flags control global).
+ * - Replacement must be a string.
+ *
+ * ### Parameters
+ * - First positional: pattern (string or RegExp, required)
+ * - Second positional: replacement (string, required)
+ *
+ * ### Example
+ * ```js
+ * // Replace all underscores with hyphens
+ * new Schema('string').transformer({$replace: ['_', '-']})
+ * // 'hello_world' → 'hello-world'
+ *
+ * // Strip all non-digit characters using a RegExp
+ * new Schema('string').normalizer({$replace: [/\D+/g, '']})
+ * // '+1 (800) 555-1234' → '18005551234'
+ *
+ * // Redact sensitive patterns
+ * new Schema('string').transformer({$replace: [/\b\d{4}-\d{4}-\d{4}-\d{4}\b/g, '[REDACTED]']})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const REPLACE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;
+/**
+ * ## $substring
+ *
+ * Extracts a portion of a string by start index and optional length.
+ *
+ * ### Parameters
+ * - `start` (number, required): Start index (0-based).
+ * - `length` (number, optional): Number of characters to extract. If omitted, extracts to end of string.
+ *
+ * ### Example
+ * ```js
+ * // Extract the first 8 characters of a hash
+ * new Schema('string').transformer({$substring: {start: 0, length: 8}})
+ * // 'abcdef1234567890' → 'abcdef12'
+ *
+ * // Strip a known prefix (e.g. 'Bearer ')
+ * new Schema('string').transformer({$substring: {start: 7}})
+ *
+ * // Extract a fixed-position field from a formatted string
+ * new Schema('string').transformer({$substring: {start: 4, length: 2}})
+ * // '2026-03-21' → '03' (month)
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const SUBSTRING_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;
+/**
+ * ## $pad
+ *
+ * Pads a string to a minimum width.
+ *
+ * ### Parameters
+ * - `width` (number, required): Target minimum length.
+ * - `char` (string, optional): Pad character. Defaults to `' '`.
+ * - `side` (`'left'`|`'right'`, optional): Which side to pad. Defaults to `'left'`.
+ *
+ * ### Example
+ * ```js
+ * // Zero-pad a numeric string to 6 digits
+ * new Schema('string').transformer({$pad: {width: 6, char: '0'}})
+ * // '42' → '000042'
+ *
+ * // Right-pad a string to fill a fixed-width column
+ * new Schema('string').transformer({$pad: {width: 20, side: 'right'}})
+ * // 'Alice' → 'Alice               '
+ *
+ * // Pad a month/day to 2 digits
+ * new Schema('number').transformer(['$string', {$pad: {width: 2, char: '0'}}])
+ * // 3 → '03'
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const PAD_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,10 @@
+/**
+ * ## $string
+ *
+ * Ensures value is a string, stringifying as necessary.  Everything other than null and undefined can be converted.
+ *
+ * See `$is-string` for strict string validation.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const STRING_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,27 @@
+/**
+ * ## $target
+ *
+ * Returns the target value passed to the processor (value being built relative to the root).
+ * (Note: may return undefined or partial results, depending on the schema!)
+ *
+ * ### Example
+ *
+ * ```js
+ * // Uses $target to provide an object for $get to access
+ * new Schema('object')
+ *   .property('level-one', new Schema('object')
+ *     .property('enable-level-3', new Schema('boolean').default(false))
+ *     .property('level-two', new Schema('object')
+ *       .property('level-three', new Schema('object')
+ *         .condition(['$target', {get: 'level-one.enable-level-3'}])
+ *         .property('child', new Schema('string'))
+ *       )
+ *     )
+ *   )
+ * // { "level-one": { "level-two": { "level-three": { "child": "ignored" } } } }
+ * // { "level-one": { "enable-level-3": true, "level-two": { "level-three": { "child": "is set" } } } }
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const TARGET_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,31 @@
+/**
+ * ## $template
+ *
+ * Operator that interpolates a template string using properties from the input object.
+ * Placeholders use `{key}` syntax; double braces `{{` and `}}` are literal brace escapes.
+ *
+ * The input must be a plain object. Unknown keys resolve to an empty string.
+ *
+ * ### Parameters
+ * - `template` (string, required): The template string to interpolate.
+ *
+ * ### Example
+ * ```js
+ * // Build a connection string from object properties
+ * new Schema('object', {
+ *   host: new Schema('string'),
+ *   port: new Schema('number'),
+ *   database: new Schema('string'),
+ * }).transformer({$template: 'postgresql://{host}:{port}/{database}'})
+ *
+ * // Format a greeting from a user object
+ * new Schema('object').transformer({$template: 'Hello, {firstName} {lastName}!'})
+ *
+ * // Use double-braces to produce literal curly braces
+ * new Schema('object').transformer({$template: 'Value: {{literal}}'})
+ * // {} → 'Value: {literal}'
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const TEMPLATE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,12 @@
+/**
+ * ## $title-case
+ *
+ * Converts a string to title case, capitalizing the first letter of each significant word
+ * and leaving articles, coordinating conjunctions, and short prepositions lowercase when
+ * they appear in the middle of the phrase. The first and last words are always capitalized.
+ *
+ * Lowercase words: a, an, the, and, but, or, nor, for, so, yet, at, by, in, of, on, to, up, as, via
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const TITLE_CASE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,9 @@
+/**
+ * ## $trim
+ *
+ * Removes leading and trailing whitespace from a string value.
+ * Safe to use in normalize phase (non-throwing operator).
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const TRIM_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,23 @@
+/**
+ * ## $truthy
+ *
+ * Validates that the value is "truthy".  Note that the definition of what values are "truthy"
+ * mirrors the boolean schema normalization of special strings like "true" and "no".
+ *
+ * ### Example
+ * ```js
+ * // Require a feature flag to be truthy before processing a value
+ * new Schema('object', {
+ *   enabled: new Schema('boolean'),
+ *   config: new Schema('string').validator({$assert: {$property: 'enabled'}}),
+ * })
+ *
+ * // Use $truthy inside a conditional to branch on truthiness
+ * new Schema('any').transformer({
+ *   $if: ['$truthy', '$uppercase']
+ * })
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const TRUTHY_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,11 @@
+/**
+ * ## $type
+ *
+ * Returns the type name of the input value as a string. Unlike the `$is-*` constraint family,
+ * this operator produces the type name as a value usable in pipelines and templates.
+ *
+ * **Return values**: `'string'`, `'number'`, `'boolean'`, `'array'`, `'object'`, `'date'`, `'schema'`, `'null'`, `'undefined'`
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const TYPE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,10 @@
+/**
+ * ## $unique
+ *
+ * Returns a new array with duplicate values removed, preserving insertion order
+ * of first occurrences. Uses identity-based (`Set`) deduplication.
+ * Throws if the input is not an array.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const UNIQUE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,9 @@
+/**
+ * ## $uppercase
+ *
+ * Converts a string value to uppercase. Safe to use in normalize phase (non-throwing).
+ * Non-string values are coerced to strings before conversion.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const UPPERCASE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,20 @@
+/**
+ * ## $url
+ *
+ * Validates that a string is a valid URL and normalizes it to canonical form.
+ * Uses the WHATWG URL Standard for validation and normalization. The normalized
+ * URL includes explicit protocol, properly encoded characters, and standardized formatting.
+ *
+ * - `https://example.com` → `https://example.com/`
+ * - `http://localhost:8080/api` → `http://localhost:8080/api`
+ * - `https://example.com/path?query=value` → `https://example.com/path?query=value`
+ * - `ftp://files.example.com/` → `ftp://files.example.com/`
+ *
+ * - `not-a-url` (missing protocol)
+ * - `//example.com` (missing protocol)
+ * - `example.com` (missing protocol)
+ * - `http://` (missing host)
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const URL_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,31 @@
+/**
+ * ## $url-decode
+ *
+ * Decodes a percent-encoded URL string.
+ *
+ * Use `{$url-decode: {full: true}}` to decode a complete URL (`decodeURI`)
+ * rather than a component (`decodeURIComponent`). Full-URL decoding preserves
+ * sequences that are valid structural URL characters (`%2F` etc.) undecoded.
+ *
+ * Throws if the input is not a string or contains a malformed escape sequence.
+ *
+ * ### Parameters
+ * - `full` (boolean, optional, default `false`): Use full-URL decoding (`decodeURI`) rather than component decoding (`decodeURIComponent`).
+ *
+ * ### Example
+ * ```js
+ * // Decode a percent-encoded query parameter
+ * new Schema('string').normalizer('$url-decode')
+ * // 'hello%20world%20%26%20more' → 'hello world & more'
+ *
+ * // Decode a full URL without decoding structural characters
+ * new Schema('string').normalizer({'$url-decode': {full: true}})
+ * // 'https://example.com/path%20with%20spaces' → 'https://example.com/path with spaces'
+ *
+ * // Decode then validate the result
+ * new Schema('string').normalizer('$url-decode').validator('$non-empty')
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const URL_DECODE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,36 @@
+/**
+ * ## $url-encode
+ *
+ * Percent-encodes a string for safe use as a URL component (query param value,
+ * path segment, etc.). Encodes all characters except unreserved URI characters
+ * (`A–Z a–z 0–9 - _ . !  ~ * ' ( )`).
+ *
+ * Use `{$url-encode: {full: true}}` to encode a complete URL instead of a
+ * component — this preserves `://`, `/`, `?`, `&`, `=`, and other structural
+ * characters rather than encoding them.
+ *
+ * Non-string inputs are coerced to string before encoding.
+ *
+ * ### Parameters
+ * - `full` (boolean, optional, default `false`): Use full-URL encoding (`encodeURI`) rather than component encoding (`encodeURIComponent`).
+ *
+ * ### Example
+ * ```js
+ * // Encode a query parameter value
+ * new Schema('string').transformer('$url-encode')
+ * // 'hello world & more' → 'hello%20world%20%26%20more'
+ *
+ * // Encode a full URL, preserving structural characters
+ * new Schema('string').transformer({'$url-encode': {full: true}})
+ * // 'https://example.com/path with spaces' → 'https://example.com/path%20with%20spaces'
+ *
+ * // Build an encoded query string from an object
+ * new Schema('object', {
+ *   q: new Schema('string').transformer('$url-encode'),
+ *   page: new Schema('number'),
+ * })
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const URL_ENCODE_OPERATOR: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

@@ -0,0 +1,20 @@
+/**
+ * ## $uuid
+ *
+ * Validates that a string matches valid UUID format (versions 1-5).
+ * UUIDs must follow RFC 4122 format: 8-4-4-4-12 hexadecimal digits
+ * separated by hyphens.
+ *
+ * - `550e8400-e29b-41d4-a716-446655440000` (v4)
+ * - `6ba7b810-9dad-11d1-80b4-00c04fd430c8` (v1)
+ * - `3d813cbb-47fb-32ba-91df-831e1593ac29` (v3)
+ * - `A6EAFB30-E49B-51D4-9B1D-8F6C0F89E8B3` (case-insensitive)
+ *
+ * - `550e8400-e29b-41d4-a716` (too short)
+ * - `550e8400e29b41d4a716446655440000` (missing hyphens)
+ * - `550e8400-e29b-61d4-a716-446655440000` (invalid version digit)
+ * - `not-a-valid-uuid-string`
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const UUID_CONSTRAINT: import("../../value-processor/value-processor.js").ValueProcessorDefinition;

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

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

package/types/core-library/schemas/any-schema.d.ts

@@ -0,0 +1,2 @@
+export const ANY_SCHEMA: Schema;
+import { Schema } from '../../schema.js';

package/types/core-library/schemas/array-schema.d.ts

@@ -0,0 +1,2 @@
+export const ARRAY_SCHEMA: Schema;
+import { Schema } from '../../schema.js';

package/types/core-library/schemas/boolean-schema.d.ts

@@ -0,0 +1,2 @@
+export const BOOLEAN_SCHEMA: Schema;
+import { Schema } from '../../schema.js';

package/types/core-library/schemas/date-schema.d.ts

@@ -0,0 +1,2 @@
+export const DATE_SCHEMA: Schema;
+import { Schema } from '../../schema.js';

package/types/core-library/schemas/function-schema.d.ts

@@ -0,0 +1,2 @@
+export const FUNCTION_SCHEMA: Schema;
+import { Schema } from '../../schema.js';

package/types/core-library/schemas/number-schema.d.ts

@@ -0,0 +1,2 @@
+export const NUMBER_SCHEMA: Schema;
+import { Schema } from '../../schema.js';