@skunkworksai/ui-kit 0.1.18

package/dist/types/components/primitives/AppSheet.d.ts

@@ -0,0 +1,32 @@
+import { Sheet, SheetContent, SheetDescription, SheetTitle, SheetTrigger } from "../ui/sheet";
+/**
+ * AppSheet — Extends the Dialog component to display content that complements the main screen content.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppSheet(props: React.ComponentProps<typeof Sheet>): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppSheetTrigger — The trigger component for AppSheet.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppSheetTrigger(props: React.ComponentProps<typeof SheetTrigger>): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppSheetContent — The content component for AppSheet.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppSheetContent({ className, ...props }: React.ComponentPropsWithoutRef<typeof SheetContent>): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppSheetHeader — The header section of an AppSheet.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppSheetHeader(props: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppSheetTitle — The title component for AppSheet.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppSheetTitle(props: React.ComponentPropsWithoutRef<typeof SheetTitle>): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppSheetDescription — The description component for AppSheet.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppSheetDescription(props: React.ComponentPropsWithoutRef<typeof SheetDescription>): import("react/jsx-runtime").JSX.Element;
+export { AppSheet, AppSheetTrigger, AppSheetContent, AppSheetHeader, AppSheetTitle, AppSheetDescription };

package/dist/types/components/primitives/AppSidebar.d.ts

@@ -0,0 +1,59 @@
+import * as React from "react";
+import { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar } from "../ui/sidebar";
+export type AppSidebarBrandDropdownItem = {
+    separator: true;
+} | {
+    separator?: false;
+    label: string;
+    onClick?: () => void;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+};
+export type AppSidebarBrandProps = {
+    logo?: string | {
+        src: string;
+    } | React.ReactNode;
+    collapsedLogo?: string | {
+        src: string;
+    } | React.ReactNode;
+    logoAlt?: string;
+    dropdown?: AppSidebarBrandDropdownItem[];
+    showChevron?: boolean;
+    className?: string;
+};
+declare function AppSidebarBrand({ logo, collapsedLogo, logoAlt, dropdown, showChevron, className, }: AppSidebarBrandProps): import("react/jsx-runtime").JSX.Element;
+export type AppSidebarDefaultNavItem = {
+    title: string;
+    icon: React.ElementType;
+    isActive?: boolean;
+    href?: string;
+};
+export type AppSidebarDefaultNavSection = {
+    label?: string;
+    items: AppSidebarDefaultNavItem[];
+};
+export declare const DEFAULT_NAV: AppSidebarDefaultNavSection[];
+declare function AppSidebarProvider(props: React.ComponentProps<typeof SidebarProvider>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebar({ className, ...props }: React.ComponentProps<typeof Sidebar>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarTrigger(props: React.ComponentProps<typeof SidebarTrigger>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarRail(props: React.ComponentProps<typeof SidebarRail>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarInset(props: React.ComponentProps<typeof SidebarInset>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarInput(props: React.ComponentProps<typeof SidebarInput>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarHeader(props: React.ComponentProps<typeof SidebarHeader>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarFooter(props: React.ComponentProps<typeof SidebarFooter>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarSeparator(props: React.ComponentProps<typeof SidebarSeparator>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarContent(props: React.ComponentProps<typeof SidebarContent>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarGroup(props: React.ComponentProps<typeof SidebarGroup>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarGroupLabel(props: React.ComponentProps<typeof SidebarGroupLabel>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarGroupAction(props: React.ComponentProps<typeof SidebarGroupAction>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarGroupContent(props: React.ComponentProps<typeof SidebarGroupContent>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarMenu({ className, ...props }: React.ComponentProps<typeof SidebarMenu>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarMenuItem(props: React.ComponentProps<typeof SidebarMenuItem>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarMenuButton({ className, ...props }: React.ComponentProps<typeof SidebarMenuButton>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarMenuAction(props: React.ComponentProps<typeof SidebarMenuAction>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarMenuBadge(props: React.ComponentProps<typeof SidebarMenuBadge>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarMenuSkeleton(props: React.ComponentProps<typeof SidebarMenuSkeleton>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarMenuSub(props: React.ComponentProps<typeof SidebarMenuSub>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarMenuSubItem(props: React.ComponentProps<typeof SidebarMenuSubItem>): import("react/jsx-runtime").JSX.Element;
+declare function AppSidebarMenuSubButton(props: React.ComponentProps<typeof SidebarMenuSubButton>): import("react/jsx-runtime").JSX.Element;
+export { AppSidebar, AppSidebarBrand, AppSidebarContent, AppSidebarFooter, AppSidebarGroup, AppSidebarGroupAction, AppSidebarGroupContent, AppSidebarGroupLabel, AppSidebarHeader, AppSidebarInput, AppSidebarInset, AppSidebarMenu, AppSidebarMenuAction, AppSidebarMenuBadge, AppSidebarMenuButton, AppSidebarMenuItem, AppSidebarMenuSkeleton, AppSidebarMenuSub, AppSidebarMenuSubButton, AppSidebarMenuSubItem, AppSidebarProvider, AppSidebarRail, AppSidebarSeparator, AppSidebarTrigger, useSidebar, };

package/dist/types/components/primitives/AppSkeleton.d.ts

@@ -0,0 +1,6 @@
+/**
+ * AppSkeleton — Used to show a placeholder while content is loading.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppSkeleton(props: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+export { AppSkeleton };

package/dist/types/components/primitives/AppSpinner.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+type AppSpinnerProps = React.SVGAttributes<SVGSVGElement> & {
+    label?: string;
+};
+/**
+ * AppSpinner — A loading indicator component.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare const AppSpinner: React.ForwardRefExoticComponent<React.SVGAttributes<SVGSVGElement> & {
+    label?: string;
+} & React.RefAttributes<SVGSVGElement>>;
+export { AppSpinner };
+export type { AppSpinnerProps };

package/dist/types/components/primitives/AppSwitch.d.ts

@@ -0,0 +1,8 @@
+import { Switch } from "../ui/switch";
+type AppSwitchProps = React.ComponentPropsWithoutRef<typeof Switch>;
+/**
+ * AppSwitch — A control that allows the user to toggle between checked and unchecked states.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppSwitch(props: AppSwitchProps): import("react/jsx-runtime").JSX.Element;
+export { AppSwitch };

package/dist/types/components/primitives/AppTable.d.ts

@@ -0,0 +1,53 @@
+import * as React from "react";
+import { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow } from "../ui/table";
+/**
+ * AppTable — A responsive table component for displaying data in rows and columns.
+ * @note Never use the raw HTML equivalent. Use AppTable.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+type AppTableProps = React.ComponentProps<typeof Table>;
+declare function AppTable(props: AppTableProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTableHeader — The header section of an AppTable.
+ * @note Never use the raw HTML equivalent. Use AppTableHeader.
+ */
+type AppTableHeaderProps = React.ComponentProps<typeof TableHeader>;
+declare function AppTableHeader(props: AppTableHeaderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTableBody — The body section of an AppTable.
+ * @note Never use the raw HTML equivalent. Use AppTableBody.
+ */
+type AppTableBodyProps = React.ComponentProps<typeof TableBody>;
+declare function AppTableBody(props: AppTableBodyProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTableFooter — The footer section of an AppTable.
+ * @note Never use the raw HTML equivalent. Use AppTableFooter.
+ */
+type AppTableFooterProps = React.ComponentProps<typeof TableFooter>;
+declare function AppTableFooter(props: AppTableFooterProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTableHead — A header cell within an AppTable.
+ * @note Never use the raw HTML equivalent. Use AppTableHead.
+ */
+type AppTableHeadProps = React.ComponentProps<typeof TableHead>;
+declare function AppTableHead(props: AppTableHeadProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTableRow — A row within an AppTable.
+ * @note Never use the raw HTML equivalent. Use AppTableRow.
+ * @note Set data-state="selected" to apply the selection highlight.
+ */
+type AppTableRowProps = React.ComponentProps<typeof TableRow>;
+declare function AppTableRow(props: AppTableRowProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTableCell — A cell within an AppTable.
+ * @note Never use the raw HTML equivalent. Use AppTableCell.
+ */
+type AppTableCellProps = React.ComponentProps<typeof TableCell>;
+declare function AppTableCell(props: AppTableCellProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTableCaption — A caption for an AppTable. Place as the first child of AppTable.
+ * @note Never use the raw HTML equivalent. Use AppTableCaption.
+ */
+type AppTableCaptionProps = React.ComponentProps<typeof TableCaption>;
+declare function AppTableCaption(props: AppTableCaptionProps): import("react/jsx-runtime").JSX.Element;
+export { AppTable, type AppTableProps, AppTableHeader, type AppTableHeaderProps, AppTableBody, type AppTableBodyProps, AppTableFooter, type AppTableFooterProps, AppTableHead, type AppTableHeadProps, AppTableRow, type AppTableRowProps, AppTableCell, type AppTableCellProps, AppTableCaption, type AppTableCaptionProps, };

package/dist/types/components/primitives/AppTabs.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { Tabs, TabsContent, TabsList, TabsTrigger, type TabsVariant } from "../ui/tabs";
+type AppTabsProps = React.ComponentProps<typeof Tabs> & {
+    variant?: TabsVariant;
+};
+declare function AppTabs({ variant, className, ...props }: AppTabsProps): import("react/jsx-runtime").JSX.Element;
+declare function AppTabsList({ className, ...props }: Omit<React.ComponentProps<typeof TabsList>, "variant">): import("react/jsx-runtime").JSX.Element;
+declare function AppTabsTrigger(props: Omit<React.ComponentProps<typeof TabsTrigger>, "variant">): import("react/jsx-runtime").JSX.Element;
+declare function AppTabsContent(props: React.ComponentProps<typeof TabsContent>): import("react/jsx-runtime").JSX.Element;
+export { AppTabs, AppTabsList, AppTabsTrigger, AppTabsContent, type AppTabsProps };

package/dist/types/components/primitives/AppTextarea.d.ts

@@ -0,0 +1,9 @@
+import { Textarea } from "../ui/textarea";
+type AppTextareaProps = React.ComponentPropsWithoutRef<typeof Textarea>;
+/**
+ * AppTextarea — A multi-line text input component.
+ * @note Never use the raw HTML equivalent. Use AppTextarea.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppTextarea(props: AppTextareaProps): import("react/jsx-runtime").JSX.Element;
+export { AppTextarea };

package/dist/types/components/primitives/AppThemeProvider.d.ts

@@ -0,0 +1,46 @@
+import * as React from "react";
+import { AppButton } from "./AppButton";
+export type AppTheme = "light" | "dark";
+export type AppThemeContextValue = {
+    theme: AppTheme;
+    toggle: () => void;
+};
+export type AppThemeProviderProps = {
+    children: React.ReactNode;
+    /** localStorage key used to persist the theme preference. Default: "ui-kit-theme" */
+    storageKey?: string;
+    /** Theme to use when no stored preference exists. Default: "light" */
+    defaultTheme?: AppTheme;
+};
+/**
+ * AppThemeProvider — Provides theme context and persists the user's light/dark
+ * preference to localStorage. Toggles the `dark` class on `<html>`.
+ *
+ * Place this near the root of your app (e.g. in layout.tsx):
+ * ```tsx
+ * <AppThemeProvider>
+ *   {children}
+ * </AppThemeProvider>
+ * ```
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppThemeProvider({ children, storageKey, defaultTheme, }: AppThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+declare namespace AppThemeProvider {
+    var displayName: string;
+}
+/**
+ * useAppTheme — Returns the current theme and a toggle function.
+ * Requires AppThemeProvider to be present in the tree.
+ * Falls back to `{ theme: "light", toggle: () => {} }` if no provider is found.
+ */
+declare function useAppTheme(): AppThemeContextValue;
+/**
+ * AppThemeToggle — Ghost icon button that switches between Sun (light) and Moon (dark).
+ * Requires AppThemeProvider to be present in the tree.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppThemeToggle({ ...props }: React.ComponentProps<typeof AppButton>): import("react/jsx-runtime").JSX.Element;
+declare namespace AppThemeToggle {
+    var displayName: string;
+}
+export { AppThemeProvider, useAppTheme, AppThemeToggle };

package/dist/types/components/primitives/AppToaster.d.ts

@@ -0,0 +1,7 @@
+import { toast as appToast } from "sonner";
+/**
+ * AppToaster — A component that displays toast notifications.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare const AppToaster: () => import("react/jsx-runtime").JSX.Element;
+export { AppToaster, appToast as toast };

package/dist/types/components/primitives/AppToggle.d.ts

@@ -0,0 +1,9 @@
+import { Toggle, toggleVariants } from "../ui/toggle";
+import type { VariantProps } from "class-variance-authority";
+type AppToggleProps = React.ComponentProps<typeof Toggle> & VariantProps<typeof toggleVariants>;
+/**
+ * AppToggle — A two-state button that can be either on or off.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppToggle(props: AppToggleProps): import("react/jsx-runtime").JSX.Element;
+export { AppToggle };

package/dist/types/components/primitives/AppToggleGroup.d.ts

@@ -0,0 +1,18 @@
+/**
+ * AppToggleGroup — A set of two-state buttons that can be toggled on or off.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare const AppToggleGroup: import("react").ForwardRefExoticComponent<((Omit<import("@radix-ui/react-toggle-group").ToggleGroupSingleProps & import("react").RefAttributes<HTMLDivElement>, "ref"> | Omit<import("@radix-ui/react-toggle-group").ToggleGroupMultipleProps & import("react").RefAttributes<HTMLDivElement>, "ref">) & import("class-variance-authority").VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & {
+    size?: "default" | "sm" | "lg";
+}) & import("react").RefAttributes<HTMLDivElement>>;
+/**
+ * AppToggleGroupItem — An individual toggle button within AppToggleGroup.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare const AppToggleGroupItem: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-toggle-group").ToggleGroupItemProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("class-variance-authority").VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & import("react").RefAttributes<HTMLButtonElement>>;
+export { AppToggleGroup, AppToggleGroupItem };

package/dist/types/components/primitives/AppTooltip.d.ts

@@ -0,0 +1,26 @@
+import { Tooltip, TooltipContent, TooltipTrigger } from "../ui/tooltip";
+/**
+ * AppTooltipProvider — Wraps components to provide tooltip context. Place at app root or layout level.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppTooltipProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTooltip — A popup that displays information related to an element on hover or focus.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppTooltip(props: React.ComponentProps<typeof Tooltip>): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTooltipTrigger — The element that triggers the tooltip.
+ * @note Use `asChild` when wrapping an existing interactive element (button, link).
+ * @note Wrap disabled buttons in a <span> so pointer events reach the trigger.
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppTooltipTrigger(props: React.ComponentProps<typeof TooltipTrigger>): import("react/jsx-runtime").JSX.Element;
+/**
+ * AppTooltipContent — The tooltip popup. Suppressed on mobile (no hover on touch).
+ * @note If a prop you need is missing, stop and inform the design team.
+ */
+declare function AppTooltipContent(props: React.ComponentProps<typeof TooltipContent>): import("react/jsx-runtime").JSX.Element | null;
+export { AppTooltip, AppTooltipProvider, AppTooltipTrigger, AppTooltipContent };

package/dist/types/components/primitives/AppTypography.d.ts

@@ -0,0 +1,80 @@
+import * as React from "react";
+/**
+ * AppTypography — the typography primitive for UI Kit.
+ *
+ * @prop variant - Controls the visual style and default HTML tag. Required.
+ * @prop as - Overrides the rendered HTML tag while keeping the variant's styles.
+ *   Use when semantic HTML requires a different tag than the visual style.
+ *
+ * @note Never use raw heading or paragraph elements for styled text — use AppTypography.
+ * @note Never set font-size, font-weight, or color directly — use the variant prop.
+ * @note If a variant you need is missing, stop and inform the design team.
+ */
+declare const variantConfig: {
+    readonly display: {
+        readonly tag: "h1";
+        readonly classes: "scroll-m-20 text-4xl font-extrabold tracking-tight text-balance text-foreground";
+    };
+    readonly h1: {
+        readonly tag: "h1";
+        readonly classes: "scroll-m-20 text-4xl font-extrabold tracking-tight text-balance text-foreground";
+    };
+    readonly h2: {
+        readonly tag: "h2";
+        readonly classes: "scroll-m-20 border-b pb-2 text-3xl font-semibold tracking-tight first:mt-0 text-foreground";
+    };
+    readonly h3: {
+        readonly tag: "h3";
+        readonly classes: "scroll-m-20 text-2xl font-semibold tracking-tight text-foreground";
+    };
+    readonly h4: {
+        readonly tag: "h4";
+        readonly classes: "scroll-m-20 text-xl font-semibold tracking-tight text-foreground";
+    };
+    readonly p: {
+        readonly tag: "p";
+        readonly classes: "leading-7 [&:not(:first-child)]:mt-6 text-foreground";
+    };
+    readonly lead: {
+        readonly tag: "p";
+        readonly classes: "text-xl text-muted-foreground";
+    };
+    readonly large: {
+        readonly tag: "div";
+        readonly classes: "text-lg font-semibold text-foreground";
+    };
+    readonly small: {
+        readonly tag: "small";
+        readonly classes: "text-sm font-medium leading-none";
+    };
+    readonly muted: {
+        readonly tag: "p";
+        readonly classes: "text-sm text-muted-foreground";
+    };
+    readonly mono: {
+        readonly tag: "p";
+        readonly classes: "text-sm font-mono text-foreground";
+    };
+    readonly blockquote: {
+        readonly tag: "blockquote";
+        readonly classes: "mt-6 border-l-2 pl-6 italic text-foreground";
+    };
+    readonly code: {
+        readonly tag: "code";
+        readonly classes: "relative rounded bg-muted px-[0.3rem] py-[0.2rem] font-mono text-sm font-semibold text-foreground";
+    };
+    readonly list: {
+        readonly tag: "ul";
+        readonly classes: "my-6 ml-6 list-disc [&>li]:mt-2 text-foreground";
+    };
+};
+type AppTypographyVariant = keyof typeof variantConfig;
+type AppTypographyProps = {
+    variant: AppTypographyVariant;
+    as?: React.ElementType;
+    className?: string;
+    children?: React.ReactNode;
+} & Omit<React.HTMLAttributes<HTMLElement>, "className" | "children">;
+declare function AppTypography({ variant, as, className, children, ...props }: AppTypographyProps): import("react/jsx-runtime").JSX.Element;
+export { AppTypography };
+export type { AppTypographyProps, AppTypographyVariant };

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

@@ -0,0 +1,57 @@
+export * from "./AppAccordion";
+export * from "./AppAlert";
+export * from "./AppAlertDialog";
+export * from "./AppAspectRatio";
+export * from "./AppAvatar";
+export * from "./AppBadge";
+export * from "./AppBreadcrumb";
+export * from "./AppButton";
+export * from "./AppButtonGroup";
+export * from "./AppCalendar";
+export * from "./AppCard";
+export * from "./AppCheckbox";
+export * from "./AppCollapsible";
+export * from "./AppCommand";
+export * from "./AppContextMenu";
+export * from "./AppDialog";
+export * from "./AppDrawer";
+export * from "./AppDropdownMenu";
+export * from "./AppField";
+export * from "./AppForm";
+export * from "./AppHoverCard";
+export * from "./AppInput";
+export * from "./AppLabel";
+export * from "./AppMenubar";
+export * from "./AppNavigationMenu";
+export * from "./AppPagination";
+export * from "./AppPopover";
+export * from "./AppProgress";
+export * from "./AppRadioGroup";
+export * from "./AppScrollArea";
+export * from "./AppScrollText";
+export * from "./AppSelect";
+export * from "./AppSeparator";
+export * from "./AppSheet";
+export * from "./AppSidebar";
+export * from "./AppSpinner";
+export * from "./AppSkeleton";
+export * from "./AppSwitch";
+export * from "./AppTable";
+export * from "./AppTabs";
+export * from "./AppTypography";
+export * from "./AppTextarea";
+export * from "./AppToggle";
+export * from "./AppToggleGroup";
+export * from "./AppTooltip";
+export * from "./AppCarousel";
+export * from "./AppDatePicker";
+export * from "./AppChart";
+export * from "./AppDataTable";
+export * from "./AppCombobox";
+export * from "./AppEmpty";
+export * from "./AppKbd";
+export { AppToaster, toast as sonnerToast } from "./AppToaster";
+export { AppThemeProvider, useAppTheme, AppThemeToggle, type AppTheme, type AppThemeProviderProps, type AppThemeContextValue } from "./AppThemeProvider";
+export * from "../blocks";
+export { usePageTitle } from "../../hooks/use-page-title";
+export type { AppPageTitleProps } from "../blocks/AppPageTitle";

package/dist/types/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/types/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/types/components/ui/alert.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+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 };

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

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

package/dist/types/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/types/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/types/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/types/components/ui/button.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "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;
+}): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants };
+export type ButtonProps = React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+};

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { DayPicker } from "react-day-picker";
+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/types/components/ui/card.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+declare function Card({ className, size, ...props }: React.ComponentProps<"div"> & {
+    size?: "default" | "sm";
+}): import("react/jsx-runtime").JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };

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

@@ -0,0 +1,28 @@
+import * as React from "react";
+import useEmblaCarousel, { type UseEmblaCarouselType } from "embla-carousel-react";
+import { Button } from "./button";
+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;
+};
+type CarouselContextProps = {
+    carouselRef: ReturnType<typeof useEmblaCarousel>[0];
+    api: ReturnType<typeof useEmblaCarousel>[1];
+    scrollPrev: () => void;
+    scrollNext: () => void;
+    canScrollPrev: boolean;
+    canScrollNext: boolean;
+} & CarouselProps;
+declare function useCarousel(): CarouselContextProps;
+declare function Carousel({ orientation, opts, setApi, plugins, className, children, ...props }: React.ComponentProps<"div"> & CarouselProps): import("react/jsx-runtime").JSX.Element;
+declare function CarouselContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CarouselItem({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CarouselPrevious({ className, variant, size, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+declare function CarouselNext({ className, variant, size, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+export { type CarouselApi, Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext, useCarousel, };