chesai-ui 0.1.0

package/dist/components/radio-group/index.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+export interface RadioGroupItemProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    value?: string;
+}
+declare const RadioGroupItem: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLInputElement>>;
+interface RadioGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    label?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    name?: string;
+    disabled?: boolean;
+}
+declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Radio: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>> & {
+    Item: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLInputElement>>;
+};
+export { Radio, RadioGroup, RadioGroupItem };

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

@@ -0,0 +1,51 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+import * as SelectPrimitive from "@radix-ui/react-select";
+interface SelectContextProps {
+    variant: "primary" | "secondary";
+    shape: "full" | "minimal" | "sharp";
+    size: "sm" | "md" | "lg";
+}
+declare const selectTriggerVariants: (props?: {
+    variant?: "primary" | "secondary";
+    shape?: "full" | "minimal" | "sharp";
+    size?: "md" | "lg" | "sm";
+    isErrored?: boolean;
+    disabled?: boolean;
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+interface SelectProps extends SelectPrimitive.SelectProps {
+    children: React.ReactNode;
+    variant?: SelectContextProps["variant"];
+    shape?: SelectContextProps["shape"];
+    size?: SelectContextProps["size"];
+}
+declare const Select: React.FC<SelectProps>;
+interface SelectTriggerProps extends React.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger> {
+    error?: string;
+    variant?: VariantProps<typeof selectTriggerVariants>["variant"];
+    shape?: VariantProps<typeof selectTriggerVariants>["shape"];
+    size?: VariantProps<typeof selectTriggerVariants>["size"];
+}
+declare const SelectTrigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface SelectWrapperProps extends Omit<SelectProps, "children" | "onChange">, VariantProps<typeof selectTriggerVariants> {
+    label?: string;
+    error?: string;
+    placeholder?: string;
+    items: {
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }[];
+    id?: string;
+    contentPosition?: React.ComponentProps<typeof SelectContent>["position"];
+    onValueChange?: (value: string) => void;
+    value?: string;
+}
+declare const SelectInput: React.ForwardRefExoticComponent<SelectWrapperProps & React.RefAttributes<HTMLButtonElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectInput, };

package/dist/components/shallow-router/index.d.ts

@@ -0,0 +1,63 @@
+import { default as React, HTMLAttributes, ReactNode } from 'react';
+import { default as useShallowRouter } from '../../hooks/useShallowRouter';
+type RouterMode = "search" | "pathname";
+interface RouterOptions {
+    mode: RouterMode;
+    paramName: string;
+    basePath: string;
+}
+/**
+ * A custom hook to consume the ShallowRouter context.
+ * Provides access to routing functions like `push`, `replace`, and the current `path`.
+ *
+ * @returns {ReturnType<typeof useShallowRouter>} The router instance.
+ * @throws {Error} If used outside of a `<ShallowRouter>` provider.
+ */
+export declare const useRouter: () => ReturnType<typeof useShallowRouter>;
+/**
+ * A custom hook to access the configuration options of the nearest ShallowRouter provider.
+ * Useful for components that need to behave differently based on the routing mode.
+ *
+ * @returns {RouterOptions} The router's configuration options.
+ * @throws {Error} If used outside of a `<ShallowRouter>` provider.
+ */
+export declare const useRouterOptions: () => RouterOptions;
+interface ShallowRouterProps {
+    children: ReactNode;
+    mode?: RouterMode;
+    paramName?: string;
+    basePath?: string;
+}
+/**
+ * A provider component that initializes the shallow router and makes its
+ * state and methods available to all descendant components.
+ */
+export declare const ShallowRouter: React.FC<ShallowRouterProps>;
+interface ShallowRouteProps {
+    /** The path to match. Supports a trailing wildcard `*` for prefix matching. */
+    path: string;
+    children: ReactNode;
+}
+/**
+ * Conditionally renders its children only when its `path` prop matches the current router path.
+ * Supports a trailing wildcard `*` for prefix matching (e.g., `/users/*`).
+ */
+export declare const ShallowRoute: React.FC<ShallowRouteProps>;
+interface ShallowPageProps extends HTMLAttributes<HTMLDivElement> {
+    /** The path that this page corresponds to. Used by `ShallowSwitch` to identify the active page. */
+    path: string;
+}
+/**
+ * A simple container for a page's content.
+ * It should be used as a direct child of `ShallowSwitch`.
+ */
+export declare const ShallowPage: React.ForwardRefExoticComponent<ShallowPageProps & React.RefAttributes<HTMLDivElement>>;
+interface ShallowSwitchProps {
+    children: React.ReactElement<ShallowPageProps> | React.ReactElement<ShallowPageProps>[];
+}
+/**
+ * Manages rendering `<ShallowPage>` components. It identifies the active
+ * page based on the current route and renders only that page.
+ */
+export declare const ShallowSwitch: React.FC<ShallowSwitchProps>;
+export {};

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

@@ -0,0 +1,41 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+import { Drawer as VaulDrawer } from 'vaul';
+type SheetProps = React.ComponentProps<typeof VaulDrawer.Root> & {
+    mode?: "normal" | "detached";
+    shape?: "full" | "minimal" | "sharp";
+    side?: "left" | "right";
+    /**
+     * If true, the sheet will always render as a bottom sheet,
+     * overriding the responsive behavior on desktop viewports.
+     * @default false
+     */
+    forceBottomSheet?: boolean;
+};
+declare const contentVariants: (props?: {
+    side?: "bottom" | "left" | "right" | "top";
+    height?: "auto" | "snap";
+    shape?: "full" | "minimal" | "sharp";
+    mode?: "normal" | "detached";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+type SheetContentProps = React.ComponentProps<typeof VaulDrawer.Content> & VariantProps<typeof contentVariants>;
+export declare const Sheet: React.FC<SheetProps> & {
+    Trigger: React.ForwardRefExoticComponent<import('@radix-ui/react-dialog').DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<SheetContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Close: React.ForwardRefExoticComponent<import('@radix-ui/react-dialog').DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+    Title: React.ForwardRefExoticComponent<import('@radix-ui/react-dialog').DialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<import('@radix-ui/react-dialog').DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+    Header: {
+        ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Grabber: {
+        ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export {};

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

@@ -0,0 +1,76 @@
+import { MotionValue } from 'framer-motion';
+import { default as React } from 'react';
+type DesktopVariant = "permanent" | "modal";
+type MobileVariant = "modal" | "push";
+type SidebarSide = "left" | "right";
+interface SidebarContextProps {
+    isDesktop: boolean;
+    isExpanded: boolean;
+    isOpen: boolean;
+    activeItem: string;
+    desktopVariant: DesktopVariant;
+    mobileVariant: MobileVariant;
+    side: SidebarSide;
+    collapsible: boolean;
+    indicatorId: string;
+    variant: "primary" | "secondary";
+    sidebarX: MotionValue<number>;
+    expandedWidth: number;
+    toggle: () => void;
+    onOpenChange: (isOpen: boolean) => void;
+    handleItemPress: (itemKey: string) => void;
+}
+/**
+ * Hook to access sidebar state and actions. Must be used within a <Sidebar> component.
+ */
+export declare const useSidebar: () => SidebarContextProps;
+interface SidebarProps {
+    children: [
+        React.ReactElement<SidebarContainerProps>,
+        React.ReactElement<SidebarContentProps>
+    ];
+    activeItem: string;
+    onItemPress: (itemKey: string) => void;
+    isOpen?: boolean;
+    onOpenChange?: (isOpen: boolean) => void;
+    defaultOpen?: boolean;
+    desktopVariant?: DesktopVariant;
+    mobileVariant?: MobileVariant;
+    side?: SidebarSide;
+    collapsible?: boolean;
+}
+interface SidebarContainerProps {
+    children: React.ReactNode;
+    className?: string;
+    variant?: "primary" | "secondary";
+}
+interface PrimaryActionProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    icon: React.ReactNode;
+    variant?: "primary" | "secondary";
+}
+interface SidebarNavProps extends React.HTMLAttributes<HTMLElement> {
+    size?: "sm" | "md" | "lg";
+    shape?: "full" | "minimal" | "sharp";
+}
+interface NavItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    itemKey: string;
+    icon: React.ReactNode;
+    endAdornment?: React.ReactNode;
+    size?: "sm" | "md" | "lg";
+    shape?: "full" | "minimal" | "sharp";
+}
+interface SidebarContentProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+export declare const Sidebar: React.FC<SidebarProps> & {
+    Container: React.NamedExoticComponent<SidebarContainerProps & React.RefAttributes<HTMLElement>>;
+    Header: React.MemoExoticComponent<(props: React.HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element>;
+    PrimaryAction: React.NamedExoticComponent<PrimaryActionProps & React.RefAttributes<HTMLButtonElement>>;
+    Nav: React.MemoExoticComponent<({ children, className, size, shape, ...props }: SidebarNavProps) => import("react/jsx-runtime").JSX.Element>;
+    Item: React.NamedExoticComponent<NavItemProps & React.RefAttributes<HTMLButtonElement>>;
+    Footer: React.MemoExoticComponent<(props: React.HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element>;
+    Separator: React.MemoExoticComponent<(props: React.HTMLAttributes<HTMLHRElement>) => import("react/jsx-runtime").JSX.Element>;
+    SectionHeader: React.MemoExoticComponent<(props: React.HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element>;
+    DragHandle: React.MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+    Content: React.NamedExoticComponent<SidebarContentProps & React.RefAttributes<HTMLDivElement>>;
+};
+export {};

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

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+import * as RadixSlider from "@radix-ui/react-slider";
+declare const Slider: React.ForwardRefExoticComponent<Omit<RadixSlider.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & VariantProps<(props?: {
+    variant?: "linear" | "bar";
+    direction?: "horizontal" | "vertical";
+    size?: "md" | "lg" | "sm" | "xl" | "2xl";
+} & import('class-variance-authority/dist/types').ClassProp) => string> & React.RefAttributes<HTMLSpanElement>>;
+export { Slider };

package/dist/components/split-button/index.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+type ButtonShape = "full" | "minimal" | "sharp";
+type SplitButtonChildren = [
+    React.ReactElement<{
+        className?: string;
+    }>,
+    React.ReactElement<{
+        className?: string;
+    }>
+];
+interface SplitButtonProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: SplitButtonChildren;
+    shape?: ButtonShape;
+}
+export declare const SplitButton: {
+    ({ children, className, shape, ...props }: SplitButtonProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

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

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+declare const switchTrackVariants: (props?: {
+    size?: "md" | "lg" | "sm";
+    shape?: "full" | "minimal" | "sharp";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface SwitchProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, // Omit the conflicting 'size' prop
+VariantProps<typeof switchTrackVariants> {
+    label?: string;
+}
+export declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLInputElement>>;
+export {};

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

@@ -0,0 +1,43 @@
+import { ColumnDef, Row, Table as TanstackTable } from '@tanstack/react-table';
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+declare module "@tanstack/react-table" {
+    interface ColumnMeta<TData, TValue> {
+        isAccordionHeader?: boolean;
+    }
+}
+export type { ColumnDef };
+type ResponsiveLayout = "scroll" | "custom";
+declare const tableVariants: (props?: {
+    layout?: "custom" | "scroll" | "desktop";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface TableRootProps<TData> extends React.HTMLAttributes<HTMLTableElement>, VariantProps<typeof tableVariants> {
+    table: TanstackTable<TData>;
+    responsiveLayout?: ResponsiveLayout;
+    breakpoint?: "sm" | "md" | "lg";
+    stickyCellVariant?: "card" | "secondary";
+    /**
+     * A function to render a custom component for each row on mobile viewports.
+     * Required when `responsiveLayout` is set to `'custom'`.
+     * @param row The TanStack Table `row` object.
+     */
+    renderMobileRow?: (row: Row<TData>) => React.ReactNode;
+}
+export declare const Table: {
+    <TData extends {}>({ className, table, responsiveLayout, breakpoint, stickyCellVariant, renderMobileRow, ...props }: TableRootProps<TData>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+} & {
+    Row: {
+        <TData extends {}>({ row, ...rest }: {
+            row: Row<TData>;
+            [key: string]: any;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Head: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & {
+        colIndex: number;
+    } & React.RefAttributes<HTMLTableCellElement>>;
+    Cell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & {
+        colIndex: number;
+    } & React.RefAttributes<HTMLTableCellElement>>;
+};

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

@@ -0,0 +1,42 @@
+import { default as React } from 'react';
+type TabVariant = "primary" | "secondary";
+type PageTransition = "slide" | "fade";
+interface TabsContextProps {
+    activeTab: string;
+    setActiveTab: (value: string) => void;
+    variant: TabVariant;
+    pageTransition: PageTransition;
+    indicatorId: string;
+}
+export declare const useTabs: () => TabsContextProps;
+interface TabsProps {
+    children: React.ReactNode;
+    defaultValue: string;
+    variant?: TabVariant;
+    pageTransition?: PageTransition;
+    routingMode?: "search" | "pathname";
+    routingParamName?: string;
+    /**
+     * For 'pathname' mode, specifies which tab to redirect to on initial load
+     * if the current path is the base path.
+     */
+    initialTab?: string;
+}
+interface TabsListProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+interface TabsTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    value: string;
+    icon?: React.ReactNode;
+}
+interface TabsContentProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+interface TabsPanelProps extends React.HTMLAttributes<HTMLDivElement> {
+    value: string;
+}
+export declare const Tabs: React.FC<TabsProps> & {
+    List: React.ForwardRefExoticComponent<TabsListProps & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+    Panel: React.ForwardRefExoticComponent<TabsPanelProps & React.RefAttributes<HTMLDivElement>>;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+declare const taskbarVariants: (props?: {
+    variant?: "card" | "secondary" | "transparent";
+    bordered?: boolean;
+    size?: "md" | "lg" | "sm";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface TaskbarProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof taskbarVariants> {
+    /** Content to render at the start of the taskbar (e.g., app icon, title). */
+    startAdornment?: React.ReactNode;
+    /** Content to render in the center (e.g., navigation menu). */
+    centerAdornment?: React.ReactNode;
+    /** Determines if the maximize icon should show the 'restore' state. */
+    isMaximized?: boolean;
+    /** Callback fired when the minimize button is clicked. */
+    onMinimize?: () => void;
+    /** Callback fired when the maximize/restore button is clicked. */
+    onMaximize?: () => void;
+    /** Callback fired when the close button is clicked. */
+    onClose?: () => void;
+}
+export declare const Taskbar: React.ForwardRefExoticComponent<TaskbarProps & React.RefAttributes<HTMLElement>>;
+export {};

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

@@ -0,0 +1,17 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+declare const textAreaWrapperVariants: (props?: {
+    variant?: "primary" | "secondary" | "minimal";
+    shape?: "full" | "minimal" | "sharp";
+    size?: "md" | "lg" | "sm";
+    isErrored?: boolean;
+    isFocused?: boolean;
+    disabled?: boolean;
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface TextAreaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "size">, VariantProps<typeof textAreaWrapperVariants> {
+    label?: string;
+    error?: string;
+    wrapperClassName?: string;
+}
+export declare const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export {};

package/dist/components/time-picker/index.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+import { inputWrapperVariants } from '../input';
+export interface TimePickerProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "value" | "onChange" | "size">, VariantProps<typeof inputWrapperVariants> {
+    label?: string;
+    error?: string;
+    placeholder?: string;
+    value?: Date;
+    onChange?: (date: Date) => void;
+    variant?: "docked" | "modal";
+}
+export declare const TimePicker: React.ForwardRefExoticComponent<TimePickerProps & React.RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,9 @@
+import { Toaster as Sonner } from 'sonner';
+type ToasterProps = React.ComponentProps<typeof Sonner>;
+/**
+ * A toaster component that displays notifications. It is a styled wrapper
+ * around the `sonner` library, configured to match the chesai-ui theme.
+ */
+declare const Toaster: ({ ...props }: ToasterProps) => import("react/jsx-runtime").JSX.Element;
+export { toast } from 'sonner';
+export { Toaster };

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

@@ -0,0 +1,33 @@
+import { useFloating } from '@floating-ui/react';
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+declare const tooltipVariants: (props?: {
+    variant?: "primary" | "secondary";
+    size?: "md" | "lg" | "sm";
+    shape?: "full" | "minimal" | "sharp";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface TooltipProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof tooltipVariants> {
+}
+interface TooltipContextType {
+    isOpen: boolean;
+    setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    getReferenceProps: (userProps?: React.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    floatingStyles: React.CSSProperties;
+    refs: {
+        setReference: (node: HTMLElement | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    };
+    middlewareData: ReturnType<typeof useFloating>["middlewareData"];
+    placement: ReturnType<typeof useFloating>["placement"];
+    arrowRef: React.RefObject<HTMLDivElement>;
+}
+export declare const useTooltip: () => TooltipContextType;
+export declare const TooltipProvider: ({ children, }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TooltipTrigger: React.ForwardRefExoticComponent<Omit<React.HTMLProps<HTMLElement> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLElement>>;
+export declare const Tooltip: React.ForwardRefExoticComponent<TooltipProps & React.RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+declare const variants: {
+    h1: string;
+    h2: string;
+    h3: string;
+    h4: string;
+    p: string;
+    blockquote: string;
+    highlight: string;
+    lead: string;
+    large: string;
+    small: string;
+    muted: string;
+};
+type TypographyOwnProps = {
+    variant?: keyof typeof variants;
+    className?: string;
+};
+type PolymorphicComponentProps<C extends React.ElementType, P extends object> = P & Omit<React.ComponentPropsWithoutRef<C>, keyof P>;
+type TypographyProps<C extends React.ElementType> = PolymorphicComponentProps<C, TypographyOwnProps & {
+    as?: C;
+}>;
+type PolymorphicRef<C extends React.ElementType> = React.ComponentPropsWithRef<C>["ref"];
+type TypographyComponent = (<C extends React.ElementType = "p">(props: TypographyProps<C> & {
+    ref?: PolymorphicRef<C>;
+}) => React.ReactElement | null) & {
+    displayName?: string;
+};
+export declare const Typography: TypographyComponent;
+export {};

package/dist/components/window-controls/index.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const WindowControls: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;

package/dist/context/List.context.d.ts

@@ -0,0 +1,12 @@
+export interface ListContextProps {
+    isSelectionMode: boolean;
+    setIsSelectionMode: (value: boolean) => void;
+    selectedItems: Set<string | number>;
+    toggleSelection: (id: string | number) => void;
+    isSelectable: boolean;
+    isReorderable: boolean;
+    variant: 'primary' | 'secondary';
+    shape: 'full' | 'minimal' | 'sharp';
+    size: 'sm' | 'md' | 'lg';
+}
+export declare const ListContext: import('react').Context<ListContextProps>;

package/dist/hooks/use-calender.d.ts

@@ -0,0 +1,16 @@
+import { DateRange } from 'react-day-picker';
+export declare const useCalendar: (cursorDate: Date, value?: Date | DateRange, mode?: "single" | "range") => {
+    daysInMonth: import('date-fns').EachDayOfIntervalResult<{
+        start: Date;
+        end: Date;
+    }, undefined>;
+    weekdays: string[];
+    getDayProps: (day: Date) => {
+        isCurrentMonth: boolean;
+        isToday: boolean;
+        isSelected: boolean;
+        isRangeStart: boolean;
+        isRangeEnd: boolean;
+        isInRange: boolean;
+    };
+};

package/dist/hooks/use-time-picker.d.ts

@@ -0,0 +1,15 @@
+export declare const useTimePicker: (initialDate: Date) => {
+    time: Date;
+    setTime: import('react').Dispatch<import('react').SetStateAction<Date>>;
+    displayHour: number;
+    minutes: number;
+    period: string;
+    setHour: (hour: number) => void;
+    setMinute: (minute: number) => void;
+    setPeriod: (newPeriod: "AM" | "PM") => void;
+    formattedTime: {
+        hour: string;
+        minute: string;
+        period: string;
+    };
+};

package/dist/hooks/useAppBar.d.ts

@@ -0,0 +1,36 @@
+import { MotionStyle } from 'framer-motion';
+import { AppBarSharedProps } from '../components/appbar';
+export type UseAppBarOptions = AppBarSharedProps;
+export declare const useAppBar: (options: UseAppBarOptions & {
+    appBarColor?: "background" | "card" | "primary" | "secondary";
+}) => {
+    isScrolled: boolean;
+    contentPaddingTop: number;
+    headerProps: {
+        style: MotionStyle;
+    };
+    mainRowProps: {
+        ref: import('react').RefObject<HTMLDivElement>;
+        style: {
+            height: number | import('motion-dom').MotionValue<number>;
+        };
+    };
+    largeContentProps: {
+        ref: import('react').RefObject<HTMLDivElement>;
+        style: MotionStyle;
+    };
+    childrenContainerProps: {
+        style: {
+            opacity: number | import('motion-dom').MotionValue<number>;
+        };
+    };
+    smallHeaderProps: {
+        style: {
+            opacity: import('motion-dom').MotionValue<number>;
+        };
+    };
+    finalColor: "background" | "card" | "primary" | "secondary";
+    finalShadow: "md" | "none";
+    isCollapsible: boolean;
+    shouldRenderLargeContent: boolean;
+};

package/dist/hooks/useShallowRouter.d.ts

@@ -0,0 +1,25 @@
+type HistoryMode = "search" | "pathname";
+interface UseHistoryOptions {
+    mode?: HistoryMode;
+    paramName?: string;
+    basePath?: string;
+}
+type Params = Record<string, string | number | boolean | null | undefined>;
+declare const useShallowRouter: (options?: UseHistoryOptions) => {
+    path: string;
+    searchParams: URLSearchParams;
+    otherParams: URLSearchParams;
+    push: (path: string, additionalParams?: Params, state?: any) => void;
+    replace: (path: string, additionalParams?: Params, state?: any) => void;
+    goBack: () => void;
+    goForward: () => void;
+    go: (n: number) => void;
+    updateParams: (params: Params, replaceHistory?: boolean) => void;
+    clearParams: (keepPath?: boolean) => void;
+    getParam: (key: string) => string;
+    hasParam: (key: string) => boolean;
+    length: number;
+    href: string;
+    basename: string;
+};
+export default useShallowRouter;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './components';

package/dist/storybook-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const objectValuesToControls: (obj: Record<string, string>, control?: string) => {
+    control: string;
+    options: string[];
+};