@astral/validations 4.20.3 → 4.20.4

package/node/min/min.d.ts

@@ -0,0 +1,26 @@
+import { type ValidationContext, createRule } from '../core';
+type BaseMinValidationTypes = number | string | Array<unknown>;
+type CommonThreshold = number | Date;
+type MinParams<ValidationType> = {
+    /**
+     * Сообщение ошибки
+     */
+    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext) => string;
+};
+/**
+ * Проверяет значение на соответствие минимуму. Работает с: string, array, Date, number
+ * @param threshold - нижний доступный порог value
+ * @example
+ * ```ts
+ *  string(min(22));
+ *
+ *  number(min(22));
+ *
+ *  array(min(2)));
+ *
+ *  date(min(new Date())));
+ * ```
+ */
+export declare function min<ValidationType extends Date, TLastSchemaValues extends Record<string, unknown> = {}>(threshold: Date, params?: MinParams<ValidationType>): ReturnType<typeof createRule<Date, TLastSchemaValues>>;
+export declare function min<ValidationType extends BaseMinValidationTypes, TLastSchemaValues extends Record<string, unknown> = {}>(threshold: number, params?: MinParams<ValidationType>): ReturnType<typeof createRule<BaseMinValidationTypes, TLastSchemaValues>>;
+export {};

package/node/min/min.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.min = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+function min(threshold, params) {
+    return (0, core_1.createRule)((value, ctx) => {
+        const getMessage = (typeMessage) => (params === null || params === void 0 ? void 0 : params.getMessage)
+            ? params.getMessage(threshold, value, ctx)
+            : typeMessage;
+        if (value instanceof Date && threshold instanceof Date) {
+            return (0, core_1.resetTime)(value) >= (0, core_1.resetTime)(threshold)
+                ? undefined
+                : ctx.createError({
+                    code: constants_1.DATE_MIN_ERROR_CODE,
+                    message: getMessage(`Не раньше ${threshold.toLocaleDateString('ru')}`),
+                });
+        }
+        if (threshold instanceof Date) {
+            return undefined;
+        }
+        if (typeof value === 'string') {
+            const isError = value.trim().length < threshold;
+            return isError
+                ? ctx.createError({
+                    code: constants_1.STRING_MIN_ERROR_CODE,
+                    message: getMessage(`Мин. символов: ${threshold}`),
+                })
+                : undefined;
+        }
+        if (Array.isArray(value) && value.length < threshold) {
+            return ctx.createError({
+                code: constants_1.ARRAY_MIN_ERROR_CODE,
+                message: getMessage(`Не меньше ${threshold}`),
+            });
+        }
+        if (typeof value === 'number' && value < threshold) {
+            return ctx.createError({
+                code: constants_1.NUMBER_MIN_ERROR_CODE,
+                message: getMessage(`Не меньше ${threshold}`),
+            });
+        }
+        return undefined;
+    });
+}
+exports.min = min;

package/node/minYearsOld/constants.d.ts

@@ -0,0 +1,4 @@
+import { type ErrorCode } from '../core';
+export declare const BIRTH_DATE_MAX_ERROR_CODE: ErrorCode;
+export declare const BIRTH_DATE_MIN_ERROR_CODE: ErrorCode;
+export declare const BIRTH_DATE_MIN: Date;

package/node/minYearsOld/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BIRTH_DATE_MIN = exports.BIRTH_DATE_MIN_ERROR_CODE = exports.BIRTH_DATE_MAX_ERROR_CODE = void 0;
+const core_1 = require("../core");
+exports.BIRTH_DATE_MAX_ERROR_CODE = (0, core_1.createErrorCode)('birth-date-max');
+exports.BIRTH_DATE_MIN_ERROR_CODE = (0, core_1.createErrorCode)('birth-date-min');
+exports.BIRTH_DATE_MIN = new Date('01.01.1900');

package/node/minYearsOld/index.d.ts

@@ -0,0 +1,2 @@
+export * from './minYearsOld';
+export * from './constants';

package/node/minYearsOld/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./minYearsOld"), exports);
+__exportStar(require("./constants"), exports);

package/node/minYearsOld/minYearsOld.d.ts

@@ -0,0 +1,24 @@
+type MinYearsOldParams = {
+    /**
+     * Кастомное сообщение ошибки
+     */
+    customErrorMessage: string;
+};
+/**
+ * Проверяет дату рождения на соответствие условию. Работает с date.
+ * @param age - ограничение по возрасту (коло-во лет, вычитаемое из текущей даты для валидации)
+ * @param params - объект параметров
+ * @example
+ * ```ts
+
+ *
+ *  const validate = date(
+ *   minYearsOld(18, {
+ *     customMessage:
+ *             'Только совершеннолетние могут воспользоваться данной услугой',
+ *   }),
+ * );
+ * ```
+ */
+export declare function minYearsOld<ValidationType, TLastSchemaValues extends Record<string, unknown> = {}>(age: number, params?: MinYearsOldParams): (value: ValidationType, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/node/minYearsOld/minYearsOld.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minYearsOld = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * Проверяет дату рождения на соответствие условию. Работает с date.
+ * @param age - ограничение по возрасту (коло-во лет, вычитаемое из текущей даты для валидации)
+ * @param params - объект параметров
+ * @example
+ * ```ts
+
+ *
+ *  const validate = date(
+ *   minYearsOld(18, {
+ *     customMessage:
+ *             'Только совершеннолетние могут воспользоваться данной услугой',
+ *   }),
+ * );
+ * ```
+ */
+function minYearsOld(age, params) {
+    return (0, core_1.createRule)((value, ctx) => {
+        const getMessage = (typeMessage) => {
+            const message = params === null || params === void 0 ? void 0 : params.customErrorMessage;
+            return message ? message : typeMessage;
+        };
+        const threshold = new Date();
+        threshold.setFullYear(threshold.getFullYear() - age);
+        if (value instanceof Date && value > constants_1.BIRTH_DATE_MIN) {
+            if (value > threshold) {
+                return ctx.createError({
+                    code: constants_1.BIRTH_DATE_MAX_ERROR_CODE,
+                    message: getMessage(`Вам должно быть больше ${age} лет`),
+                });
+            }
+            return undefined;
+        }
+        if (value < constants_1.BIRTH_DATE_MIN) {
+            return ctx.createError({
+                code: constants_1.BIRTH_DATE_MIN_ERROR_CODE,
+                message: getMessage(`Не ранее ${constants_1.BIRTH_DATE_MIN}`),
+            });
+        }
+        return undefined;
+    });
+}
+exports.minYearsOld = minYearsOld;

package/node/mobilePhone/constants.d.ts

@@ -0,0 +1,3 @@
+import { type ErrorInfo } from '../core';
+export declare const MOBILE_PHONE_ERROR_INFO: ErrorInfo;
+export declare const MOBILE_PHONE_REGEX: RegExp;

package/node/mobilePhone/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOBILE_PHONE_REGEX = exports.MOBILE_PHONE_ERROR_INFO = void 0;
+const core_1 = require("../core");
+exports.MOBILE_PHONE_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('mobilePhone'),
+    message: 'Некорректный номер телефона',
+};
+exports.MOBILE_PHONE_REGEX = /^(79)\d{9}$/;

package/node/mobilePhone/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mobilePhone';
+export * from './constants';

package/node/mobilePhone/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mobilePhone"), exports);
+__exportStar(require("./constants"), exports);

package/node/mobilePhone/mobilePhone.d.ts

@@ -0,0 +1,19 @@
+import { type CommonRuleParams } from '../core';
+type MobilePhoneParams = CommonRuleParams<string> & {
+    /**
+     * Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description
+ * Проверяет валиден ли мобильный телефон.
+ * Валидный телефон начинается с "79" и не содержит символов, кроме цифр.
+ * @example
+ * ```ts
+ * const validate = string(mobilePhone());
+ * validate('79999999999');
+ * ```
+ */
+export declare const mobilePhone: <TLastSchemaValues extends Record<string, unknown>>(params?: MobilePhoneParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/node/mobilePhone/mobilePhone.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mobilePhone = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * @description
+ * Проверяет валиден ли мобильный телефон.
+ * Валидный телефон начинается с "79" и не содержит символов, кроме цифр.
+ * @example
+ * ```ts
+ * const validate = string(mobilePhone());
+ * validate('79999999999');
+ * ```
+ */
+const mobilePhone = (params) => (0, core_1.createRule)((value, ctx) => {
+    if (!constants_1.MOBILE_PHONE_REGEX.test(value)) {
+        return ctx.createError({
+            message: (params === null || params === void 0 ? void 0 : params.message) || constants_1.MOBILE_PHONE_ERROR_INFO.message,
+            code: constants_1.MOBILE_PHONE_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });
+exports.mobilePhone = mobilePhone;

package/node/number/constants.d.ts

@@ -0,0 +1,4 @@
+import { type ErrorInfo } from '../core';
+export declare const NUMBER_TYPE_ERROR_INFO: ErrorInfo;
+export declare const NAN_NUMBER_ERROR_INFO: ErrorInfo;
+export declare const INFINITY_NUMBER_ERROR_INFO: ErrorInfo;

package/node/number/constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INFINITY_NUMBER_ERROR_INFO = exports.NAN_NUMBER_ERROR_INFO = exports.NUMBER_TYPE_ERROR_INFO = void 0;
+const core_1 = require("../core");
+exports.NUMBER_TYPE_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('number-type'),
+    message: 'Не число',
+};
+exports.NAN_NUMBER_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('number-nan'),
+    message: 'Некорректное число',
+};
+exports.INFINITY_NUMBER_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('number-infinity'),
+    message: 'Бесконечное число',
+};

package/node/number/index.d.ts

@@ -0,0 +1,2 @@
+export * from './number';
+export * from './constants';

package/node/number/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./number"), exports);
+__exportStar(require("./constants"), exports);

package/node/number/number.d.ts

@@ -0,0 +1,19 @@
+import { type ValidationRule } from '../core';
+type AdditionalDefOptions = {
+    nanErrorMessage?: string;
+    infinityErrorMessage?: string;
+};
+/**
+ * Guard для number. Проверяет значение на тип number и NaN, Infinity
+ * Для NaN и Infinity возвращаются отдельные ошибки
+ * @param rules - правила, валидирующие number или unknown value
+ * @example
+ * ```ts
+ *  const validate = number(min(22));
+ *
+ *  // undefined
+ *  validate(24);
+ * ```
+ */
+export declare const number: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<number, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, AdditionalDefOptions>;
+export {};

package/node/number/number.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.number = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * Guard для number. Проверяет значение на тип number и NaN, Infinity
+ * Для NaN и Infinity возвращаются отдельные ошибки
+ * @param rules - правила, валидирующие number или unknown value
+ * @example
+ * ```ts
+ *  const validate = number(min(22));
+ *
+ *  // undefined
+ *  validate(24);
+ * ```
+ */
+const number = (...rules) => (0, core_1.createGuard)((value, ctx, { typeErrorMessage, nanErrorMessage, infinityErrorMessage }) => {
+    if (typeof value !== 'number') {
+        return ctx.createError(Object.assign(Object.assign({}, constants_1.NUMBER_TYPE_ERROR_INFO), { message: typeErrorMessage || constants_1.NUMBER_TYPE_ERROR_INFO.message }));
+    }
+    if (Number.isNaN(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, constants_1.NAN_NUMBER_ERROR_INFO), { message: nanErrorMessage || constants_1.NAN_NUMBER_ERROR_INFO.message }));
+    }
+    if (!Number.isFinite(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, constants_1.INFINITY_NUMBER_ERROR_INFO), { message: infinityErrorMessage || constants_1.INFINITY_NUMBER_ERROR_INFO.message }));
+    }
+    return (0, core_1.compose)(...rules)(value, ctx);
+});
+exports.number = number;

package/node/object/constants.d.ts

@@ -0,0 +1,2 @@
+import { type ErrorInfo } from '../core';
+export declare const OBJECT_TYPE_ERROR_INFO: ErrorInfo;

package/node/object/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBJECT_TYPE_ERROR_INFO = void 0;
+const core_1 = require("../core");
+exports.OBJECT_TYPE_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('object'),
+    message: 'Не является объектом',
+};

package/node/object/index.d.ts

@@ -0,0 +1,3 @@
+export * from './object';
+export * from './constants';
+export * from './objectAsync';

package/node/object/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./object"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./objectAsync"), exports);

package/node/object/isEmptyErrors/index.d.ts

@@ -0,0 +1 @@
+export * from './isEmptyErrors';

package/node/object/isEmptyErrors/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./isEmptyErrors"), exports);

package/node/object/isEmptyErrors/isEmptyErrors.d.ts

@@ -0,0 +1,5 @@
+import { type ErrorMap } from '../../core';
+/**
+ * Проверяет есть ли errorMap ошибки
+ */
+export declare const isEmptyErrors: (errorMap: ErrorMap) => boolean;

package/node/object/isEmptyErrors/isEmptyErrors.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmptyErrors = void 0;
+/**
+ * Проверяет есть ли errorMap ошибки
+ */
+const isEmptyErrors = (errorMap) => Object.values(errorMap).every((error) => error === undefined);
+exports.isEmptyErrors = isEmptyErrors;

package/node/object/object.d.ts

@@ -0,0 +1,49 @@
+import { type Guard, type ValidationContext, type ValidationRule } from '../core';
+/**
+ * Специальный итерфейс Guard для object. В данном интерфейсе ctx required
+ * Переопределение необходимо для того, чтобы ts показывал, что ctx required в кастомных правилах
+ */
+interface ObjectPropGuard<TLastSchemaValues extends Record<string, unknown>> {
+    (value: Parameters<Guard<TLastSchemaValues>>[0], ctx: ValidationContext<TLastSchemaValues>): ReturnType<Guard<TLastSchemaValues>>;
+    define: Guard<TLastSchemaValues>['define'];
+}
+type AdditionalDefOptions = {
+    /**
+     * Делает все свойства объекта partial
+     */
+    isPartial?: boolean;
+};
+/**
+ * Возможные значения, принимаемые схемой
+ */
+export type SchemaValue<TValue extends Record<string, unknown>> = ObjectPropGuard<TValue> | ValidationRule<unknown, TValue>;
+/**
+ * Схема правил валдиации для объекта
+ */
+export type Schema<TValue extends Record<string, unknown>> = Record<keyof TValue, SchemaValue<TValue>>;
+/**
+ * Guard для объекта
+ * @param schema - схема валидации объекта
+ * @example
+ * ```ts
+ * type Values = {
+ *   name: string;
+ *   age?: number;
+ *   info: { surname: string };
+ * };
+ *
+ * const values: Values = { name: 'Vasya', info: { surname: 'Vasin' } };
+ *
+ * const validateObject = object<Values>({
+ *   name: string(min(2)),
+ *   age: optional(number()),
+ *   info: object<Values['info']>({ surname: string(min(2)) }),
+ *   customField: (value, ctx) => {
+ *     return ctx.createError({ message: 'error', code: 'custom error' })
+ *   }
+ * });
+ * ```
+ */
+export declare const object: <TValue extends Record<string, unknown>, TLastSchemaValues extends Record<string, unknown> = {}>(schema: Schema<TValue>) => Guard<TLastSchemaValues, AdditionalDefOptions>;
+export type ObjectGuard<TValue extends Record<string, unknown>> = ReturnType<typeof object<TValue>>;
+export {};

package/node/object/object.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.object = void 0;
+const is_plain_obj_1 = __importDefault(require("is-plain-obj"));
+const core_1 = require("../core");
+const optional_1 = require("../optional");
+const isEmptyErrors_1 = require("./isEmptyErrors");
+const constants_1 = require("./constants");
+/**
+ * Guard для объекта
+ * @param schema - схема валидации объекта
+ * @example
+ * ```ts
+ * type Values = {
+ *   name: string;
+ *   age?: number;
+ *   info: { surname: string };
+ * };
+ *
+ * const values: Values = { name: 'Vasya', info: { surname: 'Vasin' } };
+ *
+ * const validateObject = object<Values>({
+ *   name: string(min(2)),
+ *   age: optional(number()),
+ *   info: object<Values['info']>({ surname: string(min(2)) }),
+ *   customField: (value, ctx) => {
+ *     return ctx.createError({ message: 'error', code: 'custom error' })
+ *   }
+ * });
+ * ```
+ */
+const object = (schema) => (0, core_1.createGuard)((value, ctx, { typeErrorMessage, isPartial }) => {
+    const context = (0, core_1.createContext)(ctx, value, {
+        lastSchemaValue: value,
+    });
+    if (!(0, is_plain_obj_1.default)(value)) {
+        return context.createError(Object.assign(Object.assign({}, constants_1.OBJECT_TYPE_ERROR_INFO), { message: typeErrorMessage || constants_1.OBJECT_TYPE_ERROR_INFO.message }));
+    }
+    const generateErrorMap = () => {
+        const schemaEntries = Object.entries(schema);
+        const isOptional = context.global.overrides.objectIsPartial || isPartial;
+        return schemaEntries.reduce((errorMap, [key, rule]) => {
+            const callRule = isOptional ? (0, optional_1.optional)(rule) : rule;
+            errorMap[key] = (0, core_1.callRule)(callRule, value[key], context);
+            return errorMap;
+        }, {});
+    };
+    const errorMap = generateErrorMap();
+    if (!(0, isEmptyErrors_1.isEmptyErrors)(errorMap)) {
+        return (0, core_1.createErrorMap)(errorMap);
+    }
+    return undefined;
+});
+exports.object = object;

package/node/object/objectAsync/index.d.ts

@@ -0,0 +1 @@
+export * from './objectAsync';

package/node/object/objectAsync/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./objectAsync"), exports);

package/node/object/objectAsync/objectAsync.d.ts

@@ -0,0 +1,61 @@
+import { type AsyncGuard, type AsyncValidationRule, type Guard, type ValidationContext, type ValidationRule } from '../../core';
+/**
+ * Специальный итерфейс Guard для object. В данном интерфейсе ctx required
+ * Переопределение необходимо для того, чтобы ts показывал, что ctx required в кастомных правилах
+ */
+interface ObjectPropGuard<TLastSchemaValues extends Record<string, unknown>> {
+    (value: Parameters<Guard<TLastSchemaValues>>[0], ctx: ValidationContext<TLastSchemaValues>): ReturnType<Guard<TLastSchemaValues>>;
+    define: Guard<TLastSchemaValues>['define'];
+}
+interface AsyncObjectPropGuard<TLastSchemaValues extends Record<string, unknown>> {
+    (value: Parameters<Guard<TLastSchemaValues>>[0], ctx: ValidationContext<TLastSchemaValues>): ReturnType<AsyncGuard<TLastSchemaValues>>;
+    define: AsyncGuard<TLastSchemaValues>['define'];
+}
+type AdditionalDefOptions = {
+    /**
+     * Делает все свойства объекта partial
+     */
+    isPartial?: boolean;
+};
+/**
+ * Возможные значения, принимаемые схемой
+ */
+export type AsyncSchemaValue<TValue extends Record<string, unknown>> = ObjectPropGuard<TValue> | AsyncObjectPropGuard<TValue> | ValidationRule<unknown, TValue> | AsyncValidationRule<unknown, TValue>;
+/**
+ * Схема правил валдиации для объекта
+ */
+export type AsyncSchema<TValue extends Record<string, unknown>> = Record<keyof TValue, AsyncSchemaValue<TValue>>;
+/**
+ * Guard для объекта, который поддерживает асинхронную валидацию
+ * @example
+ * ```ts
+ * type Values = {
+ *   name: string;
+ *   age?: number;
+ *   info: { surname: string };
+ * };
+ *
+ * const values: Values = { name: 'Vasya', info: { surname: 'Vasin' } };
+ *
+ * const validateObject = objectAsync<Values>({
+ *   name: string(min(2), async (value, ctx) => {
+ *     const result = await validateName(value);
+ *
+ *     return result.isInvalid
+ *       ? ctx.createError({
+ *           message: 'Имя занято',
+ *           code: 'name-is-not-available',
+ *         })
+ *       : undefined;
+ *   }),
+ *   age: optional(number()),
+ *   info: object<Values['info']>({ surname: string(min(2)) }),
+ *   customField: (value, ctx) => {
+ *     return ctx.createError({ message: 'error', code: 'custom error' });
+ *   },
+ * });
+ * ```
+ */
+export declare const objectAsync: <TValue extends Record<string, unknown>, TLastSchemaValues extends Record<string, unknown> = {}>(schema: AsyncSchema<TValue>) => AsyncGuard<TLastSchemaValues, AdditionalDefOptions>;
+export type ObjectAsyncGuard<TValue extends Record<string, unknown>> = ReturnType<typeof objectAsync<TValue>>;
+export {};