/// <reference types="react" />

declare module "App" {
  import "./App.css";
  function App(): import("react/jsx-runtime").JSX.Element;
  export default App;
}
declare module "@/lib/utils" {
  import { type ClassValue } from "clsx";
  export function cn(...inputs: ClassValue[]): string;
}
declare module "@/components/ui/accordion" {
  import * as React from "react";
  import * as AccordionPrimitive from "@radix-ui/react-accordion";
  const Accordion: React.ForwardRefExoticComponent<
    (
      | AccordionPrimitive.AccordionSingleProps
      | AccordionPrimitive.AccordionMultipleProps
    ) &
      React.RefAttributes<HTMLDivElement>
  >;
  const AccordionItem: React.ForwardRefExoticComponent<
    Omit<
      AccordionPrimitive.AccordionItemProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const AccordionTrigger: React.ForwardRefExoticComponent<
    Omit<
      AccordionPrimitive.AccordionTriggerProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const AccordionContent: React.ForwardRefExoticComponent<
    Omit<
      AccordionPrimitive.AccordionContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };
}
declare module "@/components/ui/button" {
  import * as React from "react";
  import { type VariantProps } from "class-variance-authority";
  const buttonVariants: (
    props?:
      | ({
          variant?:
            | "link"
            | "default"
            | "destructive"
            | "outline"
            | "secondary"
            | "ghost"
            | null
            | undefined;
          size?: "default" | "sm" | "lg" | "icon" | null | undefined;
        } & import("class-variance-authority/types").ClassProp)
      | undefined
  ) => string;
  export interface ButtonProps
    extends React.ButtonHTMLAttributes<HTMLButtonElement>,
      VariantProps<typeof buttonVariants> {
    variant?:
      | "link"
      | "default"
      | "destructive"
      | "outline"
      | "secondary"
      | "ghost"
      | null
      | undefined;
    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
    asChild?: boolean;
  }
  const Button: React.ForwardRefExoticComponent<
    ButtonProps & React.RefAttributes<HTMLButtonElement>
  >;
  export { Button, buttonVariants };
}
declare module "@/components/ui/alert-dialog" {
  import * as React from "react";
  import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
  const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
  const AlertDialogTrigger: React.ForwardRefExoticComponent<
    AlertDialogPrimitive.AlertDialogTriggerProps &
      React.RefAttributes<HTMLButtonElement>
  >;
  const AlertDialogContent: React.ForwardRefExoticComponent<
    Omit<
      AlertDialogPrimitive.AlertDialogContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const AlertDialogHeader: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const AlertDialogFooter: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const AlertDialogTitle: React.ForwardRefExoticComponent<
    Omit<
      AlertDialogPrimitive.AlertDialogTitleProps &
        React.RefAttributes<HTMLHeadingElement>,
      "ref"
    > &
      React.RefAttributes<HTMLHeadingElement>
  >;
  const AlertDialogDescription: React.ForwardRefExoticComponent<
    Omit<
      AlertDialogPrimitive.AlertDialogDescriptionProps &
        React.RefAttributes<HTMLParagraphElement>,
      "ref"
    > &
      React.RefAttributes<HTMLParagraphElement>
  >;
  const AlertDialogAction: React.ForwardRefExoticComponent<
    Omit<
      AlertDialogPrimitive.AlertDialogActionProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const AlertDialogCancel: React.ForwardRefExoticComponent<
    Omit<
      AlertDialogPrimitive.AlertDialogCancelProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  export {
    AlertDialog,
    AlertDialogTrigger,
    AlertDialogContent,
    AlertDialogHeader,
    AlertDialogFooter,
    AlertDialogTitle,
    AlertDialogDescription,
    AlertDialogAction,
    AlertDialogCancel,
  };
}
declare module "@/components/ui/alert" {
  import * as React from "react";
  import { type VariantProps } from "class-variance-authority";
  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>
  >;
  const AlertTitle: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLHeadingElement> &
      React.RefAttributes<HTMLParagraphElement>
  >;
  const AlertDescription: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLParagraphElement> &
      React.RefAttributes<HTMLParagraphElement>
  >;
  export { Alert, AlertTitle, AlertDescription };
}
declare module "@/components/ui/aspect-ratio" {
  import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio";
  const AspectRatio: import("react").ForwardRefExoticComponent<
    AspectRatioPrimitive.AspectRatioProps &
      import("react").RefAttributes<HTMLDivElement>
  >;
  export { AspectRatio };
}
declare module "@/components/ui/avatar" {
  import * as React from "react";
  import * as AvatarPrimitive from "@radix-ui/react-avatar";
  const Avatar: React.ForwardRefExoticComponent<
    Omit<
      AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>,
      "ref"
    > &
      React.RefAttributes<HTMLSpanElement>
  >;
  const AvatarImage: React.ForwardRefExoticComponent<
    Omit<
      AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>,
      "ref"
    > &
      React.RefAttributes<HTMLImageElement>
  >;
  const AvatarFallback: React.ForwardRefExoticComponent<
    Omit<
      AvatarPrimitive.AvatarFallbackProps &
        React.RefAttributes<HTMLSpanElement>,
      "ref"
    > &
      React.RefAttributes<HTMLSpanElement>
  >;
  export { Avatar, AvatarImage, AvatarFallback };
}
declare module "@/components/ui/badge" {
  import * as React from "react";
  import { type VariantProps } from "class-variance-authority";
  const badgeVariants: (
    props?:
      | ({
          variant?:
            | "default"
            | "destructive"
            | "outline"
            | "secondary"
            | null
            | undefined;
        } & import("class-variance-authority/types").ClassProp)
      | undefined
  ) => string;
  export interface BadgeProps
    extends React.HTMLAttributes<HTMLDivElement>,
      VariantProps<typeof badgeVariants> {}
  function Badge({
    className,
    variant,
    ...props
  }: BadgeProps): import("react/jsx-runtime").JSX.Element;
  export { Badge, badgeVariants };
}
declare module "@/components/ui/calendar" {
  import * as React from "react";
  import { DayPicker } from "react-day-picker";
  export type CalendarProps = React.ComponentProps<typeof DayPicker>;
  function Calendar({
    className,
    classNames,
    showOutsideDays,
    ...props
  }: CalendarProps): import("react/jsx-runtime").JSX.Element;
  namespace Calendar {
    var displayName: string;
  }
  export { Calendar };
}
declare module "@/components/ui/card" {
  import * as React from "react";
  const Card: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>
  >;
  const CardHeader: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>
  >;
  const CardTitle: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>
  >;
  const CardDescription: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>
  >;
  const CardContent: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>
  >;
  const CardFooter: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>
  >;
  export {
    Card,
    CardHeader,
    CardFooter,
    CardTitle,
    CardDescription,
    CardContent,
  };
}
declare module "@/components/ui/checkbox" {
  import * as React from "react";
  import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
  const Checkbox: React.ForwardRefExoticComponent<
    Omit<
      CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  export { Checkbox };
}
declare module "@/components/ui/collapsible" {
  import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
  const Collapsible: import("react").ForwardRefExoticComponent<
    CollapsiblePrimitive.CollapsibleProps &
      import("react").RefAttributes<HTMLDivElement>
  >;
  const CollapsibleTrigger: import("react").ForwardRefExoticComponent<
    CollapsiblePrimitive.CollapsibleTriggerProps &
      import("react").RefAttributes<HTMLButtonElement>
  >;
  const CollapsibleContent: import("react").ForwardRefExoticComponent<
    CollapsiblePrimitive.CollapsibleContentProps &
      import("react").RefAttributes<HTMLDivElement>
  >;
  export { Collapsible, CollapsibleTrigger, CollapsibleContent };
}
declare module "@/components/ui/dialog" {
  import * as React from "react";
  import * as DialogPrimitive from "@radix-ui/react-dialog";
  const Dialog: React.FC<DialogPrimitive.DialogProps>;
  const DialogTrigger: React.ForwardRefExoticComponent<
    DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>
  >;
  const DialogContent: React.ForwardRefExoticComponent<
    Omit<
      DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const DialogHeader: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const DialogFooter: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const DialogTitle: React.ForwardRefExoticComponent<
    Omit<
      DialogPrimitive.DialogTitleProps &
        React.RefAttributes<HTMLHeadingElement>,
      "ref"
    > &
      React.RefAttributes<HTMLHeadingElement>
  >;
  const DialogDescription: React.ForwardRefExoticComponent<
    Omit<
      DialogPrimitive.DialogDescriptionProps &
        React.RefAttributes<HTMLParagraphElement>,
      "ref"
    > &
      React.RefAttributes<HTMLParagraphElement>
  >;
  export {
    Dialog,
    DialogTrigger,
    DialogContent,
    DialogHeader,
    DialogFooter,
    DialogTitle,
    DialogDescription,
  };
}
declare module "@/components/ui/command" {
  import * as React from "react";
  import { DialogProps } from "@radix-ui/react-dialog";
  const Command: React.ForwardRefExoticComponent<
    Omit<
      {
        children?: React.ReactNode;
      } & React.HTMLAttributes<HTMLDivElement> & {
          label?: string | undefined;
          shouldFilter?: boolean | undefined;
          filter?: ((value: string, search: string) => number) | undefined;
          defaultValue?: string | undefined;
          value?: string | undefined;
          onValueChange?: ((value: string) => void) | undefined;
          loop?: boolean | undefined;
          vimBindings?: boolean | undefined;
        } & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  interface CommandDialogProps extends DialogProps {}
  const CommandDialog: ({
    children,
    ...props
  }: CommandDialogProps) => import("react/jsx-runtime").JSX.Element;
  const CommandInput: React.ForwardRefExoticComponent<
    Omit<
      Omit<
        React.InputHTMLAttributes<HTMLInputElement>,
        "onChange" | "value" | "type"
      > & {
        value?: string | undefined;
        onValueChange?: ((search: string) => void) | undefined;
      } & React.RefAttributes<HTMLInputElement>,
      "ref"
    > &
      React.RefAttributes<HTMLInputElement>
  >;
  const CommandList: React.ForwardRefExoticComponent<
    Omit<
      {
        children?: React.ReactNode;
      } & React.HTMLAttributes<HTMLDivElement> &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const CommandEmpty: React.ForwardRefExoticComponent<
    Omit<
      {
        children?: React.ReactNode;
      } & React.HTMLAttributes<HTMLDivElement> &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const CommandGroup: React.ForwardRefExoticComponent<
    Omit<
      {
        children?: React.ReactNode;
      } & Omit<React.HTMLAttributes<HTMLDivElement>, "value" | "heading"> & {
          heading?: React.ReactNode;
          value?: string | undefined;
          forceMount?: boolean | undefined;
        } & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const CommandSeparator: React.ForwardRefExoticComponent<
    Omit<
      React.HTMLAttributes<HTMLDivElement> & {
        alwaysRender?: boolean | undefined;
      } & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const CommandItem: React.ForwardRefExoticComponent<
    Omit<
      {
        children?: React.ReactNode;
      } & Omit<
        React.HTMLAttributes<HTMLDivElement>,
        "onSelect" | "disabled" | "value"
      > & {
          disabled?: boolean | undefined;
          onSelect?: ((value: string) => void) | undefined;
          value?: string | undefined;
          forceMount?: boolean | undefined;
        } & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  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,
  };
}
declare module "@/components/ui/context-menu" {
  import * as React from "react";
  import * as ContextMenuPrimitive from "@radix-ui/react-context-menu";
  const ContextMenu: React.FC<ContextMenuPrimitive.ContextMenuProps>;
  const ContextMenuTrigger: React.ForwardRefExoticComponent<
    ContextMenuPrimitive.ContextMenuTriggerProps &
      React.RefAttributes<HTMLSpanElement>
  >;
  const ContextMenuGroup: React.ForwardRefExoticComponent<
    ContextMenuPrimitive.ContextMenuGroupProps &
      React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuPortal: React.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
  const ContextMenuSub: React.FC<ContextMenuPrimitive.ContextMenuSubProps>;
  const ContextMenuRadioGroup: React.ForwardRefExoticComponent<
    ContextMenuPrimitive.ContextMenuRadioGroupProps &
      React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuSubTrigger: React.ForwardRefExoticComponent<
    Omit<
      ContextMenuPrimitive.ContextMenuSubTriggerProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > & {
      inset?: boolean | undefined;
    } & React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuSubContent: React.ForwardRefExoticComponent<
    Omit<
      ContextMenuPrimitive.ContextMenuSubContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuContent: React.ForwardRefExoticComponent<
    Omit<
      ContextMenuPrimitive.ContextMenuContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuItem: React.ForwardRefExoticComponent<
    Omit<
      ContextMenuPrimitive.ContextMenuItemProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > & {
      inset?: boolean | undefined;
    } & React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<
    Omit<
      ContextMenuPrimitive.ContextMenuCheckboxItemProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuRadioItem: React.ForwardRefExoticComponent<
    Omit<
      ContextMenuPrimitive.ContextMenuRadioItemProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuLabel: React.ForwardRefExoticComponent<
    Omit<
      ContextMenuPrimitive.ContextMenuLabelProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > & {
      inset?: boolean | undefined;
    } & React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuSeparator: React.ForwardRefExoticComponent<
    Omit<
      ContextMenuPrimitive.ContextMenuSeparatorProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const ContextMenuShortcut: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  export {
    ContextMenu,
    ContextMenuTrigger,
    ContextMenuContent,
    ContextMenuItem,
    ContextMenuCheckboxItem,
    ContextMenuRadioItem,
    ContextMenuLabel,
    ContextMenuSeparator,
    ContextMenuShortcut,
    ContextMenuGroup,
    ContextMenuPortal,
    ContextMenuSub,
    ContextMenuSubContent,
    ContextMenuSubTrigger,
    ContextMenuRadioGroup,
  };
}
declare module "@/components/ui/dropdown-menu" {
  import * as React from "react";
  import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
  const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
  const DropdownMenuTrigger: React.ForwardRefExoticComponent<
    DropdownMenuPrimitive.DropdownMenuTriggerProps &
      React.RefAttributes<HTMLButtonElement>
  >;
  const DropdownMenuGroup: React.ForwardRefExoticComponent<
    DropdownMenuPrimitive.DropdownMenuGroupProps &
      React.RefAttributes<HTMLDivElement>
  >;
  const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
  const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
  const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<
    DropdownMenuPrimitive.DropdownMenuRadioGroupProps &
      React.RefAttributes<HTMLDivElement>
  >;
  const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<
    Omit<
      DropdownMenuPrimitive.DropdownMenuSubTriggerProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > & {
      inset?: boolean | undefined;
    } & React.RefAttributes<HTMLDivElement>
  >;
  const DropdownMenuSubContent: React.ForwardRefExoticComponent<
    Omit<
      DropdownMenuPrimitive.DropdownMenuSubContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const DropdownMenuContent: React.ForwardRefExoticComponent<
    Omit<
      DropdownMenuPrimitive.DropdownMenuContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const DropdownMenuItem: React.ForwardRefExoticComponent<
    Omit<
      DropdownMenuPrimitive.DropdownMenuItemProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > & {
      inset?: boolean | undefined;
    } & React.RefAttributes<HTMLDivElement>
  >;
  const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<
    Omit<
      DropdownMenuPrimitive.DropdownMenuCheckboxItemProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const DropdownMenuRadioItem: React.ForwardRefExoticComponent<
    Omit<
      DropdownMenuPrimitive.DropdownMenuRadioItemProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const DropdownMenuLabel: React.ForwardRefExoticComponent<
    Omit<
      DropdownMenuPrimitive.DropdownMenuLabelProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > & {
      inset?: boolean | undefined;
    } & React.RefAttributes<HTMLDivElement>
  >;
  const DropdownMenuSeparator: React.ForwardRefExoticComponent<
    Omit<
      DropdownMenuPrimitive.DropdownMenuSeparatorProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  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,
  };
}
declare module "@/components/ui/label" {
  import * as React from "react";
  import * as LabelPrimitive from "@radix-ui/react-label";
  import { type VariantProps } from "class-variance-authority";
  const Label: React.ForwardRefExoticComponent<
    Omit<
      LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>,
      "ref"
    > &
      VariantProps<
        (
          props?: import("class-variance-authority/types").ClassProp | undefined
        ) => string
      > &
      React.RefAttributes<HTMLLabelElement>
  >;
  export { Label };
}
declare module "@/components/ui/form" {
  import * as React from "react";
  import * as LabelPrimitive from "@radix-ui/react-label";
  import { ControllerProps, FieldPath, FieldValues } from "react-hook-form";
  const Form: <
    TFieldValues extends FieldValues,
    TContext = any,
    TTransformedValues extends FieldValues | undefined = undefined
  >(
    props: import("react-hook-form").FormProviderProps<
      TFieldValues,
      TContext,
      TTransformedValues
    >
  ) => React.JSX.Element;
  const FormField: <
    TFieldValues extends FieldValues = FieldValues,
    TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>
  >({
    ...props
  }: ControllerProps<
    TFieldValues,
    TName
  >) => import("react/jsx-runtime").JSX.Element;
  const useFormField: () => {
    invalid: boolean;
    isDirty: boolean;
    isTouched: boolean;
    isValidating: boolean;
    error?: import("react-hook-form").FieldError | undefined;
    id: string;
    name: string;
    formItemId: string;
    formDescriptionId: string;
    formMessageId: string;
  };
  const FormItem: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>
  >;
  const FormLabel: React.ForwardRefExoticComponent<
    Omit<
      LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>,
      "ref"
    > &
      React.RefAttributes<HTMLLabelElement>
  >;
  const FormControl: React.ForwardRefExoticComponent<
    Omit<
      import("@radix-ui/react-slot").SlotProps &
        React.RefAttributes<HTMLElement>,
      "ref"
    > &
      React.RefAttributes<HTMLElement>
  >;
  const FormDescription: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLParagraphElement> &
      React.RefAttributes<HTMLParagraphElement>
  >;
  const FormMessage: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLParagraphElement> &
      React.RefAttributes<HTMLParagraphElement>
  >;
  export {
    useFormField,
    Form,
    FormItem,
    FormLabel,
    FormControl,
    FormDescription,
    FormMessage,
    FormField,
  };
}
declare module "@/components/ui/hover-card" {
  import * as React from "react";
  import * as HoverCardPrimitive from "@radix-ui/react-hover-card";
  const HoverCard: React.FC<HoverCardPrimitive.HoverCardProps>;
  const HoverCardTrigger: React.ForwardRefExoticComponent<
    HoverCardPrimitive.HoverCardTriggerProps &
      React.RefAttributes<HTMLAnchorElement>
  >;
  const HoverCardContent: React.ForwardRefExoticComponent<
    Omit<
      HoverCardPrimitive.HoverCardContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export { HoverCard, HoverCardTrigger, HoverCardContent };
}
declare module "@/components/ui/input" {
  import * as React from "react";
  const Input: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.InputHTMLAttributes<HTMLInputElement>,
        HTMLInputElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLInputElement>
  >;
  export { Input };
}
declare module "@/components/ui/menubar" {
  import * as React from "react";
  import * as MenubarPrimitive from "@radix-ui/react-menubar";
  const MenubarMenu: {
    (
      props: MenubarPrimitive.ScopedProps<MenubarPrimitive.MenubarMenuProps>
    ): JSX.Element;
    displayName: string;
  };
  const MenubarGroup: React.ForwardRefExoticComponent<
    MenubarPrimitive.MenubarGroupProps & React.RefAttributes<HTMLDivElement>
  >;
  const MenubarPortal: React.FC<MenubarPrimitive.MenubarPortalProps>;
  const MenubarSub: React.FC<MenubarPrimitive.MenubarSubProps>;
  const MenubarRadioGroup: React.ForwardRefExoticComponent<
    MenubarPrimitive.MenubarRadioGroupProps &
      React.RefAttributes<HTMLDivElement>
  >;
  const Menubar: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const MenubarTrigger: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarTriggerProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const MenubarSubTrigger: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarSubTriggerProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > & {
      inset?: boolean | undefined;
    } & React.RefAttributes<HTMLDivElement>
  >;
  const MenubarSubContent: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarSubContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const MenubarContent: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const MenubarItem: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarItemProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > & {
      inset?: boolean | undefined;
    } & React.RefAttributes<HTMLDivElement>
  >;
  const MenubarCheckboxItem: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarCheckboxItemProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const MenubarRadioItem: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarRadioItemProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const MenubarLabel: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarLabelProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > & {
      inset?: boolean | undefined;
    } & React.RefAttributes<HTMLDivElement>
  >;
  const MenubarSeparator: React.ForwardRefExoticComponent<
    Omit<
      MenubarPrimitive.MenubarSeparatorProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const MenubarShortcut: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
    displayname: string;
  };
  export {
    Menubar,
    MenubarMenu,
    MenubarTrigger,
    MenubarContent,
    MenubarItem,
    MenubarSeparator,
    MenubarLabel,
    MenubarCheckboxItem,
    MenubarRadioGroup,
    MenubarRadioItem,
    MenubarPortal,
    MenubarSubContent,
    MenubarSubTrigger,
    MenubarGroup,
    MenubarSub,
    MenubarShortcut,
  };
}
declare module "@/components/ui/navigation-menu" {
  import * as React from "react";
  import * as NavigationMenuPrimitive from "@radix-ui/react-navigation-menu";
  const NavigationMenu: React.ForwardRefExoticComponent<
    Omit<
      NavigationMenuPrimitive.NavigationMenuProps &
        React.RefAttributes<HTMLElement>,
      "ref"
    > &
      React.RefAttributes<HTMLElement>
  >;
  const NavigationMenuList: React.ForwardRefExoticComponent<
    Omit<
      NavigationMenuPrimitive.NavigationMenuListProps &
        React.RefAttributes<HTMLUListElement>,
      "ref"
    > &
      React.RefAttributes<HTMLUListElement>
  >;
  const NavigationMenuItem: React.ForwardRefExoticComponent<
    NavigationMenuPrimitive.NavigationMenuItemProps &
      React.RefAttributes<HTMLLIElement>
  >;
  const navigationMenuTriggerStyle: (
    props?: import("class-variance-authority/types").ClassProp | undefined
  ) => string;
  const NavigationMenuTrigger: React.ForwardRefExoticComponent<
    Omit<
      NavigationMenuPrimitive.NavigationMenuTriggerProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const NavigationMenuContent: React.ForwardRefExoticComponent<
    Omit<
      NavigationMenuPrimitive.NavigationMenuContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const NavigationMenuLink: React.ForwardRefExoticComponent<
    NavigationMenuPrimitive.NavigationMenuLinkProps &
      React.RefAttributes<HTMLAnchorElement>
  >;
  const NavigationMenuViewport: React.ForwardRefExoticComponent<
    Omit<
      NavigationMenuPrimitive.NavigationMenuViewportProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const NavigationMenuIndicator: React.ForwardRefExoticComponent<
    Omit<
      NavigationMenuPrimitive.NavigationMenuIndicatorProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export {
    navigationMenuTriggerStyle,
    NavigationMenu,
    NavigationMenuList,
    NavigationMenuItem,
    NavigationMenuContent,
    NavigationMenuTrigger,
    NavigationMenuLink,
    NavigationMenuIndicator,
    NavigationMenuViewport,
  };
}
declare module "@/components/ui/popover" {
  import * as React from "react";
  import * as PopoverPrimitive from "@radix-ui/react-popover";
  const Popover: React.FC<PopoverPrimitive.PopoverProps>;
  const PopoverTrigger: React.ForwardRefExoticComponent<
    PopoverPrimitive.PopoverTriggerProps &
      React.RefAttributes<HTMLButtonElement>
  >;
  const PopoverContent: React.ForwardRefExoticComponent<
    Omit<
      PopoverPrimitive.PopoverContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export { Popover, PopoverTrigger, PopoverContent };
}
declare module "@/components/ui/progress" {
  import * as React from "react";
  import * as ProgressPrimitive from "@radix-ui/react-progress";
  const Progress: React.ForwardRefExoticComponent<
    Omit<
      ProgressPrimitive.ProgressProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export { Progress };
}
declare module "@/components/ui/radio-group" {
  import * as React from "react";
  import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
  const RadioGroup: React.ForwardRefExoticComponent<
    Omit<
      RadioGroupPrimitive.RadioGroupProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const RadioGroupItem: React.ForwardRefExoticComponent<
    Omit<
      RadioGroupPrimitive.RadioGroupItemProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  export { RadioGroup, RadioGroupItem };
}
declare module "@/components/ui/scroll-area" {
  import * as React from "react";
  import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
  const ScrollArea: React.ForwardRefExoticComponent<
    Omit<
      ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const ScrollBar: React.ForwardRefExoticComponent<
    Omit<
      ScrollAreaPrimitive.ScrollAreaScrollbarProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export { ScrollArea, ScrollBar };
}
declare module "@/components/ui/select" {
  import * as React from "react";
  import * as SelectPrimitive from "@radix-ui/react-select";
  const Select: React.FC<SelectPrimitive.SelectProps>;
  const SelectGroup: React.ForwardRefExoticComponent<
    SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>
  >;
  const SelectValue: React.ForwardRefExoticComponent<
    SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>
  >;
  const SelectTrigger: React.ForwardRefExoticComponent<
    Omit<
      SelectPrimitive.SelectTriggerProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const SelectContent: React.ForwardRefExoticComponent<
    Omit<
      SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SelectLabel: React.ForwardRefExoticComponent<
    Omit<
      SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SelectItem: React.ForwardRefExoticComponent<
    Omit<
      SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SelectSeparator: React.ForwardRefExoticComponent<
    Omit<
      SelectPrimitive.SelectSeparatorProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export {
    Select,
    SelectGroup,
    SelectValue,
    SelectTrigger,
    SelectContent,
    SelectLabel,
    SelectItem,
    SelectSeparator,
  };
}
declare module "@/components/ui/separator" {
  import * as React from "react";
  import * as SeparatorPrimitive from "@radix-ui/react-separator";
  const Separator: React.ForwardRefExoticComponent<
    Omit<
      SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export { Separator };
}
declare module "@/components/ui/sheet" {
  import * as React from "react";
  import * as SheetPrimitive from "@radix-ui/react-dialog";
  import { type VariantProps } from "class-variance-authority";
  const Sheet: React.FC<SheetPrimitive.DialogProps>;
  const SheetTrigger: React.ForwardRefExoticComponent<
    SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>
  >;
  const SheetClose: React.ForwardRefExoticComponent<
    SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>
  >;
  const SheetPortal: React.FC<SheetPrimitive.DialogPortalProps>;
  const SheetOverlay: React.ForwardRefExoticComponent<
    Omit<
      SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const sheetVariants: (
    props?:
      | ({
          side?: "top" | "right" | "bottom" | "left" | null | undefined;
        } & import("class-variance-authority/types").ClassProp)
      | undefined
  ) => string;
  interface SheetContentProps
    extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>,
      VariantProps<typeof sheetVariants> {}
  const SheetContent: React.ForwardRefExoticComponent<
    SheetContentProps & React.RefAttributes<HTMLDivElement>
  >;
  const SheetHeader: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const SheetFooter: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const SheetTitle: React.ForwardRefExoticComponent<
    Omit<
      SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>,
      "ref"
    > &
      React.RefAttributes<HTMLHeadingElement>
  >;
  const SheetDescription: React.ForwardRefExoticComponent<
    Omit<
      SheetPrimitive.DialogDescriptionProps &
        React.RefAttributes<HTMLParagraphElement>,
      "ref"
    > &
      React.RefAttributes<HTMLParagraphElement>
  >;
  export {
    Sheet,
    SheetPortal,
    SheetOverlay,
    SheetTrigger,
    SheetClose,
    SheetContent,
    SheetHeader,
    SheetFooter,
    SheetTitle,
    SheetDescription,
  };
}
declare module "@/components/ui/skeleton" {
  function Skeleton({
    className,
    ...props
  }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
  export { Skeleton };
}
declare module "@/components/ui/slider" {
  import * as React from "react";
  import * as SliderPrimitive from "@radix-ui/react-slider";
  const Slider: React.ForwardRefExoticComponent<
    Omit<
      SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>,
      "ref"
    > &
      React.RefAttributes<HTMLSpanElement>
  >;
  export { Slider };
}
declare module "@/components/ui/switch" {
  import * as React from "react";
  import * as SwitchPrimitives from "@radix-ui/react-switch";
  const Switch: React.ForwardRefExoticComponent<
    Omit<
      SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  export { Switch };
}
declare module "@/components/ui/table" {
  import * as React from "react";
  const Table: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLTableElement> &
      React.RefAttributes<HTMLTableElement>
  >;
  const TableHeader: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLTableSectionElement> &
      React.RefAttributes<HTMLTableSectionElement>
  >;
  const TableBody: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLTableSectionElement> &
      React.RefAttributes<HTMLTableSectionElement>
  >;
  const TableFooter: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLTableSectionElement> &
      React.RefAttributes<HTMLTableSectionElement>
  >;
  const TableRow: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLTableRowElement> &
      React.RefAttributes<HTMLTableRowElement>
  >;
  const TableHead: React.ForwardRefExoticComponent<
    React.ThHTMLAttributes<HTMLTableCellElement> &
      React.RefAttributes<HTMLTableCellElement>
  >;
  const TableCell: React.ForwardRefExoticComponent<
    React.TdHTMLAttributes<HTMLTableCellElement> &
      React.RefAttributes<HTMLTableCellElement>
  >;
  const TableCaption: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLTableCaptionElement> &
      React.RefAttributes<HTMLTableCaptionElement>
  >;
  export {
    Table,
    TableHeader,
    TableBody,
    TableFooter,
    TableHead,
    TableRow,
    TableCell,
    TableCaption,
  };
}
declare module "@/components/ui/tabs" {
  import * as React from "react";
  import * as TabsPrimitive from "@radix-ui/react-tabs";
  const Tabs: React.ForwardRefExoticComponent<
    TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>
  >;
  const TabsList: React.ForwardRefExoticComponent<
    Omit<
      TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const TabsTrigger: React.ForwardRefExoticComponent<
    Omit<
      TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const TabsContent: React.ForwardRefExoticComponent<
    Omit<
      TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export { Tabs, TabsList, TabsTrigger, TabsContent };
}
declare module "@/components/ui/textarea" {
  import * as React from "react";
  export interface TextareaProps
    extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {}
  const Textarea: React.ForwardRefExoticComponent<
    TextareaProps & React.RefAttributes<HTMLTextAreaElement>
  >;
  export { Textarea };
}
declare module "@/components/ui/toast" {
  import * as React from "react";
  import * as ToastPrimitives from "@radix-ui/react-toast";
  import { type VariantProps } from "class-variance-authority";
  const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
  const ToastViewport: React.ForwardRefExoticComponent<
    Omit<
      ToastPrimitives.ToastViewportProps &
        React.RefAttributes<HTMLOListElement>,
      "ref"
    > &
      React.RefAttributes<HTMLOListElement>
  >;
  const Toast: React.ForwardRefExoticComponent<
    Omit<
      ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>,
      "ref"
    > &
      VariantProps<
        (
          props?:
            | ({
                variant?: "default" | "destructive" | null | undefined;
              } & import("class-variance-authority/types").ClassProp)
            | undefined
        ) => string
      > &
      React.RefAttributes<HTMLLIElement>
  >;
  const ToastAction: React.ForwardRefExoticComponent<
    Omit<
      ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const ToastClose: React.ForwardRefExoticComponent<
    Omit<
      ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const ToastTitle: React.ForwardRefExoticComponent<
    Omit<
      ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const ToastDescription: React.ForwardRefExoticComponent<
    Omit<
      ToastPrimitives.ToastDescriptionProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
  type ToastActionElement = React.ReactElement<typeof ToastAction>;
  export {
    type ToastProps,
    type ToastActionElement,
    ToastProvider,
    ToastViewport,
    Toast,
    ToastTitle,
    ToastDescription,
    ToastClose,
    ToastAction,
  };
}
declare module "@/components/ui/use-toast" {
  import * as React from "react";
  import type { ToastActionElement, ToastProps } from "@/components/ui/toast";
  type ToasterToast = ToastProps & {
    id: string;
    title?: React.ReactNode;
    description?: React.ReactNode;
    action?: ToastActionElement;
  };
  const actionTypes: {
    readonly ADD_TOAST: "ADD_TOAST";
    readonly UPDATE_TOAST: "UPDATE_TOAST";
    readonly DISMISS_TOAST: "DISMISS_TOAST";
    readonly REMOVE_TOAST: "REMOVE_TOAST";
  };
  type ActionType = typeof actionTypes;
  type Action =
    | {
        type: ActionType["ADD_TOAST"];
        toast: ToasterToast;
      }
    | {
        type: ActionType["UPDATE_TOAST"];
        toast: Partial<ToasterToast>;
      }
    | {
        type: ActionType["DISMISS_TOAST"];
        toastId?: ToasterToast["id"];
      }
    | {
        type: ActionType["REMOVE_TOAST"];
        toastId?: ToasterToast["id"];
      };
  interface State {
    toasts: ToasterToast[];
  }
  export const reducer: (state: State, action: Action) => State;
  type Toast = Omit<ToasterToast, "id">;
  function toast({ ...props }: Toast): {
    id: string;
    dismiss: () => void;
    update: (props: ToasterToast) => void;
  };
  function useToast(): {
    toast: typeof toast;
    dismiss: (toastId?: string) => void;
    toasts: ToasterToast[];
  };
  export { useToast, toast };
}
declare module "@/components/ui/toaster" {
  export function Toaster(): import("react/jsx-runtime").JSX.Element;
}
declare module "@/components/ui/toggle" {
  import * as React from "react";
  import * as TogglePrimitive from "@radix-ui/react-toggle";
  import { type VariantProps } from "class-variance-authority";
  const toggleVariants: (
    props?:
      | ({
          variant?: "default" | "outline" | null | undefined;
          size?: "default" | "sm" | "lg" | null | undefined;
        } & import("class-variance-authority/types").ClassProp)
      | undefined
  ) => string;
  const Toggle: React.ForwardRefExoticComponent<
    Omit<
      TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      VariantProps<
        (
          props?:
            | ({
                variant?: "default" | "outline" | null | undefined;
                size?: "default" | "sm" | "lg" | null | undefined;
              } & import("class-variance-authority/types").ClassProp)
            | undefined
        ) => string
      > &
      React.RefAttributes<HTMLButtonElement>
  >;
  export { Toggle, toggleVariants };
}
declare module "@/components/ui/tooltip" {
  import * as React from "react";
  import * as TooltipPrimitive from "@radix-ui/react-tooltip";
  const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
  const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
  const TooltipTrigger: React.ForwardRefExoticComponent<
    TooltipPrimitive.TooltipTriggerProps &
      React.RefAttributes<HTMLButtonElement>
  >;
  const TooltipContent: React.ForwardRefExoticComponent<
    Omit<
      TooltipPrimitive.TooltipContentProps &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };
}
declare module "@/components/ui/resizable" {
  import * as ResizablePrimitive from "react-resizable-panels";
  const ResizablePanelGroup: ({
    className,
    ...props
  }: React.ComponentProps<
    typeof ResizablePrimitive.PanelGroup
  >) => import("react/jsx-runtime").JSX.Element;
  const ResizablePanel: import("react").ForwardRefExoticComponent<
    Omit<
      import("react").HTMLAttributes<keyof HTMLElementTagNameMap>,
      "id" | "onResize"
    > & {
      className?: string | undefined;
      collapsedSize?: number | undefined;
      collapsible?: boolean | undefined;
      defaultSize?: number | undefined;
      id?: string | undefined;
      maxSize?: number | undefined;
      minSize?: number | undefined;
      onCollapse?: ResizablePrimitive.PanelOnCollapse | undefined;
      onExpand?: ResizablePrimitive.PanelOnExpand | undefined;
      onResize?: ResizablePrimitive.PanelOnResize | undefined;
      order?: number | undefined;
      style?: object | undefined;
      tagName?: keyof HTMLElementTagNameMap | undefined;
    } & {
      children?: import("react").ReactNode;
    } & import("react").RefAttributes<ResizablePrimitive.ImperativePanelHandle>
  >;
  const ResizableHandle: ({
    withHandle,
    className,
    ...props
  }: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
    withHandle?: boolean;
  }) => import("react/jsx-runtime").JSX.Element;
  export { ResizablePanelGroup, ResizablePanel, ResizableHandle };
}
declare module "@/components/ui/input-otp" {
  import * as React from "react";
  import { SlotProps } from "input-otp";
  const InputOTP: React.ForwardRefExoticComponent<
    (
      | Omit<
          Omit<
            React.InputHTMLAttributes<HTMLInputElement>,
            | "onChange"
            | "value"
            | "maxLength"
            | "textAlign"
            | "onComplete"
            | "pushPasswordManagerStrategy"
            | "containerClassName"
            | "noScriptCSSFallback"
          > & {
            value?: string | undefined;
            onChange?: ((newValue: string) => unknown) | undefined;
            maxLength: number;
            textAlign?: "center" | "right" | "left" | undefined;
            onComplete?: ((...args: any[]) => unknown) | undefined;
            pushPasswordManagerStrategy?: "none" | "increase-width" | undefined;
            containerClassName?: string | undefined;
            noScriptCSSFallback?: string | null | undefined;
          } & {
            render: (props: import("input-otp").RenderProps) => React.ReactNode;
            children?: undefined;
          } & React.RefAttributes<HTMLInputElement>,
          "ref"
        >
      | Omit<
          Omit<
            React.InputHTMLAttributes<HTMLInputElement>,
            | "onChange"
            | "value"
            | "maxLength"
            | "textAlign"
            | "onComplete"
            | "pushPasswordManagerStrategy"
            | "containerClassName"
            | "noScriptCSSFallback"
          > & {
            value?: string | undefined;
            onChange?: ((newValue: string) => unknown) | undefined;
            maxLength: number;
            textAlign?: "center" | "right" | "left" | undefined;
            onComplete?: ((...args: any[]) => unknown) | undefined;
            pushPasswordManagerStrategy?: "none" | "increase-width" | undefined;
            containerClassName?: string | undefined;
            noScriptCSSFallback?: string | null | undefined;
          } & {
            render?: undefined;
            children: React.ReactNode;
          } & React.RefAttributes<HTMLInputElement>,
          "ref"
        >
    ) &
      React.RefAttributes<HTMLInputElement>
  >;
  const InputOTPGroup: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLDivElement>,
        HTMLDivElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const InputOTPSlot: React.ForwardRefExoticComponent<
    SlotProps &
      Omit<
        React.DetailedHTMLProps<
          React.HTMLAttributes<HTMLDivElement>,
          HTMLDivElement
        >,
        "ref"
      > &
      React.RefAttributes<HTMLDivElement>
  >;
  const InputOTPSeparator: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLDivElement>,
        HTMLDivElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };
}
declare module "@/components/ui/breadcrumb" {
  import * as React from "react";
  const Breadcrumb: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>,
      "ref"
    > & {
      separator?: React.ReactNode;
    } & React.RefAttributes<HTMLElement>
  >;
  const BreadcrumbList: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.OlHTMLAttributes<HTMLOListElement>,
        HTMLOListElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLOListElement>
  >;
  const BreadcrumbItem: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.LiHTMLAttributes<HTMLLIElement>,
        HTMLLIElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLLIElement>
  >;
  const BreadcrumbLink: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.AnchorHTMLAttributes<HTMLAnchorElement>,
        HTMLAnchorElement
      >,
      "ref"
    > & {
      asChild?: boolean | undefined;
    } & React.RefAttributes<HTMLAnchorElement>
  >;
  const BreadcrumbPage: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLSpanElement>,
        HTMLSpanElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLSpanElement>
  >;
  const BreadcrumbSeparator: {
    ({
      children,
      className,
      ...props
    }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const BreadcrumbEllipsis: {
    ({
      className,
      ...props
    }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  export {
    Breadcrumb,
    BreadcrumbList,
    BreadcrumbItem,
    BreadcrumbLink,
    BreadcrumbPage,
    BreadcrumbSeparator,
    BreadcrumbEllipsis,
  };
}
declare module "@/components/ui/toggle-group" {
  import * as React from "react";
  import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
  import { VariantProps } from "class-variance-authority";
  const ToggleGroup: React.ForwardRefExoticComponent<
    ((
      | Omit<
          ToggleGroupPrimitive.ToggleGroupSingleProps &
            React.RefAttributes<HTMLDivElement>,
          "ref"
        >
      | Omit<
          ToggleGroupPrimitive.ToggleGroupMultipleProps &
            React.RefAttributes<HTMLDivElement>,
          "ref"
        >
    ) &
      VariantProps<
        (
          props?:
            | ({
                variant?: "default" | "outline" | null | undefined;
                size?: "default" | "sm" | "lg" | null | undefined;
              } & import("class-variance-authority/types").ClassProp)
            | undefined
        ) => string
      >) &
      React.RefAttributes<HTMLDivElement>
  >;
  const ToggleGroupItem: React.ForwardRefExoticComponent<
    Omit<
      ToggleGroupPrimitive.ToggleGroupItemProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      VariantProps<
        (
          props?:
            | ({
                variant?: "default" | "outline" | null | undefined;
                size?: "default" | "sm" | "lg" | null | undefined;
              } & import("class-variance-authority/types").ClassProp)
            | undefined
        ) => string
      > &
      React.RefAttributes<HTMLButtonElement>
  >;
  export { ToggleGroup, ToggleGroupItem };
}
declare module "@/components/ui/sonner" {
  import { Toaster } from "sonner";
  type SonnerProps = React.ComponentProps<typeof Toaster>;
  const Sonner: ({
    ...props
  }: SonnerProps) => import("react/jsx-runtime").JSX.Element;
  export { Sonner };
}
declare module "@/components/ui/pagination" {
  import * as React from "react";
  import { ButtonProps } from "@/components/ui/button";
  const Pagination: {
    ({
      className,
      ...props
    }: React.ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const PaginationContent: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLUListElement>,
        HTMLUListElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLUListElement>
  >;
  const PaginationItem: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.LiHTMLAttributes<HTMLLIElement>,
        HTMLLIElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLLIElement>
  >;
  type PaginationLinkProps = {
    isActive?: boolean;
  } & Pick<ButtonProps, "size"> &
    React.ComponentProps<"a">;
  const PaginationLink: {
    ({
      className,
      isActive,
      size,
      ...props
    }: PaginationLinkProps): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const PaginationPrevious: {
    ({
      className,
      ...props
    }: React.ComponentProps<
      typeof PaginationLink
    >): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const PaginationNext: {
    ({
      className,
      ...props
    }: React.ComponentProps<
      typeof PaginationLink
    >): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const PaginationEllipsis: {
    ({
      className,
      ...props
    }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  export {
    Pagination,
    PaginationContent,
    PaginationEllipsis,
    PaginationItem,
    PaginationLink,
    PaginationNext,
    PaginationPrevious,
  };
}
declare module "@/components/ui/drawer" {
  import * as React from "react";
  import { Drawer as DrawerPrimitive } from "vaul";
  import type {
    DialogTitleProps,
    DialogTriggerProps,
    DialogPortalProps,
    DialogCloseProps,
    DialogOverlayProps,
    DialogContentProps,
    DialogDescriptionProps,
  } from "@radix-ui/react-dialog";
  const Drawer: {
    ({
      shouldScaleBackground,
      ...props
    }: React.ComponentProps<
      typeof DrawerPrimitive.Root
    >): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const DrawerTrigger: React.ForwardRefExoticComponent<
    DialogTriggerProps & React.RefAttributes<HTMLButtonElement>
  >;
  const DrawerPortal: React.FC<DialogPortalProps>;
  const DrawerClose: React.ForwardRefExoticComponent<
    DialogCloseProps & React.RefAttributes<HTMLButtonElement>
  >;
  const DrawerOverlay: React.ForwardRefExoticComponent<
    Omit<
      Omit<DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const DrawerContent: React.ForwardRefExoticComponent<
    Omit<
      Omit<DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
        onAnimationEnd?: (open: boolean) => void;
      } & React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const DrawerHeader: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const DrawerFooter: {
    ({
      className,
      ...props
    }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
    displayName: string;
  };
  const DrawerTitle: React.ForwardRefExoticComponent<
    Omit<DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> &
      React.RefAttributes<HTMLHeadingElement>
  >;
  const DrawerDescription: React.ForwardRefExoticComponent<
    Omit<
      DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>,
      "ref"
    > &
      React.RefAttributes<HTMLParagraphElement>
  >;
  export {
    Drawer,
    DrawerPortal,
    DrawerOverlay,
    DrawerTrigger,
    DrawerClose,
    DrawerContent,
    DrawerHeader,
    DrawerFooter,
    DrawerTitle,
    DrawerDescription,
  };
}
declare module "@/components/ui/carousel" {
  import * as React from "react";
  import useEmblaCarousel, {
    type UseEmblaCarouselType,
  } from "embla-carousel-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;
  };
  const Carousel: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> &
      CarouselProps &
      React.RefAttributes<HTMLDivElement>
  >;
  const CarouselContent: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>
  >;
  const CarouselItem: React.ForwardRefExoticComponent<
    React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>
  >;
  const CarouselPrevious: React.ForwardRefExoticComponent<
    Omit<
      import("@/components/ui/button").ButtonProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const CarouselNext: React.ForwardRefExoticComponent<
    Omit<
      import("@/components/ui/button").ButtonProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  export {
    type CarouselApi,
    Carousel,
    CarouselContent,
    CarouselItem,
    CarouselPrevious,
    CarouselNext,
  };
}
declare module "hooks/use-mobile" {
  export function useIsMobile(): boolean;
}
declare module "@/components/ui/sidebar" {
  import * as React from "react";
  import { VariantProps } from "class-variance-authority";
  type SidebarContext = {
    state: "expanded" | "collapsed";
    open: boolean;
    setOpen: (open: boolean) => void;
    openMobile: boolean;
    setOpenMobile: (open: boolean) => void;
    isMobile: boolean;
    toggleSidebar: () => void;
  };
  const SidebarContext: React.Context<SidebarContext | null>;
  function useSidebar(): SidebarContext;
  const SidebarProvider: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLDivElement> &
        React.HTMLAttributes<HTMLDivElement> & {
          defaultOpen?: boolean | undefined;
          open?: boolean | undefined;
          onOpenChange?: ((open: boolean) => void) | undefined;
        },
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const Sidebar: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLDivElement> &
        React.HTMLAttributes<HTMLDivElement> & {
          side?: "right" | "left" | undefined;
          variant?: "inset" | "sidebar" | "floating" | undefined;
          collapsible?: "none" | "icon" | "offcanvas" | undefined;
        },
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarTrigger: React.ForwardRefExoticComponent<
    Omit<
      import("@/components/ui/button").ButtonProps &
        React.RefAttributes<HTMLButtonElement>,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const SidebarRail: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.ButtonHTMLAttributes<HTMLButtonElement>,
        HTMLButtonElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const SidebarInset: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarInput: React.ForwardRefExoticComponent<
    Omit<
      Omit<
        React.DetailedHTMLProps<
          React.InputHTMLAttributes<HTMLInputElement>,
          HTMLInputElement
        >,
        "ref"
      > &
        React.RefAttributes<HTMLInputElement>,
      "ref"
    > &
      React.RefAttributes<HTMLInputElement>
  >;
  const SidebarHeader: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLDivElement>,
        HTMLDivElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarFooter: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLDivElement>,
        HTMLDivElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarSeparator: React.ForwardRefExoticComponent<
    Omit<
      Omit<
        import("@radix-ui/react-separator").SeparatorProps &
          React.RefAttributes<HTMLDivElement>,
        "ref"
      > &
        React.RefAttributes<HTMLDivElement>,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarContent: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLDivElement>,
        HTMLDivElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarGroup: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLDivElement>,
        HTMLDivElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarGroupLabel: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLDivElement> &
        React.HTMLAttributes<HTMLDivElement> & {
          asChild?: boolean | undefined;
        },
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarGroupAction: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLButtonElement> &
        React.ButtonHTMLAttributes<HTMLButtonElement> & {
          asChild?: boolean | undefined;
        },
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const SidebarGroupContent: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLDivElement>,
        HTMLDivElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarMenu: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLUListElement>,
        HTMLUListElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLUListElement>
  >;
  const SidebarMenuItem: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.LiHTMLAttributes<HTMLLIElement>,
        HTMLLIElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLLIElement>
  >;
  const SidebarMenuButton: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLButtonElement> &
        React.ButtonHTMLAttributes<HTMLButtonElement> & {
          asChild?: boolean | undefined;
          isActive?: boolean | undefined;
          tooltip?:
            | string
            | (Omit<
                import("@radix-ui/react-tooltip").TooltipContentProps &
                  React.RefAttributes<HTMLDivElement>,
                "ref"
              > &
                React.RefAttributes<HTMLDivElement>)
            | undefined;
        } & VariantProps<
          (
            props?:
              | ({
                  variant?: "default" | "outline" | null | undefined;
                  size?: "default" | "sm" | "lg" | null | undefined;
                } & import("class-variance-authority/types").ClassProp)
              | undefined
          ) => string
        >,
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const SidebarMenuAction: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLButtonElement> &
        React.ButtonHTMLAttributes<HTMLButtonElement> & {
          asChild?: boolean | undefined;
          showOnHover?: boolean | undefined;
        },
      "ref"
    > &
      React.RefAttributes<HTMLButtonElement>
  >;
  const SidebarMenuBadge: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLDivElement>,
        HTMLDivElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarMenuSkeleton: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLDivElement> &
        React.HTMLAttributes<HTMLDivElement> & {
          showIcon?: boolean | undefined;
        },
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const SidebarMenuSub: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.HTMLAttributes<HTMLUListElement>,
        HTMLUListElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLUListElement>
  >;
  const SidebarMenuSubItem: React.ForwardRefExoticComponent<
    Omit<
      React.DetailedHTMLProps<
        React.LiHTMLAttributes<HTMLLIElement>,
        HTMLLIElement
      >,
      "ref"
    > &
      React.RefAttributes<HTMLLIElement>
  >;
  const SidebarMenuSubButton: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLAnchorElement> &
        React.AnchorHTMLAttributes<HTMLAnchorElement> & {
          asChild?: boolean | undefined;
          size?: "sm" | "md" | undefined;
          isActive?: boolean | undefined;
        },
      "ref"
    > &
      React.RefAttributes<HTMLAnchorElement>
  >;
  export {
    Sidebar,
    SidebarContent,
    SidebarFooter,
    SidebarGroup,
    SidebarGroupAction,
    SidebarGroupContent,
    SidebarGroupLabel,
    SidebarHeader,
    SidebarInput,
    SidebarInset,
    SidebarMenu,
    SidebarMenuAction,
    SidebarMenuBadge,
    SidebarMenuButton,
    SidebarMenuItem,
    SidebarMenuSkeleton,
    SidebarMenuSub,
    SidebarMenuSubButton,
    SidebarMenuSubItem,
    SidebarProvider,
    SidebarRail,
    SidebarSeparator,
    SidebarTrigger,
    useSidebar,
  };
}
declare module "@/components/ui/chart" {
  import * as React from "react";
  import * as RechartsPrimitive from "recharts";
  const THEMES: {
    readonly light: "";
    readonly dark: ".dark";
  };
  export type ChartConfig = {
    [k in string]: {
      label?: React.ReactNode;
      icon?: React.ComponentType;
    } & (
      | {
          color?: string;
          theme?: never;
        }
      | {
          color?: never;
          theme: Record<keyof typeof THEMES, string>;
        }
    );
  };
  const ChartContainer: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLDivElement> &
        React.HTMLAttributes<HTMLDivElement> & {
          config: ChartConfig;
          children: React.ComponentProps<
            typeof RechartsPrimitive.ResponsiveContainer
          >["children"];
        },
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const ChartStyle: ({
    id,
    config,
  }: {
    id: string;
    config: ChartConfig;
  }) => import("react/jsx-runtime").JSX.Element | null;
  const ChartTooltip: typeof RechartsPrimitive.Tooltip;
  const ChartTooltipContent: React.ForwardRefExoticComponent<
    Omit<
      RechartsPrimitive.DefaultTooltipContentProps<
        import("recharts/types/component/DefaultTooltipContent").ValueType,
        import("recharts/types/component/DefaultTooltipContent").NameType
      > & {
        accessibilityLayer?: boolean | undefined;
        active?: boolean | undefined;
        includeHidden?: boolean | undefined;
        allowEscapeViewBox?:
          | import("recharts/types/util/types").AllowInDimension
          | undefined;
        animationDuration?: number | undefined;
        animationEasing?:
          | import("recharts/types/util/types").AnimationTiming
          | undefined;
        content?:
          | import("recharts/types/component/Tooltip").ContentType<
              import("recharts/types/component/DefaultTooltipContent").ValueType,
              import("recharts/types/component/DefaultTooltipContent").NameType
            >
          | undefined;
        coordinate?:
          | Partial<import("recharts/types/util/types").Coordinate>
          | undefined;
        cursor?:
          | boolean
          | React.ReactElement<any, string | React.JSXElementConstructor<any>>
          | React.SVGProps<SVGElement>
          | undefined;
        filterNull?: boolean | undefined;
        defaultIndex?: number | undefined;
        isAnimationActive?: boolean | undefined;
        offset?: number | undefined;
        payloadUniqBy?:
          | import("recharts/types/util/payload/getUniqPayload").UniqueOption<
              import("recharts/types/component/DefaultTooltipContent").Payload<
                import("recharts/types/component/DefaultTooltipContent").ValueType,
                import("recharts/types/component/DefaultTooltipContent").NameType
              >
            >
          | undefined;
        position?:
          | Partial<import("recharts/types/util/types").Coordinate>
          | undefined;
        reverseDirection?:
          | import("recharts/types/util/types").AllowInDimension
          | undefined;
        shared?: boolean | undefined;
        trigger?: "hover" | "click" | undefined;
        useTranslate3d?: boolean | undefined;
        viewBox?:
          | import("recharts/types/util/types").CartesianViewBox
          | undefined;
        wrapperStyle?: React.CSSProperties | undefined;
      } & React.ClassAttributes<HTMLDivElement> &
        React.HTMLAttributes<HTMLDivElement> & {
          hideLabel?: boolean | undefined;
          hideIndicator?: boolean | undefined;
          indicator?: "line" | "dashed" | "dot" | undefined;
          nameKey?: string | undefined;
          labelKey?: string | undefined;
        },
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  const ChartLegend: typeof RechartsPrimitive.Legend;
  const ChartLegendContent: React.ForwardRefExoticComponent<
    Omit<
      React.ClassAttributes<HTMLDivElement> &
        React.HTMLAttributes<HTMLDivElement> &
        Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
          hideIcon?: boolean | undefined;
          nameKey?: string | undefined;
        },
      "ref"
    > &
      React.RefAttributes<HTMLDivElement>
  >;
  export {
    ChartContainer,
    ChartTooltip,
    ChartTooltipContent,
    ChartLegend,
    ChartLegendContent,
    ChartStyle,
  };
}
declare module "@" {
  export * from "@/components/ui/accordion";
  export * from "@/components/ui/alert-dialog";
  export * from "@/components/ui/alert";
  export * from "@/components/ui/aspect-ratio";
  export * from "@/components/ui/avatar";
  export * from "@/components/ui/badge";
  export * from "@/components/ui/button";
  export * from "@/components/ui/calendar";
  export * from "@/components/ui/card";
  export * from "@/components/ui/checkbox";
  export * from "@/components/ui/collapsible";
  export * from "@/components/ui/command";
  export * from "@/components/ui/context-menu";
  export * from "@/components/ui/dialog";
  export * from "@/components/ui/dropdown-menu";
  export * from "@/components/ui/form";
  export * from "@/components/ui/hover-card";
  export * from "@/components/ui/input";
  export * from "@/components/ui/label";
  export * from "@/components/ui/menubar";
  export * from "@/components/ui/navigation-menu";
  export * from "@/components/ui/popover";
  export * from "@/components/ui/progress";
  export * from "@/components/ui/radio-group";
  export * from "@/components/ui/scroll-area";
  export * from "@/components/ui/select";
  export * from "@/components/ui/separator";
  export * from "@/components/ui/sheet";
  export * from "@/components/ui/skeleton";
  export * from "@/components/ui/slider";
  export * from "@/components/ui/switch";
  export * from "@/components/ui/table";
  export * from "@/components/ui/tabs";
  export * from "@/components/ui/textarea";
  export * from "@/components/ui/toast";
  export * from "@/components/ui/toaster";
  export * from "@/components/ui/toggle";
  export * from "@/components/ui/tooltip";
  export * from "@/components/ui/use-toast";
  export * from "@/lib/utils";
  export * from "@/components/ui/resizable";
  export * from "@/components/ui/input-otp";
  export * from "@/components/ui/breadcrumb";
  export * from "@/components/ui/toggle-group";
  export * from "@/components/ui/sonner";
  export * from "@/components/ui/pagination";
  export * from "@/components/ui/drawer";
  export * from "@/components/ui/carousel";
  export * from "@/components/ui/sidebar";
  export * from "@/components/ui/chart";
}
declare module "main" {
  import "./index.css";
}
declare module "class-variance-authority" {
  import { clsx } from "clsx";
  import type {
    ClassProp,
    ClassValue,
    OmitUndefined,
    StringToBoolean,
  } from "./types";
  export type VariantProps<Component extends (...args: any) => any> = Omit<
    OmitUndefined<Parameters<Component>[0]>,
    "class" | "className"
  >;
  export type CxOptions = Parameters<typeof clsx>;
  export type CxReturn = ReturnType<typeof clsx>;
  export declare const cx: typeof clsx;
  type ConfigSchema = Record<string, Record<string, ClassValue>>;
  type ConfigVariants<T extends ConfigSchema> = {
    [Variant in keyof T]?: StringToBoolean<keyof T[Variant]> | null | undefined;
  };
  type ConfigVariantsMulti<T extends ConfigSchema> = {
    [Variant in keyof T]?:
      | StringToBoolean<keyof T[Variant]>
      | StringToBoolean<keyof T[Variant]>[]
      | undefined;
  };
  type Config<T> = T extends ConfigSchema
    ? {
        variants?: T;
        defaultVariants?: ConfigVariants<T>;
        compoundVariants?: (T extends ConfigSchema
          ? (ConfigVariants<T> | ConfigVariantsMulti<T>) & ClassProp
          : ClassProp)[];
      }
    : never;
  type Props<T> = T extends ConfigSchema
    ? ConfigVariants<T> & ClassProp
    : ClassProp;
  export declare const cva: <T>(
    base?: ClassValue,
    config?: Config<T>
  ) => (props?: Props<T>) => string;
  export {};
}
declare module "class-variance-authority/types" {
  import type * as CLSX from "clsx";
  export type ClassPropKey = "class" | "className";
  export type ClassValue = CLSX.ClassValue;
  export type ClassProp =
    | {
        class: ClassValue;
        className?: never;
      }
    | {
        class?: never;
        className: ClassValue;
      }
    | {
        class?: never;
        className?: never;
      };
  export type OmitUndefined<T> = T extends undefined ? never : T;
  export type StringToBoolean<T> = T extends "true" | "false" ? boolean : T;
}
declare module "clsx" {
  export type ClassValue =
    | ClassArray
    | ClassDictionary
    | string
    | number
    | bigint
    | null
    | boolean
    | undefined;
  export type ClassDictionary = Record<string, any>;
  export type ClassArray = ClassValue[];

  export function clsx(...inputs: ClassValue[]): string;
  export default clsx;
}