import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default, { ReactElement, ReactNode, Dispatch, SetStateAction, Component, JSX, ComponentPropsWithoutRef } from 'react';
import { j as RoleInterface, U as UserInterface, M as ModuleWithPermissions, A as Action, h as CompanyInterface, N as NotificationInterface } from '../notification.interface-DEW8hR8g.js';
import { a as ContentInterface } from '../content.interface-Czin-YRh.js';
import { PartialBlock } from '@blocknote/core';
import { D as DataListRetriever } from '../useDataListRetriever-BqJSFBck.js';
import { DateRange, DayPicker, DayButton } from 'react-day-picker';
import { DropzoneState, DropzoneOptions } from 'react-dropzone';
export { DropzoneOptions } from 'react-dropzone';
import * as react_hook_form from 'react-hook-form';
import { FieldValues, UseFormReturn, Path, ControllerRenderProps, ControllerFieldState } from 'react-hook-form';
import { F as FeatureInterface } from '../feature.interface-CIWxo8NP.js';
import { B as BreadcrumbItemData } from '../breadcrumb.item.data.interface-CgB4_1EE.js';
import { ColumnDef } from '@tanstack/react-table';
import { A as AuthComponent, P as PasskeyInterface, T as TotpAuthenticatorInterface } from '../AuthComponent-DCfP4o32.js';
export { a as getIcon, g as getIconByModule, b as getIconByModuleName } from '../AuthComponent-DCfP4o32.js';
import { J as JsonApiHydratedDataInterface } from '../ApiDataInterface-DPP8s46n.js';
import { b as AuthInterface } from '../auth.interface-C4kEZscm.js';
import { g as OnboardingCardRenderProps } from '../onboarding.interface-Djyl9qYu.js';
import { e as OAuthScopeInfo, O as OAuthClientInterface, b as OAuthClientCreateRequest, d as OAuthConsentRequest } from '../oauth.interface-vL7za9Bz.js';
import { Q as QuestionnaireField } from '../waitlist.config-kPfjImle.js';
import { Accordion as Accordion$1 } from '@base-ui/react/accordion';
import * as class_variance_authority_types from 'class-variance-authority/types';
import { VariantProps } from 'class-variance-authority';
import { AlertDialog as AlertDialog$1 } from '@base-ui/react/alert-dialog';
import { Button as Button$1 } from '@base-ui/react/button';
import { Avatar as Avatar$1 } from '@base-ui/react/avatar';
import { useRender } from '@base-ui/react/use-render';
import useEmblaCarousel, { UseEmblaCarouselType } from 'embla-carousel-react';
import * as RechartsPrimitive from 'recharts';
import { Checkbox as Checkbox$1 } from '@base-ui/react/checkbox';
import { Collapsible as Collapsible$1 } from '@base-ui/react/collapsible';
import { Command as Command$1 } from 'cmdk';
import { Dialog as Dialog$1 } from '@base-ui/react/dialog';
import { ContextMenu as ContextMenu$1 } from '@base-ui/react/context-menu';
import { Drawer as Drawer$1 } from 'vaul';
import { Menu } from '@base-ui/react/menu';
import { PreviewCard } from '@base-ui/react/preview-card';
import { OTPInput } from 'input-otp';
import { NavigationMenu as NavigationMenu$1 } from '@base-ui/react/navigation-menu';
import { Popover as Popover$1 } from '@base-ui/react/popover';
import { Progress as Progress$1 } from '@base-ui/react/progress';
import { Radio } from '@base-ui/react/radio';
import { RadioGroup as RadioGroup$1 } from '@base-ui/react/radio-group';
import * as ResizablePrimitive from 'react-resizable-panels';
import { ScrollArea as ScrollArea$1 } from '@base-ui/react/scroll-area';
import { Select as Select$1 } from '@base-ui/react/select';
import { Separator as Separator$1 } from '@base-ui/react/separator';
import { Tooltip as Tooltip$1 } from '@base-ui/react/tooltip';
import { Slider as Slider$1 } from '@base-ui/react/slider';
import { ToasterProps } from 'sonner';
import { Switch as Switch$1 } from '@base-ui/react/switch';
import { Tabs as Tabs$1 } from '@base-ui/react/tabs';
import { Toggle as Toggle$1 } from '@base-ui/react/toggle';
import { UniqueIdentifier, DndContextProps, DragEndEvent, DragOverlay } from '@dnd-kit/core';
import { SortableContextProps } from '@dnd-kit/sortable';
import 'lucide-react';
import '../ApiRequestDataTypeInterface-CYEcRUrh.js';

type AddUserToRoleProps = {
    role: RoleInterface;
    refresh: () => Promise<void>;
};
declare function AddUserToRole(props: AddUserToRoleProps): react_jsx_runtime.JSX.Element;

type UserAvatarEditorProps = {
    user?: UserInterface;
    file?: File | null;
    setFile: (file: File | null) => void;
    resetImage: boolean;
    setResetImage: (reset: boolean) => void;
};
declare function UserAvatarEditor({ user, file, setFile, resetImage, setResetImage }: UserAvatarEditorProps): react_jsx_runtime.JSX.Element;

type UserDeleterProps = {
    user: UserInterface;
    companyId?: string;
    onDeleted?: () => void;
};
declare function UserDeleter(props: UserDeleterProps): react_jsx_runtime.JSX.Element | null;

type UserEditorProps = {
    user?: UserInterface;
    propagateChanges?: (user: UserInterface) => void;
    adminCreated?: boolean;
    trigger?: React.ReactNode;
    onRevalidate?: (path: string) => Promise<void>;
};
declare function UserEditor(props: UserEditorProps): react_jsx_runtime.JSX.Element | null;

type UserMultiSelectProps = {
    id: string;
    form: any;
    currentUser?: UserInterface;
    label?: string;
    placeholder?: string;
    onChange?: (users?: UserInterface[]) => void;
    maxCount?: number;
    isRequired?: boolean;
};
declare function UserMultiSelect({ id, form, currentUser, label, placeholder, onChange, maxCount, isRequired, }: UserMultiSelectProps): react_jsx_runtime.JSX.Element;

type UserReactivatorProps = {
    user: UserInterface;
    propagateChanges: (user: UserInterface) => void;
};
declare function UserReactivator(props: UserReactivatorProps): react_jsx_runtime.JSX.Element | null;

type UserResentInvitationEmailProps = {
    user: UserInterface;
};
declare function UserResentInvitationEmail(props: UserResentInvitationEmailProps): react_jsx_runtime.JSX.Element | null;

type UserSelectorProps = {
    id: string;
    form: any;
    label?: string;
    placeholder?: string;
    onChange?: (user?: UserInterface) => void;
    isRequired?: boolean;
};
declare function UserSelector({ id, form, label, placeholder, onChange, isRequired }: UserSelectorProps): react_jsx_runtime.JSX.Element;

type PageContainerProps = {
    children: React.ReactNode;
    testId?: string;
    className?: string;
};
declare function PageContainer({ children, testId, className }: PageContainerProps): react_jsx_runtime.JSX.Element;

type ReactMarkdownContainerProps = {
    content: string;
    collapsible?: boolean;
    initialLines?: number;
    size?: "small" | "normal";
};
declare function ReactMarkdownContainer({ content, collapsible, initialLines, size, }: ReactMarkdownContainerProps): react_jsx_runtime.JSX.Element;

type Tab = {
    label: string;
    contentLabel?: React.ReactNode;
    content: React.ReactNode;
    modules?: ModuleWithPermissions[];
    action?: Action;
};
type TabsContainerProps = {
    tabs: Tab[];
    defaultTab?: string;
    tabsListClassName?: string;
    tabsTriggerClassName?: string;
    scrollAreaClassName?: string;
    style?: "navigation";
    additionalComponent?: React.ReactNode;
};
declare function TabsContainer({ tabs, defaultTab, tabsListClassName, tabsTriggerClassName, scrollAreaClassName, style, additionalComponent, }: TabsContainerProps): string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;

type AttributeElementProps = {
    inline?: boolean;
    title?: string | ReactElement<any>;
    value?: string | ReactElement<any>;
    className?: string;
};
declare function AttributeElement({ inline, title, value, className }: AttributeElementProps): react_jsx_runtime.JSX.Element;

type AllowedUsersDetailsProps = {
    showTitle?: boolean;
    content: ContentInterface;
};
declare function AllowedUsersDetails({ showTitle, content }: AllowedUsersDetailsProps): react_jsx_runtime.JSX.Element;

type BlockNoteEditorProps = {
    id: string;
    type: string;
    initialContent?: PartialBlock[];
    onChange?: (content: any, isEmpty: boolean, hasUnresolvedDiff: boolean) => void;
    size?: "sm" | "md";
    className?: string;
    markdownContent?: string;
    diffContent?: PartialBlock[];
    placeholder?: string;
    bordered?: boolean;
};

declare const BlockNoteEditorContainer: React__default.NamedExoticComponent<BlockNoteEditorProps>;

declare function ErrorDetails({ title, message, code }: {
    title?: string;
    message: string;
    code: number;
}): react_jsx_runtime.JSX.Element;

declare function errorToast(params: {
    title?: string;
    error: any;
}): void;

type CommonAssociationTriggerProps = {
    sourceType: string;
    destinationType: string;
    hasDestination?: boolean;
    onTrigger: () => void;
};
declare function CommonAssociationTrigger({ sourceType, destinationType, hasDestination, onTrigger, }: CommonAssociationTriggerProps): react_jsx_runtime.JSX.Element;
type CommonAssociationCommandDialogProps = {
    show: boolean;
    setShow: (show: boolean) => void;
    data: DataListRetriever<any>;
    source: string;
    destination: string;
    destinationName: string;
    children: ReactNode;
};
declare function CommonAssociationCommandDialog({ show, setShow, data, source, destination, destinationName, children, }: CommonAssociationCommandDialogProps): react_jsx_runtime.JSX.Element;
declare const triggerAssociationToast: (params: {
    t: any;
    source: string;
    destination: string;
    source_name: string;
    destination_name: string;
    level?: string;
}) => void;

type CommonDeleterProps = {
    type: string;
    deleteFunction: () => Promise<void>;
    redirectTo?: string;
    forceShow?: boolean;
    testId?: string;
};
declare function CommonDeleter({ deleteFunction, redirectTo, type, forceShow, testId }: CommonDeleterProps): react_jsx_runtime.JSX.Element;

type CommonEditorButtonsProps = {
    isEdit: boolean;
    form: any;
    disabled?: boolean;
    setOpen: (open: boolean) => void;
};
declare function CommonEditorButtons({ isEdit, form, disabled, setOpen }: CommonEditorButtonsProps): react_jsx_runtime.JSX.Element;

type CommonEditorHeaderProps = {
    type: string;
    name?: string;
};
declare function CommonEditorHeader({ type, name }: CommonEditorHeaderProps): react_jsx_runtime.JSX.Element;

type CommonEditorTriggerProps = {
    isEdit: boolean;
    edit?: string;
    create?: string;
    testId?: string;
};
declare function CommonEditorTrigger({ isEdit, edit: _edit, create, testId }: CommonEditorTriggerProps): react_jsx_runtime.JSX.Element;

type DatePickerPopoverProps = {
    children: ReactNode;
    value?: Date;
    onSelect: (date?: Date) => void;
    minDate?: Date;
    align?: "start" | "center" | "end";
    className?: string;
};
declare const DatePickerPopover: ({ children, value, onSelect, minDate, align, className, }: DatePickerPopoverProps) => react_jsx_runtime.JSX.Element;

type DateRangeSelectorProps = {
    onDateChange: (date?: DateRange) => void;
    avoidSettingDates?: boolean;
    showPreviousMonth?: boolean;
};
declare function DateRangeSelector({ onDateChange, avoidSettingDates, showPreviousMonth }: DateRangeSelectorProps): react_jsx_runtime.JSX.Element;

type DirectionOptions = "rtl" | "ltr" | undefined;
type FileUploaderContextType = {
    dropzoneState: DropzoneState;
    isLOF: boolean;
    isFileTooBig: boolean;
    removeFileFromSet: (index: number) => void;
    activeIndex: number;
    setActiveIndex: Dispatch<SetStateAction<number>>;
    orientation: "horizontal" | "vertical";
    direction: DirectionOptions;
};
declare const useFileUpload: () => FileUploaderContextType;
type FileUploaderProps = {
    value: File[] | null;
    reSelect?: boolean;
    onValueChange: (value: File[] | null) => void;
    dropzoneOptions: DropzoneOptions;
    orientation?: "horizontal" | "vertical";
};
declare const FileUploader: React$1.ForwardRefExoticComponent<FileUploaderProps & React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
declare const FileUploaderContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
declare const FileUploaderItem: React$1.ForwardRefExoticComponent<{
    index: number;
} & React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
declare const FileInput: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;

type FormCheckboxProps = {
    form: any;
    id: string;
    name: string;
    labelBefore?: boolean;
    description?: string;
    isRequired?: boolean;
};
declare function FormCheckbox({ form, id, name, labelBefore, description, isRequired }: FormCheckboxProps): react_jsx_runtime.JSX.Element;

type FormFieldWrapperProps<T extends FieldValues> = {
    form: UseFormReturn<T>;
    name: Path<T>;
    label?: string;
    description?: string;
    isRequired?: boolean;
    orientation?: "vertical" | "horizontal" | "responsive";
    children: (field: ControllerRenderProps<T, Path<T>>, fieldState: ControllerFieldState) => ReactNode;
    testId?: string;
};
declare function FormFieldWrapper<T extends FieldValues>({ form, name, label, description, isRequired, orientation, children, testId, }: FormFieldWrapperProps<T>): react_jsx_runtime.JSX.Element;

declare function FormDate({ form, id, name, minDate, onChange, isRequired, }: {
    form: any;
    id: string;
    name?: string;
    placeholder?: string;
    minDate?: Date;
    onChange?: (date?: Date) => Promise<void>;
    isRequired?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function FormDateTime({ form, id, name, minDate, onChange, allowEmpty, }: {
    form: any;
    id: string;
    name?: string;
    placeholder?: string;
    minDate?: Date;
    onChange?: (date?: Date) => Promise<void>;
    allowEmpty?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function FormInput({ form, id, name, placeholder, type, onBlur, disabled, onKeyDown, autoFocus, onChange, testId, isRequired, }: {
    form: any;
    id: string;
    name?: string;
    placeholder?: string;
    type?: "text" | "number" | "currency" | "password" | "link";
    onBlur?: () => Promise<void>;
    disabled?: boolean;
    onKeyDown?: (event: React__default.KeyboardEvent) => void;
    autoFocus?: boolean;
    onChange?: (value: string | number) => Promise<void>;
    testId?: string;
    isRequired?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function FormPassword({ form, id, name, placeholder, onBlur, disabled, testId, isRequired, }: {
    form: any;
    id: string;
    name?: string;
    placeholder?: string;
    onBlur?: () => Promise<void>;
    disabled?: boolean;
    testId?: string;
    isRequired?: boolean;
}): react_jsx_runtime.JSX.Element;

/**
 * FormPlaceAutocomplete component integrates Google Places API (New)
 * to provide address suggestions as the user types.
 *
 * Prerequisites:
 * 1. Set NEXT_PUBLIC_GOOGLE_MAPS_API_KEY environment variable
 * 2. Enable Places API (New) in Google Cloud Console
 * 3. Configure API key restrictions as needed
 *
 * Note: This uses the new Places API via REST calls, not the legacy JavaScript API
 */
interface PlaceSuggestion {
    place_id: string;
    description: string;
    structured_formatting: {
        main_text: string;
        secondary_text: string;
    };
}
interface PlaceAutocompleteProps {
    form: any;
    id: string;
    name?: string;
    placeholder?: string;
    disabled?: boolean;
    testId?: string;
    isRequired?: boolean;
    onPlaceSelect?: (place: PlaceSuggestion) => void;
    className?: string;
    /**
     * Optional array of place types to include in search results.
     * When not specified, defaults to address types: ["street_address", "premise", "subpremise"]
     * For cities, use: ["locality", "administrative_area_level_3"]
     * For regions, use: ["administrative_area_level_1", "administrative_area_level_2"]
     */
    includeTypes?: string[];
}
declare function FormPlaceAutocomplete({ form, id, name, placeholder, disabled, testId, isRequired, onPlaceSelect, className, includeTypes, }: PlaceAutocompleteProps): react_jsx_runtime.JSX.Element;

declare function FormSelect({ form, id, name, placeholder: _placeholder, disabled, values, onChange, useRows, testId, }: {
    form: any;
    id: string;
    name?: string;
    placeholder?: string;
    disabled?: boolean;
    values: {
        id: string;
        text: string;
    }[];
    onChange?: (value: string) => void;
    useRows?: boolean;
    testId?: string;
}): react_jsx_runtime.JSX.Element;

declare function FormSlider({ form, id, name, disabled, showPercentage, }: {
    form: any;
    id: string;
    name?: string;
    placeholder?: string;
    disabled?: boolean;
    showPercentage?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function FormSwitch({ form, id, name, disabled, description, }: {
    form: any;
    id: string;
    name?: string;
    disabled?: boolean;
    description?: string;
}): react_jsx_runtime.JSX.Element;

declare function FormTextarea({ form, id, name, className, placeholder, testId, }: {
    form: any;
    id: string;
    name: string;
    placeholder?: string;
    className?: string;
    testId?: string;
}): react_jsx_runtime.JSX.Element;

interface GdprConsentCheckboxProps<T extends FieldValues> {
    form: UseFormReturn<T>;
    id: Path<T>;
    label: ReactNode;
    description?: string;
    required?: boolean;
}
declare function GdprConsentCheckbox<T extends FieldValues>({ form, id, label, description, required, }: GdprConsentCheckboxProps<T>): react_jsx_runtime.JSX.Element;

interface PasswordInputProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
}
declare const PasswordInput: React$1.ForwardRefExoticComponent<PasswordInputProps & React$1.RefAttributes<HTMLInputElement>>;

type FormFeaturesProps = {
    form: any;
    name?: string;
    features: FeatureInterface[];
    featureField?: string;
};
declare function FormFeatures({ form, name, features, featureField }: FormFeaturesProps): react_jsx_runtime.JSX.Element;

type BreadcrumbProps = {
    items: BreadcrumbItemData[];
};
declare function BreadcrumbNavigation({ items }: BreadcrumbProps): react_jsx_runtime.JSX.Element;

type TitleProps = {
    type?: string | string[];
    element?: string;
    functions?: ReactNode;
    className?: string;
    module?: ModuleWithPermissions;
    prioritizeFunctions?: boolean;
};
declare function ContentTitle({ module, type, element, functions, className, prioritizeFunctions }: TitleProps): react_jsx_runtime.JSX.Element | null;

type HeaderProps = {
    children?: React.ReactNode;
};
declare function Header({ children }: HeaderProps): react_jsx_runtime.JSX.Element;

declare function ModeToggleSwitch(): react_jsx_runtime.JSX.Element;

type PageSectionProps = {
    children: ReactNode;
    title?: string;
    options?: ReactNode[];
    open?: boolean;
    small?: boolean;
    onToggle?: (isOpen: boolean) => void;
};
declare function PageSection({ children, title, options, open, small, onToggle }: PageSectionProps): react_jsx_runtime.JSX.Element;

declare function RecentPagesNavigator(): react_jsx_runtime.JSX.Element | null;

type PageContainerItems = {
    title: string;
    content: ReactNode;
};
type PageContainerContentDetailsProps = {
    items: PageContainerItems[];
    section?: string;
    module: ModuleWithPermissions;
    id: string;
};
declare function PageContainerContentDetails({ items, section, module, id }: PageContainerContentDetailsProps): react_jsx_runtime.JSX.Element;

type PageContentContainerProps = {
    header?: ReactNode;
    details?: ReactNode;
    footer?: ReactNode;
    content?: ReactNode;
    fullBleed?: boolean;
};
declare function PageContentContainer({ header, details, footer, content, fullBleed }: PageContentContainerProps): react_jsx_runtime.JSX.Element;

declare const cellComponent: (params: {
    id: string;
    name: string;
    title: string;
    component: React__default.ReactNode;
}) => ColumnDef<any>;

declare const cellDate: (params: {
    name: string;
    title: string;
}) => ColumnDef<any>;

declare const cellId: (params: {
    name: string;
    checkedIds?: string[];
    toggleId?: (id: string) => void;
}) => ColumnDef<any>;

declare const cellLink: <T>(params: {
    id: string;
    name: string;
    title: string;
    generateUrl: (id: string) => string;
}) => ColumnDef<T>;

declare const cellUrl: (params: {
    name: string;
    title: string;
}) => ColumnDef<any>;

type GenerateTableStructureParams = {
    data: any[];
    toggleValueToFormIdsId: (id: string, name: string) => void;
    isSelected: (id: string) => boolean;
};
type ContentListTableProps = {
    title?: string;
    data: DataListRetriever<any>;
    tableGenerator?: never;
    tableGeneratorType: ModuleWithPermissions;
    fields: any[];
    checkedIds?: string[];
    toggleId?: (id: string) => void;
    functions?: ReactNode;
    filters?: ReactNode;
    allowSearch?: boolean;
    context?: Record<string, any>;
};
declare const ContentListTable: React$1.NamedExoticComponent<ContentListTableProps>;

type ContentTableSearchProps = {
    data: DataListRetriever<any>;
};
declare function ContentTableSearch({ data }: ContentTableSearchProps): react_jsx_runtime.JSX.Element;

type AuthContainerProps = {
    componentType: AuthComponent;
    params?: {
        code?: string;
    };
};
declare function AuthContainer({ componentType, params }: AuthContainerProps): react_jsx_runtime.JSX.Element;

declare function SecurityContainer(): react_jsx_runtime.JSX.Element;

declare function LandingComponent(): react_jsx_runtime.JSX.Element;

declare function AcceptInvitation(): react_jsx_runtime.JSX.Element;

declare function ActivateAccount(): react_jsx_runtime.JSX.Element;

declare function Cookies({ dehydratedAuth, page }: {
    dehydratedAuth: JsonApiHydratedDataInterface;
    page?: string;
}): null;

declare function ForgotPassword(): react_jsx_runtime.JSX.Element;

declare function Login(): react_jsx_runtime.JSX.Element;

interface LogoutProps {
    storageKeys?: string[];
}
declare function Logout({ storageKeys }: LogoutProps): react_jsx_runtime.JSX.Element;

declare function RefreshUser(): null;

declare function ResetPassword(): react_jsx_runtime.JSX.Element;

declare function TwoFactorChallenge(): react_jsx_runtime.JSX.Element | null;

interface GdprConsentSectionProps<T extends FieldValues> {
    form: UseFormReturn<T>;
    termsCheckboxId?: Path<T>;
    marketingCheckboxId?: Path<T>;
}
declare function GdprConsentSection<T extends FieldValues>({ form, termsCheckboxId, marketingCheckboxId, }: GdprConsentSectionProps<T>): react_jsx_runtime.JSX.Element;

interface PasskeySetupDialogProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    onSuccess: () => void;
}
declare function PasskeySetupDialog({ open, onOpenChange, onSuccess }: PasskeySetupDialogProps): react_jsx_runtime.JSX.Element;

interface PasskeyListProps {
    passkeys: PasskeyInterface[];
    onRefresh: () => void;
}
declare function PasskeyList({ passkeys, onRefresh }: PasskeyListProps): react_jsx_runtime.JSX.Element;

interface TotpInputProps {
    onComplete: (code: string) => void;
    disabled?: boolean;
    autoFocus?: boolean;
    error?: string;
}
declare function TotpInput({ onComplete, disabled, autoFocus, error }: TotpInputProps): react_jsx_runtime.JSX.Element;

interface PasskeyButtonProps {
    pendingToken: string;
    onSuccess: (auth: AuthInterface) => void;
    onError: (error: Error) => void;
    disabled?: boolean;
}
declare function PasskeyButton({ pendingToken, onSuccess, onError, disabled }: PasskeyButtonProps): react_jsx_runtime.JSX.Element;

interface BackupCodesDialogProps {
    remainingCodes: number;
    onRegenerate: () => void;
    trigger?: React.ReactElement;
}
declare function BackupCodesDialog({ remainingCodes, onRegenerate, trigger }: BackupCodesDialogProps): react_jsx_runtime.JSX.Element;

interface DisableTwoFactorDialogProps {
    onSuccess: () => void;
    trigger?: React.ReactElement;
}
declare function DisableTwoFactorDialog({ onSuccess, trigger }: DisableTwoFactorDialogProps): react_jsx_runtime.JSX.Element;

interface TotpSetupDialogProps {
    onSuccess: () => void;
    trigger?: React.ReactElement;
}
declare function TotpSetupDialog({ onSuccess, trigger }: TotpSetupDialogProps): react_jsx_runtime.JSX.Element;

interface TotpAuthenticatorListProps {
    authenticators: TotpAuthenticatorInterface[];
    onDelete: () => void;
}
declare function TotpAuthenticatorList({ authenticators, onDelete }: TotpAuthenticatorListProps): react_jsx_runtime.JSX.Element;

declare function TwoFactorSettings(): react_jsx_runtime.JSX.Element;

declare function AdminCompanyContainer(): react_jsx_runtime.JSX.Element;

declare function CompanyContainer(): react_jsx_runtime.JSX.Element | null;

declare function CompanyDetails(): react_jsx_runtime.JSX.Element | null;

interface TokenStatusIndicatorProps {
    className?: string;
    size?: "sm" | "md" | "lg";
    showExtraPages?: boolean;
}
/**
 * TokenStatusIndicator displays the current status of available monthly and extra pages
 * using battery icons to represent the percentage of monthly pages remaining.
 *
 * Battery levels:
 * - BatteryFull: >75% available
 * - BatteryMedium: 25-75% available
 * - BatteryLow: 5-25% available
 * - Battery (empty): <5% available
 */
declare function TokenStatusIndicator({ className, size, showExtraPages }: TokenStatusIndicatorProps): react_jsx_runtime.JSX.Element | null;

type CompanyConfigurationEditorProps = {
    company: CompanyInterface;
};
declare function CompanyConfigurationEditor(props: CompanyConfigurationEditorProps): react_jsx_runtime.JSX.Element;

type SecurityConfigurationFormProps = {
    form: UseFormReturn<any>;
};
declare function CompanyConfigurationSecurityForm({ form }: SecurityConfigurationFormProps): react_jsx_runtime.JSX.Element;

type CompanyDeleterProps = {
    company: CompanyInterface;
};
declare function CompanyDeleter({ company }: CompanyDeleterProps): react_jsx_runtime.JSX.Element | null;

type CompanyEditorProps = {
    company?: CompanyInterface;
    propagateChanges?: (company: CompanyInterface) => void;
    onRevalidate?: (path: string) => Promise<void>;
};
declare function CompanyEditor(props: CompanyEditorProps): react_jsx_runtime.JSX.Element;

declare function CompaniesList(): react_jsx_runtime.JSX.Element;

type ContentsListProps = {
    contentList: ContentInterface[];
};
declare function ContentsList({ contentList }: ContentsListProps): react_jsx_runtime.JSX.Element;

type ContentsListByIdProps = {
    contentIds: string[];
};
declare function ContentsListById({ contentIds }: ContentsListByIdProps): react_jsx_runtime.JSX.Element;

type RelevantContentsListProps = {
    id: string;
};
declare function RelevantContentsList({ id }: RelevantContentsListProps): react_jsx_runtime.JSX.Element;

interface Props$1 {
    children: ReactNode;
    fallback?: ReactNode;
}
interface State {
    hasError: boolean;
    error?: Error;
}
declare class NotificationErrorBoundary extends Component<Props$1, State> {
    constructor(props: Props$1);
    static getDerivedStateFromError(error: Error): State;
    componentDidCatch(error: Error, errorInfo: React__default.ErrorInfo): void;
    render(): string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
}

declare function NotificationsListContainer(): react_jsx_runtime.JSX.Element;

type NotificationsListProps = {
    archived: boolean;
};
declare function NotificationsList({ archived }: NotificationsListProps): react_jsx_runtime.JSX.Element;

interface NotificationModalProps {
    isOpen: boolean;
    setIsOpen: (open: boolean) => void;
}
declare function NotificationModal(props: NotificationModalProps): react_jsx_runtime.JSX.Element;

type TaskCommentedOnProps = {
    notification: NotificationInterface;
    closePopover: () => void;
};
declare const generateNotificationData: (params: {
    notification: NotificationInterface;
    generateUrl: any;
}) => {
    title: string;
    actor?: UserInterface;
    url?: string;
    taskId?: string;
};
declare function NotificationToast(notification: NotificationInterface, t: any, generateUrl: any, reouter: any): {
    title: string;
    description: string | ReactElement<any>;
    action?: {
        label: string;
        onClick: () => void;
    };
};
declare function NotificationMenuItem({ notification, closePopover }: TaskCommentedOnProps): react_jsx_runtime.JSX.Element;

declare function PushNotificationProvider({ children }: {
    children: ReactNode;
}): JSX.Element;

declare function OnboardingCard({ step, currentIndex, totalSteps, labels, onNext, onPrevious, onClose, isFirst, isLast, }: OnboardingCardRenderProps): react_jsx_runtime.JSX.Element;

/**
 * ReferralCodeCapture captures referral codes from URL parameters.
 *
 * Behavior:
 * - Checks if referral feature is enabled before processing
 * - Reads the configured query param (default "ref") from the URL
 * - Checks if a referral cookie already exists
 * - If ref param is present AND no existing cookie, sets the cookie (first referrer wins)
 * - Renders nothing (null) - component only captures the code
 */
declare function ReferralCodeCapture(): null;

/**
 * Translation strings for the ReferralWidget component.
 * All strings are optional and have defaults.
 */
interface ReferralWidgetTranslations {
    /** Widget title */
    title?: string;
    /** Widget description */
    description?: string;
    /** Label for the referral link field */
    yourLink?: string;
    /** Copy button label (for screen readers) */
    copyButton?: string;
    /** Toast message when link is copied */
    copiedMessage?: string;
    /** Stats section label */
    statsLabel?: string;
    /** Completed referrals label */
    completedLabel?: string;
    /** Tokens earned label */
    tokensLabel?: string;
    /** Email invite section title */
    inviteTitle?: string;
    /** Email invite description */
    inviteDescription?: string;
    /** Email input placeholder */
    emailPlaceholder?: string;
    /** Send button label */
    sendButton?: string;
    /** Sending button label (while in progress) */
    sendingButton?: string;
    /** Toast message when invite is sent */
    inviteSent?: string;
    /** Error message when invite fails */
    inviteError?: string;
    /** Error message when copy fails */
    copyError?: string;
    /** Error message for invalid email */
    invalidEmail?: string;
}
/**
 * Props for the ReferralWidget component.
 */
interface ReferralWidgetProps {
    /** Custom translations to override defaults */
    translations?: ReferralWidgetTranslations;
    /** Additional CSS class names */
    className?: string;
    /** Whether to render in dialog mode (no Card wrapper, no header) */
    isDialog?: boolean;
    /** Callback when the referral link is copied */
    onLinkCopied?: () => void;
    /** Callback when an invite is successfully sent */
    onInviteSent?: (email: string) => void;
    /** Callback when an invite fails to send */
    onInviteError?: (error: Error) => void;
}
/**
 * ReferralWidget displays referral information and allows users to share their referral link.
 *
 * Features:
 * - Shows user's unique referral link
 * - Copy-to-clipboard functionality
 * - Email invite form
 * - Referral stats display
 * - Feature flag awareness (renders null when disabled)
 * - Customizable translations
 * - Optional callback props for events
 *
 * @example
 * ```tsx
 * import { ReferralWidget } from "@carlonicora/nextjs-jsonapi/components";
 *
 * // Basic usage with defaults
 * <ReferralWidget />
 *
 * // With custom translations
 * <ReferralWidget
 *   translations={{
 *     title: t("referral.title"),
 *     description: t("referral.description"),
 *   }}
 *   onLinkCopied={() => analytics.track("referral_link_copied")}
 * />
 * ```
 */
declare function ReferralWidget({ translations, className, isDialog, onLinkCopied, onInviteSent, onInviteError, }: ReferralWidgetProps): react_jsx_runtime.JSX.Element | null;

/**
 * Translation strings for the ReferralDialog component.
 * Extends ReferralWidgetTranslations with dialog-specific strings.
 */
interface ReferralDialogTranslations extends ReferralWidgetTranslations {
    /** Dialog title */
    dialogTitle?: string;
    /** Dialog description */
    dialogDescription?: string;
}
/**
 * Props for the ReferralDialog component.
 */
interface ReferralDialogProps extends Omit<ReferralWidgetProps, "isDialog" | "translations"> {
    /** Whether the dialog is open */
    open: boolean;
    /** Callback when the dialog open state changes */
    onOpenChange: (open: boolean) => void;
    /** Custom translations to override defaults */
    translations?: ReferralDialogTranslations;
    /** Additional CSS class name for the dialog content */
    dialogClassName?: string;
}
/**
 * ReferralDialog displays the ReferralWidget in a modal dialog.
 *
 * Features:
 * - Feature flag awareness (renders null when disabled)
 * - Uses shadcn Dialog components
 * - Passes through all ReferralWidget props
 * - Customizable translations including dialog-specific text
 *
 * @example
 * ```tsx
 * import { ReferralDialog } from "@carlonicora/nextjs-jsonapi/components";
 *
 * // Basic usage
 * const [open, setOpen] = useState(false);
 * <ReferralDialog open={open} onOpenChange={setOpen} />
 *
 * // With custom translations
 * <ReferralDialog
 *   open={open}
 *   onOpenChange={setOpen}
 *   translations={{
 *     dialogTitle: t("referral.title"),
 *     dialogDescription: t("referral.description"),
 *     yourLink: t("referral.yourLink"),
 *   }}
 * />
 * ```
 */
declare function ReferralDialog({ open, onOpenChange, translations, dialogClassName, ...widgetProps }: ReferralDialogProps): react_jsx_runtime.JSX.Element | null;

declare function RoleContainer(): react_jsx_runtime.JSX.Element | null;

declare function RoleDetails(): react_jsx_runtime.JSX.Element | null;

type FormRolesProps = {
    form: any;
    id: string;
    name: string;
    roles: RoleInterface[];
};
declare function FormRoles({ form, id, name, roles }: FormRolesProps): react_jsx_runtime.JSX.Element;

type RemoveUserFromRoleProps = {
    user: UserInterface;
    role: RoleInterface;
    refresh: () => Promise<void>;
};
declare function RemoveUserFromRole({ role, user, refresh }: RemoveUserFromRoleProps): react_jsx_runtime.JSX.Element;

type UserRoleAddProps = {
    user: UserInterface;
    refresh: () => Promise<void>;
};
declare function UserRoleAdd({ user, refresh }: UserRoleAddProps): react_jsx_runtime.JSX.Element;

declare function RolesList(): react_jsx_runtime.JSX.Element;

type UserRolesListProps = {
    user: UserInterface;
};
declare function UserRolesList({ user }: UserRolesListProps): react_jsx_runtime.JSX.Element;

declare function UserContainer(): react_jsx_runtime.JSX.Element | null;

declare function UserIndexContainer(): react_jsx_runtime.JSX.Element | null;

declare function UsersListContainer(): react_jsx_runtime.JSX.Element;

type UserDetailsProps$1 = {
    user: UserInterface;
};
declare function UserDetails({ user }: UserDetailsProps$1): react_jsx_runtime.JSX.Element;

declare function UserIndexDetails(): react_jsx_runtime.JSX.Element | null;

type UserDetailsProps = {
    user: UserInterface;
};
declare function UserStanadaloneDetails({ user }: UserDetailsProps): react_jsx_runtime.JSX.Element;

declare function AdminUsersList(): react_jsx_runtime.JSX.Element | null;

type CompanyUsersListProps = {
    isDeleted?: boolean;
};
declare function CompanyUsersList({ isDeleted }: CompanyUsersListProps): react_jsx_runtime.JSX.Element;

type ContributorsListProps = {
    content: ContentInterface;
};
declare function ContributorsList({ content }: ContributorsListProps): react_jsx_runtime.JSX.Element;

type RelevantUsersListProps = {
    id: string;
};
declare function RelevantUsersList({ id }: RelevantUsersListProps): react_jsx_runtime.JSX.Element;

type RoleUsersListProps = {
    role: RoleInterface;
};
declare function RoleUsersList({ role }: RoleUsersListProps): react_jsx_runtime.JSX.Element;

type UserListInAddProps = {
    data: DataListRetriever<UserInterface>;
    existingUsers: UserInterface[] | null;
    setSelectedUser: (user: UserInterface) => void;
    setLevelOpen?: (open: boolean) => void;
};
declare function UserListInAdd({ data, existingUsers, setSelectedUser, setLevelOpen }: UserListInAddProps): react_jsx_runtime.JSX.Element;

type UsersListProps = {
    data: DataListRetriever<UserInterface>;
    optionComponents?: ReactElement<any>[];
    removeFunction?: (user: UserInterface) => Promise<void>;
    hideOptions?: boolean;
    showRelevance?: boolean;
    restrictToJoinRequests?: boolean;
};
declare function UsersList({ data, optionComponents: _optionComponents, removeFunction: _removeFunction, hideOptions: _hideOptions, showRelevance: _showRelevance, }: UsersListProps): react_jsx_runtime.JSX.Element;

type UsersListByContentIdsProps = {
    contentIds: string[];
};
declare function UsersListByContentIds({ contentIds }: UsersListByContentIdsProps): react_jsx_runtime.JSX.Element;

type UserAvatarProps = {
    user: UserInterface;
    className?: string;
    showFull?: boolean;
    showLink?: boolean;
    showTooltip?: boolean;
};
declare function UserAvatar({ user, className, showFull, showLink, showTooltip }: UserAvatarProps): react_jsx_runtime.JSX.Element;

interface OAuthRedirectUriInputProps {
    /** Current array of redirect URIs */
    value: string[];
    /** Called when URIs change */
    onChange: (uris: string[]) => void;
    /** Error message to display */
    error?: string;
    /** Whether input is disabled */
    disabled?: boolean;
    /** Label text */
    label?: string;
}
/**
 * Dynamic input for managing OAuth redirect URIs
 *
 * @example
 * ```tsx
 * const [redirectUris, setRedirectUris] = useState<string[]>(['']);
 *
 * <OAuthRedirectUriInput
 *   value={redirectUris}
 *   onChange={setRedirectUris}
 *   error={errors.redirectUris}
 * />
 * ```
 */
declare function OAuthRedirectUriInput({ value, onChange, error, disabled, label, }: OAuthRedirectUriInputProps): react_jsx_runtime.JSX.Element;

interface OAuthScopeSelectorProps {
    /** Currently selected scopes */
    value: string[];
    /** Called when selection changes */
    onChange: (scopes: string[]) => void;
    /** Available scopes to display (defaults to all) */
    availableScopes?: OAuthScopeInfo[];
    /** Whether selector is disabled */
    disabled?: boolean;
    /** Error message */
    error?: string;
    /** Label text */
    label?: string;
}
/**
 * Checkbox selector for OAuth scopes
 *
 * @example
 * ```tsx
 * const [scopes, setScopes] = useState<string[]>([]);
 *
 * <OAuthScopeSelector
 *   value={scopes}
 *   onChange={setScopes}
 *   error={errors.scopes}
 * />
 * ```
 */
declare function OAuthScopeSelector({ value, onChange, availableScopes, disabled, error, label, }: OAuthScopeSelectorProps): react_jsx_runtime.JSX.Element;

interface OAuthClientSecretDisplayProps {
    /** The client secret to display */
    secret: string;
    /** Called when user dismisses the dialog */
    onDismiss: () => void;
    /** Whether the dialog is open */
    open: boolean;
    /** Optional client name for context */
    clientName?: string;
}
/**
 * Modal dialog for displaying a client secret ONE TIME
 * Shows warning that secret cannot be retrieved again
 *
 * @example
 * ```tsx
 * const [secret, setSecret] = useAtom(oauthNewClientSecretAtom);
 *
 * <OAuthClientSecretDisplay
 *   secret={secret || ''}
 *   open={!!secret}
 *   onDismiss={() => setSecret(null)}
 * />
 * ```
 */
declare function OAuthClientSecretDisplay({ secret, onDismiss, open, clientName }: OAuthClientSecretDisplayProps): react_jsx_runtime.JSX.Element;

interface OAuthClientCardProps {
    /** The OAuth client to display */
    client: OAuthClientInterface;
    /** Called when card is clicked */
    onClick?: () => void;
    /** Called when edit is clicked */
    onEdit?: () => void;
    /** Called when delete is clicked */
    onDelete?: () => void;
}
/**
 * Card component for displaying an OAuth client in a list
 */
declare function OAuthClientCard({ client, onClick, onEdit, onDelete }: OAuthClientCardProps): react_jsx_runtime.JSX.Element;

interface OAuthClientListProps {
    /** List of OAuth clients */
    clients: OAuthClientInterface[];
    /** Whether list is loading */
    isLoading?: boolean;
    /** Error to display */
    error?: Error | null;
    /** Called when a client is clicked */
    onClientClick?: (client: OAuthClientInterface) => void;
    /** Called when create button is clicked */
    onCreateClick?: () => void;
    /** Called when edit is clicked on a client */
    onEditClick?: (client: OAuthClientInterface) => void;
    /** Called when delete is clicked on a client */
    onDeleteClick?: (client: OAuthClientInterface) => void;
    /** Message to show when list is empty */
    emptyStateMessage?: string;
    /** Title for the list */
    title?: string;
}
/**
 * Component for displaying a list of OAuth clients
 */
declare function OAuthClientList({ clients, isLoading, error, onClientClick, onCreateClick, onEditClick, onDeleteClick, emptyStateMessage, title, }: OAuthClientListProps): react_jsx_runtime.JSX.Element;

interface OAuthClientFormProps {
    /** Existing client for edit mode (undefined = create mode) */
    client?: OAuthClientInterface;
    /** Called on form submit */
    onSubmit: (data: OAuthClientCreateRequest) => Promise<void>;
    /** Called on cancel */
    onCancel: () => void;
    /** Whether form is submitting */
    isLoading?: boolean;
}
/**
 * Form for creating or editing an OAuth client
 */
declare function OAuthClientForm({ client, onSubmit, onCancel, isLoading }: OAuthClientFormProps): react_jsx_runtime.JSX.Element;

interface OAuthClientDetailProps {
    /** The OAuth client to display */
    client: OAuthClientInterface;
    /** Whether data is loading */
    isLoading?: boolean;
    /** Called when edit is clicked */
    onEdit?: () => void;
    /** Called when delete is clicked */
    onDelete?: () => Promise<void>;
    /** Called when regenerate secret is clicked */
    onRegenerateSecret?: () => Promise<void>;
}
/**
 * Detailed view of an OAuth client
 */
declare function OAuthClientDetail({ client, isLoading, onEdit, onDelete, onRegenerateSecret, }: OAuthClientDetailProps): react_jsx_runtime.JSX.Element;

interface OAuthConsentHeaderProps {
    /** The requesting OAuth client */
    client: OAuthClientInterface;
    /** Optional logo URL override */
    logoUrl?: string;
    /** Application name (e.g., "Only35") */
    appName?: string;
}
/**
 * Header component for OAuth consent screen
 * Shows platform logo and requesting app information
 */
declare function OAuthConsentHeader({ client, logoUrl, appName }: OAuthConsentHeaderProps): react_jsx_runtime.JSX.Element;

interface OAuthScopeListProps {
    /** List of requested scopes */
    scopes: OAuthScopeInfo[];
}
/**
 * List of requested OAuth scopes for consent display
 */
declare function OAuthScopeList({ scopes }: OAuthScopeListProps): react_jsx_runtime.JSX.Element | null;

interface OAuthConsentActionsProps {
    /** Called when user clicks Authorize */
    onApprove: () => void;
    /** Called when user clicks Deny */
    onDeny: () => void;
    /** Whether an action is in progress */
    isLoading?: boolean;
}
/**
 * Action buttons for OAuth consent screen
 */
declare function OAuthConsentActions({ onApprove, onDeny, isLoading }: OAuthConsentActionsProps): react_jsx_runtime.JSX.Element;

interface OAuthConsentScreenProps {
    /** OAuth authorization parameters */
    params: OAuthConsentRequest;
    /** Optional platform logo URL */
    logoUrl?: string;
    /** Platform name */
    appName?: string;
    /** Terms of Service URL */
    termsUrl?: string;
    /** Privacy Policy URL */
    privacyUrl?: string;
}
/**
 * Main OAuth consent screen component
 * Displays client info, requested scopes, and approve/deny buttons
 *
 * @example
 * ```tsx
 * <OAuthConsentScreen
 *   params={{
 *     clientId: searchParams.client_id,
 *     redirectUri: searchParams.redirect_uri,
 *     scope: searchParams.scope,
 *     state: searchParams.state,
 *   }}
 * />
 * ```
 */
declare function OAuthConsentScreen({ params, logoUrl, appName, termsUrl, privacyUrl, }: OAuthConsentScreenProps): react_jsx_runtime.JSX.Element;

interface WaitlistFormProps {
    onSuccess?: () => void;
}
declare function WaitlistForm({ onSuccess }: WaitlistFormProps): react_jsx_runtime.JSX.Element;

interface WaitlistQuestionnaireRendererProps<T extends FieldValues> {
    form: UseFormReturn<T>;
    fields: QuestionnaireField[];
    fieldPrefix?: string;
}
declare function WaitlistQuestionnaireRenderer<T extends FieldValues>({ form, fields, fieldPrefix, }: WaitlistQuestionnaireRendererProps<T>): react_jsx_runtime.JSX.Element | null;

declare function WaitlistHeroSection(): react_jsx_runtime.JSX.Element;

declare function WaitlistSuccessState(): react_jsx_runtime.JSX.Element;

interface Props {
    code: string;
}
declare function WaitlistConfirmation({ code }: Props): react_jsx_runtime.JSX.Element;

declare function WaitlistList(): react_jsx_runtime.JSX.Element;

declare function Accordion({ className, ...props }: Accordion$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function AccordionItem({ className, ...props }: Accordion$1.Item.Props): react_jsx_runtime.JSX.Element;
declare function AccordionTrigger({ className, children, ...props }: Accordion$1.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function AccordionContent({ className, children, ...props }: Accordion$1.Panel.Props): react_jsx_runtime.JSX.Element;

declare const alertVariants: (props?: ({
    variant?: "default" | "destructive" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare function Alert({ className, variant, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof alertVariants>): react_jsx_runtime.JSX.Element;
declare function AlertTitle({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function AlertDescription({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function AlertAction({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;

declare const buttonVariants: (props?: ({
    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
    size?: "default" | "icon" | "xs" | "sm" | "lg" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare function Button({ className, variant, size, ...props }: Button$1.Props & VariantProps<typeof buttonVariants>): react_jsx_runtime.JSX.Element;

declare function AlertDialog({ ...props }: AlertDialog$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function AlertDialogTrigger({ ...props }: AlertDialog$1.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function AlertDialogPortal({ ...props }: AlertDialog$1.Portal.Props): react_jsx_runtime.JSX.Element;
declare function AlertDialogOverlay({ className, ...props }: AlertDialog$1.Backdrop.Props): react_jsx_runtime.JSX.Element;
declare function AlertDialogContent({ className, size, ...props }: AlertDialog$1.Popup.Props & {
    size?: "default" | "sm";
}): react_jsx_runtime.JSX.Element;
declare function AlertDialogHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function AlertDialogFooter({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function AlertDialogMedia({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function AlertDialogTitle({ className, ...props }: React$1.ComponentProps<typeof AlertDialog$1.Title>): react_jsx_runtime.JSX.Element;
declare function AlertDialogDescription({ className, ...props }: React$1.ComponentProps<typeof AlertDialog$1.Description>): react_jsx_runtime.JSX.Element;
declare function AlertDialogAction({ className, ...props }: React$1.ComponentProps<typeof Button>): react_jsx_runtime.JSX.Element;
declare function AlertDialogCancel({ className, variant, size, ...props }: AlertDialog$1.Close.Props & Pick<React$1.ComponentProps<typeof Button>, "variant" | "size">): react_jsx_runtime.JSX.Element;

declare function Avatar({ className, size, ...props }: Avatar$1.Root.Props & {
    size?: "default" | "sm" | "lg";
}): react_jsx_runtime.JSX.Element;
declare function AvatarImage({ className, ...props }: Avatar$1.Image.Props): react_jsx_runtime.JSX.Element;
declare function AvatarFallback({ className, ...props }: Avatar$1.Fallback.Props): react_jsx_runtime.JSX.Element;
declare function AvatarBadge({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
declare function AvatarGroup({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function AvatarGroupCount({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;

declare const badgeVariants: (props?: ({
    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare function Badge({ className, variant, render, ...props }: useRender.ComponentProps<"span"> & VariantProps<typeof badgeVariants>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;

declare function Breadcrumb({ className, ...props }: React$1.ComponentProps<"nav">): react_jsx_runtime.JSX.Element;
declare function BreadcrumbList({ className, ...props }: React$1.ComponentProps<"ol">): react_jsx_runtime.JSX.Element;
declare function BreadcrumbItem({ className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
declare function BreadcrumbLink({ className, render, ...props }: useRender.ComponentProps<"a">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
declare function BreadcrumbPage({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
declare function BreadcrumbSeparator({ children, className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
declare function BreadcrumbEllipsis({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;

declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, ...props }: React$1.ComponentProps<typeof DayPicker> & {
    buttonVariant?: React$1.ComponentProps<typeof Button>["variant"];
}): react_jsx_runtime.JSX.Element;
declare function CalendarDayButton({ className, day, modifiers, ...props }: React$1.ComponentProps<typeof DayButton>): react_jsx_runtime.JSX.Element;

declare function Card({ className, size, ...props }: React$1.ComponentProps<"div"> & {
    size?: "default" | "sm";
}): react_jsx_runtime.JSX.Element;
declare function CardHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function CardTitle({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function CardDescription({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function CardAction({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function CardContent({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function CardFooter({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;

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;
};
type CarouselContextProps = {
    carouselRef: ReturnType<typeof useEmblaCarousel>[0];
    api: ReturnType<typeof useEmblaCarousel>[1];
    scrollPrev: () => void;
    scrollNext: () => void;
    canScrollPrev: boolean;
    canScrollNext: boolean;
} & CarouselProps;
declare function useCarousel(): CarouselContextProps;
declare function Carousel({ orientation, opts, setApi, plugins, className, children, ...props }: React$1.ComponentProps<"div"> & CarouselProps): react_jsx_runtime.JSX.Element;
declare function CarouselContent({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function CarouselItem({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function CarouselPrevious({ className, variant, size, ...props }: React$1.ComponentProps<typeof Button>): react_jsx_runtime.JSX.Element;
declare function CarouselNext({ className, variant, size, ...props }: React$1.ComponentProps<typeof Button>): react_jsx_runtime.JSX.Element;

declare const THEMES: {
    readonly light: "";
    readonly dark: ".dark";
};
type PayloadItem = {
    dataKey?: string | number;
    name?: string;
    value?: string | number;
    type?: string;
    color?: string;
    payload?: Record<string, unknown> & {
        fill?: string;
    };
    fill?: string;
};
type ChartConfig = {
    [k in string]: {
        label?: React$1.ReactNode;
        icon?: React$1.ComponentType;
    } & ({
        color?: string;
        theme?: never;
    } | {
        color?: never;
        theme: Record<keyof typeof THEMES, string>;
    });
};
declare function ChartContainer({ id, className, children, config, ...props }: React$1.ComponentProps<"div"> & {
    config: ChartConfig;
    children: React$1.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
}): react_jsx_runtime.JSX.Element;
declare const ChartStyle: ({ id, config }: {
    id: string;
    config: ChartConfig;
}) => react_jsx_runtime.JSX.Element | null;
declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: React$1.ComponentProps<"div"> & {
    active?: boolean;
    payload?: PayloadItem[];
    label?: string | number;
    labelFormatter?: (label: unknown, payload: PayloadItem[]) => React$1.ReactNode;
    formatter?: (value: unknown, name: string, item: PayloadItem, index: number, payload: unknown) => React$1.ReactNode;
    hideLabel?: boolean;
    hideIndicator?: boolean;
    indicator?: "line" | "dot" | "dashed";
    nameKey?: string;
    labelKey?: string;
    labelClassName?: string;
    color?: string;
}): react_jsx_runtime.JSX.Element | null;
declare const ChartLegend: typeof RechartsPrimitive.Legend;
declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: React$1.ComponentProps<"div"> & {
    payload?: PayloadItem[];
    verticalAlign?: "top" | "bottom" | "middle";
    hideIcon?: boolean;
    nameKey?: string;
}): react_jsx_runtime.JSX.Element | null;

declare function Checkbox({ className, ...props }: Checkbox$1.Root.Props): react_jsx_runtime.JSX.Element;

declare function Collapsible({ ...props }: Collapsible$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function CollapsibleTrigger({ ...props }: Collapsible$1.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function CollapsibleContent({ ...props }: Collapsible$1.Panel.Props): react_jsx_runtime.JSX.Element;

declare function Dialog({ ...props }: Dialog$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function DialogTrigger({ ...props }: Dialog$1.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function DialogPortal({ ...props }: Dialog$1.Portal.Props): react_jsx_runtime.JSX.Element;
declare function DialogClose({ ...props }: Dialog$1.Close.Props): react_jsx_runtime.JSX.Element;
declare function DialogOverlay({ className, ...props }: Dialog$1.Backdrop.Props): react_jsx_runtime.JSX.Element;
declare function DialogContent({ className, children, showCloseButton, ...props }: Dialog$1.Popup.Props & {
    showCloseButton?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function DialogHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function DialogFooter({ className, showCloseButton, children, ...props }: React$1.ComponentProps<"div"> & {
    showCloseButton?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function DialogTitle({ className, ...props }: Dialog$1.Title.Props): react_jsx_runtime.JSX.Element;
declare function DialogDescription({ className, ...props }: Dialog$1.Description.Props): react_jsx_runtime.JSX.Element;

declare function Command({ className, ...props }: React$1.ComponentProps<typeof Command$1>): react_jsx_runtime.JSX.Element;
declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: Omit<React$1.ComponentProps<typeof Dialog>, "children"> & {
    title?: string;
    description?: string;
    className?: string;
    showCloseButton?: boolean;
    children: React$1.ReactNode;
}): react_jsx_runtime.JSX.Element;
declare function CommandInput({ className, ...props }: React$1.ComponentProps<typeof Command$1.Input>): react_jsx_runtime.JSX.Element;
declare function CommandList({ className, ...props }: React$1.ComponentProps<typeof Command$1.List>): react_jsx_runtime.JSX.Element;
declare function CommandEmpty({ className, ...props }: React$1.ComponentProps<typeof Command$1.Empty>): react_jsx_runtime.JSX.Element;
declare function CommandGroup({ className, ...props }: React$1.ComponentProps<typeof Command$1.Group>): react_jsx_runtime.JSX.Element;
declare function CommandSeparator({ className, ...props }: React$1.ComponentProps<typeof Command$1.Separator>): react_jsx_runtime.JSX.Element;
declare function CommandItem({ className, children, ...props }: React$1.ComponentProps<typeof Command$1.Item>): react_jsx_runtime.JSX.Element;
declare function CommandShortcut({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;

declare function ContextMenu({ ...props }: ContextMenu$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function ContextMenuPortal({ ...props }: ContextMenu$1.Portal.Props): react_jsx_runtime.JSX.Element;
declare function ContextMenuTrigger({ className, ...props }: ContextMenu$1.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function ContextMenuContent({ className, align, alignOffset, side, sideOffset, ...props }: ContextMenu$1.Popup.Props & Pick<ContextMenu$1.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): react_jsx_runtime.JSX.Element;
declare function ContextMenuGroup({ ...props }: ContextMenu$1.Group.Props): react_jsx_runtime.JSX.Element;
declare function ContextMenuLabel({ className, inset, ...props }: ContextMenu$1.GroupLabel.Props & {
    inset?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function ContextMenuItem({ className, inset, variant, ...props }: ContextMenu$1.Item.Props & {
    inset?: boolean;
    variant?: "default" | "destructive";
}): react_jsx_runtime.JSX.Element;
declare function ContextMenuSub({ ...props }: ContextMenu$1.SubmenuRoot.Props): react_jsx_runtime.JSX.Element;
declare function ContextMenuSubTrigger({ className, inset, children, ...props }: ContextMenu$1.SubmenuTrigger.Props & {
    inset?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function ContextMenuSubContent({ ...props }: React$1.ComponentProps<typeof ContextMenuContent>): react_jsx_runtime.JSX.Element;
declare function ContextMenuCheckboxItem({ className, children, checked, ...props }: ContextMenu$1.CheckboxItem.Props): react_jsx_runtime.JSX.Element;
declare function ContextMenuRadioGroup({ ...props }: ContextMenu$1.RadioGroup.Props): react_jsx_runtime.JSX.Element;
declare function ContextMenuRadioItem({ className, children, ...props }: ContextMenu$1.RadioItem.Props): react_jsx_runtime.JSX.Element;
declare function ContextMenuSeparator({ className, ...props }: ContextMenu$1.Separator.Props): react_jsx_runtime.JSX.Element;
declare function ContextMenuShortcut({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;

declare function Drawer({ ...props }: React$1.ComponentProps<typeof Drawer$1.Root>): react_jsx_runtime.JSX.Element;
declare function DrawerTrigger({ ...props }: React$1.ComponentProps<typeof Drawer$1.Trigger>): react_jsx_runtime.JSX.Element;
declare function DrawerPortal({ ...props }: React$1.ComponentProps<typeof Drawer$1.Portal>): react_jsx_runtime.JSX.Element;
declare function DrawerClose({ ...props }: React$1.ComponentProps<typeof Drawer$1.Close>): react_jsx_runtime.JSX.Element;
declare function DrawerOverlay({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Overlay>): react_jsx_runtime.JSX.Element;
declare function DrawerContent({ className, children, ...props }: React$1.ComponentProps<typeof Drawer$1.Content>): react_jsx_runtime.JSX.Element;
declare function DrawerHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function DrawerFooter({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function DrawerTitle({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Title>): react_jsx_runtime.JSX.Element;
declare function DrawerDescription({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Description>): react_jsx_runtime.JSX.Element;

declare function DropdownMenu({ ...props }: Menu.Root.Props): react_jsx_runtime.JSX.Element;
declare function DropdownMenuPortal({ ...props }: Menu.Portal.Props): react_jsx_runtime.JSX.Element;
declare function DropdownMenuTrigger({ ...props }: Menu.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function DropdownMenuContent({ align, alignOffset, side, sideOffset, className, ...props }: Menu.Popup.Props & Pick<Menu.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): react_jsx_runtime.JSX.Element;
declare function DropdownMenuGroup({ ...props }: Menu.Group.Props): react_jsx_runtime.JSX.Element;
declare function DropdownMenuLabel({ className, inset, ...props }: Menu.GroupLabel.Props & {
    inset?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function DropdownMenuItem({ className, inset, variant, ...props }: Menu.Item.Props & {
    inset?: boolean;
    variant?: "default" | "destructive";
}): react_jsx_runtime.JSX.Element;
declare function DropdownMenuSub({ ...props }: Menu.SubmenuRoot.Props): react_jsx_runtime.JSX.Element;
declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: Menu.SubmenuTrigger.Props & {
    inset?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function DropdownMenuSubContent({ align, alignOffset, side, sideOffset, className, ...props }: React$1.ComponentProps<typeof DropdownMenuContent>): react_jsx_runtime.JSX.Element;
declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: Menu.CheckboxItem.Props): react_jsx_runtime.JSX.Element;
declare function DropdownMenuRadioGroup({ ...props }: Menu.RadioGroup.Props): react_jsx_runtime.JSX.Element;
declare function DropdownMenuRadioItem({ className, children, ...props }: Menu.RadioItem.Props): react_jsx_runtime.JSX.Element;
declare function DropdownMenuSeparator({ className, ...props }: Menu.Separator.Props): react_jsx_runtime.JSX.Element;
declare function DropdownMenuShortcut({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;

declare function Label({ className, ...props }: React$1.ComponentProps<"label">): react_jsx_runtime.JSX.Element;

declare function FieldSet({ className, ...props }: React.ComponentProps<"fieldset">): react_jsx_runtime.JSX.Element;
declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<"legend"> & {
    variant?: "legend" | "label";
}): react_jsx_runtime.JSX.Element;
declare function FieldGroup({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare const fieldVariants: (props?: ({
    orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare function Field({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof fieldVariants>): react_jsx_runtime.JSX.Element;
declare function FieldContent({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): react_jsx_runtime.JSX.Element;
declare function FieldTitle({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function FieldDescription({ className, ...props }: React.ComponentProps<"p">): react_jsx_runtime.JSX.Element;
declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<"div"> & {
    children?: React.ReactNode;
}): react_jsx_runtime.JSX.Element;
declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<"div"> & {
    errors?: Array<{
        message?: string;
    } | undefined>;
}): react_jsx_runtime.JSX.Element | null;

/**
 * Form component is a wrapper around react-hook-form's FormProvider.
 * Use this to wrap your form and spread the form object into it.
 *
 * @example
 * const form = useForm<FormValues>();
 * return (
 *   <Form {...form}>
 *     <form onSubmit={form.handleSubmit(onSubmit)}>
 *       <FormInput form={form} id="email" name="Email" />
 *     </form>
 *   </Form>
 * );
 */
declare const Form: <TFieldValues extends react_hook_form.FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: react_hook_form.FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;

declare function HoverCard({ ...props }: PreviewCard.Root.Props): react_jsx_runtime.JSX.Element;
declare function HoverCardTrigger({ ...props }: PreviewCard.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function HoverCardContent({ className, side, sideOffset, align, alignOffset, ...props }: PreviewCard.Popup.Props & Pick<PreviewCard.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): react_jsx_runtime.JSX.Element;

declare function Input({ className, type, ...props }: React$1.ComponentProps<"input">): react_jsx_runtime.JSX.Element;

declare function InputGroup({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare const inputGroupAddonVariants: (props?: ({
    align?: "inline-start" | "inline-end" | "block-start" | "block-end" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare function InputGroupAddon({ className, align, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): react_jsx_runtime.JSX.Element;
declare const inputGroupButtonVariants: (props?: ({
    size?: "xs" | "sm" | "icon-xs" | "icon-sm" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React$1.ComponentProps<typeof Button>, "size" | "type"> & VariantProps<typeof inputGroupButtonVariants> & {
    type?: "button" | "submit" | "reset";
}): react_jsx_runtime.JSX.Element;
declare function InputGroupText({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
declare function InputGroupInput({ className, ...props }: React$1.ComponentProps<"input">): react_jsx_runtime.JSX.Element;
declare function InputGroupTextarea({ className, ...props }: React$1.ComponentProps<"textarea">): react_jsx_runtime.JSX.Element;

declare function InputOTP({ className, containerClassName, ...props }: React$1.ComponentProps<typeof OTPInput> & {
    containerClassName?: string;
}): react_jsx_runtime.JSX.Element;
declare function InputOTPGroup({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function InputOTPSlot({ index, className, ...props }: React$1.ComponentProps<"div"> & {
    index: number;
}): react_jsx_runtime.JSX.Element;
declare function InputOTPSeparator({ ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;

declare function NavigationMenu({ className, children, ...props }: ComponentPropsWithoutRef<typeof NavigationMenu$1.Root>): react_jsx_runtime.JSX.Element;
declare function NavigationMenuList({ className, ...props }: ComponentPropsWithoutRef<typeof NavigationMenu$1.List>): react_jsx_runtime.JSX.Element;
declare function NavigationMenuItem({ className, ...props }: ComponentPropsWithoutRef<typeof NavigationMenu$1.Item>): react_jsx_runtime.JSX.Element;
declare const navigationMenuTriggerStyle: (props?: class_variance_authority_types.ClassProp | undefined) => string;
declare function NavigationMenuTrigger({ className, children, ...props }: NavigationMenu$1.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function NavigationMenuContent({ className, ...props }: NavigationMenu$1.Content.Props): react_jsx_runtime.JSX.Element;
declare function NavigationMenuPositioner({ className, side, sideOffset, align, alignOffset, ...props }: NavigationMenu$1.Positioner.Props): react_jsx_runtime.JSX.Element;
declare function NavigationMenuLink({ className, ...props }: NavigationMenu$1.Link.Props): react_jsx_runtime.JSX.Element;
declare function NavigationMenuIndicator({ className, ...props }: ComponentPropsWithoutRef<typeof NavigationMenu$1.Icon>): react_jsx_runtime.JSX.Element;

declare function Popover({ ...props }: Popover$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function PopoverTrigger({ ...props }: Popover$1.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function PopoverContent({ className, align, alignOffset, side, sideOffset, ...props }: Popover$1.Popup.Props & Pick<Popover$1.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): react_jsx_runtime.JSX.Element;
declare function PopoverHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function PopoverTitle({ className, ...props }: Popover$1.Title.Props): react_jsx_runtime.JSX.Element;
declare function PopoverDescription({ className, ...props }: Popover$1.Description.Props): react_jsx_runtime.JSX.Element;

declare function Progress({ className, children, value, ...props }: Progress$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function ProgressTrack({ className, ...props }: Progress$1.Track.Props): react_jsx_runtime.JSX.Element;
declare function ProgressIndicator({ className, ...props }: Progress$1.Indicator.Props): react_jsx_runtime.JSX.Element;
declare function ProgressLabel({ className, ...props }: Progress$1.Label.Props): react_jsx_runtime.JSX.Element;
declare function ProgressValue({ className, ...props }: Progress$1.Value.Props): react_jsx_runtime.JSX.Element;

declare function RadioGroup({ className, ...props }: RadioGroup$1.Props): react_jsx_runtime.JSX.Element;
declare function RadioGroupItem({ className, ...props }: Radio.Root.Props): react_jsx_runtime.JSX.Element;

declare function ResizablePanelGroup({ className, ...props }: React$1.ComponentProps<typeof ResizablePrimitive.Group>): react_jsx_runtime.JSX.Element;
declare function ResizablePanel({ ...props }: React$1.ComponentProps<typeof ResizablePrimitive.Panel>): react_jsx_runtime.JSX.Element;
declare function ResizableHandle({ withHandle, className, ...props }: React$1.ComponentProps<typeof ResizablePrimitive.Separator> & {
    withHandle?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ScrollArea({ className, children, ...props }: ScrollArea$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function ScrollBar({ className, orientation, ...props }: ScrollArea$1.Scrollbar.Props): react_jsx_runtime.JSX.Element;

declare const Select: typeof Select$1.Root;
declare function SelectGroup({ className, ...props }: Select$1.Group.Props): react_jsx_runtime.JSX.Element;
declare function SelectValue({ className, ...props }: Select$1.Value.Props): react_jsx_runtime.JSX.Element;
declare function SelectTrigger({ className, size, children, ...props }: Select$1.Trigger.Props & {
    size?: "sm" | "default";
}): react_jsx_runtime.JSX.Element;
declare function SelectContent({ className, children, side, sideOffset, align, alignOffset, alignItemWithTrigger, ...props }: Select$1.Popup.Props & Pick<Select$1.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset" | "alignItemWithTrigger">): react_jsx_runtime.JSX.Element;
declare function SelectLabel({ className, ...props }: Select$1.GroupLabel.Props): react_jsx_runtime.JSX.Element;
declare function SelectItem({ className, children, ...props }: Select$1.Item.Props): react_jsx_runtime.JSX.Element;
declare function SelectSeparator({ className, ...props }: Select$1.Separator.Props): react_jsx_runtime.JSX.Element;
declare function SelectScrollUpButton({ className, ...props }: React$1.ComponentProps<typeof Select$1.ScrollUpArrow>): react_jsx_runtime.JSX.Element;
declare function SelectScrollDownButton({ className, ...props }: React$1.ComponentProps<typeof Select$1.ScrollDownArrow>): react_jsx_runtime.JSX.Element;

declare function Separator({ className, orientation, ...props }: Separator$1.Props): react_jsx_runtime.JSX.Element;

declare function Sheet({ ...props }: Dialog$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function SheetTrigger({ ...props }: Dialog$1.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function SheetClose({ ...props }: Dialog$1.Close.Props): react_jsx_runtime.JSX.Element;
declare function SheetContent({ className, children, side, showCloseButton, ...props }: Dialog$1.Popup.Props & {
    side?: "top" | "right" | "bottom" | "left";
    showCloseButton?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function SheetHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function SheetFooter({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function SheetTitle({ className, ...props }: Dialog$1.Title.Props): react_jsx_runtime.JSX.Element;
declare function SheetDescription({ className, ...props }: Dialog$1.Description.Props): react_jsx_runtime.JSX.Element;

declare function TooltipProvider({ delay, ...props }: Tooltip$1.Provider.Props): react_jsx_runtime.JSX.Element;
declare function Tooltip({ ...props }: Tooltip$1.Root.Props): react_jsx_runtime.JSX.Element;
declare function TooltipTrigger({ ...props }: Tooltip$1.Trigger.Props): react_jsx_runtime.JSX.Element;
declare function TooltipContent({ className, side, sideOffset, align, alignOffset, children, ...props }: Tooltip$1.Popup.Props & Pick<Tooltip$1.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): react_jsx_runtime.JSX.Element;

type SidebarContextProps = {
    state: "expanded" | "collapsed";
    open: boolean;
    setOpen: (open: boolean) => void;
    openMobile: boolean;
    setOpenMobile: (open: boolean) => void;
    isMobile: boolean;
    toggleSidebar: () => void;
};
declare function useSidebar(): SidebarContextProps;
declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }: React$1.ComponentProps<"div"> & {
    defaultOpen?: boolean;
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
}): react_jsx_runtime.JSX.Element;
declare function Sidebar({ side, variant, collapsible, className, children, ...props }: React$1.ComponentProps<"div"> & {
    side?: "left" | "right";
    variant?: "sidebar" | "floating" | "inset";
    collapsible?: "offExamples" | "icon" | "none";
}): react_jsx_runtime.JSX.Element;
declare function SidebarTrigger({ className, onClick, ...props }: React$1.ComponentProps<typeof Button>): react_jsx_runtime.JSX.Element;
declare function SidebarRail({ className, ...props }: React$1.ComponentProps<"button">): react_jsx_runtime.JSX.Element;
declare function SidebarInset({ className, ...props }: React$1.ComponentProps<"main">): react_jsx_runtime.JSX.Element;
declare function SidebarInput({ className, ...props }: React$1.ComponentProps<typeof Input>): react_jsx_runtime.JSX.Element;
declare function SidebarHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function SidebarFooter({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function SidebarSeparator({ className, ...props }: React$1.ComponentProps<typeof Separator>): react_jsx_runtime.JSX.Element;
declare function SidebarContent({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function SidebarGroup({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function SidebarGroupLabel({ className, render, ...props }: useRender.ComponentProps<"div"> & React$1.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
declare function SidebarGroupAction({ className, render, ...props }: useRender.ComponentProps<"button"> & React$1.ComponentProps<"button">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
declare function SidebarGroupContent({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function SidebarMenu({ className, ...props }: React$1.ComponentProps<"ul">): react_jsx_runtime.JSX.Element;
declare function SidebarMenuItem({ className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
declare const sidebarMenuButtonVariants: (props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare function SidebarMenuButton({ render, isActive, variant, size, tooltip, className, ...props }: useRender.ComponentProps<"button"> & React$1.ComponentProps<"button"> & {
    isActive?: boolean;
    tooltip?: string | React$1.ComponentProps<typeof TooltipContent>;
} & VariantProps<typeof sidebarMenuButtonVariants>): react_jsx_runtime.JSX.Element;
declare function SidebarMenuAction({ className, render, showOnHover, ...props }: useRender.ComponentProps<"button"> & React$1.ComponentProps<"button"> & {
    showOnHover?: boolean;
}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
declare function SidebarMenuBadge({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React$1.ComponentProps<"div"> & {
    showIcon?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function SidebarMenuSub({ className, ...props }: React$1.ComponentProps<"ul">): react_jsx_runtime.JSX.Element;
declare function SidebarMenuSubItem({ className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
declare function SidebarMenuSubButton({ render, size, isActive, className, ...props }: useRender.ComponentProps<"a"> & React$1.ComponentProps<"a"> & {
    size?: "sm" | "md";
    isActive?: boolean;
}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;

declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;

declare function Slider({ className, defaultValue, value, min, max, ...props }: Slider$1.Root.Props): react_jsx_runtime.JSX.Element;

declare const Toaster: ({ ...props }: ToasterProps) => react_jsx_runtime.JSX.Element;

declare function Switch({ className, size, children, ...props }: Switch$1.Root.Props & {
    size?: "sm" | "default";
}): react_jsx_runtime.JSX.Element;

declare function Table({ className, ...props }: React$1.ComponentProps<"table">): react_jsx_runtime.JSX.Element;
declare function TableHeader({ className, ...props }: React$1.ComponentProps<"thead">): react_jsx_runtime.JSX.Element;
declare function TableBody({ className, ...props }: React$1.ComponentProps<"tbody">): react_jsx_runtime.JSX.Element;
declare function TableFooter({ className, ...props }: React$1.ComponentProps<"tfoot">): react_jsx_runtime.JSX.Element;
declare function TableRow({ className, ...props }: React$1.ComponentProps<"tr">): react_jsx_runtime.JSX.Element;
declare function TableHead({ className, ...props }: React$1.ComponentProps<"th">): react_jsx_runtime.JSX.Element;
declare function TableCell({ className, ...props }: React$1.ComponentProps<"td">): react_jsx_runtime.JSX.Element;
declare function TableCaption({ className, ...props }: React$1.ComponentProps<"caption">): react_jsx_runtime.JSX.Element;

declare function Tabs({ className, orientation, ...props }: Tabs$1.Root.Props): react_jsx_runtime.JSX.Element;
declare const tabsListVariants: (props?: ({
    variant?: "default" | "line" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare function TabsList({ className, variant, ...props }: Tabs$1.List.Props & VariantProps<typeof tabsListVariants>): react_jsx_runtime.JSX.Element;
declare function TabsTrigger({ className, ...props }: Tabs$1.Tab.Props): react_jsx_runtime.JSX.Element;
declare function TabsContent({ className, ...props }: Tabs$1.Panel.Props): react_jsx_runtime.JSX.Element;

declare function Textarea({ className, ...props }: React$1.ComponentProps<"textarea">): react_jsx_runtime.JSX.Element;

declare const toggleVariants: (props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare function Toggle({ className, variant, size, ...props }: Toggle$1.Props & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;

interface GetItemValue<T> {
    /**
     * Callback that returns a unique identifier for each kanban item. Required for array of objects.
     * @example getItemValue={(item) => item.id}
     */
    getItemValue: (item: T) => UniqueIdentifier;
}
type KanbanRootProps<T> = Omit<DndContextProps, "collisionDetection"> & GetItemValue<T> & {
    value: Record<UniqueIdentifier, T[]>;
    onValueChange?: (columns: Record<UniqueIdentifier, T[]>) => void;
    onMove?: (event: DragEndEvent & {
        activeIndex: number;
        overIndex: number;
    }) => void;
    strategy?: SortableContextProps["strategy"];
    orientation?: "horizontal" | "vertical";
    flatCursor?: boolean;
} & (T extends object ? GetItemValue<T> : Partial<GetItemValue<T>>);
declare function KanbanRoot<T>(props: KanbanRootProps<T>): react_jsx_runtime.JSX.Element;
interface KanbanBoardProps extends React$1.ComponentPropsWithoutRef<"div"> {
    children: React$1.ReactNode;
    asChild?: boolean;
}
declare const KanbanBoard: React$1.ForwardRefExoticComponent<KanbanBoardProps & React$1.RefAttributes<HTMLDivElement>>;
interface KanbanColumnProps extends React$1.ComponentPropsWithoutRef<"div"> {
    value: UniqueIdentifier;
    children: React$1.ReactNode;
    asChild?: boolean;
    asHandle?: boolean;
    disabled?: boolean;
}
declare const KanbanColumn: React$1.ForwardRefExoticComponent<KanbanColumnProps & React$1.RefAttributes<HTMLDivElement>>;
interface KanbanColumnHandleProps extends React$1.ComponentPropsWithoutRef<"button"> {
    asChild?: boolean;
}
declare const KanbanColumnHandle: React$1.ForwardRefExoticComponent<KanbanColumnHandleProps & React$1.RefAttributes<HTMLButtonElement>>;
interface KanbanItemProps extends React$1.ComponentPropsWithoutRef<"div"> {
    value: UniqueIdentifier;
    asHandle?: boolean;
    asChild?: boolean;
    disabled?: boolean;
}
declare const KanbanItem: React$1.ForwardRefExoticComponent<KanbanItemProps & React$1.RefAttributes<HTMLDivElement>>;
interface KanbanItemHandleProps extends React$1.ComponentPropsWithoutRef<"button"> {
    asChild?: boolean;
}
declare const KanbanItemHandle: React$1.ForwardRefExoticComponent<KanbanItemHandleProps & React$1.RefAttributes<HTMLButtonElement>>;
interface KanbanOverlayProps extends Omit<React$1.ComponentPropsWithoutRef<typeof DragOverlay>, "children"> {
    container?: Element | DocumentFragment | null;
    children?: ((params: {
        value: UniqueIdentifier;
        variant: "column" | "item";
    }) => React$1.ReactNode) | React$1.ReactNode;
}
declare function KanbanOverlay(props: KanbanOverlayProps): React$1.ReactPortal | null;

interface LinkProps {
    href: string;
    children: React$1.ReactNode;
    className?: string;
    [key: string]: any;
}
declare const Link: React$1.ForwardRefExoticComponent<Omit<LinkProps, "ref"> & React$1.RefAttributes<HTMLAnchorElement>>;

/**
 * Variants for the multi-select component to handle different styles.
 * Uses class-variance-authority (cva) to define different styles based on "variant" prop.
 */
declare const multiSelectVariants: (props?: ({
    variant?: "default" | "destructive" | "secondary" | "inverted" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
/**
 * Props for MultiSelect component
 */
interface MultiSelectProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof multiSelectVariants> {
    /**
     * An array of option objects to be displayed in the multi-select component.
     * Each option object has a label, value, and an optional icon.
     */
    options: {
        /** The text to display for the option. */
        label: string;
        /** The unique value associated with the option. */
        value: string;
        /** Optional icon component to display alongside the option. */
        icon?: React$1.ComponentType<{
            className?: string;
        }>;
    }[];
    /**
     * Callback function triggered when the selected values change.
     * Receives an array of the new selected values.
     */
    onValueChange: (value: string[]) => void;
    /** The default selected values when the component mounts. */
    defaultValue?: string[];
    /**
     * The controlled value for the component. When provided, the component
     * will be controlled rather than using internal state.
     */
    value?: string[];
    /**
     * Placeholder text to be displayed when no values are selected.
     * Optional, defaults to "Select options".
     */
    placeholder?: string;
    /**
     * Animation duration in seconds for the visual effects (e.g., bouncing badges).
     * Optional, defaults to 0 (no animation).
     */
    animation?: number;
    /**
     * Maximum number of items to display. Extra selected items will be summarized.
     * Optional, defaults to 3.
     */
    maxCount?: number;
    /**
     * The modality of the popover. When set to true, interaction with outside elements
     * will be disabled and only popover content will be visible to screen readers.
     * Optional, defaults to false.
     */
    modalPopover?: boolean;
    /**
     * Additional class names to apply custom styles to the multi-select component.
     * Optional, can be used to add custom styles.
     */
    className?: string;
    /**
     * Callback function triggered when the search input value changes.
     * Optional, receives the search string.
     */
    onSearchChange?: (search: string) => void;
    /**
     * Whether the component is in a loading state (e.g., during search).
     * Optional, defaults to false.
     */
    loading?: boolean;
    /**
     * Text to display when loading.
     * Optional, defaults to "Searching...".
     */
    loadingText?: string;
    /**
     * Text to display when no results are found.
     * Optional, defaults to "No results found.".
     */
    emptyText?: string;
}
declare const MultiSelect: React$1.ForwardRefExoticComponent<MultiSelectProps & React$1.RefAttributes<HTMLButtonElement>>;

export { AcceptInvitation, Accordion, AccordionContent, AccordionItem, AccordionTrigger, ActivateAccount, AddUserToRole, AdminCompanyContainer, AdminUsersList, Alert, AlertAction, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogMedia, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, AllowedUsersDetails, AttributeElement, AuthContainer, Avatar, AvatarBadge, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarImage, BackupCodesDialog, Badge, BlockNoteEditorContainer, KanbanBoard as Board, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbNavigation, BreadcrumbPage, BreadcrumbSeparator, Button, Calendar, CalendarDayButton, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, type ChartConfig, ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, Checkbox, Collapsible, CollapsibleContent, CollapsibleTrigger, KanbanColumn as Column, KanbanColumnHandle as ColumnHandle, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, CommonAssociationCommandDialog, CommonAssociationTrigger, CommonDeleter, CommonEditorButtons, CommonEditorHeader, CommonEditorTrigger, CompaniesList, CompanyConfigurationEditor, CompanyConfigurationSecurityForm, CompanyContainer, CompanyDeleter, CompanyDetails, CompanyEditor, CompanyUsersList, ContentListTable, ContentTableSearch, ContentTitle, ContentsList, ContentsListById, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, ContributorsList, Cookies, DatePickerPopover, DateRangeSelector, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DisableTwoFactorDialog, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, ErrorDetails, Field, FieldContent, FieldDescription, FieldError, FieldGroup, FieldLabel, FieldLegend, FieldSeparator, FieldSet, FieldTitle, FileInput, FileUploader, FileUploaderContent, FileUploaderItem, ForgotPassword, Form, FormCheckbox, FormDate, FormDateTime, FormFeatures, FormFieldWrapper, FormInput, FormPassword, FormPlaceAutocomplete, FormRoles, FormSelect, FormSlider, FormSwitch, FormTextarea, GdprConsentCheckbox, GdprConsentSection, type GenerateTableStructureParams, Header, HoverCard, HoverCardContent, HoverCardTrigger, Input, InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput, InputGroupText, InputGroupTextarea, InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, KanbanItem as Item, KanbanItemHandle as ItemHandle, KanbanRoot as Kanban, KanbanBoard, KanbanColumn, KanbanColumnHandle, KanbanItem, KanbanItemHandle, KanbanOverlay, Label, LandingComponent, Link, type LinkProps, Login, Logout, ModeToggleSwitch, MultiSelect, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuPositioner, NavigationMenuTrigger, NotificationErrorBoundary, NotificationMenuItem, NotificationModal, NotificationToast, NotificationsList, NotificationsListContainer, OAuthClientCard, type OAuthClientCardProps, OAuthClientDetail, type OAuthClientDetailProps, OAuthClientForm, type OAuthClientFormProps, OAuthClientList, type OAuthClientListProps, OAuthClientSecretDisplay, type OAuthClientSecretDisplayProps, OAuthConsentActions, type OAuthConsentActionsProps, OAuthConsentHeader, type OAuthConsentHeaderProps, OAuthConsentScreen, type OAuthConsentScreenProps, OAuthRedirectUriInput, type OAuthRedirectUriInputProps, OAuthScopeList, type OAuthScopeListProps, OAuthScopeSelector, type OAuthScopeSelectorProps, OnboardingCard, KanbanOverlay as Overlay, PageContainer, PageContainerContentDetails, type PageContainerItems, PageContentContainer, PageSection, PasskeyButton, PasskeyList, PasskeySetupDialog, PasswordInput, type PasswordInputProps, Popover, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, Progress, ProgressIndicator, ProgressLabel, ProgressTrack, ProgressValue, PushNotificationProvider, RadioGroup, RadioGroupItem, ReactMarkdownContainer, RecentPagesNavigator, ReferralCodeCapture, ReferralDialog, type ReferralDialogProps, type ReferralDialogTranslations, ReferralWidget, type ReferralWidgetProps, type ReferralWidgetTranslations, RefreshUser, RelevantContentsList, RelevantUsersList, RemoveUserFromRole, ResetPassword, ResizableHandle, ResizablePanel, ResizablePanelGroup, RoleContainer, RoleDetails, RoleUsersList, RolesList, KanbanRoot as Root, ScrollArea, ScrollBar, SecurityContainer, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, SheetTrigger, Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, Skeleton, Slider, Switch, type Tab, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContainer, TabsContent, TabsList, TabsTrigger, Textarea, Toaster, Toggle, TokenStatusIndicator, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, TotpAuthenticatorList, TotpInput, TotpSetupDialog, TwoFactorChallenge, TwoFactorSettings, UserAvatar, UserAvatarEditor, UserContainer, UserDeleter, UserDetails, UserEditor, UserIndexContainer, UserIndexDetails, UserListInAdd, UserMultiSelect, UserReactivator, UserResentInvitationEmail, UserRoleAdd, UserRolesList, UserSelector, UserStanadaloneDetails, UsersList, UsersListByContentIds, UsersListContainer, WaitlistConfirmation, WaitlistForm, WaitlistHeroSection, WaitlistList, WaitlistQuestionnaireRenderer, WaitlistSuccessState, badgeVariants, buttonVariants, cellComponent, cellDate, cellId, cellLink, cellUrl, errorToast, generateNotificationData, navigationMenuTriggerStyle, tabsListVariants, toggleVariants, triggerAssociationToast, useCarousel, useFileUpload, useSidebar };
