@astral/validations 4.20.3 → 4.21.0

package/node/positiveNumber/positiveNumber.d.ts

@@ -0,0 +1,25 @@
+type PositiveNumberParams = {
+    /**
+     * Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description
+ * Проверяет является ли значение положительным числом.
+ * @example
+ * ```ts
+ * const validate = number(positiveNumber(3));
+ *
+ * // undefined
+ * validate(3)
+ *
+ * // { message: 'Только положительное числа' }
+ * validate(0)
+ *
+ * // { message: 'Только положительное числа' }
+ * validate(-1)
+ * ```
+ */
+export declare const positiveNumber: <TLastSchemaValues extends Record<string, unknown>>(params?: PositiveNumberParams) => (value: number, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/node/positiveNumber/positiveNumber.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.positiveNumber = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+const isPositiveNumber = (number) => {
+    return number > 0;
+};
+/**
+ * @description
+ * Проверяет является ли значение положительным числом.
+ * @example
+ * ```ts
+ * const validate = number(positiveNumber(3));
+ *
+ * // undefined
+ * validate(3)
+ *
+ * // { message: 'Только положительное числа' }
+ * validate(0)
+ *
+ * // { message: 'Только положительное числа' }
+ * validate(-1)
+ * ```
+ */
+const positiveNumber = (params) => (0, core_1.createRule)((value, ctx) => {
+    if (!isPositiveNumber(value)) {
+        return ctx.createError({
+            message: (params === null || params === void 0 ? void 0 : params.message) || constants_1.POSITIVE_NUMBER_ERROR_INFO.message,
+            code: constants_1.POSITIVE_NUMBER_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+});
+exports.positiveNumber = positiveNumber;

package/node/rangeDate/constants.d.ts

@@ -0,0 +1,7 @@
+import { type ErrorInfo } from '../core';
+export declare const RANGE_DATE_REQUIRED_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_START_REQUIRED_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_END_REQUIRED_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_START_INVALID_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_END_INVALID_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_END_EARLIER_START_ERROR_INFO: ErrorInfo;

package/node/rangeDate/constants.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANGE_DATE_END_EARLIER_START_ERROR_INFO = exports.RANGE_DATE_END_INVALID_ERROR_INFO = exports.RANGE_DATE_START_INVALID_ERROR_INFO = exports.RANGE_DATE_END_REQUIRED_ERROR_INFO = exports.RANGE_DATE_START_REQUIRED_ERROR_INFO = exports.RANGE_DATE_REQUIRED_ERROR_INFO = void 0;
+const core_1 = require("../core");
+exports.RANGE_DATE_REQUIRED_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-required'),
+    message: 'Укажите период',
+};
+exports.RANGE_DATE_START_REQUIRED_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-startRequired'),
+    message: 'Укажите дату начала',
+};
+exports.RANGE_DATE_END_REQUIRED_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-endRequired'),
+    message: 'Укажите дату окончания',
+};
+exports.RANGE_DATE_START_INVALID_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-startInvalid'),
+    message: 'Дата начала некорректная',
+};
+exports.RANGE_DATE_END_INVALID_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-endInvalid'),
+    message: 'Дата окончания некорректная',
+};
+exports.RANGE_DATE_END_EARLIER_START_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-endEarlierStart'),
+    message: 'Дата окончания не может быть раньше даты начала',
+};

package/node/rangeDate/index.d.ts

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

package/node/rangeDate/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("./constants"), exports);
+__exportStar(require("./rangeDate"), exports);

package/node/rangeDate/rangeDate.d.ts

@@ -0,0 +1,50 @@
+import { type ValidationRule } from '../core';
+type RangeDateValue = {
+    start?: Date;
+    end?: Date;
+};
+type RangeDateParams = {
+    /**
+     * Позволяет пометить дату как необязательная
+     */
+    required?: {
+        /**
+         * Если `false` дата начала будет не обязательна
+         * @default true
+         */
+        start?: boolean;
+        /**
+         * Если `false` дата окончания будет не обязательна
+         * @default true
+         */
+        end?: boolean;
+    };
+    /**
+     * Позволяет переопределить дефолтные сообщения об ошибках
+     */
+    messages?: {
+        /**
+         * Для даты начала
+         */
+        startRequired?: string;
+        /**
+         * Для даты окончания
+         */
+        endRequired?: string;
+        /**
+         * Если дата окончания раньше даты начала
+         */
+        endEarlierStart?: string;
+    };
+};
+/**
+ * Guard для интервала дат. Проверяет даты интервала на обязательность заполнения, валидность значений и хронологический порядок
+ * @param rules - правила валидаций, применяющиеся к интервалу дат
+ * @example
+ * ```ts
+ * const validate = rangeDate();
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+export declare const rangeDate: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<RangeDateValue, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, RangeDateParams>;
+export {};

package/node/rangeDate/rangeDate.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeDate = void 0;
+const utils_1 = require("@astral/utils");
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * Guard для интервала дат. Проверяет даты интервала на обязательность заполнения, валидность значений и хронологический порядок
+ * @param rules - правила валидаций, применяющиеся к интервалу дат
+ * @example
+ * ```ts
+ * const validate = rangeDate();
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+const rangeDate = (...rules) => (0, core_1.createGuard)((externalValue, ctx, params) => {
+    const { required, messages } = Object.assign(Object.assign({}, (params || {})), { required: {
+            start: (params === null || params === void 0 ? void 0 : params.required) && 'start' in (params === null || params === void 0 ? void 0 : params.required)
+                ? params === null || params === void 0 ? void 0 : params.required.start
+                : true,
+            end: (params === null || params === void 0 ? void 0 : params.required) && 'end' in (params === null || params === void 0 ? void 0 : params.required)
+                ? params === null || params === void 0 ? void 0 : params.required.end
+                : true,
+        } });
+    // Приводим тип, чтобы не усложнять код и не дублировать часть проверок
+    // Существующие проверки покрывают все кейсы
+    // Иначе необходимо делать проверку на объект и наличие полей start и end с учетом вариативности
+    const value = externalValue;
+    if ((required === null || required === void 0 ? void 0 : required.start) && (required === null || required === void 0 ? void 0 : required.end) && !value.start && !value.end) {
+        return ctx.createError({
+            message: constants_1.RANGE_DATE_REQUIRED_ERROR_INFO.message,
+            code: constants_1.RANGE_DATE_REQUIRED_ERROR_INFO.code,
+        });
+    }
+    if ((required === null || required === void 0 ? void 0 : required.start) && !value.start) {
+        return ctx.createError({
+            message: (messages === null || messages === void 0 ? void 0 : messages.startRequired) ||
+                constants_1.RANGE_DATE_START_REQUIRED_ERROR_INFO.message,
+            code: constants_1.RANGE_DATE_START_REQUIRED_ERROR_INFO.code,
+        });
+    }
+    if ((required === null || required === void 0 ? void 0 : required.end) && !value.end) {
+        return ctx.createError({
+            message: (messages === null || messages === void 0 ? void 0 : messages.endRequired) || constants_1.RANGE_DATE_END_REQUIRED_ERROR_INFO.message,
+            code: constants_1.RANGE_DATE_END_REQUIRED_ERROR_INFO.code,
+        });
+    }
+    if ((value === null || value === void 0 ? void 0 : value.start) && !(0, utils_1.isDate)(value.start)) {
+        return ctx.createError({
+            message: constants_1.RANGE_DATE_START_INVALID_ERROR_INFO.message,
+            code: constants_1.RANGE_DATE_START_INVALID_ERROR_INFO.code,
+        });
+    }
+    if ((value === null || value === void 0 ? void 0 : value.end) && !(0, utils_1.isDate)(value.end)) {
+        return ctx.createError({
+            message: constants_1.RANGE_DATE_END_INVALID_ERROR_INFO.message,
+            code: constants_1.RANGE_DATE_END_INVALID_ERROR_INFO.code,
+        });
+    }
+    if (value.end && value.start && (0, core_1.isDateEarlier)(value.end, value.start)) {
+        return ctx.createError({
+            message: (messages === null || messages === void 0 ? void 0 : messages.endEarlierStart) ||
+                constants_1.RANGE_DATE_END_EARLIER_START_ERROR_INFO.message,
+            code: constants_1.RANGE_DATE_END_EARLIER_START_ERROR_INFO.code,
+        });
+    }
+    return (0, core_1.compose)(...rules)(value, ctx);
+});
+exports.rangeDate = rangeDate;

package/node/rangeDateInterval/constants.d.ts

@@ -0,0 +1,7 @@
+import { type ErrorInfo } from '../core';
+import type { DefaultMessage } from './types';
+type DynamicErrorInfo = Pick<ErrorInfo, 'code'> & {
+    message: DefaultMessage;
+};
+export declare const RANGE_DATE_INTERVAL_ERROR_INFO: DynamicErrorInfo;
+export {};

package/node/rangeDateInterval/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANGE_DATE_INTERVAL_ERROR_INFO = void 0;
+const utils_1 = require("@astral/utils");
+const core_1 = require("../core");
+const selectDeclensionUnitStrategy = (unit) => {
+    const strategy = {
+        day: utils_1.declensionDay,
+        month: utils_1.declensionMonth,
+        year: utils_1.declensionYear,
+    };
+    return strategy[unit];
+};
+exports.RANGE_DATE_INTERVAL_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-interval'),
+    message: (limit, unit) => `Период не может превышать ${limit} ${selectDeclensionUnitStrategy(unit)(limit)}`,
+};

package/node/rangeDateInterval/index.d.ts

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

package/node/rangeDateInterval/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("./constants"), exports);
+__exportStar(require("./rangeDateInterval"), exports);

package/node/rangeDateInterval/rangeDateInterval.d.ts

@@ -0,0 +1,23 @@
+import type { DateUnit, RangeDateValue } from './types';
+type RangeDateIntervalParams = {
+    limit: number;
+    /**
+     * Еденицы измерения лимита
+     * @default 'day'
+     */
+    unit?: DateUnit;
+    /**
+     * Замена стандартного сообщения об ошибки
+     */
+    message?: string;
+};
+/**
+ * Позволяет ограничить интервал на конкретное значение. Установка интревала возможна в следующих единицах: день, месяц и год.
+ * @example
+ * ```ts
+ * const validate = rangeDate(rangeDateInterval({ limit: 14 }));
+ * validate({ start: new Date('2024.08.15'), end: new Date('2024.09.05') });
+ * ```
+ */
+export declare const rangeDateInterval: <TLastSchemaValues extends Record<string, unknown>>(params: RangeDateIntervalParams) => (value: RangeDateValue, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/node/rangeDateInterval/rangeDateInterval.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeDateInterval = void 0;
+const utils_1 = require("@astral/utils");
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+const selectAddingStrategy = (unit) => {
+    const strategy = {
+        day: utils_1.addDays,
+        month: utils_1.addMonths,
+        year: utils_1.addYears,
+    };
+    return strategy[unit];
+};
+/**
+ * Позволяет ограничить интервал на конкретное значение. Установка интревала возможна в следующих единицах: день, месяц и год.
+ * @example
+ * ```ts
+ * const validate = rangeDate(rangeDateInterval({ limit: 14 }));
+ * validate({ start: new Date('2024.08.15'), end: new Date('2024.09.05') });
+ * ```
+ */
+const rangeDateInterval = (params) => (0, core_1.createRule)((value, ctx) => {
+    const { limit, unit = 'day', message } = params;
+    if (!value.start || !value.end) {
+        return undefined;
+    }
+    if (!(0, utils_1.isDate)(value.start) || !(0, utils_1.isDate)(value.end)) {
+        return undefined;
+    }
+    const addLimits = selectAddingStrategy(unit);
+    if (!(0, core_1.isDateEarlier)(value.end, addLimits(value.start, limit))) {
+        return ctx.createError({
+            message: message || constants_1.RANGE_DATE_INTERVAL_ERROR_INFO.message(limit, unit),
+            code: constants_1.RANGE_DATE_INTERVAL_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+});
+exports.rangeDateInterval = rangeDateInterval;

package/node/rangeDateInterval/types.d.ts

@@ -0,0 +1,6 @@
+export type RangeDateValue = {
+    start?: Date;
+    end?: Date;
+};
+export type DateUnit = 'day' | 'month' | 'year';
+export type DefaultMessage = (limit: number, unit: DateUnit) => string;

package/node/rangeDateInterval/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node/rangeDateMinMax/constants.d.ts

@@ -0,0 +1,8 @@
+import { type ErrorInfo } from '../core';
+import type { DefaultMessage } from './types';
+type DynamicErrorInfo = Pick<ErrorInfo, 'code'> & {
+    message: DefaultMessage;
+};
+export declare const RANGE_DATE_MIN_ERROR_INFO: DynamicErrorInfo;
+export declare const RANGE_DATE_MAX_ERROR_INFO: DynamicErrorInfo;
+export {};

package/node/rangeDateMinMax/constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANGE_DATE_MAX_ERROR_INFO = exports.RANGE_DATE_MIN_ERROR_INFO = void 0;
+const core_1 = require("../core");
+const DEFAULT_FIELD_NAME = {
+    start: 'начала',
+    end: 'окончания',
+};
+exports.RANGE_DATE_MIN_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-min'),
+    message: (field, minDate) => `Дата ${DEFAULT_FIELD_NAME[field]} должна быть позже ${minDate}`,
+};
+exports.RANGE_DATE_MAX_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-max'),
+    message: (field, maxDate) => `Дата ${DEFAULT_FIELD_NAME[field]} должна быть раньше ${maxDate}`,
+};

package/node/rangeDateMinMax/index.d.ts

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

package/node/rangeDateMinMax/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("./constants"), exports);
+__exportStar(require("./rangeDateMinMax"), exports);

package/node/rangeDateMinMax/rangeDateMinMax.d.ts

@@ -0,0 +1,34 @@
+type RangeDateValue = {
+    start?: Date;
+    end?: Date;
+};
+type LimitOptions = {
+    /**
+     * Дата
+     */
+    limit: Date;
+    /**
+     * Замена стандартного сообщения ошибки
+     */
+    message?: (field: 'start' | 'end', date: string) => string;
+};
+type RangeDateMinMaxParams = {
+    start?: {
+        min?: LimitOptions;
+        max?: LimitOptions;
+    };
+    end?: {
+        min?: LimitOptions;
+        max?: LimitOptions;
+    };
+};
+/**
+ * Проверяет даты на минимальное и максимальное допустимое значение
+ * @example
+ * ```ts
+ * const validate = rangeDate(rangeDateMinMax({ start: { min: { limit: new Date(2023, 0, 1) }}, end: { max: { limit: new Date() } } }));
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+export declare const rangeDateMinMax: <TLastSchemaValues extends Record<string, unknown>>(params?: RangeDateMinMaxParams) => (value: RangeDateValue, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/node/rangeDateMinMax/rangeDateMinMax.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeDateMinMax = void 0;
+const utils_1 = require("@astral/utils");
+const core_1 = require("../core");
+const rangeDate_1 = require("../rangeDate");
+const constants_1 = require("./constants");
+const formatDateToView = (date) => {
+    return new Intl.DateTimeFormat('ru-RU').format(date);
+};
+/**
+ * Проверяет даты на минимальное и максимальное допустимое значение
+ * @example
+ * ```ts
+ * const validate = rangeDate(rangeDateMinMax({ start: { min: { limit: new Date(2023, 0, 1) }}, end: { max: { limit: new Date() } } }));
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+const rangeDateMinMax = (params) => (0, core_1.createRule)((value, ctx) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+    if (!value.start && !value.end) {
+        return undefined;
+    }
+    if ((value === null || value === void 0 ? void 0 : value.start) && !(0, utils_1.isDate)(value.start)) {
+        return ctx.createError({
+            message: rangeDate_1.RANGE_DATE_START_INVALID_ERROR_INFO.message,
+            code: rangeDate_1.RANGE_DATE_START_INVALID_ERROR_INFO.code,
+        });
+    }
+    if ((value === null || value === void 0 ? void 0 : value.end) && !(0, utils_1.isDate)(value.end)) {
+        return ctx.createError({
+            message: rangeDate_1.RANGE_DATE_END_INVALID_ERROR_INFO.message,
+            code: rangeDate_1.RANGE_DATE_END_INVALID_ERROR_INFO.code,
+        });
+    }
+    // Если дата начала раньше заданной минимальной
+    if (((_b = (_a = params === null || params === void 0 ? void 0 : params.start) === null || _a === void 0 ? void 0 : _a.min) === null || _b === void 0 ? void 0 : _b.limit) &&
+        value.start &&
+        (0, core_1.isDateEarlier)(value.start, (_c = params === null || params === void 0 ? void 0 : params.start.min) === null || _c === void 0 ? void 0 : _c.limit)) {
+        return ctx.createError({
+            message: ((_e = (_d = params.start.min).message) === null || _e === void 0 ? void 0 : _e.call(_d, 'start', formatDateToView(params.start.min.limit))) ||
+                constants_1.RANGE_DATE_MIN_ERROR_INFO.message('start', formatDateToView(params.start.min.limit)),
+            code: constants_1.RANGE_DATE_MIN_ERROR_INFO.code,
+        });
+    }
+    // Если дата начала позже заданной максимальной
+    if (((_g = (_f = params === null || params === void 0 ? void 0 : params.start) === null || _f === void 0 ? void 0 : _f.max) === null || _g === void 0 ? void 0 : _g.limit) &&
+        value.start &&
+        (0, core_1.isDateEarlier)((_h = params === null || params === void 0 ? void 0 : params.start.max) === null || _h === void 0 ? void 0 : _h.limit, value.start)) {
+        return ctx.createError({
+            message: ((_k = (_j = params.start.max).message) === null || _k === void 0 ? void 0 : _k.call(_j, 'start', formatDateToView(params.start.max.limit))) ||
+                constants_1.RANGE_DATE_MAX_ERROR_INFO.message('start', formatDateToView(params.start.max.limit)),
+            code: constants_1.RANGE_DATE_MAX_ERROR_INFO.code,
+        });
+    }
+    // Если дата окончания раньше заданной минимальной
+    if (((_m = (_l = params === null || params === void 0 ? void 0 : params.end) === null || _l === void 0 ? void 0 : _l.min) === null || _m === void 0 ? void 0 : _m.limit) &&
+        value.end &&
+        (0, core_1.isDateEarlier)(value.end, (_o = params === null || params === void 0 ? void 0 : params.end.min) === null || _o === void 0 ? void 0 : _o.limit)) {
+        return ctx.createError({
+            message: ((_q = (_p = params.end.min).message) === null || _q === void 0 ? void 0 : _q.call(_p, 'start', formatDateToView(params.end.min.limit))) ||
+                constants_1.RANGE_DATE_MIN_ERROR_INFO.message('end', formatDateToView(params.end.min.limit)),
+            code: constants_1.RANGE_DATE_MIN_ERROR_INFO.code,
+        });
+    }
+    // Если дата окончания позже заданной максимально
+    if (((_s = (_r = params === null || params === void 0 ? void 0 : params.end) === null || _r === void 0 ? void 0 : _r.max) === null || _s === void 0 ? void 0 : _s.limit) &&
+        value.end &&
+        (0, core_1.isDateEarlier)((_t = params === null || params === void 0 ? void 0 : params.end.max) === null || _t === void 0 ? void 0 : _t.limit, value.end)) {
+        return ctx.createError({
+            message: ((_v = (_u = params.end.max).message) === null || _v === void 0 ? void 0 : _v.call(_u, 'start', formatDateToView(params.end.max.limit))) ||
+                constants_1.RANGE_DATE_MAX_ERROR_INFO.message('end', formatDateToView(params.end.max.limit)),
+            code: constants_1.RANGE_DATE_MAX_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+});
+exports.rangeDateMinMax = rangeDateMinMax;

package/node/rangeDateMinMax/types.d.ts

@@ -0,0 +1,2 @@
+export type Field = 'start' | 'end';
+export type DefaultMessage = (field: Field, date: string) => string;

package/node/rangeDateMinMax/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node/rangeDateNotEqual/constants.d.ts

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

package/node/rangeDateNotEqual/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANGE_DATE_NOT_EQUAL_ERROR_INFO = void 0;
+const core_1 = require("../core");
+exports.RANGE_DATE_NOT_EQUAL_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('rangedate-notequal'),
+    message: 'Даты начала и окончания не могут совпадать',
+};

package/node/rangeDateNotEqual/index.d.ts

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

package/node/rangeDateNotEqual/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("./constants"), exports);
+__exportStar(require("./rangeDateNotEqual"), exports);

package/node/rangeDateNotEqual/rangeDateNotEqual.d.ts

@@ -0,0 +1,20 @@
+type RangeDateValue = {
+    start?: Date;
+    end?: Date;
+};
+type RangeDateNotEqualParams = {
+    /**
+     * Замена стандартного сообщения ошибки
+     */
+    message?: string;
+};
+/**
+ * Проверяет даты интервала на совпадение даты начала и окончания
+ * @example
+ * ```ts
+ * const validate = rangeDate(rangeDateNotEqual());
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+export declare const rangeDateNotEqual: <TLastSchemaValues extends Record<string, unknown>>(params?: RangeDateNotEqualParams) => (value: RangeDateValue, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/node/rangeDateNotEqual/rangeDateNotEqual.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeDateNotEqual = void 0;
+const utils_1 = require("@astral/utils");
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+const isDateEqual = (dateA, dateB) => {
+    return (0, core_1.resetTime)(dateA).getTime() === (0, core_1.resetTime)(dateB).getTime();
+};
+/**
+ * Проверяет даты интервала на совпадение даты начала и окончания
+ * @example
+ * ```ts
+ * const validate = rangeDate(rangeDateNotEqual());
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+const rangeDateNotEqual = (params) => (0, core_1.createRule)((value, ctx) => {
+    if (!value.start || !value.end) {
+        return undefined;
+    }
+    if (!(0, utils_1.isDate)(value.start) || !(0, utils_1.isDate)(value.end)) {
+        return undefined;
+    }
+    if (isDateEqual(value.start, value.end)) {
+        return ctx.createError({
+            message: (params === null || params === void 0 ? void 0 : params.message) || constants_1.RANGE_DATE_NOT_EQUAL_ERROR_INFO.message,
+            code: constants_1.RANGE_DATE_NOT_EQUAL_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+});
+exports.rangeDateNotEqual = rangeDateNotEqual;

package/node/snils/constants.d.ts

@@ -0,0 +1,4 @@
+import { type ErrorInfo } from '../core';
+export declare const SNILS_ERROR_INFO: ErrorInfo;
+export declare const RESTRICTED_VALUES: string[];
+export declare const DEFAULT_CHECKED_SUM: number[];