@astral/validations 3.3.0 → 4.1.0

package/integer/integer.d.ts

@@ -21,5 +21,5 @@ type IntegerParams = {
  * validate(3.14)
  * ```
  */
-export declare const integer: <TValues>(params?: IntegerParams) => (value: number, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const integer: <TLastSchemaValues extends Record<string, unknown>>(params?: IntegerParams) => (value: number, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/kpp/kpp.d.ts

@@ -13,5 +13,5 @@ type KPPParams = CommonRuleParams<string> & {
  * validate('770201001');
  * ```
  */
-export declare const kpp: <TValues>(params?: KPPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const kpp: <TLastSchemaValues extends Record<string, unknown>>(params?: KPPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/max/max.d.ts

@@ -5,7 +5,7 @@ type MaxParams<ValidationType> = {
     /**
      * @description Сообщение ошибки
      */
-    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext<unknown>) => string;
+    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext) => string;
 };
 /**
  * @description Проверяет значение на соответствие максимуму. Работает с: string, array, Date, number
@@ -21,6 +21,6 @@ type MaxParams<ValidationType> = {
  *  date(max(new Date())));
  * ```
  */
-export declare function max<ValidationType extends Date>(threshold: Date, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<Date, unknown>>;
-export declare function max<ValidationType extends BaseMaxValidationTypes>(threshold: number, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<BaseMaxValidationTypes, unknown>>;
+export declare function max<ValidationType extends Date>(threshold: Date, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<Date>>;
+export declare function max<ValidationType extends BaseMaxValidationTypes>(threshold: number, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<BaseMaxValidationTypes>>;
 export {};

package/min/min.d.ts

@@ -5,7 +5,7 @@ type MinParams<ValidationType> = {
     /**
      * @description Сообщение ошибки
      */
-    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext<unknown>) => string;
+    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext) => string;
 };
 /**
  * @description Проверяет значение на соответствие минимуму. Работает с: string, array, Date, number
@@ -21,6 +21,6 @@ type MinParams<ValidationType> = {
  *  date(min(new Date())));
  * ```
  */
-export declare function min<ValidationType extends Date>(threshold: Date, params?: MinParams<ValidationType>): ReturnType<typeof createRule<Date, unknown>>;
-export declare function min<ValidationType extends BaseMinValidationTypes>(threshold: number, params?: MinParams<ValidationType>): ReturnType<typeof createRule<BaseMinValidationTypes, unknown>>;
+export declare function min<ValidationType extends Date>(threshold: Date, params?: MinParams<ValidationType>): ReturnType<typeof createRule<Date>>;
+export declare function min<ValidationType extends BaseMinValidationTypes>(threshold: number, params?: MinParams<ValidationType>): ReturnType<typeof createRule<BaseMinValidationTypes>>;
 export {};

package/mobilePhone/mobilePhone.d.ts

@@ -15,5 +15,5 @@ type MobilePhoneParams = CommonRuleParams<string> & {
  * validate('79999999999');
  * ```
  */
-export declare const mobilePhone: <TValues>(params?: MobilePhoneParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const mobilePhone: <TLastSchemaValues extends Record<string, unknown>>(params?: MobilePhoneParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/number/number.d.ts

@@ -15,8 +15,8 @@ type AdditionalDefOptions = {
  *  validate(24);
  * ```
  */
-export declare const number: <TValues>(...rules: ValidationRule<number, TValues>[]) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+export declare const number: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<number, TLastSchemaValues>[]) => {
+    (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
     define(overridesDefOptions: Partial<AdditionalDefOptions> & {
         requiredErrorMessage?: string | undefined;
         typeErrorMessage?: string | undefined;

package/object/object.d.ts

@@ -3,9 +3,9 @@ import { Guard, ValidationContext, ValidationRule } from '../core';
  * @description Специальный итерфейс Guard для object. В данном интерфейсе ctx required
  * Переопределение необходимо для того, чтобы ts показывал, что ctx required в кастомных правилах
  */
-interface ObjectPropGuard<TValues> {
-    (value: Parameters<Guard<TValues>>[0], ctx: ValidationContext<TValues>): ReturnType<Guard<TValues>>;
-    define: Guard<TValues>['define'];
+interface ObjectPropGuard<TLastSchemaValues extends Record<string, unknown>> {
+    (value: Parameters<Guard<TLastSchemaValues>>[0], ctx: ValidationContext<TLastSchemaValues>): ReturnType<Guard<TLastSchemaValues>>;
+    define: Guard<TLastSchemaValues>['define'];
 }
 type AdditionalDefOptions = {
     /**
@@ -16,11 +16,11 @@ type AdditionalDefOptions = {
 /**
  * @description Возможные значения, принимаемые схемой
  */
-export type SchemaValue<TValues> = ObjectPropGuard<TValues> | ValidationRule<unknown, TValues>;
+export type SchemaValue<TValue extends Record<string, unknown>> = ObjectPropGuard<TValue> | ValidationRule<unknown, TValue>;
 /**
  * @description Схема правил валдиации для объекта
  */
-export type Schema<TValue extends Record<string, unknown>, TValues = unknown> = Record<keyof TValue, SchemaValue<TValues>>;
+export type Schema<TValue extends Record<string, unknown>> = Record<keyof TValue, SchemaValue<TValue>>;
 /**
  * @description Guard для объекта
  * @param schema - схема валидации объекта
@@ -44,13 +44,13 @@ export type Schema<TValue extends Record<string, unknown>, TValues = unknown> =
  * });
  * ```
  */
-export declare const object: <TValue extends Record<string, unknown>, TValues = unknown>(schema: Schema<TValue, TValues>) => {
-    (value: unknown, prevCtx?: ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+export declare const object: <TValue extends Record<string, unknown>, TLastSchemaValues extends Record<string, unknown> = {}>(schema: Schema<TValue>) => {
+    (value: unknown, prevCtx?: ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
     define(overridesDefOptions: Partial<AdditionalDefOptions> & {
         requiredErrorMessage?: string | undefined;
         typeErrorMessage?: string | undefined;
         isOptional?: boolean | undefined;
     }): any;
 };
-export type ObjectGuard<TValue extends Record<string, unknown>, TValues = unknown> = ReturnType<typeof object<TValue, TValues>>;
+export type ObjectGuard<TValue extends Record<string, unknown>> = ReturnType<typeof object<TValue>>;
 export {};

package/object/object.js

@@ -1,5 +1,5 @@
 import isPlainObject from 'is-plain-obj';
-import { createErrorMap, createGuard, } from '../core';
+import { createContext, createErrorMap, createGuard, } from '../core';
 import { optional } from '../optional';
 import { isEmptyErrors } from './isEmptyErrors';
 import { OBJECT_TYPE_ERROR_INFO } from './constants';
@@ -27,16 +27,17 @@ import { OBJECT_TYPE_ERROR_INFO } from './constants';
  * ```
  */
 export const object = (schema) => createGuard((value, ctx, { typeErrorMessage, isPartial }) => {
+    const context = createContext(ctx, value, value);
     if (!isPlainObject(value)) {
-        return ctx.createError(Object.assign(Object.assign({}, OBJECT_TYPE_ERROR_INFO), { message: typeErrorMessage || OBJECT_TYPE_ERROR_INFO.message }));
+        return context.createError(Object.assign(Object.assign({}, OBJECT_TYPE_ERROR_INFO), { message: typeErrorMessage || OBJECT_TYPE_ERROR_INFO.message }));
     }
     const generateErrorMap = () => {
         const schemaEntries = Object.entries(schema);
-        const isOptional = ctx.global.overrides.objectIsPartial || isPartial;
+        const isOptional = context.global.overrides.objectIsPartial || isPartial;
         return schemaEntries.reduce((errorMap, [key, rule]) => {
             const isGuard = 'define' in rule;
             const callRule = isGuard && isOptional ? optional(rule) : rule;
-            errorMap[key] = callRule(value[key], ctx);
+            errorMap[key] = callRule(value[key], context);
             return errorMap;
         }, {});
     };

package/ogrnIP/ogrnIP.d.ts

@@ -13,5 +13,5 @@ type OgrnIPParams = CommonRuleParams<string> & {
  * validate('7728168971');
  * ```
  */
-export declare const ogrnIP: <TValues>(params?: OgrnIPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const ogrnIP: <TLastSchemaValues extends Record<string, unknown>>(params?: OgrnIPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/ogrnUL/ogrnUL.d.ts

@@ -13,5 +13,5 @@ type OgrnULParams = CommonRuleParams<string> & {
  * validate('7728168971');
  * ```
  */
-export declare const ogrnUL: <TValues>(params?: OgrnULParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const ogrnUL: <TLastSchemaValues extends Record<string, unknown>>(params?: OgrnULParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/onlyNumber/onlyNumber.d.ts

@@ -12,5 +12,5 @@ type OnlyNumberParams = {
  *  validate('123');
  * ```
  */
-export declare const onlyNumber: <TValues>(params?: OnlyNumberParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const onlyNumber: <TLastSchemaValues extends Record<string, unknown>>(params?: OnlyNumberParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/optional/optional.d.ts

@@ -4,4 +4,4 @@ import { Guard } from '../core';
  * @param guard - правило, проверяющее тип значения
  * @example object({ name: optional(string(min(22))) })
  */
-export declare const optional: <TValues>(guard: Guard<TValues, {}>) => Guard<TValues, {}>;
+export declare const optional: <TLastSchemaValues extends Record<string, unknown>>(guard: Guard<TLastSchemaValues, {}>) => Guard<TLastSchemaValues, {}>;

package/or/or.d.ts

@@ -11,4 +11,4 @@ import { ValidationResult, ValidationRule } from '../core';
  *  const result = validate('string');
  * ```
  */
-export declare const or: <TValues>(...rules: ValidationRule<unknown, TValues>[]) => (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => ValidationResult;
+export declare const or: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<unknown, TLastSchemaValues>[]) => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => ValidationResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astral/validations",
-  "version": "3.3.0",
+  "version": "4.1.0",
   "browser": "./index.js",
   "main": "./index.js",
   "dependencies": {

package/partial/partial.d.ts

@@ -5,7 +5,7 @@ import { object } from '../object';
  * @example partial(object({ name: string() }))
  */
 export declare const partial: (objectGuard: ReturnType<typeof object>) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<unknown> | undefined): import("../core").ValidationResult;
+    (value: unknown, prevCtx?: import("../core").ValidationContext<Record<string, unknown>> | undefined): import("../core").ValidationResult;
     define(overridesDefOptions: Partial<{
         isPartial?: boolean | undefined;
     }> & {

package/pattern/pattern.d.ts

@@ -14,5 +14,5 @@ type PatternParams = {
  * string(pattern(/[0-9]/))
  * ```
  */
-export declare const pattern: <TValues>(regex: RegExp, params?: PatternParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const pattern: <TLastSchemaValues extends Record<string, unknown>>(regex: RegExp, params?: PatternParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/personName/constants.d.ts

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

package/personName/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const PERSON_NAME_ERROR_INFO = {
+    code: createErrorCode('personName'),
+    message: 'Проверьте имя',
+};

package/personName/index.d.ts

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

package/personName/index.js

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

package/personName/personName.d.ts

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

package/personName/personName.js

@@ -0,0 +1,29 @@
+import { createRule, isFullNameValidCharacters, isHasConsecutiveChars, isStartsWithAndEndsWithLetter, isValidFullNameLength, } from '../core';
+import { PERSON_NAME_ERROR_INFO } from './constants';
+/**
+ * @description Проверяет валидно ли имя
+ * @example
+ * ```ts
+ * const validate = string(personName());
+ * validate("Иван");
+ * ```
+ */
+export const personName = (params) => createRule((value, ctx) => {
+    const createPersonNameError = () => ctx.createError({
+        message: (params === null || params === void 0 ? void 0 : params.message) || PERSON_NAME_ERROR_INFO.message,
+        code: PERSON_NAME_ERROR_INFO.code,
+    });
+    if (isValidFullNameLength(value)) {
+        return createPersonNameError();
+    }
+    if (isFullNameValidCharacters(value)) {
+        return createPersonNameError();
+    }
+    if (isStartsWithAndEndsWithLetter(value)) {
+        return createPersonNameError();
+    }
+    if (isHasConsecutiveChars(value)) {
+        return createPersonNameError();
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/personPatronymic/constants.d.ts

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

package/personPatronymic/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const PERSON_PATRONYMIC_ERROR_INFO = {
+    code: createErrorCode('personPatronymic'),
+    message: 'Проверьте отчество',
+};

package/personPatronymic/index.d.ts

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

package/personPatronymic/index.js

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

package/personPatronymic/personPatronymic.d.ts

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

package/personPatronymic/personPatronymic.js

@@ -0,0 +1,29 @@
+import { createRule, isFullNameValidCharacters, isHasConsecutiveChars, isStartsWithAndEndsWithLetter, isValidFullNameLength, } from '../core';
+import { PERSON_PATRONYMIC_ERROR_INFO } from './constants';
+/**
+ * @description Проверяет валидно ли отчество
+ * @example
+ * ```ts
+ * const validate = string(personPatronymic());
+ * validate("Иванович");
+ * ```
+ */
+export const personPatronymic = (params) => createRule((value, ctx) => {
+    const createPersonPatronymicError = () => ctx.createError({
+        message: (params === null || params === void 0 ? void 0 : params.message) || PERSON_PATRONYMIC_ERROR_INFO.message,
+        code: PERSON_PATRONYMIC_ERROR_INFO.code,
+    });
+    if (isValidFullNameLength(value)) {
+        return createPersonPatronymicError();
+    }
+    if (isFullNameValidCharacters(value)) {
+        return createPersonPatronymicError();
+    }
+    if (isStartsWithAndEndsWithLetter(value)) {
+        return createPersonPatronymicError();
+    }
+    if (isHasConsecutiveChars(value)) {
+        return createPersonPatronymicError();
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/personSurname/constants.d.ts

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

package/personSurname/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const PERSON_SURNAME_ERROR_INFO = {
+    code: createErrorCode('personSurname'),
+    message: 'Проверьте фамилию',
+};

package/personSurname/index.d.ts

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

package/personSurname/index.js

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

package/personSurname/personSurname.d.ts

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

package/personSurname/personSurname.js

@@ -0,0 +1,29 @@
+import { createRule, isFullNameValidCharacters, isHasConsecutiveChars, isStartsWithAndEndsWithLetter, isValidFullNameLength, } from '../core';
+import { PERSON_SURNAME_ERROR_INFO } from './constants';
+/**
+ * @description Проверяет валидно ли фамилия
+ * @example
+ * ```ts
+ * const validate = string(personSurname());
+ * validate("Иванов");
+ * ```
+ */
+export const personSurname = (params) => createRule((value, ctx) => {
+    const createPersonSurnameError = () => ctx.createError({
+        message: (params === null || params === void 0 ? void 0 : params.message) || PERSON_SURNAME_ERROR_INFO.message,
+        code: PERSON_SURNAME_ERROR_INFO.code,
+    });
+    if (isValidFullNameLength(value)) {
+        return createPersonSurnameError();
+    }
+    if (isFullNameValidCharacters(value)) {
+        return createPersonSurnameError();
+    }
+    if (isStartsWithAndEndsWithLetter(value)) {
+        return createPersonSurnameError();
+    }
+    if (isHasConsecutiveChars(value)) {
+        return createPersonSurnameError();
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/positiveNumber/positiveNumber.d.ts

@@ -21,5 +21,5 @@ type PositiveNumberParams = {
  * validate(-1)
  * ```
  */
-export declare const positiveNumber: <TValues>(params?: PositiveNumberParams) => (value: number, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const positiveNumber: <TLastSchemaValues extends Record<string, unknown>>(params?: PositiveNumberParams) => (value: number, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/snils/snils.d.ts

@@ -13,5 +13,5 @@ type SnilsParams = CommonRuleParams<string> & {
  * validate('15657325992');
  * ```
  */
-export declare const snils: <TValues>(params?: SnilsParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const snils: <TLastSchemaValues extends Record<string, unknown>>(params?: SnilsParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/string/string.d.ts

@@ -1,6 +1,6 @@
 import { ValidationRule } from '../core';
-export declare const string: <TValues>(...rules: ValidationRule<string, TValues>[]) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+export declare const string: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<string, TLastSchemaValues>[]) => {
+    (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
     define(overridesDefOptions: Partial<{}> & {
         requiredErrorMessage?: string | undefined;
         typeErrorMessage?: string | undefined;

package/transform/transform.d.ts

@@ -14,5 +14,5 @@ type Transformer<TValue, TResult> = (value: TValue) => TResult;
  *  );
  * ```
  */
-export declare const transform: <TValue extends unknown, TResult extends unknown, TValues>(transformer: Transformer<TValue, TResult>, ...rules: ValidationRule<TResult, TValues>[]) => (value: TValue, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const transform: <TValue extends unknown, TResult extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(transformer: Transformer<TValue, TResult>, ...rules: ValidationRule<TResult, TLastSchemaValues>[]) => (value: TValue, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/when/when.d.ts

@@ -1,17 +1,17 @@
 import { ValidationContext, ValidationRule } from '../core';
-type Params<TValues> = {
+type Params<TLastSchemaValues extends Record<string, unknown>> = {
     /**
      * @description Условие для выбора ветки
      */
-    is: (value: unknown, ctx: ValidationContext<TValues>) => boolean;
+    is: (value: unknown, ctx: ValidationContext<TLastSchemaValues>) => boolean;
     /**
      * Правила валидации, применяемые если is === true
      */
-    then: ValidationRule<unknown, TValues>;
+    then: ValidationRule<unknown, TLastSchemaValues>;
     /**
      * Правила валидации, применяемые если is === false
      */
-    otherwise: ValidationRule<unknown, TValues>;
+    otherwise: ValidationRule<unknown, TLastSchemaValues>;
 };
 /**
  * @description Позволяет указывать условные валидации
@@ -19,7 +19,7 @@ type Params<TValues> = {
  * ```ts
  * type Values = { name: string; isAgree: boolean };
  *
- * const validate = object<Values, Values>({
+ * const validate = object<Values>({
  *   name: when({
  *     is: (_, ctx) => ctx.global.values.isAgree,
  *     then: string(),
@@ -35,5 +35,5 @@ type Params<TValues> = {
  * const result2 = validate({ isAgree: true, name: '' });
  * ```
  */
-export declare const when: <TValues>({ is, then, otherwise }: Params<TValues>) => (value: unknown, prevCtx?: ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const when: <TLastSchemaValues extends Record<string, unknown>>({ is, then, otherwise, }: Params<TLastSchemaValues>) => (value: unknown, prevCtx?: ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/when/when.js

@@ -5,7 +5,7 @@ import { createRule } from '../core';
  * ```ts
  * type Values = { name: string; isAgree: boolean };
  *
- * const validate = object<Values, Values>({
+ * const validate = object<Values>({
  *   name: when({
  *     is: (_, ctx) => ctx.global.values.isAgree,
  *     then: string(),
@@ -21,7 +21,7 @@ import { createRule } from '../core';
  * const result2 = validate({ isAgree: true, name: '' });
  * ```
  */
-export const when = ({ is, then, otherwise }) => createRule((value, ctx) => {
+export const when = ({ is, then, otherwise, }) => createRule((value, ctx) => {
     if (is(value, ctx)) {
         return then(value, ctx);
     }