@pushui/react 0.0.3

package/dist/index.d.ts

@@ -0,0 +1,1271 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ComponentPropsWithRef, ReactNode, ComponentProps, Ref, RefObject, CSSProperties, ElementType } from 'react';
+import { EmblaOptionsType } from 'embla-carousel';
+
+type AudioSource = {
+    src: string;
+    type: string;
+};
+type AudioTypes = Omit<ComponentPropsWithRef<'audio'>, 'src'> & {
+    /** Audio source URL (use sources for multiple formats) */
+    src?: string;
+    /** Multiple audio sources for browser compatibility */
+    sources?: AudioSource[];
+    /** Title displayed above the audio player */
+    title?: ReactNode;
+    /** Caption text displayed below the audio player */
+    caption?: ReactNode;
+    /** Link to transcript for accessibility */
+    transcriptUrl?: string;
+    /** Transcript link text */
+    transcriptLabel?: string;
+    /** Fallback content for unsupported browsers */
+    fallback?: ReactNode;
+    /** Fallback text for unsupported browsers */
+    fallbackText?: string;
+    /** Link text for audio fallback */
+    fallbackLinkText?: string;
+};
+
+declare function Audio({ ref, src, sources, title, caption, transcriptUrl, transcriptLabel, fallback, fallbackText, fallbackLinkText, className, controls, ...rest }: AudioTypes): react_jsx_runtime.JSX.Element;
+
+type ColorVariant = 'default' | 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info';
+type ActionAppearance = 'default' | 'underline' | 'outline' | 'button';
+type HorizontalAlign = 'left' | 'center' | 'right';
+type VerticalAlign = 'start' | 'center' | 'end';
+type FontSizes = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+
+type AvatarTypes = Omit<ComponentPropsWithRef<'div'>, 'children'> & {
+    src?: string;
+    alt?: string;
+    name?: string;
+    width?: string;
+    fontSize?: FontSizes;
+    variant?: ColorVariant;
+    defaultLabel?: string;
+};
+
+declare function Avatar({ ref, src, alt, name, width, fontSize, variant, defaultLabel, className, style, ...rest }: AvatarTypes): react_jsx_runtime.JSX.Element;
+
+type BadgeTypes = ComponentPropsWithRef<'div'> & {
+    variant?: ColorVariant;
+};
+
+declare function Badge({ ref, children, className, variant, ...rest }: BadgeTypes): react_jsx_runtime.JSX.Element;
+
+type BreadcrumbItemData = {
+    label: string;
+    href?: string;
+};
+type BreadcrumbTypes = ComponentPropsWithRef<'nav'> & {
+    items: BreadcrumbItemData[];
+    separator?: ReactNode;
+    renderLink?: (item: BreadcrumbItemData, children: ReactNode) => ReactNode;
+};
+
+declare function Breadcrumb({ ref, items, separator, renderLink, className, 'aria-label': ariaLabel, ...rest }: BreadcrumbTypes): react_jsx_runtime.JSX.Element;
+
+type DividerVariant = 'solid' | 'dashed' | 'dotted';
+type DividerSpacing = 1 | 2 | 3 | 4 | 5;
+type DividerTypes = ComponentPropsWithRef<'hr'> & {
+    /** Line style */
+    variant?: DividerVariant;
+    /** Vertical spacing */
+    spacing?: DividerSpacing;
+    /** Text to display in the middle of the divider */
+    children?: ReactNode;
+    /** weather a line is visible or not */
+    hidden?: boolean;
+};
+
+declare function Divider({ ref, variant, spacing, className, children, hidden, ...rest }: DividerTypes): react_jsx_runtime.JSX.Element;
+
+type IframeTypes = Omit<ComponentPropsWithRef<'iframe'>, 'title'> & {
+    /** Source URL */
+    src: string;
+    /** Title is required for accessibility */
+    title: string;
+    /** Allow fullscreen */
+    allowFullScreen?: boolean;
+};
+
+declare function Iframe({ ref, src, title, allowFullScreen, className, loading, ...rest }: IframeTypes): react_jsx_runtime.JSX.Element;
+
+type ImageTypes = Omit<ComponentPropsWithRef<'img'>, 'alt'> & {
+    alt: string;
+    caption?: ReactNode;
+    asChild?: boolean;
+};
+
+declare function Image({ ref, className, alt, caption, asChild, children, ...props }: ImageTypes): react_jsx_runtime.JSX.Element;
+
+type LayoutTypes = ComponentPropsWithRef<'div'>;
+
+declare function Layout({ ref, children, className, ...rest }: LayoutTypes): react_jsx_runtime.JSX.Element;
+
+/** @deprecated Use ActionAppearance instead */
+type LinkAppearance = ActionAppearance;
+type LinkTypes = ComponentPropsWithRef<'a'> & {
+    disabled?: boolean;
+    variant?: ColorVariant;
+    appearance?: ActionAppearance;
+    contrast?: boolean;
+    asChild?: boolean;
+};
+
+declare function Link({ ref, href, title, disabled, children, className, appearance, contrast, variant, asChild, ...rest }: LinkTypes): react_jsx_runtime.JSX.Element;
+
+type LogoTypes = ComponentPropsWithRef<'a'> & {
+    children: ReactNode;
+    asChild?: boolean;
+};
+type LogoFallbackTypes = ComponentPropsWithRef<'div'>;
+
+declare function Logo({ ref, children, className, asChild, ...rest }: LogoTypes): react_jsx_runtime.JSX.Element;
+declare function LogoFallback({ className, children, ...rest }: LogoFallbackTypes): react_jsx_runtime.JSX.Element;
+
+type HeadingLevel = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+type TitleTypes = ComponentPropsWithRef<'h1'> & {
+    level?: HeadingLevel;
+};
+
+declare function Title({ ref, level, children, className, ...rest }: TitleTypes): react_jsx_runtime.JSX.Element;
+
+type NoteTypes = ComponentPropsWithRef<'div'> & {
+    variant?: ColorVariant;
+};
+
+declare function Note({ ref, variant, className, children, ...rest }: NoteTypes): react_jsx_runtime.JSX.Element | null;
+declare function NoteTitle({ level, children, className, ...rest }: TitleTypes): react_jsx_runtime.JSX.Element | null;
+
+type PaginationTypes = Omit<ComponentPropsWithRef<'nav'>, 'onChange'> & {
+    currentPage: number;
+    totalPages: number;
+    onPageChange?: (page: number) => void;
+    getPageHref?: (page: number) => string;
+    renderLink?: (page: number, children: ReactNode) => ReactNode;
+    siblingCount?: number;
+    boundaryCount?: number;
+    showFirstLast?: boolean;
+    showPrevNext?: boolean;
+    disabled?: boolean;
+    firstPageLabel?: string;
+    previousPageLabel?: string;
+    nextPageLabel?: string;
+    lastPageLabel?: string;
+    pageLabel?: (page: number) => string;
+};
+
+declare function Pagination({ ref, currentPage, totalPages, onPageChange, getPageHref, renderLink, siblingCount, boundaryCount, showFirstLast, showPrevNext, disabled, className, 'aria-label': ariaLabel, firstPageLabel, previousPageLabel, nextPageLabel, lastPageLabel, pageLabel, ...rest }: PaginationTypes): react_jsx_runtime.JSX.Element | null;
+
+type ProgressTypes = Omit<ComponentPropsWithRef<'div'>, 'children'> & {
+    value?: number;
+    max?: number;
+    variant?: ColorVariant;
+    height?: string;
+    showLabel?: boolean;
+    indeterminate?: boolean;
+    label?: string;
+};
+
+declare function Progress({ ref, height, value, max, variant, showLabel, indeterminate, label, className, ...rest }: ProgressTypes): react_jsx_runtime.JSX.Element;
+
+type RichTextTypes = ComponentPropsWithRef<'div'> & {
+    /** HTML content string (uses dangerouslySetInnerHTML) */
+    html?: string;
+};
+
+declare function RichText({ ref, html, className, children, ...rest }: RichTextTypes): react_jsx_runtime.JSX.Element;
+
+type SectionTypes = ComponentPropsWithRef<'div'>;
+type SectionHeaderTypes = ComponentProps<'div'>;
+
+declare function Section({ ref, className, children, ...rest }: SectionTypes): react_jsx_runtime.JSX.Element;
+declare function SectionHeader({ children, className, ...rest }: SectionHeaderTypes): react_jsx_runtime.JSX.Element;
+declare function SectionTitle({ children, level, className, ...rest }: TitleTypes): react_jsx_runtime.JSX.Element;
+
+type SkeletonVariant = 'text' | 'circle' | 'rect';
+type SkeletonTypes = ComponentPropsWithRef<'div'> & {
+    /** Shape variant */
+    variant?: SkeletonVariant;
+    /** Width (CSS value) */
+    width?: string | number;
+    /** Height (CSS value) */
+    height?: string | number;
+    /** Disable animation */
+    animation?: boolean;
+};
+
+declare function Skeleton({ ref, variant, width, height, animation, className, style, ...rest }: SkeletonTypes): react_jsx_runtime.JSX.Element;
+
+type SpinnerTypes = Omit<ComponentPropsWithRef<'div'>, 'children'> & {
+    width?: string;
+    borderWidth?: string;
+    label?: string;
+    /** When true, removes role="status" for use inside elements with aria-busy */
+    inline?: boolean;
+};
+
+declare function Spinner({ ref, className, width, borderWidth, label, inline, style, ...rest }: SpinnerTypes): react_jsx_runtime.JSX.Element;
+
+type ToastConfigTypes = {
+    id?: number;
+    children?: ReactNode;
+    duration?: number;
+    closeLabel?: string;
+};
+type ToastTypes = ToastConfigTypes & {
+    onRemove: (id: number) => void;
+};
+
+declare function Toast({ id, children, duration, onRemove, closeLabel, }: ToastTypes): react_jsx_runtime.JSX.Element;
+
+declare function Toasts({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+type ToastContextTypes = {
+    toasts: ToastConfigTypes[];
+    addToast: (options: ToastConfigTypes) => void;
+    removeToast: (id: number) => void;
+};
+declare const ToastsContext: react.Context<ToastContextTypes | undefined>;
+declare const useToasts: () => ToastContextTypes;
+
+type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+type TooltipTypes = Omit<ComponentPropsWithRef<'div'>, 'content'> & {
+    /** Tooltip content */
+    content: ReactNode;
+    /** Position relative to trigger */
+    position?: TooltipPosition;
+    /** Delay before showing (ms) */
+    delay?: number;
+    /** Children element that triggers the tooltip */
+    children: ReactNode;
+    /** Disable the tooltip */
+    disabled?: boolean;
+};
+
+declare function Tooltip({ ref, content, position: preferredPosition, delay, children, disabled, className, ...rest }: TooltipTypes): react_jsx_runtime.JSX.Element;
+
+type VideoSource = {
+    src: string;
+    type: string;
+};
+type VideoTrack = {
+    src: string;
+    kind: 'subtitles' | 'captions' | 'descriptions' | 'chapters' | 'metadata';
+    srclang: string;
+    label: string;
+    default?: boolean;
+};
+type VideoTypes = Omit<ComponentPropsWithRef<'video'>, 'src'> & {
+    /** Video source URL (use sources for multiple formats) */
+    src?: string;
+    /** Multiple video sources for browser compatibility */
+    sources?: VideoSource[];
+    /** Text tracks for captions, subtitles, descriptions */
+    tracks?: VideoTrack[];
+    /** Poster image URL */
+    poster?: string;
+    /** Caption text displayed below the video */
+    caption?: ReactNode;
+    /** Fallback content for unsupported browsers */
+    fallback?: ReactNode;
+    /** Fallback text for unsupported browsers (default: "Your browser doesn't support HTML video.") */
+    fallbackText?: string;
+    /** Link text for video fallback (default: "link to the video") */
+    fallbackLinkText?: string;
+};
+
+declare function Video({ ref, src, sources, tracks, poster, caption, fallback, fallbackText, fallbackLinkText, className, controls, ...rest }: VideoTypes): react_jsx_runtime.JSX.Element;
+
+/** @deprecated Use ActionAppearance instead */
+type ButtonAppearance = ActionAppearance;
+type ButtonTypes = ComponentPropsWithRef<'button'> & {
+    variant?: ColorVariant;
+    appearance?: ActionAppearance;
+    contrast?: boolean;
+    loading?: boolean;
+};
+
+declare function Button({ ref, title, disabled, children, className, appearance, contrast, loading, type, variant, ...rest }: ButtonTypes): react_jsx_runtime.JSX.Element;
+
+type CheckboxTypes = Omit<ComponentProps<'label'>, 'onChange' | 'ref'> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+    ref?: Ref<HTMLInputElement>;
+    label?: string;
+    labelClassName?: string;
+    disabled?: boolean;
+};
+
+declare function Checkbox({ label, checked, defaultChecked, onChange, ref, className, labelClassName, disabled, ...rest }: CheckboxTypes): react_jsx_runtime.JSX.Element;
+
+type InputDateTypes = Omit<ComponentProps<'div'>, 'onChange' | 'ref'> & {
+    selected: Date | null;
+    onChange: (date: Date | null) => void;
+    onBlur?: () => void;
+    ref?: Ref<HTMLInputElement>;
+    placeholder?: string;
+    dateFormat?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    disabled?: boolean;
+    label?: string;
+    months?: string[];
+    daysShort?: string[];
+    selectDateLabel?: string;
+    previousMonthLabel?: string;
+    nextMonthLabel?: string;
+    cancelLabel?: string;
+    applyLabel?: string;
+};
+
+declare function InputDate({ selected, onChange, onBlur, ref, placeholder, dateFormat, minDate, maxDate, disabled, label, className, months, daysShort, selectDateLabel, previousMonthLabel, nextMonthLabel, cancelLabel, applyLabel, ...rest }: InputDateTypes): react_jsx_runtime.JSX.Element;
+
+type InputFileTypes = Omit<ComponentPropsWithRef<'input'>, 'type' | 'onChange' | 'value'> & {
+    /** Label text */
+    label?: string;
+    /** Custom class for the label */
+    labelClassName?: string;
+    /** Custom class for the trigger button */
+    buttonClassName?: string;
+    /** Callback when files change */
+    onChange?: (files: FileList | null) => void;
+    /** Enable drag and drop zone */
+    dropzone?: boolean;
+    /** Text for the button */
+    buttonText?: string;
+    /** Show selected file names */
+    showFileNames?: boolean;
+    /** Accepted file types (e.g., ".jpg,.png", "image/*", "application/pdf") */
+    accept?: string;
+    /** Text for single file button (default: "Choose a file") */
+    chooseFileLabel?: string;
+    /** Text for multiple files button (default: "Choose files") */
+    chooseFilesLabel?: string;
+    /** Text when no file selected (default: "No file selected") */
+    noFileSelectedLabel?: string;
+    /** Text showing file count (default: "{count} files selected") */
+    filesSelectedLabel?: (count: number) => string;
+    /** Text for single file drop zone (default: "Drop file here") */
+    dropFileLabel?: string;
+    /** Text for multiple files drop zone (default: "Drop files here") */
+    dropFilesLabel?: string;
+};
+
+declare function InputFile({ label, ref, className, labelClassName, buttonClassName, onChange, dropzone, buttonText, showFileNames, multiple, disabled, accept, chooseFileLabel, chooseFilesLabel, noFileSelectedLabel, filesSelectedLabel, dropFileLabel, dropFilesLabel, ...rest }: InputFileTypes): react_jsx_runtime.JSX.Element;
+
+type InputNumberTypes = Omit<ComponentPropsWithRef<'input'>, 'onChange' | 'value' | 'step' | 'min' | 'max'> & {
+    value?: number;
+    step?: number;
+    min?: number;
+    max?: number;
+    onChange?: (value: number) => void;
+    label?: string;
+    inputClassName?: string;
+    labelClassName?: string;
+    incrementLabel?: string;
+    decrementLabel?: string;
+};
+
+declare function InputNumber({ value, onChange, ref, min, max, step, disabled, className, inputClassName, labelClassName, label, incrementLabel, decrementLabel, ...rest }: InputNumberTypes): react_jsx_runtime.JSX.Element;
+
+type InputPasswordTypes = Omit<ComponentPropsWithRef<'input'>, 'type'> & {
+    label?: string;
+    inputClassName?: string;
+    labelClassName?: string;
+    showLabel?: string;
+    hideLabel?: string;
+};
+
+declare function InputPassword({ label, ref, disabled, className, inputClassName, labelClassName, showLabel, hideLabel, 'aria-label': ariaLabel, ...rest }: InputPasswordTypes): react_jsx_runtime.JSX.Element;
+
+type RadioOptionTypes = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+type InputRadioTypes = Omit<ComponentProps<'input'>, 'onChange' | 'value' | 'ref'> & {
+    value?: string;
+    onChange?: (value: string) => void;
+    ref?: Ref<HTMLDivElement>;
+    options: RadioOptionTypes[];
+    name: string;
+    label?: string;
+    optionClassName?: string;
+    labelClassName?: string;
+    direction?: 'vertical' | 'horizontal';
+};
+
+declare function InputRadio({ value, onChange, options, name, label, ref, disabled, className, optionClassName, labelClassName, direction, ...rest }: InputRadioTypes): react_jsx_runtime.JSX.Element;
+
+type SearchResultTypes = {
+    id: string | number;
+    label: string;
+    [key: string]: unknown;
+};
+type InputSearchTypes = Omit<ComponentPropsWithRef<'input'>, 'type' | 'onChange' | 'results' | 'onSelect'> & {
+    label?: string;
+    inputClassName?: string;
+    labelClassName?: string;
+    mode?: 'redirect' | 'dropdown';
+    action?: string;
+    method?: 'get' | 'post';
+    paramName?: string;
+    results?: SearchResultTypes[];
+    onSearch?: (query: string) => void;
+    onSelect?: (result: SearchResultTypes) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    loading?: boolean;
+    searchDebounce?: number;
+    minChars?: number;
+    renderResult?: (result: SearchResultTypes) => ReactNode;
+    noResultsText?: string;
+    flip?: boolean;
+    value?: string;
+    onChange?: (value: string) => void;
+    clearLabel?: string;
+};
+
+declare function InputSearch({ ref, label, className, inputClassName, labelClassName, mode, action, method, paramName, results, onSearch, onSelect, onLoadMore, hasMore, loading, searchDebounce, minChars, renderResult, noResultsText, flip, value: controlledValue, onChange, placeholder, disabled, clearLabel, 'aria-label': ariaLabel, ...rest }: InputSearchTypes): react_jsx_runtime.JSX.Element;
+
+type OptionTypes = {
+    value: string;
+    label: string;
+};
+type OptionListTypes = ComponentProps<'ul'> & {
+    controlId: string;
+};
+type OptionListItemTypes = {
+    option: OptionTypes;
+    index: number;
+    disabled?: boolean;
+    className?: string;
+};
+type ChoiceListTypes = ComponentProps<'ul'> & {
+    selectedOptions: OptionTypes[];
+};
+type ChoiceListItemTypes = {
+    option: OptionTypes;
+    onRemove: (option: OptionTypes) => void;
+    disabled?: boolean;
+};
+type ChoiceClearTypes = ComponentProps<'button'>;
+type SelectActionsTypes = ComponentProps<'div'>;
+type SelectPlaceholderTypes = ComponentProps<'span'>;
+type SelectModalTypes = ComponentProps<'div'>;
+type SelectRootTypes = Omit<ComponentProps<'div'>, 'onChange'> & {
+    options: OptionTypes[];
+    value: OptionTypes[];
+    onChange: (values: OptionTypes[]) => void;
+    disabled?: boolean;
+    label?: string;
+    labelClassName?: string;
+    placeholder?: string;
+    flip?: boolean;
+    multiple?: boolean;
+    searchable?: boolean;
+    searchDebounce?: number;
+    onSearch?: (query: string) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    loading?: boolean;
+    children: ReactNode;
+    clearAllLabel?: string;
+    selectedOptionsLabel?: string;
+    removeLabel?: string;
+    searchLabel?: string;
+};
+type SelectContextTypes = {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    toggleOption: (option: OptionTypes) => void;
+    updateMenuPosition: () => void;
+    clearAll: () => void;
+    menuPosition: {
+        top: number;
+        left: number;
+        width: number;
+        flip: boolean;
+    };
+    rootRef: RefObject<HTMLDivElement | null>;
+    menuRef: RefObject<HTMLDivElement | null>;
+    searchInputRef: RefObject<HTMLInputElement | null>;
+    choiceButtonRefs: RefObject<Map<string, HTMLButtonElement>>;
+    controlId: string;
+    value: OptionTypes[];
+    options: OptionTypes[];
+    filteredOptions: OptionTypes[];
+    focusedIndex: number;
+    setFocusedIndex: (index: number) => void;
+    disabled?: boolean;
+    placeholder: string;
+    multiple?: boolean;
+    searchable?: boolean;
+    searchQuery: string;
+    setSearchQuery: (query: string) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    loading?: boolean;
+    clearAllLabel: string;
+    selectedOptionsLabel: string;
+    removeLabel: string;
+    searchLabel: string;
+};
+
+declare const OptionListItem: react.MemoExoticComponent<(props: OptionListItemTypes) => react_jsx_runtime.JSX.Element>;
+declare const OptionList: react.MemoExoticComponent<(props: OptionListTypes) => react_jsx_runtime.JSX.Element>;
+declare const ChoiceClear: react.MemoExoticComponent<({ className, ...rest }: ChoiceClearTypes) => react_jsx_runtime.JSX.Element | null>;
+declare const ChoiceList: react.MemoExoticComponent<(props: ChoiceListTypes) => react_jsx_runtime.JSX.Element | null>;
+declare const ChoiceListItem: react.MemoExoticComponent<({ option, disabled, onRemove }: ChoiceListItemTypes) => react_jsx_runtime.JSX.Element>;
+declare const SelectModal: react.MemoExoticComponent<({ children, className, ...rest }: SelectModalTypes) => react.ReactPortal | null>;
+declare const SelectActions: react.MemoExoticComponent<({ children, className, ...rest }: SelectActionsTypes) => react_jsx_runtime.JSX.Element>;
+declare const SelectTrigger: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;
+declare const SelectSearch: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element | null>;
+declare const SelectPlaceholder: react.MemoExoticComponent<({ className, ...rest }: SelectPlaceholderTypes) => react_jsx_runtime.JSX.Element | null>;
+declare const SelectRoot: (props: SelectRootTypes) => react_jsx_runtime.JSX.Element;
+
+declare const SelectContextRoot: react.Provider<SelectContextTypes | undefined>;
+declare const useSelectContext: () => SelectContextTypes;
+
+type SliderMark = {
+    value: number;
+    label?: string;
+};
+type SliderOrientation = 'horizontal' | 'vertical';
+type SliderSize = 'sm' | 'md';
+type SliderTrack = 'normal' | 'inverted' | false;
+type SliderValueLabelDisplay = 'auto' | 'on' | 'off';
+type SliderBaseTypes = Omit<ComponentProps<'input'>, 'value' | 'defaultValue' | 'onChange' | 'size' | 'step'> & {
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step increment. Set to null to only allow values from marks */
+    step?: number | null;
+    /** Whether the slider is disabled */
+    disabled?: boolean;
+    /** Orientation of the slider */
+    orientation?: SliderOrientation;
+    /** Size variant */
+    size?: SliderSize;
+    /** Track display mode */
+    track?: SliderTrack;
+    /** Show marks on the slider. True for automatic marks at each step, or array for custom marks */
+    marks?: boolean | SliderMark[];
+    /** Value label display mode */
+    valueLabelDisplay?: SliderValueLabelDisplay;
+    /** Format the value label */
+    valueLabelFormat?: (value: number) => string;
+    /** Get aria value text for accessibility */
+    getAriaValueText?: (value: number) => string;
+    /** Label for accessibility */
+    'aria-label'?: string;
+    /** ID of element that labels the slider */
+    'aria-labelledby'?: string;
+    /** Custom class name */
+    className?: string;
+};
+type SliderSingleTypes = SliderBaseTypes & {
+    /** Whether this is a range slider */
+    range?: false;
+    /** Current value (controlled) */
+    value?: number;
+    /** Default value (uncontrolled) */
+    defaultValue?: number;
+    /** Callback when value changes */
+    onChange?: (value: number) => void;
+    /** Callback when value change is committed (on mouse up / touch end) */
+    onChangeCommitted?: (value: number) => void;
+};
+type SliderRangeTypes = SliderBaseTypes & {
+    /** Whether this is a range slider */
+    range: true;
+    /** Current value (controlled) */
+    value?: [number, number];
+    /** Default value (uncontrolled) */
+    defaultValue?: [number, number];
+    /** Callback when value changes */
+    onChange?: (value: [number, number]) => void;
+    /** Callback when value change is committed (on mouse up / touch end) */
+    onChangeCommitted?: (value: [number, number]) => void;
+    /** Minimum distance between the two thumbs */
+    minDistance?: number;
+    /** Disable swapping thumbs when they meet */
+    disableSwap?: boolean;
+};
+type SliderTypes = SliderSingleTypes | SliderRangeTypes;
+
+declare function Slider(props: SliderTypes): react_jsx_runtime.JSX.Element;
+
+type SwitchTypes = Omit<ComponentProps<'label'>, 'onChange' | 'ref'> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+    ref?: Ref<HTMLInputElement>;
+    label?: string;
+    labelClassName?: string;
+    disabled?: boolean;
+};
+
+declare function Switch({ label, checked, defaultChecked, onChange, ref, className, labelClassName, disabled, ...rest }: SwitchTypes): react_jsx_runtime.JSX.Element;
+
+type InputTextTypes = Omit<ComponentPropsWithRef<'input'>, 'type'> & {
+    type?: 'text' | 'email' | 'url' | 'tel';
+    label?: string;
+    inputClassName?: string;
+    labelClassName?: string;
+};
+
+declare function InputText({ label, ref, className, inputClassName, labelClassName, type, 'aria-label': ariaLabel, ...rest }: InputTextTypes): react_jsx_runtime.JSX.Element;
+
+type InputTextareaTypes = Omit<ComponentPropsWithRef<'textarea'>, 'onChange' | 'value'> & {
+    value?: string;
+    onChange?: (value: string) => void;
+    label?: string;
+    textareaClassName?: string;
+    labelClassName?: string;
+    showCount?: boolean;
+};
+
+declare function InputTextarea({ value, label, ref, onChange, disabled, maxLength, className, labelClassName, textareaClassName, showCount, ...rest }: InputTextareaTypes): react_jsx_runtime.JSX.Element;
+
+type AccordionType = 'single' | 'multiple';
+type AccordionContextValue = {
+    type: AccordionType;
+    expandedItems: string[];
+    toggleItem: (value: string) => void;
+    accordionId: string;
+};
+type AccordionTypes = ComponentPropsWithRef<'div'> & {
+    type?: AccordionType;
+    defaultValue?: string | string[];
+    value?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    collapsible?: boolean;
+};
+type AccordionItemContextValue = {
+    value: string;
+    isExpanded: boolean;
+    triggerId: string;
+    contentId: string;
+    disabled: boolean;
+};
+type AccordionItemTypes = ComponentPropsWithRef<'div'> & {
+    value: string;
+    disabled?: boolean;
+};
+type AccordionTriggerTypes = ComponentPropsWithRef<'button'> & {
+    /** Heading level for proper document structure (default: 'h3') */
+    headingLevel?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+};
+type AccordionContentTypes = ComponentPropsWithRef<'div'>;
+
+declare function Accordion({ ref, type, defaultValue, value, onValueChange, collapsible, className, children, ...props }: AccordionTypes): react_jsx_runtime.JSX.Element;
+declare function AccordionItem({ ref, value, children, className, disabled, ...props }: AccordionItemTypes): react_jsx_runtime.JSX.Element;
+declare function AccordionTrigger({ ref, children, className, headingLevel: Heading, ...props }: AccordionTriggerTypes): react_jsx_runtime.JSX.Element;
+declare function AccordionContent({ ref, className, children, ...props }: AccordionContentTypes): react_jsx_runtime.JSX.Element;
+
+/** @deprecated Use HorizontalAlign instead */
+type HorizontalAlignTypes = HorizontalAlign;
+/** @deprecated Use VerticalAlign instead */
+type VerticalAlignTypes = VerticalAlign;
+/** @deprecated Use HorizontalAlign instead */
+type BannerTextAlignTypes = HorizontalAlign;
+type BannerOverlay = 'none' | 'light' | 'dark';
+type BannerTextColor = 'light' | 'dark';
+/** @deprecated Use BannerOverlay instead */
+type BannerOverlayTypes = BannerOverlay;
+/** @deprecated Use BannerTextColor instead */
+type BannerTextColorTypes = BannerTextColor;
+type BannerBackgroundVideo = {
+    src: string;
+    poster?: string;
+};
+type BannerTypes = ComponentPropsWithRef<'div'> & {
+    backgroundImage?: string;
+    backgroundVideo?: BannerBackgroundVideo;
+    backgroundColor?: string;
+    horizontalAlign?: HorizontalAlign;
+    verticalAlign?: VerticalAlign;
+    minHeight?: string;
+    overlay?: BannerOverlay;
+};
+type BannerContentTypes = ComponentPropsWithRef<'div'> & {
+    maxWidth?: string;
+    textAlign?: HorizontalAlign;
+    textColor?: BannerTextColor;
+};
+type BannerTitleTypes = TitleTypes;
+type BannerSubtitleTypes = ComponentPropsWithRef<'p'>;
+type BannerBodyTypes = ComponentPropsWithRef<'div'>;
+type BannerActionsTypes = ComponentPropsWithRef<'div'>;
+
+declare function Banner({ ref, backgroundImage, backgroundVideo, backgroundColor, overlay, minHeight, className, style, children, horizontalAlign, verticalAlign, ...props }: BannerTypes): react_jsx_runtime.JSX.Element;
+declare function BannerContent({ ref, textAlign, textColor, maxWidth, className, style, children, ...props }: BannerContentTypes): react_jsx_runtime.JSX.Element;
+declare function BannerTitle({ level, className, children, ...props }: BannerTitleTypes): react_jsx_runtime.JSX.Element;
+declare function BannerSubtitle({ ref, className, children, ...props }: BannerSubtitleTypes): react_jsx_runtime.JSX.Element;
+declare function BannerBody({ ref, className, children, ...props }: BannerBodyTypes): react_jsx_runtime.JSX.Element;
+declare function BannerActions({ ref, className, children, ...props }: BannerActionsTypes): react_jsx_runtime.JSX.Element;
+
+type CardTypes = ComponentPropsWithRef<'div'>;
+type CardHeaderTypes = ComponentPropsWithRef<'div'>;
+type CardBodyTypes = ComponentPropsWithRef<'div'>;
+type CardFooterTypes = ComponentPropsWithRef<'div'>;
+
+declare function Card({ ref, className, children, ...rest }: CardTypes): react_jsx_runtime.JSX.Element;
+declare function CardHeader({ ref, className, children, ...rest }: CardHeaderTypes): react_jsx_runtime.JSX.Element;
+declare function CardBody({ ref, className, children, ...rest }: CardBodyTypes): react_jsx_runtime.JSX.Element;
+declare function CardFooter({ ref, className, children, ...rest }: CardFooterTypes): react_jsx_runtime.JSX.Element;
+
+type CarouselContextValue = {
+    selectedIndex: number;
+    scrollSnaps: number[];
+    canScrollPrev: boolean;
+    canScrollNext: boolean;
+    scrollPrev: () => void;
+    scrollNext: () => void;
+    scrollTo: (index: number) => void;
+};
+type CarouselOptions = {
+    /** Enables active state (default: true) */
+    active?: EmblaOptionsType['active'];
+    /** Align slides within viewport: 'start' | 'center' | 'end' | number (default: 'center') */
+    align?: EmblaOptionsType['align'];
+    /** Scroll axis: 'x' | 'y' (default: 'x') */
+    axis?: EmblaOptionsType['axis'];
+    /** Responsive breakpoints with options */
+    breakpoints?: EmblaOptionsType['breakpoints'];
+    /** Contain scroll to prevent empty space: 'trimSnaps' | 'keepSnaps' | false (default: 'trimSnaps') */
+    containScroll?: EmblaOptionsType['containScroll'];
+    /** Custom container selector */
+    container?: EmblaOptionsType['container'];
+    /** Scroll direction: 'ltr' | 'rtl' (default: 'ltr') */
+    direction?: EmblaOptionsType['direction'];
+    /** Enable free scrolling without snapping (default: false) */
+    dragFree?: EmblaOptionsType['dragFree'];
+    /** Drag threshold in pixels before scrolling starts (default: 10) */
+    dragThreshold?: EmblaOptionsType['dragThreshold'];
+    /** Scroll animation duration in ms (default: 25) */
+    duration?: EmblaOptionsType['duration'];
+    /** Threshold for slide in-view detection: 0-1 (default: 0) */
+    inViewThreshold?: EmblaOptionsType['inViewThreshold'];
+    /** Enable infinite looping (default: false) */
+    loop?: EmblaOptionsType['loop'];
+    /** Skip snaps when dragging aggressively (default: false) */
+    skipSnaps?: EmblaOptionsType['skipSnaps'];
+    /** Custom slides selector */
+    slides?: EmblaOptionsType['slides'];
+    /** Number of slides to scroll per interaction: number | 'auto' (default: 1) */
+    slidesToScroll?: EmblaOptionsType['slidesToScroll'];
+    /** Starting slide index (default: 0) */
+    startIndex?: EmblaOptionsType['startIndex'];
+    /** Enable/disable drag interactions (default: true) */
+    watchDrag?: EmblaOptionsType['watchDrag'];
+    /** Reinitialize on container resize (default: true) */
+    watchResize?: EmblaOptionsType['watchResize'];
+    /** Reinitialize when slides change (default: true) */
+    watchSlides?: EmblaOptionsType['watchSlides'];
+};
+type CarouselTypes = ComponentPropsWithRef<'div'> & CarouselOptions & {
+    /** Number of slides visible at once (sets slide width via CSS) */
+    slidesPerView?: number;
+    /** Gap between slides in rem */
+    gap?: number;
+};
+interface CarouselCSSProperties extends CSSProperties {
+    '--carousel-slides-per-view'?: number;
+    '--carousel-gap'?: string;
+}
+type CarouselContainerTypes = ComponentPropsWithRef<'div'>;
+type CarouselSlideTypes = ComponentPropsWithRef<'div'>;
+type CarouselControlsTypes = ComponentPropsWithRef<'div'> & {
+    /** Position arrows overlaying the carousel left/right */
+    overlay?: boolean;
+};
+type CarouselPrevTypes = ComponentPropsWithRef<'button'> & {
+    label?: string;
+};
+type CarouselNextTypes = ComponentPropsWithRef<'button'> & {
+    label?: string;
+};
+type CarouselDotsTypes = ComponentPropsWithRef<'div'> & {
+    label?: string;
+    navigationLabel?: string;
+};
+
+declare function Carousel({ ref, active, align, axis, breakpoints, containScroll, container, direction, dragFree, dragThreshold, duration, inViewThreshold, loop, skipSnaps, slides, slidesToScroll, startIndex, watchDrag, watchResize, watchSlides, slidesPerView, gap, className, style, children, ...props }: CarouselTypes): react_jsx_runtime.JSX.Element;
+declare function CarouselContainer({ ref, className, children, ...props }: CarouselContainerTypes): react_jsx_runtime.JSX.Element;
+declare function CarouselSlide({ ref, className, children, ...props }: CarouselSlideTypes): react_jsx_runtime.JSX.Element;
+declare function CarouselControls({ ref, overlay, className, children, ...props }: CarouselControlsTypes): react_jsx_runtime.JSX.Element;
+declare function CarouselPrev({ ref, className, label, children, ...props }: CarouselPrevTypes): react_jsx_runtime.JSX.Element;
+declare function CarouselNext({ ref, className, label, children, ...props }: CarouselNextTypes): react_jsx_runtime.JSX.Element;
+declare function CarouselDots({ ref, className, label, navigationLabel, ...props }: CarouselDotsTypes): react_jsx_runtime.JSX.Element;
+
+type GapSize = 0 | 1 | 2 | 3 | 4 | 5;
+type GridTypes = ComponentPropsWithRef<'div'> & {
+    col?: number;
+    colXS?: number;
+    colSM?: number;
+    colMD?: number;
+    colLG?: number;
+    colXL?: number;
+    gap?: GapSize;
+    gapXS?: GapSize;
+    gapSM?: GapSize;
+    gapMD?: GapSize;
+    gapLG?: GapSize;
+    gapXL?: GapSize;
+    /** Enable masonry layout (items flow vertically then horizontally) */
+    masonry?: boolean;
+};
+type GridItemTypes = ComponentPropsWithRef<'div'> & {
+    col?: number;
+    colXS?: number;
+    colSM?: number;
+    colMD?: number;
+    colLG?: number;
+    colXL?: number;
+    row?: number;
+    rowXS?: number;
+    rowSM?: number;
+    rowMD?: number;
+    rowLG?: number;
+    rowXL?: number;
+};
+
+declare function Grid({ ref, children, gap, gapXS, gapSM, gapMD, gapLG, gapXL, col, colXS, colSM, colMD, colLG, colXL, masonry, className, ...rest }: GridTypes): react_jsx_runtime.JSX.Element;
+
+declare function GridItem({ children, col, colXS, colSM, colMD, colLG, colXL, row, rowXS, rowSM, rowMD, rowLG, rowXL, className, ...rest }: GridItemTypes): react_jsx_runtime.JSX.Element;
+
+type ModalConfigTypes = {
+    id?: number;
+    title?: ReactNode;
+    children: ReactNode;
+    width?: string;
+    closeOnBackdrop?: boolean;
+    duration?: number;
+    closeLabel?: string;
+    hideCloseButton?: boolean;
+};
+type ModalTypes = ModalConfigTypes & {
+    onRemove: (id: number) => void;
+};
+
+declare function Modal({ id, title, width, children, onRemove, duration, closeOnBackdrop, closeLabel, hideCloseButton, }: ModalTypes): react_jsx_runtime.JSX.Element;
+
+declare function Modals({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+type ModalsContextTypes = {
+    modals: ModalConfigTypes[];
+    addModal: (options: ModalConfigTypes) => void;
+    removeModal: (id: number) => void;
+};
+declare const ModalsContext: react.Context<ModalsContextTypes | undefined>;
+declare const useModals: () => ModalsContextTypes;
+
+type TabContextValue = {
+    activeTab: string;
+    setActiveTab: (value: string) => void;
+    tabId: string;
+};
+type TabTypes = ComponentPropsWithRef<'div'> & {
+    value?: string;
+    defaultValue: string;
+    onValueChange?: (value: string) => void;
+};
+type TabListTypes = ComponentPropsWithRef<'div'>;
+type TabButtonTypes = Omit<ButtonTypes, 'value'> & {
+    value: string;
+};
+type TabPanelsTypes = ComponentPropsWithRef<'div'>;
+type TabPanelTypes = ComponentPropsWithRef<'div'> & {
+    value: string;
+};
+
+declare function Tab({ ref, defaultValue, value, onValueChange, className, children, ...props }: TabTypes): react_jsx_runtime.JSX.Element;
+declare function TabList({ ref, className, children, ...props }: TabListTypes): react_jsx_runtime.JSX.Element;
+declare function TabButton({ value, children, className, appearance, variant, ...props }: TabButtonTypes): react_jsx_runtime.JSX.Element;
+declare function TabPanels({ ref, className, children, ...props }: TabPanelsTypes): react_jsx_runtime.JSX.Element;
+declare function TabPanel({ ref, value, className, children, ...props }: TabPanelTypes): react_jsx_runtime.JSX.Element | null;
+
+type TableTypes = ComponentPropsWithRef<'table'> & {
+    /** Adds striped rows */
+    striped?: boolean;
+    /** Adds hover effect on rows */
+    hoverable?: boolean;
+    /** Makes the table more compact */
+    compact?: boolean;
+    /** Adds border to all cells */
+    bordered?: boolean;
+};
+type TableHeadTypes = ComponentPropsWithRef<'thead'>;
+type TableBodyTypes = ComponentPropsWithRef<'tbody'>;
+type TableFootTypes = ComponentPropsWithRef<'tfoot'>;
+type TableRowTypes = ComponentPropsWithRef<'tr'>;
+type TableHeaderCellTypes = ComponentPropsWithRef<'th'>;
+type TableCellTypes = ComponentPropsWithRef<'td'>;
+type TableCaptionTypes = ComponentPropsWithRef<'caption'> & {
+    /** Position of the caption */
+    position?: 'top' | 'bottom';
+};
+
+declare function Table({ striped, hoverable, compact, bordered, className, children, ref, ...props }: TableTypes): react_jsx_runtime.JSX.Element;
+declare function TableHead({ className, children, ref, ...props }: TableHeadTypes): react_jsx_runtime.JSX.Element;
+declare function TableBody({ className, children, ref, ...props }: TableBodyTypes): react_jsx_runtime.JSX.Element;
+declare function TableFoot({ className, children, ref, ...props }: TableFootTypes): react_jsx_runtime.JSX.Element;
+declare function TableRow({ className, children, ref, ...props }: TableRowTypes): react_jsx_runtime.JSX.Element;
+declare function TableHeaderCell({ className, children, ref, ...props }: TableHeaderCellTypes): react_jsx_runtime.JSX.Element;
+declare function TableCell({ className, children, ref, ...props }: TableCellTypes): react_jsx_runtime.JSX.Element;
+declare function TableCaption({ position, className, children, ref, ...props }: TableCaptionTypes): react_jsx_runtime.JSX.Element;
+
+type AccountSectionTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type AccountCardTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type AccountCardHeaderTypes = ComponentPropsWithRef<'div'> & {
+    children?: ReactNode;
+};
+type AccountCardBodyTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type AccountCardFooterTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type AccountFormTypes = ComponentPropsWithRef<'form'> & {
+    children: ReactNode;
+};
+type AccountTitleTypes = {
+    children: ReactNode;
+    className?: string;
+    level?: HeadingLevel;
+};
+
+declare function AccountCard({ ref, children, className, ...rest }: AccountCardTypes): react_jsx_runtime.JSX.Element;
+declare function AccountCardHeader({ ref, children, className, ...rest }: AccountCardHeaderTypes): react_jsx_runtime.JSX.Element;
+declare function AccountCardBody({ ref, children, className, ...rest }: AccountCardBodyTypes): react_jsx_runtime.JSX.Element;
+declare function AccountCardFooter({ ref, children, className, ...rest }: AccountCardFooterTypes): react_jsx_runtime.JSX.Element;
+
+declare function AccountForm({ ref, children, className, ...rest }: AccountFormTypes): react_jsx_runtime.JSX.Element;
+
+declare function AccountSection({ ref, children, className, ...rest }: AccountSectionTypes): react_jsx_runtime.JSX.Element;
+
+declare function AccountTitle({ children, className, level, }: AccountTitleTypes): react_jsx_runtime.JSX.Element;
+
+type AuthSectionTypes = ComponentPropsWithRef<'section'> & {
+    children: ReactNode;
+};
+type AuthCardTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type AuthCardHeaderTypes = ComponentPropsWithRef<'div'> & {
+    children?: ReactNode;
+};
+type AuthCardBodyTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type AuthCardFooterTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type AuthFormTypes = ComponentPropsWithRef<'form'> & {
+    children: ReactNode;
+};
+type AuthLinkTypes = {
+    asChild?: boolean;
+    children: ReactNode;
+    className?: string;
+    href?: string;
+};
+type AuthTitleTypes = {
+    children: ReactNode;
+    className?: string;
+    level?: HeadingLevel;
+};
+type AuthMessageTypes = ComponentPropsWithRef<'div'> & {
+    children?: ReactNode;
+    title: string;
+    message: string;
+    status?: 'success' | 'error' | 'info';
+    footer?: ReactNode;
+};
+
+declare function AuthCard({ ref, children, className, ...rest }: AuthCardTypes): react_jsx_runtime.JSX.Element;
+declare function AuthCardHeader({ ref, children, className, ...rest }: AuthCardHeaderTypes): react_jsx_runtime.JSX.Element;
+declare function AuthCardBody({ ref, children, className, ...rest }: AuthCardBodyTypes): react_jsx_runtime.JSX.Element;
+declare function AuthCardFooter({ ref, children, className, ...rest }: AuthCardFooterTypes): react_jsx_runtime.JSX.Element;
+
+declare function AuthForm({ ref, children, className, ...rest }: AuthFormTypes): react_jsx_runtime.JSX.Element;
+
+declare function AuthLink({ asChild, children, className, ...rest }: AuthLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function AuthSection({ ref, children, className, ...rest }: AuthSectionTypes): react_jsx_runtime.JSX.Element;
+
+declare function AuthTitle({ level, children, className, ...rest }: AuthTitleTypes): react_jsx_runtime.JSX.Element;
+
+type DashboardLayoutTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type DashboardSidebarTypes = ComponentPropsWithRef<'aside'> & {
+    children: ReactNode;
+};
+type DashboardBrandTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type DashboardMainTypes = ComponentPropsWithRef<'main'> & {
+    children: ReactNode;
+};
+type DashboardHeaderTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type DashboardTitleTypes = ComponentPropsWithRef<'h1'> & {
+    children: ReactNode;
+};
+type DashboardNavTypes = ComponentPropsWithRef<'nav'> & {
+    children: ReactNode;
+};
+type DashboardNavLinkTypes = ComponentPropsWithRef<'a'> & {
+    children: ReactNode;
+    asChild?: boolean;
+    current?: boolean;
+};
+
+declare function DashboardBrand({ ref, children, className, ...rest }: DashboardBrandTypes): react_jsx_runtime.JSX.Element;
+
+declare function DashboardLayout({ ref, children, className, ...rest }: DashboardLayoutTypes): react_jsx_runtime.JSX.Element;
+
+declare function DashboardMain({ ref, children, className, ...rest }: DashboardMainTypes): react_jsx_runtime.JSX.Element;
+
+declare function DashboardMainHeader({ ref, children, className, ...rest }: DashboardHeaderTypes): react_jsx_runtime.JSX.Element;
+
+declare function DashboardMainTitle({ ref, children, className, ...rest }: DashboardTitleTypes): react_jsx_runtime.JSX.Element;
+
+declare function DashboardNav({ ref, children, className, title, ...rest }: DashboardNavTypes): react_jsx_runtime.JSX.Element;
+
+declare function DashboardNavLink({ ref, children, className, asChild, current, ...rest }: DashboardNavLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function DashboardNavTitle({ ref, level, children, className, ...rest }: TitleTypes): react_jsx_runtime.JSX.Element;
+
+declare function DashboardSidebar({ ref, children, className, ...rest }: DashboardSidebarTypes): react_jsx_runtime.JSX.Element;
+
+type FooterTypes = ComponentPropsWithRef<'footer'>;
+type FooterMainTypes = ComponentPropsWithRef<'div'> & {
+    brand?: ReactNode;
+};
+type FooterMainLogoTypes = ComponentPropsWithRef<'div'>;
+type FooterMainMenuTypes = ComponentPropsWithRef<'div'>;
+type FooterMainNavTypes = ComponentPropsWithRef<'nav'> & {
+    title?: string;
+    'aria-label'?: string;
+};
+type FooterMainLinkTypes = ComponentPropsWithRef<'a'> & {
+    asChild?: boolean;
+    current?: boolean;
+};
+type FooterBottomTypes = ComponentPropsWithRef<'div'> & {
+    copyright?: string;
+};
+type FooterBottomNavTypes = ComponentPropsWithRef<'nav'> & {
+    'aria-label'?: string;
+};
+type FooterBottomLinkTypes = ComponentPropsWithRef<'a'> & {
+    asChild?: boolean;
+    current?: boolean;
+};
+
+declare function FooterBottom({ ref, children, className, copyright, ...rest }: FooterBottomTypes): react_jsx_runtime.JSX.Element;
+
+declare function FooterBottomLink({ asChild, children, className, current, ...props }: FooterBottomLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function FooterBottomNav({ ref, children, className, 'aria-label': ariaLabel, ...rest }: FooterBottomNavTypes): react_jsx_runtime.JSX.Element;
+
+declare function FooterRoot({ ref, children, className, ...rest }: FooterTypes): react_jsx_runtime.JSX.Element;
+
+declare function FooterMain({ ref, children, className, ...rest }: FooterMainTypes): react_jsx_runtime.JSX.Element;
+
+declare function FooterMainLink({ asChild, children, className, current, ...props }: FooterMainLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function FooterMainLogo({ ref, children, className, ...rest }: FooterMainLogoTypes): react_jsx_runtime.JSX.Element;
+
+declare function FooterMainMenu({ ref, children, className, ...rest }: FooterMainMenuTypes): react_jsx_runtime.JSX.Element;
+
+declare function FooterMainNav({ ref, children, className, title, 'aria-label': ariaLabel, ...rest }: FooterMainNavTypes): react_jsx_runtime.JSX.Element;
+
+declare function FooterMainNavTitle({ children, className, level, }: TitleTypes): react_jsx_runtime.JSX.Element;
+
+type HeaderTextColor = 'light' | 'dark';
+type HeaderTypes = ComponentPropsWithRef<'header'> & {
+    children: ReactNode;
+    baseId?: string;
+    transparent?: boolean;
+    textColor?: HeaderTextColor;
+};
+type HeaderTopTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+    containerClassName?: string;
+};
+type HeaderTopNavTypes = ComponentPropsWithRef<'nav'> & {
+    children: ReactNode;
+    'aria-label'?: string;
+};
+type HeaderTopDropdownTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+    label: ReactNode;
+    href?: string;
+    as?: ElementType;
+    current?: boolean;
+};
+type HeaderMainTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+    containerClassName?: string;
+};
+type HeaderMainLogoTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type HeaderMainNavTypes = ComponentPropsWithRef<'nav'> & {
+    children: ReactNode;
+    'aria-label'?: string;
+};
+type HeaderMainDropdownTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+    label: ReactNode;
+    href?: string;
+    as?: ElementType;
+    mega?: boolean;
+    current?: boolean;
+};
+type HeaderMobileTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type HeaderMobileLogoTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type HeaderMobileBarTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+};
+type HeaderMobileToggleTypes = Omit<ComponentPropsWithRef<'button'>, 'children'> & {
+    label?: string;
+    closeLabel?: string;
+    menuLabel?: string;
+};
+type HeaderMobileMenuTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+    'aria-label'?: string;
+};
+type HeaderMobileTopTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+    'aria-label'?: string;
+};
+type HeaderMobileNavTypes = ComponentPropsWithRef<'nav'> & {
+    children: ReactNode;
+    'aria-label'?: string;
+};
+type HeaderMobileDropdownTypes = ComponentPropsWithRef<'div'> & {
+    children: ReactNode;
+    label: ReactNode;
+    baseId?: string;
+};
+type HeaderTopLinkTypes = ComponentPropsWithRef<'a'> & {
+    asChild?: boolean;
+    children: ReactNode;
+    current?: boolean;
+};
+type HeaderTopDropdownLinkTypes = ComponentPropsWithRef<'a'> & {
+    asChild?: boolean;
+    children: ReactNode;
+    current?: boolean;
+};
+type HeaderMainLinkTypes = ComponentPropsWithRef<'a'> & {
+    asChild?: boolean;
+    children: ReactNode;
+    current?: boolean;
+};
+type HeaderMainDropdownLinkTypes = ComponentPropsWithRef<'a'> & {
+    asChild?: boolean;
+    children: ReactNode;
+    current?: boolean;
+};
+type HeaderMobileLinkTypes = ComponentPropsWithRef<'a'> & {
+    asChild?: boolean;
+    children: ReactNode;
+    current?: boolean;
+};
+type HeaderMobileDropdownLinkTypes = ComponentPropsWithRef<'a'> & {
+    asChild?: boolean;
+    children: ReactNode;
+    current?: boolean;
+};
+type HeaderNavTypes = 'main' | 'top' | 'mobile';
+type HeaderContextTypes = {
+    isOpen: boolean;
+    toggle: () => void;
+    mobileMenuId: string;
+    mobileToggleId: string;
+    registerNav: (type: HeaderNavTypes) => number;
+    getNavCount: (type: HeaderNavTypes) => number;
+    isTransparent: boolean;
+    textColor: HeaderTextColor;
+};
+
+declare const HeaderContext: react.Context<HeaderContextTypes | null>;
+declare const useHeader: () => HeaderContextTypes;
+
+declare function HeaderRoot({ ref, children, baseId, transparent, textColor, className, ...rest }: HeaderTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMain({ ref, children, className, containerClassName, ...rest }: HeaderMainTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMainDropdown({ children, label, href, as, mega, current, className, ...rest }: HeaderMainDropdownTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMainDropdownLink({ asChild, children, className, current, ...props }: HeaderMainDropdownLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMainLink({ asChild, children, className, current, ...props }: HeaderMainLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMainLogo({ ref, children, className, ...rest }: HeaderMainLogoTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMainNav({ ref, children, className, 'aria-label': ariaLabel, ...rest }: HeaderMainNavTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobile({ ref, children, className, ...rest }: HeaderMobileTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobileBar({ ref, children, className, ...rest }: HeaderMobileBarTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobileDropdown({ ref, children, label, baseId, className, ...rest }: HeaderMobileDropdownTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobileDropdownLink({ asChild, children, className, current, ...props }: HeaderMobileDropdownLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobileLink({ asChild, children, className, current, ...props }: HeaderMobileLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobileLogo({ ref, children, className, ...rest }: HeaderMobileLogoTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobileMenu({ ref, children, className, 'aria-label': ariaLabel, ...rest }: HeaderMobileMenuTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobileNav({ ref, children, className, 'aria-label': ariaLabel, ...rest }: HeaderMobileNavTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobileToggle({ ref, label, closeLabel, menuLabel, className, ...rest }: HeaderMobileToggleTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderMobileTop({ ref, className, children, ...rest }: HeaderMobileTopTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderTop({ ref, children, className, containerClassName, ...rest }: HeaderTopTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderTopDropdown({ children, label, href, as, current, className, ...rest }: HeaderTopDropdownTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderTopDropdownLink({ asChild, children, className, current, ...props }: HeaderTopDropdownLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderTopLink({ asChild, children, className, current, ...props }: HeaderTopLinkTypes): react_jsx_runtime.JSX.Element;
+
+declare function HeaderTopNav({ ref, children, className, 'aria-label': ariaLabel, ...rest }: HeaderTopNavTypes): react_jsx_runtime.JSX.Element;
+
+type PageRootTypes = ComponentPropsWithRef<'div'> & {
+    children?: ReactNode;
+};
+
+declare function PageRoot({ ref, children, className, ...rest }: PageRootTypes): react_jsx_runtime.JSX.Element;
+
+export { Accordion, AccordionContent, type AccordionContentTypes, type AccordionContextValue, AccordionItem, type AccordionItemContextValue, type AccordionItemTypes, AccordionTrigger, type AccordionTriggerTypes, type AccordionType, type AccordionTypes, AccountCard, AccountCardBody, type AccountCardBodyTypes, AccountCardFooter, type AccountCardFooterTypes, AccountCardHeader, type AccountCardHeaderTypes, type AccountCardTypes, AccountForm, type AccountFormTypes, AccountSection, type AccountSectionTypes, AccountTitle, type AccountTitleTypes, Audio, type AudioSource, type AudioTypes, AuthCard, AuthCardBody, type AuthCardBodyTypes, AuthCardFooter, type AuthCardFooterTypes, AuthCardHeader, type AuthCardHeaderTypes, type AuthCardTypes, AuthForm, type AuthFormTypes, AuthLink, type AuthLinkTypes, type AuthMessageTypes, AuthSection, type AuthSectionTypes, AuthTitle, type AuthTitleTypes, Avatar, type AvatarTypes, Badge, type BadgeTypes, Banner, BannerActions, type BannerActionsTypes, type BannerBackgroundVideo, BannerBody, type BannerBodyTypes, BannerContent, type BannerContentTypes, type BannerOverlay, type BannerOverlayTypes, BannerSubtitle, type BannerSubtitleTypes, type BannerTextAlignTypes, type BannerTextColor, type BannerTextColorTypes, BannerTitle, type BannerTitleTypes, type BannerTypes, Breadcrumb, type BreadcrumbItemData, type BreadcrumbTypes, Button, type ButtonAppearance, type ButtonTypes, Card, CardBody, type CardBodyTypes, CardFooter, type CardFooterTypes, CardHeader, type CardHeaderTypes, type CardTypes, Carousel, type CarouselCSSProperties, CarouselContainer, type CarouselContainerTypes, type CarouselContextValue, CarouselControls, type CarouselControlsTypes, CarouselDots, type CarouselDotsTypes, CarouselNext, type CarouselNextTypes, type CarouselOptions, CarouselPrev, type CarouselPrevTypes, CarouselSlide, type CarouselSlideTypes, type CarouselTypes, Checkbox, type CheckboxTypes, ChoiceClear, type ChoiceClearTypes, ChoiceList, ChoiceListItem, type ChoiceListItemTypes, type ChoiceListTypes, DashboardBrand, type DashboardBrandTypes, type DashboardHeaderTypes, DashboardLayout, type DashboardLayoutTypes, DashboardMain, DashboardMainHeader, DashboardMainTitle, type DashboardMainTypes, DashboardNav, DashboardNavLink, type DashboardNavLinkTypes, DashboardNavTitle, type DashboardNavTypes, DashboardSidebar, type DashboardSidebarTypes, type DashboardTitleTypes, Divider, type DividerSpacing, type DividerTypes, type DividerVariant, FooterBottom, FooterBottomLink, type FooterBottomLinkTypes, FooterBottomNav, type FooterBottomNavTypes, type FooterBottomTypes, FooterMain, FooterMainLink, type FooterMainLinkTypes, FooterMainLogo, type FooterMainLogoTypes, FooterMainMenu, type FooterMainMenuTypes, FooterMainNav, FooterMainNavTitle, type FooterMainNavTypes, type FooterMainTypes, FooterRoot, type FooterTypes, type GapSize, Grid, GridItem, type GridItemTypes, type GridTypes, HeaderContext, type HeaderContextTypes, HeaderMain, HeaderMainDropdown, HeaderMainDropdownLink, type HeaderMainDropdownLinkTypes, type HeaderMainDropdownTypes, HeaderMainLink, type HeaderMainLinkTypes, HeaderMainLogo, type HeaderMainLogoTypes, HeaderMainNav, type HeaderMainNavTypes, type HeaderMainTypes, HeaderMobile, HeaderMobileBar, type HeaderMobileBarTypes, HeaderMobileDropdown, HeaderMobileDropdownLink, type HeaderMobileDropdownLinkTypes, type HeaderMobileDropdownTypes, HeaderMobileLink, type HeaderMobileLinkTypes, HeaderMobileLogo, type HeaderMobileLogoTypes, HeaderMobileMenu, type HeaderMobileMenuTypes, HeaderMobileNav, type HeaderMobileNavTypes, HeaderMobileToggle, type HeaderMobileToggleTypes, HeaderMobileTop, type HeaderMobileTopTypes, type HeaderMobileTypes, type HeaderNavTypes, HeaderRoot, type HeaderTextColor, HeaderTop, HeaderTopDropdown, HeaderTopDropdownLink, type HeaderTopDropdownLinkTypes, type HeaderTopDropdownTypes, HeaderTopLink, type HeaderTopLinkTypes, HeaderTopNav, type HeaderTopNavTypes, type HeaderTopTypes, type HeaderTypes, type HeadingLevel, type HorizontalAlignTypes, Iframe, type IframeTypes, Image, type ImageTypes, InputDate, type InputDateTypes, InputFile, type InputFileTypes, InputNumber, type InputNumberTypes, InputPassword, type InputPasswordTypes, InputRadio, type InputRadioTypes, InputSearch, type InputSearchTypes, InputText, type InputTextTypes, InputTextarea, type InputTextareaTypes, Layout, type LayoutTypes, Link, type LinkAppearance, type LinkTypes, Logo, LogoFallback, type LogoFallbackTypes, type LogoTypes, Modal, type ModalConfigTypes, type ModalTypes, Modals, ModalsContext, type ModalsContextTypes, Note, NoteTitle, type NoteTypes, OptionList, OptionListItem, type OptionListItemTypes, type OptionListTypes, type OptionTypes, PageRoot, type PageRootTypes, Pagination, type PaginationTypes, Progress, type ProgressTypes, type RadioOptionTypes, RichText, type RichTextTypes, type SearchResultTypes, Section, SectionHeader, type SectionHeaderTypes, SectionTitle, type SectionTypes, SelectActions, type SelectActionsTypes, SelectContextRoot, type SelectContextTypes, SelectModal, type SelectModalTypes, SelectPlaceholder, type SelectPlaceholderTypes, SelectRoot, type SelectRootTypes, SelectSearch, SelectTrigger, Skeleton, type SkeletonTypes, type SkeletonVariant, Slider, type SliderBaseTypes, type SliderMark, type SliderOrientation, type SliderRangeTypes, type SliderSingleTypes, type SliderSize, type SliderTrack, type SliderTypes, type SliderValueLabelDisplay, Spinner, type SpinnerTypes, Switch, type SwitchTypes, Tab, TabButton, type TabButtonTypes, type TabContextValue, TabList, type TabListTypes, TabPanel, type TabPanelTypes, TabPanels, type TabPanelsTypes, type TabTypes, Table, TableBody, type TableBodyTypes, TableCaption, type TableCaptionTypes, TableCell, type TableCellTypes, TableFoot, type TableFootTypes, TableHead, type TableHeadTypes, TableHeaderCell, type TableHeaderCellTypes, TableRow, type TableRowTypes, type TableTypes, Title, type TitleTypes, Toast, type ToastConfigTypes, type ToastTypes, Toasts, ToastsContext, Tooltip, type TooltipPosition, type TooltipTypes, type VerticalAlignTypes, Video, type VideoSource, type VideoTrack, type VideoTypes, useHeader, useModals, useSelectContext, useToasts };