@buildbase/sdk 0.0.1

package/dist/types/components/ui/dropdown-menu.d.ts

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

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

@@ -0,0 +1,23 @@
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as React from 'react';
+import { ControllerProps, FieldPath, FieldValues } from 'react-hook-form';
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: import("react-hook-form").FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => import("react/jsx-runtime").JSX.Element;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import("react-hook-form").FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare const FormItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-slot").SlotProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const FormDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, useFormField, };

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

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const headingVariants: (props?: ({
+    variant?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | null | undefined;
+    padding?: "default" | "sm" | "lg" | "none" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface HeadingProps extends React.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof headingVariants> {
+}
+declare const Heading: React.ForwardRefExoticComponent<HeadingProps & React.RefAttributes<HTMLHeadingElement>>;
+export { Heading, headingVariants };

package/dist/types/components/ui/hover-card.d.ts

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

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

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };

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

@@ -0,0 +1,5 @@
+import * as LabelPrimitive from '@radix-ui/react-label';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare 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 };

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

@@ -0,0 +1,33 @@
+import * as MenubarPrimitive from '@radix-ui/react-menubar';
+import * as React from 'react';
+declare const MenubarMenu: {
+    (props: MenubarPrimitive.MenubarMenuProps & {
+        __scopeMenubar?: import("@radix-ui/react-context").Scope;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const MenubarGroup: React.ForwardRefExoticComponent<MenubarPrimitive.MenubarGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarPortal: React.FC<MenubarPrimitive.MenubarPortalProps>;
+declare const MenubarSub: React.FC<MenubarPrimitive.MenubarSubProps>;
+declare const MenubarRadioGroup: React.ForwardRefExoticComponent<MenubarPrimitive.MenubarRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Menubar: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarTrigger: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const MenubarSubTrigger: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarSubContent: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarContent: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarItem: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarCheckboxItem: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarRadioItem: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarLabel: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarSeparator: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayname: string;
+};
+export { Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, };

package/dist/types/components/ui/navigation-menu.d.ts

@@ -0,0 +1,12 @@
+import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
+import * as React from 'react';
+declare const NavigationMenu: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const NavigationMenuList: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React.RefAttributes<HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const NavigationMenuItem: React.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
+declare const navigationMenuTriggerStyle: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+declare const NavigationMenuTrigger: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const NavigationMenuContent: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuLink: React.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const NavigationMenuViewport: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuIndicator: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, navigationMenuTriggerStyle, NavigationMenuViewport, };

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

@@ -0,0 +1,6 @@
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as React from 'react';
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverContent, PopoverTrigger };

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

@@ -0,0 +1,4 @@
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as React from 'react';
+declare const Progress: React.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Progress };

package/dist/types/components/ui/radio-group.d.ts

@@ -0,0 +1,5 @@
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as React from 'react';
+declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { RadioGroup, RadioGroupItem };

package/dist/types/components/ui/scroll-area.d.ts

@@ -0,0 +1,5 @@
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as React from 'react';
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ScrollArea, ScrollBar };

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

@@ -0,0 +1,11 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as React from 'react';
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, SelectValue, };

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

@@ -0,0 +1,4 @@
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as React from 'react';
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

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

@@ -0,0 +1,28 @@
+import * as SheetPrimitive from '@radix-ui/react-dialog';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const Sheet: React.FC<SheetPrimitive.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: {
+    ({ ...props }: SheetPrimitive.DialogPortalProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "left" | "right" | "top" | "bottom" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, };

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

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

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

@@ -0,0 +1,4 @@
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import * as React from 'react';
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Slider };

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

@@ -0,0 +1,4 @@
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as React from 'react';
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

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

@@ -0,0 +1,10 @@
+import * as React from 'react';
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow };

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

@@ -0,0 +1,7 @@
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as React from 'react';
+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>>;
+export { Tabs, TabsContent, TabsList, TabsTrigger };

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

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

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

@@ -0,0 +1,15 @@
+import * as ToastPrimitives from '@radix-ui/react-toast';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare 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>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare 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 { Toast, ToastAction, ToastClose, ToastDescription, ToastProvider, ToastTitle, ToastViewport, type ToastActionElement, type ToastProps, };

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

@@ -0,0 +1 @@
+export declare function Toaster(): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,12 @@
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare 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 };

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

@@ -0,0 +1,7 @@
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as React from 'react';
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/types/components/ui/use-toast.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import type { ToastActionElement, ToastProps } from './toast';
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    action?: ToastActionElement;
+};
+declare 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 declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, 'id'>;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+    toasts: ToasterToast[];
+};
+export { toast, useToast };

package/dist/types/components/user/auth.d.ts

@@ -0,0 +1,6 @@
+interface IProps {
+    children: React.ReactNode;
+}
+export declare const WhenAuthenticated: (props: IProps) => import("react").ReactNode;
+export declare const WhenUnauthenticated: (props: IProps) => import("react").ReactNode;
+export {};

package/dist/types/components/user/role.d.ts

@@ -0,0 +1,8 @@
+interface IProps {
+    roles: string[];
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+}
+export declare const WhenRoles: (props: IProps) => import("react").ReactNode;
+export declare const WhenWorkspaceRoles: (props: IProps) => import("react").ReactNode;
+export {};

package/dist/types/contexts/AuthContext.d.ts

@@ -0,0 +1,9 @@
+import type { IAuthState } from '../providers/auth/types';
+import type { AuthAction, AuthContextValue } from './types';
+export declare const AuthProvider: import("react").FC<{
+    children: import("react").ReactNode;
+}>;
+export declare const useAuthContext: () => AuthContextValue;
+export declare const useAuthState: () => IAuthState;
+export declare const useAuthDispatch: () => import("react").Dispatch<AuthAction>;
+export declare const useAuthSelector: <Selected = IAuthState>(selector?: ((state: IAuthState) => Selected) | undefined, equalityFn?: ((a: Selected, b: Selected) => boolean) | undefined) => Selected;

package/dist/types/contexts/OSContext.d.ts

@@ -0,0 +1,9 @@
+import type { IOsState } from '../providers/os/types';
+import type { OSAction, OSContextValue } from './types';
+export declare const OSProvider: import("react").FC<{
+    children: import("react").ReactNode;
+}>;
+export declare const useOSContext: () => OSContextValue;
+export declare const useOSState: () => IOsState;
+export declare const useOSDispatch: () => import("react").Dispatch<OSAction>;
+export declare const useOSSelector: <Selected = IOsState>(selector?: ((state: IOsState) => Selected) | undefined, equalityFn?: ((a: Selected, b: Selected) => boolean) | undefined) => Selected;

package/dist/types/contexts/SDKContextProvider.d.ts

@@ -0,0 +1,15 @@
+import React, { type ReactNode } from 'react';
+/**
+ * SDK Context Provider
+ * Combines all context providers in the correct order
+ *
+ * Provider hierarchy:
+ * 1. OSProvider - Base configuration (serverUrl, version, orgId)
+ * 2. AuthProvider - Authentication state
+ * 3. WorkspaceProvider - Workspace management (depends on auth)
+ *
+ * This order ensures dependencies are available when needed.
+ */
+export declare const SDKContextProvider: React.FC<{
+    children: ReactNode;
+}>;

package/dist/types/contexts/WorkspaceContext.d.ts

@@ -0,0 +1,8 @@
+import type { WorkspaceAction, WorkspaceContextValue, WorkspaceState } from './types';
+export declare const WorkspaceProvider: import("react").FC<{
+    children: import("react").ReactNode;
+}>;
+export declare const useWorkspaceContext: () => WorkspaceContextValue;
+export declare const useWorkspaceState: () => WorkspaceState;
+export declare const useWorkspaceDispatch: () => import("react").Dispatch<WorkspaceAction>;
+export declare const useWorkspaceSelector: <Selected = WorkspaceState>(selector?: ((state: WorkspaceState) => Selected) | undefined, equalityFn?: ((a: Selected, b: Selected) => boolean) | undefined) => Selected;

package/dist/types/contexts/actionCreators.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Action creators for Context API
+ * These functions create actions for use with Context API reducers
+ */
+import type { AuthSession } from '../providers/auth/types';
+import type { IOsState } from '../providers/os/types';
+import type { IWorkspace, IWorkspaceFeature } from '../providers/workspace/types';
+import type { AuthAction, OSAction, WorkspaceAction } from './types';
+export declare const authActions: {
+    authenticationStarted: () => AuthAction;
+    authenticationFailed: () => AuthAction;
+    setSession: (session: AuthSession) => AuthAction;
+    removeSession: () => AuthAction;
+};
+export declare const workspaceActions: {
+    setWorkspaces: (workspaces: IWorkspace[]) => WorkspaceAction;
+    setAllFeatures: (features: IWorkspaceFeature[]) => WorkspaceAction;
+    setCurrentWorkspace: (workspace: IWorkspace) => WorkspaceAction;
+    resetCurrentWorkspace: () => WorkspaceAction;
+    setIsInitialized: (isInitialized: boolean) => WorkspaceAction;
+    setLoading: (loading: boolean) => WorkspaceAction;
+    setError: (error: string | null) => WorkspaceAction;
+    setRefreshing: (refreshing: boolean) => WorkspaceAction;
+    setSwitching: (switching: boolean) => WorkspaceAction;
+};
+export declare const osActions: {
+    setSaaSOSConfig: (config: IOsState) => OSAction;
+    removeSaaSOSConfig: () => OSAction;
+};

package/dist/types/contexts/createContext.d.ts

@@ -0,0 +1,27 @@
+import React, { type Dispatch, type ReactNode } from 'react';
+/**
+ * Generic context factory with performance optimizations
+ * Creates a context, provider, and hooks with minimal boilerplate
+ *
+ * Optimizations:
+ * - Memoized context value to prevent unnecessary re-renders
+ * - Stable dispatch reference (already stable from useReducer)
+ * - Split state/dispatch for selective subscriptions
+ */
+export declare function createContextProvider<State, Action>({ name, initialState, reducer, initializer, }: {
+    name: string;
+    initialState: State;
+    reducer: (state: State, action: Action) => State;
+    initializer?: (initialState: State) => State;
+}): {
+    Provider: React.FC<{
+        children: ReactNode;
+    }>;
+    useContext: () => {
+        state: State;
+        dispatch: Dispatch<Action>;
+    };
+    useState: () => State;
+    useDispatch: () => React.Dispatch<Action>;
+    useSelector: <Selected = State>(selector?: (state: State) => Selected, equalityFn?: (a: Selected, b: Selected) => boolean) => Selected;
+};

package/dist/types/contexts/index.d.ts

@@ -0,0 +1,10 @@
+export { AuthProvider, useAuthContext, useAuthDispatch, useAuthSelector, useAuthState, } from './AuthContext';
+export { OSProvider, useOSContext, useOSDispatch, useOSSelector, useOSState } from './OSContext';
+export { SDKContextProvider } from './SDKContextProvider';
+export { WorkspaceProvider, useWorkspaceContext, useWorkspaceDispatch, useWorkspaceSelector, useWorkspaceState, } from './WorkspaceContext';
+export type { AuthAction, AuthContextValue, OSAction, OSContextValue, SDKContextValue, WorkspaceAction, WorkspaceContextValue, WorkspaceState, } from './types';
+export { authReducer, getInitialAuthState, getInitialOSState, getInitialWorkspaceState, osReducer, workspaceReducer, } from './reducers';
+export { useAppSelector } from './useAppSelector';
+export type { SDKState } from './useAppSelector';
+export { useAppDispatch } from './useAppDispatch';
+export type { SDKDispatch } from './useAppDispatch';

package/dist/types/contexts/reducers/authReducer.d.ts

@@ -0,0 +1,13 @@
+import type { IAuthState } from '../../providers/auth/types';
+import type { AuthAction } from '../types';
+export declare const AUTH_TOKEN_KEY = "saas_os_auth_token";
+/**
+ * Initial state for auth context
+ * Loads session from localStorage if available
+ */
+export declare const getInitialAuthState: () => IAuthState;
+/**
+ * Auth reducer for Context API
+ * Handles all auth state updates with proper immutability
+ */
+export declare const authReducer: (state: IAuthState, action: AuthAction) => IAuthState;

package/dist/types/contexts/reducers/index.d.ts

@@ -0,0 +1,3 @@
+export { authReducer, getInitialAuthState } from './authReducer';
+export { getInitialOSState, osReducer } from './osReducer';
+export { getInitialWorkspaceState, workspaceReducer } from './workspaceReducer';

package/dist/types/contexts/reducers/osReducer.d.ts

@@ -0,0 +1,11 @@
+import type { IOsState } from '../../providers/os/types';
+import type { OSAction } from '../types';
+/**
+ * Initial state for OS context
+ */
+export declare const getInitialOSState: () => IOsState;
+/**
+ * OS reducer for Context API
+ * Handles OS configuration state updates with proper immutability
+ */
+export declare const osReducer: (state: IOsState, action: OSAction) => IOsState;

package/dist/types/contexts/reducers/workspaceReducer.d.ts

@@ -0,0 +1,10 @@
+import type { WorkspaceAction, WorkspaceState } from '../types';
+/**
+ * Initial state for workspace context
+ */
+export declare const getInitialWorkspaceState: () => WorkspaceState;
+/**
+ * Workspace reducer for Context API
+ * Handles all workspace state updates with proper immutability
+ */
+export declare const workspaceReducer: (state: WorkspaceState, action: WorkspaceAction) => WorkspaceState;

package/dist/types/contexts/types.d.ts

@@ -0,0 +1,74 @@
+import type { Dispatch } from 'react';
+import type { AuthSession, IAuthState } from '../providers/auth/types';
+import type { IOsState } from '../providers/os/types';
+import type { IWorkspace, IWorkspaceFeature } from '../providers/workspace/types';
+export type AuthAction = {
+    type: 'AUTHENTICATION_STARTED';
+} | {
+    type: 'AUTHENTICATION_FAILED';
+} | {
+    type: 'SET_SESSION';
+    payload: AuthSession;
+} | {
+    type: 'REMOVE_SESSION';
+};
+export interface AuthContextValue {
+    state: IAuthState;
+    dispatch: Dispatch<AuthAction>;
+}
+export type WorkspaceAction = {
+    type: 'SET_WORKSPACES';
+    payload: IWorkspace[];
+} | {
+    type: 'SET_ALL_FEATURES';
+    payload: IWorkspaceFeature[];
+} | {
+    type: 'SET_CURRENT_WORKSPACE';
+    payload: IWorkspace;
+} | {
+    type: 'RESET_CURRENT_WORKSPACE';
+} | {
+    type: 'SET_IS_INITIALIZED';
+    payload: boolean;
+} | {
+    type: 'SET_LOADING';
+    payload: boolean;
+} | {
+    type: 'SET_ERROR';
+    payload: string | null;
+} | {
+    type: 'SET_REFRESHING';
+    payload: boolean;
+} | {
+    type: 'SET_SWITCHING';
+    payload: boolean;
+};
+export interface WorkspaceState {
+    workspaces: IWorkspace[];
+    loading: boolean;
+    error: string | null;
+    currentWorkspace: IWorkspace | null;
+    refreshing: boolean;
+    switching: boolean;
+    isInitialized: boolean;
+    allFeatures: IWorkspaceFeature[];
+}
+export interface WorkspaceContextValue {
+    state: WorkspaceState;
+    dispatch: Dispatch<WorkspaceAction>;
+}
+export type OSAction = {
+    type: 'SET_SAAS_OS_CONFIG';
+    payload: IOsState;
+} | {
+    type: 'REMOVE_SAAS_OS_CONFIG';
+};
+export interface OSContextValue {
+    state: IOsState;
+    dispatch: Dispatch<OSAction>;
+}
+export interface SDKContextValue {
+    auth: AuthContextValue;
+    workspace: WorkspaceContextValue;
+    os: OSContextValue;
+}