@scbt-ecom/ui 0.0.30 → 0.0.32

package/dist/shared/ui/calendar/model/classes.d.ts

@@ -0,0 +1,24 @@
+export declare const dayPickerClasses: (isRange?: boolean) => {
+    weekday: string;
+    months: string;
+    month: string;
+    caption: string;
+    today: string;
+    outside: string;
+    disabled: string;
+    hidden: string;
+    selected: string;
+    range_middle: string;
+    range_end: string;
+    range_start: string;
+    day: string;
+    day_button: string;
+    nav: string;
+    nav_button: string;
+    nav_button_previous: string;
+    nav_button_next: string;
+    table: string;
+    head_row: string;
+    head_cell: string;
+    row: string;
+};

package/dist/shared/ui/calendar/model/helpers.d.ts

@@ -0,0 +1,9 @@
+export declare const MONTHS_OPTIONS: string[];
+export declare const DAYS_OF_WEEK: ({
+    day: string;
+    isWeekend?: undefined;
+} | {
+    day: string;
+    isWeekend: boolean;
+})[];
+export declare const YEARS_OPTIONS: number[];

package/dist/shared/ui/calendar/model/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useDatePicker, type TControlledDate } from './useDatePicker';
+export { useCalendarDropdowns } from './useCalendarDropdowns';

package/dist/shared/ui/calendar/model/hooks/useCalendarDropdowns.d.ts

@@ -0,0 +1,9 @@
+export declare const useCalendarDropdowns: () => {
+    calendarSetter: (val?: boolean) => void;
+    toggleCalendar: (onClickIcon?: (...args: unknown[]) => unknown) => void;
+    isMonthOpen: boolean;
+    toggleMonthDropdown: () => void;
+    isYearsOpen: boolean;
+    toggleYearDropdown: () => void;
+    isCalendarOpen: boolean;
+};

package/dist/shared/ui/calendar/model/hooks/useDatePicker.d.ts

@@ -0,0 +1,19 @@
+import { TCalendarMode } from '../../Calendar';
+import * as React from 'react';
+export type TControlledDate = {
+    day: number;
+    month: number;
+    year: number;
+};
+export declare const useDatePicker: () => {
+    formattedControlledDate: Date;
+    controlledDate: TControlledDate;
+    setControlledDate: React.Dispatch<React.SetStateAction<TControlledDate>>;
+    onClickDay: (date: Date, onChange: (...event: unknown[]) => void, mode: TCalendarMode, closeCalendar: () => void) => void;
+    onChangeMonth: (date: Date, onChange: (...event: unknown[]) => void) => void;
+    onSelectMonth: (month: number, onChange: (...event: unknown[]) => void) => void;
+    onSelectYear: (year: number, onChange: (...event: unknown[]) => void) => void;
+    onBlurInput: (inputValue: string, onChange: (...event: unknown[]) => void) => void;
+    onClickPrev: (event: React.MouseEvent<HTMLButtonElement>, onPreviousClick?: React.MouseEventHandler<HTMLButtonElement>) => void;
+    onClickNext: (event: React.MouseEvent<HTMLButtonElement>, onNextClick?: React.MouseEventHandler<HTMLButtonElement>) => void;
+};

package/dist/shared/ui/calendar/ui/CalendarHeader.d.ts

@@ -0,0 +1,15 @@
+import { NavProps } from 'react-day-picker';
+import { TControlledDate } from '../model/hooks';
+interface ICalendarHeaderProps extends NavProps {
+    controlledDate: TControlledDate;
+    isMonthOpen: boolean;
+    toggleMonthDropdown: () => void;
+    isYearsOpen: boolean;
+    toggleYearDropdown: () => void;
+    onSelectMonth: (month: number) => void;
+    onSelectYear: (year: number) => void;
+    onClickPrev: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    onClickNext: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}
+export declare const CalendarHeader: ({ onSelectMonth, onSelectYear, onClickPrev, onClickNext, controlledDate, isMonthOpen, toggleMonthDropdown, isYearsOpen, toggleYearDropdown }: ICalendarHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/Dropdown.d.ts

@@ -0,0 +1,10 @@
+interface IDropdownProps<Value extends string | number> {
+    options: Value[];
+    isActive: boolean;
+    selectedDate: Value;
+    onClickTrigger: () => void;
+    onClickOption: (value: number) => void;
+    variant?: 'months' | 'years';
+}
+export declare const Dropdown: <Value extends string | number>({ options, isActive, selectedDate, onClickTrigger, onClickOption, variant }: IDropdownProps<Value>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/NavigationArrows.d.ts

@@ -0,0 +1,5 @@
+import { NavProps } from 'react-day-picker';
+interface INavigationArrowsProps extends NavProps {
+}
+export declare const NavigationArrows: ({ onPreviousClick, onNextClick }: INavigationArrowsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/Weekdays.d.ts

@@ -0,0 +1 @@
+export declare const Weekdays: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { Weekdays } from './Weekdays';
+export { CalendarHeader } from './CalendarHeader';

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

@@ -0,0 +1,13 @@
+import { FieldValues } from 'react-hook-form';
+import { TAdditionalInputPrimitiveClasses, TControlledInputPrimitiveProps } from './model';
+import * as React from 'react';
+type TCheckboxClasses = Partial<TAdditionalInputPrimitiveClasses> & {
+    wrapper?: string;
+    indicator?: string;
+};
+export interface ICheckboxControlProps<T extends FieldValues> extends Omit<TControlledInputPrimitiveProps<T>, 'label'> {
+    classes?: TCheckboxClasses;
+    label: React.ReactElement | string;
+}
+export declare const CheckboxControl: <T extends FieldValues>({ control, helperText, label, disabled, classes, ...props }: ICheckboxControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/FormControl.d.ts

@@ -0,0 +1,3 @@
+export interface IFormControlProps {
+}
+export declare const FormControl: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,6 @@
+import { FieldValues } from 'react-hook-form';
+import { TAdditionalInputClassesWithAttachment, TControlledInputProps, TInputCommonProps } from './model';
+export interface InputControlProps<T extends FieldValues> extends TControlledInputProps<T>, TInputCommonProps {
+    classes?: Partial<TAdditionalInputClassesWithAttachment>;
+}
+export declare const InputControl: <T extends FieldValues>({ label, size, helperText, control, classes, badge, icon, swapPosition, disabled, ...props }: InputControlProps<T>) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { FieldValues } from 'react-hook-form';
+import { TAdditionalInputClassesWithAttachment, TControlledInputProps, TInputCommonProps } from './model';
+export interface InputControlMaskProps<T extends FieldValues> extends TControlledInputProps<T>, TInputCommonProps {
+    format: string;
+    mask?: string | string[];
+    allowEmptyFormatting?: boolean;
+    onInputChange?: (arg?: string) => void;
+    classes?: Partial<TAdditionalInputClassesWithAttachment>;
+}
+export declare const InputControlMask: <T extends FieldValues>({ format, allowEmptyFormatting, mask, control, onInputChange, size, helperText, label, classes, disabled, badge, icon, swapPosition, ...props }: InputControlMaskProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formControlElements/RadioControl.d.ts

@@ -0,0 +1,26 @@
+import { FieldValues } from 'react-hook-form';
+import { VariantProps } from 'class-variance-authority';
+import { TAdditionalInputPrimitiveClasses, TControlledInputPrimitiveProps } from './model';
+declare const radioOptionsConfig: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type TRadioClasses = Partial<TAdditionalInputPrimitiveClasses> & {
+    groupName?: string;
+    radioGroup?: string;
+    radioOption?: string;
+    indicator?: string;
+};
+export interface IRadioGroupOption {
+    label: string;
+    value: string;
+    isDisabled?: boolean;
+}
+type TRadioOptionsConfig = VariantProps<typeof radioOptionsConfig>;
+export interface IRadioControlProps<T extends FieldValues> extends TRadioOptionsConfig, Omit<TControlledInputPrimitiveProps<T>, 'label'> {
+    radioItemsGroup: IRadioGroupOption[];
+    groupName?: string;
+    classes?: TRadioClasses;
+    label?: never;
+}
+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/formControlElements/SelectControl.d.ts

@@ -0,0 +1,27 @@
+import { FieldValues } from 'react-hook-form';
+import { TControlledInputProps } from './model';
+interface ISelectControlClasses {
+    trigger: string;
+    options: string;
+    scrollArea: string;
+    option: string;
+    icon: string;
+    message: string;
+    value: string;
+    label: string;
+}
+export interface ISelectOption {
+    id: string;
+    optionValue: string;
+    isDisabled?: boolean;
+}
+export interface ISelectControlProps<T extends FieldValues> extends TControlledInputProps<T> {
+    classes?: Partial<ISelectControlClasses>;
+    optionsList: ISelectOption[];
+    label: string;
+    multiple?: boolean;
+    intent?: 'filled' | 'clear';
+    disabled?: boolean;
+}
+export declare const SelectControl: <T extends FieldValues>({ size, control, helperText, disabled, classes, optionsList, label, multiple, intent, ...props }: ISelectControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/SwitchControl.d.ts

@@ -0,0 +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> {
+    disabled?: boolean;
+    classes?: Partial<ISwitchClasses>;
+}
+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/formControlElements/TextareaControl.d.ts

@@ -0,0 +1,11 @@
+import { FieldValues } from 'react-hook-form';
+import { TAdditionalInputClassesWithAttachment, TControlledInputProps, TTextareaCommonProps } from './model';
+type TTextareaClasses = Partial<TAdditionalInputClassesWithAttachment> & {
+    head: string;
+    scrollArea: string;
+};
+export interface ITextareaControlProps<T extends FieldValues> extends TControlledInputProps<T>, TTextareaCommonProps {
+    classes?: Partial<TTextareaClasses>;
+}
+export declare const TextareaControl: <T extends FieldValues>({ label, size, helperText, control, classes, badge, icon, swapPosition, disabled, placeholder, ...props }: ITextareaControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/calendarControl/CalendarControl.d.ts

@@ -0,0 +1,13 @@
+import { FieldValues } from 'react-hook-form';
+import { TControlledInputProps } from '../model';
+import { TCalendarClasses } from './model/types';
+export interface ICalendarControlProps<T extends FieldValues> extends TControlledInputProps<T> {
+    maskFormat?: string;
+    mask?: string | string[];
+    allowEmptyFormatting?: boolean;
+    classes?: Partial<TCalendarClasses>;
+    disabled?: boolean;
+    onClickIcon?: (...args: unknown[]) => unknown;
+    defaultValue?: string;
+}
+export declare const CalendarControl: <T extends FieldValues>({ control, classes, label, disabled, maskFormat, allowEmptyFormatting, mask, size, helperText, icon, badge, swapPosition, onClickIcon, defaultValue, ...props }: ICalendarControlProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formControlElements/calendarControl/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useCalendarDropdowns } from './useCalendarDropdowns';
+export { useCalendar } from './useCalendar';

package/dist/shared/ui/formControlElements/calendarControl/hooks/useCalendar.d.ts

@@ -0,0 +1,16 @@
+export declare const useCalendar: (calendarValue: string) => {
+    memoDaysOfMonth: import('date-fns').EachDayOfIntervalResult<{
+        start: Date;
+        end: Date;
+    }, undefined>;
+    firstDayOfMonth: Date;
+    selectedDay: string;
+    selectedMonth: string;
+    selectedYear: string;
+    formattedMonth: string;
+    onSelectDay: (day: Date, onChange: (...event: unknown[]) => void) => void;
+    onSelectMonth: (month: number, onChange: (...event: unknown[]) => void) => void;
+    onSelectYear: (year: number, onChange: (...event: unknown[]) => void) => void;
+    onBlurInput: (inputValue: string, onChange: (...event: unknown[]) => void) => void;
+    onChangeMonth: (event: React.MouseEvent<HTMLButtonElement>, onChange: (...event: unknown[]) => void, mode: "prev" | "next") => void;
+};

package/dist/shared/ui/formControlElements/calendarControl/hooks/useCalendarDropdowns.d.ts

@@ -0,0 +1,9 @@
+export declare const useCalendarDropdowns: () => {
+    calendarSetter: (val?: boolean) => void;
+    toggleCalendar: (onClickIcon?: (...args: unknown[]) => unknown) => void;
+    isMonthOpen: boolean;
+    toggleMonthDropdown: () => void;
+    isYearsOpen: boolean;
+    toggleYearDropdown: () => void;
+    isCalendarOpen: boolean;
+};

package/{lib/shared/ui/formControlElements/calendarControl/index.ts → dist/shared/ui/formControlElements/calendarControl/index.d.ts}

@@ -1 +1 @@
-export { CalendarControl, type ICalendarControlProps } from './CalendarControl'
+export { CalendarControl, type ICalendarControlProps } from './CalendarControl';

package/dist/shared/ui/formControlElements/calendarControl/model/helpers.d.ts

@@ -0,0 +1,24 @@
+import { TDayOfWeek } from './types';
+export declare const capitalizeFirstLetter: (query: string) => string;
+export declare const colStartClasses: string[];
+export declare const calendarAnimation: {
+    initial: {
+        opacity: number;
+        y: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+    };
+    exit: {
+        opacity: number;
+        y: number;
+    };
+    transition: {
+        duration: number;
+        ease: string;
+    };
+};
+export declare const YEARS_OPTIONS: number[];
+export declare const DAYS_OF_WEEK: TDayOfWeek[];
+export declare const MONTHS_OPTIONS: string[];

package/dist/shared/ui/formControlElements/calendarControl/model/types.d.ts

@@ -0,0 +1,33 @@
+import { TAdditionalInputClassesWithAttachment } from '../../model';
+export type TDayOfWeek = {
+    day: string;
+    isWeekend?: boolean;
+};
+export type TDaysOfMonthClasses = {
+    monthWrapper: string;
+    button: string;
+    day: string;
+};
+export type TDaysOfWeekClasses = {
+    weekWrapper: string;
+    weekDay: string;
+};
+export type TNavigationClasses = {
+    navigationWrapper: string;
+    swipeButton: string;
+    arrowIcon: string;
+};
+export type TDropdownClasses = {
+    dropdownWrapper: string;
+    dropdownTrigger: string;
+    dropdownIcon: string;
+    dropdownOverlay: string;
+    dropdownOptions: string;
+    dropdownOption: string;
+    dropdowns: string;
+};
+export type TCalendarClasses = Partial<TDayOfWeek> & Partial<TDaysOfMonthClasses> & Partial<TDaysOfWeekClasses> & Partial<TNavigationClasses> & Partial<TDropdownClasses> & Partial<TAdditionalInputClassesWithAttachment> & {
+    rootWrapper: string;
+    calendarWrapper: string;
+    calendarHeader: string;
+};

package/dist/shared/ui/formControlElements/calendarControl/ui/DaysOfMonth.d.ts

@@ -0,0 +1,10 @@
+import { TDaysOfMonthClasses } from '../model/types';
+interface IDaysOfMonthProps {
+    daysList: Date[];
+    selectedDay: number;
+    firstDayOfMonth: Date;
+    onSelectDay: (day: Date) => void;
+    classes?: Partial<TDaysOfMonthClasses>;
+}
+export declare const DaysOfMonth: ({ daysList, firstDayOfMonth, selectedDay, onSelectDay, classes }: IDaysOfMonthProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/calendarControl/ui/DaysOfWeek.d.ts

@@ -0,0 +1,6 @@
+import { TDaysOfWeekClasses } from '../model/types';
+interface IDaysOfWeekProps {
+    classes?: Partial<TDaysOfWeekClasses>;
+}
+export declare const DaysOfWeek: ({ classes }: IDaysOfWeekProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/calendarControl/ui/Dropdown.d.ts

@@ -0,0 +1,11 @@
+import { TDropdownClasses } from '../model/types';
+export interface IDropdownProps<Value extends string | number> {
+    options: Value[];
+    selectedValue: string;
+    isActive: boolean;
+    onClickTrigger: () => void;
+    onClickOption: (value: number) => void;
+    variant?: 'months' | 'years';
+    classes?: Partial<TDropdownClasses>;
+}
+export declare const Dropdown: <Value extends string | number>({ onClickTrigger, isActive, selectedValue, options, variant, onClickOption, classes }: IDropdownProps<Value>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formControlElements/calendarControl/ui/Header.d.ts

@@ -0,0 +1,14 @@
+import { TDropdownClasses } from '../model/types';
+interface IHeaderProps {
+    month: string;
+    year: string;
+    isYearsOpen: boolean;
+    isMonthOpen: boolean;
+    toggleMonthDropdown: () => void;
+    toggleYearDropdown: () => void;
+    onSelectMonth: (month: number) => void;
+    onSelectYear: (year: number) => void;
+    classes?: Partial<TDropdownClasses>;
+}
+export declare const Header: ({ isMonthOpen, isYearsOpen, toggleMonthDropdown, toggleYearDropdown, onSelectMonth, onSelectYear, month, year, classes }: IHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/calendarControl/ui/Navigation.d.ts

@@ -0,0 +1,9 @@
+import { MouseEventHandler } from 'react';
+import { TNavigationClasses } from '../model/types';
+interface INavigationProps {
+    onClickPrevMonth: MouseEventHandler<HTMLButtonElement>;
+    onClickNextMonth: MouseEventHandler<HTMLButtonElement>;
+    classes?: Partial<TNavigationClasses>;
+}
+export declare const Navigation: ({ onClickPrevMonth, onClickNextMonth, classes }: INavigationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/calendarControl/ui/OptionsList.d.ts

@@ -0,0 +1,5 @@
+import { IDropdownProps } from './Dropdown';
+interface IOptionsListProps<Value extends string | number> extends Omit<IDropdownProps<Value>, 'onClickTrigger'> {
+}
+export declare const OptionsList: <Value extends string | number>({ isActive, variant, options, onClickOption, selectedValue, classes }: IOptionsListProps<Value>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/calendarControl/ui/index.d.ts

@@ -0,0 +1,4 @@
+export { DaysOfWeek } from './DaysOfWeek';
+export { Navigation } from './Navigation';
+export { DaysOfMonth } from './DaysOfMonth';
+export { Header } from './Header';

package/dist/shared/ui/formControlElements/dadata/DadataInputControl.d.ts

@@ -0,0 +1,14 @@
+import { FieldValues } from 'react-hook-form';
+import { TAdditionalInputClassesWithAttachment, TControlledInputProps, TInputCommonProps } from '../model';
+import { TDadataBaseUrl, TDadataType } from './model/types';
+type TDadataClasses = Partial<TAdditionalInputClassesWithAttachment> & {
+    options?: string;
+    indentMargin?: string;
+};
+export interface IDadataInputControlProps<T extends FieldValues> extends TControlledInputProps<T>, TInputCommonProps {
+    classes?: TDadataClasses;
+    dadataType?: TDadataType;
+    dadataBaseUrl?: TDadataBaseUrl;
+}
+export declare const DadataInputControl: <T extends FieldValues>({ control, helperText, classes, size, label, disabled, dadataType, dadataBaseUrl, badge, icon, swapPosition, ...props }: IDadataInputControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/{lib/shared/ui/formControlElements/dadata/index.ts → dist/shared/ui/formControlElements/dadata/index.d.ts}

@@ -1 +1 @@
-export { DadataInputControl, type IDadataInputControlProps } from './DadataInputControl'
+export { DadataInputControl, type IDadataInputControlProps } from './DadataInputControl';

package/dist/shared/ui/formControlElements/dadata/model/api.d.ts

@@ -0,0 +1,2 @@
+import { TDadataBaseUrl, TDadataType } from './types';
+export declare const fetchSuggestions: (searchText: string, dadataType: TDadataType, dadataBaseUrl: TDadataBaseUrl) => Promise<import('./types').IDadataCountryOption[] | import('./types').IDadataAutoOption[] | import('./types').IDadataCacheOption<unknown>[]>;

package/dist/shared/ui/formControlElements/dadata/model/helpers.d.ts

@@ -0,0 +1,7 @@
+import { IDadataAutoOption, IDadataCacheOption, IDadataCountryOption, TDadataBaseUrl, TDadataReturn, TDadataSuggestionType, TDadataType } from './types';
+export declare const getDadataBaseUrl: (baseUrl: TDadataBaseUrl) => any;
+export declare const getDataByDadataType: <T>(dadataType: TDadataType, data: TDadataReturn<T>) => IDadataCountryOption[] | IDadataAutoOption[] | IDadataCacheOption<T>[];
+export declare const getOptionsByDadataType: <T>(dadataType: TDadataType, suggestions: TDadataSuggestionType<T>) => {
+    value: string;
+    label: string;
+}[];

package/dist/shared/ui/formControlElements/dadata/model/types.d.ts

@@ -0,0 +1,42 @@
+export type TDadataType = 'address' | 'fio' | 'country' | 'auto' | 'party';
+export type TDadataBaseUrl = 'cache' | 'constants';
+export type TDadataOption = {
+    value: string;
+    additionalText?: string;
+    isDisabled?: boolean;
+};
+export interface IDadataCountryOption {
+    id: number;
+    country_name: string;
+}
+export interface IDadataConstantsCountrySuggestion {
+    matches: IDadataCountryOption[];
+}
+export interface IDadataAutoOption {
+    id: number;
+    mark: string;
+    model: string;
+    model_mark: string;
+    year_max: string;
+    year_min: string;
+}
+export interface IDadataConstantsAutoSuggestion {
+    matches: IDadataAutoOption[];
+}
+export interface IDadataCacheOption<T> {
+    value: string;
+    unrestricted_value: string;
+    data: T;
+}
+export interface IDadataCacheSuggestion<T> {
+    suggestions: IDadataCacheOption<T>[];
+}
+export interface IDadataOrganizationOption {
+    value: string;
+    unrestricted_value: string;
+    data: {
+        inn: 'string';
+    };
+}
+export type TDadataReturn<T> = IDadataConstantsCountrySuggestion | IDadataCacheSuggestion<T> | IDadataConstantsAutoSuggestion;
+export type TDadataSuggestionType<T> = IDadataCountryOption[] | IDadataCacheOption<T>[] | IDadataAutoOption[];

package/dist/shared/ui/formControlElements/dadata/model/useDadata.d.ts

@@ -0,0 +1,7 @@
+import { TDadataBaseUrl, TDadataOption, TDadataType } from './types';
+import * as React from 'react';
+export declare const useDadata: (dadataType: TDadataType, dadataBaseUrl: TDadataBaseUrl) => {
+    setQuery: React.Dispatch<React.SetStateAction<string>>;
+    suggestionsOptions: TDadataOption[] | null;
+    debounceQuery: string;
+};

package/{lib/shared/ui/formControlElements/index.ts → dist/shared/ui/formControlElements/index.d.ts}

@@ -1,10 +1,10 @@
-export { InputControl, type InputControlProps } from './InputControl'
-export { InputControlMask, type InputControlMaskProps } from './InputControlMask'
-export { FormControl } from './FormControl'
-export { DadataInputControl, type IDadataInputControlProps } from './dadata'
-export { CheckboxControl, type ICheckboxControlProps } from './CheckboxControl'
-export { RadioControl, type IRadioControlProps, type IRadioGroupOption } from './RadioControl'
-export { SwitchControl, type ISwitchControlProps } from './SwitchControl'
-export { SelectControl, type ISelectControlProps, type ISelectOption } from './SelectControl'
-export { TextareaControl, type ITextareaControlProps } from './TextareaControl'
-export { CalendarControl, type ICalendarControlProps } from './calendarControl'
+export { InputControl, type InputControlProps } from './InputControl';
+export { InputControlMask, type InputControlMaskProps } from './InputControlMask';
+export { FormControl } from './FormControl';
+export { DadataInputControl, type IDadataInputControlProps } from './dadata';
+export { CheckboxControl, type ICheckboxControlProps } from './CheckboxControl';
+export { RadioControl, type IRadioControlProps, type IRadioGroupOption } from './RadioControl';
+export { SwitchControl, type ISwitchControlProps } from './SwitchControl';
+export { SelectControl, type ISelectControlProps, type ISelectOption } from './SelectControl';
+export { TextareaControl, type ITextareaControlProps } from './TextareaControl';
+export { CalendarControl, type ICalendarControlProps } from './calendarControl';

package/dist/shared/ui/formControlElements/model/classes-types.d.ts

@@ -0,0 +1,18 @@
+export type TFieldWrapperClasses = {
+    field: string;
+    label: string;
+};
+export type TFieldAttachmentClasses = {
+    badge: string;
+    icon: string;
+    attachmentWrapper: string;
+};
+export type TFieldContainerClasses = {
+    container: string;
+};
+export type TInputCommonClasses = {
+    input: string;
+    message: string;
+};
+export type TAdditionalInputPrimitiveClasses = TFieldWrapperClasses & TFieldContainerClasses & TInputCommonClasses;
+export type TAdditionalInputClassesWithAttachment = TAdditionalInputPrimitiveClasses & TFieldAttachmentClasses;

package/dist/shared/ui/formControlElements/model/index.d.ts

@@ -0,0 +1,2 @@
+export * from './classes-types';
+export * from './props-types';

package/dist/shared/ui/formControlElements/model/props-types.d.ts

@@ -0,0 +1,20 @@
+import { Control, FieldValues, Path } from 'react-hook-form';
+import { TFieldContainerConfig } from '../ui/FieldContainer';
+import type * as React from 'react';
+export type TInputCommonProps = Omit<React.ComponentProps<'input'>, 'name' | 'placeholder' | 'size' | 'type' | 'defaultValue'>;
+export type TTextareaCommonProps = Omit<React.ComponentProps<'textarea'>, 'name' | 'size' | 'type' | 'defaultValue'>;
+type TFieldControlledProps<T extends FieldValues> = {
+    name: Path<T>;
+    control: Control<T>;
+    label: string;
+    helperText?: string;
+};
+export type TFieldContainerSize = 'sm' | 'md' | 'lg' | 'full';
+export type TFieldAttachment = {
+    badge?: string;
+    icon?: React.ReactElement;
+    swapPosition?: boolean;
+};
+export type TControlledInputProps<T extends FieldValues> = TFieldContainerConfig & TFieldAttachment & TFieldControlledProps<T>;
+export type TControlledInputPrimitiveProps<T extends FieldValues> = TInputCommonProps & TFieldControlledProps<T>;
+export {};

package/dist/shared/ui/formControlElements/ui/FieldAttachment.d.ts

@@ -0,0 +1,13 @@
+import { TFieldAttachmentClasses } from '../model/classes-types';
+import { TFieldAttachment } from '../model/props-types';
+import * as React from 'react';
+interface IFieldAttachmentProps extends TFieldAttachment {
+    classes?: Partial<TFieldAttachmentClasses>;
+    error?: boolean;
+    isTextarea?: boolean;
+    swapPosition?: boolean;
+    onClickIcon?: (...args: unknown[]) => unknown;
+    onKeyDownIcon?: (event: React.KeyboardEvent) => unknown;
+}
+export declare const FieldAttachment: ({ badge, icon, error, isTextarea, classes, swapPosition, onClickIcon, onKeyDownIcon }: IFieldAttachmentProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/ui/FieldContainer.d.ts

@@ -0,0 +1,14 @@
+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>;
+    children: React.ReactNode;
+}
+export declare const FieldContainer: ({ size, intent, classes, children }: IFieldContainerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formControlElements/ui/FieldWrapper.d.ts

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