prometeo-design-system 3.1.5 → 3.1.6

package/dist/components/Autocomplete/Autocomplete.d.ts

@@ -0,0 +1,20 @@
+import { ComponentType } from 'react';
+import { CustomSelectOptionRendererProps } from '../Select/Select';
+import { OptionAccessor } from '../Shared/types';
+export interface AutocompleteProps<T> {
+    label?: string;
+    placeholder?: string;
+    name?: string;
+    multiple?: boolean;
+    options?: T[];
+    optionValue: OptionAccessor<T, string | number>;
+    optionLabel: OptionAccessor<T, string>;
+    fetcher?: (input?: string) => Promise<T[]>;
+    asyncMode?: 'fetch_in_open' | 'fetch_on_type';
+    debounceDelay?: number;
+    labelVariant?: 'static' | 'default';
+    disabled?: boolean;
+    renderOption?: ComponentType<CustomSelectOptionRendererProps<T>>;
+}
+declare const Autocomplete: <T extends object>(props: AutocompleteProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default Autocomplete;

package/dist/components/Autocomplete/useAutocomplete.d.ts

@@ -0,0 +1,43 @@
+import { OptionAccessor } from '../Shared/types';
+export interface UseAutocompleteOptionsMultiple<T extends object> extends UseAutocompleteBaseOptions<T> {
+    multiple: true;
+    controlledValue?: T[];
+    onChange?: (newValue: T[], name?: string) => void;
+}
+export interface UseAutocompleteOptionsSingle<T extends object> extends UseAutocompleteBaseOptions<T> {
+    multiple?: false;
+    controlledValue?: T;
+    onChange?: (newValue: T, name?: string) => void;
+}
+export interface UseAutocompleteBaseOptions<T extends object> {
+    options?: (T | undefined | null)[];
+    fetcher?: (input?: string) => Promise<T[]>;
+    asyncMode?: 'fetch_in_open' | 'fetch_on_type';
+    disabled?: boolean;
+    debounceDelay?: number;
+    minCharacters?: number;
+    optionLabel?: OptionAccessor<T, string>;
+    optionValue?: OptionAccessor<T, string | number>;
+    inputRef?: React.RefObject<HTMLInputElement | null> | (() => React.RefObject<HTMLInputElement | null> | undefined);
+    onFetchingStart?: () => void;
+    onFetchingEnd?: () => void;
+    onTypeStart?: () => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    isOpen?: boolean;
+    subscribeOpenChange?: (cb: (open: boolean) => void) => (() => void) | undefined;
+    name?: string;
+}
+export type UseAutocompleteOptions<T extends object> = UseAutocompleteOptionsMultiple<T> | UseAutocompleteOptionsSingle<T>;
+export declare function useAutocomplete<T extends object>(options?: UseAutocompleteOptions<T>): {
+    inputValue: string;
+    setInputValue: import('react').Dispatch<import('react').SetStateAction<string>>;
+    cleanInputValue: () => void;
+    cleanOptions: () => void;
+    clearValue: () => void;
+    filteredOptions: T[];
+    isLoading: boolean;
+    value: T | T[] | undefined;
+    setValue: import('react').Dispatch<import('react').SetStateAction<T | T[] | undefined>>;
+    onOptionClick: (option: T) => void;
+};

package/dist/components/Avatar/Avatar.d.ts

@@ -0,0 +1,11 @@
+export type SizeVariant = "xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl";
+interface IAvatar {
+    imageUrl?: string;
+    sizeImage?: SizeVariant;
+    sizeFallback?: SizeVariant;
+    fallbackText?: string;
+    subImageUrl?: string;
+    borderColor?: string;
+}
+export default function Avatar({ imageUrl, sizeImage, sizeFallback, fallbackText, subImageUrl, }: IAvatar): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Avatar/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Avatar';

package/dist/components/Button/Button.d.ts

@@ -0,0 +1,23 @@
+import { ButtonVariant, ColorVariant, SizeVariant } from '../Shared/types';
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    label?: string;
+    onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    icon?: React.ReactNode;
+    contentClassName?: string;
+    loadingText?: string;
+    animate?: boolean;
+    animateIcon?: boolean;
+    isLoading?: boolean;
+    children?: React.ReactNode;
+    spinner?: React.ReactNode;
+    type?: 'button' | "submit" | "reset";
+    className?: string;
+    disabled?: boolean;
+    variant?: ButtonVariant;
+    form?: string;
+    size?: SizeVariant;
+    color?: ColorVariant;
+    hideSpinner?: boolean;
+}
+declare const _default: import('react').MemoExoticComponent<({ label, onClick, icon, contentClassName, loadingText, animate, animateIcon, isLoading, children, hideSpinner, spinner, type, className, disabled, variant, form, size, color }: ButtonProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

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

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

package/dist/components/Card/Card.d.ts

@@ -0,0 +1,12 @@
+interface ICard {
+    onClickClose: () => void;
+    userName: string;
+    urlImage: string;
+    companyName: string;
+    areaName: string;
+    expiresAt: string;
+    onClickLogin: () => void;
+    loading?: boolean;
+}
+declare const Card: ({ onClickClose, userName, urlImage, companyName, areaName, expiresAt, onClickLogin, loading }: ICard) => import("react/jsx-runtime").JSX.Element;
+export default Card;

package/dist/components/CardProfile/CardProfile.d.ts

@@ -0,0 +1,55 @@
+import { ReactNode } from 'react';
+interface ICardProfile {
+    children: ReactNode;
+    dropMenu?: ReactNode;
+}
+export interface IArea {
+    _id: string;
+    name: string;
+}
+export interface ICompany {
+    _id: string;
+    name: string;
+}
+export interface ISessionLocalStorage {
+    _id: string;
+    name: string;
+    email: string;
+    username: string;
+    areaId: IArea;
+    companyId: ICompany;
+    expires_at: string;
+    logoutDate: string;
+    token: string;
+}
+interface IDropMenu {
+    isExpanded: boolean;
+    sessions: ISessionLocalStorage[];
+    onClickLogout: () => void;
+    handleTokenLogin: () => void;
+}
+interface ICardProfileImage {
+    isExpanded: boolean;
+    imageUrl?: string;
+    fallbackText?: string;
+}
+interface ICardProfileContent {
+    isExpanded: boolean;
+    nameUser: string;
+    nameCompany: string;
+    nameArea: string;
+    cardProfile: ReactNode;
+    onClick: () => void;
+}
+interface ICardProfileOptions {
+    onClick: () => void;
+    isExpanded: boolean;
+}
+export declare const CardProfile: (({ children }: ICardProfile) => import("react/jsx-runtime").JSX.Element) & {
+    Menu: ({ isExpanded, sessions, onClickLogout, handleTokenLogin, }: IDropMenu) => import("react/jsx-runtime").JSX.Element;
+    Image: ({ imageUrl, fallbackText }: ICardProfileImage) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ isExpanded, nameUser, nameCompany, nameArea, cardProfile, onClick, }: ICardProfileContent) => import("react/jsx-runtime").JSX.Element;
+    Separator: () => import("react/jsx-runtime").JSX.Element;
+    Options: ({ isExpanded, onClick }: ICardProfileOptions) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/components/CheckBox/CheckBox.d.ts

@@ -0,0 +1,11 @@
+import { HTMLProps } from 'react';
+export type CheckBoxProps = {
+    className?: string;
+    disabled?: boolean;
+} & HTMLProps<HTMLInputElement>;
+interface ICheckBox extends CheckBoxProps {
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    value?: string;
+}
+declare const _default: import('react').NamedExoticComponent<Omit<ICheckBox, "ref"> & import('react').RefAttributes<HTMLInputElement>>;
+export default _default;

package/dist/components/DatePicker/DatePicker.d.ts

@@ -0,0 +1,82 @@
+import { DateAfter, DateBefore, DateInterval, DateRange, DayOfWeek, Matcher } from 'react-day-picker';
+import { InputProps } from '../Input/Input';
+interface DatePickerBaseProps {
+    variant?: 'input' | 'only-calendar' | 'input-and-calendar';
+    required?: boolean;
+    disabledDates?: boolean | Matcher[] | Date | Date[] | DateRange | DateBefore | DateAfter | DateInterval | DayOfWeek | ((date: Date) => boolean);
+    className?: string;
+    header?: string | React.ReactNode;
+    footer?: string | React.ReactNode;
+    hideOutsideDays?: boolean;
+    numberOfMonths?: number;
+    startMonth?: Date;
+    endMonth?: Date;
+    showActionButtons?: boolean;
+    applyLabel?: string;
+    cancelLabel?: string;
+    onApply?: (value: Date | DateRange | Date[] | undefined) => void;
+    onCancel?: () => void;
+    hideFooter?: boolean;
+    inputProps?: Partial<InputProps>;
+    label?: string;
+    name?: string;
+    min?: number;
+    max?: number;
+}
+interface DatePickerSingleProps extends DatePickerBaseProps {
+    mode?: "single";
+    selected: Date | undefined;
+    onSelect: (date: Date) => void;
+}
+interface DatePickerRangeProps extends DatePickerBaseProps {
+    mode: "range";
+    selected: DateRange | undefined;
+    onSelect: (range: DateRange) => void;
+    min?: number;
+    max?: number;
+    excludeDisabled?: boolean;
+}
+interface DatePickerMultipleProps extends DatePickerBaseProps {
+    mode: "multiple";
+    selected: Date[] | undefined;
+    onSelect: (dates: Date[]) => void;
+    min?: number;
+    max?: number;
+}
+export type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps | DatePickerMultipleProps;
+declare const DatePicker: (props: DatePickerProps) => import("react/jsx-runtime").JSX.Element;
+export default DatePicker;
+interface CalendarProps {
+    min?: number;
+    max?: number;
+    excludeDisabled?: boolean;
+    endMonth?: Date;
+    startMonth?: Date;
+    readonly?: boolean;
+    className?: string;
+    required?: boolean;
+    hideFooter?: boolean;
+    applyLabel?: string;
+    cancelLabel?: string;
+    onApply?: () => void;
+    onCancel?: () => void;
+    numberOfMonths?: number;
+    hideOutsideDays?: boolean;
+    style?: React.CSSProperties;
+    showActionButtons?: boolean;
+    header?: string | React.ReactNode;
+    footer?: string | React.ReactNode;
+    mode: "single" | "range" | "multiple";
+    ref?: React.RefObject<HTMLDivElement | null>;
+    selected: Date | DateRange | Date[] | undefined;
+    displayValue: Date | DateRange | Date[] | undefined;
+    onSelect?: (value: Date | DateRange | Date[]) => void;
+    calendarPosition?: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    disabledDates?: boolean | Matcher[] | Date | Date[] | DateRange | DateBefore | DateAfter | DateInterval | DayOfWeek | ((date: Date) => boolean);
+}
+export declare const Calendar: import('react').MemoExoticComponent<(props: CalendarProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/components/Dialog/Dialog.d.ts

@@ -0,0 +1,35 @@
+interface DialogProps<TContext = unknown> {
+    title?: string;
+    children: React.ReactNode | ((context: TContext | null) => React.ReactNode);
+    onClose?: (context: TContext | null) => void;
+    className?: string;
+}
+export interface DialogHandle<TContext = unknown> {
+    open: (context?: TContext) => void;
+    close: () => void;
+    isOpen: boolean;
+    getContext: () => TContext | null;
+}
+interface DialogContentProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface DialogTitleProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface DialogHeaderProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface DialogFooterProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+declare const DialogModal: import('react').ForwardRefExoticComponent<DialogProps<any> & import('react').RefAttributes<DialogHandle<any>>> & {
+    Content: import('react').MemoExoticComponent<({ children, className }: DialogContentProps) => import("react/jsx-runtime").JSX.Element>;
+    Header: import('react').MemoExoticComponent<({ children, className }: DialogHeaderProps) => import("react/jsx-runtime").JSX.Element>;
+    Footer: import('react').MemoExoticComponent<({ children, className }: DialogFooterProps) => import("react/jsx-runtime").JSX.Element>;
+    Title: import('react').MemoExoticComponent<({ children, className }: DialogTitleProps) => import("react/jsx-runtime").JSX.Element>;
+};
+export default DialogModal;

package/dist/components/Dialog/DialogV2.d.ts

@@ -0,0 +1,35 @@
+interface DialogProps<TContext = unknown> {
+    title?: string;
+    children: React.ReactNode | ((context: TContext | null) => React.ReactNode);
+    onClose?: (context: TContext | null) => void;
+    className?: string;
+}
+export interface DialogHandle<TContext = unknown> {
+    open: (context?: TContext) => void;
+    close: () => void;
+    isOpen: boolean;
+    getContext: () => TContext | null;
+}
+interface DialogContentProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface DialogTitleProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface DialogHeaderProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface DialogFooterProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+declare const DialogModal: import('react').ForwardRefExoticComponent<DialogProps<any> & import('react').RefAttributes<DialogHandle<any>>> & {
+    Content: import('react').MemoExoticComponent<({ children, className }: DialogContentProps) => import("react/jsx-runtime").JSX.Element>;
+    Header: import('react').MemoExoticComponent<({ children, className }: DialogHeaderProps) => import("react/jsx-runtime").JSX.Element>;
+    Footer: import('react').MemoExoticComponent<({ children, className }: DialogFooterProps) => import("react/jsx-runtime").JSX.Element>;
+    Title: import('react').MemoExoticComponent<({ children, className }: DialogTitleProps) => import("react/jsx-runtime").JSX.Element>;
+};
+export default DialogModal;

package/dist/components/Dialog/useDialogControl.d.ts

@@ -0,0 +1,8 @@
+import { DialogHandle } from './Dialog';
+export declare const useDialogControl: <TContext = unknown>() => {
+    ref: import('react').RefObject<DialogHandle<TContext> | null>;
+    open: (context?: TContext) => void;
+    close: () => void;
+    isOpen: () => boolean;
+    getContext: () => NonNullable<TContext> | null;
+};

package/dist/components/Drawer/DrawerDesktop.d.ts

@@ -0,0 +1,21 @@
+export interface DrawerDesktopHandle<TContext = unknown> {
+    open: (context?: TContext) => void;
+    close: () => void;
+    isOpen: boolean;
+    getContext: () => TContext | null;
+    subscribeOpenChange: (cb: (open: boolean) => void) => () => void;
+}
+export interface DrawerDesktopProps<TContext = unknown> {
+    children?: React.ReactNode | ((context: TContext | null) => React.ReactNode);
+    direction?: "left" | "right";
+    modal?: boolean;
+    className?: string;
+    onClose?: (context?: TContext) => void;
+    defaultOpen?: boolean;
+    attachToParent?: boolean;
+    closeOnOverlayClick?: boolean;
+    hideCloseButton?: boolean;
+    unmountChildrenOnClose?: boolean;
+}
+declare const DrawerDesktop: import('react').ForwardRefExoticComponent<DrawerDesktopProps<any> & import('react').RefAttributes<DrawerDesktopHandle<any>>>;
+export default DrawerDesktop;

package/dist/components/Drawer/DrawerMobile.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+export interface DrawerMobileProps<TContext = unknown> {
+    children?: React.ReactNode | ((context: TContext | null) => React.ReactNode);
+    defaultOpen?: boolean;
+    onClose?: (context: TContext | null) => void;
+    snap?: string | number | null;
+    snapPoints?: (string | number)[];
+    setSnap?: (snap: string | number) => void;
+    attachToParent?: boolean;
+    hideOnClose?: boolean;
+    unmountChildrenOnClose?: boolean;
+    header?: React.ReactNode | string;
+    modal?: boolean;
+    closeOnOverlayClick?: boolean;
+}
+export interface DrawerMobileHandle<TContext = unknown> {
+    open: (snap?: string | number, context?: TContext) => void;
+    close: () => void;
+    isOpen: boolean;
+    getContext: () => TContext | null;
+    subscribeOpenChange: (cb: (open: boolean) => void) => () => void;
+}
+declare const DrawerMobile: React.ForwardRefExoticComponent<DrawerMobileProps<any> & React.RefAttributes<DrawerMobileHandle<any>>>;
+export default DrawerMobile;

package/dist/components/Drawer/useDrawerDesktop.d.ts

@@ -0,0 +1,8 @@
+import { DrawerDesktopHandle } from './DrawerDesktop';
+export declare const useDrawerDesktop: <TContext = unknown>() => {
+    isOpen: boolean;
+    open: (context?: TContext) => void;
+    close: () => void;
+    drawerRef: import('react').RefObject<DrawerDesktopHandle<TContext> | null>;
+    getContext: () => NonNullable<TContext> | null;
+};

package/dist/components/Drawer/useDrawerMobile.d.ts

@@ -0,0 +1,8 @@
+import { DrawerMobileHandle } from './DrawerMobile';
+export declare const useDrawerMobile: <TContext = unknown>() => {
+    isOpen: boolean;
+    open: (snap?: string | number, context?: TContext) => void;
+    close: () => void;
+    drawerRef: import('react').RefObject<DrawerMobileHandle<TContext> | null>;
+    getContext: () => NonNullable<TContext> | null;
+};

package/dist/components/DropZone/DropZone.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { DropzoneOptions } from 'react-dropzone';
+interface DropZoneProps extends Omit<DropzoneOptions, 'onDrop'> {
+    onFilesAccepted?: (files: File[]) => void;
+    onFilesRejected?: (rejectedFiles: unknown[]) => void;
+    className?: string;
+    subtitle?: string;
+    acceptedFormats?: string;
+    maxSize: number;
+    variant?: 'default' | 'compact';
+    disabled?: boolean;
+    showIcon?: boolean;
+}
+declare const DropZone: React.ForwardRefExoticComponent<DropZoneProps & React.RefAttributes<HTMLDivElement>>;
+export { DropZone };
+export type { DropZoneProps };

package/dist/components/DropZone/DropzoneCompossable.d.ts

@@ -0,0 +1,54 @@
+import { default as React } from 'react';
+import { useFileDropzone, UseFileDropzoneOptions } from './useFileDropzone';
+interface DropZoneAreaProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'compact';
+    isDragActive?: boolean;
+    isDragReject?: boolean;
+    hasErrors?: boolean;
+    disabled?: boolean;
+    getRootProps?: () => unknown;
+    getInputProps?: () => unknown;
+}
+interface DropZoneHeaderProps {
+    title?: string;
+    variant?: 'default' | 'compact';
+    className?: string;
+}
+interface DropZoneIconProps {
+    size?: number;
+    className?: string;
+    showIcon?: boolean;
+    isDragActive?: boolean;
+    isDragReject?: boolean;
+    hasErrors?: boolean;
+}
+interface DropZoneMessageProps {
+    subtitle?: string;
+    acceptedFormats?: string;
+    className?: string;
+    isDragActive?: boolean;
+    isDragReject?: boolean;
+    hasErrors?: boolean;
+}
+interface DropZoneErrorsProps {
+    className?: string;
+    fileRejections?: unknown[];
+}
+interface DropZoneWrapperProps extends UseFileDropzoneOptions {
+    className?: string;
+    title?: string;
+    subtitle?: string;
+    acceptedFormats?: string;
+    variant?: 'default' | 'compact';
+    disabled?: boolean;
+    showIcon?: boolean;
+}
+export declare const DropZone: (({ children, className }: DropZoneWrapperProps) => import("react/jsx-runtime").JSX.Element) & {
+    Header: ({ title, variant, className }: DropZoneHeaderProps) => import("react/jsx-runtime").JSX.Element | null;
+    Area: ({ children, className, variant, isDragActive, isDragReject, hasErrors, disabled, getRootProps, getInputProps, ...props }: DropZoneAreaProps) => import("react/jsx-runtime").JSX.Element;
+    Icon: ({ size, className, showIcon, isDragActive, isDragReject, hasErrors }: DropZoneIconProps) => import("react/jsx-runtime").JSX.Element | null;
+    Message: ({ subtitle, acceptedFormats, className, isDragActive, isDragReject, hasErrors }: DropZoneMessageProps) => import("react/jsx-runtime").JSX.Element;
+    Errors: ({ className, fileRejections }: DropZoneErrorsProps) => import("react/jsx-runtime").JSX.Element | null;
+    useDropzone: typeof useFileDropzone;
+};
+export type { DropZoneAreaProps, DropZoneErrorsProps, DropZoneHeaderProps, DropZoneIconProps, DropZoneMessageProps, DropZoneWrapperProps };

package/dist/components/DropZone/useFileDropzone.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { DropzoneOptions } from 'react-dropzone';
+export interface UseFileDropzoneOptions extends Omit<DropzoneOptions, "onDrop"> {
+    onFilesAccepted?: (files: File[]) => void;
+    onFilesRejected?: (rejectedFiles: unknown[]) => void;
+}
+export declare function useFileDropzone({ onFilesAccepted, onFilesRejected, ...options }: UseFileDropzoneOptions): {
+    hasErrors: boolean;
+    open: () => void;
+    isFocused: boolean;
+    isDragActive: boolean;
+    isDragAccept: boolean;
+    isDragReject: boolean;
+    isFileDialogActive: boolean;
+    acceptedFiles: readonly import('file-selector').FileWithPath[];
+    fileRejections: readonly import('react-dropzone').FileRejection[];
+    rootRef: React.RefObject<HTMLElement>;
+    inputRef: React.RefObject<HTMLInputElement>;
+    getRootProps: <T extends import('react-dropzone').DropzoneRootProps>(props?: T) => T;
+    getInputProps: <T extends import('react-dropzone').DropzoneInputProps>(props?: T) => T;
+};

package/dist/components/FAB/FAButton.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { ColorVariant, ButtonVariant } from '../Shared/types';
+import { IconComponent } from '../../Icons/types';
+export interface FAButtonProps {
+    icon?: IconComponent;
+    label?: string;
+    attachToParent?: boolean;
+    position?: {
+        left?: number | string;
+        top?: number | string;
+        right?: number | string;
+        bottom?: number | string;
+    };
+    color?: ColorVariant;
+    variant?: ButtonVariant;
+    disabled?: boolean;
+    className?: string;
+    onClick: () => void;
+}
+declare const FAButton: React.MemoExoticComponent<(props: FAButtonProps) => import("react/jsx-runtime").JSX.Element>;
+export default FAButton;

package/dist/components/FileCard/FileCard.d.ts

@@ -0,0 +1,52 @@
+export interface FileWithPreview {
+    file: File;
+    preview?: string;
+    progress?: number;
+    status?: 'pending' | 'uploading' | 'uploaded' | 'error';
+    error?: string;
+}
+export interface FileCardProps {
+    files: FileWithPreview[];
+    onRemoveFile: (index: number) => void;
+    className?: string;
+}
+export interface FileCardItemProps {
+    file: File;
+    preview?: string;
+    index: number;
+    progress?: number;
+    status?: 'pending' | 'uploading' | 'uploaded' | 'error';
+    error?: string;
+    onRemove: (index: number) => void;
+    className?: string;
+}
+export interface FilePreviewProps {
+    file: File;
+    preview?: string;
+    className?: string;
+}
+export interface FileInfoProps {
+    file: File;
+    progress?: number;
+    status?: 'pending' | 'uploading' | 'uploaded' | 'error';
+    error?: string;
+    className?: string;
+}
+export interface FileActionsProps {
+    index: number;
+    onRemove: (index: number) => void;
+    status?: 'pending' | 'uploading' | 'uploaded' | 'error';
+    className?: string;
+}
+export declare const FilePreview: ({ file, preview, className }: FilePreviewProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FileInfo: ({ file, progress, status, error, className }: FileInfoProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FileActions: ({ index, onRemove, status, className }: FileActionsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FileCardItem: ({ file, preview, index, progress, status, error, onRemove, className }: FileCardItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FileCard: ({ files, onRemoveFile, className }: FileCardProps) => import("react/jsx-runtime").JSX.Element | null;
+declare const FileCardCompound: (({ files, onRemoveFile, className }: FileCardProps) => import("react/jsx-runtime").JSX.Element | null) & {
+    Item: ({ file, preview, index, progress, status, error, onRemove, className }: FileCardItemProps) => import("react/jsx-runtime").JSX.Element;
+    Preview: ({ file, preview, className }: FilePreviewProps) => import("react/jsx-runtime").JSX.Element;
+    Info: ({ file, progress, status, error, className }: FileInfoProps) => import("react/jsx-runtime").JSX.Element;
+    Actions: ({ index, onRemove, status, className }: FileActionsProps) => import("react/jsx-runtime").JSX.Element;
+};
+export default FileCardCompound;

package/dist/components/Header/Header.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+export interface IHeader {
+    title?: string;
+    children?: ReactNode;
+    className?: string;
+    subtitle?: string;
+    subtitleClassName?: string;
+    titleClassName?: string;
+}
+declare const _default: import('react').MemoExoticComponent<({ title, subtitle, children, className, subtitleClassName, titleClassName }: IHeader) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/components/Image/GalleryPreview.d.ts

@@ -0,0 +1,8 @@
+import { ReactElement, default as React } from 'react';
+import { ImageProps } from './Image';
+interface GalleryPreviewProps {
+    images?: ReactElement<ImageProps>[];
+    className?: string;
+}
+declare const GalleryPreview: React.NamedExoticComponent<GalleryPreviewProps & React.RefAttributes<unknown>>;
+export default GalleryPreview;

package/dist/components/Image/Image.d.ts

@@ -0,0 +1,23 @@
+import { SpinnerProps } from '../Spinner/Spinner';
+import { ImageGalleryHandle } from './ImageGallery';
+export interface ImageProps {
+    src: string;
+    alt: string;
+    width?: number | string;
+    height?: number | string;
+    className?: string;
+    lazy?: boolean;
+    showLoader?: boolean;
+    loaderProps?: {
+        loaderType?: 'skeleton' | 'clasic';
+        variant?: SpinnerProps['variant'];
+        speedMultiplier?: SpinnerProps['speedMultiplier'];
+        className?: string;
+        size?: SpinnerProps['size'];
+        backdropClassName?: string;
+    };
+    allowPreview?: boolean;
+    galleryRef?: React.RefObject<ImageGalleryHandle | null>;
+}
+declare const CustomImage: import('react').MemoExoticComponent<(props: ImageProps) => import("react/jsx-runtime").JSX.Element>;
+export default CustomImage;

package/dist/components/Image/ImageGallery.d.ts

@@ -0,0 +1,18 @@
+import { ReactElement } from 'react';
+import { ImageProps } from './Image';
+export interface ImageGalleryProps {
+    children?: ReactElement<ImageProps> | ReactElement<ImageProps>[];
+    className?: string;
+    lightboxClassName?: string;
+    showThumbnails?: boolean;
+    thumbnailsClassName?: string;
+}
+export interface ImageGalleryHandle {
+    openLightbox: (index?: number) => void;
+    closeLightbox: () => void;
+    isOpen: boolean;
+    addImage: (image: ImageProps) => void;
+    images: ImageProps[];
+}
+declare const ImageGallery: import('react').ForwardRefExoticComponent<ImageGalleryProps & import('react').RefAttributes<ImageGalleryHandle>>;
+export default ImageGallery;