@scbt-ecom/ui 0.0.18 → 0.0.22

package/dist/shared/constants/designSystem/others.d.ts

@@ -5,4 +5,12 @@ declare const allowedBorderRadius: {
     lg: string;
     full: string;
 };
-export { allowedBorderRadius };
+declare const allowedBackgroundDeg: {
+    30: string;
+    45: string;
+    80: string;
+    90: string;
+    110: string;
+    180: string;
+};
+export { allowedBorderRadius, allowedBackgroundDeg };

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

@@ -1,6 +1,6 @@
 import { ComponentProps, ReactElement } from 'react';
 import { VariantProps } from 'class-variance-authority';
-type TAdditionalClasses = {
+type TButtonClasses = {
     button: string;
     icon: string;
 };
@@ -11,7 +11,7 @@ declare const buttonConfig: (props?: ({
 type TButtonProps = VariantProps<typeof buttonConfig>;
 export interface IButtonIconProps extends ComponentProps<'button'>, TButtonProps {
     children: ReactElement;
-    classes?: Partial<TAdditionalClasses>;
+    classes?: Partial<TButtonClasses>;
 }
 export declare const ButtonIcon: import('react').ForwardRefExoticComponent<Omit<IButtonIconProps, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
 export {};

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

@@ -1,6 +1,6 @@
 import { ComponentProps } from 'react';
 import { VariantProps } from 'class-variance-authority';
-import { AnyIconName } from './icon/Icon';
+import { TAllowedIcons } from './icon/Icon';
 declare const customLinkConfig: (props?: ({
     intent?: "white" | "blue" | null | undefined;
     withIcon?: boolean | null | undefined;
@@ -9,7 +9,7 @@ declare const customLinkConfig: (props?: ({
 type TCustomLinkConfig = VariantProps<typeof customLinkConfig>;
 export interface ICustomLinkProps extends TCustomLinkConfig, ComponentProps<'a'> {
     Component: 'a';
-    icon?: AnyIconName;
+    icon?: TAllowedIcons;
 }
 export declare const CustomLink: ({ Component, intent, children, withIcon, disabled, icon, ...props }: ICustomLinkProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,13 @@
+import { VariantProps } from 'class-variance-authority';
+declare const iconConfig: (props?: ({
+    intent?: "outline" | "filled" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type TIconConfig = VariantProps<typeof iconConfig>;
+export interface IDocumentProps extends TIconConfig {
+    text: string;
+    size: number;
+    sizeType: 'КБ' | 'МБ';
+    href: string;
+}
+export declare const Document: ({ text, size, sizeType, href, intent }: IDocumentProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,12 +1,21 @@
-import { HTMLAttributes } from 'react';
+import { HTMLAttributes, ReactElement } from 'react';
 import { VariantProps } from 'class-variance-authority';
+declare const wrapperConfig: (props?: ({
+    position?: "fixed" | "absolute" | "static" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
 declare const loaderConfig: (props?: ({
     intent?: "primary" | "secondary" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
-    position?: "fixed" | "absolute" | "static" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface ILoaderProps extends VariantProps<typeof loaderConfig>, HTMLAttributes<HTMLDivElement> {
+type ILoaderClasses = {
+    wrapper: string;
+    loader: string;
+    text: string;
+};
+export interface ILoaderProps extends VariantProps<typeof loaderConfig>, VariantProps<typeof wrapperConfig>, HTMLAttributes<HTMLDivElement> {
     intent?: 'primary' | 'secondary';
+    text?: ReactElement | string;
+    classes?: Partial<ILoaderClasses>;
 }
-export declare const Loader: ({ size, className, intent, position, ...props }: ILoaderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Loader: ({ size, classes, intent, position, text, ...props }: ILoaderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,5 +1,12 @@
+interface IPhoneViewClasses {
+    wrapper: string;
+    link: string;
+    text: string;
+}
 export interface IPhoneViewProps {
     phone: string;
     text: string;
+    classes?: Partial<IPhoneViewClasses>;
 }
-export declare const PhoneView: ({ phone, text }: IPhoneViewProps) => import("react/jsx-runtime").JSX.Element;
+export declare const PhoneView: ({ phone, text, classes }: IPhoneViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+import { ReactElement } from 'react';
+type IProgressBarClasses = {
+    wrapper: string;
+    topContent: string;
+    bottomContent: string;
+    progressBar: string;
+    progress: string;
+    loader: string;
+};
+export interface IProgressBarProps {
+    topContent?: ReactElement;
+    bottomContent?: ReactElement;
+    progress: number;
+    maxPercent?: number;
+    classes?: Partial<IProgressBarClasses>;
+}
+export declare const ProgressBar: ({ topContent, bottomContent, progress, maxPercent, classes }: IProgressBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,4 @@
+export interface ISkeletonProps {
+    className?: string;
+}
+export declare const Skeleton: ({ className }: ISkeletonProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,33 @@
+import { ReactElement } from 'react';
+/**
+ * @param {string} id - для триггера и для контента должен совпадать
+ */
+interface ITabsClasses {
+    root: string;
+    list: string;
+    trigger: string;
+    content: string;
+    contentsWrapper: string;
+}
+interface ITabContent {
+    id: string;
+    body: ReactElement | string;
+    accordion?: {
+        title: string;
+    };
+}
+interface ITabTrigger {
+    id: string;
+    label: string;
+}
+export interface ITabRenderContent {
+    triggers: ITabTrigger[];
+    contents: ITabContent[];
+}
+export interface ITabsSwitcherProps {
+    renderContent: ITabRenderContent;
+    defaultActiveTabId?: string;
+    classes?: Partial<ITabsClasses>;
+}
+export declare const TabsSwitcher: ({ renderContent, defaultActiveTabId, classes }: ITabsSwitcherProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/accordion/Accordion.d.ts

@@ -1,7 +1,13 @@
-import { IAccordionHeaderClasses, IAccordionItem, IAccordionRootClasses } from './model/types';
+import { TAccordionHeaderClasses, TAccordionRootClasses } from './model/types';
+import * as React from 'react';
+/**
+ * @param {string[]} defaultOpen - По умолчанию открытые аккордеоны необходимо указать тот же label явно руками.
+ * Пример defaultValue={['Заголовок аккордеона 1', 'Заголовок аккордеона 2']}
+ */
 export interface IAccordionProps {
-    accordionItems: IAccordionItem[];
-    classes?: Partial<IAccordionRootClasses> & Partial<IAccordionHeaderClasses>;
-    defaultValue?: string[];
+    children: React.ReactNode;
+    label: string | React.ReactElement;
+    classes?: Partial<TAccordionHeaderClasses> & Partial<TAccordionRootClasses>;
+    defaultOpen?: string[];
 }
-export declare const Accordion: ({ accordionItems, classes, defaultValue }: IAccordionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Accordion: ({ children, label, classes, defaultOpen }: IAccordionProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,16 +1,17 @@
-import { ReactNode } from 'react';
-export interface IAccordionHeaderClasses {
+import type * as React from 'react';
+export type TAccordionHeaderClasses = {
     trigger: string;
     icon: string;
     header: string;
     inner: string;
-}
-export interface IAccordionRootClasses {
+};
+export type TAccordionRootClasses = {
     item: string;
     content: string;
+    contentInner: string;
     accordion: string;
-}
+};
 export interface IAccordionItem {
     label: string;
-    content: ReactNode;
+    content: React.ReactNode;
 }

package/dist/shared/ui/accordion/ui/AccordionHeader.d.ts

@@ -1,8 +1,8 @@
-import { ReactElement } from 'react';
-import { IAccordionHeaderClasses } from '../model/types';
+import { TAccordionHeaderClasses } from '../model/types';
+import * as React from 'react';
 interface IAccordionHeaderProps {
-    children?: ReactElement | string;
-    classes?: Partial<IAccordionHeaderClasses>;
+    children?: React.ReactElement | string;
+    classes?: Partial<TAccordionHeaderClasses>;
 }
-export declare const AccordionHeader: import('react').ForwardRefExoticComponent<IAccordionHeaderProps & import('react').RefAttributes<HTMLButtonElement>>;
+export declare const AccordionHeader: React.ForwardRefExoticComponent<IAccordionHeaderProps & React.RefAttributes<HTMLButtonElement>>;
 export {};

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

@@ -1,11 +1,13 @@
+import { ReactElement } from 'react';
 import { FieldValues } from 'react-hook-form';
 import { TAdditionalInputPrimitiveClasses, TControlledInputPrimitiveProps } from './model';
 type TCheckboxClasses = Partial<TAdditionalInputPrimitiveClasses> & {
     wrapper?: string;
     indicator?: string;
 };
-export interface ICheckboxControlProps<T extends FieldValues> extends TControlledInputPrimitiveProps<T> {
+export interface ICheckboxControlProps<T extends FieldValues> extends Omit<TControlledInputPrimitiveProps<T>, 'label'> {
     classes?: TCheckboxClasses;
+    label: 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/InputControl.d.ts

@@ -1,6 +1,6 @@
 import { FieldValues } from 'react-hook-form';
-import { TAdditionalInputClassesWithAttachment, TControlledInputProps } from './model';
-export interface InputControlProps<T extends FieldValues> extends TControlledInputProps<T> {
+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, disabled, ...props }: InputControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+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

@@ -1,10 +1,10 @@
 import { FieldValues } from 'react-hook-form';
-import { TAdditionalInputClassesWithAttachment, TControlledInputProps } from './model';
-export interface InputControlMaskProps<T extends FieldValues> extends TControlledInputProps<T> {
+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, ...props }: InputControlMaskProps<T>) => import("react/jsx-runtime").JSX.Element;
+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/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/calendar/CalendarControl.d.ts

@@ -0,0 +1,20 @@
+import { DayPickerProps, PropsRange, PropsSingle } from 'react-day-picker';
+import { FieldValues } from 'react-hook-form';
+import { TAdditionalInputClassesWithAttachment, TControlledInputProps } from '../model';
+type TCalendarClasses = Partial<TAdditionalInputClassesWithAttachment> & {
+    root: string;
+    wrapper: string;
+    calendar: string;
+};
+export type TCalendarMode = 'range' | 'single';
+type TCalendarCommonProps = PropsSingle | PropsRange;
+export type ICalendarControlProps<T extends FieldValues> = TControlledInputProps<T> & TCalendarCommonProps & DayPickerProps & {
+    maskFormat?: string;
+    mask?: string | string[];
+    allowEmptyFormatting?: boolean;
+    classes?: Partial<TCalendarClasses>;
+    disabled?: boolean;
+    onClickIcon?: (...args: unknown[]) => unknown;
+};
+export declare const CalendarControl: <T extends FieldValues>(props: ICalendarControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/shared/ui/formControlElements/calendar/model/animation.d.ts

@@ -0,0 +1,18 @@
+export declare const calendarAnimation: {
+    initial: {
+        opacity: number;
+        y: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+    };
+    exit: {
+        opacity: number;
+        y: number;
+    };
+    transition: {
+        duration: number;
+        ease: string;
+    };
+};

package/dist/shared/ui/formControlElements/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/formControlElements/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/formControlElements/calendar/model/hooks/index.d.ts

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

package/dist/shared/ui/formControlElements/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/formControlElements/calendar/model/hooks/useDatePicker.d.ts

@@ -0,0 +1,18 @@
+import { TCalendarMode } from '../../CalendarControl';
+export type TControlledDate = {
+    day: number;
+    month: number;
+    year: number;
+};
+export declare const useDatePicker: () => {
+    formattedControlledDate: Date;
+    controlledDate: TControlledDate;
+    setControlledDate: import('react').Dispatch<import('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/formControlElements/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/formControlElements/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/formControlElements/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/formControlElements/calendar/ui/Weekdays.d.ts

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

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

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

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

@@ -1,14 +1,14 @@
 import { FieldValues } from 'react-hook-form';
-import { TAdditionalInputClassesWithAttachment, TControlledInputProps } from '../model';
+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> {
+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, ...props }: IDadataInputControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+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/dist/shared/ui/formControlElements/index.d.ts

@@ -3,4 +3,8 @@ 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 } from './RadioControl';
+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 './calendar';

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

@@ -1,7 +1,8 @@
-import { ComponentProps, ReactElement } from 'react';
 import { Control, FieldValues, Path } from 'react-hook-form';
 import { TFieldContainerConfig } from '../ui/FieldContainer';
-type TFieldCommonProps = Omit<ComponentProps<'input'>, 'name' | 'placeholder' | 'size' | 'type' | 'defaultValue'>;
+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>;
@@ -11,8 +12,9 @@ type TFieldControlledProps<T extends FieldValues> = {
 export type TFieldContainerSize = 'sm' | 'md' | 'lg' | 'full';
 export type TFieldAttachment = {
     badge?: string;
-    icon?: ReactElement;
+    icon?: React.ReactElement;
+    swapPosition?: boolean;
 };
-export type TControlledInputProps<T extends FieldValues> = TFieldContainerConfig & TFieldCommonProps & TFieldAttachment & TFieldControlledProps<T>;
-export type TControlledInputPrimitiveProps<T extends FieldValues> = TFieldCommonProps & TFieldControlledProps<T>;
+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

@@ -3,6 +3,10 @@ import { TFieldAttachment } from '../model/props-types';
 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, classes }: IFieldAttachmentProps) => import("react/jsx-runtime").JSX.Element;
+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

@@ -2,6 +2,7 @@ import { ReactNode } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import { TFieldContainerClasses } from '../model/classes-types';
 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>;
@@ -9,5 +10,5 @@ interface IFieldContainerProps extends TFieldContainerConfig {
     classes?: Partial<TFieldContainerClasses>;
     children: ReactNode;
 }
-export declare const FieldContainer: ({ size, classes, children }: IFieldContainerProps) => import("react/jsx-runtime").JSX.Element;
+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

@@ -8,6 +8,7 @@ interface IFieldWrapperProps<V> {
     error?: boolean;
     classes?: Partial<TFieldWrapperClasses>;
     disabled?: boolean;
+    isTextarea?: boolean;
 }
-export declare const FieldWrapper: <V>({ children, error, disabled, classes, fieldId, label, value }: IFieldWrapperProps<V>) => import("react/jsx-runtime").JSX.Element;
+export declare const FieldWrapper: <V>({ children, error, disabled, classes, fieldId, label, value, isTextarea }: IFieldWrapperProps<V>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/icon/Icon.d.ts

@@ -1,10 +1,10 @@
 import { SVGProps } from 'react';
 import { SpritesMap } from './sprite.gen';
 export type IconName<Key extends keyof SpritesMap> = `${Key}/${SpritesMap[Key]}`;
-export type AnyIconName = {
+export type TAllowedIcons = {
     [Key in keyof SpritesMap]: IconName<Key>;
 }[keyof SpritesMap];
 export interface IconProps extends SVGProps<SVGSVGElement> {
-    name: AnyIconName;
+    name: TAllowedIcons;
 }
 export declare const Icon: ({ name, className, ...props }: IconProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,2 +1,2 @@
-export { Icon, type IconProps, type AnyIconName } from './Icon';
+export { Icon, type IconProps, type TAllowedIcons } from './Icon';
 export * from './sprite.gen';

package/dist/shared/ui/icon/sprite.gen.d.ts

@@ -1,6 +1,9 @@
 export interface SpritesMap {
+    arrows: 'arrowCircle' | 'arrowLink' | 'arrowRight';
     brandLogos: 'logoBlack' | 'logoBusiness' | 'logoGray' | 'logoInsurance' | 'logoMain' | 'logoWhite';
-    common: 'arrowCircle' | 'arrowLink' | 'arrowRight' | 'check' | 'close' | 'warningCircle';
+    files: 'documentFilled' | 'documentOutline';
+    general: 'calendar' | 'check' | 'close';
+    info: 'warningCircle';
 }
 export declare const SPRITES_META: {
     [Key in keyof SpritesMap]: {