@azure-net/node-kit 0.0.0-stage → 0.1.0

package/dist/validation/Result.js

@@ -0,0 +1,264 @@
+import { types } from "node:util";
+/**
+ * JSON metadata only: bigint -> decimal string, Date -> ISO (invalid -> null),
+ * RegExp -> /source/flags, non-finite numbers -> null. Only own enumerable data
+ * properties are copied; accessors, functions, symbols, undefined and proxies
+ * are omitted (null in arrays). No getters or toJSON methods are called.
+ * Cycles become "[Circular]". Depth (32), container width (1000), and shared
+ * per-result budgets (10000 entries / 100000 characters) bound the snapshot.
+ * Truncated values become "[Truncated]"; oversized keys are omitted. Objects
+ * use a $snapshot marker when their contents cannot be represented in budget.
+ */
+function snapshotMetadata(value, budget, active = new WeakSet(), depth = 0) {
+    if (budget.entries-- <= 0 || depth > 32)
+        return "[Truncated]";
+    const text = (input) => {
+        const length = Math.min(input.length, 4096, Math.max(0, budget.characters));
+        budget.characters -= length;
+        return (input.slice(0, length) + (length < input.length ? "[Truncated]" : ""));
+    };
+    if (value === null || typeof value === "boolean")
+        return value;
+    if (typeof value === "string")
+        return text(value);
+    if (typeof value === "bigint")
+        return text(String(value));
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : null;
+    if (typeof value !== "object" || types.isProxy(value))
+        return undefined;
+    if (active.has(value))
+        return "[Circular]";
+    if (types.isDate(value)) {
+        const time = Date.prototype.getTime.call(value);
+        return Number.isFinite(time)
+            ? text(Date.prototype.toISOString.call(value))
+            : null;
+    }
+    if (types.isRegExp(value)) {
+        const source = Object.getOwnPropertyDescriptor(RegExp.prototype, "source").get.call(value);
+        let flags = "";
+        for (const [property, flag] of [
+            ["hasIndices", "d"],
+            ["global", "g"],
+            ["ignoreCase", "i"],
+            ["multiline", "m"],
+            ["dotAll", "s"],
+            ["unicode", "u"],
+            ["unicodeSets", "v"],
+            ["sticky", "y"],
+        ]) {
+            if (Object.getOwnPropertyDescriptor(RegExp.prototype, property)?.get?.call(value))
+                flags += flag;
+        }
+        return text(`/${source}/${flags}`);
+    }
+    active.add(value);
+    try {
+        if (Array.isArray(value)) {
+            const length = Object.getOwnPropertyDescriptor(value, "length")
+                .value;
+            const result = [];
+            for (let i = 0; i < Math.min(length, 1000); i++) {
+                if (budget.entries <= 0)
+                    break;
+                const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+                result.push(snapshotMetadata(descriptor && "value" in descriptor ? descriptor.value : undefined, budget, active, depth + 1) ?? null);
+            }
+            if (result.length < length)
+                result.push("[Truncated]");
+            return Object.freeze(result);
+        }
+        const result = {};
+        let count = 0;
+        for (const key of Reflect.ownKeys(value)) {
+            if (budget.entries <= 0 || count++ >= 1000 || budget.characters <= 0) {
+                Object.defineProperty(result, "$snapshot", {
+                    value: "[Truncated]",
+                    enumerable: true,
+                    configurable: true,
+                });
+                break;
+            }
+            if (typeof key !== "string" ||
+                key.length > 4096 ||
+                key.length > budget.characters)
+                continue;
+            budget.characters -= key.length;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor?.enumerable || !("value" in descriptor))
+                continue;
+            const item = snapshotMetadata(descriptor.value, budget, active, depth + 1);
+            if (item !== undefined)
+                Object.defineProperty(result, key, {
+                    value: item,
+                    enumerable: true,
+                    configurable: true,
+                });
+        }
+        return Object.freeze(result);
+    }
+    finally {
+        active.delete(value);
+    }
+}
+function snapshotParams(params, budget) {
+    const snapshot = snapshotMetadata(params, budget);
+    return snapshot !== null && typeof snapshot === "object"
+        ? snapshot
+        : Object.freeze({ $snapshot: snapshot ?? "[Omitted]" });
+}
+// Public paths need limits independently of the engine's traversal budget.
+const MAX_ISSUES = 10_000;
+const MAX_DEPTH = 128;
+const MAX_TREE_NODES = 100_000;
+const MAX_ARRAY_SLOTS = 100_000;
+const MAX_INDEX = 10_000;
+function snapshotIssues(issues) {
+    if (issues.length > MAX_ISSUES)
+        throw new RangeError("Too many validation issues");
+    const root = { arrayLength: 0 };
+    let nodes = 1;
+    let slots = 0;
+    const metadataBudget = {
+        entries: 10_000,
+        characters: 100_000,
+    };
+    return Object.freeze(issues.map((issue) => {
+        if (issue.path.length > MAX_DEPTH)
+            throw new RangeError("Validation path is too deep");
+        let node = root;
+        for (const part of issue.path) {
+            if (typeof part === "number") {
+                if (!Number.isSafeInteger(part) || part < 0 || part > MAX_INDEX) {
+                    throw new RangeError("Validation array index must be an integer between 0 and 10000");
+                }
+                // Count each array's high-water mark, not each occurrence of its path.
+                const length = Math.max(node.arrayLength, part + 1);
+                slots += length - node.arrayLength;
+                node.arrayLength = length;
+                if (slots > MAX_ARRAY_SLOTS)
+                    throw new RangeError("Validation array paths are too large");
+            }
+            else if (typeof part !== "string") {
+                throw new TypeError("Validation path segments must be strings or numbers");
+            }
+            const children = (node.children ??= new Map());
+            let child = children.get(part);
+            if (!child) {
+                if (++nodes > MAX_TREE_NODES)
+                    throw new RangeError("Validation error tree is too large");
+                child = { arrayLength: 0 };
+                children.set(part, child);
+            }
+            node = child;
+        }
+        return Object.freeze({
+            path: Object.freeze([...issue.path]),
+            code: issue.code,
+            message: issue.message,
+            params: snapshotParams(issue.params, metadataBudget),
+        });
+    }));
+}
+function freezeTree(node) {
+    if (node.fields) {
+        for (const child of Object.values(node.fields))
+            freezeTree(child);
+        Object.freeze(node.fields);
+    }
+    if (node.items) {
+        for (const child of node.items)
+            if (child)
+                freezeTree(child);
+        Object.freeze(node.items);
+    }
+    Object.freeze(node.messages);
+    Object.freeze(node);
+}
+/** A snapshot of validation diagnostics. Failed results never retain `data`. */
+export class ValidationResult {
+    isValid;
+    issues;
+    data;
+    #errors;
+    /** No issues means success (including when data is undefined); otherwise data is discarded. */
+    constructor(data, issues) {
+        this.issues = snapshotIssues(issues);
+        this.isValid = this.issues.length === 0;
+        this.data = this.isValid ? data : undefined;
+        Object.freeze(this);
+    }
+    get errors() {
+        if (this.#errors)
+            return this.#errors;
+        const root = { messages: [] };
+        for (const issue of this.issues) {
+            let node = root;
+            for (const part of issue.path) {
+                if (typeof part === "number") {
+                    const items = (node.items ??= []);
+                    while (items.length <= part)
+                        items.push(null);
+                    node = items[part] ??= { messages: [] };
+                }
+                else {
+                    const fields = (node.fields ??= Object.create(null));
+                    node = fields[part] ??= { messages: [] };
+                }
+            }
+            node.messages.push(issue.message);
+        }
+        freezeTree(root);
+        this.#errors = root;
+        return this.#errors;
+    }
+    get formErrors() {
+        return this.errors.messages;
+    }
+    /**
+     * Flat RFC 6901 JSON Pointer keys: ~ becomes ~0, / becomes ~1.
+     * Root issues are excluded (see formErrors). String "0" and numeric 0
+     * share a pointer; the typed tree preserves their separate namespaces.
+     */
+    toFieldErrors() {
+        const fields = Object.create(null);
+        for (const issue of this.issues) {
+            if (!issue.path.length)
+                continue;
+            const pointer = "/" +
+                issue.path
+                    .map((part) => String(part).replace(/~/g, "~0").replace(/\//g, "~1"))
+                    .join("/");
+            (fields[pointer] ??= []).push(issue.message);
+        }
+        for (const messages of Object.values(fields))
+            Object.freeze(messages);
+        return Object.freeze(fields);
+    }
+}
+/** An Error wrapper whose JSON representation excludes validated input and stack. */
+export class ValidationError extends Error {
+    result;
+    constructor(result, message = "Validation failed") {
+        super(message);
+        if (result.isValid)
+            throw new TypeError("ValidationError requires a failed validation result");
+        this.name = "ValidationError";
+        this.result = result;
+    }
+    get issues() {
+        return this.result.issues;
+    }
+    get errors() {
+        return this.result.errors;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            issues: this.issues,
+            errors: this.errors,
+        };
+    }
+}

package/dist/validation/Symbols.d.ts

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

package/dist/validation/Symbols.js

@@ -0,0 +1 @@
+export const validatorDefinition = Symbol("Validator.definition");

package/dist/validation/Types.d.ts

@@ -0,0 +1,105 @@
+export type ValidationPath = readonly (string | number)[];
+export type ValidationParams = Readonly<Record<string, unknown>>;
+export interface MessageContext {
+    readonly code: string;
+    readonly messageKey: string;
+    readonly params: ValidationParams;
+    readonly path: ValidationPath;
+    readonly locale: string;
+    readonly label: string;
+}
+export type ValidationMessage = string | ((context: MessageContext) => string);
+export type ValidationMessages = Readonly<Record<string, ValidationMessage>>;
+export type ValidationLocales = Readonly<Record<string, ValidationMessages>>;
+export interface RuleOptions {
+    readonly message?: ValidationMessage;
+    readonly messageKey?: string;
+    readonly code?: string;
+    readonly label?: string;
+}
+export interface RuleFailure extends RuleOptions {
+    readonly params?: ValidationParams;
+    /** Relative to the current field. Omit to report against that field. */
+    readonly path?: ValidationPath;
+}
+export type RuleResult = boolean | RuleFailure | readonly RuleFailure[];
+export interface RuleContext<TValue, TData = unknown, TRoot = TData, TContext = unknown> {
+    readonly value: TValue;
+    readonly data: TData;
+    readonly root: TRoot;
+    readonly context: TContext;
+    readonly path: ValidationPath;
+    readonly signal: AbortSignal | undefined;
+}
+export type SyncValidationRule<TValue, TData = unknown, TRoot = TData, TContext = unknown> = (context: RuleContext<TValue, TData, TRoot, TContext>) => RuleResult;
+export type AsyncValidationRule<TValue, TData = unknown, TRoot = TData, TContext = unknown> = (context: RuleContext<TValue, TData, TRoot, TContext>) => PromiseLike<RuleResult>;
+export type ValidationRule<TValue, TData = unknown, TRoot = TData, TContext = unknown> = (context: RuleContext<TValue, TData, TRoot, TContext>) => RuleResult | PromiseLike<RuleResult>;
+/** Built-in descriptors are immutable. The phantom output preserves field compatibility. */
+export interface BuiltinRule<TValue = unknown, TContext = unknown, TRoot = unknown> {
+    readonly kind: "test" | "optional" | "nullable" | "object" | "array" | "tuple" | "record" | "map" | "set" | "union" | "intersection" | "lazy" | "validator";
+    readonly code: string;
+    readonly structural: boolean;
+    readonly options: RuleOptions;
+    readonly params: ValidationParams;
+    readonly test?: (value: unknown, context: RuleContext<unknown>) => RuleResult;
+    readonly shape?: Readonly<Record<string, readonly AnyRule[]>>;
+    readonly items?: readonly AnyRule[];
+    readonly keys?: readonly AnyRule[];
+    readonly tuple?: readonly (readonly AnyRule[])[];
+    readonly rest?: readonly AnyRule[];
+    readonly alternatives?: readonly (readonly AnyRule[])[];
+    readonly discriminator?: string;
+    readonly variants?: Readonly<Record<string, readonly AnyRule[]>>;
+    readonly resolve?: () => readonly AnyRule[];
+    readonly unknownKeys?: "reject" | "allow";
+    readonly output?: () => TValue;
+    readonly needsContext?: (context: TContext) => void;
+    readonly needsRoot?: (root: TRoot) => void;
+}
+export type FieldRule<TValue, TData = unknown, TRoot = TData, TContext = unknown> = BuiltinRule<TValue, TContext, TRoot> | ValidationRule<TValue, TData, TRoot, TContext>;
+export type ValidationRules<T extends object, TRoot = T, TContext = unknown> = {
+    readonly [K in keyof T]-?: K extends string | number ? readonly (BuiltinRule<T[K], TContext, TRoot> | ValidationRule<NoInfer<T[K]>, NoInfer<T>, TRoot, TContext>)[] : never;
+};
+/** Internal erased rule representation; public callbacks retain their contextual types. */
+export type AnyRule = BuiltinRule<any, any, any> | ValidationRule<any, any, any, any>;
+export interface ValidationIssue {
+    readonly path: ValidationPath;
+    readonly code: string;
+    readonly message: string;
+    readonly params: ValidationParams;
+}
+/** Separate namespaces avoid collisions with fields named messages, fields or items. */
+export type ValidationErrors<T = unknown> = {
+    readonly messages: readonly string[];
+    readonly fields?: unknown extends T ? Readonly<Record<string, ValidationErrors>> : NonNullable<T> extends readonly unknown[] | Map<unknown, unknown> | Set<unknown> ? never : NonNullable<T> extends object ? {
+        readonly [K in keyof NonNullable<T>]?: ValidationErrors<NonNullable<T>[K]>;
+    } : never;
+    readonly items?: unknown extends T ? readonly (ValidationErrors | null)[] : NonNullable<T> extends readonly (infer U)[] ? readonly (ValidationErrors<U> | null)[] : NonNullable<T> extends Map<infer K, infer V> ? readonly (ValidationErrors<{
+        key: K;
+        value: V;
+    }> | null)[] : NonNullable<T> extends Set<infer U> ? readonly (ValidationErrors<U> | null)[] : never;
+};
+export interface ValidatorOptions {
+    readonly messages?: ValidationMessages;
+    readonly locales?: ValidationLocales;
+    readonly defaultLocale?: string;
+    readonly fallbackLocale?: string;
+    readonly getLocale?: () => string | undefined;
+    readonly maxIssues?: number;
+    readonly maxDepth?: number;
+    readonly maxNodes?: number;
+    readonly unknownKeys?: "reject" | "allow";
+    readonly cascade?: "stop" | "continue";
+}
+export interface ValidatorCreateOptions extends Omit<ValidatorOptions, "messages"> {
+    /** A single-language catalog or catalogs keyed by locale. */
+    readonly messages?: ValidationMessages | ValidationLocales;
+}
+export interface ValidationOptions<TContext = unknown> {
+    readonly locale?: string;
+    readonly context?: TContext;
+    readonly signal?: AbortSignal;
+}
+export type ValidationArguments<TContext> = unknown extends TContext ? [options?: ValidationOptions<TContext>] : [options: ValidationOptions<TContext> & {
+    readonly context: TContext;
+}];

package/dist/validation/Types.js

@@ -0,0 +1 @@
+export {};

package/dist/validation/Validator.d.ts

@@ -0,0 +1,26 @@
+import type { ValidationResult } from "./Result.js";
+import type { AnyRule, ValidationArguments, ValidationRules, ValidatorOptions, ValidatorCreateOptions } from "./Types.js";
+import { validatorDefinition } from "./Symbols.js";
+type Shape = Readonly<Record<string, readonly AnyRule[]>>;
+type ValidatorConstructor<T extends object, C> = (new () => Validator<T, C>) & {
+    readonly configuration: ValidatorOptions;
+};
+export declare abstract class Validator<T extends object, TContext = unknown> {
+    static readonly configuration: ValidatorOptions;
+    /** Called once per subclass, after construction. Never capture request-local state here. */
+    protected abstract rules(): ValidationRules<T, T, TContext>;
+    private static config;
+    private static schema;
+    static [validatorDefinition]<T extends object, C>(this: ValidatorConstructor<T, C>): Shape;
+    static validate<T extends object, C = unknown>(this: ValidatorConstructor<T, C>, input: unknown, ...[options]: ValidationArguments<C>): ValidationResult<T>;
+    static validateAndThrow<T extends object, C = unknown>(this: ValidatorConstructor<T, C>, input: unknown, ...[options]: ValidationArguments<C>): T;
+    static validateAsync<T extends object, C = unknown>(this: ValidatorConstructor<T, C>, input: unknown, ...[options]: ValidationArguments<C>): Promise<ValidationResult<T>>;
+    static validateAndThrowAsync<T extends object, C = unknown>(this: ValidatorConstructor<T, C>, input: unknown, ...[options]: ValidationArguments<C>): Promise<T>;
+    /** Both Validator.create(options) and new Validator.create(options) return a base class. */
+    static readonly create: {
+        (options?: ValidatorCreateOptions): typeof Validator;
+        new (options?: ValidatorCreateOptions): typeof Validator;
+    };
+}
+export declare const createValidator: (options?: ValidatorCreateOptions) => typeof Validator;
+export {};

package/dist/validation/Validator.js

@@ -0,0 +1,95 @@
+import { validateAsync, validateSync } from "./Engine.js";
+import { ValidationError } from "./Result.js";
+import { validatorDefinition } from "./Symbols.js";
+const schemas = new WeakMap();
+const configurations = new WeakMap();
+function settings(options) {
+    for (const [key, limit] of [
+        ["maxDepth", 64],
+        ["maxNodes", 10000],
+        ["maxIssues", 10000],
+    ]) {
+        const value = options[key];
+        if (value !== undefined &&
+            (!Number.isSafeInteger(value) || value < 1 || value > limit)) {
+            throw new RangeError(`${key} must be an integer between 1 and ${limit}.`);
+        }
+    }
+    const entries = Object.values(options.messages ?? {});
+    const multi = entries.some((value) => value !== null && typeof value === "object");
+    if (multi &&
+        entries.some((value) => value === null || typeof value !== "object" || Array.isArray(value))) {
+        throw new TypeError("messages must be a flat catalog or a locale-to-catalog map, not a mixture.");
+    }
+    const messages = multi
+        ? undefined
+        : options.messages;
+    const locales = options.locales ??
+        (multi ? options.messages : undefined);
+    return Object.freeze({
+        ...options,
+        messages: messages && Object.freeze({ ...messages }),
+        locales: locales &&
+            Object.freeze(Object.fromEntries(Object.entries(locales).map(([locale, messages]) => [
+                locale,
+                Object.freeze({ ...messages }),
+            ]))),
+    });
+}
+export class Validator {
+    static configuration = Object.freeze({});
+    static config(constructor) {
+        let config = configurations.get(constructor);
+        if (!config) {
+            config = settings(constructor.configuration);
+            configurations.set(constructor, config);
+        }
+        return config;
+    }
+    static schema(constructor) {
+        let schema = schemas.get(constructor);
+        if (!schema) {
+            const definition = new constructor().rules();
+            if (Object.getOwnPropertySymbols(definition).length)
+                throw new TypeError("Validation schemas support string and numeric keys, not symbols.");
+            schema = Object.freeze(Object.fromEntries(Object.entries(definition).map(([key, rules]) => {
+                if (!Array.isArray(rules))
+                    throw new TypeError(`Rules for ${key} must be an array.`);
+                return [key, Object.freeze([...rules])];
+            })));
+            schemas.set(constructor, schema);
+        }
+        return schema;
+    }
+    static [validatorDefinition]() {
+        Validator.config(this);
+        return Validator.schema(this);
+    }
+    static validate(input, ...[options]) {
+        return validateSync(input, Validator.schema(this), Validator.config(this), options ?? {});
+    }
+    static validateAndThrow(input, ...[options]) {
+        const result = validateSync(input, Validator.schema(this), Validator.config(this), options ?? {});
+        if (!result.isValid)
+            throw new ValidationError(result);
+        return result.data;
+    }
+    static async validateAsync(input, ...[options]) {
+        return validateAsync(input, Validator.schema(this), Validator.config(this), options ?? {});
+    }
+    static async validateAndThrowAsync(input, ...[options]) {
+        const result = await validateAsync(input, Validator.schema(this), Validator.config(this), options ?? {});
+        if (!result.isValid)
+            throw new ValidationError(result);
+        return result.data;
+    }
+    /** Both Validator.create(options) and new Validator.create(options) return a base class. */
+    static create = function (options = {}) {
+        const configuration = settings(options);
+        class ConfiguredValidator extends Validator {
+            static configuration = configuration;
+        }
+        return ConfiguredValidator;
+    };
+}
+export const createValidator = (options = {}) => Validator.create(options);

package/dist/validation/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Types.js";
+export * from "./Result.js";
+export * from "./Validator.js";
+export * from "./rules/index.js";
+export * from "./messages/index.js";

package/dist/validation/index.js

@@ -0,0 +1,5 @@
+export * from "./Types.js";
+export * from "./Result.js";
+export * from "./Validator.js";
+export * from "./rules/index.js";
+export * from "./messages/index.js";

package/dist/validation/messages/En.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationMessages } from "../Types.js";
+/** Flat, dependency-free English catalog keyed by validation code. */
+export declare const validationMessagesEn: ValidationMessages;

package/dist/validation/messages/En.js

@@ -0,0 +1,118 @@
+/** Flat, dependency-free English catalog keyed by validation code. */
+export const validationMessagesEn = Object.freeze({
+    "type.object": "Must be an object.",
+    "type.array": "Must be an array.",
+    "type.tuple": "Must match the required tuple structure.",
+    "type.record": "Must be a record.",
+    "type.map": "Must be a Map.",
+    "type.set": "Must be a Set.",
+    "type.union": "Must match one of the allowed alternatives.",
+    "type.intersection": "Must satisfy all intersected validation rules.",
+    "type.lazy": "Must match the resolved validation rules.",
+    "type.validator": "Must satisfy the nested validator.",
+    "object.unknownKeys": "Contains unknown fields.",
+    "object.accessor": "Accessor properties are not supported.",
+    "validation.depth": "Maximum validation depth exceeded.",
+    "validation.nodes": "Maximum validation node count exceeded.",
+    "validation.cycle": "Circular references are not supported.",
+    "custom.invalid": "Invalid value.",
+    "array.unique": "Array items must be unique.",
+    "array.length": ({ params }) => `Array must contain exactly ${String(params.length)} items.`,
+    "array.contains": "Array must contain the required value.",
+    "array.some": "At least one array item must satisfy the condition.",
+    "array.every": "Every array item must satisfy the condition.",
+    "comparison.sameAs": "Must match the referenced field.",
+    "comparison.notSameAs": "Must differ from the referenced field.",
+    string: "Must be a string.",
+    number: "Must be a finite number.",
+    finite: "Must be a finite number.",
+    bigint: "Must be a bigint.",
+    boolean: "Must be a boolean.",
+    date: "Must be a valid Date.",
+    symbol: "Must be a symbol.",
+    literal: "Must equal the required literal value.",
+    enum: "Must be an allowed enum value.",
+    enumName: "Must be an allowed enum name.",
+    integer: "Must be an integer.",
+    safeInteger: "Must be a safe integer.",
+    int32: "Must be a signed 32-bit integer.",
+    uint32: "Must be an unsigned 32-bit integer.",
+    float32: "Must be a finite number within the 32-bit float range.",
+    int64: "Must be a signed 64-bit bigint.",
+    uint64: "Must be an unsigned 64-bit bigint.",
+    lessThan: ({ params }) => `Must be ${params.inclusive === true ? "at most" : "less than"} ${String(params.max)}.`,
+    greaterThan: ({ params }) => `Must be ${params.inclusive === true ? "at least" : "greater than"} ${String(params.min)}.`,
+    lessThanOrEqual: ({ params }) => `Must be at most ${String(params.max)}.`,
+    greaterThanOrEqual: ({ params }) => `Must be at least ${String(params.min)}.`,
+    positive: "Must be positive.",
+    negative: "Must be negative.",
+    nonNegative: "Must be non-negative.",
+    nonPositive: "Must be non-positive.",
+    min: ({ params }) => `Must be ${params.inclusive === false ? "greater than" : "at least"} ${String(params.min)}.`,
+    max: ({ params }) => `Must be ${params.inclusive === false ? "less than" : "at most"} ${String(params.max)}.`,
+    between: ({ params }) => `Must be ${params.minInclusive === false ? "greater than" : "at least"} ${String(params.min)} and ${params.maxInclusive === false ? "less than" : "at most"} ${String(params.max)}.`,
+    multipleOf: ({ params }) => `Must be a multiple of ${String(params.divisor)}.`,
+    decimal: "Must be a decimal within the allowed number of fractional places.",
+    precisionScale: "Must satisfy the required precision and scale.",
+    equal: "Must equal the expected value.",
+    notEqual: "Must differ from the disallowed value.",
+    notNull: "Must not be null.",
+    required: "This value is required.",
+    notEmpty: "Must not be empty.",
+    empty: "Must be empty.",
+    unknown: "Invalid value.",
+    never: "No value is allowed.",
+    null: "Must be null.",
+    undefined: "Must be undefined.",
+    nan: "Must be NaN.",
+    instanceOf: "Must be an instance of the required class.",
+    file: "Must be a file satisfying the size, type and extension requirements.",
+    blob: "Must be a Blob or File satisfying the configured requirements.",
+    before: "Must be before the specified date.",
+    after: "Must be after the specified date.",
+    same: "Must equal the specified date.",
+    isPast: "Must be in the past.",
+    isFuture: "Must be in the future.",
+    length: ({ params }) => `Length must be ${String(params.length)}.`,
+    minLength: ({ params }) => `Length must be at least ${String(params.minLength)}.`,
+    maxLength: ({ params }) => `Length must be at most ${String(params.maxLength)}.`,
+    matches: "Must match the required pattern.",
+    includes: "Must contain the required substring.",
+    startsWith: "Must start with the required prefix.",
+    endsWith: "Must end with the required suffix.",
+    lowercase: "Must be lowercase.",
+    uppercase: "Must be uppercase.",
+    email: "Must be a valid email address.",
+    uuid: "Must be a valid UUID.",
+    guid: "Must be a valid GUID.",
+    url: "Must be a valid absolute URL.",
+    httpUrl: "Must be a valid HTTP or HTTPS URL.",
+    hostname: "Must be a valid hostname.",
+    e164: "Must be a phone number in E.164 format.",
+    emoji: "Must contain valid emoji sequences.",
+    base64: "Must be valid Base64.",
+    base64url: "Must be valid Base64url.",
+    hex: "Must be a hexadecimal string.",
+    jwt: "Must have valid JWT syntax.",
+    nanoid: "Must be a valid Nano ID.",
+    cuid: "Must be a valid CUID.",
+    cuid2: "Must be a valid CUID2.",
+    ulid: "Must be a valid ULID.",
+    xid: "Must be a valid XID.",
+    ksuid: "Must be a valid KSUID.",
+    ip: "Must be a valid IP address.",
+    ipv4: "Must be a valid IPv4 address.",
+    ipv6: "Must be a valid IPv6 address.",
+    cidr: "Must be valid CIDR notation.",
+    cidrv4: "Must be valid IPv4 CIDR notation.",
+    cidrv6: "Must be valid IPv6 CIDR notation.",
+    mac: "Must be a valid MAC address.",
+    creditCard: "Must be a valid card number.",
+    iban: "Must be a valid IBAN.",
+    currencyCode: "Must be a supported currency code.",
+    hash: "Must be a hash in the required format.",
+    isoDate: "Must be a valid ISO date.",
+    isoTime: "Must be a valid ISO time.",
+    isoDateTime: "Must be a valid ISO date and time.",
+    isoDuration: "Must be a valid ISO duration.",
+});

package/dist/validation/messages/Ru.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationMessages } from "../Types.js";
+/** Flat, dependency-free Russian catalog keyed by validation code. */
+export declare const validationMessagesRu: ValidationMessages;