abrplus-ui-kit 0.2.9

package/dist/types/components/molecules/input/tag/index.d.ts

@@ -0,0 +1,13 @@
+import { InputFieldError } from '../../../../configs';
+import { default as React } from 'react';
+import { InputDefaultProps } from '../default';
+export interface InputTagProps extends Omit<InputDefaultProps, 'value' | 'onChange'> {
+    value?: string[];
+    onChange?: (tags: string[]) => void;
+    label?: string | React.ReactNode;
+    required?: boolean;
+    hideErrorMessage?: boolean;
+    wrapperClassName?: string;
+    error?: InputFieldError;
+}
+export declare const InputTag: React.MemoExoticComponent<({ value, onChange, placeholder, disabled, label, required, hideErrorMessage, error, wrapperClassName, }: InputTagProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/components/molecules/inputDatePicker/index.d.ts

@@ -0,0 +1,17 @@
+import { InputDatePickerProps as Props } from 'jalaali-react-date-picker';
+import { InputFieldError } from '../../../configs';
+export interface InputDatePickerProps extends Omit<Props, 'wrapperClassName' | 'error'> {
+    wrapperClassName?: string;
+    /**
+     * if `error` property provided, regardless of its value, the error gap is applied to component.
+     */
+    error?: InputFieldError;
+    label?: string | React.ReactNode;
+    required?: boolean;
+    helperText?: string;
+    onChangeISO?: (date: string | undefined) => void;
+    valueISO?: string;
+    hideErrorMessage?: boolean;
+    placeholder?: string;
+}
+export declare const InputDatePicker: ({ helperText, required, label, error, wrapperClassName, onChange: onChangeProp, onChangeISO, value: valueProp, valueISO, locale, placeholder, wrapperStyle, hideErrorMessage, ...props }: InputDatePickerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/molecules/inputErrorMessage/index.d.ts

@@ -0,0 +1,9 @@
+export interface ErrorProps {
+    name?: string;
+    children?: React.ReactNode;
+    textColor?: string;
+    message?: string;
+    testID?: string;
+    className?: string;
+}
+export declare const InputErrorMessage: ({ children, message, textColor, className }: ErrorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/molecules/inputRangePicker/index.d.ts

@@ -0,0 +1,16 @@
+import { InputRangePickerProps as Props } from 'jalaali-react-date-picker';
+import { InputFieldError } from '../../../configs';
+export interface InputRangePickerProps extends Omit<Props, 'wrapperClassName' | 'error'> {
+    wrapperClassName?: string;
+    inputWrapperClassName?: string;
+    /**
+     * if `error` property provided, regardless of its value, the error gap is applied to component.
+     */
+    error?: InputFieldError;
+    label?: string | React.ReactNode;
+    required?: boolean;
+    helperText?: string;
+    hideErrorMessage?: boolean;
+    height?: number | string;
+}
+export declare const InputRangePicker: ({ helperText, required, label, error, wrapperClassName, inputWrapperClassName, value, locale, wrapperStyle, hideErrorMessage, height, ...props }: InputRangePickerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/molecules/logo/index.d.ts

@@ -0,0 +1,25 @@
+import { LogoIconNameType } from '../../../configs';
+import { CSSProperties } from 'react';
+import { TooltipProps } from '../..';
+export type LogoProps = {
+    style?: CSSProperties;
+    shape?: 'circle' | 'square';
+    className?: string;
+    toolTipTitle?: string;
+    iconName?: LogoIconNameType;
+    hasAnimation?: boolean;
+    iconSize?: number;
+    badged?: boolean;
+    isFullSizeLogo?: boolean;
+    badgeColor?: string;
+    badgeStatus?: 'success' | 'error' | 'warn' | 'default';
+    badgePosition?: 'left' | 'right';
+    onClick?: () => void;
+    imageSrc?: string;
+} & ({
+    hasToolTip: true;
+    tooltipProps?: Partial<TooltipProps>;
+} | {
+    hasToolTip?: false;
+});
+export declare const Logo: ({ style, shape, className, toolTipTitle, imageSrc, iconName, badgeStatus, badgePosition, badgeColor, badged, hasAnimation, iconSize, isFullSizeLogo, onClick, ...rest }: LogoProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/molecules/noResult/index.d.ts

@@ -0,0 +1,8 @@
+import { IconsNames } from 'src/components/atoms';
+import { SelectProps } from '../select';
+export interface NotResultTextProps extends Pick<SelectProps<any>, 'error' | 'noContentFoundMessage'> {
+    errorIcon?: IconsNames;
+    noContentIcon?: IconsNames;
+}
+declare const NotResult: ({ error, noContentFoundMessage, errorIcon, noContentIcon, }: NotResultTextProps) => import("react/jsx-runtime").JSX.Element;
+export { NotResult };

package/dist/types/components/molecules/notification/index.d.ts

@@ -0,0 +1,13 @@
+import { ArgsProps } from 'antd/lib/notification';
+declare const useNotification: () => {
+    success: (props: ArgsProps) => void;
+    neutral: (props: ArgsProps) => void;
+    negative: (props: ArgsProps) => void;
+    informative: (props: ArgsProps) => void;
+    successfullyAdded: () => void;
+    successfullyEdited: () => void;
+    successfullyDeleted: () => void;
+    copied: () => void;
+    error: (error?: string) => void;
+};
+export { useNotification };

package/dist/types/components/molecules/select/components/clearIcon.d.ts

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

package/dist/types/components/molecules/select/components/index.d.ts

@@ -0,0 +1,5 @@
+export * from './clearIcon';
+export * from './label';
+export * from './notFound';
+export * from './placeholder';
+export * from './suffix';

package/dist/types/components/molecules/select/components/label.d.ts

@@ -0,0 +1,6 @@
+import { SelectProps } from '../../..';
+export interface SelectLabelProps extends Pick<SelectProps<any>, 'label' | 'size' | 'disabled' | 'required' | 'labelExtraNode'> {
+    offset?: number;
+}
+declare const SelectLabel: ({ disabled, label, labelExtraNode, required, size, offset, }: SelectLabelProps) => import("react/jsx-runtime").JSX.Element | null;
+export { SelectLabel };

package/dist/types/components/molecules/select/components/notFound.d.ts

@@ -0,0 +1,5 @@
+import { SelectProps } from '../types';
+export interface SelectNotFoundProps extends Pick<SelectProps<any>, 'error' | 'noContentFoundMessage'> {
+}
+declare const SelectNotFound: ({ error, noContentFoundMessage }: SelectNotFoundProps) => import("react/jsx-runtime").JSX.Element;
+export { SelectNotFound };

package/dist/types/components/molecules/select/components/placeholder.d.ts

@@ -0,0 +1,7 @@
+import { SelectProps } from '..';
+export interface SelectPlaceholderProps extends Pick<SelectProps<any>, 'placeholder' | 'disabled'> {
+    isHovered?: boolean;
+    isTabFocused?: boolean;
+}
+declare const SelectPlaceholder: ({ placeholder, isHovered, disabled, isTabFocused, }: SelectPlaceholderProps) => import("react/jsx-runtime").JSX.Element;
+export { SelectPlaceholder };

package/dist/types/components/molecules/select/components/suffix.d.ts

@@ -0,0 +1,10 @@
+import { InputFieldError } from '../../../../configs';
+import { SelectProps } from '..';
+export interface SelectSuffixProps extends Pick<SelectProps<any>, 'disabled' | 'loading'> {
+    isHovered?: boolean;
+    isTabFocused?: boolean;
+    disabled?: boolean;
+    error?: InputFieldError;
+}
+declare const SelectSuffix: ({ isHovered, isTabFocused, disabled, error }: SelectSuffixProps) => import("react/jsx-runtime").JSX.Element;
+export { SelectSuffix };

package/dist/types/components/molecules/select/index.d.ts

@@ -0,0 +1,13 @@
+import { DefaultSelectOption, PlusTreeSelectProps, SelectInfinite, SelectProps, SelectRawValue } from './types';
+declare const Select: {
+    readonly Tree: <TMultiple extends boolean>({ initialValue, value: valueProps, label, beforeLabelIcon, renderPrefix, treeData, placeholder, treeDefaultExpandAll, warning, disabled, searchable, addable, multiple, onChange, onAddButtonClick, renderItem, className, style, onTreeExpand, onSearch, localSearch, wrapperClassName, error, required, size, labelOffset, hasError, addonBefore, popupClassName, header, footer, onSelect, onDeselect, treeDataHashMap, ...rest }: PlusTreeSelectProps<TMultiple>) => import("react/jsx-runtime").JSX.Element;
+    readonly Single: <T extends Record<string, any> = DefaultSelectOption>(props: SelectProps<T, "single"> & {
+        ref?: React.ForwardedRef<HTMLUListElement>;
+    }) => import('react').ReactElement | null;
+    readonly Multiple: <T extends Record<string, any> = DefaultSelectOption>(props: SelectProps<T, "multiple"> & {
+        ref?: React.ForwardedRef<HTMLUListElement>;
+    }) => import('react').ReactElement | null;
+};
+export * from './components';
+export { Select };
+export type { DefaultSelectOption, PlusTreeSelectProps, SelectInfinite, SelectProps, SelectRawValue, };

package/dist/types/components/molecules/select/multiple/index.d.ts

@@ -0,0 +1,5 @@
+import { default as React, ReactElement } from 'react';
+import { DefaultSelectOption, SelectProps } from '../types';
+export declare const MultipleSelect: <T extends Record<string, any> = DefaultSelectOption>(props: SelectProps<T, "multiple"> & {
+    ref?: React.ForwardedRef<HTMLUListElement>;
+}) => ReactElement | null;

package/dist/types/components/molecules/select/single/index.d.ts

@@ -0,0 +1,5 @@
+import { default as React, ReactElement } from 'react';
+import { DefaultSelectOption, SelectProps } from '../types';
+export declare const SingleSelect: <T extends Record<string, any> = DefaultSelectOption>(props: SelectProps<T, "single"> & {
+    ref?: React.ForwardedRef<HTMLUListElement>;
+}) => ReactElement | null;

package/dist/types/components/molecules/select/style.d.ts

@@ -0,0 +1,8 @@
+import { ThemeConfig } from 'antd';
+export declare const CustomizedAntSelectConfig: ThemeConfig;
+export declare const generateSelectClassNames: ({ size, error, disabled, isTabFocused, }: {
+    size: "small" | "medium" | "large";
+    error?: boolean;
+    disabled: boolean;
+    isTabFocused: boolean;
+}) => string;

package/dist/types/components/molecules/select/treeSelect/index.d.ts

@@ -0,0 +1,2 @@
+import { PlusTreeSelectProps } from '../types';
+export declare const PlusTreeSelect: <TMultiple extends boolean>({ initialValue, value: valueProps, label, beforeLabelIcon, renderPrefix, treeData, placeholder, treeDefaultExpandAll, warning, disabled, searchable, addable, multiple, onChange, onAddButtonClick, renderItem, className, style, onTreeExpand, onSearch, localSearch, wrapperClassName, error, required, size, labelOffset, hasError, addonBefore, popupClassName, header, footer, onSelect, onDeselect, treeDataHashMap, ...rest }: PlusTreeSelectProps<TMultiple>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/molecules/select/types.d.ts

@@ -0,0 +1,108 @@
+import { SelectProps as AntSelectProps } from 'antd';
+import { TreeSelectProps } from 'antd/lib';
+import { LabeledValue } from 'antd/lib/select';
+import { default as React, ReactNode } from 'react';
+import { ITreeOption, InputFieldError } from '../../../configs';
+import { IconsNames } from '../../atoms';
+import { TagProps } from '../tag';
+export { TreeSelect } from 'antd';
+export type SelectRawValue = string | number | null;
+export type DynamicValue<T, P> = P extends 'single' ? T | null : T[];
+export type GetValueType<VALUE, TMultiple extends boolean | undefined> = TMultiple extends false | undefined ? VALUE | null : VALUE[] | null;
+export interface SelectProps<T extends Record<string, any> | unknown, P extends 'single' | 'multiple' = 'single'> extends Omit<AntSelectProps<T>, 'onChange' | 'options' | 'labelInValue' | 'optionLabelProp' | 'disabled' | 'size' | 'allowClear' | 'value' | 'mode'> {
+    /**
+     * if `error` property provided, regardless of its value, the error gap is applied to component.
+     */
+    error?: InputFieldError;
+    /**
+     *  pass this prop to only show negative border
+     */
+    hasError?: boolean;
+    hideErrorMessage?: boolean;
+    underlined?: boolean;
+    label?: string | ReactNode;
+    labelOffset?: number;
+    labelExtraNode?: ReactNode;
+    labelExtractor?: (item: T) => ReactNode | string;
+    valueExtractor?: (item: T) => string;
+    tagExtractor?: (item: T) => string;
+    getTagProps?: (item: DefaultSelectOption) => Omit<TagProps, 'title'>;
+    disableExtractor?: (item: T) => boolean;
+    options?: T[];
+    showSearch?: boolean;
+    renderItem?: (item: T, index: number, isActive: boolean, disabled?: boolean) => React.ReactNode;
+    onClickItem?: (value: SelectOption<LabeledValue>) => void;
+    renderSelectedItem?: (item: T) => React.ReactNode;
+    onChange?: (value?: DynamicValue<T, P>) => void;
+    onChangeValue?(value: DynamicValue<SelectRawValue, P>): void;
+    selectedValue?: DynamicValue<SelectRawValue, P>;
+    value?: DynamicValue<T, P>;
+    wrapperClassName?: string;
+    disabled?: boolean;
+    allowClear?: boolean;
+    required?: boolean;
+    lang?: 'fa' | 'en';
+    noContentFoundMessage?: string;
+    labelPosition?: 'vertical' | 'horizontal';
+    size?: 'small' | 'medium' | 'large';
+    footer?: ReactNode;
+    header?: ReactNode;
+    infinite?: SelectInfinite;
+    isLocaleSearch?: boolean;
+    disableOutsideScroll?: boolean;
+    /**
+     * `selectedValue` has more priority than `value`. if `selectedValue` provided the select component ignores the `value`.
+     */
+    addonBefore?: ReactNode;
+    addonAfter?: ReactNode;
+}
+export interface PlusTreeSelectProps<TMultiple extends boolean> extends Omit<TreeSelectProps, 'onTreeExpand' | 'size'> {
+    initialValue?: ITreeOption[];
+    value?: ITreeOption | ITreeOption[] | null;
+    label?: string;
+    beforeLabelIcon?: IconsNames;
+    afterLabelIcon?: IconsNames;
+    renderPrefix?: (options: {
+        value?: any;
+    }) => React.ReactNode;
+    treeData: ITreeOption[];
+    placeholder?: string;
+    treeDefaultExpandAll?: boolean;
+    warning?: boolean;
+    disabled?: boolean;
+    searchable?: boolean;
+    addable?: boolean;
+    multiple?: boolean;
+    onChange?: (value: GetValueType<ITreeOption, TMultiple>) => void;
+    onAddButtonClick?: () => void;
+    renderItem?: (menuItem: ITreeOption) => React.ReactNode;
+    readonly className?: string;
+    style?: React.CSSProperties;
+    onTreeExpand: (keys: Array<ITreeOption['value']>) => void;
+    localSearch?: boolean;
+    size?: 'small' | 'medium' | 'large';
+    footer?: ReactNode;
+    header?: ReactNode;
+    addonBefore?: ReactNode;
+    addonAfter?: ReactNode;
+    error?: InputFieldError;
+    /**
+     *  pass this prop to only show negative border
+     */
+    hasError?: boolean;
+    labelOffset?: number;
+    required?: boolean;
+    wrapperClassName?: string;
+    treeDataHashMap?: Map<ITreeOption['value'], ITreeOption>;
+}
+export declare const SELECT_POPUP_HEIGHT = 200;
+export type DefaultSelectOption = {
+    label?: ReactNode;
+    value: any;
+};
+export type SelectInfinite = {
+    total?: number;
+    fetchNextPage: () => void;
+    hasMore: boolean;
+};
+export type SelectOption<T> = T | null | undefined;

package/dist/types/components/molecules/sortableList/index.d.ts

@@ -0,0 +1,19 @@
+import { Props as DndContextProps } from '@dnd-kit/core/dist/components/DragOverlay';
+import { Props as SortableContextProps } from '@dnd-kit/sortable/dist/components/SortableContext';
+import { HTMLAttributes, ReactNode } from 'react';
+export interface DraggableItem {
+    id: string | number;
+}
+interface SortableListProps<T extends DraggableItem> {
+    move: (i: number, j: number) => void;
+    data: T[];
+    renderItem: (item: T, index: number) => ReactNode;
+    wrapperClassName?: string;
+    activateDistance?: number;
+    dndContextProps?: DndContextProps;
+    sortableContextProps?: SortableContextProps;
+    sortableWrapperProps?: HTMLAttributes<HTMLDivElement>;
+    sortableItemProps?: HTMLAttributes<HTMLDivElement>;
+}
+export declare const SortableList: <T extends DraggableItem>({ move, renderItem, data, wrapperClassName, activateDistance, dndContextProps, sortableContextProps, sortableWrapperProps: { className: sortableWrapperClassName, ...restSortableWrapperProps }, sortableItemProps, }: SortableListProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/molecules/spliter/index.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface PropsTypes {
+    title?: string;
+    children?: React.ReactNode;
+    direction?: 'center' | 'start' | 'end';
+    expand?: boolean;
+}
+export declare const Spliter: ({ children, title, direction, expand }: PropsTypes) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/molecules/tag/index.d.ts

@@ -0,0 +1,17 @@
+import { default as React, CSSProperties } from 'react';
+export interface TagProps {
+    closable?: boolean;
+    onClose?: (e: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    visible?: boolean;
+    imageSrc?: string;
+    title: string;
+    disabled?: boolean;
+    error?: boolean;
+    height?: number;
+    readonly className?: string;
+    style?: CSSProperties;
+    autoSlice?: boolean;
+    sliceLength?: number;
+}
+declare const Tag: ({ closable, onClose, imageSrc, title, disabled, className, style, autoSlice, sliceLength, }: TagProps) => import("react/jsx-runtime").JSX.Element;
+export { Tag };

package/dist/types/components/molecules/tagCollectionView/index.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+export interface TagCollectionProps {
+    tags?: {
+        value: string;
+        onRemove?: () => void;
+    }[];
+    label?: ReactNode;
+    hasMore?: boolean;
+    fetchNextPage?: () => void;
+    isSearchable?: boolean;
+    noContentFoundMessage?: string;
+    numberOfRows?: number;
+}
+export declare const TagCollectionView: ({ tags, label, hasMore, fetchNextPage, isSearchable, noContentFoundMessage, numberOfRows, }: TagCollectionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/molecules/tagInput/components/notFoundAddItem.d.ts

@@ -0,0 +1,4 @@
+declare const NotFoundAddItem: ({ onAddNewItem }: {
+    onAddNewItem: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export { NotFoundAddItem };

package/dist/types/components/molecules/tagInput/index.d.ts

@@ -0,0 +1,6 @@
+import { default as React, ReactElement } from 'react';
+import { DefaultSelectOption, TagInputProps } from './types';
+export declare const TagInput: <T extends Record<string, any> = DefaultSelectOption>(props: TagInputProps<T> & {
+    ref?: React.ForwardedRef<HTMLUListElement>;
+}) => ReactElement | null;
+export type { SelectOption, TagInputProps } from './types';

package/dist/types/components/molecules/tagInput/style.d.ts

@@ -0,0 +1,9 @@
+import { ThemeConfig } from 'antd';
+import { SelectProps } from '../select/types';
+export declare const CustomizedAntSelectTagConfig: ThemeConfig;
+export declare const generateSelectClassNames: ({ size, error, disabled, isTabFocused, }: {
+    size: SelectProps<any>["size"];
+    error?: boolean;
+    disabled: SelectProps<any>["disabled"];
+    isTabFocused: boolean;
+}) => string;

package/dist/types/components/molecules/tagInput/types.d.ts

@@ -0,0 +1,66 @@
+import { SelectProps as AntSelectProps } from 'antd';
+import { default as React, ReactNode } from 'react';
+import { InputFieldError } from '../../../configs';
+export interface TagResponseVM {
+    id?: string;
+    tag?: string;
+}
+export interface TagInputProps<T extends Record<string, any> | unknown> extends Omit<AntSelectProps<T>, 'onChange' | 'options' | 'labelInValue' | 'optionLabelProp' | 'disabled' | 'size' | 'allowClear' | 'value' | 'mode'> {
+    /**
+     * if `error` property provided, regardless of its value, the error gap is applied to component.
+     */
+    error?: InputFieldError;
+    /**
+     *  pass this prop to only show negative border
+     */
+    hasError?: boolean;
+    height?: number | string;
+    underlined?: boolean;
+    label?: string;
+    labelOffset?: number;
+    labelExtraNode?: ReactNode;
+    labelExtractor?: (item: T) => ReactNode | string;
+    valueExtractor?: (item: T) => string;
+    tagExtractor?: (item: T) => string;
+    disableExtractor?: (item: T) => boolean;
+    options?: T[];
+    showSearch?: boolean;
+    renderItem?: (item: T, index: number, isActive: boolean) => React.ReactNode;
+    renderSelectedItem?: (item: T) => React.ReactNode;
+    onChange?: (value?: T[]) => void;
+    onChangeValue?(value: TagResponseVM[]): void;
+    onAddNew?: (value: string) => void;
+    selectedValue?: string[];
+    selectedValues?: T[];
+    value?: T[];
+    wrapperClassName?: string;
+    disabled?: boolean;
+    allowClear?: boolean;
+    required?: boolean;
+    tagValue?: T[];
+    onChangeTagValue?: (value?: T[]) => void;
+    noContentFoundMessage?: string;
+    labelPosition?: 'vertical' | 'horizontal';
+    size?: 'small' | 'medium';
+    footer?: ReactNode;
+    header?: ReactNode;
+    infinite?: SelectInfinite;
+    /**
+     * `selectedValue` has more priority than `value`. if `selectedValue` provided the select component ignores the `value`.
+     */
+    addonBefore?: ReactNode;
+    addonAfter?: ReactNode;
+    hideErrorMessage?: boolean;
+}
+export declare const SELECT_POPUP_HEIGHT = 200;
+export type DefaultSelectOption = {
+    label?: ReactNode;
+    value: any;
+};
+type SelectInfinite = {
+    total?: number;
+    fetchNextPage: () => void;
+    hasMore: boolean;
+};
+export type SelectOption<T> = T | null | undefined;
+export {};

package/dist/types/components/molecules/timePicker/index.d.ts

@@ -0,0 +1,6 @@
+import { InputFieldError } from '../../../configs';
+import { TimePickerProps as PickerProps } from 'antd';
+export interface InputTimePickerProps extends PickerProps {
+    error?: InputFieldError;
+}
+export declare const InputTimePicker: ({ className, error, ...rest }: InputTimePickerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/molecules/titleBox/index.d.ts

@@ -0,0 +1,8 @@
+import { StatusBoxProps } from './status';
+import { TitleBoxProps } from './title';
+declare const Box: {
+    readonly Status: ({ active }: StatusBoxProps) => import("react/jsx-runtime").JSX.Element;
+    readonly Title: ({ children, title }: TitleBoxProps) => import("react/jsx-runtime").JSX.Element;
+};
+export { Box };
+export type { StatusBoxProps, TitleBoxProps };

package/dist/types/components/molecules/titleBox/status.d.ts

@@ -0,0 +1,5 @@
+export interface StatusBoxProps {
+    active: boolean | undefined;
+}
+declare const StatusBox: ({ active }: StatusBoxProps) => import("react/jsx-runtime").JSX.Element;
+export { StatusBox };

package/dist/types/components/molecules/titleBox/title.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export interface TitleBoxProps {
+    title: string | ReactNode;
+    children: string | ReactNode;
+}
+declare const TitleBox: ({ children, title }: TitleBoxProps) => import("react/jsx-runtime").JSX.Element;
+export { TitleBox };

package/dist/types/components/molecules/tree/index.d.ts

@@ -0,0 +1,29 @@
+import { ITreeOption } from '../../../configs';
+import { FetchNextPageOptions, InfiniteData, InfiniteQueryObserverResult } from '@tanstack/react-query';
+import { TreeProps as AntTreeProps } from 'antd/lib';
+import { ReactNode } from 'react';
+import { IconsNames } from '../../atoms/icon';
+export interface TreeProps<T extends TreeDataType> extends Omit<AntTreeProps, 'switcherIcon' | 'icon' | 'treeData'> {
+    switcherIconName?: IconsNames;
+    nodeClassName?: string;
+    titleHeader: string;
+    isLoading?: boolean;
+    titleIcon: IconsNames;
+    treeData: T[];
+    renderRightIcons?: (node: T) => ReactNode;
+    renderIcon?: ((treeNode: T) => ReactNode) | ReactNode;
+    isExpandable?: boolean;
+    onDrawerToggle?: (open: boolean) => void;
+    expandedWidth?: number;
+    collapsedWidth?: number;
+    onSearch?: (value: string) => void;
+    hasSearch?: boolean;
+    infiniteProps?: {
+        isInfinite: boolean;
+        hasMore: boolean;
+        fetchNextPage: (options?: FetchNextPageOptions | undefined) => Promise<InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
+    };
+}
+export interface TreeDataType extends ITreeOption {
+}
+export declare const Tree: <T extends TreeDataType>({ switcherIconName, treeData, isLoading, className, nodeClassName, renderIcon, renderRightIcons, isExpandable, titleHeader, titleIcon, expandedWidth, collapsedWidth, onDrawerToggle, infiniteProps, onSearch, hasSearch, ...rest }: TreeProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/molecules/tree/searchBar/index.d.ts

@@ -0,0 +1,7 @@
+import { RefAttributes } from 'react';
+import { InputRef, InputSearchProps } from '../../input';
+type TreeSearchBarProps = InputSearchProps & RefAttributes<InputRef> & {
+    onSearch: (value: string) => void;
+};
+export declare const TreeSearchBar: ({ onSearch, ...props }: TreeSearchBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/molecules/verticalTabs/index.d.ts

@@ -0,0 +1,19 @@
+import { ReactElement, ReactNode } from 'react';
+interface TabProps {
+    title: string;
+    tab: string;
+    children: ReactNode;
+    className?: string;
+    transparent?: boolean;
+    extraNode?: ReactNode;
+}
+export interface VerticalTabsProps {
+    defaultActiveTab?: string;
+    query?: boolean;
+    children: ReactElement<TabProps>[];
+}
+declare const VerticalTabs: {
+    ({ children, query, defaultActiveTab }: VerticalTabsProps): import("react/jsx-runtime").JSX.Element;
+    Tab: (_props: TabProps) => null;
+};
+export { VerticalTabs };

package/dist/types/components/organisms/avatarGroup/index.d.ts

@@ -0,0 +1,25 @@
+import { LogoProps } from 'src/components/molecules';
+import { FlexProps } from '../../antOverrides';
+import { PopoverProps } from '../../atoms';
+export interface AvatarGroupItemType {
+    id?: string;
+    name?: string;
+    imageSrc?: string;
+}
+export interface AvatarGroupItemsProps<T extends AvatarGroupItemType = AvatarGroupItemType> {
+    items: T[];
+    renderItem?: (item: T) => JSX.Element;
+    max?: number;
+    avatarProps?: {
+        size?: number;
+    };
+    nameExtractor?: (item: T) => string;
+    hasAnimation?: boolean;
+    onClickAvatar?: (item: T) => void;
+    itemLogoProps?: LogoProps;
+    containerProps?: FlexProps;
+    popoverProps?: PopoverProps & {
+        containerProps?: FlexProps;
+    };
+}
+export declare function AvatarGroup<T extends AvatarGroupItemType>({ items, max, avatarProps: { size }, onClickAvatar, hasAnimation, nameExtractor, renderItem, itemLogoProps, containerProps, popoverProps, }: AvatarGroupItemsProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/organisms/drawer/components/footer.d.ts

@@ -0,0 +1,3 @@
+import { DrawerAction } from '..';
+declare const DrawerFooter: ({ discardTitle, onDiscard, onSubmit, submitTitle, isLoading, isSubmitDisabled, }: DrawerAction) => import("react/jsx-runtime").JSX.Element;
+export { DrawerFooter };

package/dist/types/components/organisms/drawer/components/headerTitle.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface DrawerHeaderTitleProps {
+    title?: string | React.ReactNode;
+    closable?: boolean;
+    onClose?: (e: React.MouseEvent | React.KeyboardEvent) => void;
+}
+declare const DrawerHeaderTitle: ({ title, closable, onClose }: DrawerHeaderTitleProps) => import("react/jsx-runtime").JSX.Element;
+export { DrawerHeaderTitle };

package/dist/types/components/organisms/drawer/index.d.ts

@@ -0,0 +1,24 @@
+import { DrawerProps as Props } from 'antd';
+import { HTMLAttributes, ReactNode } from 'react';
+import { DrawerHeaderTitleProps } from './components/headerTitle';
+export type DrawerAction = Partial<{
+    onSubmit: () => void;
+    onDiscard: () => void;
+    submitTitle: string;
+    discardTitle: string;
+    isLoading?: boolean;
+    noPadding?: boolean;
+    isSubmitDisabled?: boolean;
+}>;
+export interface DrawerProps extends Omit<Props, 'title' | 'onClose' | 'closable'> {
+    title?: string | ReactNode;
+    transparent?: boolean;
+    onClose?: () => void;
+    headerHeight?: number;
+    wrapperClassName?: HTMLAttributes<HTMLElement>['className'];
+    contentClassName?: HTMLAttributes<HTMLElement>['className'];
+    closable?: boolean;
+}
+declare const Drawer: ({ title, closable, transparent, submitTitle, discardTitle, onClose, onSubmit, onDiscard, classNames, styles, children, isLoading, headerHeight, wrapperClassName, contentClassName, noPadding, isSubmitDisabled, footer, ...rest }: DrawerProps & DrawerAction) => import("react/jsx-runtime").JSX.Element;
+export { Drawer };
+export type { DrawerHeaderTitleProps };

package/dist/types/components/organisms/index.d.ts

@@ -0,0 +1,4 @@
+export * from './avatarGroup';
+export * from './drawer';
+export * from './modal';
+export * from './table';