import type { fade, fly, scale, slide } from "svelte/transition";
import type { Coords, Middleware, Placement, Strategy } from "@floating-ui/dom";
import type { Component, Snippet } from "svelte";
import type { ClassValue, HTMLAnchorAttributes, HTMLAttributes, HTMLBlockquoteAttributes, HTMLButtonAttributes, HTMLDialogAttributes, HTMLImgAttributes, HTMLInputAttributes, HTMLLabelAttributes, HTMLLiAttributes, HTMLOlAttributes, HTMLSelectAttributes, HTMLSourceAttributes, HTMLTableAttributes, HTMLTdAttributes, HTMLTextareaAttributes, HTMLThAttributes, HTMLTrackAttributes, HTMLVideoAttributes, SVGAttributes, FullAutoFill } from "svelte/elements";
import type { Writable } from "svelte/store";
import type { BlurParams, EasingFunction, FadeParams, FlyParams, ScaleParams, SlideParams, TransitionConfig } from "svelte/transition";
import type { VariantProps } from "tailwind-variants";
import type { Day } from "date-fns";
import type { AlertVariants } from "./alert/theme";
import type { BadgeVariants } from "./badge/theme";
import type { BannerVariants } from "./banner/theme";
import type { ButtonVariants, GradientButtonVariantes, gradientButton } from "./buttons/theme";
import type { CardVariants } from "./card/theme";
import type Slide from "./carousel/Slide.svelte";
import type { CarouselVariants, SlideVariants } from "./carousel/theme";
import type { DrawerHandleVariants, DrawerVariants, DrawerheadVariants } from "./drawer/theme";
import type { DatepickerVariants } from "./datepicker/theme";
import type { FooterCopyrightVariants, FooterLinkVariants } from "./footer/theme";
import type { GalleryVariants } from "./gallery/theme";
import type { IndicatorVariants } from "./indicator/theme";
import type { ListgroupItemVariants, ListgroupVariants } from "./list-group/theme";
import type { MegaMenuVariants } from "./mega-menu/theme";
import type { ModalVariants } from "./modal/theme";
import type { NavbarUlVariants, NavbarHamburgerVariants } from "./navbar/theme";
import type { PaginationNavVariants } from "./pagination/theme";
import type { PopoverVariants } from "./popover/theme";
import type { SidebarVariants, SidebarCtaVariants, SidebarBrandVariants, SidebarDropdownWrapperVariants, SidebarButtonVariants } from "./sidebar/theme";
import type { CardPlaceholderVariants, ImagePlaceholderVariants, ListPlaceholderVariants, SkeletonVariants, TestimonialPlaceholderVariants, TextPlaceholderVariants, VideoPlaceholderVariants, WidgetPlaceholderVariants } from "./skeleton/theme";
import type { SpeedDialVariants, SpeedDialButtonVariants } from "./speed-dial/theme";
import type { SpinnerVariants } from "./spinner/theme";
import type { StepIndicatorVariants } from "./step-indicator/theme";
import type { StepperVariants, ProgressStepperVariants, DetailedStepperVariants, VerticalStepperVariants, BreadcrumbStepperVariants, TimelineStepperVariants } from "./stepper/theme";
import type { PaginationItemVariants, PaginationVariants } from "./pagination/theme";
import type { ProgressbarVariants, ProgressradialVariants } from "./progress/theme";
import type { RatingVariants, AdvancedRatingVariants, ReviewVariants, ScoreRatingVariants } from "./rating/theme";
import type { TableVariants, TableSearchVariants, TableSearchColor } from "./table/theme";
import type { TabsVaraints, TabItemVariants } from "./tabs/theme";
import type { TimelineVariants, ActivityItemVariants, GroupVariants, GroupItemVariants, TimelineItemVariants } from "./timeline/theme";
import type { ToastVaraints } from "./toast/theme";
import type { ToolbarButtonVariants, ToolbarGroupVariants, ToolbarVariants } from "./toolbar/theme";
import type { TooltipVariants } from "./tooltip/theme";
import type { CheckboxButtonVariants, CheckboxVariants } from "./forms/checkbox/theme";
import type { FileuploadViariants } from "./forms/fileupload/theme";
import type { FloatingLabelInputVaratiants } from "./forms/floating-label/theme";
import type { HelperVariants } from "./forms/helper/theme";
import type { InputVariants } from "./forms/input-field/theme";
import type { LabelVariants } from "./forms/label/theme";
import type { RadioVariants } from "./forms/radio/theme";
import type { RangeVariants } from "./forms/range/theme";
import type { SearchVariants } from "./forms/search/theme";
import type { MultiSelectVariants, SelectVariants } from "./forms/select/theme";
import type { TextareaVariants } from "./forms/textarea/theme";
import type { ToggleVariants } from "./forms/toggle/theme";
import type { PhoneInputVariants } from "./forms/phoneinput/theme";
import type { AnchorVariants } from "./typography/a/theme";
import type { BlockquoteVariants } from "./typography/blockquote/theme";
import type { DescriptionListVariants } from "./typography/descriptionlist/theme";
import type { HeadingVariants } from "./typography/heading/theme";
import type { HrVariants } from "./typography/hr/theme";
import type { ImgVariants } from "./typography/img/theme";
import type { ListVariants } from "./typography/list/theme";
import type { ParagraphVariants } from "./typography/paragraph/theme";
import type { SpanVariants } from "./typography/span/theme";
import type { ClipboardVariants } from "./clipboard/theme";
import type { AccordionItemVariants, AccordionVariants } from "./accordion/theme";
import type { AvatarVariants } from "./avatar/theme";
import type { BottomNavHeaderItemVariants, BottomNavHeaderVariants, BottomNavItemVariants, BottomNavVariants } from "./bottom-navigation/theme";
import type { BreadcrumbItemVariants, BreadcrumbVariants } from "./breadcrumb/theme";
import type { ButtonGroupVariants } from "./button-group/theme";
import type { AndroidVariants, DefaultMockupVariants, DesktopVariants, IosVariants, LaptopVariants, SmartwatchVariants, TabletVariants } from "./device-mockups/theme";
import type { ApexOptions } from "apexcharts";
import type { ButtonToggleVariants } from "./forms/button-toggle/theme";
import type { TagsVariants } from "./forms/tags/theme";
import type { VirtualListVariants } from "./virtuallist/theme";
import type { KanbanBoardVariants, KanbanCardVariants } from "./kanban/theme";
import type { TourVariants } from "./tour/theme";
import type { CommandPaletteVariants } from "./command-palette/theme";
import type { ScrollSpyVariants } from "./scroll-spy/theme";
import type { CloseButtonVariants } from "./utils/theme";
import type { DialogVariants } from "./dialog/theme";
export declare const xs = "xs";
export declare const sm = "sm";
export declare const md = "md";
export declare const lg = "lg";
export declare const xl = "xl";
export interface drawerTransitionParamTypes {
    amount?: number;
    delay?: number;
    duration?: number;
    easing?: (t: number) => number;
    opacity?: number;
    x?: number;
    y?: number;
}
export type CloseButtonProps = CloseButtonVariants & AnchorButtonAttributes & {
    onclick?: (ev: MouseEvent) => void;
    name?: string;
    ariaLabel?: string;
    class?: string;
    svgClass?: string;
};
export type NavbarType = {
    navStatus?: boolean;
    breakPoint: "md" | "lg" | "xl" | "xxl";
    activeClass?: string | null;
    nonActiveClass?: string | null;
    closeNav: () => void;
};
export type DeviceVariantType = "default" | "ios" | "android" | "tablet" | "laptop" | "desktop" | "smartwatch";
export declare type SizeType = typeof xs | typeof sm | typeof md | typeof lg | typeof xl;
export interface TransitionParamTypes {
    delay?: number;
    duration?: number;
    easing?: (t: number) => number;
    css?: (t: number, u: number) => string | null;
    tick?: (t: number, u: number) => void;
}
export type ParamsType = FadeParams | BlurParams | FlyParams | SlideParams | ScaleParams | undefined;
export type TransitionFunc = (node: HTMLElement, params: ParamsType) => TransitionConfig;
export interface LinkType {
    name: string;
    href?: string;
    rel?: string;
    active?: boolean;
    [propName: string]: any;
}
export type AnchorButtonAttributes = ({
    href: string;
} & HTMLAnchorAttributes) | ({
    href?: undefined;
} & HTMLButtonAttributes);
export type AnchorDivAttributes = ({
    href: string;
} & HTMLAnchorAttributes) | ({
    href?: undefined;
} & HTMLAttributes<HTMLDivElement>);
export type AnchorButtonDivAttributes = ({
    href: string;
} & HTMLAnchorAttributes) | ({
    href?: undefined;
    onclick: () => void;
} & HTMLButtonAttributes) | ({
    href?: undefined;
    onclick?: undefined;
} & HTMLAttributes<HTMLDivElement>);
export interface AccordionProps extends AccordionVariants, Omit<HTMLAttributes<HTMLDivElement>, "color"> {
    children: Snippet;
    multiple?: boolean;
    activeClass?: string;
    inactiveClass?: string;
    transitionType?: TransitionFunc | "none";
}
export interface AccordionItemProps extends AccordionItemVariants, HTMLAttributes<HTMLDivElement> {
    children: Snippet;
    header?: Snippet;
    arrowup?: Snippet;
    arrowdown?: Snippet;
    headingTag?: "h2" | "h3" | "h4" | "h5" | "h6" | "div";
    activeClass?: string;
    inactiveClass?: string;
    transitionType?: TransitionFunc | "none";
    transitionParams?: ParamsType;
    headerClass?: string;
    contentClass?: string;
}
export interface AlertProps extends Omit<AlertVariants, "icon">, Omit<HTMLAttributes<HTMLDivElement>, "color"> {
    children: Snippet;
    icon?: Snippet;
    alertStatus?: boolean;
    closeIcon?: Component;
    closeAriaLabel?: string;
    transition?: TransitionFunc;
    params?: ParamsType;
    onclick?: () => void;
}
export interface AvatarProps extends AvatarVariants, HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    indicator?: Snippet;
    href?: HTMLAnchorAttributes["href"];
    target?: HTMLAnchorAttributes["target"];
    src?: string;
    dot?: Partial<Omit<IndicatorProps, "children">>;
    alt?: string;
    onclick?: () => void;
}
export interface BadgeProps extends BadgeVariants, Omit<HTMLAttributes<HTMLDivElement>, "color"> {
    children: Snippet;
    icon?: Snippet;
    badgeStatus?: boolean;
    large?: boolean;
    dismissable?: boolean;
    closeAriaLabel?: string;
    href?: HTMLAnchorAttributes["href"];
    target?: HTMLAnchorAttributes["target"];
    transition?: TransitionFunc;
    params?: ParamsType;
    aClass?: ClassValue;
}
export interface BannerProps extends BannerVariants, Omit<HTMLAttributes<HTMLDivElement>, "color" | "onclose"> {
    header?: Snippet;
    open?: boolean;
    dismissable?: boolean;
    closeAriaLabel?: string;
    innerClass?: ClassValue;
    transition?: TransitionFunc;
    params?: ParamsType;
    closeClass?: ClassValue;
    onclose?: (ev: MouseEvent) => void;
}
export interface BottomNavProps extends BottomNavVariants, HTMLAttributes<HTMLDivElement> {
    children: Snippet;
    header?: Snippet;
    activeUrl?: string;
    outerClass?: ClassValue;
    innerClass?: ClassValue;
    activeClass?: ClassValue;
}
export type BottomNavItemProps = BottomNavItemVariants & AnchorButtonAttributes & {
    children: Snippet;
    btnName?: string;
    activeClass?: ClassValue;
    btnClass?: ClassValue;
    spanClass?: ClassValue;
    active?: boolean;
};
export interface BottomNavHeaderProps extends BottomNavHeaderVariants, HTMLAttributes<HTMLDivElement> {
    children: Snippet;
    outerClass?: ClassValue;
    innerClass?: ClassValue;
}
export interface BottomNavHeaderItemProps extends BottomNavHeaderItemVariants, HTMLButtonAttributes {
    itemName: string;
    active?: boolean;
}
export interface BreadcrumbProps extends BreadcrumbVariants, HTMLAttributes<HTMLElement> {
    children: Snippet;
    solid?: boolean;
    olClass?: ClassValue;
    ariaLabel?: string;
}
export interface BreadcrumbItemProps extends BreadcrumbItemVariants, HTMLLiAttributes {
    children: Snippet;
    icon?: Snippet;
    home?: boolean;
    href?: string;
    linkClass?: ClassValue;
    spanClass?: ClassValue;
    homeClass?: ClassValue;
}
export interface ButtonGroupProps extends ButtonGroupVariants, HTMLAttributes<HTMLDivElement> {
    children: Snippet;
    disabled?: boolean;
}
export type GradientButtonColor = NonNullable<VariantProps<typeof gradientButton>["color"]>;
export type HTMLButtonOrAnchorAttributes = Omit<HTMLButtonAttributes & HTMLAnchorAttributes, "color">;
export type ButtonProps = ButtonVariants & AnchorButtonAttributes & {
    tag?: string;
    disabled?: boolean;
    outline?: boolean;
    shadow?: boolean;
    loading?: boolean;
    spinnerProps?: SpinnerProps;
};
export interface GradientButtonProps extends GradientButtonVariantes, HTMLButtonOrAnchorAttributes {
    tag?: string;
    disabled?: boolean;
    href?: string;
    btnClass?: ClassValue;
}
export interface AccordionContextType {
    flush?: boolean;
    activeClass?: string | null;
    inactiveClass?: string | null;
    transitionType?: TransitionFunc | "none";
}
export interface BottomNavContextType {
    activeClass?: string | null;
    activeUrl?: string;
    navType?: BottomNavVariants["navType"];
}
export interface CarouselContextType {
    images: HTMLImgAttributes[];
    index: number;
    lastSlideChange: number;
    slideDuration: number;
    forward: boolean;
    changeSlide: (newIndex: number) => void;
}
export interface DrawerContextType {
    placement: "left" | "right" | "top" | "bottom";
}
export interface DropdownContextType {
    activeUrl: string;
}
export interface PaginationContextType {
    group: boolean;
    table?: boolean;
    size?: "default" | "large";
    activeClasses?: ClassValue;
}
export interface ButtonToggleContextType {
    toggleSelected: (toggleValue: string) => void;
    isSelected: (toggleValue: string) => boolean;
    multiSelect: boolean;
    color?: string;
    size?: "xs" | "sm" | "md" | "lg" | "xl";
    roundedSize?: "sm" | "md" | "lg" | "xl" | "full";
    ctxIconClass?: string;
    ctxBtnClass?: string;
}
export interface ListContextType {
    ctxClass: string;
}
export interface ToolbarContextType {
    separators: boolean;
}
export interface ListGroupContextType {
    active?: boolean;
    horizontal?: boolean;
}
export interface ButtonGroupContextType {
    size: SizeType;
    disabled?: boolean;
}
export type ButtonToggleGroupProps = HTMLAttributes<HTMLDivElement> & {
    multiSelect?: boolean;
    name?: string;
    value?: string | null | string[];
    color?: ButtonToggleVariants["color"];
    size?: ButtonToggleVariants["size"];
    roundedSize?: "sm" | "md" | "lg" | "xl" | "full";
    onSelect?: (val: string | null | string[]) => void;
    children: Snippet;
    ctxIconClass?: ClassValue;
    ctxBtnClass?: ClassValue;
};
export type ButtonToggleProps = ButtonToggleVariants & HTMLButtonAttributes & {
    value: string;
    selected?: boolean;
    children: Snippet;
    iconSlot?: Snippet;
    color?: ButtonToggleVariants["color"];
    iconClass?: ClassValue;
    contentClass?: ClassValue;
    txtClass?: ClassValue;
};
export interface ButtonToggleContext {
    toggleSelected: (toggleValue: string) => void;
    isSelected: (toggleValue: string) => boolean;
}
export type CheckIconProps = SVGAttributes<SVGSVGElement>;
export type CardProps = Omit<CardVariants, "href"> & AnchorDivAttributes & {
    img?: string;
    imgClass?: ClassValue;
    contentClass?: string;
};
export interface CarouselProps extends CarouselVariants, Omit<HTMLAttributes<HTMLDivElement>, "children" | "onchange"> {
    children?: Snippet<[number]>;
    slide?: Snippet<[{
        index: number;
        Slide: typeof Slide;
    }]>;
    images: HTMLImgAttributes[];
    index?: number;
    slideDuration?: number;
    transition?: TransitionFunc;
    duration?: number;
    disableSwipe?: boolean;
    imgClass?: ClassValue;
    onchange?: (x: HTMLImgAttributes) => void;
    isPreload?: boolean;
    slideFit?: SlideProps["fit"];
}
export interface IndicatorsProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    children?: Snippet<[{
        selected: boolean;
        index: number;
    }]>;
    activeClass?: ClassValue;
    inactiveClass?: ClassValue;
    position?: "top" | "bottom";
}
export interface ControlButtonProps extends HTMLButtonAttributes {
    forward: boolean;
    name?: string | null;
    spanClass?: ClassValue;
}
export interface ControlsProps extends Omit<HTMLButtonAttributes, "children"> {
    children?: Snippet<[(forward: boolean) => void]>;
}
export interface ThumbnailProps extends HTMLImgAttributes {
    selected?: boolean;
}
export interface ThumbnailsProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    children?: Snippet<[{
        image: HTMLImgAttributes;
        selected: boolean;
        imgClass: string;
        Thumbnail: Component;
    }]>;
    images: HTMLImgAttributes[];
    index: number;
    ariaLabel?: string;
    imgClass?: ClassValue;
    throttleDelay?: number;
}
export interface SlideProps extends SlideVariants, HTMLImgAttributes {
    image: HTMLImgAttributes;
    transition?: TransitionFunc;
}
export interface ChartProps {
    options: ApexOptions;
    class?: ClassValue;
}
export interface ClipboardProps extends ClipboardVariants, ButtonVariants, Omit<HTMLButtonAttributes, "children" | "color" | "disabled"> {
    children: Snippet<[boolean]>;
    value?: string;
    success?: boolean;
    showLabel?: boolean;
    embedded?: boolean;
}
export interface DarkmodeProps extends HTMLButtonAttributes {
    lightIcon?: Snippet;
    darkIcon?: Snippet;
    size?: "sm" | "md" | "lg";
    ariaLabel?: string;
}
export type DateOrRange = Date | {
    from?: Date;
    to?: Date;
};
export interface ActionSlotParams {
    selectedDate: DateOrRange | undefined;
    handleClear: () => void;
    handleApply: (date: DateOrRange) => void;
    close: () => void;
}
export interface DatepickerProps extends DatepickerVariants, Omit<HTMLAttributes<HTMLDivElement>, "onselect"> {
    value?: Date;
    defaultDate?: Date | null;
    range?: boolean;
    rangeFrom?: Date;
    rangeTo?: Date;
    availableFrom?: Date | null;
    availableTo?: Date | null;
    locale?: string;
    firstDayOfWeek?: Day;
    dateFormat?: Intl.DateTimeFormatOptions;
    placeholder?: string;
    disabled?: boolean;
    required?: boolean;
    color?: ButtonProps["color"];
    inline?: boolean;
    autohide?: boolean;
    showActionButtons?: boolean;
    title?: string;
    onselect?: (x: DateOrRange) => void;
    onclear?: () => void;
    onapply?: (x: DateOrRange) => void;
    inputmode?: HTMLInputAttributes["inputmode"];
    monthColor?: ButtonProps["color"];
    btnClass?: ClassValue;
    inputClass?: ClassValue;
    monthBtnSelected?: ClassValue;
    monthBtn?: ClassValue;
    translationLocale?: string;
    elementRef?: HTMLInputElement;
    actionSlot?: Snippet<[ActionSlotParams]>;
    inputProps?: HTMLInputAttributes;
}
export interface DeviceMockupProps {
    children: Snippet;
    device?: DeviceVariantType;
}
export interface DesktopProps extends DesktopVariants, HTMLAttributes<HTMLElement> {
    children?: Snippet;
    divClass?: ClassValue;
    div2Class?: ClassValue;
    div3Class?: ClassValue;
    div4Class?: ClassValue;
}
export interface LaptopProps extends LaptopVariants, HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    divClass?: ClassValue;
    div2Class?: ClassValue;
    div3Class?: ClassValue;
    div4Class?: ClassValue;
}
export interface AndroidProps extends AndroidVariants, HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    divClass?: ClassValue;
    div2Class?: ClassValue;
    div3Class?: ClassValue;
    div4Class?: ClassValue;
    div5Class?: ClassValue;
    div6Class?: ClassValue;
    div7Class?: ClassValue;
}
export interface DefaultMockupProps extends DefaultMockupVariants, HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    divClass?: ClassValue;
    div2Class?: ClassValue;
    div3Class?: ClassValue;
    div4Class?: ClassValue;
    div5Class?: ClassValue;
    div6Class?: ClassValue;
}
export interface IosProps extends IosVariants, HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    divClass?: ClassValue;
    div2Class?: ClassValue;
    div3Class?: ClassValue;
    div4Class?: ClassValue;
    div5Class?: ClassValue;
    div6Class?: ClassValue;
}
export interface SmartwatchProps extends SmartwatchVariants, HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    divClass?: ClassValue;
    div2Class?: ClassValue;
    div3Class?: ClassValue;
    div4Class?: ClassValue;
    div5Class?: ClassValue;
    div6Class?: ClassValue;
}
export interface TabletProps extends TabletVariants, HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    divClass?: ClassValue;
    div2Class?: ClassValue;
    div3Class?: ClassValue;
    div4Class?: ClassValue;
    div5Class?: ClassValue;
    div6Class?: ClassValue;
}
export interface DialogProps extends DialogVariants, HTMLDialogAttributes {
    onaction?: ({ action, data }: {
        action: string;
        data: FormData;
    }) => any;
    form?: boolean;
    modal?: boolean;
    autoclose?: boolean;
    focustrap?: boolean;
    permanent?: boolean;
    dismissable?: boolean;
    outsideclose?: boolean;
    transition?: TransitionFunc;
    transitionParams?: ParamsType;
}
export interface DrawerProps extends DrawerVariants, Omit<DialogProps, "hidden" | "classes" | "shifted"> {
    /** @deprecated Use `outsideclose` instead. Will be removed in next minor version. */
    activateClickOutside?: boolean;
    /** @deprecated Use `open` instead. Will be removed in next minor version. */
    hidden?: boolean | null;
    offset?: string;
}
export interface DrawerHandleProps extends DrawerHandleVariants, HTMLButtonAttributes {
}
export interface DrawerheadProps extends DrawerheadVariants, HTMLButtonAttributes {
    closeIcon?: Snippet;
    buttonClass?: ClassValue;
    svgClass?: ClassValue;
}
export interface DropdownProps extends PopperProps {
    simple?: boolean;
    activeUrl?: string;
    isOpen?: boolean;
}
export type DropdownDividerProps = HTMLAttributes<HTMLDivElement>;
export interface DropdownHeaderProps extends HTMLAttributes<HTMLDivElement> {
    children: Snippet;
}
export interface DropdownItemProps {
    children: Snippet;
    aClass?: ClassValue;
    activeClass?: ClassValue;
    liClass?: ClassValue;
    classes?: {
        active?: ClassValue;
        base?: ClassValue;
        li?: ClassValue;
    };
    class?: ClassValue;
    href?: string;
    onclick?: (e: MouseEvent) => void;
    [key: string]: any;
}
export interface DropdownGroupProps extends HTMLAttributes<HTMLUListElement> {
    children: Snippet;
}
export type FooterType = "default" | "sticky" | "sitemap" | "socialmedia" | "logo" | undefined;
export interface FooterProps extends HTMLAttributes<HTMLElement> {
    children: Snippet;
    footerType?: FooterType;
}
export interface FooterBrandProps extends HTMLAnchorAttributes {
    children?: Snippet;
    aClass?: ClassValue;
    spanClass?: ClassValue;
    imgClass?: ClassValue;
    href?: string;
    src?: string;
    alt?: string;
    name?: string;
}
export interface FooterCopyrightProps extends FooterCopyrightVariants, HTMLAnchorAttributes {
    spanClass?: ClassValue;
    aClass?: ClassValue;
    href?: string;
    by?: string;
    copyrightMessage?: string;
    year?: number;
    bySpanClass?: ClassValue;
}
export interface FooterIconProps extends HTMLAnchorAttributes {
    children: Snippet;
    href?: string;
    ariaLabel?: string;
}
export interface FooterLinkGroupProps extends HTMLAttributes<HTMLUListElement> {
    children: Snippet;
}
export interface FooterLinkProps extends FooterLinkVariants, HTMLAnchorAttributes {
    children: Snippet;
    liClass?: ClassValue;
    aClass?: ClassValue;
    href?: string;
}
export interface CheckboxItem {
    value: string | number;
    label?: string;
    checked?: boolean | null;
    [key: string]: any;
}
export interface CheckboxProps extends CheckboxVariants, Omit<HTMLInputAttributes, "children" | "color"> {
    children?: Snippet<[{
        value?: string | number;
        checked: boolean;
    } | CheckboxItem]>;
    custom?: boolean;
    inline?: boolean;
    tinted?: boolean;
    rounded?: boolean;
    choices?: CheckboxItem[];
    divClass?: ClassValue;
    labelProps?: Omit<LabelProps, "children">;
}
export interface CheckboxButtonProps extends CheckboxButtonVariants, Omit<HTMLInputAttributes, "size" | "checked"> {
    inline?: boolean;
    pill?: boolean;
    outline?: boolean;
    size?: ButtonProps["size"];
    color?: ButtonProps["color"];
    shadow?: boolean;
}
export interface DropzoneProps extends HTMLInputAttributes {
    children: Snippet;
    files?: FileList | null;
    onDrop?: HTMLLabelAttributes["ondrop"];
    onDragOver?: HTMLLabelAttributes["ondragover"];
    onChange?: HTMLInputAttributes["onchange"];
}
export interface FileuploadProps extends FileuploadViariants, Omit<HTMLInputAttributes, "size"> {
    files?: FileList | null;
    size?: FileuploadViariants["size"];
    color?: InputProps<never>["color"];
    elementRef?: HTMLInputElement;
    clearable?: boolean;
    clearableSvgClass?: ClassValue;
    clearableColor?: CloseButtonVariants["color"];
    clearableOnClick?: () => void;
    clearableClass?: ClassValue;
    wrapperClass?: ClassValue;
}
export interface FloatingLabelInputProps extends FloatingLabelInputVaratiants, Omit<HTMLInputAttributes, "size"> {
    children: Snippet;
    id?: string;
    value?: string | number | readonly string[];
    elementRef?: HTMLInputElement;
    "aria-describedby"?: string;
    variant?: FloatingLabelInputVaratiants["variant"];
    size?: FloatingLabelInputVaratiants["size"];
    color?: FloatingLabelInputVaratiants["color"];
    inputClass?: ClassValue;
    labelClass?: ClassValue;
    clearable?: boolean;
    clearableSvgClass?: ClassValue;
    clearableColor?: CloseButtonVariants["color"];
    clearableClass?: ClassValue;
    clearableOnClick?: () => void;
    data?: string[];
    maxSuggestions?: number;
    onSelect?: (item: string) => void;
    comboClass?: ClassValue;
    placeholder?: string;
}
export interface HelperProps extends HelperVariants, Omit<HTMLAttributes<HTMLParagraphElement>, "color"> {
}
export type InputValue = string | number | string[] | undefined;
export interface InputProps<T extends InputValue = string> extends InputVariants, Omit<HTMLInputAttributes, "size" | "children" | "value"> {
    children?: Snippet<[{
        class: string;
    } & Omit<InputProps<T>, "children" | "left" | "right" | "size">]>;
    left?: Snippet;
    right?: Snippet;
    size?: InputVariants["size"];
    value?: T;
    elementRef?: HTMLInputElement;
    color?: InputVariants["color"];
    leftClass?: ClassValue;
    rightClass?: ClassValue;
    divClass?: ClassValue;
    wrapperClass?: ClassValue;
    clearable?: boolean;
    clearableSvgClass?: ClassValue;
    clearableColor?: CloseButtonVariants["color"];
    clearableClass?: ClassValue;
    clearableOnClick?: () => void;
    data?: string[];
    maxSuggestions?: number;
    onSelect?: (item: string) => void;
    comboClass?: ClassValue;
    comboItemClass?: ClassValue;
    oninput?: (event: Event) => void;
    onfocus?: (event: FocusEvent) => void;
    onblur?: (event: FocusEvent) => void;
    onkeydown?: (event: KeyboardEvent) => void;
    /** @deprecated Use `oninput` instead. Will be removed in next minor version. */
    onInput?: (event: Event) => void;
    /** @deprecated Use `onfocus` instead. Will be removed in next minor version. */
    onFocus?: (event: FocusEvent) => void;
    /** @deprecated Use `onblur` instead. Will be removed in next minor version. */
    onBlur?: (event: FocusEvent) => void;
    /** @deprecated Use `onkeydown` instead. Will be removed in next minor version. */
    onKeydown?: (event: KeyboardEvent) => void;
}
export interface InputAddonProps extends HTMLAttributes<HTMLDivElement> {
    children: Snippet;
    size?: ButtonGroupProps["size"];
}
export interface PhoneInputProps extends PhoneInputVariants, Omit<HTMLInputAttributes, "size" | "children" | "value"> {
    phoneType?: "default" | "floating" | "countryCode" | "copy" | "advanced";
    children?: Snippet;
    floatingLabel?: string;
    labelFor?: string;
    phoneIcon?: boolean;
}
export interface LabelProps extends HTMLLabelAttributes {
    children: Snippet;
    color?: LabelVariants["color"];
    show?: boolean;
}
export interface RadioProps<T> extends RadioVariants, Omit<HTMLInputAttributes, "color"> {
    group?: T;
    value?: T;
    inputClass?: ClassValue;
    labelClass?: ClassValue;
}
export interface RadioButtonProps<T> extends Omit<HTMLInputAttributes, "size"> {
    group?: T;
    value?: T;
    inline?: boolean;
    pill?: boolean;
    outline?: boolean;
    size?: ButtonProps["size"];
    color?: ButtonProps["color"];
    shadow?: boolean;
    checkedClass?: ClassValue;
}
export interface RangeProps extends RangeVariants, Omit<HTMLInputAttributes, "size" | "color"> {
    value?: number | string;
    inputClass?: ClassValue;
}
export interface SearchProps extends SearchVariants, Omit<HTMLInputAttributes, "size"> {
    children?: Snippet;
    value?: string;
    elementRef?: HTMLInputElement;
    clearable?: boolean;
    clearableSvgClass?: ClassValue;
    clearableColor?: CloseButtonVariants["color"];
    clearableClass?: ClassValue;
    clearableOnClick?: () => void;
    inputClass?: ClassValue;
}
export type SelectOptionType<T> = {
    name: string | number;
    value: T;
    disabled?: boolean;
    [key: string]: any;
};
export interface SelectProps<T> extends SelectVariants, Omit<HTMLSelectAttributes, "size" | "disabled"> {
    children?: Snippet;
    items?: SelectOptionType<T>[];
    elementRef?: HTMLSelectElement;
    placeholder?: string;
    selectClass?: ClassValue;
    clearable?: boolean;
    clearableSvgClass?: ClassValue;
    clearableColor?: CloseButtonVariants["color"];
    clearableClass?: ClassValue;
    clearableOnClick?: () => void;
    onClear?: () => void;
    disabled?: boolean;
}
export interface MultiSelectProps<T> extends MultiSelectVariants, Omit<HTMLAttributes<HTMLDivElement>, "size" | "children" | "onchange" | "onblur"> {
    children?: Snippet<[{
        item: SelectOptionType<T>;
        clear: () => void;
    }]>;
    items: SelectOptionType<T>[];
    value: T[];
    dropdownClass?: ClassValue;
    placeholder?: string;
    disabled?: boolean | undefined;
    size?: "sm" | "md" | "lg";
    name?: string | undefined | null;
    form?: string | undefined | null;
    required?: boolean | undefined | null;
    autocomplete?: FullAutoFill | undefined | null;
    onchange?: (event: Event) => void;
    onblur?: (event: FocusEvent) => void;
}
export interface TagsProps extends TagsVariants, HTMLAttributes<HTMLDivElement> {
    value: string[];
    itemClass?: ClassValue;
    placeholder?: string;
    spanClass?: ClassValue;
    closeClass?: ClassValue;
    inputClass?: ClassValue;
    closeBtnSize?: CloseButtonVariants["size"];
    unique?: boolean;
    availableTags?: string[];
    maxSuggestions?: number;
    showHelper?: boolean;
    showAvailableTags?: boolean;
    allowNewTags?: boolean;
    inputProps?: HTMLInputAttributes;
    disabled?: boolean;
}
export type TimePickerType = "default" | "dropdown" | "select" | "range" | "timerange-dropdown" | "timerange-toggle" | "inline-buttons";
export type ColumnCount = 1 | 2 | 3 | 4;
export type TimePickerOption = {
    name: string;
    value: string;
};
export interface TimepickerProps {
    id?: string;
    endId?: string;
    value?: string;
    endValue?: string;
    min?: string;
    max?: string;
    required?: boolean;
    disabled?: boolean;
    inputColor?: InputProps["color"];
    buttonColor?: ButtonProps["color"];
    Icon?: Component;
    iconClass?: string;
    type?: TimePickerType;
    optionLabel?: string;
    options?: TimePickerOption[];
    size?: ButtonGroupVariants["size"];
    divClass?: ClassValue;
    inputClass?: ClassValue;
    selectClass?: ClassValue;
    timerangeLabel?: string;
    timerangeButtonLabel?: string;
    timeIntervals?: string[];
    columns?: ColumnCount;
    onselect?: (data: {
        time: string;
        endTime: string;
        [key: string]: string;
    }) => void;
}
export interface TextareaProps extends TextareaVariants, HTMLTextareaAttributes {
    header?: Snippet;
    footer?: Snippet;
    addon?: Snippet;
    value?: string;
    elementRef?: HTMLTextAreaElement;
    wrapped?: boolean;
    divClass?: ClassValue;
    innerClass?: ClassValue;
    headerClass?: ClassValue;
    footerClass?: ClassValue;
    addonClass?: ClassValue;
    clearable?: boolean;
    clearableSvgClass?: ClassValue;
    clearableColor?: CloseButtonVariants["color"];
    clearableClass?: ClassValue;
    clearableOnClick?: () => void;
    textareaClass?: ClassValue;
}
export interface ToggleProps extends Omit<ToggleVariants, "off_state_label">, Omit<HTMLInputAttributes, "size" | "color"> {
    offLabel?: Snippet;
    value?: string | number;
    checked?: boolean;
    disabled?: boolean;
    spanClass?: ClassValue;
    inputClass?: ClassValue;
}
export type ImgType = {
    src?: string;
    alt?: string;
};
export interface GalleryProps extends GalleryVariants, HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    figure?: Snippet<[item: ImgType]>;
    items?: HTMLImgAttributes[];
    imgClass?: ClassValue;
    height?: string;
    rowHeight?: number;
    columns?: number;
}
export interface IndicatorProps extends HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    color?: IndicatorVariants["color"];
    cornerStyle?: IndicatorVariants["cornerStyle"];
    size?: IndicatorVariants["size"];
    border?: boolean;
    placement?: IndicatorVariants["placement"];
    offset?: boolean;
}
export interface KbdProps extends HTMLAttributes<HTMLElement> {
    children: Snippet;
}
export interface ListGroupItemType {
    name?: string;
    Icon?: Component;
    onclick?: () => void;
    href?: string;
    active?: boolean;
    current?: boolean;
    disabled?: boolean;
    img?: {
        src: string;
        alt: string;
    };
    comment?: string;
    message?: string;
    [key: string]: any;
}
export interface ListgroupProps extends ListgroupVariants, Omit<HTMLAttributes<HTMLUListElement>, "children"> {
    children?: Snippet<[item: ListGroupItemType | string]>;
    items?: (ListGroupItemType | string)[];
    active?: boolean;
    onclick?: (event?: MouseEvent) => void;
    itemClass?: ClassValue;
    aClasss?: ClassValue;
    btnClass?: ClassValue;
    iconClass?: ClassValue;
}
export type ListgroupItemProps = Omit<ListgroupItemVariants, "state"> & AnchorButtonAttributes & {
    current?: boolean;
    disabled?: boolean;
    Icon?: Component;
    iconClass?: ClassValue;
    name?: string;
    children?: Snippet;
};
export interface MegaMenuProps extends MegaMenuVariants, Omit<PopperProps, "children"> {
    children: Snippet<[{
        item: LinkType;
        index: number;
    }]>;
    extra?: Snippet;
    items?: LinkType[];
    full?: boolean;
    ulClass?: ClassValue;
    extraClass?: ClassValue;
    isOpen?: boolean;
}
export interface ModalProps extends ModalVariants, Omit<DialogProps, "classes"> {
    header?: Snippet;
    footer?: Snippet;
    headerClass?: ClassValue;
    bodyClass?: ClassValue;
    footerClass?: ClassValue;
    closeBtnClass?: ClassValue;
    fullscreen?: boolean;
}
export interface MenuProps extends SVGAttributes<SVGSVGElement> {
    size?: string;
    color?: string;
    variation?: "solid" | "outline";
    ariaLabel?: string;
}
export type NavbarState = {
    hidden: boolean;
    activeClass?: string;
    nonActiveClass?: string;
    activeUrl?: string;
};
export type NavbarBreakpoint = "sm" | "md" | "lg" | "xl";
export interface NavbarProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    children: Snippet<[{
        hidden: boolean;
        toggle: () => void;
        NavContainer: Component;
    }]>;
    fluid?: boolean;
    navContainerClass?: ClassValue;
    closeOnClickOutside?: boolean;
    breakpoint?: NavbarBreakpoint;
}
export type NavBrandProps = HTMLAnchorAttributes;
export interface NavContainerProps extends HTMLAttributes<HTMLDivElement> {
    fluid?: boolean;
}
export type NavHamburgerProps = ToolbarButtonProps & NavbarHamburgerVariants & {
    href?: undefined;
    menuClass?: ClassValue;
};
export interface NavUlProps extends NavbarUlVariants, Omit<HTMLAttributes<HTMLDivElement>, "class"> {
    activeUrl?: string;
    ulClass?: ClassValue;
    hidden?: boolean;
    slideParams?: SlideParams;
    transition?: typeof slide | typeof fly | typeof fade | typeof scale;
    transitionParams?: SlideParams | FlyParams | FadeParams | ScaleParams;
    activeClass?: ClassValue;
    nonActiveClass?: ClassValue;
    respectMotionPreference?: boolean;
    class?: ClassValue;
}
export type NavLiProps = AnchorButtonAttributes & {
    activeClass?: ClassValue;
    nonActiveClass?: ClassValue;
};
export interface ToolbarProps extends ToolbarVariants, Omit<HTMLAttributes<HTMLDivElement>, "color"> {
    end?: Snippet;
}
export interface ToolbarGroupProps extends ToolbarGroupVariants, HTMLAttributes<HTMLDivElement> {
}
export type ToolbarButtonProps = ToolbarButtonVariants & AnchorButtonAttributes & {
    name?: string;
};
export type PaginationItemType = {
    size?: "default" | "large";
    active?: boolean | null;
    group?: boolean | null;
    table?: boolean | null;
};
export interface PaginationItemSpecificProps {
    children?: Snippet;
    name?: string;
    href?: string;
    active?: boolean;
    rel?: string;
    size?: "default" | "large";
}
export type PaginationHTMLButtonOrAnchorAttributes = HTMLButtonAttributes & HTMLAnchorAttributes;
export interface PaginationButtonProps extends PaginationItemVariants, PaginationHTMLButtonOrAnchorAttributes {
    children?: Snippet;
    onclick?: () => void;
    disabled?: boolean;
}
export interface PaginationNavProps extends PaginationNavVariants, HTMLAttributes<HTMLElement>, PaginationVariants {
    prevContent?: Snippet;
    nextContent?: Snippet;
    prevClass?: ClassValue;
    nextClass?: ClassValue;
    currentPage: number;
    totalPages: number;
    visiblePages?: number;
    onPageChange: (page: number) => void;
    layout?: "navigation" | "pagination" | "table";
    previousLabel?: string;
    nextLabel?: string;
    showIcons?: boolean;
    ariaLabel?: string;
    size?: "default" | "large";
    spanClass?: ClassValue;
    tableDivClass?: ClassValue;
    classes?: {
        prev?: ClassValue;
        next?: ClassValue;
        span?: ClassValue;
        tableDiv?: ClassValue;
        active?: ClassValue;
    };
}
export interface PaginationItemProps extends PaginationItemVariants, PaginationHTMLButtonOrAnchorAttributes {
    children?: Snippet;
}
export interface PaginationProps extends PaginationVariants, HTMLLiAttributes {
    prevContent?: Snippet;
    nextContent?: Snippet;
    pages?: PaginationItemProps[];
    previous?: () => void;
    next?: () => void;
    ariaLabel?: string;
}
export interface PopoverProps extends PopoverVariants, Omit<PopperProps, "title"> {
    title?: Snippet | string;
    color?: PopoverVariants["color"];
    params?: ParamsType;
    defaultClass?: ClassValue;
    transition?: TransitionFunc;
    isOpen?: boolean;
}
export interface ProgressbarProps extends ProgressbarVariants, Omit<HTMLAttributes<HTMLDivElement>, "color"> {
    progress?: string | number;
    precision?: number;
    tweenDuration?: number;
    animate?: boolean;
    size?: string;
    labelInside?: boolean;
    labelOutside?: string;
    easing?: EasingFunction;
}
export interface ProgressradialProps extends ProgressradialVariants, Omit<HTMLAttributes<HTMLDivElement>, "color"> {
    progress?: number | string;
    radius?: number;
    startingPosition?: "top" | "right" | "bottom" | "left";
    precision?: number;
    tweenDuration?: number;
    animate?: boolean;
    size?: string;
    thickness?: number | string;
    labelInside?: boolean;
    labelOutside?: string;
    easing?: (t: number) => number;
}
export type RatingItem = {
    label: string | null | undefined;
    rating: number;
};
export interface AdvancedRatingProps extends AdvancedRatingVariants, HTMLAttributes<HTMLDivElement> {
    rating?: Snippet;
    globalText?: Snippet;
    ratings: RatingItem[];
    divClass?: ClassValue;
    spanClass?: ClassValue;
    div2Class?: ClassValue;
    div3Class?: ClassValue;
    span2Class?: ClassValue;
    unit?: string;
}
export interface RatingProps extends RatingVariants, HTMLAttributes<HTMLDivElement> {
    children?: Snippet;
    text?: Snippet;
    size?: number;
    total?: number;
    rating?: number;
    icon?: Component;
    count?: boolean;
    pClass?: ClassValue;
}
export interface RatingCommentProps {
    children: Snippet;
    evaluation?: Snippet;
    helpfullink?: string;
    abuselink?: string;
    comment: {
        id?: string;
        user: {
            name?: string;
            img: {
                src: string | undefined | null;
                alt?: string;
            };
            joined?: string;
        };
        total?: number;
        rating: number;
        heading?: string;
        address?: string;
        datetime?: string;
    };
}
export type ReviewType = {
    name?: string;
    imgSrc?: string;
    imgAlt?: string;
    address?: string;
    reviewDate?: string;
    title?: string;
    rating?: number;
    item1?: string;
    item2?: string;
    item3?: string;
};
export interface ReviewProps extends ReviewVariants, HTMLAttributes<HTMLElement> {
    children: Snippet;
    address?: Snippet;
    item1?: Snippet;
    item2?: Snippet;
    item3?: Snippet;
    review?: ReviewType;
    articleClass?: ClassValue;
    divClass?: ClassValue;
    div2Class?: ClassValue;
    div3Class?: ClassValue;
    imgClass?: ClassValue;
    ulClass?: ClassValue;
    liClass?: ClassValue;
}
export interface ScoreRatingProps extends ScoreRatingVariants {
    ratings?: {
        label: string | undefined | null;
        rating: number;
    }[];
    ratings2?: {
        label: string | undefined | null;
        rating: number;
    }[];
    headerLabel?: {
        desc1?: string;
        desc2?: string;
        desc3?: string;
        link?: {
            label: string | undefined | null;
            url: string;
        };
    };
}
export interface RatingIconProps extends SVGAttributes<SVGSVGElement> {
    fillPercent?: number;
    fillColor?: string;
    strokeColor?: string;
    size?: number;
    ariaLabel?: string;
    role?: string;
    svgClass?: ClassValue;
    iconIndex?: number;
    groupId?: string;
    pathd?: string;
}
export type SidebarContextType = {
    closeSidebar?: () => void;
    activeClass?: string;
    nonActiveClass?: string;
    isSingle?: boolean;
    selected?: Writable<object | null>;
    activeUrl?: string;
};
export interface SidebarProps extends SidebarVariants, HTMLAttributes<HTMLElement> {
    children: Snippet;
    isOpen?: boolean;
    closeSidebar?: () => void;
    activateClickOutside?: boolean;
    isSingle?: boolean;
    ariaLabel?: string;
    divClass?: ClassValue;
    nonActiveClass?: ClassValue;
    activeClass?: ClassValue;
    params?: ParamsType;
    transition?: TransitionFunc;
    backdrop?: boolean;
    backdropClass?: ClassValue;
    activeUrl?: string;
    alwaysOpen?: boolean;
    disableBreakpoints?: boolean;
}
export interface SidebarButtonProps extends SidebarButtonVariants, HTMLButtonAttributes {
    breakpoint?: SidebarVariants["breakpoint"];
    svgClass?: ClassValue;
}
export interface SidebarCtaProps extends SidebarCtaVariants, HTMLAttributes<HTMLDivElement> {
    icon?: Snippet;
    divClass?: ClassValue;
    spanClass?: ClassValue;
    label: string;
}
export interface SiteType {
    name?: string;
    href?: string;
    img?: string;
}
export interface SidebarBrandProps extends SidebarBrandVariants, HTMLAnchorAttributes {
    site?: SiteType;
    imgClass?: ClassValue;
    spanClass?: ClassValue;
}
export type Bindable<T> = {
    get(): T;
    set(value: T): void;
};
export interface SidebarDropdownWrapperProps extends SidebarDropdownWrapperVariants, HTMLButtonAttributes {
    children: Snippet;
    arrowup?: Snippet;
    arrowdown?: Snippet;
    icon?: Snippet;
    isOpen?: boolean;
    btnClass?: ClassValue;
    label?: string;
    spanClass?: ClassValue;
    ulClass?: ClassValue;
    params?: ParamsType;
    transition?: TransitionFunc;
    svgClass?: ClassValue;
    onclick?: () => void;
    isSingle?: boolean;
}
export interface SidebarGroupProps extends HTMLAttributes<HTMLUListElement> {
    children: Snippet;
    borderClass?: ClassValue;
    border?: boolean;
}
export interface SidebarItemProps extends HTMLAnchorAttributes {
    icon?: Snippet;
    subtext?: Snippet;
    label?: string;
    spanClass?: ClassValue;
    activeClass?: ClassValue;
    nonActiveClass?: ClassValue;
    aClass?: ClassValue;
    active?: boolean;
}
export interface CardPlaceholderProps extends CardPlaceholderVariants, HTMLAttributes<HTMLDivElement> {
    size?: CardPlaceholderVariants["size"];
}
export interface ImagePlaceholderProps extends ImagePlaceholderVariants, HTMLAttributes<HTMLDivElement> {
    size?: ImagePlaceholderVariants["size"];
    rounded?: ImagePlaceholderVariants["rounded"];
    imgOnly?: boolean;
}
export interface ListPlaceholderProps extends ListPlaceholderVariants, HTMLAttributes<HTMLDivElement> {
    itemNumber?: number;
    size?: ListPlaceholderVariants["size"];
    rounded?: ListPlaceholderVariants["rounded"];
}
export interface SkeletonProps extends SkeletonVariants, HTMLAttributes<HTMLDivElement> {
    size?: SkeletonVariants["size"];
}
export interface TestimonialPlaceholderProps extends TestimonialPlaceholderVariants, HTMLAttributes<HTMLDivElement> {
}
export interface TextPlaceholderProps extends TextPlaceholderVariants, HTMLAttributes<HTMLDivElement> {
    size?: TextPlaceholderVariants["size"];
}
export interface VideoPlaceholderProps extends VideoPlaceholderVariants, HTMLAttributes<HTMLDivElement> {
    size?: VideoPlaceholderVariants["size"];
}
export interface WidgetPlaceholderProps extends WidgetPlaceholderVariants, HTMLAttributes<HTMLDivElement> {
}
export interface SpeedCtxType {
    pill: boolean;
    tooltip: Placement | "none";
    textOutside: boolean;
}
type BaseSpeedDialTriggerProps = {
    children?: any;
    name?: string;
    pill?: boolean;
    icon?: Snippet;
    class?: string;
    [key: string]: any;
};
export type RegularSpeedDialTriggerProps = BaseSpeedDialTriggerProps & {
    gradient?: false;
    color?: ButtonVariants["color"];
};
export type GradientSpeedDialTriggerProps = BaseSpeedDialTriggerProps & {
    gradient: true;
    color?: GradientButtonColor;
};
export type SpeedDialTriggerProps = RegularSpeedDialTriggerProps | GradientSpeedDialTriggerProps;
export type SpeedDialProps = PopperProps & SpeedDialVariants & {
    children: Snippet;
    button?: Snippet;
    popperClass?: ClassValue;
    placement?: Placement;
    tooltip?: Placement | "none";
    trigger?: PopperProps["trigger"];
    textOutside?: boolean;
    pill?: boolean;
    ontoggle?: PopperProps["ontoggle"];
    onbeforetoggle?: PopperProps["onbeforetoggle"];
    isOpen?: boolean;
};
export type SpeedDialButtonProps = ButtonProps & SpeedDialButtonVariants & {
    name?: string;
    tooltip?: Placement | "none";
    pill?: boolean;
    textOutside?: boolean;
    textClass?: ClassValue;
};
export interface SpinnerProps extends SVGAttributes<SVGSVGElement> {
    type?: "default" | "dots" | "bars" | "pulse" | "orbit";
    color?: SpinnerVariants["color"];
    size?: SpinnerVariants["size"];
    currentFill?: string;
    currentColor?: string;
}
export interface StepIndicatorProps extends StepIndicatorVariants, HTMLAttributes<HTMLElement> {
    steps?: string[];
    currentStep?: number;
    size?: StepIndicatorVariants["size"];
    color?: StepIndicatorVariants["color"] | "custom";
    glow?: boolean;
    hideLabel?: boolean;
    clickable?: boolean;
    completedCustom?: string;
    currentCustom?: string;
    onStepClick?: (event: {
        current: number;
        last: number;
    }) => void;
}
export type StepStatus = "completed" | "current" | "pending";
export interface Step {
    id?: number;
    label: string;
    description?: string;
    status?: StepStatus;
    icon?: Component;
    iconClass?: ClassValue;
    descriptionClass?: ClassValue;
}
export interface StepperProps extends HTMLOlAttributes, StepperVariants {
    steps: Step[];
    current?: number;
    clickable?: boolean;
    showCheckmarkForCompleted?: boolean;
    onStepClick?: (event: {
        current: number;
        last: number;
    }) => void;
}
export interface ProgressStep {
    id?: string | number;
    status?: StepStatus;
    icon?: Component;
    iconClass?: ClassValue;
}
export interface ProgressStepperProps extends HTMLOlAttributes, ProgressStepperVariants {
    steps: ProgressStep[];
    current?: number;
    clickable?: boolean;
    showCheckmarkForCompleted?: boolean;
    onStepClick?: (event: {
        current: number;
        last: number;
    }) => void;
}
export interface DetailedStep {
    id: number;
    label: string;
    description?: string;
    status?: "completed" | "current" | "pending";
    icon?: Component;
    iconClass?: ClassValue;
    descriptionClass?: ClassValue;
}
export interface DetailedStepperProps extends HTMLOlAttributes, DetailedStepperVariants {
    steps: DetailedStep[];
    contentClass?: ClassValue;
    current?: number;
    clickable?: boolean;
    showCheckmarkForCompleted?: boolean;
    onStepClick?: (event: {
        current: number;
        last: number;
    }) => void;
}
export interface VerticalStep {
    id: number;
    label: string;
    status?: "completed" | "current" | "pending";
    icon?: Component;
    iconClass?: ClassValue;
}
export interface VerticalStepperProps extends HTMLOlAttributes, VerticalStepperVariants {
    steps: VerticalStep[];
    liClass?: ClassValue;
    current?: number;
    clickable?: boolean;
    showCheckmarkForCompleted?: boolean;
    onStepClick?: (event: {
        current: number;
        last: number;
    }) => void;
}
export interface BreadcrumbStep {
    id: number;
    label: string;
    shortLabel?: string;
    status?: "completed" | "current" | "pending";
    icon?: Component;
    iconClass?: ClassValue;
}
export interface BreadcrumbStepperProps extends BreadcrumbStepperVariants, HTMLOlAttributes {
    steps: BreadcrumbStep[];
    current?: number;
    clickable?: boolean;
    showCheckmarkForCompleted?: boolean;
    onStepClick?: (event: {
        current: number;
        last: number;
    }) => void;
}
export interface TimelineStep {
    id?: string | number;
    label: string;
    description?: string;
    status?: "completed" | "current" | "pending";
    icon?: Component;
    iconClass?: ClassValue;
}
export interface TimelineStepperProps extends HTMLOlAttributes, TimelineStepperVariants {
    steps: TimelineStep[];
    contentClass?: ClassValue;
    current?: number;
    clickable?: boolean;
    showCheckmarkForCompleted?: boolean;
    onStepClick?: (event: {
        current: number;
        last: number;
    }) => void;
}
export type TableContextType = {
    striped?: boolean;
    hoverable?: boolean;
    border?: boolean;
    color?: TableVariants["color"];
};
export type HeadItemType = string | number | {
    text: string;
    [key: string]: string | number | boolean;
};
export interface TableHeadProps extends HTMLAttributes<HTMLTableSectionElement> {
    children?: Snippet;
    headerSlot?: Snippet;
    defaultRow?: boolean;
    headItems?: HeadItemType[];
    striped?: boolean;
    border?: boolean;
    color?: TableVariants["color"];
}
export type TableItemType = Record<string, string | number | boolean>;
export interface TableProps extends TableVariants, Omit<HTMLTableAttributes, "border"> {
    children?: Snippet;
    footerSlot?: Snippet;
    captionSlot?: Snippet;
    divClass?: ClassValue;
    striped?: boolean;
    hoverable?: boolean;
    border?: boolean;
    shadow?: boolean;
    color?: TableVariants["color"];
    items?: TableItemType[];
}
export interface TableBodyRowProps extends HTMLAttributes<HTMLTableRowElement> {
    children?: Snippet;
    striped?: boolean;
    hoverable?: boolean;
    border?: boolean;
    color?: TableVariants["color"];
}
export interface TableBodyCellProps extends HTMLTdAttributes {
    children?: Snippet;
    colspan?: number;
    color?: TableVariants["color"];
    onclick?: () => void;
}
export type CellValue = string | number | boolean | null | undefined;
export type BodyRow = CellValue[] | (Record<string, CellValue> & {
    id?: string | number;
});
export interface TableBodyProps extends HTMLAttributes<HTMLTableSectionElement> {
    children?: Snippet;
    bodyItems?: BodyRow[];
}
export interface TableHeadCellProps<T = any> extends HTMLThAttributes {
    children?: Snippet;
    padding?: string;
    sort?: ((a: T, b: T) => number) | null;
    defaultDirection?: "asc" | "desc";
    defaultSort?: boolean;
    direction?: "asc" | "desc" | null;
}
export type TableSearchType = {
    striped?: boolean;
    hoverable?: boolean;
    color?: string;
};
export interface TableSearchProps extends TableSearchVariants, HTMLTableAttributes {
    children?: Snippet;
    header?: Snippet;
    footer?: Snippet;
    divClass?: ClassValue;
    inputValue?: string;
    striped?: boolean;
    hoverable?: boolean;
    customColor?: string;
    color?: TableSearchColor;
    innerDivClass?: ClassValue;
    inputClass?: ClassValue;
    searchClass?: ClassValue;
    svgDivClass?: ClassValue;
    svgClass?: ClassValue;
    tableClass?: ClassValue;
    placeholder?: string;
    oninput?: (event: Event) => void;
}
export interface TabsProps extends TabsVaraints, HTMLAttributes<HTMLUListElement> {
    children: Snippet;
    selected?: string;
    tabStyle?: TabsVaraints["tabStyle"];
    ulClass?: ClassValue;
    contentClass?: ClassValue;
    divider?: boolean;
}
export interface TabitemProps extends TabItemVariants, HTMLLiAttributes {
    children?: Snippet;
    titleSlot?: Snippet;
    open?: boolean;
    title?: string;
    key?: string;
    activeClass?: ClassValue;
    inactiveClass?: ClassValue;
    disabled?: boolean;
    tabStyle?: TabsVaraints["tabStyle"];
}
export interface TabCtxType {
    activeClass?: string;
    inactiveClass?: string;
    tabStyle?: TabsVaraints["tabStyle"];
    panelId: string;
}
export type SelectedTab = {
    snippet?: Snippet;
    id?: string;
};
export interface TabsContextType {
    activeClasses?: string;
    ctx: TabCtxType;
    registerTab: (tab: SelectedTab) => void;
    unregisterTab: (tabId: string) => void;
}
export type { ThemeConfig } from "./theme";
export interface ActivityType {
    id?: string | number;
    title: HTMLElement | string;
    date: Date | string;
    src: string;
    alt: string;
    text?: HTMLElement | string;
}
export interface ActivityProps extends HTMLOlAttributes {
    children: Snippet;
}
export interface ActivityItemProps extends ActivityItemVariants, HTMLLiAttributes {
    activities: ActivityType[];
    liClass?: string;
    spanClass?: string;
    imgClass?: string;
    outerDivClass?: string;
    innerDivClass?: string;
    timeClass?: string;
    titleClass?: string;
    textClass?: string;
}
export interface GroupProps extends GroupVariants, HTMLOlAttributes {
    children: Snippet;
    divClass?: string;
    timeClass?: string;
    date?: Date | string;
    olClass?: string;
}
export interface GroupItemProps extends GroupItemVariants, HTMLLiAttributes {
    timelines: GroupTimelineType[];
    aClass?: string;
    imgClass?: string;
    divClass?: string;
    titleClass?: string;
    spanClass?: string;
}
export interface GroupTimelineType {
    id?: string | number;
    name?: string | HTMLElement;
    src?: string;
    alt?: string;
    href?: string;
    isPrivate?: boolean;
    comment?: string | HTMLElement;
}
export type DateFormat = "year" | "month-year" | "full-date";
export interface TimelineProps extends HTMLOlAttributes {
    children: Snippet;
    order?: TimelineVariants["order"];
}
type ColorVariant = "primary" | "green" | "orange" | "red" | "blue" | "purple" | "gray";
export interface TimelineItemProps extends TimelineItemVariants, HTMLLiAttributes {
    children: Snippet;
    orientationSlot?: Snippet;
    title: string;
    date: string;
    svgClass?: string;
    liClass?: string;
    defaultDivClass?: string;
    divClass?: string;
    timeClass?: string;
    h3Class?: string;
    dateFormat?: DateFormat;
    color?: ColorVariant;
    isLast?: boolean;
    connectorClass?: string;
    datePrefix?: string;
}
export interface ToastProps extends ToastVaraints, HTMLAttributes<HTMLDivElement> {
    children: Snippet;
    icon?: Snippet;
    toastStatus?: boolean;
    dismissable?: boolean;
    closeAriaLabel?: string;
    color?: ToastVaraints["color"];
    position?: ToastVaraints["position"];
    iconClass?: string;
    contentClass?: string;
    align?: boolean;
    params?: ParamsType;
    transition?: TransitionFunc;
    class?: string;
}
export interface ToastContainerProps extends HTMLAttributes<HTMLDivElement> {
    children: Snippet;
    position?: ToastVaraints["position"];
    class?: ClassValue | null;
}
export interface TooltipProps extends TooltipVariants, PopperProps {
}
export interface AnchorProps {
    children: Snippet;
    color?: AnchorVariants["color"];
    asButton?: boolean;
    onclick?: (event: MouseEvent) => void;
    id?: string;
    class?: string;
    style?: string;
    tabindex?: number;
    title?: string;
    role?: string;
    "aria-label"?: string;
    "data-testid"?: string;
    href?: string;
    target?: string;
    rel?: string;
    download?: string | boolean;
    type?: "button" | "submit" | "reset";
    disabled?: boolean;
    name?: string;
    value?: string | number | string[];
    [key: string]: any;
}
export interface BlockquoteProps extends HTMLBlockquoteAttributes {
    children: Snippet;
    border?: boolean;
    italic?: boolean;
    bg?: boolean;
    alignment?: BlockquoteVariants["alignment"];
    size?: BlockquoteVariants["size"];
}
export interface DescriptionListProps extends HTMLAttributes<HTMLElement> {
    children: Snippet;
    tag: DescriptionListVariants["tag"];
}
export interface HeadingProps extends HTMLAttributes<HTMLElement> {
    children: Snippet;
    tag?: HeadingVariants["tag"];
}
export interface HrProps extends HrVariants, HTMLAttributes<HTMLElement> {
    children?: Snippet;
    divClass?: ClassValue;
    iconDivClass?: ClassValue;
    textSpanClass?: ClassValue;
    innerDivClass?: ClassValue;
    divProps?: HTMLAttributes<HTMLDivElement>;
    hrProps?: HTMLAttributes<HTMLHRElement>;
}
export interface Picture {
    /**
     * Key is format. Value is srcset.
     */
    sources: Record<string, string>;
    img: {
        src: string;
        w: number;
        h: number;
    };
}
export interface ImgProps extends ImgVariants, Omit<HTMLImgAttributes, "children"> {
    children?: Snippet<[{
        class: string;
        restProps: any;
    }]>;
    size?: ImgVariants["size"];
    effect?: ImgVariants["effect"];
    caption?: string;
    figClass?: string;
    captionClass?: string;
    href?: HTMLAnchorElement["href"];
    align?: ImgVariants["align"];
}
export interface EnhandedImgProps extends ImgVariants, Omit<HTMLImgAttributes, "src"> {
    src: string | Picture;
    size?: ImgVariants["size"];
    multiple?: boolean;
    transform?: string;
    effect?: ImgVariants["effect"];
    caption?: string;
    figClass?: string;
    captionClass?: string;
    href?: HTMLAnchorElement["href"];
}
export interface LayoutProps extends HTMLAttributes<HTMLElement> {
    children: Snippet;
}
export interface ListProps extends HTMLOlAttributes {
    children: Snippet;
    tag?: ListVariants["tag"];
    position?: ListVariants["position"];
    ctxClass?: string;
    isContenteditable?: boolean;
}
export interface LiProps extends HTMLLiAttributes {
    children: Snippet;
    icon?: boolean;
}
export interface MarkProps extends HTMLAttributes<HTMLElement> {
    children: Snippet;
}
export interface ParagraphProps extends ParagraphVariants, HTMLAttributes<HTMLParagraphElement> {
    children: Snippet;
    italic?: boolean;
    firstUpper?: boolean;
    justify?: boolean;
}
export interface SecondaryProps extends HTMLAttributes<HTMLElement> {
    children: Snippet;
}
export interface SpanProps extends SpanVariants, HTMLAttributes<HTMLSpanElement> {
    children?: Snippet;
    italic?: boolean;
    underline?: boolean;
    linethrough?: boolean;
    uppercase?: boolean;
}
export interface VideoProps extends HTMLVideoAttributes {
    type?: HTMLSourceAttributes["type"];
    src?: HTMLSourceAttributes["src"];
    trackSrc?: HTMLTrackAttributes["src"];
    srclang?: HTMLTrackAttributes["lang"];
    label?: HTMLTrackAttributes["label"];
}
export interface TriggeredToggleEvent extends ToggleEvent {
    trigger: HTMLElement;
}
export interface PopperProps extends Omit<HTMLAttributes<HTMLDivElement>, "onbeforetoggle" | "ontoggle" | "onclose" | "color"> {
    triggeredBy?: string;
    triggerDelay?: number;
    trigger?: "hover" | "click";
    placement?: Placement;
    arrow?: boolean;
    arrowClass?: string;
    offset?: number;
    role?: "tooltip" | "menu" | "dialog" | "listbox" | "combobox";
    yOnly?: boolean;
    strategy?: Strategy;
    reference?: string;
    middlewares?: Middleware[];
    children: Snippet;
    onbeforetoggle?: (ev: TriggeredToggleEvent) => void;
    ontoggle?: (ev: TriggeredToggleEvent) => void;
    onclose?: (ev: TriggeredToggleEvent) => void;
    transition?: TransitionFunc;
    transitionParams?: ParamsType;
    isOpen?: boolean;
}
export interface ArrowProps {
    placement?: Placement;
    cords: Partial<Coords>;
    strategy?: "absolute" | "fixed";
    class?: ClassValue | null;
}
export interface VirtualListProps<T = unknown> extends VirtualListVariants, Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    children: Snippet<[item: T, index: number]>;
    items?: T[];
    minItemHeight?: number;
    height?: number;
    overscan?: number;
    getItemHeight?: (item: T, index: number) => number;
    scrollToIndex?: (fn: (index: number) => void) => void;
    contained?: boolean;
    ariaLabel?: string;
    class?: ClassValue | null;
}
export interface KanbanCardType {
    id: string | number;
    title: string;
    description?: string;
    tags?: string[];
}
export interface KanbanColumnType {
    id: string | number;
    title: string;
    cards: KanbanCardType[];
    color?: string;
}
export interface KanbanBoardProps extends KanbanBoardVariants, HTMLAttributes<HTMLDivElement> {
    columns?: KanbanColumnType[];
    onMove?: (card: KanbanCardType, from: KanbanColumnType, to: KanbanColumnType) => void;
    onAddCard?: (col: KanbanColumnType) => void;
    cardProps?: Partial<Omit<KanbanCardProps, "card" | "isDragging" | "onDragStart" | "onDragEnd">>;
    class?: ClassValue | null;
}
export interface KanbanCardProps extends KanbanCardVariants, HTMLAttributes<HTMLElement> {
    card: KanbanCardType;
    isDragging?: boolean;
    onDragStart?: (card: KanbanCardType, ev?: DragEvent) => void;
    onDragEnd?: (ev?: DragEvent) => void;
    class?: ClassValue | null;
}
export interface SplitPaneProps {
    direction?: "horizontal" | "vertical";
    minSize?: number;
    responsive?: boolean;
    breakpoint?: number;
    transition?: boolean;
    transitionDuration?: number;
    keyboardStep?: number;
    initialSizes?: number[];
    onResize?: (sizes: number[]) => void;
    children: Snippet;
    class?: ClassValue | null;
}
export interface PaneProps {
    children?: Snippet;
    class?: ClassValue | null;
    style?: string;
}
export interface DividerProps {
    direction: "horizontal" | "vertical";
    index: number;
    onMouseDown: (e: MouseEvent, index: number) => void;
    onTouchStart: (e: TouchEvent, index: number) => void;
    onKeyDown: (e: KeyboardEvent, index: number) => void;
    isDragging: boolean;
    class?: ClassValue | null;
    currentSize: number;
}
export interface SplitPaneContext {
    registerPane: () => number;
    getPaneStyle: (index: number) => string;
    getPaneSize: (index: number) => number;
    shouldRenderDivider: (index: number) => boolean;
    getDirection: () => "horizontal" | "vertical";
    getIsDragging: () => boolean;
    onMouseDown: (e: MouseEvent, index: number) => void;
    onTouchStart: (e: TouchEvent, index: number) => void;
    onKeyDown: (e: KeyboardEvent, index: number) => void;
}
export type TourStep = {
    target: string;
    title?: string;
    description: string;
    placement?: Placement;
};
export interface TourProps extends TourVariants, Omit<HTMLAttributes<HTMLDivElement>, "color"> {
    steps: TourStep[];
    active?: boolean;
    currentStep?: number;
    oncomplete?: () => void;
    onskip?: () => void;
    showOverlay?: boolean;
    scrollBehavior?: ScrollBehavior;
    tooltipOffset?: number;
    highlightClass?: string;
}
export interface CommandItem {
    id: string;
    label: string;
    description?: string;
    /** Icon can be a Svelte Component or a string representing an icon class/name */
    icon?: string | Component;
    keywords?: string[];
    onselect: () => void;
}
export interface CommandPaletteProps extends CommandPaletteVariants, Omit<DialogProps, "classes"> {
    items?: CommandItem[];
    placeholder?: string;
    emptyMessage?: string;
    shortcutKey?: string;
    vim?: boolean;
}
export interface ScrollSpyItem {
    id: string;
    label: string;
    href?: string;
}
export interface ScrollSpyProps extends ScrollSpyVariants, HTMLAttributes<HTMLElement> {
    /** Array of navigation items */
    items: ScrollSpyItem[];
    /** Position of the navigation bar */
    position?: "top" | "left" | "right";
    /** Offset from top when calculating active section (useful for fixed headers) */
    offset?: number;
    /** Enable sticky positioning */
    sticky?: boolean;
    /** Custom class for active item */
    activeClass?: string;
    /** Custom class for inactive item */
    inactiveClass?: string;
    /** Custom class for nav container */
    class?: string;
    /** Enable smooth scroll behavior */
    smoothScroll?: boolean;
    /** Scroll container selector (if scrolling within a container instead of window) */
    scrollContainer?: string;
    /** Callback when active section changes */
    onActiveChange?: (itemId: string) => void;
    /** Callback when navigation item is clicked */
    onNavigate?: (itemId: string) => void;
}
import type { VirtualMasonryVariants } from "./virtual-masonry/theme";
export interface VirtualMasonryProps<T = unknown> extends VirtualMasonryVariants, Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    children: Snippet<[item: T, index: number]>;
    items?: T[];
    columns?: number;
    gap?: number;
    height?: number;
    overscan?: number;
    getItemHeight?: (item: T, index: number) => number;
    scrollToIndex?: (fn: (index: number) => void) => void;
    contained?: boolean;
    ariaLabel?: string;
    class?: ClassValue | null;
}
import type { ClipboardManagerVariants } from "./clipboard-manager/theme";
export interface ClipboardItem {
    id: number;
    text: string;
    pinned?: boolean;
    timestamp: number;
}
export interface ClipboardManagerProps extends ClipboardManagerVariants {
    children?: Snippet<[{
        item: ClipboardItem;
        copyItem: (item: ClipboardItem) => Promise<void>;
        deleteItem: (id: number) => void;
        togglePin: (id: number) => void;
    }]>;
    items?: ClipboardItem[];
    placeholder?: string;
    saveLabel?: string;
    clearLabel?: string;
    limit?: number;
    saveToStorage?: boolean;
    class?: ClassValue | null;
    toastDuration?: number;
    filterSensitive?: boolean;
    maxLength?: number;
    enableSelectionMenu?: boolean;
    selectionTarget?: string;
    showInput?: boolean;
    emptyState?: Snippet;
    storageKey?: string;
    open?: boolean;
    badgeProps?: Omit<BadgeProps, "children">;
    modalProps?: ModalProps;
    detectSensitiveData?: (text: string) => boolean;
}