@scbt-ecom/ui 0.31.5 → 0.32.0

package/README.md

@@ -1,4 +1,4 @@
-# React + TypeScript + Vite
+# React + TypeScript + Vite haha
 
 This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
 

package/dist/shared/validation/base/base.constants.d.ts

@@ -3,6 +3,7 @@ export declare const baseDefaultMessages: {
     NON_EMPTY: () => string;
     MIN_LENGTH: (min: number) => string;
     MAX_LENGTH: (max: number) => string;
+    FIX_LENGTH: (length: number) => string;
     MIN_VALUE: (min: number) => string;
     MAX_VALUE: (max: number) => string;
     PHONE_NON_EMPTY: () => string;
@@ -10,7 +11,9 @@ export declare const baseDefaultMessages: {
     EMAIL_INVALID: () => string;
     EMAIL_NON_EMPTY: () => string;
     SELECT_NON_EMPTY: () => string;
-    SELECT_MULTIPLE_NON_EMPTY: (length: number) => string;
+    SELECT_MULTIPLE_MIN_LENGTH: (length: number) => string;
+    SELECT_MULTIPLE_MAX_LENGTH: (length: number) => string;
+    SELECT_FIX_LENGTH: (length: number) => string;
     DATE_INVALID_FORMAT: () => string;
     DATE_NON_EMPTY: () => string;
     VALUE_OUT_OF_RANGE: <T extends Primitive>(range: T[]) => string;

package/dist/shared/validation/base/base.validators.d.ts

@@ -1,20 +1,16 @@
+import { getDateSchema } from './date.validators';
+import { getEmailSchema } from './email.validators';
+import { getNumberSchema } from './number.validators';
+import { getPhoneSchema } from './phone.validators';
+import { getSelectSchema } from './select.validators';
+import { getStringSchema } from './string.validators';
+import { getUnionSchema } from './union.validators';
 export declare const baseValidationSchemas: {
-    getStringRequired: (props?: import('./string.validators').StringValidationOptions) => import('zod').ZodDefault<import('zod').ZodEffects<import('zod').ZodString, string, string>>;
-    getStringOptional: (props?: import('./string.validators').StringValidationOptions) => import('zod').ZodEffects<import('zod').ZodOptional<import('zod').ZodString>, string | undefined, string | undefined>;
-    getEmailRequired: (props?: import('./email.validators').EmailValidationOptions) => import('zod').ZodDefault<import('zod').ZodString>;
-    getEmailOptional: (props?: import('./email.validators').EmailValidationOptions) => import('zod').ZodEffects<import('zod').ZodOptional<import('zod').ZodEffects<import('zod').ZodString, string, string>>, string | undefined, string | undefined>;
-    getSelectRequired: <Multi extends boolean>(props?: Multi extends true ? import('./select.validators').SelectSingleValidationOptions<Multi> & {
-        minLength?: number;
-    } : import('./select.validators').SelectSingleValidationOptions<Multi>) => import('zod').ZodDefault<import('zod').ZodEffects<import('zod').ZodNullable<import('zod').ZodString>, string | null, string | null>> | import('zod').ZodDefault<import('zod').ZodArray<import('zod').ZodDefault<import('zod').ZodEffects<import('zod').ZodNullable<import('zod').ZodString>, string | null, string | null>>, "many">>;
-    getSelectOptional: <Multi extends boolean>(props?: Omit<Multi extends true ? import('./select.validators').SelectSingleValidationOptions<Multi> & {
-        minLength?: number;
-    } : import('./select.validators').SelectSingleValidationOptions<Multi>, "message">) => import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>> | import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodOptional<import('zod').ZodNullable<import('zod').ZodString>>, "many">>;
-    getNumberRequired: (props?: import('./number.validators').NumberValidationOptions) => import('zod').ZodDefault<import('zod').ZodNumber>;
-    getNumberOptional: (props?: import('./number.validators').NumberValidationOptions) => import('zod').ZodEffects<import('zod').ZodOptional<import('zod').ZodDefault<import('zod').ZodNumber>>, number | undefined, number | undefined>;
-    getPhoneRequired: (props?: import('./phone.validators').PhoneValidationOptions) => import('zod').ZodDefault<import('zod').ZodEffects<import('zod').ZodString, string, string>>;
-    getPhoneOptional: (props?: import('./phone.validators').PhoneValidationOptions) => import('zod').ZodEffects<import('zod').ZodEffects<import('zod').ZodString, string, string>, string | undefined, string>;
-    getDateRequired: (props?: import('./date.validators').DateValidationOptions) => import('zod').ZodDefault<import('zod').ZodEffects<import('zod').ZodString, string, string>>;
-    getDateOptional: (props?: import('./date.validators').DateValidationOptions) => import('zod').ZodOptional<import('zod').ZodEffects<import('zod').ZodEffects<import('zod').ZodString, string | undefined, string>, string | undefined, string>>;
-    getUnionRequired: <T extends import('zod').Primitive>(values: [T, T, ...T[]], props?: import('./union.validators').UnionValidationOptions<T>) => import('zod').ZodUnion<[import('zod').ZodLiteral<T>, import('zod').ZodLiteral<T>, ...import('zod').ZodLiteral<T>[]]>;
-    getUnionOptional: <T extends import('zod').Primitive>(values: [T, T, ...T[]], props?: import('./union.validators').UnionValidationOptions<T>) => import('zod').ZodOptional<import('zod').ZodUnion<[import('zod').ZodLiteral<T>, import('zod').ZodLiteral<T>, ...import('zod').ZodLiteral<T>[]]>>;
+    getStringSchema: typeof getStringSchema;
+    getEmailSchema: typeof getEmailSchema;
+    getSelectSchema: typeof getSelectSchema;
+    getNumberSchema: typeof getNumberSchema;
+    getPhoneSchema: typeof getPhoneSchema;
+    getDateSchema: typeof getDateSchema;
+    getUnionSchema: typeof getUnionSchema;
 };

package/dist/shared/validation/base/date.validators.d.ts

@@ -1,7 +1,7 @@
 import { default as z } from 'zod';
-export type DateValidationOptions = {
+export type DateValidationOptions<Required extends boolean> = {
     /**
-     * парсить строку с учетом ISO формата
+     * валидация строки с учетом ISO формата
      * @default false
      */
     iso?: boolean;
@@ -10,6 +10,10 @@ export type DateValidationOptions = {
      * @default 'dd.MM.yyyy'
      */
     pattern?: string;
+    /**
+     * указывает что поле обязательное
+     */
+    required?: Required;
     message?: {
         min?: string;
         invalidDate?: string;
@@ -17,31 +21,35 @@ export type DateValidationOptions = {
 };
 /**
  * Схема валидации опционального поля номера телефона
- * @param {DateValidationOptions} props настройки схемы
- * @typeParam `iso` - `boolean | undefined` `default: false`
- * @typeParam `pattern` - `string | undefined` `default: 'dd.MM.yyyy'`
- * @typeParam `message` - `{ [min | invalidOperator]: string }`
- * @returns схема валидации поля в соответствии с настройками
- *
- * @example
- * z.object({
- *   field: zodValidators.base.getDateRequired()
- * })
- * // will returns z.string()
  */
-export declare const getDateRequired: (props?: DateValidationOptions) => z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+declare const getDateRequired: (props?: Omit<DateValidationOptions<boolean>, "required">) => z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+type DateRequiredSchema = ReturnType<typeof getDateRequired>;
 /**
  * Схема валидации опционального поля номера телефона
+ */
+declare const getDateOptional: (props?: Omit<DateValidationOptions<boolean>, "required">) => z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string | undefined, string>, string | undefined, string>>;
+type DateOptionalSchema = ReturnType<typeof getDateOptional>;
+/**
+ * Схема валидации поля даты
  * @param {DateValidationOptions} props настройки схемы
- * @typeParam `iso` - `boolean | undefined` `default: false` парсить строку с учетом ISO формата
- * @typeParam `pattern` - `string | undefined` `default: 'dd.MM.yyyy'` шаблон для валидации строки (будет проигнорирован, если `iso = true`)
+ * @typeParam `required` - `boolean`
+ * @typeParam `iso` - `boolean | undefined`
+ * @typeParam `pattern` - `string | undefined`
  * @typeParam `message` - `{ [min | invalidOperator]: string }`
  * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with required value
  * z.object({
- *   field: zodValidators.base.getDateOptional()
+ *   field: zodValidators.base.getDateSchema()
  * })
  * // will returns z.string()
+ *
+ * @example with required value
+ * z.object({
+ *   field: zodValidators.base.getDateSchema({ required: false })
+ * })
+ * // will returns z.string().optional()
  */
-export declare const getDateOptional: (props?: DateValidationOptions) => z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string | undefined, string>, string | undefined, string>>;
+export declare function getDateSchema(props?: DateValidationOptions<true>): DateRequiredSchema;
+export declare function getDateSchema(props?: DateValidationOptions<false>): DateOptionalSchema;
+export {};

package/dist/shared/validation/base/email.validators.d.ts

@@ -1,5 +1,14 @@
 import { default as z } from 'zod';
-export type EmailValidationOptions = {
+export type EmailValidationOptions<Required extends boolean> = {
+    /**
+     * указывает что поле обязательное
+     * @default true
+     */
+    required?: Required;
+    /**
+     * Регулярное выражение для проверки email на валидность
+     */
+    regexp?: RegExp;
     message?: {
         min?: string;
         invalid?: string;
@@ -7,27 +16,34 @@ export type EmailValidationOptions = {
 };
 /**
  * Схема валидации обязательного поля типа email
+ */
+declare const getEmailRequired: (props?: Omit<EmailValidationOptions<true>, "required">) => z.ZodDefault<z.ZodString>;
+type EmailRequiredSchema = ReturnType<typeof getEmailRequired>;
+/**
+ * Схема валидации опционального поля типа email
+ */
+declare const getEmailOptional: (props?: Omit<EmailValidationOptions<false>, "required">) => z.ZodEffects<z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>, string | undefined, string | undefined>;
+type EmailOptionalSchema = ReturnType<typeof getEmailOptional>;
+/**
+ * Схема валидации поля типа email
  * @param {EmailValidationOptions} props настройки схемы
+ * @typeParam `required` - `boolean`
+ * @typeParam `regexp` - `RegExp`
  * @typeParam `message` - `{ [min | invalid]: string }`
  * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with required value
  * z.object({
- *   field: zodValidators.base.getEmailRequired({ message: { min: '' } })
+ *   field: zodValidators.base.getEmailSchema()
  * })
  * // will returns z.string().min(1).email()
- */
-export declare const getEmailRequired: (props?: EmailValidationOptions) => z.ZodDefault<z.ZodString>;
-/**
- * Схема валидации опционального поля типа email
- * @param {EmailValidationOptions} props настройки схемы
- * @typeParam `message` - `{ [min | invalid]: string }`
- * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with optional value
  * z.object({
- *   field: zodValidators.base.getEmailOptional({ message: { min: '' } })
+ *   field: zodValidators.base.getEmailSchema({ required: false })
  * })
  * // will returns z.string().min(1).email().optional()
  */
-export declare const getEmailOptional: (props?: EmailValidationOptions) => z.ZodEffects<z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>, string | undefined, string | undefined>;
+export declare function getEmailSchema(props?: EmailValidationOptions<true>): EmailRequiredSchema;
+export declare function getEmailSchema(props?: EmailValidationOptions<false>): EmailOptionalSchema;
+export {};

package/dist/shared/validation/base/index.d.ts

@@ -1 +1,2 @@
 export * from './base.validators';
+export { baseDefaultMessages } from './base.constants';

package/dist/shared/validation/base/number.validators.d.ts

@@ -1,36 +1,53 @@
 import { default as z } from 'zod';
-export type NumberValidationOptions = {
+export type NumberValidationOptions<Required extends boolean> = {
+    /**
+     * минимальное значение
+     * @default 0
+     */
     min?: number;
+    /**
+     * максимальное значение
+     * @default undefined
+     */
     max?: number;
-    message?: Record<keyof Omit<NumberValidationOptions, 'message'>, string>;
+    /**
+     * указывает что поле обязательное
+     * @default true
+     */
+    required?: Required;
+    message?: Record<keyof Omit<NumberValidationOptions<Required>, 'message'>, string>;
 };
 /**
  * Схема валидации обязательного поля числового типа
+ */
+declare const getNumberRequired: (props?: Omit<NumberValidationOptions<true>, "required">) => z.ZodDefault<z.ZodNumber>;
+type NumberRequiredSchema = ReturnType<typeof getNumberRequired>;
+/**
+ * Схема валидации опционального поля числового типа
+ */
+declare const getNumberOptional: (props?: Omit<NumberValidationOptions<false>, "required">) => z.ZodEffects<z.ZodOptional<z.ZodDefault<z.ZodNumber>>, number | undefined, number | undefined>;
+type NumberOptionalSchema = ReturnType<typeof getNumberOptional>;
+/**
+ * Схема валидации опционального поля числового типа
  * @param {NumberValidationOptions} props настройки схемы
+ @typeParam `required` - `boolean`
  * @typeParam `min` - `number | undefined` `default: 1`
  * @typeParam `max` - `number | undefined` `default: undefined`
  * @typeParam `message` - `{ [min | max]: string }`
  * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with required min, max value
  * z.object({
- *   field: zodValidators.base.getNumberRequired({ min: 10, max: 20 })
+ *   field: zodValidators.base.getNumberSchema({ min: 10, max: 20 })
  * })
  * // will returns z.coerce.number().min(10).max(20)
- */
-export declare const getNumberRequired: (props?: NumberValidationOptions) => z.ZodDefault<z.ZodNumber>;
-/**
- * Схема валидации опционального поля числового типа
- * @param {NumberValidationOptions} props настройки схемы
- * @typeParam `min` - `number | undefined` `default: 1`
- * @typeParam `max` - `number | undefined` `default: undefined`
- * @typeParam `message` - `{ [min | max]: string }`
- * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with optional min, max value
  * z.object({
- *   field: zodValidators.base.getNumberOptional({ min: 10, max: 20 })
+ *   field: zodValidators.base.getNumberSchema({ min: 10, max: 20, required: false })
  * })
  * // will returns z.coerce.number().min(10).max(20).optional()
  */
-export declare const getNumberOptional: (props?: NumberValidationOptions) => z.ZodEffects<z.ZodOptional<z.ZodDefault<z.ZodNumber>>, number | undefined, number | undefined>;
+export declare function getNumberSchema(props?: NumberValidationOptions<true>): NumberRequiredSchema;
+export declare function getNumberSchema(props?: NumberValidationOptions<false>): NumberOptionalSchema;
+export {};

package/dist/shared/validation/base/phone.validators.d.ts

@@ -1,8 +1,8 @@
 import { default as z } from 'zod';
-export type PhoneValidationOptions = {
+export type PhoneValidationOptions<Required extends boolean> = {
     /**
      * исключает маску в возвращаемом значении
-     * @default false
+     * @default true
      */
     ignoreMask?: boolean;
     /**
@@ -10,6 +10,10 @@ export type PhoneValidationOptions = {
      * @default /[()+_ -]/g
      */
     maskSymbols?: RegExp;
+    /**
+     * указывает что поле обязательное
+     */
+    required?: Required;
     message?: {
         min?: string;
         invalidOperator?: string;
@@ -17,31 +21,35 @@ export type PhoneValidationOptions = {
 };
 /**
  * Схема валидации обязательного поля номера телефона
+ */
+declare const getPhoneRequired: (props?: Omit<PhoneValidationOptions<true>, "required">) => z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+type PhoneRequiredSchema = ReturnType<typeof getPhoneRequired>;
+/**
+ * Схема валидации опционального поля номера телефона
+ */
+declare const getPhoneOptional: (props?: Omit<PhoneValidationOptions<false>, "required">) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string | undefined, string>;
+type PhoneOptionalSchema = ReturnType<typeof getPhoneOptional>;
+/**
+ * Схема валидации опционального поля номера телефона
  * @param {PhoneValidationOptions} props настройки схемы
- * @typeParam `ignoreMask` - `boolean | undefined` `default: false`
+ @typeParam `required` - `boolean`
+ * @typeParam `ignoreSeparators` - `boolean | undefined` `default: false`
  * @typeParam `maskSymbols` - `RegExp | undefined` `default: /[()+_ -]/g`
  * @typeParam `message` - `{ [min | invalidOperator]: string }`
  * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with required value
  * z.object({
- *   field: zodValidators.base.getPhoneRequired()
+ *   field: zodValidators.base.getPhoneSchema()
  * })
  * // will returns z.string()
- */
-export declare const getPhoneRequired: (props?: PhoneValidationOptions) => z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
-/**
- * Схема валидации опционального поля номера телефона
- * @param {PhoneValidationOptions} props настройки схемы
- * @typeParam `ignoreSeparators` - `boolean | undefined` `default: false` возвращает строку вырезая символы маски
- * @typeParam `maskSymbols` - `RegExp | undefined` `default: /[()+_ -]/g` игнорирует символы для проверки поля исключая данные символы
- * @typeParam `message` - `{ [min | invalidOperator]: string }`
- * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with optional value
  * z.object({
- *   field: zodValidators.base.getPhoneOptional()
+ *   field: zodValidators.base.getPhoneSchema({ required: false })
  * })
- * // will returns z.string()
+ * // will returns z.string().optional()
  */
-export declare const getPhoneOptional: (props?: PhoneValidationOptions) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string | undefined, string>;
+export declare function getPhoneSchema(props?: PhoneValidationOptions<true>): PhoneRequiredSchema;
+export declare function getPhoneSchema(props?: PhoneValidationOptions<false>): PhoneOptionalSchema;
+export {};

package/dist/shared/validation/base/select.validators.d.ts

@@ -1,60 +1,85 @@
 import { default as z } from 'zod';
-export type SelectSingleValidationOptions<Multi extends boolean = false> = {
+export type SelectSingleValidationOptions<Required extends boolean, Multi extends boolean = false> = {
     /**
      * включает валидацию мульти селекта
      * @default false
      */
     multiple?: Multi;
+    /**
+     * указывает что поле обязательное
+     * @default true
+     */
+    required?: Required;
     message?: {
         single?: string;
         multiple?: string;
     };
 };
-type SelectMultipleValidationOptions<Multi extends boolean = true> = SelectSingleValidationOptions<Multi> & {
+type SelectMultipleValidationOptions<Required extends boolean, Multi extends boolean = true> = SelectSingleValidationOptions<Required, Multi> & {
     /**
      * минимальное количество элементов
      * @default 0
      */
     minLength?: number;
+    /**
+     * максимальное количество элементов
+     * @default undefined
+     */
+    maxLength?: number;
+    /**
+     * фиксированное количество элементов
+     * @default undefined
+     */
+    length?: number;
+    message?: SelectSingleValidationOptions<Required, Multi> & {
+        minLength?: string;
+        maxLength?: string;
+        length?: string;
+    };
 };
-type SelectValidationOptions<Multi extends boolean> = Multi extends true ? SelectMultipleValidationOptions<Multi> : SelectSingleValidationOptions<Multi>;
+type SelectValidationOptions<Required extends boolean, Multi extends boolean> = Multi extends true ? SelectMultipleValidationOptions<Required, Multi> : SelectSingleValidationOptions<Required, Multi>;
 /**
  * Схема валидации обязательного поля типа select
+ */
+declare const getSelectRequired: <Required extends boolean, Multi extends boolean>(props?: SelectValidationOptions<Required, Multi>) => z.ZodDefault<z.ZodEffects<z.ZodNullable<z.ZodString>, string | null, string | null>> | z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodEffects<z.ZodNullable<z.ZodString>, string | null, string | null>>, "many">>;
+type SelectRequiredSchema = ReturnType<typeof getSelectRequired>;
+/**
+ * Схема валидации опционального поля типа select
+ */
+declare function getSelectOptional<Required extends boolean, Multi extends boolean>(props?: Omit<SelectValidationOptions<Required, Multi>, 'message'>): z.ZodOptional<z.ZodNullable<z.ZodString>> | z.ZodOptional<z.ZodArray<z.ZodOptional<z.ZodNullable<z.ZodString>>, "many">>;
+type SelectOptionalSchema = ReturnType<typeof getSelectOptional>;
+/**
+ * Схема валидации опционального поля типа select
  * @param {SelectValidationOptions} props настройки схемы
+ @typeParam `required` - `boolean`
  * @typeParam `multiple` - `boolean`
- * @typeParam `minLength` - `number` `required if multiple = true`
- * @typeParam `message` - `{ [single | multiple]: string }`
+ * @typeParam `minLength` - `number | undefined`
  * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with required single value
  * z.object({
- *   field: zodValidators.base.getSelectRequired({ multiple: false })
+ *   field: zodValidators.base.getSelectSchema({ multiple: false })
  * })
- * // will returns z.string().min(1).nullable().refine(Boolean)
+ * // will returns z.string().nullable()
  *
+ * @example with required multiple value
  * z.object({
- *   field: zodValidators.base.getSelectRequired({ multiple: true, minLength: 3 })
+ *   field: zodValidators.base.getSelectSchema({ multiple: true })
  * })
- * // will returns z.array(z.string().min(1).nullable().refine(Boolean))
- */
-export declare const getSelectRequired: <Multi extends boolean>(props?: SelectValidationOptions<Multi>) => z.ZodDefault<z.ZodEffects<z.ZodNullable<z.ZodString>, string | null, string | null>> | z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodEffects<z.ZodNullable<z.ZodString>, string | null, string | null>>, "many">>;
-/**
- * Схема валидации опционального поля типа select
- * @param {SelectValidationOptions} props настройки схемы
- * @typeParam `multiple` - `boolean`
- * @typeParam `minLength` - `number` `required if multiple = true`
- * @returns схема валидации поля в соответствии с настройками
+ * // will returns z.array(z.string().nullable())
  *
- * @example
+ * @example with optional single value
  * z.object({
- *   field: zodValidators.base.getSelectOptional({ multiple: false })
+ *   field: zodValidators.base.getSelectSchema({ required: false, multiple: false })
  * })
- * // will returns z.string().nullable()
+ * // will returns z.string().nullable().optional()
  *
+ * @example with optional multiple value
  * z.object({
- *   field: zodValidators.base.getSelectOptional({ multiple: true })
+ *   field: zodValidators.base.getSelectSchema({ required: false, multiple: true })
  * })
- * // will returns z.array(z.string().nullable())
+ * // will returns z.array(z.string().nullable().optional()).optional()
  */
-export declare const getSelectOptional: <Multi extends boolean>(props?: Omit<SelectValidationOptions<Multi>, "message">) => z.ZodOptional<z.ZodNullable<z.ZodString>> | z.ZodOptional<z.ZodArray<z.ZodOptional<z.ZodNullable<z.ZodString>>, "many">>;
+export declare function getSelectSchema<Multi extends boolean>(props?: SelectValidationOptions<true, Multi>): SelectRequiredSchema;
+export declare function getSelectSchema<Multi extends boolean>(props?: SelectValidationOptions<false, Multi>): SelectOptionalSchema;
 export {};

package/dist/shared/validation/base/string.validators.d.ts

@@ -1,5 +1,5 @@
 import { default as z } from 'zod';
-export type StringValidationOptions = {
+export type StringValidationOptions<Required extends boolean> = {
     /**
      * минимальное количество символов
      * @default 1
@@ -10,8 +10,27 @@ export type StringValidationOptions = {
      * @default undefined
      */
     max?: number;
-    message?: Record<keyof Omit<StringValidationOptions, 'message'>, string>;
+    /**
+     * фиксированная длина символов
+     */
+    length?: number;
+    /**
+     * указывает что поле обязательное
+     * @default true
+     */
+    required?: Required;
+    message?: Record<keyof Omit<StringValidationOptions<Required>, 'message'> | 'root', string>;
 };
+/**
+ * Схема валидации обязательного поля строкового типа
+ */
+declare const getStringRequired: (props?: Omit<StringValidationOptions<true>, "required">) => z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+type StringRequiredSchema = ReturnType<typeof getStringRequired>;
+/**
+ * Схема валидации обязательного поля строкового типа
+ */
+declare const getStringOptional: (props?: Omit<StringValidationOptions<false>, "required">) => z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+type StringOptionalSchema = ReturnType<typeof getStringOptional>;
 /**
  * Схема валидации обязательного поля строкового типа
  * @param {StringValidationOptions} props настройки схемы
@@ -20,25 +39,30 @@ export type StringValidationOptions = {
  * @typeParam `message` - `{ [min | max]: string }`
  * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with required min value
+ * z.object({
+ *   field: zodValidators.base.getStringSchema({ min: 10 })
+ * })
+ * // will returns z.string().min(10)
+ *
+ * @example with required min, max value
  * z.object({
- *   field: zodValidators.base.getStringRequired({ min: 10, max: 20 })
+ *   field: zodValidators.base.getStringSchema({ min: 10, max: 20 })
  * })
  * // will returns z.string().min(10).max(20)
- */
-export declare const getStringRequired: (props?: StringValidationOptions) => z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
-/**
- * Схема валидации обязательного поля строкового типа
- * @param {StringValidationOptions} props настройки схемы
- * @typeParam `min` - `number | undefined` `default: 1`
- * @typeParam `max` - `number | undefined` `default: undefined`
- * @typeParam `message` - `{ [min | max]: string }`
- * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with optional min value
+ * z.object({
+ *   field: zodValidators.base.getStringSchema({ required: false, min: 10 })
+ * })
+ * // will returns z.string().min(10).optional()
+ *
+ * @example with optional min, max value
  * z.object({
- *   field: zodValidators.base.getStringOptional({ min: 10, max: 20 })
+ *   field: zodValidators.base.getStringSchema({ required: false, min: 10, max: 20 })
  * })
  * // will returns z.string().min(10).max(20).optional()
  */
-export declare const getStringOptional: (props?: StringValidationOptions) => z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+export declare function getStringSchema(props?: StringValidationOptions<true>): StringRequiredSchema;
+export declare function getStringSchema(props?: StringValidationOptions<false>): StringOptionalSchema;
+export {};

package/dist/shared/validation/base/union.validators.d.ts

@@ -1,34 +1,56 @@
 import { default as z } from 'zod';
-export type UnionValidationOptions<T extends z.Primitive> = {
+export type UnionValidationOptions<Required extends boolean, T extends z.Primitive> = {
+    /**
+     * сообщение об ошибке
+     */
     message?: ((values: readonly T[]) => string) | string;
     errorMap?: z.ZodErrorMap;
+    /**
+     * сообщение об ошибке при не правильном типе значение
+     */
     invalid_type_error?: string;
+    /**
+     * сообщение об ошибке при отсутствии значения
+     */
     required_error?: string;
+    /**
+     * описание схемы
+     */
     description?: string;
+    /**
+     * указывает что поле обязательное
+     * @default true
+     */
+    required?: Required;
 };
 /**
  * Схема валидации обязательного поля из выборки
- * @param {z.Primitive[]} values литералы
- * @param {z.RawCreateParams & { message: (values: z.Primitive[]) => string }} props настройки схемы
- * @returns схема валидации поля в соответствии с настройками
- *
- * @example
- * z.object({
- *   field: zodValidators.base.getUnionRequired(['A', 'B'] as const)
- * })                                                      ^ it need to infer literal type
- * // will returns z.union([z.literal('A'), z.literal('B')])
  */
-export declare const getUnionRequired: <T extends z.Primitive>(values: [T, T, ...T[]], props?: UnionValidationOptions<T>) => z.ZodUnion<[z.ZodLiteral<T>, z.ZodLiteral<T>, ...z.ZodLiteral<T>[]]>;
+declare const getUnionRequired: <T extends z.Primitive>(values: [T, T, ...T[]], props?: Omit<UnionValidationOptions<true, T>, "required">) => z.ZodUnion<[z.ZodLiteral<T>, z.ZodLiteral<T>, ...z.ZodLiteral<T>[]]>;
+type UnionRequiredSchema<T extends z.Primitive> = ReturnType<typeof getUnionRequired<T>>;
+/**
+ * Схема валидации обязательного поля из выборки
+ */
+declare const getUnionOptional: <T extends z.Primitive>(values: [T, T, ...T[]], props?: UnionValidationOptions<false, T>) => z.ZodOptional<z.ZodUnion<[z.ZodLiteral<T>, z.ZodLiteral<T>, ...z.ZodLiteral<T>[]]>>;
+type UnionOptionalSchema<T extends z.Primitive> = ReturnType<typeof getUnionOptional<T>>;
 /**
  * Схема валидации обязательного поля из выборки
  * @param {z.Primitive} values литералы
  * @param {z.RawCreateParams & { message: (values: z.Primitive[]) => string }} props настройки схемы
  * @returns схема валидации поля в соответствии с настройками
  *
- * @example
+ * @example with required union value
+ * z.object({
+ *   field: zodValidators.base.getUnionSchema(['A', 'B'] as const)
+ * })                                                      ^ it need to infer literal type
+ * // will returns z.union([z.literal('A'), z.literal('B')])
+ *
+ * @example with optional union value
  * z.object({
- *   field: zodValidators.base.getUnionRequired(['A', 'B'] as const)
+ *   field: zodValidators.base.getUnionSchema(['A', 'B'] as const, { required: false })
  * })                                                      ^ it need to infer literal type
  * // will returns z.union([z.literal('A'), z.literal('B')]).optional()
  */
-export declare const getUnionOptional: <T extends z.Primitive>(values: [T, T, ...T[]], props?: UnionValidationOptions<T>) => z.ZodOptional<z.ZodUnion<[z.ZodLiteral<T>, z.ZodLiteral<T>, ...z.ZodLiteral<T>[]]>>;
+export declare function getUnionSchema<T extends z.Primitive>(values: [T, T, ...T[]], props?: UnionValidationOptions<true, T>): UnionRequiredSchema<T>;
+export declare function getUnionSchema<T extends z.Primitive>(values: [T, T, ...T[]], props?: UnionValidationOptions<false, T>): UnionOptionalSchema<T>;
+export {};

package/dist/shared/validation/dadata/dadata.constants.d.ts

@@ -0,0 +1,14 @@
+export declare const fioDefaultMessages: {
+    NON_EMPTY: () => string;
+    VALUE_NO_WHITESPACE: () => string;
+    ONLY_CYRILLIC: () => string;
+    NAME_OR_SURNAME_NON_EMPTY: () => string;
+    INVALID_NAME: () => string;
+    INVALID_SURNAME: () => string;
+    INVALID_PATRONYMIC: () => string;
+};
+export declare const fioRegex: {
+    ONLY_CYRILLIC: RegExp;
+    CHECK_HYPHEN: RegExp;
+    PATRONYMIC: RegExp;
+};