@scbt-ecom/ui 0.38.0 → 0.38.1

package/dist/shared/ui/formElements/ui/fieldAttachment/FieldAttachment.d.ts

@@ -0,0 +1,20 @@
+import { ReactElement } from 'react';
+export type TFieldAttachmentClasses = {
+    successIcon?: string;
+    errorIcon?: string;
+    badge?: string;
+    icon?: string;
+    fieldAttachmentRoot?: string;
+};
+export interface IFieldAttachmentProps {
+    badge?: ReactElement | string;
+    invalid?: boolean;
+    isTouched?: boolean;
+    withValidateIcons?: boolean;
+    icon?: ReactElement;
+    onClickIcon?: (...args: unknown[]) => unknown;
+    onKeyDownIcon?: (event: React.KeyboardEvent) => unknown;
+    classes?: TFieldAttachmentClasses;
+    disabled?: boolean;
+}
+export declare const FieldAttachment: ({ badge, invalid, isTouched, withValidateIcons, icon, onClickIcon, onKeyDownIcon, classes, disabled }: IFieldAttachmentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/ui/fieldAttachment/index.d.ts

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

package/dist/shared/ui/formElements/ui/fieldAttachment/ui/IconSlot.d.ts

@@ -0,0 +1,6 @@
+import { IFieldAttachmentProps, TFieldAttachmentClasses } from '../FieldAttachment';
+interface IIconSlotProps extends Pick<IFieldAttachmentProps, 'icon' | 'onClickIcon' | 'onKeyDownIcon' | 'disabled'> {
+    classes?: Pick<TFieldAttachmentClasses, 'icon'>;
+}
+export declare const IconSlot: ({ onClickIcon, onKeyDownIcon, icon, classes, disabled }: IIconSlotProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/ui/fieldAttachment/ui/ValidateSlot.d.ts

@@ -0,0 +1,7 @@
+import { IFieldAttachmentProps, TFieldAttachmentClasses } from '../FieldAttachment';
+export interface IValidateSlotProps extends Pick<IFieldAttachmentProps, 'badge' | 'withValidateIcons'> {
+    isValid?: boolean;
+    isInvalid?: boolean;
+    classes?: Pick<TFieldAttachmentClasses, 'badge' | 'errorIcon' | 'successIcon'>;
+}
+export declare const ValidateSlot: ({ badge, withValidateIcons, isValid, isInvalid, classes }: IValidateSlotProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/ui/fieldAttachment/ui/index.d.ts

@@ -0,0 +1,2 @@
+export { ValidateSlot } from './ValidateSlot';
+export { IconSlot } from './IconSlot';

package/dist/shared/ui/formElements/ui/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fieldAttachment';
+export * from './MessageView';

package/dist/shared/ui/formElements/uncontrolled/autocomplete/Autocomplete.d.ts

@@ -0,0 +1,27 @@
+import { SelectBaseProps, SelectItemOption } from '..';
+import { UseQueryResult } from '@tanstack/react-query';
+export interface AutocompleteBaseProps<TData> extends Omit<SelectBaseProps<boolean>, 'options' | 'inputValue' | 'onInputChange' | 'isSearchable' | 'isMulti' | 'value' | 'onChange'> {
+    /**
+     * Запрос который должен получать options (пишем на tanstack/query)
+     */
+    query: (query: string) => UseQueryResult<TData[]>;
+    /**
+     * Позволяет форматировать данные
+     */
+    formatter: (item: TData, index: number, array: TData[]) => SelectItemOption;
+    /**
+     * Позволяет управлять выходным значением
+     */
+    returnValue?: (value: SelectItemOption) => string;
+    /**
+     * Значение инпута
+     */
+    value?: string;
+    /**
+     * Handler инпута
+     */
+    onChange?: (value: string) => void;
+}
+export declare const AutocompleteBase: <TData>(props: AutocompleteBaseProps<TData> & {
+    ref: React.Ref<HTMLInputElement>;
+}) => React.JSX.Element;

package/dist/shared/ui/formElements/uncontrolled/autocomplete/index.d.ts

@@ -0,0 +1 @@
+export { AutocompleteBase, type AutocompleteBaseProps } from './Autocomplete';

package/dist/shared/ui/formElements/uncontrolled/checkbox/Checkbox.d.ts

@@ -0,0 +1,41 @@
+import { CheckboxProps as CheckboxPrimitiveProps, CheckedState } from '@radix-ui/react-checkbox';
+export type CheckboxBaseClasses = {
+    root?: string;
+    indicator?: string;
+    icon?: string;
+};
+export type { CheckedState };
+type ExternalHandlers = {
+    onChange?: (value: CheckedState) => void;
+    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+};
+export type CheckboxBaseProps = CheckboxPrimitiveProps & {
+    /**
+     * Дополнительные стили внутренних компонентов
+     */
+    classes?: CheckboxBaseClasses;
+    /**
+     * Свойство для отображения не валидного поля
+     */
+    invalid?: boolean;
+    /**
+     * Дополнительные хендлеры
+     */
+    externalHandlers?: ExternalHandlers;
+};
+export declare const CheckboxBase: import('react').ForwardRefExoticComponent<CheckboxPrimitiveProps & {
+    /**
+     * Дополнительные стили внутренних компонентов
+     */
+    classes?: CheckboxBaseClasses;
+    /**
+     * Свойство для отображения не валидного поля
+     */
+    invalid?: boolean;
+    /**
+     * Дополнительные хендлеры
+     */
+    externalHandlers?: ExternalHandlers;
+} & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/shared/ui/formElements/uncontrolled/checkbox/index.d.ts

@@ -0,0 +1 @@
+export { CheckboxBase, type CheckboxBaseProps, type CheckedState } from './Checkbox';

package/dist/shared/ui/formElements/uncontrolled/dayPicker/DayPicker.d.ts

@@ -0,0 +1,57 @@
+import { InputBaseClasses } from '../input/Input';
+import { MaskInputProps } from '../../..';
+type ExternalHandlers = {
+    onChange?: (value: string) => void;
+    onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+};
+export type DayPickerClasses = {
+    root?: string;
+    input?: InputBaseClasses;
+};
+export type DayPickerProps = Omit<MaskInputProps, 'value' | 'onChange' | 'mask' | 'classes'> & {
+    /**
+     * Указывает, открыт ли календарь по умолчанию
+     */
+    defaultOpen?: boolean;
+    /**
+     * Значение поля
+     */
+    value?: string;
+    /**
+     * Функция изменения значения
+     */
+    onChange?: (value: string) => void;
+    /**
+     * Внешние классы которыми можно поменять стили
+     */
+    classes?: DayPickerClasses;
+    /**
+     * Дополнительные хендлеры
+     */
+    externalHandlers?: ExternalHandlers;
+};
+export declare const DayPickerBase: import('react').ForwardRefExoticComponent<Omit<MaskInputProps, "onChange" | "mask" | "value" | "classes"> & {
+    /**
+     * Указывает, открыт ли календарь по умолчанию
+     */
+    defaultOpen?: boolean;
+    /**
+     * Значение поля
+     */
+    value?: string;
+    /**
+     * Функция изменения значения
+     */
+    onChange?: (value: string) => void;
+    /**
+     * Внешние классы которыми можно поменять стили
+     */
+    classes?: DayPickerClasses;
+    /**
+     * Дополнительные хендлеры
+     */
+    externalHandlers?: ExternalHandlers;
+} & import('react').RefAttributes<HTMLInputElement>>;
+export {};

package/dist/shared/ui/formElements/uncontrolled/dayPicker/index.d.ts

@@ -0,0 +1 @@
+export { DayPickerBase, type DayPickerProps } from './DayPicker';

package/dist/shared/ui/formElements/uncontrolled/index.d.ts

@@ -0,0 +1,142 @@
+export type { InputBaseProps } from './input';
+export type { MaskInputProps } from './maskInput';
+export type { SelectBaseProps, SelectItemOption } from './select';
+export type { CheckboxBaseProps, CheckedState } from './checkbox';
+export type { DayPickerProps } from './dayPicker';
+export type { SwitchBaseProps } from './switch';
+export type { AutocompleteBaseProps } from './autocomplete';
+export type { RadioGroupBaseProps, RadioOption } from './radio';
+export type { TextareaBaseProps } from './textarea';
+export { isSingleOption } from './select';
+export type { InputOtpBaseProps } from './inputOtp';
+export declare const Uncontrolled: {
+    InputBase: import('react').ForwardRefExoticComponent<Omit<import('react').InputHTMLAttributes<HTMLInputElement>, "size" | "placeholder"> & {
+        classes?: import('./input/Input').InputBaseClasses;
+        label: string;
+        invalid?: boolean;
+        attachmentProps?: import('../../../types').DeepPartial<import('../ui').IFieldAttachmentProps>;
+        renderValues?: () => React.JSX.Element | null;
+        externalHandlers?: {
+            onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+            onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+            onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+            onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+        };
+    } & import('react').RefAttributes<HTMLInputElement>>;
+    SliderBase: import('react').ForwardRefExoticComponent<import('./slider/SliderBase').SliderBaseProps & import('react').RefAttributes<HTMLInputElement>>;
+    AutocompleteBase: <TData>(props: import('./autocomplete').AutocompleteBaseProps<TData> & {
+        ref: React.Ref<HTMLInputElement>;
+    }) => React.JSX.Element;
+    MaskInput: import('react').ForwardRefExoticComponent<Omit<import('react').InputHTMLAttributes<HTMLInputElement>, "size" | "placeholder"> & {
+        classes?: import('./input/Input').InputBaseClasses;
+        label: string;
+        invalid?: boolean;
+        attachmentProps?: import('../../../types').DeepPartial<import('../ui').IFieldAttachmentProps>;
+        renderValues?: () => React.JSX.Element | null;
+        externalHandlers?: {
+            onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+            onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+            onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+            onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+        };
+    } & {
+        mask: "datetime" | "email" | "numeric" | "currency" | "decimal" | "integer" | "percentage" | "url" | "ip" | "mac" | "ssn" | "brl-currency" | "cpf" | "cnpj" | (string & {}) | (string[] & {}) | null;
+        externalMaskDefinitions?: Record<string, import('./maskInput/MaskInput').Definition>;
+    } & import('react').RefAttributes<HTMLInputElement>>;
+    SelectBase: import('react').ForwardRefExoticComponent<Omit<import('@headlessui/react').ComboboxProps<import('./select').SelectItemOption, boolean, "li">, "className" | "onChange" | "multiple" | "by" | "virtual"> & {
+        label: string;
+        isMulti?: boolean | undefined;
+        invalid?: boolean;
+        isSearchable?: boolean;
+        options: import('./select').SelectItemOption[];
+        classes?: import('./select/Select').SelectClasses;
+        displayValue?: (option: import('./select').SelectItemOption) => string;
+        onChange?: ((value: import('./select').SelectItemOption | import('./select').SelectItemOption[] | undefined) => void) | undefined;
+        onInputChange?: (value: string) => void;
+        inputValue?: string;
+        attachmentProps?: import('../../../types').DeepPartial<import('../ui').IFieldAttachmentProps>;
+        virtual?: boolean;
+        filterDisabled?: boolean;
+        externalHandlers?: import('./select/Select').ExternalHandlers;
+    } & import('react').RefAttributes<HTMLInputElement>>;
+    CheckboxBase: import('react').ForwardRefExoticComponent<import('@radix-ui/react-checkbox').CheckboxProps & {
+        classes?: import('./checkbox/Checkbox').CheckboxBaseClasses;
+        invalid?: boolean;
+        externalHandlers?: {
+            onChange?: (value: import('@radix-ui/react-checkbox').CheckedState) => void;
+            onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+            onBlur?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+            onFocus?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+        };
+    } & import('react').RefAttributes<HTMLButtonElement>>;
+    DayPickerBase: import('react').ForwardRefExoticComponent<Omit<import('./maskInput').MaskInputProps, "onChange" | "mask" | "value" | "classes"> & {
+        defaultOpen?: boolean;
+        value?: string;
+        onChange?: (value: string) => void;
+        classes?: import('./dayPicker/DayPicker').DayPickerClasses;
+        externalHandlers?: {
+            onChange?: (value: string) => void;
+            onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
+            onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
+            onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+        };
+    } & import('react').RefAttributes<HTMLInputElement>>;
+    SwitchBase: import('react').ForwardRefExoticComponent<import('@radix-ui/react-switch').SwitchProps & {
+        classes?: {
+            root?: string;
+            thumb?: string;
+        };
+        externalHandlers?: {
+            onChange?: (value: boolean) => void;
+            onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+            onFocus?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+            onBlur?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+        };
+        invalid?: boolean;
+    } & import('react').RefAttributes<HTMLButtonElement>>;
+    RadioGroupBase: import('react').ForwardRefExoticComponent<Omit<import('@radix-ui/react-radio-group').RadioGroupProps, "children"> & {
+        options: import('./radio').RadioOption[];
+        displayValue?: (option: import('./radio').RadioOption) => string;
+        returnValue?: (option: import('./radio').RadioOption) => string;
+        classes?: import('./radio/ui/RadioItem').RadioItemClasses & {
+            root?: string;
+            list?: string;
+            radioItem?: import('./radio/ui/RadioItem').RadioItemClasses;
+        };
+        invalid?: boolean;
+        externalHandlers?: {
+            onChange?: (value: string) => void;
+            onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+            onFocus?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+            onBlur?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+        };
+    } & import('react').RefAttributes<HTMLDivElement>>;
+    TextareaBase: import('react').ForwardRefExoticComponent<Omit<import('react').TextareaHTMLAttributes<HTMLTextAreaElement>, "className" | "size"> & {
+        classes?: {
+            container?: string;
+            textarea?: string;
+            label?: string;
+        };
+        label: string;
+        invalid?: boolean;
+        attachmentProps?: import('../../../types').DeepPartial<import('../ui').IFieldAttachmentProps>;
+        externalHandlers?: {
+            onChange?: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
+            onClick?: (event: React.MouseEvent<HTMLTextAreaElement>) => void;
+            onFocus?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
+            onBlur?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
+        };
+    } & import('react').RefAttributes<HTMLTextAreaElement>>;
+    InputOtpBase: import('react').ForwardRefExoticComponent<Omit<import('input-otp').OTPInputProps, "render"> & {
+        classes?: import('./inputOtp').InputOtpBaseClasses;
+        initialFocus?: boolean;
+        externalHandlers?: {
+            onChange?: (value: string) => void;
+            onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+            onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+            onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+        };
+        invalid?: boolean;
+    } & import('react').RefAttributes<HTMLInputElement>>;
+    UploaderBase: import('react').ForwardRefExoticComponent<import('./uploader').UploaderBaseProps & import('react').RefAttributes<HTMLInputElement>>;
+};

package/dist/shared/ui/formElements/uncontrolled/input/Input.d.ts

@@ -0,0 +1,68 @@
+import { FieldAttachment } from '../../ui';
+import { DeepPartial } from '../../../../types';
+export type InputBaseClasses = {
+    container?: string;
+    input?: string;
+    label?: string;
+    renderWrapper?: string;
+};
+type FieldAttachmentProps = React.ComponentPropsWithoutRef<typeof FieldAttachment>;
+type ExternalHandlers = {
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+};
+export type InputBaseProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'placeholder' | 'size'> & {
+    /**
+     * Дополнительные стили внутренних компонентов
+     */
+    classes?: InputBaseClasses;
+    /**
+     * Отображаемый placeholder
+     */
+    label: string;
+    /**
+     * Отображение не валидного поля
+     */
+    invalid?: boolean;
+    /**
+     * Свойства дополнительной иконки
+     */
+    attachmentProps?: DeepPartial<FieldAttachmentProps>;
+    /**
+     * Рендер дополнительных значений вместо базового ввода
+     */
+    renderValues?: () => React.JSX.Element | null;
+    /**
+     * Дополнительные хендлеры
+     */
+    externalHandlers?: ExternalHandlers;
+};
+export declare const InputBase: import('react').ForwardRefExoticComponent<Omit<import('react').InputHTMLAttributes<HTMLInputElement>, "size" | "placeholder"> & {
+    /**
+     * Дополнительные стили внутренних компонентов
+     */
+    classes?: InputBaseClasses;
+    /**
+     * Отображаемый placeholder
+     */
+    label: string;
+    /**
+     * Отображение не валидного поля
+     */
+    invalid?: boolean;
+    /**
+     * Свойства дополнительной иконки
+     */
+    attachmentProps?: DeepPartial<FieldAttachmentProps>;
+    /**
+     * Рендер дополнительных значений вместо базового ввода
+     */
+    renderValues?: () => React.JSX.Element | null;
+    /**
+     * Дополнительные хендлеры
+     */
+    externalHandlers?: ExternalHandlers;
+} & import('react').RefAttributes<HTMLInputElement>>;
+export {};

package/dist/shared/ui/formElements/uncontrolled/input/index.d.ts

@@ -0,0 +1 @@
+export { InputBase, type InputBaseProps } from './Input';

package/dist/shared/ui/formElements/uncontrolled/inputOtp/InputOtpBase.d.ts

@@ -0,0 +1,51 @@
+import { OTPInputProps } from 'input-otp';
+import { InputOTPSlotClasses } from './ui';
+export type InputOtpBaseClasses = {
+    input?: string;
+    inputContainer?: string;
+    container?: string;
+    slot?: InputOTPSlotClasses;
+};
+type ExternalHandlers = {
+    onChange?: (value: string) => void;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+};
+export type InputOtpBaseProps = Omit<OTPInputProps, 'render'> & {
+    /**
+     * Внешние классы которыми можно поменять стили
+     */
+    classes?: InputOtpBaseClasses;
+    /**
+     * Изначальный автофокус
+     */
+    initialFocus?: boolean;
+    /**
+     * Внешние handlers
+     */
+    externalHandlers?: ExternalHandlers;
+    /**
+     * Для aria-invalid валидное или не валидное поле
+     */
+    invalid?: boolean;
+};
+export declare const InputOtpBase: import('react').ForwardRefExoticComponent<Omit<OTPInputProps, "render"> & {
+    /**
+     * Внешние классы которыми можно поменять стили
+     */
+    classes?: InputOtpBaseClasses;
+    /**
+     * Изначальный автофокус
+     */
+    initialFocus?: boolean;
+    /**
+     * Внешние handlers
+     */
+    externalHandlers?: ExternalHandlers;
+    /**
+     * Для aria-invalid валидное или не валидное поле
+     */
+    invalid?: boolean;
+} & import('react').RefAttributes<HTMLInputElement>>;
+export {};

package/dist/shared/ui/formElements/uncontrolled/inputOtp/index.d.ts

@@ -0,0 +1 @@
+export { type InputOtpBaseClasses, type InputOtpBaseProps, InputOtpBase } from './InputOtpBase';

package/dist/shared/ui/formElements/uncontrolled/inputOtp/ui/InputOtpSlot.d.ts

@@ -0,0 +1,14 @@
+import { ComponentPropsWithoutRef } from 'react';
+export type InputOTPSlotClasses = {
+    singleChar?: string;
+    caretWrapper?: string;
+    caret?: string;
+    substrate?: string;
+};
+interface InputOTPSlotProps extends ComponentPropsWithoutRef<'div'> {
+    index: number;
+    classes?: InputOTPSlotClasses;
+    invalid?: boolean;
+}
+export declare const InputOTPSlot: import('react').ForwardRefExoticComponent<InputOTPSlotProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/shared/ui/formElements/uncontrolled/inputOtp/ui/index.d.ts

@@ -0,0 +1 @@
+export { InputOTPSlot, type InputOTPSlotClasses } from './InputOtpSlot';

package/dist/shared/ui/formElements/uncontrolled/maskInput/MaskInput.d.ts

@@ -0,0 +1,50 @@
+import { InputBaseProps } from '../input';
+type Validator = (char: string) => boolean;
+type Casing = 'upper' | 'lower' | 'title';
+export type Definition = {
+    validator: string | Validator;
+    casing?: Casing;
+    cardinality?: number;
+    placeholder?: string;
+    definitionSymbol?: string;
+};
+export type MaskInputProps = InputBaseProps & {
+    /**
+     * маска, по которой будет определяться валидация символов
+     */
+    mask: 'datetime' | 'email' | 'numeric' | 'currency' | 'decimal' | 'integer' | 'percentage' | 'url' | 'ip' | 'mac' | 'ssn' | 'brl-currency' | 'cpf' | 'cnpj' | (string & {}) | (string[] & {}) | null;
+    /**
+     * дополнительные валидаторы спец символов в маске
+     */
+    externalMaskDefinitions?: Record<string, Definition>;
+};
+/**
+ * Компонент маски очень умный, умеет обрабатывать специальные символы
+ * в том порядке, который определён маской
+ * @typeParam `#` позволяет вводить только числа (regexp: `/\d/g`)
+ * @typeParam `A` позволяет вводить любые буквы русского и английского алфавита (regexp: `/[A-Za-zА-Яа-я]/g`)
+ * @typeParam `C` позволяет вводить любые буквы, которые определены для использования в гос номерах автомобилей (regexp: `/([АВЕКМНОРСТУХавекмнорстух])/`)
+ */
+export declare const MaskInput: import('react').ForwardRefExoticComponent<Omit<import('react').InputHTMLAttributes<HTMLInputElement>, "size" | "placeholder"> & {
+    classes?: import('../input/Input').InputBaseClasses;
+    label: string;
+    invalid?: boolean;
+    attachmentProps?: import('../../../../types').DeepPartial<import('../../ui').IFieldAttachmentProps>;
+    renderValues?: () => React.JSX.Element | null;
+    externalHandlers?: {
+        onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+        onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+        onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+        onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    };
+} & {
+    /**
+     * маска, по которой будет определяться валидация символов
+     */
+    mask: "datetime" | "email" | "numeric" | "currency" | "decimal" | "integer" | "percentage" | "url" | "ip" | "mac" | "ssn" | "brl-currency" | "cpf" | "cnpj" | (string & {}) | (string[] & {}) | null;
+    /**
+     * дополнительные валидаторы спец символов в маске
+     */
+    externalMaskDefinitions?: Record<string, Definition>;
+} & import('react').RefAttributes<HTMLInputElement>>;
+export {};

package/dist/shared/ui/formElements/uncontrolled/maskInput/index.d.ts

@@ -0,0 +1 @@
+export { MaskInput, type MaskInputProps } from './MaskInput';

package/dist/shared/ui/formElements/uncontrolled/maskInput/model/mask/index.d.ts

@@ -0,0 +1 @@
+export { defaultDefinitions } from './utils';

package/dist/shared/ui/formElements/uncontrolled/maskInput/model/mask/utils.d.ts

@@ -0,0 +1,2 @@
+import { Definition } from '../../MaskInput';
+export declare const defaultDefinitions: Record<string, Definition>;

package/dist/shared/ui/formElements/uncontrolled/radio/RadioGroup.d.ts

@@ -0,0 +1,67 @@
+import { RadioGroupProps as RadioGroupPrimitiveProps } from '@radix-ui/react-radio-group';
+import { RadioItemProps, RadioOption } from './ui';
+import { RadioItemClasses } from './ui/RadioItem';
+type RadioGroupClasses = RadioItemProps['classes'] & {
+    root?: string;
+    list?: string;
+    radioItem?: RadioItemClasses;
+};
+type ExternalHandlers = {
+    onChange?: (value: string) => void;
+    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+};
+export type RadioGroupBaseProps = Omit<RadioGroupPrimitiveProps, 'children'> & {
+    /**
+     * Список отображаемых опций
+     */
+    options: RadioOption[];
+    /**
+     * Функция для управления отображаемым значением
+     */
+    displayValue?: (option: RadioOption) => string;
+    /**
+     * Функция для управления возвращаемым значением
+     */
+    returnValue?: (option: RadioOption) => string;
+    /**
+     * Дополнительные стили внутренних компонентов
+     */
+    classes?: RadioGroupClasses;
+    /**
+     * Свойство для отображения не валидного поля
+     */
+    invalid?: boolean;
+    /**
+     * Дополнительные хендлеры
+     */
+    externalHandlers?: ExternalHandlers;
+};
+export declare const RadioGroupBase: import('react').ForwardRefExoticComponent<Omit<RadioGroupPrimitiveProps, "children"> & {
+    /**
+     * Список отображаемых опций
+     */
+    options: RadioOption[];
+    /**
+     * Функция для управления отображаемым значением
+     */
+    displayValue?: (option: RadioOption) => string;
+    /**
+     * Функция для управления возвращаемым значением
+     */
+    returnValue?: (option: RadioOption) => string;
+    /**
+     * Дополнительные стили внутренних компонентов
+     */
+    classes?: RadioGroupClasses;
+    /**
+     * Свойство для отображения не валидного поля
+     */
+    invalid?: boolean;
+    /**
+     * Дополнительные хендлеры
+     */
+    externalHandlers?: ExternalHandlers;
+} & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/shared/ui/formElements/uncontrolled/radio/index.d.ts

@@ -0,0 +1,2 @@
+export { RadioGroupBase, type RadioGroupBaseProps } from './RadioGroup';
+export type { RadioOption } from './ui';

package/dist/shared/ui/formElements/uncontrolled/radio/ui/RadioItem.d.ts

@@ -0,0 +1,35 @@
+import { RadioGroupItemProps } from '@radix-ui/react-radio-group';
+export type RadioOption = {
+    id: number | string;
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+export type RadioItemClasses = {
+    item?: string;
+    indicator?: string;
+    label?: string;
+};
+export type RadioItemProps = Omit<RadioGroupItemProps, 'value'> & {
+    /**
+     * Опция списка
+     */
+    item: RadioOption;
+    /**
+     * Функция для управления отображаемым значением
+     */
+    displayValue?: (option: RadioOption) => string;
+    /**
+     * Функция для управления возвращаемым значением
+     */
+    returnValue?: (option: RadioOption) => string;
+    /**
+     * Дополнительные стили внутренних компонентов
+     */
+    classes?: RadioItemClasses;
+    /**
+     * Свойство для отображения не валидного поля
+     */
+    invalid?: boolean;
+};
+export declare const RadioItem: import('react').MemoExoticComponent<({ item, disabled, displayValue, returnValue, classes, className, invalid, ...props }: RadioItemProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/shared/ui/formElements/uncontrolled/radio/ui/index.d.ts

@@ -0,0 +1 @@
+export { RadioItem, type RadioOption, type RadioItemProps } from './RadioItem';