@mielo-ui/mielo-react/dist/types.d.ts

React components & wrappers around mielo.css framework.

import * as react from 'react';
import { FunctionComponent, ReactNode, HTMLAttributes, ButtonHTMLAttributes, ChangeEventHandler, DetailedHTMLProps, InputHTMLAttributes, MouseEventHandler, MouseEvent } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';

interface DropdownHandles {
    close(): void;
    open(): void;
}
interface DropdownContentProps {
    isOpen: boolean;
    close(): void;
    open(): void;
}
interface DropdownProps {
    content: FunctionComponent<DropdownContentProps>;
    menu: FunctionComponent<DropdownContentProps>;
    menuHeight?: string | number;
    onClose?: () => void;
    onOpen?: () => void;
    opened?: boolean;
    className?: {
        container?: string;
        content?: string;
        menu?: string;
    };
    props?: {
        container?: Record<string, any>;
        content?: Record<string, any>;
        menu?: Record<string, any>;
    };
}

declare const Dropdown: react.ForwardRefExoticComponent<DropdownProps & react.RefAttributes<DropdownHandles>>;

type CoreSize = "mini" | "tiny" | "small" | "large" | "big" | "huge" | "massive";
type CoreAccent = boolean | "warning" | "error" | "success";
type CoreColor = "blue" | "green" | "yellow" | "orange" | "red" | "purple" | "brown" | "pink" | "deeppurple" | "indigo" | "lightgreen" | "deeporange" | "light" | "dark";

type DivProps$i = HTMLAttributes<HTMLDivElement>;
interface ListProps extends DivProps$i {
    children?: ReactNode;
    className?: string;
}

interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
    id?: string;
    children?: ReactNode;
    label?: ReactNode;
    link?: string;
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    icon?: ReactNode;
    transparent?: boolean;
    circular?: boolean;
    tertiary?: boolean;
    filled?: boolean;
    center?: boolean;
    pilled?: boolean;
    active?: boolean;
    hover?: boolean;
}
interface ButtonGroupProps {
    children?: ReactNode;
    className?: string;
}

declare function ButtonGroup$1({ className: _className, children }: ButtonGroupProps): react_jsx_runtime.JSX.Element;
declare namespace ButtonGroup$1 {
    var displayName: string;
}

declare const _default$7: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>> & {
    Group: typeof ButtonGroup$1;
};

interface CheckboxIndicatorIcon {
    indicator?: {
        unchecked?: ReactNode;
        checked?: ReactNode;
    };
    layout?: {
        unchecked?: ReactNode;
        checked?: ReactNode;
    };
}
interface LayoutIconProps {
    unchecked?: ReactNode;
    checked?: ReactNode;
}
interface CheckboxProps {
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    className?: string;
    icon?: CheckboxIndicatorIcon;
    circular?: boolean;
    toggle?: boolean;
    children?: string | ReactNode;
    label?: string | ReactNode;
    disabled?: boolean;
    checked?: boolean;
    name?: string;
    onChange?: ChangeEventHandler<HTMLInputElement>;
}

declare const Checkbox$1: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;

type ProgressIndeterminate = "pulsating" | "filling" | "sliding" | "swinging";
interface ProgressProps {
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    className?: string;
    multiple?: boolean;
    children?: ReactNode;
}
interface ProgressBarProps {
    accent?: CoreAccent;
    color?: CoreColor | string;
    indeterminate?: ProgressIndeterminate;
    className?: string;
    progressVisible?: boolean;
    transparent?: boolean;
    children?: ReactNode;
    progress?: number;
}

declare const _default$6: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>> & {
    Bar: react.ForwardRefExoticComponent<ProgressBarProps & react.RefAttributes<HTMLDivElement>>;
};

declare const ProgressBar$1: react.ForwardRefExoticComponent<ProgressBarProps & react.RefAttributes<HTMLDivElement>>;

declare const Select$1: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<SelectHandles>>;

type DivProps$h = HTMLAttributes<HTMLDivElement>;
type LabelFloating = boolean | "ftl" | "ftr" | "fbl" | "fbr";
interface LabelProps extends DivProps$h {
    floating?: LabelFloating;
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    children?: ReactNode;
    transparent?: boolean;
    circular?: boolean;
    bordered?: boolean;
}

declare const Label$1: react.ForwardRefExoticComponent<LabelProps & react.RefAttributes<HTMLDivElement>>;

type DivProps$g = HTMLAttributes<HTMLDivElement>;
interface DividerProps extends DivProps$g {
    children?: ReactNode;
}

declare function Divider$1({ className: _className, children, ...rest }: DividerProps): react_jsx_runtime.JSX.Element;
declare namespace Divider$1 {
    var displayName: string;
}

type DivProps$f = Omit<HTMLAttributes<HTMLDivElement>, "title">;
interface HeaderProps extends DivProps$f {
    icon?: JSX.Element;
    subtitle?: ReactNode;
    title?: ReactNode;
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    className?: string;
    iconSided?: boolean;
    flattened?: boolean;
    inverted?: boolean;
    center?: boolean;
}

declare const Header$1: react.ForwardRefExoticComponent<HeaderProps & react.RefAttributes<HTMLDivElement>>;

interface EntryCustomProps {
    postfix?: ReactNode;
    prefix?: ReactNode;
}
type InputProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "prefix" | "postfix" | "size" | "accent">;
interface EntryProps extends InputProps, EntryCustomProps {
    containerId?: string;
    label?: string;
    value?: string;
    transparent?: boolean;
    bordered?: boolean;
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
}

declare const Entry$1: react.ForwardRefExoticComponent<Omit<EntryProps, "ref"> & react.RefAttributes<HTMLInputElement>>;

interface ImageProps extends HTMLAttributes<HTMLElement> {
    children?: ReactNode;
    className?: string;
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    transparent?: boolean;
    container?: boolean;
    circular?: boolean;
    bordered?: boolean;
    src?: string;
}

declare const Image$1: react.ForwardRefExoticComponent<ImageProps & react.RefAttributes<HTMLElement>>;

type RadioInput = Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">;
interface RadioProps extends RadioInput {
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    children?: ReactNode;
}

declare const Radio$1: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;

type DivProps$e = HTMLAttributes<HTMLDivElement>;
interface IconProps extends DivProps$e {
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    className?: string;
    icon: ReactNode;
    circular?: boolean;
    filled?: boolean;
    bg?: true;
}

declare const Icon$1: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<HTMLDivElement>>;

type DivProps$d<E = HTMLDivElement> = Omit<HTMLAttributes<E>, "title" | "content">;
interface ItemProps<E> extends DivProps$d<E> {
    description?: ReactNode;
    content?: ReactNode;
    title?: ReactNode;
    link?: string;
    icon?: ReactNode;
    side?: ReactNode;
    label?: ReactNode;
    activatable?: boolean;
    active?: boolean;
    hover?: boolean;
    inverted?: boolean;
    vertical?: boolean;
    center?: boolean;
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    disableSidePropagation?: boolean;
    className?: string;
    tabIndex?: number;
}

declare const Item$1: react.ForwardRefExoticComponent<ItemProps<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;

type DivProps$c = Omit<HTMLAttributes<HTMLDivElement>, "title" | "content">;
interface TextProps extends DivProps$c {
    className?: string;
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    muted?: boolean;
    invert?: boolean;
    fsemibold?: boolean;
    fregular?: boolean;
    flight?: boolean;
    fbold?: boolean;
    element?: "div" | "p" | "a";
    children?: ReactNode;
    center?: boolean;
}

declare const Text$1: react.ForwardRefExoticComponent<TextProps & react.RefAttributes<HTMLDivElement>>;

declare const _default$5: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>> & {
    Item: react.ForwardRefExoticComponent<ItemProps<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
};

type DivProps$b = Omit<HTMLAttributes<HTMLDivElement>, "prefix" | "postfix" | "onChange">;
type SelectMenuListProps = LayoutProps<ListProps> & React.RefAttributes<HTMLDivElement>;
interface OptionValue extends Omit<ItemProps<HTMLDivElement>, "onClick" | "disableSidePropagation" | "link"> {
    value: any;
}
interface CustomItemProps {
    option: OptionValue;
    isSelected: boolean;
    onSelect(option: OptionValue): void;
}
interface SelectCustomProps {
    postfix?: ReactNode;
    prefix?: ReactNode;
}
interface SelectButtonProps extends SelectCustomProps, DropdownContentProps {
    selected?: OptionValue;
    label?: string;
    name?: string;
    size?: false | CoreSize;
    accent?: CoreAccent;
}
interface SelectHandles {
}
interface SelectProps extends DivProps$b, SelectCustomProps {
    options: OptionValue[];
    value?: OptionValue;
    label?: string;
    name: string;
    className?: string;
    transparent?: boolean;
    bordered?: boolean;
    disabled?: boolean;
    opened?: boolean;
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    customItem?: FunctionComponent<CustomItemProps>;
    listProps?: SelectMenuListProps;
    onChange: (option: OptionValue) => void;
    onClose?: () => void;
    onOpen?: () => void;
    menuHeight?: number | string;
}

type IndentSize = boolean | "none" | "mini" | "tiny" | "small" | "medium" | "large" | "big" | "huge" | "massive";
interface LayoutIndentPadding {
    p?: IndentSize;
    ph?: IndentSize;
    pv?: IndentSize;
    pt?: IndentSize;
    pr?: IndentSize;
    pb?: IndentSize;
    pl?: IndentSize;
}
interface LayoutIndentMargin {
    m?: IndentSize;
    mh?: IndentSize;
    mv?: IndentSize;
    mt?: IndentSize;
    mr?: IndentSize;
    mb?: IndentSize;
    ml?: IndentSize;
}
interface LayoutIndentProps extends LayoutIndentMargin, LayoutIndentPadding {
}

interface LayoutSpaceBetweenProps {
    sbh?: IndentSize;
    sbv?: IndentSize;
}

type RoundSize = boolean | "none" | "tiny" | "small" | "large" | "circular";
interface LayoutRoundedProps {
    r?: RoundSize;
    rt?: RoundSize;
    rb?: RoundSize;
    rl?: RoundSize;
    rr?: RoundSize;
    rtl?: RoundSize;
    rtr?: RoundSize;
    rbl?: RoundSize;
    rbr?: RoundSize;
}

type ShadowType = boolean | "inner" | "outer";
interface LayoutShadowProps {
    shadow?: ShadowType;
}

interface LayoutFlexProps {
    fjc?: "start" | "end" | "stretch" | "center";
    fai?: "start" | "end" | "stretch" | "center";
    f?: boolean;
    f1?: boolean;
    fw?: boolean;
    fc?: boolean;
    fr?: boolean;
}

interface LayoutGapProps {
    g?: IndentSize;
    gr?: IndentSize;
    gc?: IndentSize;
}

interface LayoutClassNameProps extends LayoutRoundedProps, LayoutSpaceBetweenProps, LayoutIndentProps, LayoutShadowProps, LayoutFlexProps, LayoutGapProps {
}

type LayoutProps<T> = Partial<LayoutSpaceBetweenProps & LayoutRoundedProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps> & T;
interface LayoutExtractedProps {
    spaceBetween: LayoutSpaceBetweenProps;
    padding: LayoutIndentPadding;
    margin: LayoutIndentMargin;
    rounded: LayoutRoundedProps;
    shadow: LayoutShadowProps;
    flex: LayoutFlexProps;
    gap: LayoutGapProps;
}
declare function extractProps<T>({ fjc, fai, fc, fw, f1, fr, f, p, ph, pv, pt, pr, pb, pl, m, mh, mv, mt, mr, mb, ml, r, rt, rb, rl, rr, rtl, rtr, rbl, rbr, g, gr, gc, sbh, sbv, shadow, ...props }: LayoutProps<T>): LayoutExtractedProps & {
    props: T;
};

interface ElementLayoutOptions {
    padding?: boolean;
    margin?: boolean;
    spaceBetween?: boolean;
    rounded?: boolean;
    shadow?: boolean;
    flex?: boolean;
    gap?: boolean;
}
declare function collectClassnames(layout: LayoutExtractedProps, options: ElementLayoutOptions): (string | boolean | undefined)[];

interface ElementLayoutComponentProps extends LayoutClassNameProps {
    [key: string]: any;
}
interface ElementLayoutProps {
    component: FunctionComponent<any>;
    options?: ElementLayoutOptions;
    props?: ElementLayoutComponentProps;
}
declare const ElementLayout: react.ForwardRefExoticComponent<Omit<any, "ref"> & react.RefAttributes<any>>;

declare const Divider: react.ForwardRefExoticComponent<DividerProps & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Header: react.ForwardRefExoticComponent<HeaderProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<SelectHandles> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Entry: react.ForwardRefExoticComponent<Omit<EntryProps, "ref"> & react.RefAttributes<HTMLInputElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Text: react.ForwardRefExoticComponent<TextProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Item: react.ForwardRefExoticComponent<ItemProps<HTMLDivElement> & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Label: react.ForwardRefExoticComponent<LabelProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Image: react.ForwardRefExoticComponent<ImageProps & react.RefAttributes<HTMLElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const ButtonGroup: react.ForwardRefExoticComponent<ButtonGroupProps & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps> & {
    Group: react.ForwardRefExoticComponent<ButtonGroupProps & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
};
declare const ProgressBar: react.ForwardRefExoticComponent<ProgressBarProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps> & {
    Bar: react.ForwardRefExoticComponent<ProgressBarProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
};

declare const components_Button: typeof Button;
declare const components_ButtonGroup: typeof ButtonGroup;
declare const components_Checkbox: typeof Checkbox;
declare const components_Divider: typeof Divider;
declare const components_Entry: typeof Entry;
declare const components_Header: typeof Header;
declare const components_Icon: typeof Icon;
declare const components_Image: typeof Image;
declare const components_Item: typeof Item;
declare const components_Label: typeof Label;
declare const components_Progress: typeof Progress;
declare const components_ProgressBar: typeof ProgressBar;
declare const components_Radio: typeof Radio;
declare const components_Select: typeof Select;
declare const components_Text: typeof Text;
declare namespace components {
  export { components_Button as Button, components_ButtonGroup as ButtonGroup, components_Checkbox as Checkbox, components_Divider as Divider, components_Entry as Entry, components_Header as Header, components_Icon as Icon, components_Image as Image, components_Item as Item, components_Label as Label, components_Progress as Progress, components_ProgressBar as ProgressBar, components_Radio as Radio, components_Select as Select, components_Text as Text };
}

type DivProps$a = HTMLAttributes<HTMLDivElement>;
interface DialogActionProps extends Pick<ButtonProps, "size" | "label" | "accent" | "icon" | "onClick"> {
}
interface DialogProps extends DivProps$a {
    onRequestClose?: () => void;
    isOpen?: boolean;
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    className?: string;
    children?: ReactNode;
    actions?: ReactNode;
    attached?: "modal";
}

type DivProps$9 = HTMLAttributes<HTMLDivElement>;
type ConfirmAccent = boolean | "warning" | "error" | "success";
type ConfirmSize = "small" | "large";
interface ConfirmAction<N = string> {
    accent?: boolean | "warning" | "error" | "success";
    label?: string;
    name: N;
}
interface ConfirmResult {
    isCustomAction: boolean;
    isConfirmed: boolean;
    isCanceled: boolean;
    isRejected: boolean;
    action: string;
}
interface ConfirmHandles {
    confirm(): Promise<ConfirmResult>;
}
interface ConfirmProps extends DivProps$9 {
    header?: LayoutProps<HeaderProps>;
    children?: ReactNode;
    accent?: ConfirmAccent;
    size?: false | ConfirmSize;
    actions?: Record<string, ConfirmAction>;
    disableOverlayClose?: boolean;
}

declare const Confirm: react.ForwardRefExoticComponent<ConfirmProps & react.RefAttributes<ConfirmHandles>>;

declare const Dialog$1: react.ForwardRefExoticComponent<DialogProps & react.RefAttributes<HTMLDivElement>>;

interface MessageProps {
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    marked?: boolean;
    banner?: boolean;
    attached?: "headerbar";
    children?: ReactNode;
    description?: ReactNode;
    title?: ReactNode;
    icon?: ReactNode;
    onClose?: () => void;
}
interface MessageContentProps {
    description?: ReactNode;
    title?: ReactNode;
    icon?: ReactNode;
    onClose?: () => void;
}

declare function MessageContent$1({ description, onClose, title, icon, }: MessageContentProps): react_jsx_runtime.JSX.Element;

declare const _default$4: react.ForwardRefExoticComponent<MessageProps & react.RefAttributes<HTMLDivElement>> & {
    Content: typeof MessageContent$1;
};

interface RawTabsProps {
    children?: ReactNode;
    accent?: CoreAccent;
    color?: CoreColor | string;
    className?: string;
}
interface TabBackgroundProps extends LayoutIndentProps, LayoutRoundedProps, LayoutShadowProps {
    height: number | string;
    offset: number | string;
    width: number | string;
    accent?: CoreAccent;
    color?: CoreColor | string;
    className?: string;
}
interface TabOption {
    accent?: CoreAccent;
    color?: CoreColor | string;
    icon?: JSX.Element;
    title: ReactNode;
    name: string;
}
interface TabProps extends TabOption, LayoutIndentProps, LayoutRoundedProps, LayoutShadowProps {
    onClick?: (event: any) => void;
    className?: string;
    transparent?: boolean;
    selected: string;
    index: number;
}
interface TabsProps extends LayoutIndentProps, LayoutRoundedProps, LayoutShadowProps {
    onChange?: (name: string) => void;
    transparent?: boolean;
    animated?: boolean;
    className?: string;
    accent?: CoreAccent;
    color?: CoreColor | string;
    tabs: TabOption[] | Record<string, TabOption>;
    selected: string;
    tabProps?: Omit<TabProps, "transparent" | "selected" | "index" | "onClick">;
}
interface TabsHandles {
}

declare const _default$3: react.ForwardRefExoticComponent<TabsProps & react.RefAttributes<TabsHandles>> & {
    Raw: react.ForwardRefExoticComponent<RawTabsProps & react.RefAttributes<HTMLDivElement>>;
};

declare const RawTabs: react.ForwardRefExoticComponent<RawTabsProps & react.RefAttributes<HTMLDivElement>>;

declare const Tab: react.ForwardRefExoticComponent<TabProps & react.RefAttributes<HTMLDivElement>>;

type DivProps$8 = HTMLAttributes<HTMLDivElement>;
interface HeaderBarProps extends DivProps$8 {
    accent?: CoreAccent;
    color?: CoreColor | string;
    className?: string;
    transparent?: boolean;
    bordered?: boolean;
    header?: ReactNode;
    right?: ReactNode;
    left?: ReactNode;
    controls?: ReactNode;
    "data-desktop-drag"?: boolean;
}

declare const HeaderBar$1: react.ForwardRefExoticComponent<HeaderBarProps & react.RefAttributes<HTMLDivElement>>;

type DivProps$7 = HTMLAttributes<HTMLDivElement>;
interface SplitViewProps extends DivProps$7 {
    accent?: CoreAccent;
    color?: CoreColor | string;
    contentClassName?: string;
    className?: string;
    headerbar?: ReactNode;
    children?: ReactNode;
    sidebar?: ReactNode;
    overlay?: MouseEventHandler<HTMLDivElement>;
}

type DivProps$6 = HTMLAttributes<HTMLDivElement>;
interface SidebarProps extends DivProps$6 {
    animateStyle?: "overlap" | "width" | "shift";
    size?: false | CoreSize;
    accent?: CoreAccent;
    color?: CoreColor | string;
    className?: string;
    headerbar?: ReactNode;
    children?: ReactNode;
    opened?: boolean;
}

declare const Sidebar: react.ForwardRefExoticComponent<SidebarProps & react.RefAttributes<HTMLDivElement>>;

declare const _default$2: react.ForwardRefExoticComponent<SplitViewProps & react.RefAttributes<HTMLDivElement>> & {
    Sidebar: react.ForwardRefExoticComponent<SidebarProps & react.RefAttributes<HTMLDivElement>>;
};

type DivProps$5 = HTMLAttributes<HTMLDivElement>;
interface WindowProps extends DivProps$5 {
    accent?: CoreAccent;
    color?: CoreColor;
    headerbar?: HeaderBarProps;
    split?: SplitViewProps;
    children?: ReactNode;
    transparent?: boolean;
}
type WindowControlType = "maximize" | "minimize" | "restore" | "close";
type WindowControlIcons = Partial<Record<WindowControlType, ReactNode>>;
type OnClickControl = (event: MouseEvent<HTMLButtonElement>, controlType: WindowControlType) => void;
interface WindowControlsProps extends DivProps$5 {
    onClickControl?: OnClickControl;
    controls: WindowControlType[];
    icons?: WindowControlIcons;
    className?: string;
}

declare const WindowControls: react.ForwardRefExoticComponent<WindowControlsProps & react.RefAttributes<HTMLDivElement>>;

declare const _default$1: react.ForwardRefExoticComponent<WindowProps & react.RefAttributes<HTMLDivElement>> & {
    Controls: react.ForwardRefExoticComponent<WindowControlsProps & react.RefAttributes<HTMLDivElement>>;
};

type DivProps$4 = HTMLAttributes<HTMLDivElement>;
interface RowsProps extends DivProps$4 {
    children: ReactNode;
    className?: string;
}
interface RowProps<E = HTMLDivElement> extends ItemProps<E> {
    className?: string;
}
interface SelectRowProps extends SelectProps {
}
interface EntryRowProps extends EntryProps {
}

declare const SelectRow$1: react.ForwardRefExoticComponent<SelectRowProps & react.RefAttributes<HTMLDivElement>>;

declare const EntryRow$1: react.ForwardRefExoticComponent<Omit<EntryRowProps, "ref"> & react.RefAttributes<HTMLInputElement>>;

declare const Row$1: react.ForwardRefExoticComponent<RowProps<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;

declare const _default: react.ForwardRefExoticComponent<RowsProps & react.RefAttributes<HTMLDivElement>> & {
    Select: react.ForwardRefExoticComponent<SelectRowProps & react.RefAttributes<HTMLDivElement>>;
    Entry: react.ForwardRefExoticComponent<Omit<EntryRowProps, "ref"> & react.RefAttributes<HTMLInputElement>>;
    Row: react.ForwardRefExoticComponent<RowProps<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
};

type DivProps$3 = HTMLAttributes<HTMLDivElement>;
interface ActivatableProps extends DivProps$3 {
    accent?: CoreAccent;
    color?: CoreColor | string;
    children?: ReactNode;
    active?: boolean;
    hover?: boolean;
}

declare const Activatable$1: react.ForwardRefExoticComponent<ActivatableProps & react.RefAttributes<HTMLDivElement>>;

type DivProps$2 = HTMLAttributes<HTMLDivElement>;
type ViewBg = "panel" | "windows" | "content" | "osd";
interface ViewProps extends DivProps$2 {
    accent?: CoreAccent;
    color?: CoreColor | string;
    activatable?: boolean;
    bordered?: boolean;
    bg?: ViewBg;
    scrollable?: boolean;
    children?: ReactNode;
}

declare const View$1: react.ForwardRefExoticComponent<ViewProps & react.RefAttributes<HTMLDivElement>>;

type DivProps$1 = HTMLAttributes<HTMLDivElement>;
interface ModalProps extends DivProps$1 {
    onRequestClose?: () => void;
    children?: ReactNode;
    isOpen?: boolean;
}
interface PortalProps {
    onRequestClose?: () => void;
    children: React.ReactNode;
    isOpen?: boolean;
}

declare function Portal({ children, ...props }: PortalProps): react_jsx_runtime.JSX.Element;

declare const Modal: react.ForwardRefExoticComponent<ModalProps & react.RefAttributes<HTMLDivElement>>;

type DivProps = HTMLAttributes<HTMLDivElement>;
interface CollapsibleProps extends DivProps {
    children?: ReactNode;
    className?: string;
    open?: boolean;
}

declare const Collapsible$1: react.ForwardRefExoticComponent<CollapsibleProps & react.RefAttributes<HTMLDivElement>>;

interface ClampProps {
    children?: ReactNode;
    header?: ReactNode;
}

declare function Clamp({ header, children }: ClampProps): react_jsx_runtime.JSX.Element;
declare namespace Clamp {
    var displayName: string;
}

declare const Window: react.ForwardRefExoticComponent<WindowProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const View: react.ForwardRefExoticComponent<ViewProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Dialog: react.ForwardRefExoticComponent<DialogProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const HeaderBar: react.ForwardRefExoticComponent<HeaderBarProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Activatable: react.ForwardRefExoticComponent<ActivatableProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Collapsible: react.ForwardRefExoticComponent<CollapsibleProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const MessageContent: react.ForwardRefExoticComponent<MessageContentProps & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Message: react.ForwardRefExoticComponent<MessageProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps> & {
    Content: react.ForwardRefExoticComponent<MessageContentProps & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
};
declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps> & {
    Item: react.ForwardRefExoticComponent<ItemProps<HTMLDivElement> & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
};
declare const SelectRow: react.ForwardRefExoticComponent<SelectRowProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const EntryRow: react.ForwardRefExoticComponent<Omit<EntryRowProps, "ref"> & react.RefAttributes<HTMLInputElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Row: react.ForwardRefExoticComponent<RowProps<HTMLDivElement> & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
declare const Rows: react.ForwardRefExoticComponent<RowsProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps> & {
    Select: react.ForwardRefExoticComponent<SelectRowProps & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
    Entry: react.ForwardRefExoticComponent<Omit<EntryRowProps, "ref"> & react.RefAttributes<HTMLInputElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
    Row: react.ForwardRefExoticComponent<RowProps<HTMLDivElement> & react.RefAttributes<HTMLDivElement> & LayoutRoundedProps & LayoutSpaceBetweenProps & LayoutIndentProps & LayoutShadowProps & LayoutFlexProps & LayoutGapProps>;
};

declare const containers_Activatable: typeof Activatable;
declare const containers_Collapsible: typeof Collapsible;
declare const containers_Dialog: typeof Dialog;
declare const containers_EntryRow: typeof EntryRow;
declare const containers_HeaderBar: typeof HeaderBar;
declare const containers_List: typeof List;
declare const containers_Message: typeof Message;
declare const containers_MessageContent: typeof MessageContent;
declare const containers_Row: typeof Row;
declare const containers_Rows: typeof Rows;
declare const containers_SelectRow: typeof SelectRow;
declare const containers_View: typeof View;
declare const containers_Window: typeof Window;
declare namespace containers {
  export { containers_Activatable as Activatable, containers_Collapsible as Collapsible, containers_Dialog as Dialog, containers_EntryRow as EntryRow, containers_HeaderBar as HeaderBar, containers_List as List, containers_Message as Message, containers_MessageContent as MessageContent, containers_Row as Row, containers_Rows as Rows, containers_SelectRow as SelectRow, containers_View as View, containers_Window as Window };
}

declare const Layout_Activatable: typeof Activatable;
declare const Layout_Button: typeof Button;
declare const Layout_ButtonGroup: typeof ButtonGroup;
declare const Layout_Checkbox: typeof Checkbox;
declare const Layout_Collapsible: typeof Collapsible;
declare const Layout_Dialog: typeof Dialog;
declare const Layout_Divider: typeof Divider;
declare const Layout_ElementLayout: typeof ElementLayout;
type Layout_ElementLayoutOptions = ElementLayoutOptions;
type Layout_ElementLayoutProps = ElementLayoutProps;
declare const Layout_Entry: typeof Entry;
declare const Layout_EntryRow: typeof EntryRow;
declare const Layout_Header: typeof Header;
declare const Layout_HeaderBar: typeof HeaderBar;
declare const Layout_Icon: typeof Icon;
declare const Layout_Image: typeof Image;
declare const Layout_Item: typeof Item;
declare const Layout_Label: typeof Label;
type Layout_LayoutClassNameProps = LayoutClassNameProps;
type Layout_LayoutFlexProps = LayoutFlexProps;
type Layout_LayoutIndentMargin = LayoutIndentMargin;
type Layout_LayoutIndentPadding = LayoutIndentPadding;
type Layout_LayoutIndentProps = LayoutIndentProps;
type Layout_LayoutProps<T> = LayoutProps<T>;
type Layout_LayoutRoundedProps = LayoutRoundedProps;
type Layout_LayoutShadowProps = LayoutShadowProps;
declare const Layout_List: typeof List;
declare const Layout_Message: typeof Message;
declare const Layout_MessageContent: typeof MessageContent;
declare const Layout_Progress: typeof Progress;
declare const Layout_ProgressBar: typeof ProgressBar;
declare const Layout_Radio: typeof Radio;
declare const Layout_Row: typeof Row;
declare const Layout_Rows: typeof Rows;
declare const Layout_Select: typeof Select;
declare const Layout_SelectRow: typeof SelectRow;
declare const Layout_Text: typeof Text;
declare const Layout_View: typeof View;
declare const Layout_Window: typeof Window;
declare const Layout_collectClassnames: typeof collectClassnames;
declare const Layout_extractProps: typeof extractProps;
declare namespace Layout {
  export { Layout_Activatable as Activatable, Layout_Button as Button, Layout_ButtonGroup as ButtonGroup, Layout_Checkbox as Checkbox, Layout_Collapsible as Collapsible, Layout_Dialog as Dialog, Layout_Divider as Divider, Layout_ElementLayout as ElementLayout, type Layout_ElementLayoutOptions as ElementLayoutOptions, type Layout_ElementLayoutProps as ElementLayoutProps, Layout_Entry as Entry, Layout_EntryRow as EntryRow, Layout_Header as Header, Layout_HeaderBar as HeaderBar, Layout_Icon as Icon, Layout_Image as Image, Layout_Item as Item, Layout_Label as Label, type Layout_LayoutClassNameProps as LayoutClassNameProps, type Layout_LayoutFlexProps as LayoutFlexProps, type Layout_LayoutIndentMargin as LayoutIndentMargin, type Layout_LayoutIndentPadding as LayoutIndentPadding, type Layout_LayoutIndentProps as LayoutIndentProps, type Layout_LayoutProps as LayoutProps, type Layout_LayoutRoundedProps as LayoutRoundedProps, type Layout_LayoutShadowProps as LayoutShadowProps, Layout_List as List, Layout_Message as Message, Layout_MessageContent as MessageContent, Layout_Progress as Progress, Layout_ProgressBar as ProgressBar, Layout_Radio as Radio, Layout_Row as Row, Layout_Rows as Rows, Layout_Select as Select, Layout_SelectRow as SelectRow, Layout_Text as Text, Layout_View as View, Layout_Window as Window, Layout_collectClassnames as collectClassnames, Layout_extractProps as extractProps };
}

declare const Maximize: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const Minimize: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const Restore: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const Close: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const index$2_Close: typeof Close;
declare const index$2_Maximize: typeof Maximize;
declare const index$2_Minimize: typeof Minimize;
declare const index$2_Restore: typeof Restore;
declare namespace index$2 {
  export { index$2_Close as Close, index$2_Maximize as Maximize, index$2_Minimize as Minimize, index$2_Restore as Restore };
}

declare const Information: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const Password: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const Question: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const Warning: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const Error: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const index$1_Error: typeof Error;
declare const index$1_Information: typeof Information;
declare const index$1_Password: typeof Password;
declare const index$1_Question: typeof Question;
declare const index$1_Warning: typeof Warning;
declare namespace index$1 {
  export { index$1_Error as Error, index$1_Information as Information, index$1_Password as Password, index$1_Question as Question, index$1_Warning as Warning };
}

declare const EmblemOk: {
    (props: react.SVGProps<SVGSVGElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const index_EmblemOk: typeof EmblemOk;
declare namespace index {
  export { index$1 as Dialog, index_EmblemOk as EmblemOk, index$2 as Window };
}

declare const L: typeof components & typeof containers;
declare const Meta: {
    Layout: typeof Layout;
};

export { Activatable$1 as Activatable, type ActivatableProps, _default$7 as Button, ButtonGroup$1 as ButtonGroup, type ButtonGroupProps, type ButtonProps, Checkbox$1 as Checkbox, type CheckboxIndicatorIcon, type CheckboxProps, Clamp, type ClampProps, Collapsible$1 as Collapsible, type CollapsibleProps, Confirm, type ConfirmAccent, type ConfirmAction, type ConfirmHandles, type ConfirmProps, type ConfirmResult, type ConfirmSize, type CoreAccent, type CoreColor, type CoreSize, type CustomItemProps, Dialog$1 as Dialog, type DialogActionProps, type DialogProps, Divider$1 as Divider, type DividerProps, Dropdown, type DropdownContentProps, type DropdownHandles, type DropdownProps, Entry$1 as Entry, type EntryProps, EntryRow$1 as EntryRow, type EntryRowProps, Header$1 as Header, HeaderBar$1 as HeaderBar, type HeaderBarProps, type HeaderProps, Icon$1 as Icon, type IconProps, index as Icons, Image$1 as Image, type ImageProps, Item$1 as Item, type ItemProps, L, Label$1 as Label, type LabelFloating, type LabelProps, type LayoutIconProps, _default$5 as List, type ListProps, _default$4 as Message, MessageContent$1 as MessageContent, type MessageContentProps, type MessageProps, Meta, Modal, type ModalProps, type OptionValue, Portal, type PortalProps, _default$6 as Progress, ProgressBar$1 as ProgressBar, type ProgressBarProps, type ProgressProps, Radio$1 as Radio, type RadioProps, RawTabs, type RawTabsProps, Row$1 as Row, type RowProps, _default as Rows, type RowsProps, Select$1 as Select, type SelectButtonProps, type SelectProps, SelectRow$1 as SelectRow, type SelectRowProps, Sidebar, type SidebarProps, _default$2 as SplitView, type SplitViewProps, Tab, type TabBackgroundProps, type TabOption, type TabProps, _default$3 as Tabs, type TabsHandles, type TabsProps, Text$1 as Text, type TextProps, View$1 as View, type ViewBg, type ViewProps, _default$1 as Window, type WindowControlIcons, type WindowControlType, WindowControls, type WindowControlsProps, type WindowProps };