@kroo-web/design-system 1.1.104 → 1.1.107

package/dist/esm/src/__tests__/setup.d.ts

@@ -0,0 +1,5 @@
+import { render, RenderOptions } from '@testing-library/react';
+import { ReactElement } from 'react';
+declare const customRender: (ui: ReactElement, options?: Omit<RenderOptions, "wrapper">) => ReturnType<typeof render>;
+export * from '@testing-library/react';
+export { customRender as render };

package/dist/esm/src/components/Accordion/config.d.ts

@@ -5,7 +5,7 @@ export declare const AccordionContext: React.Context<{
 }>;
 export declare const AccordionContextProvider: ({ children }: PropsWithChildren) => React.JSX.Element;
 export declare const AccordionItemContext: React.Context<{
-    value: string;
     setValue: (value: string) => void;
+    value: string;
 }>;
 export declare const AccordionItemContextProvider: ({ children }: PropsWithChildren) => React.JSX.Element;

package/dist/esm/src/components/Accordion/index.d.ts

@@ -1,21 +1,21 @@
-import React from 'react';
 import * as AccordionPrimitive from '@radix-ui/react-accordion';
-export type TAccordionRootProps = React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Root> & {
-    grouping?: 'attached' | 'detached';
+import React from 'react';
+export type TAccordionRootProps = {
     children: React.ReactNode;
-};
-export type TAccordionTriggerProps<C extends React.ElementType = 'p'> = React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger> & {
+    grouping?: 'attached' | 'detached';
+} & React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Root>;
+export type TAccordionTriggerProps<C extends React.ElementType = 'p'> = {
     as?: C;
-    size?: 'regular' | 'large';
     controls?: React.ReactNode;
-};
+    size?: 'large' | 'regular';
+} & React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger>;
 export declare const Accordion: {
-    Root: (props: TAccordionRootProps) => React.JSX.Element;
+    Content: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
     Item: (props: React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item>) => React.JSX.Element;
-    Trigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    Root: (props: TAccordionRootProps) => React.JSX.Element;
+    Trigger: React.ForwardRefExoticComponent<{
         as?: "p" | undefined;
-        size?: "regular" | "large";
         controls?: React.ReactNode;
-    } & React.RefAttributes<HTMLButtonElement>>;
-    Content: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+        size?: "large" | "regular";
+    } & Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 };

package/dist/esm/src/components/Button/index.d.ts

@@ -2,23 +2,23 @@ import React, { PropsWithChildren } from 'react';
 import { PolymorphicPropsWithoutRef } from '../../types/PolymorphicWithoutRef';
 declare const defaultElement = "button";
 type TButtonVisualTypes = {
+    variant?: 'danger' | 'ghost' | 'primary' | 'secondary' | 'tertiary';
     visualType?: 'button';
-    variant?: 'primary' | 'secondary' | 'tertiary' | 'ghost' | 'danger';
 } | {
+    variant?: 'danger' | 'ghost' | 'standard';
     visualType?: 'action';
-    variant?: 'standard' | 'ghost' | 'danger';
 } | {
+    variant?: 'outline' | 'primary' | 'secondary';
     visualType?: 'nav';
-    variant?: 'primary' | 'outline' | 'secondary';
 } | {
-    visualType?: 'text';
     variant?: 'primary' | 'secondary';
+    visualType?: 'text';
 };
 type TButtonOwnProps = {
     as?: 'button' | 'span';
     className?: string;
     onlyIcon?: boolean;
-} & React.ButtonHTMLAttributes<HTMLButtonElement> & PropsWithChildren & TButtonVisualTypes;
+} & PropsWithChildren & React.ButtonHTMLAttributes<HTMLButtonElement> & TButtonVisualTypes;
 export type TButtonProps<T extends React.ElementType = typeof defaultElement> = PolymorphicPropsWithoutRef<TButtonOwnProps, T>;
-export declare function Button<T extends React.ElementType = typeof defaultElement>({ as, children, variant, className, visualType, onlyIcon, ...rest }: TButtonProps<T>): React.JSX.Element;
+export declare function Button<T extends React.ElementType = typeof defaultElement>({ as, children, className, onlyIcon, variant, visualType, ...rest }: TButtonProps<T>): React.JSX.Element;
 export {};

package/dist/esm/src/components/Callout/index.d.ts

@@ -1,11 +1,11 @@
 import React, { PropsWithChildren } from 'react';
 import { TTypographyProps } from '../Typography';
 export type TCalloutRootProps = {
-    type?: 'primary' | 'secondary' | 'warning' | 'error' | 'positive';
+    type?: 'error' | 'positive' | 'primary' | 'secondary' | 'warning';
 };
 export type TCalloutTextProps = TTypographyProps<'p'>;
 export declare const Callout: {
-    Root: ({ type, children }: PropsWithChildren<TCalloutRootProps>) => React.JSX.Element;
     Icon: ({ size, weight, ...rest }: import("../Icon").TIconProps) => React.JSX.Element;
+    Root: ({ children, type }: PropsWithChildren<TCalloutRootProps>) => React.JSX.Element;
     Text: ({ children, ...props }: PropsWithChildren<TCalloutTextProps>) => React.JSX.Element;
 };

package/dist/esm/src/components/Card/index.d.ts

@@ -2,20 +2,20 @@ import React, { PropsWithChildren } from 'react';
 import { PolymorphicPropsWithoutRef } from '../../types/PolymorphicWithoutRef';
 declare const defaultElement = "div";
 export type TCardVariants = {
-    visual?: 'primary' | 'secondary' | 'tertiary';
+    elementType?: 'div';
+    radius?: 'large' | 'medium' | 'none' | 'small';
     size?: {
-        vertical: 'none' | 'extra-small' | 'small' | 'medium' | 'large';
-        horizontal: 'none' | 'extra-small' | 'small' | 'medium' | 'large';
+        horizontal: 'extra-small' | 'large' | 'medium' | 'none' | 'small';
+        vertical: 'extra-small' | 'large' | 'medium' | 'none' | 'small';
     };
-    radius?: 'none' | 'small' | 'medium' | 'large';
-    elementType?: 'div';
+    visual?: 'primary' | 'secondary' | 'tertiary';
 };
 export interface ICardOwnProps extends React.HTMLAttributes<HTMLDivElement>, PropsWithChildren {
     as?: 'div';
-    variants?: TCardVariants;
     className?: string;
     isSquare?: boolean;
+    variants?: TCardVariants;
 }
 export type ICardProps<T extends React.ElementType = typeof defaultElement> = PolymorphicPropsWithoutRef<ICardOwnProps, T>;
-export declare function Card<T extends React.ElementType = typeof defaultElement>({ as, children, variants, className, isSquare, ...rest }: ICardProps<T>): React.JSX.Element;
+export declare function Card<T extends React.ElementType = typeof defaultElement>({ as, children, className, isSquare, variants, ...rest }: ICardProps<T>): React.JSX.Element;
 export {};

package/dist/esm/src/components/Cards/index.d.ts

@@ -1,9 +1,9 @@
 import React, { PropsWithChildren } from 'react';
 export type CardsVariants = {
-    layout?: 'bento-three' | 'bento-four' | 'bento-five';
+    layout?: 'bento-five' | 'bento-four' | 'bento-three';
 };
 export interface ICardsProps extends PropsWithChildren {
-    as: 'div' | 'ol' | 'ul' | 'section';
+    as: 'div' | 'ol' | 'section' | 'ul';
     variants: CardsVariants;
 }
 export declare const Cards: ({ as, children, variants }: ICardsProps) => React.JSX.Element;

package/dist/esm/src/components/Checkbox/index.d.ts

@@ -1,11 +1,11 @@
 import React, { ReactNode } from 'react';
 import { FieldValues, Path } from 'react-hook-form';
 export type TCheckboxProps<T extends FieldValues> = {
+    className?: string;
+    disabled?: boolean;
     id: string;
+    label: ReactNode | string;
     name: Path<T>;
-    label: string | ReactNode;
-    disabled?: boolean;
-    className?: string;
-    variant?: 'radio' | 'checkbox';
+    variant?: 'checkbox' | 'radio';
 };
 export declare const Checkbox: <T extends FieldValues>(props: TCheckboxProps<T>) => React.JSX.Element;

package/dist/esm/src/components/Columns/index.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 export type TColumnsProps = {
-    cols: number;
     children: React.ReactNode;
+    cols: number;
 };
-export declare const Columns: ({ cols, children }: TColumnsProps) => React.JSX.Element;
+export declare const Columns: ({ children, cols }: TColumnsProps) => React.JSX.Element;

package/dist/esm/src/components/ComboBox/index.d.ts

@@ -1,17 +1,17 @@
 import React, { ReactNode } from 'react';
 import { ControllerRenderProps, FieldValues } from 'react-hook-form';
 export type TComboBoxItem = {
-    text: string;
     img?: string;
     render?: ReactNode;
+    text: string;
 };
 export type TComboBoxProps = {
+    alwaysOpen?: boolean;
+    field: ControllerRenderProps<FieldValues>;
     label: string;
     name: string;
-    options: TComboBoxItem[];
     onSelect?: (item: TComboBoxItem) => void;
-    alwaysOpen?: boolean;
-    field: ControllerRenderProps<FieldValues>;
+    options: TComboBoxItem[];
 };
 export declare const ComboBox: (props: Omit<TComboBoxProps, "field">) => React.JSX.Element;
-export declare const Field: ({ label, options, onSelect, alwaysOpen, field: { onBlur, ...restField } }: TComboBoxProps) => React.JSX.Element;
+export declare const Field: ({ alwaysOpen, field: { onBlur, ...restField }, label, onSelect, options }: TComboBoxProps) => React.JSX.Element;

package/dist/esm/src/components/DatePicker/index.d.ts

@@ -1,14 +1,14 @@
 import React from 'react';
 import { FieldValues, Path } from 'react-hook-form';
 export type TDatePicker<T extends FieldValues> = {
-    id: string;
-    name: Path<T>;
-    label: string;
+    disabled?: boolean;
     helper?: {
         message: string;
     };
-    min?: string;
+    id: string;
+    label: string;
     max?: string;
-    disabled?: boolean;
+    min?: string;
+    name: Path<T>;
 };
 export declare const DatePicker: <T extends FieldValues>(props: TDatePicker<T>) => React.JSX.Element;

package/dist/esm/src/components/Disclosure/index.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 export type TDisclosureProps = {
-    condition: boolean;
     children: React.ReactNode;
+    condition: boolean;
 };
-export declare const Disclosure: ({ condition, children }: TDisclosureProps) => React.JSX.Element;
+export declare const Disclosure: ({ children, condition }: TDisclosureProps) => React.JSX.Element;

package/dist/esm/src/components/Form/index.d.ts

@@ -1,8 +1,8 @@
-import React, { PropsWithChildren, HTMLProps } from 'react';
+import React, { HTMLProps, PropsWithChildren } from 'react';
 import { FieldValues, UseFormReturn } from 'react-hook-form';
-type TFormProps<T extends FieldValues> = PropsWithChildren<HTMLProps<HTMLFormElement>> & {
+type TFormProps<T extends FieldValues> = {
     methods: UseFormReturn<T>;
     onSubmit: (values: T) => void;
-};
-export declare const Form: <T extends FieldValues>({ methods, children, onSubmit, ...rest }: TFormProps<T>) => React.JSX.Element;
+} & PropsWithChildren<HTMLProps<HTMLFormElement>>;
+export declare const Form: <T extends FieldValues>({ children, methods, onSubmit, ...rest }: TFormProps<T>) => React.JSX.Element;
 export {};

package/dist/esm/src/components/Icon/index.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { MaterialSymbolProps } from 'react-material-symbols';
 export type TIconProps = {
-    size?: 'regular' | 'large' | 'xlarge';
-    weight?: 'light' | 'normal' | 'medium';
+    size?: 'large' | 'regular' | 'xlarge';
+    weight?: 'light' | 'medium' | 'normal';
 } & Omit<MaterialSymbolProps, 'size' | 'weight'>;
 export declare const Icon: ({ size, weight, ...rest }: TIconProps) => React.JSX.Element;

package/dist/esm/src/components/Link/index.d.ts

@@ -3,9 +3,9 @@ type PolymorphicLink<T extends ElementType> = {
     as?: T;
     className?: string;
 } & PropsWithChildren;
-type AnchorProps = React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+type AnchorProps = {
     as?: undefined;
-};
-export type TLink<T extends ElementType> = PolymorphicLink<T> | AnchorProps;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+export type TLink<T extends ElementType> = AnchorProps | PolymorphicLink<T>;
 export declare const Link: <T extends ElementType = "a">({ as, children, className, ...rest }: TLink<T>) => React.JSX.Element;
 export {};

package/dist/esm/src/components/Loading/index.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
 declare const sizes: {
-    small: string;
-    medium: string;
-    large: string;
     full: string;
+    large: string;
+    medium: string;
+    small: string;
 };
 export type TLoadingProps = {
     size?: keyof typeof sizes;

package/dist/esm/src/components/Modal/index.d.ts

@@ -2,32 +2,32 @@ import React, { ButtonHTMLAttributes, PropsWithChildren } from 'react';
 import { TButtonProps } from '../Button';
 export type TUseModalProps = {
     activeModal: string;
+    close: () => void;
     isOpen: boolean;
     open: (value: string) => void;
-    close: () => void;
 };
 export declare const useModal: import("zustand").UseBoundStore<import("zustand").StoreApi<TUseModalProps>>;
 export type TModalContentProps = {
     children: React.ReactNode;
-    value: string;
-    focusTrap?: boolean;
     closeOnBackdropClick?: boolean;
+    focusTrap?: boolean;
+    value: string;
 };
 export type TModalControlProps = {
     children: React.ReactNode;
     value: string;
 } & TButtonProps;
 export type TModalHeaderProps = {
+    actionButtonProps?: ButtonHTMLAttributes<HTMLButtonElement>;
+    onClick?: () => void;
     title: string;
     variant?: 'action';
-    onClick?: () => void;
-    actionButtonProps?: ButtonHTMLAttributes<HTMLButtonElement>;
 };
 export type TModalButtonProps = PropsWithChildren;
 export declare const Buttons: ({ children }: TModalButtonProps) => React.JSX.Element;
 export declare const Modal: {
-    Content: ({ value, children, focusTrap, closeOnBackdropClick }: TModalContentProps) => React.JSX.Element;
-    Control: ({ value, children, ...rest }: TModalControlProps) => React.JSX.Element;
-    Header: ({ title, variant, onClick, actionButtonProps }: TModalHeaderProps) => React.JSX.Element;
     Buttons: ({ children }: TModalButtonProps) => React.JSX.Element;
+    Content: ({ children, closeOnBackdropClick, focusTrap, value }: TModalContentProps) => React.JSX.Element;
+    Control: ({ children, value, ...rest }: TModalControlProps) => React.JSX.Element;
+    Header: ({ actionButtonProps, onClick, title, variant }: TModalHeaderProps) => React.JSX.Element;
 };

package/dist/esm/src/components/NumberField/index.d.ts

@@ -1,13 +1,13 @@
 import React from 'react';
 import { FieldValues, Path } from 'react-hook-form';
 export type TNumberFieldProps<T extends FieldValues> = {
-    label: string;
-    name: Path<T>;
-    min?: number;
-    max?: number;
-    width?: number;
     helper?: {
         message: string;
     };
+    label: string;
+    max?: number;
+    min?: number;
+    name: Path<T>;
+    width?: number;
 };
 export declare const NumberField: <T extends FieldValues>(props: TNumberFieldProps<T>) => React.JSX.Element;

package/dist/esm/src/components/PhoneField/index.d.ts

@@ -1,13 +1,13 @@
 import React, { ReactNode } from 'react';
 import { FieldValues, Path } from 'react-hook-form';
 export type TPhoneFieldProps<T extends FieldValues> = {
-    id: string;
-    name: Path<T>;
+    className?: string;
     disabled?: boolean;
     helper?: {
         message: ReactNode | string;
     };
-    className?: string;
+    id: string;
+    name: Path<T>;
     placeholder?: string;
 };
 export declare const PhoneField: <T extends FieldValues>(props: TPhoneFieldProps<T>) => React.JSX.Element;

package/dist/esm/src/components/PinInput/index.d.ts

@@ -1,11 +1,12 @@
 import React from 'react';
 import { FieldValues, Path } from 'react-hook-form';
 export interface TPinInputProps<T extends FieldValues> {
-    name: Path<T>;
-    length: number;
-    label: string;
+    isNumeric?: boolean;
     isOTP?: boolean;
     isPassword?: boolean;
-    isNumeric?: boolean;
+    label: string;
+    length: number;
+    name: Path<T>;
 }
 export declare const PinInput: <T extends FieldValues>(props: TPinInputProps<T>) => React.JSX.Element;
+export declare const OTPInput: () => React.JSX.Element;

package/dist/esm/src/components/Popover/index.d.ts

@@ -1,10 +1,10 @@
-import React from 'react';
 import * as RadixPopover from '@radix-ui/react-popover';
+import React from 'react';
 export type TPopoverRootProps = React.ComponentPropsWithoutRef<typeof RadixPopover.Root>;
 export type TPopoverTriggerProps = React.ComponentPropsWithoutRef<typeof RadixPopover.Trigger>;
 export type TPopoverContentProps = React.ComponentPropsWithoutRef<typeof RadixPopover.Content>;
 export declare const Popover: {
+    Content: ({ children, ...rest }: TPopoverContentProps) => React.JSX.Element;
     Root: (props: TPopoverRootProps) => React.JSX.Element;
     Trigger: ({ children, ...rest }: TPopoverTriggerProps) => React.JSX.Element;
-    Content: ({ children, ...rest }: TPopoverContentProps) => React.JSX.Element;
 };

package/dist/esm/src/components/ProgressIndicator/index.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
 export type TProgressIndicatorProps = {
-    label?: string;
-    size?: 'small' | 'medium' | 'full-width';
     current?: number;
+    label?: string;
     max?: number;
+    size?: 'full-width' | 'medium' | 'small';
 };
-export declare const ProgressIndicator: ({ label, size, current, max }: TProgressIndicatorProps) => React.JSX.Element;
+export declare const ProgressIndicator: ({ current, label, max, size }: TProgressIndicatorProps) => React.JSX.Element;

package/dist/esm/src/components/RadioGroup/index.d.ts

@@ -1,16 +1,16 @@
-import React from 'react';
 import * as RadixRadioGroup from '@radix-ui/react-radio-group';
+import React from 'react';
 import { FieldError, FieldValues, Path } from 'react-hook-form';
 export type TRadioGroupProps<T extends FieldValues> = {
-    name: Path<T>;
+    error?: FieldError;
     label: string;
+    name: Path<T>;
     variant?: 'cards' | 'circle';
-    error?: FieldError;
 } & Omit<RadixRadioGroup.RadioGroupProps, 'name'>;
 export declare const RadioGroup: {
-    Root: <T extends FieldValues>({ children, className, name, label, variant, disabled, ...props }: TRadioGroupProps<T>) => React.JSX.Element;
-    Item: ({ children, className, variant, ...props }: RadixRadioGroup.RadioGroupItemProps & {
-        variant?: "circle" | "cards";
-    }) => React.JSX.Element;
     Indicator: ({ className, ...props }: RadixRadioGroup.RadioGroupIndicatorProps) => React.JSX.Element;
+    Item: ({ children, className, variant, ...props }: {
+        variant?: "cards" | "circle";
+    } & RadixRadioGroup.RadioGroupItemProps) => React.JSX.Element;
+    Root: <T extends FieldValues>({ children, className, disabled, label, name, variant, ...props }: TRadioGroupProps<T>) => React.JSX.Element;
 };

package/dist/esm/src/components/Range/index.d.ts

@@ -1,15 +1,15 @@
 import React from 'react';
 import { FieldValues, Path } from 'react-hook-form';
 export type TRangeProps<T extends FieldValues> = {
+    helper?: {
+        message: string;
+    };
     id: string;
     label: string;
-    name: Path<T>;
-    min?: number;
     max?: number;
-    step?: number;
+    min?: number;
+    name: Path<T>;
     showValue?: boolean;
-    helper?: {
-        message: string;
-    };
+    step?: number;
 };
 export declare const Range: <T extends FieldValues>(props: TRangeProps<T>) => React.JSX.Element;

package/dist/esm/src/components/Select/index.d.ts

@@ -5,21 +5,21 @@ export type TItem = {
     title: string;
 };
 export type TSelectProps<T extends FieldValues> = {
-    id: string;
-    label: string;
-    name: Path<T>;
+    children?: ReactNode;
+    defaultValue?: string;
+    disabled?: boolean;
     helper?: {
         message: string;
     };
+    id: string;
     items?: {
         id: string;
-        title: string;
         props?: OptionHTMLAttributes<HTMLOptionElement>;
+        title: string;
     }[];
-    placeholder?: string;
-    disabled?: boolean;
-    defaultValue?: string;
+    label: string;
     missing?: boolean;
-    children?: ReactNode;
+    name: Path<T>;
+    placeholder?: string;
 };
 export declare const Select: <T extends FieldValues>(props: TSelectProps<T>) => React.JSX.Element;

package/dist/esm/src/components/Skeleton/index.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 export type TSkeletonProps = {
-    width?: string;
     height?: string;
     rounded?: boolean;
+    width?: string;
 };
-export declare const Skeleton: ({ width, height, rounded }: TSkeletonProps) => React.JSX.Element;
+export declare const Skeleton: ({ height, rounded, width }: TSkeletonProps) => React.JSX.Element;

package/dist/esm/src/components/Table/index.d.ts

@@ -7,11 +7,11 @@ export declare const TableRow: ({ children }: PropsWithChildren) => React.JSX.El
 export declare const TableData: ({ children }: PropsWithChildren) => React.JSX.Element;
 export declare const TableFooter: ({ children }: PropsWithChildren) => React.JSX.Element;
 export declare const Table: {
-    Root: ({ children }: PropsWithChildren) => React.JSX.Element;
-    Head: ({ children }: PropsWithChildren) => React.JSX.Element;
-    Header: ({ children }: PropsWithChildren) => React.JSX.Element;
     Body: ({ children }: PropsWithChildren) => React.JSX.Element;
-    Row: ({ children }: PropsWithChildren) => React.JSX.Element;
     Data: ({ children }: PropsWithChildren) => React.JSX.Element;
     Footer: ({ children }: PropsWithChildren) => React.JSX.Element;
+    Head: ({ children }: PropsWithChildren) => React.JSX.Element;
+    Header: ({ children }: PropsWithChildren) => React.JSX.Element;
+    Root: ({ children }: PropsWithChildren) => React.JSX.Element;
+    Row: ({ children }: PropsWithChildren) => React.JSX.Element;
 };

package/dist/esm/src/components/Tabs/index.d.ts

@@ -1,12 +1,12 @@
-import React from 'react';
 import * as RadixTabs from '@radix-ui/react-tabs';
+import React from 'react';
 export type TTabsRoot = React.ComponentProps<typeof RadixTabs.Root>;
 export type TTabsList = React.ComponentProps<typeof RadixTabs.List>;
 export type TTabsTrigger = React.ComponentProps<typeof RadixTabs.Trigger>;
 export type TTabsContent = React.ComponentProps<typeof RadixTabs.Content>;
 export declare const Tabs: {
-    Root: ({ children, ...rest }: TTabsRoot) => React.JSX.Element;
+    Content: ({ children, ...rest }: TTabsContent) => React.JSX.Element;
     List: ({ children, ...rest }: TTabsList) => React.JSX.Element;
+    Root: ({ children, ...rest }: TTabsRoot) => React.JSX.Element;
     Trigger: ({ children, ...rest }: TTabsTrigger) => React.JSX.Element;
-    Content: ({ children, ...rest }: TTabsContent) => React.JSX.Element;
 };

package/dist/esm/src/components/Tag/index.d.ts

@@ -1,14 +1,14 @@
 import React, { ReactNode } from 'react';
 import { TTypographyProps } from '../Typography';
 export type TTagProps = {
-    variant?: 'primary' | 'secondary' | 'tertiary' | 'positive' | 'danger' | 'warning' | 'night';
+    children: ReactNode | ReactNode[];
     circularIcon?: boolean;
     className?: string;
     icon: boolean;
-    children: ReactNode | ReactNode[];
+    variant?: 'danger' | 'night' | 'positive' | 'primary' | 'secondary' | 'tertiary' | 'warning';
 };
 export declare const Tag: {
-    Root: ({ variant, children, className, icon, circularIcon, ...rest }: TTagProps) => React.JSX.Element;
-    Icon: ({ size, weight, ...rest }: import("../Icon").TIconProps) => React.JSX.Element;
     Content: ({ children, ...rest }: TTypographyProps) => React.JSX.Element;
+    Icon: ({ size, weight, ...rest }: import("../Icon").TIconProps) => React.JSX.Element;
+    Root: ({ children, circularIcon, className, icon, variant, ...rest }: TTagProps) => React.JSX.Element;
 };

package/dist/esm/src/components/TextField/index.d.ts

@@ -1,20 +1,20 @@
 import React, { DetailedHTMLProps, InputHTMLAttributes, ReactNode } from 'react';
 import { FieldValues, Path } from 'react-hook-form';
 export type TTextFieldProps<T extends FieldValues> = {
-    id: string;
-    label: string;
-    name: Path<T>;
+    className?: string;
     disabled?: boolean;
+    disableError?: boolean;
     helper?: {
         message: ReactNode | string;
     };
-    type?: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>['type'];
-    prefix?: string | ReactNode;
-    suffix?: string | ReactNode;
-    className?: string;
-    rightContent?: ReactNode | string;
+    id: string;
+    label: string;
     leftContent?: ReactNode | string;
     missing?: boolean;
-    disableError?: boolean;
+    name: Path<T>;
+    prefix?: ReactNode | string;
+    rightContent?: ReactNode | string;
+    suffix?: ReactNode | string;
+    type?: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>['type'];
 } & DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
 export declare const TextField: React.ForwardRefExoticComponent<Omit<TTextFieldProps<FieldValues>, "ref"> & React.RefAttributes<HTMLInputElement>>;

package/dist/esm/src/components/Toast/index.d.ts

@@ -4,16 +4,16 @@ export type TToastRootProps = {
     children: React.ReactNode;
 };
 export type TToastTitleProps = {
-    className?: string;
     children: React.ReactNode;
+    className?: string;
 };
 export type TToastDescriptionProps = {
     children: React.ReactNode;
 };
 export type TToastIconProps = TIconProps;
 export declare const Toast: {
-    Root: ({ children }: TToastRootProps) => React.JSX.Element;
-    Title: ({ className, children }: TToastTitleProps) => React.JSX.Element;
     Description: ({ children }: TToastDescriptionProps) => React.JSX.Element;
     Icon: (props: TToastIconProps) => React.JSX.Element;
+    Root: ({ children }: TToastRootProps) => React.JSX.Element;
+    Title: ({ children, className }: TToastTitleProps) => React.JSX.Element;
 };

package/dist/esm/src/components/Tooltip/index.d.ts

@@ -1,14 +1,14 @@
-import React from 'react';
 import * as RadixTooltip from '@radix-ui/react-tooltip';
+import React from 'react';
 export type TTooltipRootProps = React.ComponentProps<typeof RadixTooltip.Root>;
-export type TTooltipTriggerProps = React.ComponentProps<typeof RadixTooltip.Trigger> & {
+export type TTooltipTriggerProps = {
     className?: string;
-};
-export type TTooltipContentProps = React.ComponentProps<typeof RadixTooltip.Content> & {
+} & React.ComponentProps<typeof RadixTooltip.Trigger>;
+export type TTooltipContentProps = {
     className?: string;
-};
+} & React.ComponentProps<typeof RadixTooltip.Content>;
 export declare const Tooltip: {
+    Content: ({ children, className, ...rest }: TTooltipContentProps) => React.JSX.Element;
     Root: ({ children, ...rest }: TTooltipRootProps) => React.JSX.Element;
-    Trigger: ({ className, children, ...rest }: TTooltipTriggerProps) => React.JSX.Element;
-    Content: ({ className, children, ...rest }: TTooltipContentProps) => React.JSX.Element;
+    Trigger: ({ children, className, ...rest }: TTooltipTriggerProps) => React.JSX.Element;
 };