@leanspec/ui 0.2.23 → 0.2.25

package/dist/lib/components/library/search/filter-select.d.ts

@@ -0,0 +1,27 @@
+/**
+ * FilterSelect component
+ * Simple dropdown for filtering
+ */
+import * as React from 'react';
+export interface FilterOption {
+    value: string;
+    label: string;
+    icon?: React.ReactNode;
+}
+export interface FilterSelectProps {
+    /** Current selected value */
+    value?: string;
+    /** Available options */
+    options: FilterOption[];
+    /** Callback when selection changes */
+    onChange?: (value: string) => void;
+    /** Placeholder when no value selected */
+    placeholder?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Allow clearing selection */
+    clearable?: boolean;
+    /** Label for clear option */
+    clearLabel?: string;
+}
+export declare function FilterSelect({ value, options, onChange, placeholder, className, clearable, clearLabel, }: FilterSelectProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/search/index.d.ts

@@ -0,0 +1,3 @@
+export { SearchInput, type SearchInputProps } from './search-input';
+export { FilterSelect, type FilterSelectProps, type FilterOption } from './filter-select';
+export { SearchResults, type SearchResultsProps } from './search-results';

package/dist/lib/components/library/search/search-input.d.ts

@@ -0,0 +1,22 @@
+/**
+ * SearchInput component
+ * Input field with search icon and keyboard shortcut hint
+ */
+import * as React from 'react';
+export interface SearchInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+    /** Current search value */
+    value?: string;
+    /** Callback when value changes */
+    onChange?: (value: string) => void;
+    /** Callback when search is submitted (Enter key) */
+    onSearch?: (value: string) => void;
+    /** Show keyboard shortcut hint */
+    showShortcut?: boolean;
+    /** Keyboard shortcut key (displayed in hint) */
+    shortcutKey?: string;
+    /** Show clear button when there's a value */
+    clearable?: boolean;
+    /** Additional CSS classes for the container */
+    containerClassName?: string;
+}
+export declare function SearchInput({ value, onChange, onSearch, showShortcut, shortcutKey, clearable, className, containerClassName, placeholder, ...props }: SearchInputProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/search/search-results.d.ts

@@ -0,0 +1,8 @@
+import { LightweightSpec } from '../../../types/specs';
+export interface SearchResultsProps {
+    results: LightweightSpec[];
+    query: string;
+    isSearching?: boolean;
+    onSpecClick?: (specId: string) => void;
+}
+export declare function SearchResults({ results, query, isSearching, onSpecClick, }: SearchResultsProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/spec/index.d.ts

@@ -0,0 +1,9 @@
+export { StatusBadge, defaultStatusConfig, type StatusBadgeProps, } from './status-badge';
+export { PriorityBadge, defaultPriorityConfig, type PriorityBadgeProps, } from './priority-badge';
+export { SpecCard, type SpecCardProps } from './spec-card';
+export { TagBadge, TagList, type TagBadgeProps, type TagListProps } from './tag-badge';
+export { SpecMetadata, type SpecMetadataProps, type SpecMetadataData } from './spec-metadata';
+export { SpecTimeline, type SpecTimelineProps } from './spec-timeline';
+export { StatusEditor, defaultStatusConfig as defaultStatusEditorConfig, type StatusEditorProps, } from './status-editor';
+export { PriorityEditor, defaultPriorityConfig as defaultPriorityEditorConfig, type PriorityEditorProps, } from './priority-editor';
+export { TagsEditor, type TagsEditorProps } from './tags-editor';

package/dist/lib/components/library/spec/priority-badge.d.ts

@@ -0,0 +1,18 @@
+import { priorityConfig as defaultPriorityConfig } from '../../../lib/badge-config';
+import { SpecPriority } from '../../../types/specs';
+export { defaultPriorityConfig };
+export interface PriorityBadgeProps {
+    /** The priority to display */
+    priority: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Show only icon, no label */
+    iconOnly?: boolean;
+    /** Custom label override */
+    label?: string;
+    /** Enable editable mode with dropdown */
+    editable?: boolean;
+    /** Callback when priority changes (editable mode only) */
+    onChange?: (priority: SpecPriority) => void;
+}
+export declare function PriorityBadge({ priority, className, iconOnly, label, editable, onChange, }: PriorityBadgeProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/spec/priority-editor.d.ts

@@ -0,0 +1,11 @@
+import { priorityConfig as defaultPriorityConfig } from '../../../lib/badge-config';
+import { SpecPriority } from '../../../types/specs';
+export { defaultPriorityConfig };
+export interface PriorityEditorProps {
+    currentPriority: SpecPriority;
+    onPriorityChange: (newPriority: SpecPriority) => Promise<void> | void;
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+}
+export declare function PriorityEditor({ currentPriority, onPriorityChange, disabled, className, ariaLabel, }: PriorityEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/spec/spec-card.d.ts

@@ -0,0 +1,16 @@
+import { LightweightSpec } from '../../../types/specs';
+export interface SpecCardProps {
+    /** Spec data to display */
+    spec: Pick<LightweightSpec, 'specNumber' | 'specName' | 'title' | 'status' | 'priority' | 'tags' | 'updatedAt' | 'parent' | 'children' | 'subSpecsCount'>;
+    /** Click handler */
+    onClick?: () => void;
+    /** Whether the card is currently selected */
+    selected?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Locale for date formatting */
+    locale?: string;
+    /** Maximum number of tags to display */
+    maxTags?: number;
+}
+export declare function SpecCard({ spec, onClick, selected, className, locale, maxTags, }: SpecCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/spec/spec-metadata.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SpecMetadata component
+ * Displays spec metadata in a card format with icons
+ */
+export interface SpecMetadataData {
+    status?: string | null;
+    priority?: string | null;
+    createdAt?: string | Date | null;
+    updatedAt?: string | Date | null;
+    completedAt?: string | Date | null;
+    assignee?: string | null;
+    tags?: string[] | null;
+    githubUrl?: string | null;
+}
+export interface SpecMetadataProps {
+    /** Spec data to display */
+    spec: SpecMetadataData;
+    /** Additional CSS classes */
+    className?: string;
+    /** Locale for date formatting */
+    locale?: string;
+    /** Labels for the metadata fields */
+    labels?: {
+        status?: string;
+        priority?: string;
+        created?: string;
+        updated?: string;
+        completed?: string;
+        assignee?: string;
+        tags?: string;
+        source?: string;
+        viewOnGitHub?: string;
+    };
+}
+export declare function SpecMetadata({ spec, className, locale, labels }: SpecMetadataProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/spec/spec-timeline.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Timeline component to visualize spec evolution (vertical layout)
+ */
+export interface SpecTimelineProps {
+    createdAt: Date | string | number | null | undefined;
+    updatedAt: Date | string | number | null | undefined;
+    completedAt?: Date | string | number | null | undefined;
+    status: string;
+    className?: string;
+    labels?: {
+        created?: string;
+        inProgress?: string;
+        complete?: string;
+        archived?: string;
+        awaiting?: string;
+        queued?: string;
+        pending?: string;
+    };
+    language?: string;
+}
+export declare function SpecTimeline({ createdAt, updatedAt, completedAt, status, className, labels, language, }: SpecTimelineProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/lib/components/library/spec/status-badge.d.ts

@@ -0,0 +1,18 @@
+import { statusConfig as defaultStatusConfig } from '../../../lib/badge-config';
+import { SpecStatus } from '../../../types/specs';
+export { defaultStatusConfig };
+export interface StatusBadgeProps {
+    /** The status to display */
+    status: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Show only icon, no label */
+    iconOnly?: boolean;
+    /** Custom label override */
+    label?: string;
+    /** Enable editable mode with dropdown */
+    editable?: boolean;
+    /** Callback when status changes (editable mode only) */
+    onChange?: (status: SpecStatus) => void;
+}
+export declare function StatusBadge({ status, className, iconOnly, label, editable, onChange, }: StatusBadgeProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/spec/status-editor.d.ts

@@ -0,0 +1,11 @@
+import { statusConfig as defaultStatusConfig } from '../../../lib/badge-config';
+import { SpecStatus } from '../../../types/specs';
+export { defaultStatusConfig };
+export interface StatusEditorProps {
+    currentStatus: SpecStatus;
+    onStatusChange: (newStatus: SpecStatus) => Promise<void> | void;
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+}
+export declare function StatusEditor({ currentStatus, onStatusChange, disabled, className, ariaLabel, }: StatusEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/spec/tag-badge.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Tag badge component for displaying spec tags
+ */
+export interface TagBadgeProps {
+    /** Tag name to display */
+    tag: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Show icon */
+    showIcon?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+    /** Whether the tag is removable */
+    removable?: boolean;
+    /** Remove handler */
+    onRemove?: () => void;
+}
+export declare function TagBadge({ tag, className, showIcon, onClick, removable, onRemove, }: TagBadgeProps): import("react/jsx-runtime").JSX.Element;
+export interface TagListProps {
+    /** Tags to display */
+    tags: string[];
+    /** Maximum tags to show before truncating */
+    maxVisible?: number;
+    /** Additional CSS classes */
+    className?: string;
+    /** Click handler for individual tags */
+    onTagClick?: (tag: string) => void;
+}
+export declare function TagList({ tags, maxVisible, className, onTagClick }: TagListProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/lib/components/library/spec/tags-editor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Tags editor component with add/remove functionality and autocomplete
+ * Framework-agnostic version that accepts callbacks
+ */
+export interface TagsEditorProps {
+    currentTags: string[];
+    availableTags?: string[];
+    onTagsChange: (newTags: string[]) => Promise<void> | void;
+    onFetchAvailableTags?: () => Promise<string[]> | string[];
+    disabled?: boolean;
+    className?: string;
+    labels?: {
+        addTag?: string;
+        removeTag?: string;
+        searchTag?: string;
+        createTag?: string;
+        noResults?: string;
+        existingTags?: string;
+        createSection?: string;
+        tagExists?: string;
+    };
+}
+export declare function TagsEditor({ currentTags, availableTags: initialAvailableTags, onTagsChange, onFetchAvailableTags, disabled, className, labels: customLabels, }: TagsEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/stats/index.d.ts

@@ -0,0 +1,3 @@
+export { StatsCard, type StatsCardProps } from './stats-card';
+export { StatsOverview, type StatsOverviewProps, type StatsData } from './stats-overview';
+export { ProgressBar, type ProgressBarProps } from './progress-bar';

package/dist/lib/components/library/stats/progress-bar.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ProgressBar component
+ * Displays a horizontal progress bar with optional label
+ */
+export interface ProgressBarProps {
+    /** Progress value (0-100) */
+    value: number;
+    /** Label to display */
+    label?: string;
+    /** Show percentage */
+    showPercentage?: boolean;
+    /** Color variant */
+    variant?: 'default' | 'success' | 'warning' | 'danger' | 'info';
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function ProgressBar({ value, label, showPercentage, variant, size, className, }: ProgressBarProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/stats/stats-card.d.ts

@@ -0,0 +1,22 @@
+import { LucideIcon } from 'lucide-react';
+export interface StatsCardProps {
+    /** Title of the stat */
+    title: string;
+    /** Main value to display */
+    value: number | string;
+    /** Optional subtitle or description */
+    subtitle?: string;
+    /** Icon to display */
+    icon?: LucideIcon;
+    /** Icon color class */
+    iconColorClass?: string;
+    /** Background gradient color class */
+    gradientClass?: string;
+    /** Trend direction */
+    trend?: 'up' | 'down' | 'neutral';
+    /** Trend percentage or label */
+    trendValue?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function StatsCard({ title, value, subtitle, icon: Icon, iconColorClass, gradientClass, trend, trendValue, className, }: StatsCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/stats/stats-overview.d.ts

@@ -0,0 +1,35 @@
+/**
+ * StatsOverview component
+ * Displays an overview of project stats with multiple stat cards
+ */
+export interface StatsData {
+    totalSpecs: number;
+    completedSpecs: number;
+    inProgressSpecs: number;
+    plannedSpecs: number;
+    archivedSpecs?: number;
+    completionRate: number;
+}
+export interface StatsOverviewProps {
+    /** Stats data to display */
+    stats: StatsData;
+    /** Show archived specs card */
+    showArchived?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Labels for localization */
+    labels?: {
+        total?: string;
+        totalSubtitle?: string;
+        completed?: string;
+        completedSubtitle?: string;
+        inProgress?: string;
+        inProgressSubtitle?: string;
+        planned?: string;
+        plannedSubtitle?: string;
+        archived?: string;
+        archivedSubtitle?: string;
+        completionRate?: string;
+    };
+}
+export declare function StatsOverview({ stats, showArchived, className, labels, }: StatsOverviewProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/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/lib/components/library/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" | 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/lib/components/library/ui/avatar.d.ts

@@ -0,0 +1,15 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const avatarVariants: (props?: ({
+    size?: "default" | "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type AvatarProps = React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root> & VariantProps<typeof avatarVariants>;
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & VariantProps<(props?: ({
+    size?: "default" | "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & 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 type AvatarImageProps = React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Image>;
+export type AvatarFallbackProps = React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback>;
+export { Avatar, AvatarImage, AvatarFallback, avatarVariants };

package/dist/lib/components/library/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" | "secondary" | "outline" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

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

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

package/dist/lib/components/library/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" | "secondary" | "outline" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => 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/lib/components/library/ui/card.d.ts

@@ -0,0 +1,9 @@
+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<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardAction: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent, CardAction };

package/dist/lib/components/library/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/lib/components/library/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 };

package/dist/lib/components/library/ui/command.d.ts

@@ -0,0 +1,80 @@
+import { DialogProps } from '@radix-ui/react-dialog';
+import * as React from "react";
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandDialog: ({ children, ...props }: DialogProps) => import("react/jsx-runtime").JSX.Element;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "value" | "type"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "heading" | "value"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "onSelect" | "disabled" | "value"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/lib/components/library/ui/dialog.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogTrigger, DialogClose, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/dist/lib/components/library/ui/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/lib/components/library/ui/hover-card.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as HoverCardPrimitive from "@radix-ui/react-hover-card";
+declare const HoverCard: React.FC<HoverCardPrimitive.HoverCardProps>;
+declare const HoverCardTrigger: React.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const HoverCardContent: React.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { HoverCard, HoverCardTrigger, HoverCardContent };