@scbt-ecom/ui 0.38.0 → 0.38.2

package/dist/shared/ui/formElements/controlled/dayPickerControl/range.d.ts

@@ -0,0 +1,29 @@
+import { Calendar, MaskInputProps } from '../../..';
+type CalendarProps = React.ComponentPropsWithoutRef<typeof Calendar>;
+type RangeDayPickerClasses = MaskInputProps['classes'] & {
+    calendar?: string;
+};
+type IsoDateRange = {
+    from?: string;
+    to?: string;
+};
+type RangeDayPickerProps = Omit<CalendarProps, 'mode'> & {
+    /**
+     * Свойства Input компонента
+     */
+    inputProps: Omit<MaskInputProps, 'mask'>;
+    /**
+     * Стили внутренних компонентов
+     */
+    classes?: RangeDayPickerClasses;
+    /**
+     * Управляемое значение
+     */
+    value: IsoDateRange;
+    /**
+     * Функция для управления значением
+     */
+    onChange: (value: IsoDateRange) => void;
+};
+export declare const RangeDayPicker: ({ inputProps, classes, value, onChange, ...props }: RangeDayPickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/dayPickerControl/single.d.ts

@@ -0,0 +1,30 @@
+import { ExternalHandlers } from './dayPickerControl';
+import { Calendar, MaskInputProps } from '../../..';
+type CalendarProps = React.ComponentPropsWithoutRef<typeof Calendar>;
+type SingleDayPickerClasses = MaskInputProps['classes'] & {
+    calendar?: string;
+};
+type SingleDayPickerProps = Omit<CalendarProps, 'mode'> & {
+    /**
+     * Свойства Input компонента
+     */
+    inputProps: Omit<MaskInputProps, 'mask'>;
+    /**
+     * Стили внутренних компонентов
+     */
+    classes?: SingleDayPickerClasses;
+    /**
+     * Управляемое значение
+     */
+    value: string;
+    /**
+     * Функция для управления значением
+     */
+    onChange: (value: string) => void;
+    /**
+     * Дополнительные хендлеры
+     */
+    externalHandlers?: ExternalHandlers;
+};
+export declare const SingleDayPicker: ({ inputProps, classes, value, onChange, externalHandlers, ...props }: SingleDayPickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/editor/EditorControl.d.ts

@@ -0,0 +1,16 @@
+import { ReactElement } from 'react';
+import { FieldValues, Path, UseControllerProps } from 'react-hook-form';
+export type EditorControlClasses = {
+    root?: string;
+    editor?: string;
+    wrapper?: string;
+    message?: string;
+    label?: string;
+};
+export type EditorControlProps<TFieldValues extends FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = UseControllerProps<TFieldValues, TName> & {
+    editable?: boolean;
+    classes?: EditorControlClasses;
+    helperText?: string | ReactElement;
+    label?: string;
+};
+export declare const EditorControl: <T extends FieldValues>({ control, label, helperText, editable, classes, defaultValue, disabled, rules, shouldUnregister, name, ...props }: EditorControlProps<T>) => import("react/jsx-runtime").JSX.Element;

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

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

package/dist/shared/ui/formElements/controlled/editor/model/config.d.ts

@@ -0,0 +1 @@
+export declare const editorConfig: (import('@tiptap/core').Extension<import('@tiptap/starter-kit').StarterKitOptions, any> | import('@tiptap/core').Mark<import('@tiptap/extension-underline').UnderlineOptions, any> | import('@tiptap/core').Extension<import('@tiptap/extension-color').ColorOptions, any> | import('@tiptap/core').Node<import('@tiptap/extension-heading').HeadingOptions, any>)[];

package/dist/shared/ui/formElements/controlled/editor/model/helper.d.ts

@@ -0,0 +1,16 @@
+import { Editor } from '@tiptap/react';
+import { ColorOption, HeadingOptions } from './types';
+export declare const headingsOptions: HeadingOptions[];
+export declare const editorHeadingClasses: Record<number, string>;
+export declare const editorAllowedColors: ColorOption[];
+export declare const renderEditorPanel: (editor: Editor) => ({
+    label: string;
+    icon: import("react/jsx-runtime").JSX.Element;
+    onClick: () => boolean;
+    isActive: boolean;
+} | {
+    label: string;
+    icon: import("react/jsx-runtime").JSX.Element;
+    onClick: () => boolean;
+    isActive?: undefined;
+})[];

package/dist/shared/ui/formElements/controlled/editor/model/types.d.ts

@@ -0,0 +1,6 @@
+export type THeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export interface HeadingOptions {
+    shortcuts: string[];
+    level: THeadingLevel;
+}
+export type ColorOption = `#${string}`;

package/dist/shared/ui/formElements/controlled/editor/ui/Editor.d.ts

@@ -0,0 +1,18 @@
+import { ReactElement } from 'react';
+import { FieldError } from 'react-hook-form';
+import { EditorEvents, UseEditorOptions } from '@tiptap/react';
+import { EditorControlClasses } from '../EditorControl';
+type ExternalHandlers = {
+    onUpdate?: (editor: EditorEvents['update']) => void;
+};
+interface EditorProps extends Partial<UseEditorOptions> {
+    onChange: (value: string) => void;
+    value: string;
+    error?: FieldError;
+    classes?: EditorControlClasses;
+    externalHandlers?: ExternalHandlers;
+    label?: string;
+    helperText?: string | ReactElement;
+}
+export declare const Editor: import('react').ForwardRefExoticComponent<EditorProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/shared/ui/formElements/controlled/editor/ui/Toolbar.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/react';
+interface ToolbarProps {
+    editor: Editor;
+}
+export declare const Toolbar: ({ editor }: ToolbarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/editor/ui/commands/SetColor.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/react';
+interface ISetColorProps {
+    editor: Editor;
+}
+export declare const SetColor: ({ editor }: ISetColorProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/editor/ui/commands/SetCoreCommands.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/react';
+interface ISetCoreCommandsProps {
+    editor: Editor;
+}
+export declare const SetCoreCommands: ({ editor }: ISetCoreCommandsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/editor/ui/commands/SetHeadings.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/react';
+interface ISetHeadingsProps {
+    editor: Editor;
+}
+export declare const SetHeadings: ({ editor }: ISetHeadingsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/editor/ui/commands/index.d.ts

@@ -0,0 +1,4 @@
+export { SetCoreCommands } from './SetCoreCommands';
+export { SetHeadings } from './SetHeadings';
+export { SetColor } from './SetColor';
+export { SetCustomLink } from './setCustomLink';

package/dist/shared/ui/formElements/controlled/editor/ui/commands/setCustomLink.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/react';
+interface ISetCustomLinkProps {
+    editor: Editor;
+}
+export declare const SetCustomLink: ({ editor }: ISetCustomLinkProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,114 @@
+export type { TextareaControlProps } from './textarea';
+export type { InputOtpControlProps } from './inputOtp';
+export declare const Controlled: {
+    InputControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, helperText, classes, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('..').InputBaseProps, "classes"> & {
+        control: import('react-hook-form').Control<TFieldValues>;
+        helperText?: string;
+        classes?: import('../uncontrolled/input/Input').InputBaseClasses & {
+            message?: string;
+            root?: string;
+        };
+    }) => import("react/jsx-runtime").JSX.Element;
+    MaskInputControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, helperText, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('..').MaskInputProps, "classes"> & {
+        control: import('react-hook-form').Control<TFieldValues>;
+        classes?: import('../uncontrolled/input/Input').InputBaseClasses & {
+            message?: string;
+        };
+        helperText?: string;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DayPickerControl: <T extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, name, disabled, rules, shouldUnregister, defaultValue, inputProps, helperText, classes, ...props }: import('./dayPickerControl/dayPickerControl').DayPickerControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+    CheckboxControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, classes, className, name, rules, shouldUnregister, defaultValue, disabled, children, helperText, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('..').CheckboxBaseProps, "classes"> & {
+        control: import('react-hook-form').Control<TFieldValues>;
+        children: React.ReactElement | string;
+        classes?: import('../uncontrolled/checkbox/Checkbox').CheckboxBaseClasses & {
+            container?: string;
+            message?: string;
+            label?: string;
+        };
+        helperText?: string;
+    }) => import("react/jsx-runtime").JSX.Element;
+    SelectControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, classes, name, rules, shouldUnregister, disabled, defaultValue, returnValue, options, helperText, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('@headlessui/react').ComboboxProps<import('..').SelectItemOption, boolean, "li">, "className" | "onChange" | "multiple" | "by" | "virtual"> & {
+        label: string;
+        isMulti?: boolean | undefined;
+        invalid?: boolean;
+        isSearchable?: boolean;
+        options: import('..').SelectItemOption[];
+        classes?: import('../uncontrolled/select/Select').SelectClasses;
+        displayValue?: (option: import('..').SelectItemOption) => string;
+        onChange?: ((value: import('..').SelectItemOption | import('..').SelectItemOption[] | undefined) => void) | undefined;
+        onInputChange?: (value: string) => void;
+        inputValue?: string;
+        attachmentProps?: import('../../../types').DeepPartial<import('../ui').IFieldAttachmentProps>;
+        virtual?: boolean;
+        filterDisabled?: boolean;
+        externalHandlers?: import('../uncontrolled/select/Select').ExternalHandlers;
+    } & {
+        control: import('react-hook-form').Control<TFieldValues>;
+        classes?: {
+            item?: string;
+            helperText?: string;
+            checkbox?: import('../uncontrolled/checkbox/Checkbox').CheckboxBaseClasses;
+        } & {
+            root?: string;
+            list?: string;
+        } & {
+            container?: string;
+            message?: string;
+        };
+        helperText?: string;
+        returnValue?: (option: import('..').SelectItemOption) => string;
+    }) => import("react/jsx-runtime").JSX.Element;
+    SwitchControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ classes, className, control, name, rules, defaultValue, disabled, shouldUnregister, children, helperText, tooltip, popoverProps, ...props }: import('./switch/SwitchControl').SwitchControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    RadioGroupControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ classes, className, control, name, rules, shouldUnregister, disabled, defaultValue, helperText, label, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('..').RadioGroupBaseProps, "classes"> & {
+        label: string;
+        control: import('react-hook-form').Control<TFieldValues>;
+        classes?: import('../uncontrolled/radio/ui/RadioItem').RadioItemClasses & {
+            root?: string;
+            list?: string;
+            radioItem?: import('../uncontrolled/radio/ui/RadioItem').RadioItemClasses;
+        } & {
+            container?: string;
+            message?: string;
+            label?: string;
+        };
+        helperText?: string;
+    }) => import("react/jsx-runtime").JSX.Element;
+    AutocompleteControl: <TFieldValues extends import('react-hook-form').FieldValues, T>({ control, name, defaultValue, disabled, helperText, rules, shouldUnregister, classes, immediate, ...props }: import('./autocomplete').AutocompleteControlProps<TFieldValues, T>) => import("react/jsx-runtime").JSX.Element;
+    DadataFio: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataCacheOption<unknown>>, "query" | "formatter"> & {
+        dadataBaseUrl: string;
+        formatter?: (item: import('./dadata/types').IDadataCacheOption<unknown>) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DadataAddress: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataCacheOption<unknown>>, "query" | "formatter"> & {
+        dadataBaseUrl: string;
+        formatter?: (item: import('./dadata/types').IDadataCacheOption<unknown>) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DadataCountry: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataCountryOption>, "query" | "formatter"> & {
+        dadataBaseUrl: string;
+        formatter?: (item: import('./dadata/types').IDadataCountryOption) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DadataAuto: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataAutoOption>, "query" | "formatter"> & {
+        dadataBaseUrl: string;
+        formatter?: (item: import('./dadata/types').IDadataAutoOption) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DadataOrganization: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataOrganizationOption>, "query" | "formatter"> & {
+        dadataBaseUrl: string;
+        formatter?: (item: import('./dadata/types').IDadataOrganizationOption) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
+    SliderControl: ({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, ...props }: Omit<import('../uncontrolled/slider/SliderBase').SliderBaseProps, "onChange" | "classes" | "value"> & import('react-hook-form').UseControllerProps<import('react-hook-form').FieldValues, string> & {
+        control: import('react-hook-form').Control<import('react-hook-form').FieldValues>;
+        classes?: import('../uncontrolled/slider/SliderBase').SliderBaseClasses & {
+            container?: string;
+        };
+    }) => import("react/jsx-runtime").JSX.Element;
+    TextareaControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ classes, control, name, rules, disabled, defaultValue, shouldUnregister, helperText, ...props }: import('./textarea').TextareaControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    UploaderControl: ({ control, name, defaultValue, rules, shouldUnregister, classes, helperText, disabled, ...props }: import('react-hook-form').UseControllerProps<import('react-hook-form').FieldValues, string> & import('../uncontrolled/uploader').UploaderBaseProps & {
+        control: import('react-hook-form').Control<import('react-hook-form').FieldValues>;
+        classes?: import('../uncontrolled/uploader').UploaderBaseProps & {
+            message?: string;
+            container?: string;
+        };
+    }) => import("react/jsx-runtime").JSX.Element;
+    InputOtpControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, helperText, ...props }: import('./inputOtp').InputOtpControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    EditorControl: <T extends import('react-hook-form').FieldValues>({ control, label, helperText, editable, classes, defaultValue, disabled, rules, shouldUnregister, name, ...props }: import('./editor').EditorControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+    InputCurrencyControl: <T extends import('react-hook-form').FieldValues>({ defaultCurrency, label, helperText, control, classes, disabled, name, defaultValue, rules, attachmentProps, shouldUnregister, externalHandlers, ...props }: import('./inputCurrency').InputCurrencyControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/shared/ui/formElements/controlled/input/InputControl.d.ts

@@ -0,0 +1,22 @@
+import { Control, FieldValues, Path, UseControllerProps } from 'react-hook-form';
+import { InputBaseProps } from '../../uncontrolled';
+type InputControlClasses = InputBaseProps['classes'] & {
+    message?: string;
+    root?: string;
+};
+type InputControlProps<TFieldValues extends FieldValues = FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<InputBaseProps, 'classes'> & {
+    /**
+     * Контрол объект для управления полем
+     */
+    control: Control<TFieldValues>;
+    /**
+     * Дополнительный текст
+     */
+    helperText?: string;
+    /**
+     * Дополнительные стили компонента
+     */
+    classes?: InputControlClasses;
+};
+export declare const InputControl: <TFieldValues extends FieldValues = FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, helperText, classes, ...props }: InputControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/input/MaskInputControl.d.ts

@@ -0,0 +1,22 @@
+import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
+import { MaskInputProps } from '../../uncontrolled';
+type MaskInputClasses = MaskInputProps['classes'] & {
+    message?: string;
+};
+type MaskInputControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<MaskInputProps, 'classes'> & {
+    /**
+     * Контрол объект для управления полем
+     */
+    control: Control<TFieldValues>;
+    /**
+     * Дополнительные стили компонента
+     */
+    classes?: MaskInputClasses;
+    /**
+     * Дополнительный текст
+     */
+    helperText?: string;
+};
+declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, helperText, ...props }: MaskInputControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export declare const MaskInputControl: typeof InnerComponent;
+export {};

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

@@ -0,0 +1,2 @@
+export { InputControl } from './InputControl';
+export { MaskInputControl } from './MaskInputControl';

package/dist/shared/ui/formElements/controlled/inputCurrency/InputCurrencyControl.d.ts

@@ -0,0 +1,26 @@
+import { ReactElement } from 'react';
+import { FieldValues, Path, UseControllerProps } from 'react-hook-form';
+import { InputBaseProps } from '../../..';
+import * as React from 'react';
+export type TCurrencyVariant = 'euro' | 'dollars' | 'rubles' | 'yuan' | 'dirhams';
+export interface ICurrencyOption {
+    ruName: string;
+    engName: string;
+    currency: TCurrencyVariant;
+}
+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 InputCurrencyControlProps<TFieldValues extends FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = Omit<InputBaseProps, 'externalHandlers' | 'onChange' | 'value' | 'defaultValue' | 'type'> & UseControllerProps<TFieldValues, TName> & {
+    classes?: any;
+    defaultCurrency?: TCurrencyVariant;
+    disabled?: boolean;
+    label: string;
+    helperText?: string | ReactElement;
+    externalHandlers?: ExternalHandlers;
+};
+export declare const InputCurrencyControl: <T extends FieldValues>({ defaultCurrency, label, helperText, control, classes, disabled, name, defaultValue, rules, attachmentProps, shouldUnregister, externalHandlers, ...props }: InputCurrencyControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/shared/ui/formElements/controlled/inputCurrency/model/helpers.d.ts

@@ -0,0 +1,3 @@
+import { ICurrencyOption, TCurrencyVariant } from '../InputCurrencyControl';
+export declare const getDelimiterForCurrency: (currency: TCurrencyVariant) => "" | "€ " | "$ " | "₽ " | "¥ " | "د.إ ";
+export declare const currencyOptionsList: ICurrencyOption[];

package/dist/shared/ui/formElements/controlled/inputCurrency/model/useInputCurrency.d.ts

@@ -0,0 +1,10 @@
+import { ICurrencyOption, TCurrencyVariant } from '../InputCurrencyControl';
+type TUseInputCurrencyReturn = {
+    menuIsOpen: boolean;
+    currentCurrencyOption: ICurrencyOption;
+    onSelectOption: (option: ICurrencyOption) => void;
+    onToggleMenu: () => void;
+    onCloseMenu: () => void;
+};
+export declare const useInputCurrency: (defaultCurrency?: TCurrencyVariant) => TUseInputCurrencyReturn;
+export {};

package/dist/shared/ui/formElements/controlled/inputCurrency/ui/MenuTrigger.d.ts

@@ -0,0 +1,7 @@
+import { ICurrencyOption } from '../InputCurrencyControl';
+interface IMenuTriggerProps {
+    onToggleMenu: () => void;
+    currentCurrencyOption: ICurrencyOption;
+}
+export declare const MenuTrigger: ({ onToggleMenu, currentCurrencyOption }: IMenuTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/inputCurrency/ui/OptionList.d.ts

@@ -0,0 +1,8 @@
+import { ICurrencyOption } from '../InputCurrencyControl';
+interface IOptionListProps {
+    optionsList: ICurrencyOption[];
+    menuIsOpen: boolean;
+    onSelectOption: (option: ICurrencyOption) => void;
+}
+export declare const OptionList: ({ optionsList, menuIsOpen, onSelectOption }: IOptionListProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,2 @@
+export { MenuTrigger } from './MenuTrigger';
+export { OptionList } from './OptionList';

package/dist/shared/ui/formElements/controlled/inputOtp/InputOtpControl.d.ts

@@ -0,0 +1,12 @@
+import { FieldValues, Path, UseControllerProps } from 'react-hook-form';
+import { InputOtpBaseProps } from '../../..';
+type InputOtpControlClasses = InputOtpBaseProps['classes'] & {
+    message?: string;
+    container?: string;
+};
+export type InputOtpControlProps<TFieldValues extends FieldValues = FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<InputOtpBaseProps, 'classes'> & {
+    classes?: InputOtpControlClasses;
+    helperText?: string;
+};
+export declare const InputOtpControl: <TFieldValues extends FieldValues = FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, helperText, ...props }: InputOtpControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1 @@
+export { InputOtpControl, type InputOtpControlProps } from './InputOtpControl';

package/dist/shared/ui/formElements/controlled/radio/RadioGroupControl.d.ts

@@ -0,0 +1,27 @@
+import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
+import { RadioGroupBaseProps } from '../../..';
+type RadioControlClasses = RadioGroupBaseProps['classes'] & {
+    container?: string;
+    message?: string;
+    label?: string;
+};
+type RadioGroupControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<RadioGroupBaseProps, 'classes'> & {
+    /**
+     * Отображаемый лейбл
+     */
+    label: string;
+    /**
+     * Контрол объект для управления полем
+     */
+    control: Control<TFieldValues>;
+    /**
+     * Дополнительные стили компонента
+     */
+    classes?: RadioControlClasses;
+    /**
+     * Дополнительный текст
+     */
+    helperText?: string;
+};
+export declare const RadioGroupControl: <TFieldValues extends FieldValues = FieldValues>({ classes, className, control, name, rules, shouldUnregister, disabled, defaultValue, helperText, label, ...props }: RadioGroupControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/shared/ui/formElements/controlled/select/SelectControl.d.ts

@@ -0,0 +1,26 @@
+import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
+import { SelectBaseProps, SelectItemOption } from '../../..';
+type SelectControlClasses = SelectBaseProps<boolean>['classes'] & {
+    container?: string;
+    message?: string;
+};
+type SelectControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & SelectBaseProps<boolean> & {
+    /**
+     * Контрол объект для управления полем
+     */
+    control: Control<TFieldValues>;
+    /**
+     * Дополнительные стили компонента
+     */
+    classes?: SelectControlClasses;
+    /**
+     * Дополнительный текст
+     */
+    helperText?: string;
+    /**
+     * Функция для управления возвращаемым значением
+     */
+    returnValue?: (option: SelectItemOption) => string;
+};
+export declare const SelectControl: <TFieldValues extends FieldValues = FieldValues>({ control, classes, name, rules, shouldUnregister, disabled, defaultValue, returnValue, options, helperText, ...props }: SelectControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/shared/ui/formElements/controlled/slider/SliderControl.d.ts

@@ -0,0 +1,11 @@
+import { Control, FieldValues, Path, UseControllerProps } from 'react-hook-form';
+import { SliderBaseClasses, SliderBaseProps } from '../../uncontrolled/slider/SliderBase';
+type SliderControlClasses = SliderBaseClasses & {
+    container?: string;
+};
+type SliderControlProps<TFieldValues extends FieldValues = FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = Omit<SliderBaseProps, 'value' | 'onChange' | 'classes'> & UseControllerProps<TFieldValues, TName> & {
+    control: Control<TFieldValues>;
+    classes?: SliderControlClasses;
+};
+export declare const SliderControl: ({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, ...props }: SliderControlProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/shared/ui/formElements/controlled/switch/SwitchControl.d.ts

@@ -0,0 +1,35 @@
+import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
+import { Popover, SwitchBaseProps } from '../../..';
+type SwitchControlClasses = SwitchBaseProps['classes'] & {
+    container?: string;
+    message?: string;
+};
+type PopoverProps = React.ComponentPropsWithoutRef<typeof Popover>;
+export type SwitchControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<SwitchBaseProps, 'classes'> & {
+    /**
+     * Контрол объект для управления полем
+     */
+    control: Control<TFieldValues>;
+    /**
+     * Отображаемый лейбл
+     */
+    children: React.ReactElement | string;
+    /**
+     * Дополнительные стили компонента
+     */
+    classes?: SwitchControlClasses;
+    /**
+     * Дополнительный текст
+     */
+    helperText?: string;
+    /**
+     * Текст всплывающей подсказки
+     */
+    tooltip?: React.ReactElement | string;
+    /**
+     * Свойства `Popover` компонента
+     */
+    popoverProps?: PopoverProps;
+};
+export declare const SwitchControl: <TFieldValues extends FieldValues = FieldValues>({ classes, className, control, name, rules, defaultValue, disabled, shouldUnregister, children, helperText, tooltip, popoverProps, ...props }: SwitchControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/shared/ui/formElements/controlled/textarea/TextareaControl.d.ts

@@ -0,0 +1,22 @@
+import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
+import { TextareaBaseProps } from '../../..';
+type TextareaControlClasses = TextareaBaseProps['classes'] & {
+    root?: string;
+    message?: string;
+};
+export type TextareaControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<TextareaBaseProps, 'classes'> & {
+    /**
+     * Контрол объект для управления полем
+     */
+    control: Control<TFieldValues>;
+    /**
+     * Дополнительные стили компонента
+     */
+    classes?: TextareaControlClasses;
+    /**
+     * Дополнительный текст
+     */
+    helperText?: string;
+};
+export declare const TextareaControl: <TFieldValues extends FieldValues = FieldValues>({ classes, control, name, rules, disabled, defaultValue, shouldUnregister, helperText, ...props }: TextareaControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1 @@
+export { TextareaControl, type TextareaControlProps } from './TextareaControl';

package/dist/shared/ui/formElements/controlled/uploader/UploaderControl.d.ts

@@ -0,0 +1,12 @@
+import { Control, FieldValues, Path, UseControllerProps } from 'react-hook-form';
+import { UploaderBaseProps } from '../../uncontrolled/uploader';
+type UploaderControlClasses = UploaderBaseProps & {
+    message?: string;
+    container?: string;
+};
+type UploaderControlProps<TFieldValues extends FieldValues = FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = UseControllerProps<TFieldValues, TName> & UploaderBaseProps & {
+    control: Control<TFieldValues>;
+    classes?: UploaderControlClasses;
+};
+export declare const UploaderControl: ({ control, name, defaultValue, rules, shouldUnregister, classes, helperText, disabled, ...props }: UploaderControlProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export * from './controlled';
+export * from './uncontrolled';

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

@@ -0,0 +1,14 @@
+import { ReactElement } from 'react';
+import { FieldError } from 'react-hook-form';
+import { VariantProps } from 'class-variance-authority';
+declare const messageViewConfig: (props?: ({
+    intent?: "error" | "simple" | null | undefined;
+    disabled?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface IMessageViewProps extends VariantProps<typeof messageViewConfig> {
+    as?: 'div' | 'span' | 'p';
+    text?: string | FieldError['message'] | ReactElement;
+    className?: string;
+}
+export declare const MessageView: ({ intent, as: Element, disabled, text, className, ...props }: IMessageViewProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};