@scbt-ecom/ui 0.30.1 → 0.30.2

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

@@ -1,19 +1,17 @@
+import { AccordionHeaderClasses } from './ui/AccordionHeader';
 import * as React from 'react';
-export type TAccordionClasses = {
+export type AccordionClasses = {
     root?: string;
     wrapper?: string;
     content?: string;
     contentInner?: string;
-    header?: string;
-    trigger?: string;
-    label?: string;
-    icon?: string;
+    header?: AccordionHeaderClasses;
 };
-export interface IAccordionProps {
+export interface AccordionProps {
     children: React.ReactNode;
     label: string | React.ReactElement;
-    classes?: TAccordionClasses;
+    classes?: AccordionClasses;
     defaultOpen?: boolean;
     icon?: React.ReactElement;
 }
-export declare const Accordion: React.ForwardRefExoticComponent<IAccordionProps & React.RefAttributes<HTMLDivElement>>;
+export declare const Accordion: React.ForwardRefExoticComponent<AccordionProps & React.RefAttributes<HTMLDivElement>>;

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

@@ -1 +1 @@
-export { Accordion, type IAccordionProps } from './Accordion';
+export { Accordion, type AccordionProps } from './Accordion';

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

@@ -1,9 +1,14 @@
-import { TAccordionClasses } from '../Accordion';
 import * as React from 'react';
-interface IAccordionHeaderProps {
+export type AccordionHeaderClasses = {
+    header?: string;
+    trigger?: string;
+    label?: string;
+    icon?: string;
+};
+interface AccordionHeaderProps {
     children?: React.ReactElement | string;
-    classes?: Pick<TAccordionClasses, 'header' | 'trigger' | 'label' | 'icon'>;
+    classes?: AccordionHeaderClasses;
     icon?: React.ReactElement;
 }
-export declare const AccordionHeader: React.ForwardRefExoticComponent<IAccordionHeaderProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const AccordionHeader: React.ForwardRefExoticComponent<AccordionHeaderProps & React.RefAttributes<HTMLButtonElement>>;
 export {};

package/dist/shared/ui/badge/Badge.d.ts

@@ -1,6 +1,6 @@
 import { HTMLAttributes, ReactElement } from 'react';
-export interface IBadgeProps extends HTMLAttributes<HTMLSpanElement> {
+export interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
     children: ReactElement | string;
     className?: string;
 }
-export declare const Badge: ({ children, className, ...props }: IBadgeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Badge: ({ children, className, ...props }: BadgeProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/brandLogos/BrandLogos.d.ts

@@ -1,5 +1,5 @@
 import { ReactElement } from 'react';
-export type TBrandLogoVariant = 'main' | 'white' | 'gray' | 'black' | 'business' | 'insurance';
-type TBrandLogosVariants = Record<TBrandLogoVariant, ReactElement>;
-export declare const brandLogos: TBrandLogosVariants;
+export type BrandLogoVariant = 'main' | 'white' | 'gray' | 'black' | 'business' | 'insurance';
+type BrandLogosVariants = Record<BrandLogoVariant, ReactElement>;
+export declare const brandLogos: BrandLogosVariants;
 export {};

package/dist/shared/ui/breadcrumbs/Breadcrumbs.d.ts

@@ -1,16 +1,16 @@
 import { ReactElement } from 'react';
-export interface IBreadcrumbLink {
+export interface BreadcrumbLink {
     label: string | ReactElement;
     path: string;
     isDisabled?: boolean;
 }
-interface IBreadcrumbLinkWithoutPath {
+interface BreadcrumbLinkWithoutPath {
     label: string;
     isDisabled?: boolean;
 }
-export type TLinksList = [...IBreadcrumbLink[], IBreadcrumbLinkWithoutPath];
-export interface IBreadcrumbsProps {
-    linksList: TLinksList;
+export type LinksList = [...BreadcrumbLink[], BreadcrumbLinkWithoutPath];
+export interface BreadcrumbsProps {
+    linksList: LinksList;
 }
-export declare const Breadcrumbs: ({ linksList }: IBreadcrumbsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Breadcrumbs: ({ linksList }: BreadcrumbsProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/button/Button.d.ts

@@ -7,11 +7,11 @@ declare const buttonConfig: (props?: ({
     isFull?: boolean | null | undefined;
     isLoading?: boolean | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export type TButtonConfig = VariantProps<typeof buttonConfig>;
-export interface IButtonProps extends ComponentProps<'button'>, TButtonConfig {
+export type ButtonConfig = VariantProps<typeof buttonConfig>;
+export interface ButtonProps extends ComponentProps<'button'>, ButtonConfig {
     iconLeft?: ReactElement;
     iconRight?: ReactElement;
     isLoading?: boolean;
 }
-export declare const Button: import('react').ForwardRefExoticComponent<Omit<IButtonProps, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
+export declare const Button: import('react').ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
 export {};

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

@@ -1 +1 @@
-export { Button, type IButtonProps } from './Button';
+export { Button, type ButtonProps } from './Button';

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

@@ -1,2 +1,2 @@
-import { TButtonConfig } from '../Button';
-export declare const setButtonLoaderIntent: (intent: TButtonConfig["intent"]) => "primary" | "secondary" | null | undefined;
+import { ButtonConfig } from '../Button';
+export declare const setButtonLoaderIntent: (intent: ButtonConfig["intent"]) => "primary" | "secondary" | null | undefined;

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

@@ -1,6 +1,6 @@
 import { ComponentProps, ReactElement } from 'react';
 import { VariantProps } from 'class-variance-authority';
-type TButtonClasses = {
+type ButtonClasses = {
     button: string;
     icon: string;
 };
@@ -8,10 +8,10 @@ declare const buttonConfig: (props?: ({
     intent?: "primary" | "secondary" | "ghost" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-type TButtonProps = VariantProps<typeof buttonConfig>;
-export interface IButtonIconProps extends Omit<ComponentProps<'button'>, 'className'>, TButtonProps {
+type ButtonProps = VariantProps<typeof buttonConfig>;
+export interface IButtonIconProps extends Omit<ComponentProps<'button'>, 'className'>, ButtonProps {
     children: ReactElement;
-    classes?: Partial<TButtonClasses>;
+    classes?: Partial<ButtonClasses>;
 }
 export declare const ButtonIcon: import('react').ForwardRefExoticComponent<Omit<IButtonIconProps, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
 export {};

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

@@ -1,20 +1,20 @@
 import { ComponentProps } from 'react';
 import { VariantProps } from 'class-variance-authority';
-import { TAllowedIcons } from '..';
+import { AllowedIcons } from '..';
 declare const customLinkConfig: (props?: ({
     intent?: "blue" | "white" | null | undefined;
     withUnderline?: boolean | null | undefined;
     disabled?: boolean | null | undefined;
     size?: "sm" | "md" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-type TCustomLinkClasses = {
+type CustomLinkClasses = {
     link?: string;
     icon?: string;
 };
-type TCustomLinkConfig = VariantProps<typeof customLinkConfig>;
-export interface ICustomLinkProps extends TCustomLinkConfig, Omit<ComponentProps<'a'>, 'className'> {
-    icon?: TAllowedIcons;
-    classes?: TCustomLinkClasses;
+type CustomLinkConfig = VariantProps<typeof customLinkConfig>;
+export interface CustomLinkProps extends CustomLinkConfig, Omit<ComponentProps<'a'>, 'className'> {
+    icon?: AllowedIcons;
+    classes?: CustomLinkClasses;
 }
-export declare const CustomLink: ({ intent, children, disabled, size, icon, classes, withUnderline, ...props }: ICustomLinkProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CustomLink: ({ intent, children, disabled, size, icon, classes, withUnderline, ...props }: CustomLinkProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -3,12 +3,12 @@ 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 {
+type IconConfig = VariantProps<typeof iconConfig>;
+export interface DocumentProps extends IconConfig {
     text: string | ReactElement;
     size: number;
     sizeType: 'КБ' | 'МБ';
     href: string;
 }
-export declare const Document: ({ text, size, sizeType, href, intent }: IDocumentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Document: ({ text, size, sizeType, href, intent }: DocumentProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/floatButton/FloatButton.d.ts

@@ -1,13 +1,13 @@
-import { IButtonProps } from '..';
-type TFloatButtonClasses = {
+import { ButtonProps } from '..';
+type FloatButtonClasses = {
     root?: string;
     button?: string;
 };
-export interface IFloatButtonProps {
+export interface FloatButtonProps {
     isVisible: boolean;
-    classes?: TFloatButtonClasses;
+    classes?: FloatButtonClasses;
     children: React.ReactElement;
-    buttonProps?: IButtonProps;
+    buttonProps?: ButtonProps;
 }
-export declare const FloatButton: ({ isVisible, classes, children, buttonProps }: IFloatButtonProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FloatButton: ({ isVisible, classes, children, buttonProps }: FloatButtonProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -5,6 +5,7 @@ export declare const Controlled: {
         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"> & {
@@ -18,10 +19,7 @@ export declare const Controlled: {
     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?: {
-            root?: string;
-            indicator?: string;
-        } & {
+        classes?: import('../uncontrolled/checkbox/Checkbox').CheckboxBaseClasses & {
             container?: string;
             message?: string;
             label?: string;
@@ -48,6 +46,7 @@ export declare const Controlled: {
         classes?: {
             item?: string;
             helperText?: string;
+            checkbox?: import('../uncontrolled/checkbox/Checkbox').CheckboxBaseClasses;
         } & {
             root?: string;
             list?: string;
@@ -62,13 +61,10 @@ export declare const Controlled: {
     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?: {
-            item?: string;
-            indicator?: string;
-            label?: string;
-        } & {
+        classes?: import('../uncontrolled/radio/ui/RadioItem').RadioItemClasses & {
             root?: string;
             list?: string;
+            radioItem?: import('../uncontrolled/radio/ui/RadioItem').RadioItemClasses;
         } & {
             container?: string;
             message?: string;

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

@@ -2,6 +2,7 @@ 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'> & {
     /**

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

@@ -1,6 +1,7 @@
 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'> & {

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

@@ -1,7 +1,8 @@
 import { CheckboxProps as CheckboxPrimitiveProps, CheckedState } from '@radix-ui/react-checkbox';
-type CheckboxBaseClasses = {
+export type CheckboxBaseClasses = {
     root?: string;
     indicator?: string;
+    icon?: string;
 };
 export type { CheckedState };
 type ExternalHandlers = {

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

@@ -1,3 +1,4 @@
+import { InputBaseClasses } from '../input/Input';
 import { MaskInputProps } from '../../..';
 type ExternalHandlers = {
     onChange?: (value: string) => void;
@@ -5,7 +6,11 @@ type ExternalHandlers = {
     onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
     onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
 };
-export type DayPickerProps = Omit<MaskInputProps, 'value' | 'onChange' | 'mask'> & {
+export type DayPickerClasses = {
+    root?: string;
+    input?: InputBaseClasses;
+};
+export type DayPickerProps = Omit<MaskInputProps, 'value' | 'onChange' | 'mask' | 'classes'> & {
     /**
      * Указывает, открыт ли календарь по умолчанию
      */
@@ -18,12 +23,16 @@ export type DayPickerProps = Omit<MaskInputProps, 'value' | 'onChange' | 'mask'>
      * Функция изменения значения
      */
     onChange?: (value: string) => void;
+    /**
+     * Внешние классы которыми можно поменять стили
+     */
+    classes?: DayPickerClasses;
     /**
      * Дополнительные хендлеры
      */
     externalHandlers?: ExternalHandlers;
 };
-export declare const DayPickerBase: import('react').ForwardRefExoticComponent<Omit<MaskInputProps, "value" | "onChange" | "mask"> & {
+export declare const DayPickerBase: import('react').ForwardRefExoticComponent<Omit<MaskInputProps, "value" | "onChange" | "mask" | "classes"> & {
     /**
      * Указывает, открыт ли календарь по умолчанию
      */
@@ -36,6 +45,10 @@ export declare const DayPickerBase: import('react').ForwardRefExoticComponent<Om
      * Функция изменения значения
      */
     onChange?: (value: string) => void;
+    /**
+     * Внешние классы которыми можно поменять стили
+     */
+    classes?: DayPickerClasses;
     /**
      * Дополнительные хендлеры
      */

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

@@ -57,10 +57,7 @@ export declare const Uncontrolled: {
         externalHandlers?: import('./select/Select').ExternalHandlers;
     } & import('react').RefAttributes<HTMLElement>>;
     CheckboxBase: import('react').ForwardRefExoticComponent<import('@radix-ui/react-checkbox').CheckboxProps & {
-        classes?: {
-            root?: string;
-            indicator?: string;
-        };
+        classes?: import('./checkbox/Checkbox').CheckboxBaseClasses;
         invalid?: boolean;
         externalHandlers?: {
             onChange?: (value: import('@radix-ui/react-checkbox').CheckedState) => void;
@@ -69,10 +66,11 @@ export declare const Uncontrolled: {
             onFocus?: (event: React.FocusEvent<HTMLButtonElement>) => void;
         };
     } & import('react').RefAttributes<HTMLButtonElement>>;
-    DayPickerBase: import('react').ForwardRefExoticComponent<Omit<import('./maskInput').MaskInputProps, "value" | "onChange" | "mask"> & {
+    DayPickerBase: import('react').ForwardRefExoticComponent<Omit<import('./maskInput').MaskInputProps, "value" | "onChange" | "mask" | "classes"> & {
         defaultOpen?: boolean;
         value?: string;
         onChange?: (value: string) => void;
+        classes?: import('./dayPicker/DayPicker').DayPickerClasses;
         externalHandlers?: {
             onChange?: (value: string) => void;
             onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
@@ -96,13 +94,10 @@ export declare const Uncontrolled: {
         options: import('./radio').RadioOption[];
         displayValue?: (option: import('./radio').RadioOption) => string;
         returnValue?: (option: import('./radio').RadioOption) => string;
-        classes?: {
-            item?: string;
-            indicator?: string;
-            label?: string;
-        } & {
+        classes?: import('./radio/ui/RadioItem').RadioItemClasses & {
             root?: string;
             list?: string;
+            radioItem?: import('./radio/ui/RadioItem').RadioItemClasses;
         };
         invalid?: boolean;
         externalHandlers?: {

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

@@ -1,8 +1,10 @@
 import { RadioGroupProps as RadioGroupPrimitiveProps } from '@radix-ui/react-radio-group';
 import { RadioItemProps, RadioOption } from './ui';
+import { RadioItemClasses } from './ui/RadioItem';
 type RadioGroupClasses = RadioItemProps['classes'] & {
     root?: string;
     list?: string;
+    radioItem?: RadioItemClasses;
 };
 type ExternalHandlers = {
     onChange?: (value: string) => void;

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

@@ -5,7 +5,7 @@ export type RadioOption = {
     label: string;
     disabled?: boolean;
 };
-type RadioItemClasses = {
+export type RadioItemClasses = {
     item?: string;
     indicator?: string;
     label?: string;
@@ -33,4 +33,3 @@ export type RadioItemProps = Omit<RadioGroupItemProps, 'value'> & {
     invalid?: boolean;
 };
 export declare const RadioItem: import('react').MemoExoticComponent<({ item, disabled, displayValue, returnValue, classes, className, invalid, ...props }: RadioItemProps) => import("react/jsx-runtime").JSX.Element>;
-export {};

package/dist/shared/ui/formElements/uncontrolled/select/ui/SelectItem.d.ts

@@ -1,9 +1,11 @@
 import { ComboboxOptionProps } from '@headlessui/react';
 import { motion } from 'framer-motion';
+import { CheckboxBaseClasses } from '../../checkbox/Checkbox';
 import { SelectItemOption } from '../model';
 type SelectItemClasses = {
     item?: string;
     helperText?: string;
+    checkbox?: CheckboxBaseClasses;
 };
 export type SelectItemProps = Omit<ComboboxOptionProps, 'className' | 'value'> & {
     option: SelectItemOption;

package/dist/shared/ui/formElements/uncontrolled/uploader/UploaderBase.d.ts

@@ -21,16 +21,16 @@ export interface UploaderBaseProps extends Omit<InputHTMLAttributes<HTMLInputEle
      */
     helperText?: string;
     /**
-     * Сеттер инпута
+     * Сеттер значение
      * @param file - файлы
      */
     onChange: (file: File[]) => void;
     /**
-     * Валидный ли инпут
+     * Валидное ли значение
      */
     invalid?: boolean;
     /**
-     * Value инпута
+     * Значение
      */
     value: File[];
 }

package/dist/shared/ui/heading/Heading.d.ts

@@ -3,10 +3,10 @@ import { VariantProps } from 'class-variance-authority';
 declare const headingConfig: (props?: ({
     as?: "h1" | "h2" | "h3" | "h4" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface IHeadingProps extends VariantProps<typeof headingConfig> {
+export interface HeadingProps extends VariantProps<typeof headingConfig> {
     children: ReactNode;
     className?: string;
     as?: 'h1' | 'h2' | 'h3' | 'h4';
 }
-export declare const Heading: ({ as, children, className, ...props }: IHeadingProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Heading: ({ as, children, className, ...props }: HeadingProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/hint/Hint.d.ts

@@ -1,21 +1,21 @@
 import * as React from 'react';
 import * as TooltipPrimitive from '@radix-ui/react-tooltip';
-type THintClasses = {
+type HintClasses = {
     content?: string;
     arrow?: string;
     trigger?: string;
 };
-export interface IHintContentProps extends TooltipPrimitive.TooltipContentProps {
+export interface HintContentProps extends TooltipPrimitive.TooltipContentProps {
     delayDuration?: number;
     sideOffset?: number;
     align?: 'end' | 'center' | 'start';
     side?: 'top' | 'right' | 'bottom' | 'left';
     defaultOpen?: boolean;
 }
-export interface IHintProps extends IHintContentProps {
+export interface IHintProps extends HintContentProps {
     triggerElement: React.ReactElement;
     children: React.ReactElement | string;
-    classes?: THintClasses;
+    classes?: HintClasses;
 }
 export declare const Hint: ({ triggerElement, children, delayDuration, sideOffset, align, side, defaultOpen, classes, ...contentProps }: IHintProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,10 +1,10 @@
 import { SpritesMap } from './sprite.gen';
 import * as React from 'react';
 export type IconName<Key extends keyof SpritesMap> = `${Key}/${SpritesMap[Key]}`;
-export type TAllowedIcons = {
+export type AllowedIcons = {
     [Key in keyof SpritesMap]: IconName<Key>;
 }[keyof SpritesMap];
 export interface IconProps extends React.SVGProps<SVGSVGElement> {
-    name: TAllowedIcons;
+    name: AllowedIcons;
 }
 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 TAllowedIcons } from './Icon';
+export { Icon, type IconProps, type AllowedIcons } from './Icon';
 export type { SpritesMap } from './sprite.gen';

package/dist/shared/ui/keyboardShortcuts/KeyboardShortcuts.d.ts

@@ -1,11 +1,11 @@
-type TKeyboardShortcutsClasses = {
+type KeyboardShortcutsClasses = {
     root?: string;
     keys?: string;
     key?: string;
 };
-export interface IKeyboardShortcutsProps {
+export interface KeyboardShortcutsProps {
     keyList: string[];
-    classes?: TKeyboardShortcutsClasses;
+    classes?: KeyboardShortcutsClasses;
 }
-export declare const KeyboardShortcuts: ({ keyList, classes }: IKeyboardShortcutsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const KeyboardShortcuts: ({ keyList, classes }: KeyboardShortcutsProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/ligal/Ligal.d.ts

@@ -1,12 +1,12 @@
 import * as React from 'react';
-type TLigalClasses = {
+type LigalClasses = {
     ligalRoot?: string;
     ligalText?: string;
     ligalButton?: string;
 };
-export interface ILigalProps {
+export interface LigalProps {
     text: string | React.ReactElement;
-    classes?: TLigalClasses;
+    classes?: LigalClasses;
 }
-export declare const Ligal: ({ text, classes }: ILigalProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Ligal: ({ text, classes }: LigalProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -12,10 +12,10 @@ type TLoaderClasses = {
     loader?: string;
     text?: string;
 };
-export interface ILoaderProps extends VariantProps<typeof loaderConfig>, VariantProps<typeof wrapperConfig>, Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
+export interface LoaderProps extends VariantProps<typeof loaderConfig>, VariantProps<typeof wrapperConfig>, Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
     intent?: 'primary' | 'secondary' | null;
     text?: ReactElement | string;
     classes?: TLoaderClasses;
 }
-export declare const Loader: ({ size, classes, intent, position, text, ...props }: ILoaderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Loader: ({ size, classes, intent, position, text, ...props }: LoaderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/modal/Modal.d.ts

@@ -1,19 +1,19 @@
 import { TModalHeaderClasses } from './ui/ModalHeader';
 import * as React from 'react';
-type IModalClasses = {
+type ModalClasses = {
     overlay?: string;
     modal?: string;
     content?: string;
     modalHeader?: TModalHeaderClasses;
 };
-export interface IModalProps {
+export interface ModalProps {
     children: React.ReactElement;
     isModalOpen: boolean;
-    classes?: IModalClasses;
+    classes?: ModalClasses;
     isPortal?: boolean;
     portalContainer?: HTMLElement;
     title?: string | React.ReactElement;
     closeModal: () => void;
 }
-export declare const Modal: ({ title, children, isModalOpen, isPortal, portalContainer, closeModal, classes }: IModalProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Modal: ({ title, children, isModalOpen, isPortal, portalContainer, closeModal, classes }: ModalProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/modal/ui/ModalHeader.d.ts

@@ -1,10 +1,10 @@
-import { IModalProps } from '../Modal';
+import { ModalProps } from '../Modal';
 export type TModalHeaderClasses = {
     header?: string;
     title?: string;
     icon?: string;
 };
-export interface IModalHeaderProps extends Pick<IModalProps, 'closeModal' | 'title'> {
+export interface IModalHeaderProps extends Pick<ModalProps, 'closeModal' | 'title'> {
     classes?: TModalHeaderClasses;
 }
 export declare const ModalHeader: ({ title, closeModal, classes }: IModalHeaderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/notification/Notification.d.ts

@@ -1,5 +1,5 @@
 import { ReactElement } from 'react';
-export interface INotificationProps {
+export interface NotificationProps {
     duration?: number;
     intent: 'info' | 'error';
     text: string | ReactElement;
@@ -7,4 +7,4 @@ export interface INotificationProps {
     content?: ReactElement;
     closure?: boolean;
 }
-export declare const Notification: (props: INotificationProps) => string | null;
+export declare const Notification: (props: NotificationProps) => string | null;

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

@@ -1 +1 @@
-export { Notification, type INotificationProps } from './Notification';
+export { Notification, type NotificationProps } from './Notification';

package/dist/shared/ui/notification/ui/CustomToast.d.ts

@@ -1,10 +1,10 @@
 import { Toast } from 'react-hot-toast';
 import { VariantProps } from 'class-variance-authority';
-import { INotificationProps } from '../Notification';
+import { NotificationProps } from '../Notification';
 declare const toastContainerConfig: (props?: ({
     intent?: "error" | "info" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 type TContainerConfig = VariantProps<typeof toastContainerConfig>;
-export type ICustomToastProps = INotificationProps & TContainerConfig & Toast;
+export type ICustomToastProps = NotificationProps & TContainerConfig & Toast;
 export declare const CustomToast: ({ intent, text, customIcon, closure, content, id }: ICustomToastProps) => import("react/jsx-runtime").JSX.Element;
 export {};