@scbt-ecom/ui 0.7.30 → 0.8.1

package/dist/shared/constants/api.d.ts

@@ -1,2 +1,4 @@
 export declare const DADATA_BASE_CACHE_URL: any;
 export declare const DADATA_BASE_CONSTANTS_URL: any;
+export declare const VITE_DADATA_BASE_CACHE_URL: any;
+export declare const VITE_DADATA_BASE_CONSTANTS_URL: any;

package/dist/shared/ui/ResponsiveContainer.d.ts

@@ -2,5 +2,6 @@ import { HTMLAttributes, ReactNode } from 'react';
 export interface IResponsiveContainerProps extends HTMLAttributes<HTMLDivElement> {
     children: ReactNode;
     className?: string;
+    offset?: boolean;
 }
-export declare const ResponsiveContainer: ({ children, className, ...props }: IResponsiveContainerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ResponsiveContainer: ({ children, offset, className, ...props }: IResponsiveContainerProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,20 @@
+import { FieldValues } from 'react-hook-form';
+import { TCommonFieldProps } from './model/types';
+import * as React from 'react';
+type TCheckboxControlClasses = {
+    root?: string;
+    wrapper?: string;
+    field?: string;
+    input?: string;
+    indicator?: string;
+    icon?: string;
+    label?: string;
+    message?: string;
+};
+export interface ICheckboxControlProps<T extends FieldValues> extends Omit<TCommonFieldProps<T>, 'label'> {
+    classes?: TCheckboxControlClasses;
+    label: React.ReactElement | string;
+    disabled?: boolean;
+}
+export declare const CheckboxControl: <T extends FieldValues>({ control, label, helperText, disabled, classes, ...props }: ICheckboxControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,15 @@
+import { FieldValues } from 'react-hook-form';
+import { TCommonFieldProps } from './model/types';
+import { IFieldAttachmentProps, TFieldAttachmentClasses, TFieldContainerConfig, TFieldWrapperClasses } from './ui';
+type TInputControlClasses = TFieldAttachmentClasses & TFieldWrapperClasses & {
+    root?: string;
+    input?: string;
+    message?: string;
+};
+export interface IInputControlProps<T extends FieldValues> extends TCommonFieldProps<T>, Omit<IFieldAttachmentProps, 'invalid' | 'isTouched'> {
+    size?: TFieldContainerConfig['size'];
+    disabled?: boolean;
+    classes?: TInputControlClasses;
+}
+export declare const InputControl: <T extends FieldValues>({ label, helperText, control, disabled, size, classes, badge, withValidateIcons, icon, onClickIcon, onKeyDownIcon, ...props }: IInputControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,19 @@
+import { FieldValues } from 'react-hook-form';
+import { TCommonFieldProps } from './model/types';
+import { IFieldAttachmentProps, TFieldAttachmentClasses, TFieldContainerConfig, TFieldWrapperClasses } from './ui';
+type TInputControlMaskClasses = TFieldAttachmentClasses & TFieldWrapperClasses & {
+    input?: string;
+    message?: string;
+    inputContainer?: string;
+};
+export interface InputControlMaskProps<T extends FieldValues> extends TCommonFieldProps<T>, Omit<IFieldAttachmentProps, 'invalid' | 'isTouched'> {
+    format: string;
+    mask?: string | string[];
+    allowEmptyFormatting?: boolean;
+    onInputChange?: (arg?: string) => void;
+    classes?: TInputControlMaskClasses;
+    size?: TFieldContainerConfig['size'];
+    disabled?: boolean;
+}
+export declare const InputControlMask: <T extends FieldValues>({ format, allowEmptyFormatting, mask, control, onInputChange, size, label, helperText, disabled, classes, badge, withValidateIcons, icon, onClickIcon, onKeyDownIcon, ...props }: InputControlMaskProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/{formControlElements → formElements}/SwitchControl.d.ts

@@ -1,16 +1,16 @@
 import { FieldValues } from 'react-hook-form';
-import { TControlledInputPrimitiveProps } from './model';
-interface ISwitchClasses {
-    wrapper: string;
-    input: string;
-    thumb: string;
-    textBlock: string;
-    label: string;
-    message: string;
-}
-export interface ISwitchControlProps<T extends FieldValues> extends TControlledInputPrimitiveProps<T> {
+import { TCommonFieldProps } from './model/types';
+type TSwitchControlClasses = {
+    root?: string;
+    input?: string;
+    thumb?: string;
+    textBlock?: string;
+    label?: string;
+    message?: string;
+};
+export interface ISwitchControlProps<T extends FieldValues> extends TCommonFieldProps<T> {
     disabled?: boolean;
-    classes?: Partial<ISwitchClasses>;
+    classes?: TSwitchControlClasses;
 }
 export declare const SwitchControl: <T extends FieldValues>({ disabled, classes, control, helperText, label, ...props }: ISwitchControlProps<T>) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,20 @@
+import { FieldValues } from 'react-hook-form';
+import { TCommonFieldProps } from './model/types';
+import { IFieldAttachmentProps, TFieldAttachmentClasses, TFieldContainerConfig, TFieldWrapperClasses } from './ui';
+type TTextareaControlClasses = TFieldAttachmentClasses & TFieldWrapperClasses & {
+    root?: string;
+    field?: string;
+    head?: string;
+    label?: string;
+    scrollArea?: string;
+    input?: string;
+    message?: string;
+};
+export interface ITextareaControlProps<T extends FieldValues> extends TCommonFieldProps<T>, Omit<IFieldAttachmentProps, 'invalid' | 'isTouched'> {
+    classes?: TTextareaControlClasses;
+    size?: TFieldContainerConfig['size'];
+    disabled?: boolean;
+    placeholder?: string;
+}
+export declare const TextareaControl: <T extends FieldValues>({ label, helperText, control, disabled, size, classes, badge, withValidateIcons, icon, onClickIcon, onKeyDownIcon, placeholder, ...props }: ITextareaControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/{formControlElements → formElements}/comboboxControl/ComboboxControl.d.ts

@@ -1,31 +1,26 @@
-import { Control, FieldValues, Path } from 'react-hook-form';
+import { FieldValues } from 'react-hook-form';
+import { TCommonFieldProps } from '../model/types';
+import { TFieldContainerConfig } from '../ui';
 import { TComboboxControlClasses } from './model/types';
 import * as React from 'react';
-type TSelectVariant = 'primary' | 'secondary';
 export interface SelectOption<ValueType> {
     value: ValueType;
     label: string | React.ReactElement;
 }
-export interface IComboboxControlProps<T extends FieldValues, ValueType> {
-    name: Path<T>;
-    control: Control<T>;
+export interface IComboboxControlProps<T extends FieldValues, ValueType> extends TCommonFieldProps<T> {
     options: SelectOption<ValueType>[];
-    label: string | React.ReactElement;
-    size?: 'sm' | 'md' | 'lg' | 'full';
-    helperText?: string | React.ReactElement;
+    size?: TFieldContainerConfig['size'];
     marker?: boolean;
-    variant?: TSelectVariant;
     isClearable?: boolean;
     defaultValue?: ValueType;
     noOptionsMessage?: string | React.ReactElement;
     disabled?: boolean;
     isMulti?: boolean;
     placeholder?: string | React.ReactElement;
+    isSearchable?: boolean;
+    classes?: TComboboxControlClasses;
     onClickIcon?: (...args: unknown[]) => unknown;
     onKeyDownIcon?: (event: React.KeyboardEvent) => unknown;
-    isSearchable?: boolean;
-    classes?: Partial<TComboboxControlClasses>;
     customChange?: (...args: unknown[]) => void;
 }
-export declare const ComboboxControl: <T extends FieldValues, ValueType>({ options, control, defaultValue, variant, isClearable, label, disabled, placeholder, helperText, noOptionsMessage, size, classes, isMulti, isSearchable, customChange, ...props }: IComboboxControlProps<T, ValueType>) => import("react/jsx-runtime").JSX.Element;
-export {};
+export declare const ComboboxControl: <T extends FieldValues, ValueType>({ options, control, defaultValue, isClearable, label, disabled, placeholder, helperText, noOptionsMessage, size, classes, isMulti, isSearchable, customChange, ...props }: IComboboxControlProps<T, ValueType>) => import("react/jsx-runtime").JSX.Element;

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

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

package/dist/shared/ui/formElements/comboboxControl/model/types.d.ts

@@ -0,0 +1,37 @@
+export type TComboboxControlClasses = TComboboxControlClassesCommon & TComboboxChildClasses & {};
+export type TComboboxControlClassesCommon = {
+    messageCombobox?: string;
+    selectWrapper?: string;
+    dropdownIndicator?: string;
+    indicatorsContainer?: string;
+    inputCombobox?: string;
+    valueContainer?: string;
+    controlCombobox?: string;
+    containerCombobox?: string;
+    menuList?: string;
+    menuCombobox?: string;
+    groupCombobox?: string;
+    menuPortal?: string;
+    optionCombobox?: string;
+    noOptionsMessage?: string;
+    singleValue?: string;
+    multiValue?: string;
+    multiValueLabel?: string;
+    multiValueRemove?: string;
+    placeholderCombobox?: string;
+    indicatorSeparator?: string;
+    fieldLabel?: string;
+    message?: string;
+};
+export type TComboboxChildClasses = TMultiValueRemoveClasses | TComboboxOptionClasses | TDropdownIndicatorClasses;
+export type TMultiValueRemoveClasses = {
+    multiRemoveIcon?: string;
+};
+export type TComboboxOptionClasses = {
+    optionCustom?: string;
+    checkboxIsMulti?: string;
+    checkboxIsMultiIcon?: string;
+};
+export type TDropdownIndicatorClasses = {
+    indicatorIcon?: string;
+};

package/dist/shared/ui/{formControlElements → formElements}/comboboxControl/ui/ComboboxOption.d.ts

@@ -1,7 +1,7 @@
 import { OptionProps } from 'react-select';
 import { TComboboxOptionClasses } from '../model/types';
 interface IComboboxOptionProps<Option> extends OptionProps<Option> {
-    classes?: Partial<TComboboxOptionClasses>;
+    classes?: TComboboxOptionClasses;
     isSelected: boolean;
 }
 export declare const ComboboxOption: <Option>({ isSelected, classes, ...props }: IComboboxOptionProps<Option>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/{formControlElements → formElements}/comboboxControl/ui/DropdownIndicator.d.ts

@@ -1,7 +1,7 @@
 import { DropdownIndicatorProps } from 'react-select';
 import { TDropdownIndicatorClasses } from '../model/types';
 interface IDropdownIndicatorProps<Option> extends DropdownIndicatorProps<Option> {
-    classes?: Partial<TDropdownIndicatorClasses>;
+    classes?: TDropdownIndicatorClasses;
 }
 export declare const DropdownIndicator: <Option>({ classes, ...props }: IDropdownIndicatorProps<Option>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/{formControlElements → formElements}/comboboxControl/ui/MultiValueRemove.d.ts

@@ -1,7 +1,7 @@
 import { MultiValueRemoveProps } from 'react-select';
 import { TMultiValueRemoveClasses } from '../model/types';
 interface IMultiValueRemoveProps extends MultiValueRemoveProps {
-    classes?: Partial<TMultiValueRemoveClasses>;
+    classes?: TMultiValueRemoveClasses;
 }
 export declare const MultiValueRemove: ({ classes, ...props }: IMultiValueRemoveProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/formElements/dadataControl/DadataAddress.d.ts

@@ -0,0 +1,3 @@
+import { FieldValues } from 'react-hook-form';
+import { IDadataProps } from './types';
+export declare const DadataAddress: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/DadataAuto.d.ts

@@ -0,0 +1,3 @@
+import { FieldValues } from 'react-hook-form';
+import { IDadataProps } from './types';
+export declare const DadataAuto: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/DadataCountry.d.ts

@@ -0,0 +1,3 @@
+import { FieldValues } from 'react-hook-form';
+import { IDadataProps } from './types';
+export declare const DadataCountry: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/DadataFio.d.ts

@@ -0,0 +1,3 @@
+import { FieldValues } from 'react-hook-form';
+import { IDadataProps } from './types';
+export declare const DadataFio: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/{formControlElements → formElements}/dadataControl/DadataOrganization.d.ts

@@ -1,3 +1,3 @@
 import { FieldValues } from 'react-hook-form';
 import { IDadataProps } from './types';
-export declare const DadataOrganization: <T extends FieldValues>({ control, name, label, baseUrl, ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;
+export declare const DadataOrganization: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/autocompleteDadata/AutocompleteDadata.d.ts

@@ -0,0 +1,26 @@
+import { FieldValues } from 'react-hook-form';
+import { TCommonFieldProps } from '../../model/types';
+import { IFieldAttachmentProps, TFieldAttachmentClasses, TFieldContainerConfig, TFieldWrapperClasses } from '../../ui';
+import { TDadataType } from './model/types';
+export type TAutocompleteDadataClasses = TFieldAttachmentClasses & TFieldWrapperClasses & {
+    root?: string;
+    input?: string;
+    message?: string;
+    options?: string;
+    optionsScrollArea?: string;
+    option?: string;
+    optionValueView?: string;
+    optionSuggestionValue?: string;
+    optionAdditionalText?: string;
+    optionEmptySuggestionValue?: string;
+};
+export interface IAutocompleteDadataProps<T extends FieldValues> extends TCommonFieldProps<T>, Omit<IFieldAttachmentProps, 'invalid' | 'isTouched'> {
+    classes?: TAutocompleteDadataClasses;
+    dadataType: TDadataType;
+    dadataBaseUrl: string;
+    size?: TFieldContainerConfig['size'];
+    disabled?: boolean;
+    customChangeInput?: (...args: unknown[]) => void;
+    customChangeOption?: (...args: unknown[]) => void;
+}
+export declare const AutocompleteDadata: <T extends FieldValues>({ dadataType, dadataBaseUrl, label, helperText, control, disabled, size, classes, badge, withValidateIcons, icon, onClickIcon, onKeyDownIcon, customChangeInput, customChangeOption, ...props }: IAutocompleteDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

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

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

package/dist/shared/ui/{formControlElements → formElements}/dadataControl/autocompleteDadata/model/types.d.ts

@@ -1,5 +1,4 @@
 export type TDadataType = 'address' | 'fio' | 'country' | 'auto' | 'party';
-export type TDadataBaseUrl = 'cache' | 'constants';
 export type TDadataOption = {
     value: string;
     additionalText?: string;

package/dist/shared/ui/formElements/dadataControl/autocompleteDadata/ui/ComboboxOptionsCustom.d.ts

@@ -0,0 +1,8 @@
+import { TAutocompleteDadataClasses } from '../AutocompleteDadata';
+import { TDadataOption } from '../model/types';
+interface IComboboxOptionsProps {
+    suggestionsOptions: TDadataOption[] | null;
+    classes?: Omit<TAutocompleteDadataClasses, 'root' | 'input' | 'message'>;
+}
+export declare const ComboboxOptionsCustom: ({ suggestionsOptions, classes }: IComboboxOptionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+export * from './DadataFio';
+export * from './DadataAuto';
+export * from './DadataCountry';
+export * from './DadataAddress';
+export * from './DadataOrganization';
+export type * from './types';

package/dist/shared/ui/formElements/dadataControl/types.d.ts

@@ -0,0 +1,5 @@
+import { FieldValues } from 'react-hook-form';
+import { IAutocompleteDadataProps, TAutocompleteDadataClasses } from './autocompleteDadata';
+export interface IDadataProps<T extends FieldValues> extends Omit<IAutocompleteDadataProps<T>, 'dadataType'> {
+    classes?: TAutocompleteDadataClasses;
+}

package/dist/shared/ui/formElements/editorControl/EditorControl.d.ts

@@ -0,0 +1,19 @@
+import { ReactElement } from 'react';
+import { FieldValues } from 'react-hook-form';
+import { TCommonFieldProps } from '../model/types';
+export type TEditorControlClasses = {
+    root?: string;
+    editor?: string;
+    wrapper?: string;
+    message?: string;
+    label?: string;
+};
+export interface ICommonEditorProps {
+    editable?: boolean;
+    helperText?: string | ReactElement;
+    label?: string;
+}
+export type IEditorControlProps<T extends FieldValues> = TCommonFieldProps<T> & ICommonEditorProps & {
+    classes?: TEditorControlClasses;
+};
+export declare const EditorControl: <T extends FieldValues>({ control, label, helperText, editable, classes, ...props }: IEditorControlProps<T>) => import("react/jsx-runtime").JSX.Element;

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

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

package/dist/shared/ui/formElements/editorControl/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/{formControlElements → formElements}/editorControl/ui/Editor.d.ts

@@ -4,7 +4,7 @@ interface IEditorProps extends ICommonEditorProps {
     onChange: (value: string) => void;
     value: string;
     error?: FieldError;
-    classes?: Partial<TEditorControlClasses>;
+    classes?: TEditorControlClasses;
 }
-export declare const Editor: ({ onChange, value, label, error, classes, editable, helperText }: IEditorProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const Editor: ({ onChange, value, label, error, classes, editable, helperText, ...props }: IEditorProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -0,0 +1,13 @@
+export * from './InputControl';
+export * from './InputControlMask';
+export * from './CheckboxControl';
+export * from './SwitchControl';
+export * from './TextareaControl';
+export * from './dadataControl';
+export * from './comboboxControl';
+export * from './sliderControl';
+export * from './editorControl';
+export * from './uploaderControl';
+export * from './radioControl';
+export * from './inputCurrencyControl';
+export * from './FormControl';

package/dist/shared/ui/{formControlElements → formElements}/inputCurrencyControl/InputCurrencyControl.d.ts

@@ -1,13 +1,16 @@
 import { FieldValues } from 'react-hook-form';
-import { TControlledInputProps, TInputCommonProps } from '../model';
+import { TCommonFieldProps } from '../model/types';
+import { IFieldAttachmentProps, TFieldContainerConfig } from '../ui';
 export type TCurrencyVariant = 'euro' | 'dollars' | 'rubles' | 'yuan' | 'dirhams';
 export interface ICurrencyOption {
     ruName: string;
     engName: string;
     currency: TCurrencyVariant;
 }
-export interface InputCurrencyControlProps<T extends FieldValues> extends TControlledInputProps<T>, TInputCommonProps {
+export interface InputCurrencyControlProps<T extends FieldValues> extends TCommonFieldProps<T>, Omit<IFieldAttachmentProps, 'invalid' | 'isTouched'> {
     classes?: any;
     defaultCurrency?: TCurrencyVariant;
+    disabled?: boolean;
+    size?: TFieldContainerConfig['size'];
 }
 export declare const InputCurrencyControl: <T extends FieldValues>({ label, size, helperText, control, classes, disabled, defaultCurrency, ...props }: InputCurrencyControlProps<T>) => import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,7 @@
+import { Control, FieldValues, Path } from 'react-hook-form';
+export type TCommonFieldProps<T extends FieldValues> = {
+    name: Path<T>;
+    control: Control<T>;
+    label: string;
+    helperText?: string;
+};

package/dist/shared/ui/{formControlElements → formElements/radioControl}/RadioControl.d.ts

@@ -1,14 +1,20 @@
 import { FieldValues } from 'react-hook-form';
 import { VariantProps } from 'class-variance-authority';
-import { TAdditionalInputPrimitiveClasses, TControlledInputPrimitiveProps } from './model';
+import { TCommonFieldProps } from '../model/types';
 declare const radioOptionsConfig: (props?: ({
     orientation?: "horizontal" | "vertical" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-type TRadioClasses = Partial<TAdditionalInputPrimitiveClasses> & {
+export type TRadioClasses = {
+    root?: string;
     groupName?: string;
+    field?: string;
+    message?: string;
     radioGroup?: string;
+    radioLabel?: string;
+    radioIndicator?: string;
+    radioInput?: string;
+    radio?: string;
     radioOption?: string;
-    indicator?: string;
 };
 export interface IRadioGroupOption {
     label: string;
@@ -16,11 +22,11 @@ export interface IRadioGroupOption {
     isDisabled?: boolean;
 }
 type TRadioOptionsConfig = VariantProps<typeof radioOptionsConfig>;
-export interface IRadioControlProps<T extends FieldValues> extends TRadioOptionsConfig, Omit<TControlledInputPrimitiveProps<T>, 'label'> {
+export interface IRadioControlProps<T extends FieldValues> extends TRadioOptionsConfig, Omit<TCommonFieldProps<T>, 'label'> {
     radioItemsGroup: IRadioGroupOption[];
     groupName?: string;
     classes?: TRadioClasses;
-    label?: never;
+    disabled?: boolean;
 }
 export declare const RadioControl: <T extends FieldValues>({ radioItemsGroup, control, groupName, helperText, disabled, classes, orientation, ...props }: IRadioControlProps<T>) => import("react/jsx-runtime").JSX.Element;
 export {};

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

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

package/dist/shared/ui/formElements/radioControl/ui/RadioGroupCustom.d.ts

@@ -0,0 +1,8 @@
+import { IRadioGroupOption, TRadioClasses } from '../RadioControl';
+interface IRadioGroupCustomProps {
+    radioItemsGroup: IRadioGroupOption[];
+    classes?: Omit<TRadioClasses, 'root' | 'message' | 'field' | 'groupName'>;
+    error?: boolean;
+}
+export declare const RadioGroupCustom: ({ radioItemsGroup, classes, error }: IRadioGroupCustomProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/shared/ui/formElements/sliderControl/SliderControl.d.ts

@@ -0,0 +1,31 @@
+import { FieldValues } from 'react-hook-form';
+import { TCommonFieldProps } from '../model/types';
+import { IFieldAttachmentProps, TFieldAttachmentClasses, TFieldContainerConfig, TFieldWrapperClasses } from '../ui';
+import { TSliderVariants } from './model/types';
+import { TSliderClasses } from './ui';
+import * as React from 'react';
+export interface ISliderCommonProps {
+    min: number;
+    max: number;
+    variant: TSliderVariants;
+    step?: number;
+}
+type TSliderControlClasses = TFieldAttachmentClasses & TFieldWrapperClasses & TSliderClasses & {
+    spanLeft?: string;
+    spanRight?: string;
+    sliderContainer?: string;
+    sliderRoot?: string;
+    input?: string;
+    message?: string;
+    textWrapper?: string;
+};
+export interface ISliderControlProps<T extends FieldValues> extends TCommonFieldProps<T>, ISliderCommonProps, Omit<IFieldAttachmentProps, 'invalid' | 'isTouched'> {
+    classes?: TSliderControlClasses;
+    disabled?: boolean;
+    size?: TFieldContainerConfig['size'];
+    onInputChange?: (value?: number, ...args: unknown[]) => void;
+    leftText?: string | React.ReactElement;
+    rightText?: string | React.ReactElement;
+}
+export declare const SliderControl: <T extends FieldValues>({ label, size, helperText, control, classes, disabled, onInputChange, min, max, variant, leftText, rightText, badge, withValidateIcons, icon, onClickIcon, onKeyDownIcon, ...props }: ISliderControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/shared/ui/formElements/sliderControl/ui/Slider.d.ts

@@ -0,0 +1,17 @@
+import { ISliderCommonProps } from '../SliderControl';
+import * as React from 'react';
+export type TSliderClasses = {
+    sliderWrapper?: string;
+    sliderRoot?: string;
+    spanLeft?: string;
+    spanRight?: string;
+    sliderTrack?: string;
+    sliderThumb?: string;
+    sliderRange?: string;
+};
+export interface ISliderProps extends ISliderCommonProps {
+    classes?: TSliderClasses;
+    onValueChange?: (value: number[]) => void;
+    value: number[];
+}
+export declare const Slider: React.ForwardRefExoticComponent<ISliderProps & React.RefAttributes<HTMLSpanElement>>;

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

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

package/dist/shared/ui/{formControlElements → formElements}/ui/FieldContainer.d.ts

@@ -1,15 +1,12 @@
 import { VariantProps } from 'class-variance-authority';
-import { TFieldContainerClasses } from '../model/classes-types';
 import * as React from 'react';
 declare const fieldContainerConfig: (props?: ({
-    intent?: "filled" | "clear" | null | undefined;
     size?: "sm" | "md" | "lg" | "full" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export type TFieldContainerConfig = VariantProps<typeof fieldContainerConfig>;
 interface IFieldContainerProps extends TFieldContainerConfig {
-    classes?: Partial<TFieldContainerClasses>;
+    className?: string;
     children: React.ReactNode;
-    intent?: 'clear' | 'filled' | null;
 }
-export declare const FieldContainer: ({ size, intent, classes, children }: IFieldContainerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FieldContainer: ({ size, className, children }: IFieldContainerProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,19 @@
+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;
+}
+export declare const FieldAttachment: ({ badge, invalid, isTouched, withValidateIcons, icon, onClickIcon, onKeyDownIcon, classes }: 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'> {
+    classes?: Pick<TFieldAttachmentClasses, 'icon'>;
+}
+export declare const IconSlot: ({ onClickIcon, onKeyDownIcon, icon, classes }: 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/fieldWrapper/FieldWrapper.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+export type TFieldWrapperClasses = {
+    fieldWrapperRoot?: string;
+    fieldLabel?: string;
+};
+export interface IFieldWrapperProps<V> {
+    children: React.ReactNode;
+    label: string;
+    disabled?: boolean;
+    fieldId: string;
+    value: V;
+    error?: boolean;
+    classes?: TFieldWrapperClasses;
+}
+export declare const FieldWrapper: <V>({ children, error, disabled, classes, label, value, fieldId }: IFieldWrapperProps<V>) => import("react/jsx-runtime").JSX.Element;

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

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

package/dist/shared/ui/formElements/ui/fieldWrapper/ui/FieldLabel.d.ts

@@ -0,0 +1,6 @@
+import { IFieldWrapperProps, TFieldWrapperClasses } from '../FieldWrapper';
+interface IFieldLabelProps<V> extends Omit<IFieldWrapperProps<V>, 'error' | 'children' | 'classes'> {
+    classes?: Pick<TFieldWrapperClasses, 'fieldLabel'>;
+}
+export declare const FieldLabel: <V>({ disabled, fieldId, label, value, classes }: IFieldLabelProps<V>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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