@quan-erp/shared-ui 1.0.0

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

@@ -0,0 +1,20 @@
+export * from './plugin-theme';
+export * from './page';
+export * from './safearea';
+export * from './protected-page';
+export * from './setting';
+export * from './dashboard';
+export * from './responsive-dialog';
+export * from './scrollable';
+export * from './portal';
+export * from './floating-action-btn';
+export * from './render-in-view';
+export * from './confirm-dialog';
+export * from './menu-tab';
+export * from './pull-to-refresh';
+export * from './empty-screen';
+export * from './error-screen';
+export * from './loading-screen';
+export * from './submenu-hub';
+export * from './data-table/export';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/custom/loading-screen.d.ts

@@ -0,0 +1,7 @@
+export declare const LoadingState: ({ title, message, className, pluginName }: {
+    title?: string;
+    message?: string;
+    className?: string;
+    pluginName?: string;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=loading-screen.d.ts.map

package/dist/components/custom/menu-tab.d.ts

@@ -0,0 +1,17 @@
+import { LocaleType, LazyLocaleType } from '../../locale';
+import { ReactNode } from 'react';
+export declare const MENU_TAB_CLASSNAME = "shared:data-[active]:text-white shared:md:text-[1rem] shared:text-[1.2rem] shared:group-data-[type=bottom-nav]:text-2xl shared:group-data-[type=bottom-nav]:[&>svg]:text-2xl";
+export declare function MenuTab({ pluginName, icon, labelKey, locale, isBeta }: {
+    pluginName?: string;
+    icon: ReactNode;
+    locale: LocaleType | LazyLocaleType;
+    labelKey: string;
+    isBeta?: boolean;
+}): import("react").JSX.Element;
+export declare function IconParkMenuTabIcon({ icon: Icon, className, pluginName, ...props }: {
+    icon: any;
+    className?: string;
+    pluginName?: string;
+    [key: string]: any;
+}): import("react").JSX.Element;
+//# sourceMappingURL=menu-tab.d.ts.map

package/dist/components/custom/page.d.ts

@@ -0,0 +1,35 @@
+import { ReactElement, ReactNode, default as React } from 'react';
+export declare function PageTitle({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function PageContent({ children }: {
+    children: ReactNode;
+}): ReactNode;
+export type BottomNavBarStore = {
+    visibility: {
+        isVisible: boolean;
+        show: () => void;
+        hide: () => void;
+    };
+};
+export declare function PageNavTitle({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function Page({ pluginName, className, children, navMenu, bottomNav, }: {
+    pluginName?: string;
+    className?: string;
+    children: ReactElement[] | ReactElement | undefined;
+    navMenu?: Partial<{
+        items: ReactNode[];
+        actionItems: ReactNode[];
+        visibleDefaultActionItem: boolean;
+        menuTitle: ReactNode;
+        visible: boolean;
+        leading: ReactNode;
+        leadingBackButton: boolean;
+    }>;
+    bottomNav?: Partial<{
+        visible: boolean;
+    }>;
+}): React.JSX.Element;
+//# sourceMappingURL=page.d.ts.map

package/dist/components/custom/plugin-theme.d.ts

@@ -0,0 +1,8 @@
+import { default as React, ReactNode } from 'react';
+interface PluginThemeProps {
+    pluginName: string;
+    children: ReactNode;
+}
+export declare function PluginTheme({ pluginName, children }: PluginThemeProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=plugin-theme.d.ts.map

package/dist/components/custom/portal.d.ts

@@ -0,0 +1,4 @@
+export declare function Portal({ children }: {
+    children: React.ReactNode;
+}): import('react').ReactPortal | null;
+//# sourceMappingURL=portal.d.ts.map

package/dist/components/custom/protected-page.d.ts

@@ -0,0 +1,26 @@
+import { ApiPermission, WithApiMetadataFetchFn } from '@quan-erp/shared-types';
+import { ComponentType, HtmlHTMLAttributes, ReactElement, ReactNode } from 'react';
+export type AnyPermissionTypes = (ApiPermission | WithApiMetadataFetchFn<any>)[];
+export type ProtectedPropsType = {
+    children: ReactNode;
+    pluginName?: string;
+    parentClassName?: string;
+    parentHTMLDivAttribute?: HtmlHTMLAttributes<HTMLDivElement>;
+    warpperClassName?: string;
+    warpperHTMLDivAttributes?: HtmlHTMLAttributes<HTMLDivElement>;
+    showProtectedFallbackAs?: 'restricted' | 'route-not-found' | 'hidden' | 'custom';
+    protectedFallbackComponent?: ReactNode;
+    participateInAssistantGuide?: boolean;
+    enableProtection?: boolean;
+    requiredApis: ApiPermission | ApiPermission[] | (() => (ApiPermission | ApiPermission[])) | WithApiMetadataFetchFn<any> | WithApiMetadataFetchFn<any>[] | AnyPermissionTypes;
+};
+export declare function Protected(props: ProtectedPropsType): import("react").JSX.Element;
+/**
+ * @deprecated Use `Protected` component directly instead from \@quan-erp/base-frontend.
+ */
+export declare function ProtectedPage(props: ProtectedPropsType): import("react").JSX.Element;
+/**
+ * @deprecated Use `Protected` component directly instead from \@quan-erp/base-frontend.
+ */
+export declare function withProtected(element: ReactElement | ReactElement[], requiredApis: ApiPermission[]): ComponentType;
+//# sourceMappingURL=protected-page.d.ts.map

package/dist/components/custom/pull-to-refresh.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+export type PullToRefreshStatus = 'idle' | 'pulling' | 'ready' | 'refreshing' | 'success' | 'error';
+interface PullToRefreshProps {
+    onRefresh: () => Promise<void> | void;
+    refreshing?: boolean;
+    threshold?: number;
+    resistance?: number;
+    renderIndicator?: (status: PullToRefreshStatus, yOffset: number, threshold: number) => React.ReactNode;
+    children: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+    success?: boolean;
+}
+export declare const PullToRefresh: React.MemoExoticComponent<({ onRefresh, refreshing, threshold, resistance, renderIndicator, children, className, disabled, success, }: PullToRefreshProps) => React.JSX.Element>;
+export {};
+//# sourceMappingURL=pull-to-refresh.d.ts.map

package/dist/components/custom/render-in-view.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+type RenderInViewProps = {
+    children: ReactNode;
+    rootMargin?: string;
+    threshold?: number;
+    once?: boolean;
+    className?: string;
+    pluginName?: string;
+} & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+export declare function RenderInView({ children, rootMargin, threshold, once, className, pluginName, ...props }: RenderInViewProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=render-in-view.d.ts.map

package/dist/components/custom/responsive-dialog.d.ts

@@ -0,0 +1,47 @@
+import { ReactNode, CSSProperties } from 'react';
+import { Drawer } from '../ui';
+import { DialogProps } from 'vaul';
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+export declare const DesktopDialogType: {
+    readonly SHEET: "SHEET";
+    readonly DIALOG: "DIALOG";
+};
+export type DesktopDialogType = "SHEET" | "DIALOG";
+type DialogType = "desktop" | "mobile";
+export declare const useDialogType: () => {
+    type: DialogType;
+    desktopDialogType: DesktopDialogType;
+};
+interface ResponsiveDialogProps {
+    open: boolean;
+    onOpenChange: (flag: boolean) => void;
+    children: ReactNode;
+    trigger?: ReactNode;
+    desktopDialogType?: DesktopDialogType;
+    pluginName?: string;
+    trackBrowserBack?: boolean;
+}
+export type ResponsiveDialogRefType = {
+    open: () => void;
+    close: () => void;
+    getStatus: () => boolean;
+};
+export declare const UncontrolledResponsiveDialog: import('react').ForwardRefExoticComponent<Omit<ResponsiveDialogProps, "open" | "onOpenChange"> & import('react').RefAttributes<ResponsiveDialogRefType>>;
+export declare function ResponsiveDialog({ open, onOpenChange, children, trigger, desktopDialogType, pluginName, trackBrowserBack, ...props }: ResponsiveDialogProps & DialogProps & React.ComponentProps<typeof Drawer> & React.ComponentProps<typeof SheetPrimitive.Root>): import("react").JSX.Element;
+interface ResponsiveSubProps {
+    children: ReactNode;
+    className?: string;
+    pluginName?: string;
+    showCloseButton?: boolean;
+}
+export declare function ResponsiveHeader({ children, pluginName, className }: ResponsiveSubProps): import("react").JSX.Element;
+export declare function ResponsiveTitle({ children, className, pluginName }: ResponsiveSubProps): import("react").JSX.Element;
+export declare function ResponsiveContent({ children, className, style, pluginName, showCloseButton }: ResponsiveSubProps & {
+    style?: CSSProperties;
+}): import("react").JSX.Element;
+export declare function ResponsiveTrigger({ children, className, pluginName }: ResponsiveSubProps): import("react").JSX.Element;
+export declare function ResponsiveDescription({ children, className, pluginName }: ResponsiveSubProps): import("react").JSX.Element;
+export declare function ResponsiveFooter({ children, className, pluginName }: ResponsiveSubProps): import("react").JSX.Element;
+export declare function ResponsiveOverlay({ children, className, pluginName }: ResponsiveSubProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=responsive-dialog.d.ts.map

package/dist/components/custom/safearea.d.ts

@@ -0,0 +1,5 @@
+export declare function SafeArea({ children, className }: {
+    children?: React.ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=safearea.d.ts.map

package/dist/components/custom/scrollable.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode, UIEvent } from 'react';
+type ScrollableDivProps = {
+    className?: string;
+    hasNext: boolean;
+    isLoading: boolean;
+    onScroll: (event: UIEvent<HTMLDivElement>) => void;
+    onEnd?: () => Promise<void>;
+    onPullRefresh?: () => Promise<void>;
+    children: ReactNode;
+    loadingComponent?: ReactNode;
+    pullThreshold?: number;
+    endThreshold?: number;
+    pullIndicator?: ReactNode;
+};
+export declare const InfiniteScrollableDiv: import('react').ForwardRefExoticComponent<ScrollableDivProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};
+//# sourceMappingURL=scrollable.d.ts.map

package/dist/components/custom/search-and-filter-suite.d.ts

@@ -0,0 +1,16 @@
+interface SearchAndFilterSuiteProps {
+    isLoading?: boolean;
+    placeholder?: string;
+    className?: string;
+    children?: React.ReactNode;
+    onSearchFn?: (obj: {
+        query: string;
+    }) => void;
+    queryParamKey?: string;
+    pageParamKey?: string;
+    resetPageOnSearch?: boolean;
+    pluginName?: string;
+}
+export declare function SearchAndFilterSuite({ isLoading, placeholder, className, children, onSearchFn, queryParamKey, pageParamKey, resetPageOnSearch, pluginName }: SearchAndFilterSuiteProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=search-and-filter-suite.d.ts.map

package/dist/components/custom/setting.d.ts

@@ -0,0 +1,30 @@
+export type SettingDataType = "string" | "number" | "boolean" | "json" | "date";
+export declare function SettingCardFooter({ children }: {
+    children?: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SettingCardHeader({ children }: {
+    children?: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SettingSectionTitle({ children }: {
+    children?: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SettingCardContent({ children }: {
+    children?: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SettingCard({ children }: {
+    children?: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SettingCardTitle({ children }: {
+    children?: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SettingCardSubtitle({ children }: {
+    children?: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SettingCardLabel({ children }: {
+    children?: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SettingSection({ children, hyperLink }: {
+    children?: React.ReactNode;
+    hyperLink: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=setting.d.ts.map

package/dist/components/custom/submenu-hub.d.ts

@@ -0,0 +1,17 @@
+import { LocaleType } from '../../locale';
+import { JSX } from 'react';
+declare const SubMenuHub: ({ title, items, description, locale, pluginName }: {
+    title: string;
+    items: {
+        name: string;
+        path: string;
+        sortNumber: number;
+        icon: JSX.Element;
+        element: JSX.Element;
+    }[];
+    description: string;
+    locale: LocaleType;
+    pluginName?: string;
+}) => JSX.Element;
+export default SubMenuHub;
+//# sourceMappingURL=submenu-hub.d.ts.map

package/dist/components/editor/editor-ui/content-editable.d.ts

@@ -0,0 +1,9 @@
+import { JSX } from 'react';
+type Props = {
+    placeholder: string;
+    className?: string;
+    placeholderClassName?: string;
+};
+export declare function ContentEditable({ placeholder, className, placeholderClassName, }: Props): JSX.Element;
+export {};
+//# sourceMappingURL=content-editable.d.ts.map

package/dist/components/editor/themes/editor-theme.d.ts

@@ -0,0 +1,3 @@
+import { EditorThemeClasses } from 'lexical';
+export declare const editorTheme: EditorThemeClasses;
+//# sourceMappingURL=editor-theme.d.ts.map

package/dist/components/ui/accordion.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };
+//# sourceMappingURL=accordion.d.ts.map

package/dist/components/ui/alert-dialog.d.ts

@@ -0,0 +1,19 @@
+import { Button } from './button';
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>): React.JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>): React.JSX.Element;
+declare function AlertDialogPortal({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal>): React.JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Overlay>): React.JSX.Element;
+declare function AlertDialogContent({ className, size, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Content> & {
+    size?: "default" | "sm";
+}): React.JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): React.JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): React.JSX.Element;
+declare function AlertDialogMedia({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogAction({ className, variant, size, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Action> & Pick<React.ComponentProps<typeof Button>, "variant" | "size">): React.JSX.Element;
+declare function AlertDialogCancel({ className, variant, size, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Cancel> & Pick<React.ComponentProps<typeof Button>, "variant" | "size">): React.JSX.Element;
+export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogMedia, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, };
+//# sourceMappingURL=alert-dialog.d.ts.map

package/dist/components/ui/alert.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Alert, AlertTitle, AlertDescription };
+//# sourceMappingURL=alert.d.ts.map

package/dist/components/ui/avatar.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback };
+//# sourceMappingURL=avatar.d.ts.map

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "secondary" | "outline" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): React.JSX.Element;
+export { Badge, badgeVariants };
+//# sourceMappingURL=badge.d.ts.map

package/dist/components/ui/breadcrumb.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };
+//# sourceMappingURL=breadcrumb.d.ts.map

package/dist/components/ui/button-group.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import { Separator } from './separator';
+declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function ButtonGroup({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>): import("react").JSX.Element;
+declare function ButtonGroupText({ className, asChild, ...props }: React.ComponentProps<"div"> & {
+    asChild?: boolean;
+}): import("react").JSX.Element;
+declare function ButtonGroupSeparator({ className, orientation, ...props }: React.ComponentProps<typeof Separator>): import("react").JSX.Element;
+export { ButtonGroup, ButtonGroupSeparator, ButtonGroupText, buttonGroupVariants, };
+//# sourceMappingURL=button-group.d.ts.map

package/dist/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const buttonVariants: (props?: ({
+    variant?: "input" | "select" | "link" | "default" | "destructive" | "secondary" | "outline" | "default2" | "destructive2" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+export { Button, buttonVariants };
+//# sourceMappingURL=button.d.ts.map

package/dist/components/ui/calendar.d.ts

@@ -0,0 +1,12 @@
+import { DayButton, DayPicker } from 'react-day-picker';
+import { Button } from './button';
+import * as React from "react";
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, type, trigger, label, ...props }: React.ComponentProps<typeof DayPicker> & {
+    type?: 'raw' | 'popover' | 'drawer' | 'automatic';
+    trigger?: React.ReactNode;
+    label?: React.ReactNode;
+    buttonVariant?: React.ComponentProps<typeof Button>["variant"];
+}): React.JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, ...props }: React.ComponentProps<typeof DayButton>): React.JSX.Element;
+export { Calendar, CalendarDayButton };
+//# sourceMappingURL=calendar.d.ts.map

package/dist/components/ui/card.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare function Card({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };
+//# sourceMappingURL=card.d.ts.map

package/dist/components/ui/carousel.d.ts

@@ -0,0 +1,29 @@
+import { default as useEmblaCarousel, UseEmblaCarouselType } from 'embla-carousel-react';
+import * as React from "react";
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+};
+declare const Carousel: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & CarouselProps & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselPrevious: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & import('class-variance-authority').VariantProps<(props?: ({
+    variant?: "input" | "select" | "link" | "default" | "destructive" | "secondary" | "outline" | "default2" | "destructive2" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const CarouselNext: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & import('class-variance-authority').VariantProps<(props?: ({
+    variant?: "input" | "select" | "link" | "default" | "destructive" | "secondary" | "outline" | "default2" | "destructive2" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { type CarouselApi, Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext, };
+//# sourceMappingURL=carousel.d.ts.map

package/dist/components/ui/chart.d.ts

@@ -0,0 +1,63 @@
+import * as React from "react";
+import * as RechartsPrimitive from "recharts";
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+export type ChartConfig = {
+    [k in string]: {
+        label?: React.ReactNode;
+        icon?: React.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+declare const ChartContainer: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    config: ChartConfig;
+    children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => React.JSX.Element | null;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+declare const ChartTooltipContent: React.ForwardRefExoticComponent<Omit<RechartsPrimitive.DefaultTooltipContentProps<import('recharts/types/component/DefaultTooltipContent').ValueType, import('recharts/types/component/DefaultTooltipContent').NameType> & {
+    accessibilityLayer?: boolean;
+    active?: boolean | undefined;
+    includeHidden?: boolean | undefined;
+    allowEscapeViewBox?: import('recharts/types/util/types').AllowInDimension;
+    animationDuration?: import('recharts/types/util/types').AnimationDuration;
+    animationEasing?: import('recharts/types/util/types').AnimationTiming;
+    content?: import('recharts/types/component/Tooltip').ContentType<import('recharts/types/component/DefaultTooltipContent').ValueType, import('recharts/types/component/DefaultTooltipContent').NameType> | undefined;
+    coordinate?: Partial<import('recharts/types/util/types').Coordinate>;
+    cursor?: boolean | React.ReactElement | React.SVGProps<SVGElement>;
+    filterNull?: boolean;
+    defaultIndex?: number;
+    isAnimationActive?: boolean;
+    offset?: number;
+    payloadUniqBy?: import('recharts/types/util/payload/getUniqPayload').UniqueOption<import('recharts/types/component/DefaultTooltipContent').Payload<import('recharts/types/component/DefaultTooltipContent').ValueType, import('recharts/types/component/DefaultTooltipContent').NameType>> | undefined;
+    position?: Partial<import('recharts/types/util/types').Coordinate>;
+    reverseDirection?: import('recharts/types/util/types').AllowInDimension;
+    shared?: boolean;
+    trigger?: "hover" | "click";
+    useTranslate3d?: boolean;
+    viewBox?: import('recharts/types/util/types').CartesianViewBox;
+    wrapperStyle?: React.CSSProperties;
+} & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: "line" | "dot" | "dashed";
+    nameKey?: string;
+    labelKey?: string;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ChartLegend: typeof RechartsPrimitive.Legend;
+declare const ChartLegendContent: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
+    hideIcon?: boolean;
+    nameKey?: string;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, ChartStyle, };
+//# sourceMappingURL=chart.d.ts.map

package/dist/components/ui/checkbox.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };
+//# sourceMappingURL=checkbox.d.ts.map

package/dist/components/ui/collapsible.d.ts

@@ -0,0 +1,6 @@
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+declare const Collapsible: import('react').ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & import('react').RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: import('react').ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & import('react').RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: import('react').ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };
+//# sourceMappingURL=collapsible.d.ts.map