visual-forge-hub-test-env 0.1.0

package/dist/components/entities/views/GanttView.d.ts

@@ -0,0 +1,33 @@
+type FieldType = 'text' | 'number' | 'boolean' | 'date' | 'longtext' | 'image' | 'url';
+interface EntityField {
+    id: string;
+    name: string;
+    display_name: string;
+    field_type: FieldType;
+}
+interface EntityRecord {
+    id: string;
+    data: any;
+    is_published: boolean;
+    created_at: string;
+}
+interface GanttConfig {
+    startDateField: string;
+    endDateField: string;
+    titleField: string;
+    groupByField?: string;
+    colorByField?: string;
+    dependenciesField?: string;
+    progressField?: string;
+}
+interface GanttViewProps {
+    records: EntityRecord[];
+    fields: EntityField[];
+    ganttConfig?: GanttConfig;
+    entityId: string;
+    onEdit: (record: EntityRecord) => void;
+    onDelete: (record: EntityRecord) => void;
+    onTogglePublish: (record: EntityRecord) => void;
+}
+export declare const GanttView: ({ records, fields, ganttConfig, entityId, onEdit, onDelete, onTogglePublish, }: GanttViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/entities/views/KanbanView.d.ts

@@ -0,0 +1,35 @@
+type FieldType = 'text' | 'number' | 'boolean' | 'date' | 'longtext' | 'image' | 'url';
+interface EntityField {
+    id: string;
+    name: string;
+    display_name: string;
+    field_type: FieldType;
+}
+interface EntityRecord {
+    id: string;
+    data: Record<string, any>;
+    is_published: boolean;
+    created_at: string;
+}
+interface CardLayout {
+    titleField: string;
+    subtitleField?: string;
+    displayFields: Array<{
+        fieldId: string;
+        position: number;
+    }>;
+}
+interface KanbanConfig {
+    groupByField: string;
+    cardLayout: CardLayout;
+}
+interface KanbanViewProps {
+    records: EntityRecord[];
+    fields: EntityField[];
+    kanbanConfig?: KanbanConfig;
+    onEdit: (record: EntityRecord) => void;
+    onDelete: (record: EntityRecord) => void;
+    onTogglePublish: (record: EntityRecord) => void;
+}
+export declare const KanbanView: ({ records, fields, kanbanConfig, onEdit, onDelete, onTogglePublish }: KanbanViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/entities/views/ListView.d.ts

@@ -0,0 +1,31 @@
+type FieldType = 'text' | 'number' | 'boolean' | 'date' | 'longtext' | 'image' | 'url';
+interface EntityField {
+    id: string;
+    name: string;
+    display_name: string;
+    field_type: FieldType;
+}
+interface EntityRecord {
+    id: string;
+    data: Record<string, any>;
+    is_published: boolean;
+    created_at: string;
+}
+interface ListConfig {
+    titleField: string;
+    subtitleField?: string;
+    displayFields: Array<{
+        fieldId: string;
+        position: number;
+    }>;
+}
+interface ListViewProps {
+    records: EntityRecord[];
+    fields: EntityField[];
+    listConfig?: ListConfig;
+    onEdit: (record: EntityRecord) => void;
+    onDelete: (record: EntityRecord) => void;
+    onTogglePublish: (record: EntityRecord) => void;
+}
+export declare const ListView: ({ records, fields, listConfig, onEdit, onDelete, onTogglePublish }: ListViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/entities/views/TimelineView.d.ts

@@ -0,0 +1,28 @@
+type FieldType = 'text' | 'number' | 'boolean' | 'date' | 'longtext' | 'image' | 'url';
+interface EntityField {
+    id: string;
+    name: string;
+    display_name: string;
+    field_type: FieldType;
+}
+interface EntityRecord {
+    id: string;
+    data: Record<string, any>;
+    is_published: boolean;
+    created_at: string;
+}
+interface TimelineConfig {
+    dateField: string;
+    titleField: string;
+    descriptionField?: string;
+}
+interface TimelineViewProps {
+    records: EntityRecord[];
+    fields: EntityField[];
+    timelineConfig?: TimelineConfig;
+    onEdit: (record: EntityRecord) => void;
+    onDelete: (record: EntityRecord) => void;
+    onTogglePublish: (record: EntityRecord) => void;
+}
+export declare const TimelineView: ({ records, fields, timelineConfig, onEdit, onDelete, onTogglePublish }: TimelineViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/ConditionalLogicEditor.d.ts

@@ -0,0 +1,20 @@
+interface ConditionalRule {
+    field_id: string;
+    operator: string;
+    value: string;
+}
+interface ConditionalLogic {
+    show_if?: ConditionalRule[];
+    logic_type?: "AND" | "OR";
+}
+interface ConditionalLogicEditorProps {
+    value: ConditionalLogic;
+    onChange: (value: ConditionalLogic) => void;
+    availableFields: Array<{
+        id: string;
+        label: string;
+        field_type: string;
+    }>;
+}
+export declare function ConditionalLogicEditor({ value, onChange, availableFields }: ConditionalLogicEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/CreateFormDialog.d.ts

@@ -0,0 +1,6 @@
+interface CreateFormDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function CreateFormDialog({ open, onOpenChange }: CreateFormDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/FieldLibrary.d.ts

@@ -0,0 +1,5 @@
+interface FieldLibraryProps {
+    onAddField: (fieldType: string, sectionId?: string) => void;
+}
+export declare function FieldLibrary({ onAddField }: FieldLibraryProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/FieldPropertiesPanel.d.ts

@@ -0,0 +1,11 @@
+interface FieldPropertiesPanelProps {
+    field: any;
+    onUpdate: (updates: any) => void;
+    availableFields: Array<{
+        id: string;
+        label: string;
+        field_type: string;
+    }>;
+}
+export declare function FieldPropertiesPanel({ field, onUpdate, availableFields }: FieldPropertiesPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/FormCanvas.d.ts

@@ -0,0 +1,11 @@
+interface FormCanvasProps {
+    fields: any[];
+    sections: any[];
+    onSelectField: (field: any) => void;
+    onSelectSection: (section: any) => void;
+    onDeleteField: (fieldId: string) => void;
+    onDeleteSection: (sectionId: string) => void;
+    onAddSection: () => void;
+}
+export declare function FormCanvas({ fields, sections, onSelectField, onSelectSection, onDeleteField, onDeleteSection, onAddSection }: FormCanvasProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/FormPreviewModal.d.ts

@@ -0,0 +1,9 @@
+interface FormPreviewModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    form: any;
+    fields: any[];
+    sections: any[];
+}
+export declare const FormPreviewModal: ({ open, onOpenChange, form, fields, sections }: FormPreviewModalProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/FormPropertiesPanel.d.ts

@@ -0,0 +1,6 @@
+interface FormPropertiesPanelProps {
+    form: any;
+    onUpdate: (updates: any) => void;
+}
+export declare function FormPropertiesPanel({ form, onUpdate }: FormPropertiesPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/FormSubmissionDialog.d.ts

@@ -0,0 +1,6 @@
+interface FormSubmissionDialogProps {
+    submission: any;
+    onClose: () => void;
+}
+export declare function FormSubmissionDialog({ submission, onClose }: FormSubmissionDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/FormTemplateDialog.d.ts

@@ -0,0 +1,15 @@
+interface FormTemplate {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    icon: string;
+    template_data: any;
+}
+interface FormTemplateDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelectTemplate: (template: FormTemplate) => void;
+}
+export declare function FormTemplateDialog({ open, onOpenChange, onSelectTemplate }: FormTemplateDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/OptionsEditor.d.ts

@@ -0,0 +1,10 @@
+interface Option {
+    value: string;
+    label: string;
+}
+interface OptionsEditorProps {
+    options: Option[];
+    onChange: (options: Option[]) => void;
+}
+export declare function OptionsEditor({ options, onChange }: OptionsEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/SectionPropertiesPanel.d.ts

@@ -0,0 +1,11 @@
+interface SectionPropertiesPanelProps {
+    section: any;
+    onUpdate: (updates: any) => void;
+    availableFields: Array<{
+        id: string;
+        label: string;
+        field_type: string;
+    }>;
+}
+export declare function SectionPropertiesPanel({ section, onUpdate, availableFields }: SectionPropertiesPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/SectionRenderer.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+interface Section {
+    id: string;
+    title: string;
+    description?: string;
+    section_type: "section" | "tab" | "column" | "repeatable";
+    is_visible: boolean;
+}
+interface SectionRendererProps {
+    sections: Section[];
+    children: (sectionId: string) => ReactNode;
+    className?: string;
+}
+export declare function SectionRenderer({ sections, children, className }: SectionRendererProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/ValidationRulesEditor.d.ts

@@ -0,0 +1,7 @@
+interface ValidationRulesEditorProps {
+    fieldType: string;
+    rules: any;
+    onChange: (rules: any) => void;
+}
+export declare function ValidationRulesEditor({ fieldType, rules, onChange }: ValidationRulesEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/public/ChartRenderer.d.ts

@@ -0,0 +1,12 @@
+interface ChartRendererProps {
+    content: {
+        chartType: string;
+        data: string;
+        title: string;
+        xAxisKey?: string;
+        yAxisKey?: string;
+        dataKeys?: string;
+    };
+}
+export declare const ChartRenderer: ({ content }: ChartRendererProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/public/ComponentRenderer.d.ts

@@ -0,0 +1,7 @@
+import { Tables } from '../../integrations/supabase/types';
+type Component = Tables<"page_components"> | Tables<"layout_components"> | Tables<"widget_components">;
+interface ComponentRendererProps {
+    component: Component;
+}
+export declare const ComponentRenderer: ({ component }: ComponentRendererProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/queries/CreateQueryDialog.d.ts

@@ -0,0 +1,6 @@
+interface CreateQueryDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+export default function CreateQueryDialog({ open, onOpenChange }: CreateQueryDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/queries/QueryConditionBuilder.d.ts

@@ -0,0 +1,5 @@
+interface QueryConditionBuilderProps {
+    queryId: string;
+}
+export default function QueryConditionBuilder({ queryId }: QueryConditionBuilderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/queries/QueryConditionTree.d.ts

@@ -0,0 +1,5 @@
+interface QueryConditionTreeProps {
+    queryId: string;
+}
+declare function QueryConditionTree({ queryId }: QueryConditionTreeProps): import("react/jsx-runtime").JSX.Element;
+export default QueryConditionTree;

package/dist/components/queries/QueryFieldSelector.d.ts

@@ -0,0 +1,7 @@
+interface QueryFieldSelectorProps {
+    queryId: string;
+    queryType: string;
+    primaryEntityId: string;
+}
+export default function QueryFieldSelector({ queryId, queryType, primaryEntityId }: QueryFieldSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/queries/QueryJoinBuilder.d.ts

@@ -0,0 +1,5 @@
+interface QueryJoinBuilderProps {
+    queryId: string;
+}
+export default function QueryJoinBuilder({ queryId }: QueryJoinBuilderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/queries/QueryJoinTree.d.ts

@@ -0,0 +1,5 @@
+interface QueryJoinTreeProps {
+    queryId: string;
+}
+declare function QueryJoinTree({ queryId }: QueryJoinTreeProps): import("react/jsx-runtime").JSX.Element;
+export default QueryJoinTree;

package/dist/components/queries/QuerySettingsPanel.d.ts

@@ -0,0 +1,6 @@
+interface QuerySettingsPanelProps {
+    queryId: string;
+    queryType: string;
+}
+export default function QuerySettingsPanel({ queryId, queryType }: QuerySettingsPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+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 };

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

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

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

@@ -0,0 +1,8 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: {
+    variant?: "default" | "destructive";
+} & import('class-variance-authority/types').ClassProp) => 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 };

package/dist/components/ui/aspect-ratio.d.ts

@@ -0,0 +1,3 @@
+import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio";
+declare const AspectRatio: import('react').ForwardRefExoticComponent<AspectRatioPrimitive.AspectRatioProps & import('react').RefAttributes<HTMLDivElement>>;
+export { AspectRatio };

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

@@ -0,0 +1,6 @@
+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 };

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

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

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

@@ -0,0 +1,19 @@
+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">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

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?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost";
+    size?: "icon" | "default" | "sm" | "lg";
+} & import('class-variance-authority/types').ClassProp) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

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

@@ -0,0 +1,8 @@
+import { DayPicker } from 'react-day-picker';
+import * as React from "react";
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

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

@@ -0,0 +1,18 @@
+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<import('./button').ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const CarouselNext: React.ForwardRefExoticComponent<Omit<import('./button').ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { type CarouselApi, Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext };

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

@@ -0,0 +1,62 @@
+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;
+}) => import("react/jsx-runtime").JSX.Element;
+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>;
+    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>>;
+    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 };

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

@@ -0,0 +1,4 @@
+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 };

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

@@ -0,0 +1,5 @@
+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 };