@freitas-ds/react 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1195 @@
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+import * as React from "react";
+import { VariantProps } from "class-variance-authority";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+import { DateRange, DayPickerProps } from "react-day-picker";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { AnyFieldApi, AnyFormApi, useForm } from "@tanstack/react-form";
+import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
+import * as SelectPrimitive from "@radix-ui/react-select";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import * as SwitchPrimitive from "@radix-ui/react-switch";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import * as ToastPrimitive from "@radix-ui/react-toast";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { FreitasThemeInput } from "@freitas-ds/theme";
+
+//#region src/components/action-bar.d.ts
+type ActionBarProps = React.HTMLAttributes<HTMLDivElement> & {
+  selectedCount: number;
+  label?: React.ReactNode;
+  onClearSelection?: () => void;
+};
+declare function ActionBar({
+  selectedCount,
+  label,
+  onClearSelection,
+  className,
+  children,
+  ...props
+}: ActionBarProps): React.JSX.Element | null;
+//#endregion
+//#region src/components/alert.d.ts
+type AlertTone = "neutral" | "info" | "success" | "warning" | "danger";
+type AlertProps = React.HTMLAttributes<HTMLDivElement> & {
+  tone?: AlertTone;
+  title?: string;
+  description?: string;
+  icon?: React.ReactNode | false;
+};
+declare function Alert({
+  className,
+  tone,
+  title,
+  description,
+  icon,
+  children,
+  ...props
+}: AlertProps): React.JSX.Element;
+//#endregion
+//#region src/components/alert-dialog.d.ts
+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 AlertDialogCancel: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>>;
+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 function AlertDialogHeader({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+declare function AlertDialogFooter({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+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 function AlertDialogCancelButton({
+  className,
+  ...props
+}: React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Cancel>): React.JSX.Element;
+declare function AlertDialogActionButton({
+  className,
+  variant,
+  ...props
+}: React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Action> & {
+  variant?: "primary" | "danger";
+}): React.JSX.Element;
+//#endregion
+//#region src/components/app-shell.d.ts
+type AppShellProps = React.HTMLAttributes<HTMLDivElement> & {
+  sidebar?: React.ReactNode;
+  topbar?: React.ReactNode;
+  children: React.ReactNode;
+};
+declare function AppShell({
+  sidebar,
+  topbar,
+  children,
+  className,
+  ...props
+}: AppShellProps): React.JSX.Element;
+type AppShellContentProps = React.HTMLAttributes<HTMLDivElement>;
+declare function AppShellContent({
+  className,
+  ...props
+}: AppShellContentProps): React.JSX.Element;
+//#endregion
+//#region src/components/avatar.d.ts
+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>>;
+declare function getInitials(name: string): string;
+//#endregion
+//#region src/components/badge.d.ts
+declare const badgeVariants: (props?: ({
+  tone?: "neutral" | "primary" | "secondary" | "success" | "warning" | "info" | "danger" | null | undefined;
+  variant?: "soft" | "outline" | "solid" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type BadgeProps = React.HTMLAttributes<HTMLSpanElement> & VariantProps<typeof badgeVariants>;
+declare function Badge({
+  className,
+  tone,
+  variant,
+  ...props
+}: BadgeProps): React.JSX.Element;
+//#endregion
+//#region src/components/breadcrumb.d.ts
+declare function Breadcrumb({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLElement>): React.JSX.Element;
+declare function BreadcrumbList({
+  className,
+  ...props
+}: React.OlHTMLAttributes<HTMLOListElement>): React.JSX.Element;
+declare function BreadcrumbItem({
+  className,
+  ...props
+}: React.LiHTMLAttributes<HTMLLIElement>): React.JSX.Element;
+declare function BreadcrumbLink({
+  className,
+  ...props
+}: React.AnchorHTMLAttributes<HTMLAnchorElement>): React.JSX.Element;
+declare function BreadcrumbPage({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+declare function BreadcrumbSeparator({
+  children,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLLIElement>): React.JSX.Element;
+declare function BreadcrumbEllipsis({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+//#endregion
+//#region src/components/button.d.ts
+declare const buttonVariants: (props?: ({
+  variant?: "primary" | "secondary" | "danger" | "outline" | "tertiary" | "ghost" | null | undefined;
+  size?: "sm" | "md" | "lg" | null | undefined;
+  fullWidth?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<typeof buttonVariants> & {
+  loading?: boolean;
+  asChild?: boolean;
+};
+declare const Button: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<(props?: ({
+  variant?: "primary" | "secondary" | "danger" | "outline" | "tertiary" | "ghost" | null | undefined;
+  size?: "sm" | "md" | "lg" | null | undefined;
+  fullWidth?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & {
+  loading?: boolean;
+  asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/components/calendar.d.ts
+type CalendarProps = DayPickerProps;
+declare function Calendar({
+  className,
+  classNames,
+  locale,
+  showOutsideDays,
+  navLayout,
+  components,
+  ...props
+}: CalendarProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/card.d.ts
+type CardProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Card({
+  className,
+  ...props
+}: CardProps): React.JSX.Element;
+type CardHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function CardHeader({
+  className,
+  ...props
+}: CardHeaderProps): React.JSX.Element;
+type CardContentProps = React.HTMLAttributes<HTMLDivElement>;
+declare function CardContent({
+  className,
+  ...props
+}: CardContentProps): React.JSX.Element;
+type CardFooterProps = React.HTMLAttributes<HTMLDivElement>;
+declare function CardFooter({
+  className,
+  ...props
+}: CardFooterProps): React.JSX.Element;
+//#endregion
+//#region src/components/checkbox.d.ts
+type CheckboxProps = React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> & {
+  error?: boolean;
+};
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+  error?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+type CheckboxFieldProps = CheckboxProps & {
+  label: string;
+  description?: string;
+  errorMessage?: string;
+  className?: string;
+};
+declare function CheckboxField({
+  id,
+  label,
+  description,
+  errorMessage,
+  required,
+  className,
+  ...props
+}: CheckboxFieldProps): React.JSX.Element;
+//#endregion
+//#region src/components/combobox.d.ts
+type ComboboxOption = {
+  value: string;
+  label: string;
+  description?: string;
+  disabled?: boolean;
+};
+type ComboboxGroup = {
+  label: string;
+  options: ComboboxOption[];
+};
+type ComboboxOptions = ComboboxOption[] | ComboboxGroup[];
+type ComboboxProps = {
+  id?: string;
+  name?: string;
+  value?: string;
+  defaultValue?: string;
+  onValueChange?: (value: string) => void;
+  placeholder?: string;
+  searchPlaceholder?: string;
+  emptyMessage?: string;
+  options: ComboboxOptions;
+  actions?: React.ReactNode;
+  disabled?: boolean;
+  required?: boolean;
+  className?: string;
+  contentClassName?: string;
+  "aria-describedby"?: string;
+  "aria-invalid"?: boolean | "true" | "false";
+  "aria-label"?: string;
+};
+declare const Combobox: React.ForwardRefExoticComponent<ComboboxProps & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/components/command-menu.d.ts
+type CommandMenuItem = {
+  value: string;
+  label: string;
+  description?: string;
+  icon?: React.ReactNode;
+  shortcut?: string | string[];
+  disabled?: boolean;
+  keywords?: string[];
+  onSelect?: () => void;
+};
+type CommandMenuGroup = {
+  label: string;
+  items: CommandMenuItem[];
+};
+type CommandMenuProps = {
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  title?: string;
+  description?: string;
+  placeholder?: string;
+  emptyMessage?: string;
+  groups: CommandMenuGroup[];
+  closeOnSelect?: boolean;
+};
+declare function CommandMenu({
+  open,
+  defaultOpen,
+  onOpenChange,
+  title,
+  description,
+  placeholder,
+  emptyMessage,
+  groups,
+  closeOnSelect
+}: CommandMenuProps): React.JSX.Element;
+//#endregion
+//#region src/components/data-table.d.ts
+type DataTableSortDirection = "asc" | "desc";
+type DataTableSortState = {
+  id: string;
+  direction: DataTableSortDirection;
+};
+type DataTableColumn<TData> = {
+  id: string;
+  header: React.ReactNode;
+  accessor?: keyof TData | ((row: TData) => React.ReactNode);
+  cell?: (row: TData) => React.ReactNode;
+  sortValue?: (row: TData) => string | number | Date | null | undefined;
+  sortable?: boolean;
+  className?: string;
+  headerClassName?: string;
+  align?: "left" | "center" | "right";
+};
+type DataTableProps<TData> = {
+  columns: Array<DataTableColumn<TData>>;
+  data: TData[];
+  getRowId?: (row: TData, index: number) => string;
+  selectedRowIds?: string[];
+  defaultSelectedRowIds?: string[];
+  onSelectedRowIdsChange?: (rowIds: string[]) => void;
+  sort?: DataTableSortState;
+  defaultSort?: DataTableSortState;
+  onSortChange?: (sort: DataTableSortState | undefined) => void;
+  onRowClick?: (row: TData, rowId: string) => void;
+  emptyState?: React.ReactNode;
+  loading?: boolean;
+  loadingRows?: number;
+  "aria-label"?: string;
+  className?: string;
+};
+declare function DataTable<TData>({
+  columns,
+  data,
+  getRowId,
+  selectedRowIds,
+  defaultSelectedRowIds,
+  onSelectedRowIdsChange,
+  sort,
+  defaultSort,
+  onSortChange,
+  onRowClick,
+  emptyState,
+  loading,
+  loadingRows,
+  "aria-label": ariaLabel,
+  className
+}: DataTableProps<TData>): React.JSX.Element;
+//#endregion
+//#region src/components/empty-state.d.ts
+type EmptyStateProps = React.HTMLAttributes<HTMLDivElement> & {
+  icon?: React.ReactNode;
+  title: string;
+  description?: string;
+  action?: React.ReactNode;
+};
+declare function EmptyState({
+  className,
+  icon,
+  title,
+  description,
+  action,
+  ...props
+}: EmptyStateProps): React.JSX.Element;
+//#endregion
+//#region src/components/pagination.d.ts
+type PaginationProps = {
+  page: number;
+  totalPages: number;
+  onPageChange?: (page: number) => void;
+  siblingCount?: number;
+  className?: string;
+};
+declare function Pagination({
+  page,
+  totalPages,
+  onPageChange,
+  siblingCount,
+  className
+}: PaginationProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/search-input.d.ts
+type SearchInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "defaultValue" | "onChange"> & {
+  value?: string;
+  defaultValue?: string;
+  onValueChange?: (value: string) => void;
+  onChange?: React.ChangeEventHandler<HTMLInputElement>;
+  onClear?: () => void;
+  clearable?: boolean;
+  containerClassName?: string;
+};
+declare const SearchInput: React.ForwardRefExoticComponent<Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "defaultValue" | "onChange"> & {
+  value?: string;
+  defaultValue?: string;
+  onValueChange?: (value: string) => void;
+  onChange?: React.ChangeEventHandler<HTMLInputElement>;
+  onClear?: () => void;
+  clearable?: boolean;
+  containerClassName?: string;
+} & React.RefAttributes<HTMLInputElement>>;
+//#endregion
+//#region src/components/data-view.d.ts
+type DataViewSearch = React.ReactNode | (Omit<SearchInputProps, "type"> & {
+  placeholder?: string;
+});
+type DataViewStateContent = React.ReactNode | (Pick<EmptyStateProps, "title" | "description" | "action" | "icon"> & {
+  retryLabel?: string;
+  onRetry?: () => void;
+});
+type DataViewProps = React.HTMLAttributes<HTMLDivElement> & {
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  search?: DataViewSearch;
+  filters?: React.ReactNode;
+  actions?: React.ReactNode;
+  selectedCount?: number;
+  selectedActions?: React.ReactNode;
+  selectedLabel?: React.ReactNode;
+  onClearSelection?: () => void;
+  empty?: DataViewStateContent;
+  loading?: boolean;
+  loadingLabel?: string;
+  error?: DataViewStateContent;
+  pagination?: React.ReactNode | PaginationProps;
+};
+declare function DataViewRoot({
+  title,
+  description,
+  search,
+  filters,
+  actions,
+  selectedCount,
+  selectedActions,
+  selectedLabel,
+  onClearSelection,
+  empty,
+  loading,
+  loadingLabel,
+  error,
+  pagination,
+  className,
+  children,
+  ...props
+}: DataViewProps): React.JSX.Element;
+type DataViewHeaderProps = React.HTMLAttributes<HTMLDivElement> & {
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  actions?: React.ReactNode;
+};
+declare function DataViewHeader({
+  title,
+  description,
+  actions,
+  className,
+  ...props
+}: DataViewHeaderProps): React.JSX.Element;
+type DataViewToolbarProps = React.HTMLAttributes<HTMLDivElement> & {
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  search?: DataViewSearch;
+  filters?: React.ReactNode;
+  actions?: React.ReactNode;
+};
+declare function DataViewToolbar({
+  title,
+  description,
+  search,
+  filters,
+  actions,
+  className,
+  ...props
+}: DataViewToolbarProps): React.JSX.Element;
+type DataViewContentProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DataViewContent({
+  className,
+  ...props
+}: DataViewContentProps): React.JSX.Element;
+type DataViewEmptyProps = EmptyStateProps;
+declare function DataViewEmpty(props: DataViewEmptyProps): React.JSX.Element;
+type DataViewPaginationProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DataViewPagination({
+  className,
+  ...props
+}: DataViewPaginationProps): React.JSX.Element;
+//#endregion
+//#region src/components/date-picker.d.ts
+type DatePickerProps = {
+  value?: Date;
+  defaultValue?: Date;
+  onValueChange?: (date: Date | undefined) => void;
+  placeholder?: string;
+  disabled?: boolean;
+  required?: boolean;
+  clearable?: boolean;
+  className?: string;
+  calendarClassName?: string;
+  "aria-label"?: string;
+  "aria-describedby"?: string;
+  "aria-invalid"?: boolean | "true" | "false";
+};
+declare function formatDate(date: Date): string;
+declare function DatePicker({
+  value,
+  defaultValue,
+  onValueChange,
+  placeholder,
+  disabled,
+  required,
+  clearable,
+  className,
+  calendarClassName,
+  "aria-label": ariaLabel,
+  "aria-describedby": ariaDescribedBy,
+  "aria-invalid": ariaInvalid
+}: DatePickerProps): React.JSX.Element;
+//#endregion
+//#region src/components/date-range-picker.d.ts
+type DateRangeValue = DateRange;
+type DateRangePickerProps = {
+  value?: DateRangeValue;
+  defaultValue?: DateRangeValue;
+  onValueChange?: (range: DateRangeValue | undefined) => void;
+  placeholder?: string;
+  disabled?: boolean;
+  clearable?: boolean;
+  className?: string;
+  calendarClassName?: string;
+  "aria-label"?: string;
+  "aria-describedby"?: string;
+  "aria-invalid"?: boolean | "true" | "false";
+};
+declare function DateRangePicker({
+  value,
+  defaultValue,
+  onValueChange,
+  placeholder,
+  disabled,
+  clearable,
+  className,
+  calendarClassName,
+  "aria-label": ariaLabel,
+  "aria-describedby": ariaDescribedBy,
+  "aria-invalid": ariaInvalid
+}: DateRangePickerProps): React.JSX.Element;
+//#endregion
+//#region src/components/dialog.d.ts
+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"> & {
+  showCloseButton?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare function DialogHeader({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+declare function DialogFooter({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+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>>;
+//#endregion
+//#region src/components/dropdown-menu.d.ts
+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;
+  tone?: "default" | "danger";
+} & 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 function DropdownMenuShortcut({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+//#endregion
+//#region src/components/filter-bar.d.ts
+type FilterBarProps = React.HTMLAttributes<HTMLDivElement> & {
+  label?: React.ReactNode;
+};
+declare function FilterBar({
+  label,
+  className,
+  children,
+  ...props
+}: FilterBarProps): React.JSX.Element;
+type FilterBarItemProps = React.HTMLAttributes<HTMLDivElement> & {
+  label: React.ReactNode;
+};
+declare function FilterBarItem({
+  label,
+  className,
+  children,
+  ...props
+}: FilterBarItemProps): React.JSX.Element;
+//#endregion
+//#region src/components/label.d.ts
+type LabelProps = React.LabelHTMLAttributes<HTMLLabelElement> & {
+  required?: boolean;
+  requiredIndicator?: React.ReactNode;
+  showRequiredIndicator?: boolean;
+};
+declare function Label({
+  className,
+  children,
+  required,
+  requiredIndicator,
+  showRequiredIndicator,
+  ...props
+}: LabelProps): React.JSX.Element;
+//#endregion
+//#region src/components/form.d.ts
+type ReactFormApi = AnyFormApi & {
+  Field: unknown;
+};
+type FormProps = {
+  form: ReactFormApi;
+  children: React.ReactNode;
+};
+declare function Form({
+  form,
+  children
+}: FormProps): React.JSX.Element;
+type FormFieldControllerProps = {
+  form?: ReactFormApi;
+  name: string;
+  validators?: unknown;
+  children: (field: AnyFieldApi) => React.ReactNode;
+};
+declare function FormFieldController({
+  form,
+  name,
+  validators,
+  children
+}: FormFieldControllerProps): React.JSX.Element;
+type FormItemProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FormItem({
+  className,
+  ...props
+}: FormItemProps): React.JSX.Element;
+type FormLabelProps = LabelProps;
+declare function FormLabel({
+  className,
+  ...props
+}: FormLabelProps): React.JSX.Element;
+type FormControlProps = {
+  children: React.ReactElement<{
+    id?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+  }>;
+};
+declare function FormControl({
+  children
+}: FormControlProps): React.ReactElement<{
+  id?: string;
+  "aria-describedby"?: string;
+  "aria-invalid"?: boolean | "true" | "false";
+}, string | React.JSXElementConstructor<any>>;
+type FormDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare function FormDescription({
+  className,
+  ...props
+}: FormDescriptionProps): React.JSX.Element;
+type FormMessageProps = React.HTMLAttributes<HTMLParagraphElement> & {
+  children?: React.ReactNode;
+};
+declare function FormMessage({
+  className,
+  children,
+  ...props
+}: FormMessageProps): React.JSX.Element | null;
+declare function getInputFieldProps(field: AnyFieldApi): {
+  name: any;
+  value: any;
+  onBlur: () => void;
+  onChange: (event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+};
+declare function getSelectFieldProps(field: AnyFieldApi): {
+  value: any;
+  onValueChange: (value: string) => void;
+};
+declare function getCheckboxFieldProps(field: AnyFieldApi): {
+  checked: boolean;
+  onCheckedChange: (value: boolean | "indeterminate") => void;
+};
+declare function getRadioGroupFieldProps(field: AnyFieldApi): {
+  value: any;
+  onValueChange: (value: string) => void;
+};
+declare function getSwitchFieldProps(field: AnyFieldApi): {
+  checked: boolean;
+  onCheckedChange: (value: boolean) => void;
+};
+declare function getDatePickerFieldProps(field: AnyFieldApi): {
+  value: any;
+  onValueChange: (value: Date | undefined) => void;
+};
+//#endregion
+//#region src/components/form-field.d.ts
+type FieldControlProps = {
+  id?: string;
+  required?: boolean;
+  "aria-required"?: boolean | "true" | "false";
+  "aria-describedby"?: string;
+  "aria-invalid"?: boolean | "true" | "false";
+};
+type FormFieldProps = {
+  id?: string;
+  label: string;
+  helperText?: string;
+  error?: string;
+  required?: boolean;
+  className?: string;
+  children: React.ReactElement<FieldControlProps>;
+};
+declare function FormField({
+  id,
+  label,
+  helperText,
+  error,
+  required,
+  className,
+  children
+}: FormFieldProps): React.JSX.Element;
+//#endregion
+//#region src/components/input.d.ts
+declare const inputVariants: (props?: ({
+  state?: "error" | "default" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type InputProps = React.InputHTMLAttributes<HTMLInputElement> & VariantProps<typeof inputVariants>;
+declare const Input: React.ForwardRefExoticComponent<React.InputHTMLAttributes<HTMLInputElement> & VariantProps<(props?: ({
+  state?: "error" | "default" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLInputElement>>;
+//#endregion
+//#region src/components/kbd.d.ts
+declare const kbdVariants: (props?: ({
+  size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type KbdProps = React.HTMLAttributes<HTMLElement> & VariantProps<typeof kbdVariants>;
+declare function Kbd({
+  className,
+  size,
+  ...props
+}: KbdProps): React.JSX.Element;
+//#endregion
+//#region src/components/native-select.d.ts
+type NativeSelectOption = {
+  value: string;
+  label: string;
+  disabled?: boolean;
+};
+declare const nativeSelectVariants: (props?: ({
+  state?: "error" | "default" | null | undefined;
+  fieldSize?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type NativeSelectProps = Omit<React.SelectHTMLAttributes<HTMLSelectElement>, "size"> & VariantProps<typeof nativeSelectVariants> & {
+  placeholder?: string;
+  options?: NativeSelectOption[];
+};
+declare const NativeSelect: React.ForwardRefExoticComponent<Omit<React.SelectHTMLAttributes<HTMLSelectElement>, "size"> & VariantProps<(props?: ({
+  state?: "error" | "default" | null | undefined;
+  fieldSize?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & {
+  placeholder?: string;
+  options?: NativeSelectOption[];
+} & React.RefAttributes<HTMLSelectElement>>;
+//#endregion
+//#region src/components/page-header.d.ts
+type PageHeaderProps = React.HTMLAttributes<HTMLDivElement> & {
+  eyebrow?: React.ReactNode;
+  title: React.ReactNode;
+  description?: React.ReactNode;
+  actions?: React.ReactNode;
+};
+declare function PageHeader({
+  className,
+  eyebrow,
+  title,
+  description,
+  actions,
+  ...props
+}: PageHeaderProps): React.JSX.Element;
+//#endregion
+//#region src/components/popover.d.ts
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/radio-group.d.ts
+type RadioGroupOption = {
+  value: string;
+  label: string;
+  description?: string;
+  disabled?: boolean;
+};
+type RadioGroupProps = React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> & {
+  options: RadioGroupOption[];
+  error?: boolean;
+};
+declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+  options: RadioGroupOption[];
+  error?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/select.d.ts
+type SelectOption = {
+  value: string;
+  label: string;
+  disabled?: boolean;
+};
+type SelectGroup = {
+  label: string;
+  options: SelectOption[];
+};
+type SelectOptions = SelectOption[] | SelectGroup[];
+type SelectRootProps = React.ComponentPropsWithoutRef<typeof SelectPrimitive.Root>;
+type SelectProps = Omit<SelectRootProps, "children"> & {
+  id?: string;
+  placeholder?: string;
+  options: SelectOptions;
+  className?: string;
+  contentClassName?: string;
+  "aria-describedby"?: string;
+  "aria-invalid"?: boolean | "true" | "false";
+};
+declare const Select: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSharedProps & {
+  value?: string;
+  defaultValue?: string;
+  onValueChange?(value: string): void;
+}, "children"> & {
+  id?: string;
+  placeholder?: string;
+  options: SelectOptions;
+  className?: string;
+  contentClassName?: string;
+  "aria-describedby"?: string;
+  "aria-invalid"?: boolean | "true" | "false";
+} & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/components/separator.d.ts
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/sheet.d.ts
+declare const Sheet: React.FC<DialogPrimitive.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+  side?: "top" | "bottom" | "left" | "right" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type SheetContentProps = React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & VariantProps<typeof sheetVariants> & {
+  showCloseButton?: boolean;
+};
+declare const SheetContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
+  side?: "top" | "bottom" | "left" | "right" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & {
+  showCloseButton?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare function SheetHeader({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+declare function SheetFooter({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+//#endregion
+//#region src/components/sidebar.d.ts
+type SidebarProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Sidebar({
+  className,
+  ...props
+}: SidebarProps): React.JSX.Element;
+type SidebarHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function SidebarHeader({
+  className,
+  ...props
+}: SidebarHeaderProps): React.JSX.Element;
+type SidebarBrandProps = React.HTMLAttributes<HTMLDivElement> & {
+  title: string;
+  description?: string;
+  icon?: React.ReactNode;
+};
+declare function SidebarBrand({
+  title,
+  description,
+  icon,
+  className,
+  ...props
+}: SidebarBrandProps): React.JSX.Element;
+type SidebarContentProps = React.HTMLAttributes<HTMLDivElement>;
+declare function SidebarContent({
+  className,
+  ...props
+}: SidebarContentProps): React.JSX.Element;
+type SidebarSectionProps = React.HTMLAttributes<HTMLDivElement> & {
+  title?: string;
+};
+declare function SidebarSection({
+  title,
+  className,
+  children,
+  ...props
+}: SidebarSectionProps): React.JSX.Element;
+type SidebarNavItemProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+  icon?: React.ReactNode;
+  active?: boolean;
+  asChild?: boolean;
+};
+declare const SidebarNavItem: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+  icon?: React.ReactNode;
+  active?: boolean;
+  asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+type SidebarFooterProps = React.HTMLAttributes<HTMLDivElement>;
+declare function SidebarFooter({
+  className,
+  ...props
+}: SidebarFooterProps): React.JSX.Element;
+//#endregion
+//#region src/components/skeleton.d.ts
+type SkeletonProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Skeleton({
+  className,
+  ...props
+}: SkeletonProps): React.JSX.Element;
+//#endregion
+//#region src/components/spinner.d.ts
+declare const spinnerVariants: (props?: ({
+  size?: "sm" | "md" | "lg" | null | undefined;
+  tone?: "primary" | "success" | "warning" | "info" | "danger" | "current" | "muted" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type SpinnerProps = React.HTMLAttributes<SVGSVGElement> & VariantProps<typeof spinnerVariants>;
+declare function Spinner({
+  className,
+  size,
+  tone,
+  ...props
+}: SpinnerProps): React.JSX.Element;
+//#endregion
+//#region src/components/status-badge.d.ts
+type StatusBadgeStatus = "active" | "inactive" | "pending" | "completed" | "canceled" | "draft" | "blocked" | "archived";
+type StatusBadgeProps = Omit<BadgeProps, "tone"> & {
+  status: StatusBadgeStatus;
+  label?: string;
+  tone?: BadgeProps["tone"];
+};
+declare function StatusBadge({
+  status,
+  label,
+  tone,
+  variant,
+  ...props
+}: StatusBadgeProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/switch.d.ts
+type SwitchProps = React.ComponentPropsWithoutRef<typeof SwitchPrimitive.Root> & {
+  error?: boolean;
+};
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+  error?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+type SwitchFieldProps = SwitchProps & {
+  label: string;
+  description?: string;
+  errorMessage?: string;
+  className?: string;
+};
+declare function SwitchField({
+  id,
+  label,
+  description,
+  errorMessage,
+  required,
+  className,
+  ...props
+}: SwitchFieldProps): React.JSX.Element;
+//#endregion
+//#region src/components/table.d.ts
+type TableContainerProps = React.HTMLAttributes<HTMLDivElement>;
+declare function TableContainer({
+  className,
+  ...props
+}: TableContainerProps): React.JSX.Element;
+type TableScrollAreaProps = React.HTMLAttributes<HTMLDivElement>;
+declare function TableScrollArea({
+  className,
+  ...props
+}: TableScrollAreaProps): React.JSX.Element;
+type TableProps = React.TableHTMLAttributes<HTMLTableElement>;
+declare const Table: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLTableElement>>;
+type TableHeaderProps = React.HTMLAttributes<HTMLTableSectionElement>;
+declare const TableHeader: React.ForwardRefExoticComponent<TableHeaderProps & React.RefAttributes<HTMLTableSectionElement>>;
+type TableBodyProps = React.HTMLAttributes<HTMLTableSectionElement>;
+declare const TableBody: React.ForwardRefExoticComponent<TableBodyProps & React.RefAttributes<HTMLTableSectionElement>>;
+type TableFooterProps = React.HTMLAttributes<HTMLTableSectionElement>;
+declare const TableFooter: React.ForwardRefExoticComponent<TableFooterProps & React.RefAttributes<HTMLTableSectionElement>>;
+type TableRowProps = React.HTMLAttributes<HTMLTableRowElement>;
+declare const TableRow: React.ForwardRefExoticComponent<TableRowProps & React.RefAttributes<HTMLTableRowElement>>;
+type TableHeadProps = React.ThHTMLAttributes<HTMLTableCellElement>;
+declare const TableHead: React.ForwardRefExoticComponent<TableHeadProps & React.RefAttributes<HTMLTableCellElement>>;
+type TableCellProps = React.TdHTMLAttributes<HTMLTableCellElement>;
+declare const TableCell: React.ForwardRefExoticComponent<TableCellProps & React.RefAttributes<HTMLTableCellElement>>;
+type TableCaptionProps = React.HTMLAttributes<HTMLTableCaptionElement>;
+declare const TableCaption: React.ForwardRefExoticComponent<TableCaptionProps & React.RefAttributes<HTMLTableCaptionElement>>;
+//#endregion
+//#region src/components/tabs.d.ts
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/textarea.d.ts
+declare const textareaVariants: (props?: ({
+  state?: "error" | "default" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement> & VariantProps<typeof textareaVariants>;
+declare const Textarea: React.ForwardRefExoticComponent<React.TextareaHTMLAttributes<HTMLTextAreaElement> & VariantProps<(props?: ({
+  state?: "error" | "default" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLTextAreaElement>>;
+//#endregion
+//#region src/components/toast.d.ts
+type ToastTone = "default" | "success" | "warning" | "info" | "danger" | "error";
+declare const ToastProvider: React.FC<ToastPrimitive.ToastProviderProps>;
+declare const ToastAction: React.ForwardRefExoticComponent<ToastPrimitive.ToastActionProps & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+type ToastProps = React.ComponentPropsWithoutRef<typeof ToastPrimitive.Root> & {
+  tone?: ToastTone;
+};
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & {
+  tone?: ToastTone;
+} & React.RefAttributes<HTMLLIElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/components/toaster.d.ts
+type ToasterProps = {
+  children?: React.ReactNode;
+  duration?: number;
+  swipeDirection?: React.ComponentProps<typeof ToastProvider>["swipeDirection"];
+};
+declare function Toaster({
+  children,
+  duration,
+  swipeDirection
+}: ToasterProps): React.JSX.Element;
+//#endregion
+//#region src/components/toolbar.d.ts
+type ToolbarProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Toolbar({
+  className,
+  ...props
+}: ToolbarProps): React.JSX.Element;
+type ToolbarSectionProps = React.HTMLAttributes<HTMLDivElement>;
+declare function ToolbarSection({
+  className,
+  ...props
+}: ToolbarSectionProps): React.JSX.Element;
+type ToolbarActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function ToolbarActions({
+  className,
+  ...props
+}: ToolbarActionsProps): React.JSX.Element;
+type ToolbarTitleProps = React.HTMLAttributes<HTMLDivElement> & {
+  title: React.ReactNode;
+  description?: React.ReactNode;
+};
+declare function ToolbarTitle({
+  title,
+  description,
+  className,
+  ...props
+}: ToolbarTitleProps): React.JSX.Element;
+//#endregion
+//#region src/components/tooltip.d.ts
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const TooltipRoot: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type TooltipProps = {
+  children: React.ReactNode;
+  content: React.ReactNode;
+  side?: "top" | "right" | "bottom" | "left";
+  align?: "start" | "center" | "end";
+  delayDuration?: number;
+  className?: string;
+};
+declare function Tooltip({
+  children,
+  content,
+  side,
+  align,
+  delayDuration,
+  className
+}: TooltipProps): React.JSX.Element;
+//#endregion
+//#region src/components/topbar.d.ts
+type TopbarProps = React.HTMLAttributes<HTMLDivElement> & {
+  start?: React.ReactNode;
+  center?: React.ReactNode;
+  end?: React.ReactNode;
+};
+declare function Topbar({
+  start,
+  center,
+  end,
+  className,
+  children,
+  ...props
+}: TopbarProps): React.JSX.Element;
+//#endregion
+//#region src/components/user-menu.d.ts
+type UserMenuItem = {
+  label: string;
+  icon?: React.ReactNode;
+  shortcut?: React.ReactNode;
+  disabled?: boolean;
+  tone?: "default" | "danger";
+  onSelect?: () => void;
+};
+type UserMenuProps = {
+  name: string;
+  email?: string;
+  avatarUrl?: string;
+  initials?: string;
+  items?: UserMenuItem[];
+  footerItems?: UserMenuItem[];
+};
+declare function UserMenu({
+  name,
+  email,
+  avatarUrl,
+  initials,
+  items,
+  footerItems
+}: UserMenuProps): React.JSX.Element;
+//#endregion
+//#region src/hooks/use-toast.d.ts
+type ToastInput = {
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  action?: React.ReactNode;
+  tone?: ToastTone;
+  duration?: number;
+};
+type ToastRecord = ToastInput & {
+  id: string;
+  open: boolean;
+};
+type ToastHandle = {
+  id: string;
+  dismiss: () => void;
+};
+type ToastContextValue = {
+  toasts: ToastRecord[];
+  toast: (toast: ToastInput) => ToastHandle;
+  dismiss: (id: string) => void;
+};
+declare const ToastContext: React.Context<ToastContextValue | null>;
+declare function useToast(): ToastContextValue;
+//#endregion
+//#region src/provider/freitas-provider.d.ts
+type FreitasProviderProps = {
+  theme?: FreitasThemeInput;
+  children: React.ReactNode;
+};
+declare function FreitasProvider({
+  theme,
+  children
+}: FreitasProviderProps): React.JSX.Element;
+//#endregion
+export { ActionBar, ActionBarProps, Alert, AlertDialog, AlertDialogAction, AlertDialogActionButton, AlertDialogCancel, AlertDialogCancelButton, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertProps, AlertTone, AppShell, AppShellContent, AppShellContentProps, AppShellProps, Avatar, AvatarFallback, AvatarImage, Badge, BadgeProps, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonProps, Calendar, CalendarProps, Card, CardContent, CardContentProps, CardFooter, CardFooterProps, CardHeader, CardHeaderProps, CardProps, Checkbox, CheckboxField, CheckboxFieldProps, CheckboxProps, Combobox, ComboboxGroup, ComboboxOption, ComboboxProps, CommandMenu, CommandMenuGroup, CommandMenuItem, CommandMenuProps, DataTable, DataTableColumn, DataTableProps, DataTableSortDirection, DataTableSortState, DataViewRoot as DataView, DataViewRoot, DataViewContent, DataViewContentProps, DataViewEmpty, DataViewEmptyProps, DataViewHeader, DataViewHeaderProps, DataViewPagination, DataViewPaginationProps, DataViewProps, DataViewSearch, DataViewStateContent, DataViewToolbar, DataViewToolbarProps, DatePicker, DatePickerProps, DateRangePicker, DateRangePickerProps, DateRangeValue, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, EmptyStateProps, FilterBar, FilterBarItem, FilterBarItemProps, FilterBarProps, Form, FormControl, FormControlProps, FormDescription, FormDescriptionProps, FormField, FormFieldController, FormFieldControllerProps, FormFieldProps, FormItem, FormItemProps, FormLabel, FormLabelProps, FormMessage, FormMessageProps, FormProps, FreitasProvider, FreitasProviderProps, Input, InputProps, Kbd, KbdProps, Label, LabelProps, NativeSelect, NativeSelectOption, NativeSelectProps, PageHeader, PageHeaderProps, Pagination, PaginationProps, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, RadioGroup, RadioGroupOption, RadioGroupProps, SearchInput, SearchInputProps, Select, SelectGroup, SelectOption, SelectProps, Separator, Sheet, SheetClose, SheetContent, SheetContentProps, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Sidebar, SidebarBrand, SidebarBrandProps, SidebarContent, SidebarContentProps, SidebarFooter, SidebarFooterProps, SidebarHeader, SidebarHeaderProps, SidebarNavItem, SidebarNavItemProps, SidebarProps, SidebarSection, SidebarSectionProps, Skeleton, SkeletonProps, Spinner, SpinnerProps, StatusBadge, StatusBadgeProps, StatusBadgeStatus, Switch, SwitchField, SwitchFieldProps, SwitchProps, Table, TableBody, TableBodyProps, TableCaption, TableCaptionProps, TableCell, TableCellProps, TableContainer, TableContainerProps, TableFooter, TableFooterProps, TableHead, TableHeadProps, TableHeader, TableHeaderProps, TableProps, TableRow, TableRowProps, TableScrollArea, TableScrollAreaProps, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, TextareaProps, Toast, ToastAction, ToastClose, ToastContext, ToastDescription, ToastHandle, ToastInput, ToastProps, ToastProvider, ToastRecord, ToastTitle, ToastTone, ToastViewport, Toaster, ToasterProps, Toolbar, ToolbarActions, ToolbarActionsProps, ToolbarProps, ToolbarSection, ToolbarSectionProps, ToolbarTitle, ToolbarTitleProps, Tooltip, TooltipProps, TooltipProvider, TooltipRoot, TooltipTrigger, Topbar, TopbarProps, UserMenu, UserMenuItem, UserMenuProps, buttonVariants, formatDate, getCheckboxFieldProps, getDatePickerFieldProps, getInitials, getInputFieldProps, getRadioGroupFieldProps, getSelectFieldProps, getSwitchFieldProps, useForm, useToast };
+//# sourceMappingURL=index.d.mts.map