@buildbase/sdk 0.0.23 → 0.0.25

package/dist/types/components/subscription/index.d.ts

@@ -1,182 +0,0 @@
-interface IWhenSubscriptionProps {
-    /** Content to render when the condition is met (workspace has an active subscription). */
-    children: React.ReactNode;
-    /** Optional component/element to show while subscription is loading (e.g. <Skeleton />). */
-    loadingComponent?: React.ReactNode;
-    /** Optional component/element to show when condition is not met (e.g. <UpgradePrompt />). */
-    fallbackComponent?: React.ReactNode;
-}
-/**
- * Renders children only when the current workspace has an active subscription (any plan).
- * Optionally pass loadingComponent (while loading) or fallbackComponent (when not subscribed).
- * Must be used within SubscriptionContextProvider.
- *
- * @param props - Component props
- * @param props.children - Content to render when subscribed
- * @param props.loadingComponent - Optional component/element to show while loading
- * @param props.fallbackComponent - Optional component/element to show when not subscribed
- * @returns ReactNode - children when subscribed, loadingComponent when loading, fallbackComponent when not subscribed, or null
- *
- * @example
- * ```tsx
- * <WhenSubscription>
- *   <BillingSettings />
- * </WhenSubscription>
- * ```
- *
- * @example
- * ```tsx
- * <WhenSubscription
- *   loadingComponent={<Skeleton />}
- *   fallbackComponent={<UpgradePrompt />}
- * >
- *   <BillingSettings />
- * </WhenSubscription>
- * ```
- */
-export declare const WhenSubscription: {
-    (props: IWhenSubscriptionProps): import("react").ReactNode;
-    displayName: string;
-};
-/**
- * Renders children only when the current workspace has no subscription (or no current workspace).
- * Optionally pass loadingComponent (while loading) or fallbackComponent (when already subscribed).
- * Must be used within SubscriptionContextProvider.
- *
- * @param props - Component props
- * @param props.children - Content to render when not subscribed
- * @param props.loadingComponent - Optional component/element to show while loading
- * @param props.fallbackComponent - Optional component/element to show when already subscribed
- * @returns ReactNode - children when not subscribed, loadingComponent when loading, fallbackComponent when subscribed, or null
- *
- * @example
- * ```tsx
- * <WhenNoSubscription>
- *   <UpgradePrompt />
- * </WhenNoSubscription>
- * ```
- *
- * @example
- * ```tsx
- * <WhenNoSubscription
- *   loadingComponent={<Spinner />}
- *   fallbackComponent={null}
- * >
- *   <UpgradePrompt />
- * </WhenNoSubscription>
- * ```
- */
-export declare const WhenNoSubscription: {
-    (props: IWhenSubscriptionProps): import("react").ReactNode;
-    displayName: string;
-};
-interface IWhenSubscriptionToPlansProps {
-    /** Plan slugs to match (e.g. ['pro', 'enterprise']). Matching is case-insensitive. */
-    plans: string[];
-    /** Content to render when the workspace is on one of the given plans. */
-    children: React.ReactNode;
-    /** Optional component/element to show while subscription is loading (e.g. <Skeleton />). */
-    loadingComponent?: React.ReactNode;
-    /** Optional component/element to show when not on a matching plan (e.g. <UpgradeToPro />). */
-    fallbackComponent?: React.ReactNode;
-}
-/**
- * Renders children only when the current workspace is subscribed to one of the given plans.
- * Matches by plan slug only. Optionally pass loadingComponent (while loading) or fallbackComponent (when not on a matching plan).
- * Must be used within SubscriptionContextProvider.
- *
- * @param props - Component props
- * @param props.plans - Plan slugs to match (e.g. ['pro', 'enterprise'])
- * @param props.children - Content to render when on a matching plan
- * @param props.loadingComponent - Optional component/element to show while loading
- * @param props.fallbackComponent - Optional component/element to show when not on a matching plan
- * @returns ReactNode - children when on a matching plan, loadingComponent when loading, fallbackComponent when not matching, or null
- *
- * @example
- * ```tsx
- * <WhenSubscriptionToPlans plans={['pro', 'enterprise']}>
- *   <AdvancedAnalytics />
- * </WhenSubscriptionToPlans>
- * ```
- *
- * @example
- * ```tsx
- * <WhenSubscriptionToPlans
- *   plans={['pro', 'enterprise']}
- *   loadingComponent={<Skeleton />}
- *   fallbackComponent={<UpgradeToPro />}
- * >
- *   <AdvancedAnalytics />
- * </WhenSubscriptionToPlans>
- * ```
- */
-export declare const WhenSubscriptionToPlans: {
-    (props: IWhenSubscriptionToPlansProps): import("react").ReactNode;
-    displayName: string;
-};
-interface IWhenTrialingProps {
-    /** Content to render when the condition is met. */
-    children: React.ReactNode;
-    /** Optional component/element to show while subscription is loading. */
-    loadingComponent?: React.ReactNode;
-    /** Optional component/element to show when condition is not met. */
-    fallbackComponent?: React.ReactNode;
-}
-/**
- * Renders children only when the current workspace subscription is in trial (status === 'trialing').
- * Must be used within SubscriptionContextProvider.
- *
- * @example
- * ```tsx
- * <WhenTrialing fallbackComponent={<NormalContent />}>
- *   <TrialBanner />
- * </WhenTrialing>
- * ```
- */
-export declare const WhenTrialing: {
-    (props: IWhenTrialingProps): import("react").ReactNode;
-    displayName: string;
-};
-/**
- * Renders children only when the current workspace subscription is NOT in trial.
- * This includes: no subscription, active, canceled, past_due, etc.
- * Must be used within SubscriptionContextProvider.
- *
- * @example
- * ```tsx
- * <WhenNotTrialing>
- *   <RegularPricingPage />
- * </WhenNotTrialing>
- * ```
- */
-export declare const WhenNotTrialing: {
-    (props: IWhenTrialingProps): import("react").ReactNode;
-    displayName: string;
-};
-interface IWhenTrialEndingProps {
-    /** Content to render when trial is ending soon. */
-    children: React.ReactNode;
-    /** Optional component/element to show while subscription is loading. */
-    loadingComponent?: React.ReactNode;
-    /** Optional component/element to show when trial is not ending soon. */
-    fallbackComponent?: React.ReactNode;
-    /** Number of days threshold to consider "ending soon". Defaults to 3. */
-    daysThreshold?: number;
-}
-/**
- * Renders children only when the subscription is trialing AND the trial ends within
- * the given threshold (default 3 days). Useful for showing urgent upgrade prompts.
- * Must be used within SubscriptionContextProvider.
- *
- * @example
- * ```tsx
- * <WhenTrialEnding daysThreshold={5}>
- *   <UpgradeBanner />
- * </WhenTrialEnding>
- * ```
- */
-export declare const WhenTrialEnding: {
-    (props: IWhenTrialEndingProps): import("react").ReactNode;
-    displayName: string;
-};
-export {};

package/dist/types/components/ui/alert-dialog.d.ts

@@ -1,20 +0,0 @@
-import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
-import * as React from 'react';
-declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
-declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
-declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const AlertDialogHeader: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
-    displayName: string;
-};
-declare const AlertDialogFooter: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
-    displayName: string;
-};
-declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
-declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
-declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, };

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

@@ -1,6 +0,0 @@
-import * as AvatarPrimitive from '@radix-ui/react-avatar';
-import * as React from 'react';
-declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
-declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
-declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
-export { Avatar, AvatarFallback, AvatarImage };

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

@@ -1,18 +0,0 @@
-import { VariantProps } from 'class-variance-authority';
-import { LucideIcon } from 'lucide-react';
-import * as React from 'react';
-declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
-    withIcon?: boolean | null | undefined;
-    fullWidth?: boolean | 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> {
-    asChild?: boolean;
-    startIcon?: React.ReactElement<LucideIcon>;
-    endIcon?: React.ReactElement<LucideIcon>;
-    fullWidth?: boolean;
-    progress?: boolean;
-}
-declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
-export { Button, buttonVariants };

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

@@ -1,13 +0,0 @@
-export interface CommandSelectOption {
-    value: string;
-    label: string;
-    icon?: string;
-}
-export interface CommandSelectProps {
-    options: CommandSelectOption[];
-    value?: string;
-    onChange?: (value: string) => void;
-    placeholder?: string;
-    emptyLabel?: string;
-}
-export declare function CommandSelect({ options, value: valueProp, onChange, placeholder, emptyLabel, }: CommandSelectProps): import("react/jsx-runtime").JSX.Element;

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

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

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

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

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

@@ -1,23 +0,0 @@
-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/input.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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/popover.d.ts

@@ -1,6 +0,0 @@
-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/radio-group.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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/skeleton.d.ts

@@ -1,3 +0,0 @@
-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/switch.d.ts

@@ -1,4 +0,0 @@
-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/user/auth.d.ts

@@ -1,76 +0,0 @@
-interface IProps {
-    children: React.ReactNode;
-}
-/**
- * Conditional component that renders children only when user is authenticated.
- * Returns null if user is not authenticated or authentication status is still loading.
- *
- * @param props - Component props
- * @param props.children - Content to render when authenticated
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <SaaSOSProvider {...config}>
- *       <WhenAuthenticated>
- *         <Dashboard />
- *       </WhenAuthenticated>
- *       <WhenUnauthenticated>
- *         <LoginPage />
- *       </WhenUnauthenticated>
- *     </SaaSOSProvider>
- *   );
- * }
- * ```
- */
-export declare const WhenAuthenticated: {
-    (props: IProps): import("react").ReactNode;
-    displayName: string;
-};
-/**
- * Conditional component that renders children only when user is NOT authenticated.
- * Returns null if user is authenticated.
- * Note: Also renders during loading/redirecting states (when not yet authenticated).
- *
- * @param props - Component props
- * @param props.children - Content to render when unauthenticated
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <SaaSOSProvider {...config}>
- *       <WhenUnauthenticated>
- *         <LoginPage />
- *       </WhenUnauthenticated>
- *       <WhenAuthenticated>
- *         <Dashboard />
- *       </WhenAuthenticated>
- *     </SaaSOSProvider>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Handle loading state separately
- * function App() {
- *   const { isLoading } = useSaaSAuth();
- *
- *   if (isLoading) return <LoadingSpinner />;
- *
- *   return (
- *     <>
- *       <WhenUnauthenticated><LoginPage /></WhenUnauthenticated>
- *       <WhenAuthenticated><Dashboard /></WhenAuthenticated>
- *     </>
- *   );
- * }
- * ```
- */
-export declare const WhenUnauthenticated: {
-    (props: IProps): import("react").ReactNode;
-    displayName: string;
-};
-export {};

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

@@ -1,84 +0,0 @@
-interface IProps {
-    roles: string[];
-    children: React.ReactNode;
-    fallback?: React.ReactNode;
-}
-/**
- * Conditional component that renders children only when user has one of the specified roles.
- * Checks the user's global role (not workspace-specific).
- *
- * @param props - Component props
- * @param props.roles - Array of role strings to check against user's role
- * @param props.children - Content to render when user has matching role
- * @param props.fallback - Optional content to render when user doesn't have matching role (default: null)
- *
- * @example
- * ```tsx
- * function AdminPanel() {
- *   return (
- *     <WhenRoles roles={['admin', 'super-admin']}>
- *       <AdminContent />
- *     </WhenRoles>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // With fallback
- * function SettingsPage() {
- *   return (
- *     <WhenRoles
- *       roles={['admin']}
- *       fallback={<p>You don't have permission to access this page.</p>}
- *     >
- *       <AdminSettings />
- *     </WhenRoles>
- *   );
- * }
- * ```
- */
-export declare const WhenRoles: {
-    (props: IProps): import("react").ReactNode;
-    displayName: string;
-};
-/**
- * Conditional component that renders children only when user has one of the specified roles
- * in the current workspace. Checks workspace-specific role, not global role.
- *
- * @param props - Component props
- * @param props.roles - Array of role strings to check against user's workspace role
- * @param props.children - Content to render when user has matching workspace role
- * @param props.fallback - Optional content to render when user doesn't have matching role (default: null)
- *
- * @example
- * ```tsx
- * function WorkspaceSettings() {
- *   return (
- *     <WhenWorkspaceRoles roles={['owner', 'admin']}>
- *       <SettingsContent />
- *     </WhenWorkspaceRoles>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Edge case: User not in current workspace
- * function WorkspaceContent() {
- *   return (
- *     <WhenWorkspaceRoles
- *       roles={['member']}
- *       fallback={<p>You are not a member of this workspace.</p>}
- *     >
- *       <WorkspaceDashboard />
- *     </WhenWorkspaceRoles>
- *   );
- * }
- * ```
- */
-export declare const WhenWorkspaceRoles: {
-    (props: IProps): import("react").ReactNode;
-    displayName: string;
-};
-export {};

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

@@ -1,9 +0,0 @@
-import type { IAuthState } from '../../providers/auth/types';
-import type { AuthAction, AuthContextValue } from './types';
-export declare const AuthContextProvider: 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/AuthContext/actions.d.ts

@@ -1,12 +0,0 @@
-/**
- * Auth action creators
- */
-import type { AuthSession } from '../../providers/auth/types';
-import type { AuthAction } from './types';
-export declare const authActions: {
-    authenticationStarted: () => AuthAction;
-    authenticationProcessing: () => AuthAction;
-    authenticationFailed: () => AuthAction;
-    setSession: (session: AuthSession) => AuthAction;
-    removeSession: () => AuthAction;
-};

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

@@ -1,4 +0,0 @@
-export { authActions } from './actions';
-export { AuthContextProvider, useAuthContext, useAuthDispatch, useAuthSelector, useAuthState, } from './AuthContext';
-export { authReducer, getInitialAuthState } from './reducer';
-export type { AuthAction, AuthContextValue } from './types';

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

@@ -1,19 +0,0 @@
-import type { IAuthState } from '../../providers/auth/types';
-import type { AuthAction } from './types';
-/**
- * Initial state for auth context.
- *
- * UX flow:
- * 1. App loads → status: loading (user sees loading state).
- * 2. AuthProviderWrapper checks session in localStorage.
- * 3. No session → status: unauthenticated (show login).
- * 4. Has session → fetch profile; success → authenticated, failure → unauthenticated.
- *
- * Flags (isLoading, isAuthenticated, isRedirecting) are derived from status via getAuthFlags().
- */
-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;