import * as react_jsx_runtime from 'react/jsx-runtime';
import React$1, { CSSProperties, InputHTMLAttributes, FormHTMLAttributes } from 'react';
import { T as TextStyleProps, I as IconStyle, S as SizingProps, C as ColorProps, d as SpinnerProps, e as InputStyleProps, B as ButtonStyle, f as StatusColor, F as FloatingAreaStyle, g as FloatingActionButtonStyle, b as IconButtonProps, R as ResolutionProps, h as ChipStyleProps, i as ImageProps, a as TabStyle, P as PrimarySwatch } from '../__types-Cs6vjY5W.js';
export { T as Table } from '../type-CsZGt3-g.js';

declare const MainAxisAlignment: "start" | "end" | "center" | "space-between" | "space-evenly";
declare const CrossAxisAlignment: "start" | "center" | "end";
declare const ScrollDirection: "vertical" | "horizontal" | "all";
interface _BaseArgs {
    mainAxisAlignment?: typeof MainAxisAlignment;
    crossAxisAlignment?: typeof CrossAxisAlignment;
    space?: string;
    padding?: string;
    children?: Array<React.ReactNode> | React.ReactNode;
}
interface ColumnArgs extends _BaseArgs {
}
interface RowArgs extends _BaseArgs {
}
interface SizedBoxArgs {
    height?: string;
    width?: string;
    minHight?: string;
    maxHeight?: string;
    minWidth?: string;
    maxWidth?: string;
    children?: React.ReactNode;
}
interface StackArgs {
    children?: Array<React.ReactNode> | React.ReactNode;
    height?: string;
    width?: string;
    padding?: string;
    overFlow?: React.CSSProperties["overflow"];
}
interface PositionedArgs {
    top?: string;
    bottom?: string;
    left?: string;
    right?: string;
    isCentered?: boolean;
    children?: React.ReactNode;
    zIndex?: number;
}
interface ScrollViewArgs extends SizedBoxArgs {
    direction?: typeof ScrollDirection;
    thumbColor?: string;
    borderRadius?: string;
    thumbStrokeWidth?: string;
    ref?: React.Ref<HTMLDivElement> | null;
}

interface BreadCrumbStyle {
    textStyle?: TextStyleProps;
    iconStyle?: IconStyle;
}
interface Props$n {
    header?: React$1.ReactNode;
    sideNav?: React$1.ReactNode;
    footer?: React$1.ReactNode;
    children: React$1.ReactNode;
    popOverComponents?: Array<React$1.JSX.Element>;
    isBreadCrumbs?: boolean;
    breadCrumbStyle?: BreadCrumbStyle;
    background?: React$1.CSSProperties["background"];
    margin?: React$1.CSSProperties["margin"];
    scrollOptions?: ScrollViewArgs;
    onBreadCrumbsClick?: (path: string) => void;
    height?: CSSProperties["height"];
    width?: CSSProperties["width"];
}
declare function Layout(p: Props$n): react_jsx_runtime.JSX.Element;

interface Args$8 {
    id?: string;
    size?: string;
    src: React$1.ImgHTMLAttributes<HTMLImageElement>["src"];
    alt?: React$1.ImgHTMLAttributes<HTMLImageElement>["alt"];
    loading?: React$1.ImgHTMLAttributes<HTMLImageElement>["loading"];
    borderRadius?: React$1.CSSProperties["borderRadius"];
    border?: React$1.CSSProperties["border"];
}
declare function Avatar({ id, src, alt, loading, size, borderRadius, border, }: Args$8): react_jsx_runtime.JSX.Element;

interface Props$m extends SizingProps, ColorProps {
    maxValue: number;
    value: number;
    label?: string;
    textStyle?: TextStyleProps;
}
declare function Progress(props: Props$m): react_jsx_runtime.JSX.Element;

interface Props$l extends TextStyleProps {
    text: string | number;
}
declare function TextComponent(props: Props$l): react_jsx_runtime.JSX.Element;

interface Props$k extends SizingProps {
    text: string;
    color?: string;
    textStyle?: TextStyleProps;
    icon?: React$1.ReactNode;
    iconStyle?: IconStyle;
    onClick?: (event: React$1.MouseEvent<HTMLDivElement>) => void;
}
declare function Tag(p: Props$k): react_jsx_runtime.JSX.Element;

declare function Spinner({ stockColor, color, size, strokeWidth, stockOpacity, animationDuration, }: SpinnerProps): react_jsx_runtime.JSX.Element;

interface DataProps$4 {
    date: string;
    count: number;
}
interface Props$j {
    year?: number;
    primaryColor?: string;
    inActiveColor?: string;
    colors?: Array<string>;
    textStyle?: TextStyleProps;
    data?: Array<DataProps$4>;
    toolTipLabel?: string;
    type: "month" | "normal";
    borderRadius?: string;
    minWidth?: string;
    maxWidth?: string;
    onClick?: (date: string) => void;
}
declare function HeatMap({ year, primaryColor, inActiveColor, colors, textStyle, data, toolTipLabel, type, borderRadius, minWidth, maxWidth, onClick, }: Props$j): react_jsx_runtime.JSX.Element;

interface InputArguments {
    label?: string;
    required?: boolean;
    errorMessage?: string;
    textStyle?: TextStyleProps;
    inputStyle?: InputStyleProps;
    placeHolderStyle?: TextStyleProps;
    labelStyle?: TextStyleProps;
    errorStyle?: TextStyleProps;
    suffixIcon?: React.ReactNode;
    prefixIcon?: React.ReactNode;
    prefixIconStyle?: IconStyle;
    suffixIconStyle?: IconStyle;
    minHeight?: string;
    maxHeight?: string;
    fixedHeight?: string;
    onValueChange?: (valueMap: any, value: string) => void;
    onEnter?: (valueMap: any, value: string) => void;
    onSuffixClick?: (valueMap: any, value: any) => void;
    animationDuration?: string;
}

interface Props$i extends InputArguments, React$1.DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
}
declare function TextBox({ type, label, errorMessage, inputStyle, errorStyle, labelStyle, placeHolderStyle, suffixIconStyle, prefixIcon, prefixIconStyle, textStyle, required, onValueChange, onEnter, onKeyUp, onSuffixClick, suffixIcon, width, height, fixedHeight, animationDuration, ...a }: Props$i): react_jsx_runtime.JSX.Element;

interface Props$h extends InputArguments, React$1.DetailedHTMLProps<InputHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement> {
}
declare function RichTextBox({ type, label, errorMessage, inputStyle, errorStyle, labelStyle, placeHolderStyle, suffixIconStyle, prefixIcon, prefixIconStyle, textStyle, required, onValueChange, onEnter, onKeyUp, onSuffixClick, suffixIcon, width, minHeight, maxHeight, height, animationDuration, ...a }: Props$h): react_jsx_runtime.JSX.Element;

interface Props$g extends ButtonStyle {
    onClick?: (e: React$1.MouseEvent<HTMLButtonElement>) => void;
}
declare function Button({ title, type, isLoading, text, textStyle, backgroundColor, spinnerStyle, hoverbackGroundColor, disabledColor, activeColor, prefixIcon, suffixIcon, animationDuration, borderRadius, width, height, padding, isDisabled, isOutlined, onClick, }: Props$g): react_jsx_runtime.JSX.Element;

interface Size {
    all?: string;
    sm?: string;
    md?: string;
    lg?: string;
    xl?: string;
    xxl?: string;
    xxxl?: string;
}
interface Animation {
    transformX?: number;
    transformY?: number;
    fromScale?: string;
    toScale?: string;
    duration?: number;
}
interface Color {
    background?: string;
    accent?: string;
    barrier?: string;
}
interface Props$f extends SizingProps {
    id?: string;
    title?: string;
    titleStyle?: TextStyleProps;
    textStyle?: TextStyleProps;
    colors?: Color;
    border?: string;
    barrierDismissible?: boolean;
    type?: "MENU" | "POPUP" | "BOTTOM-SHEET";
    state: boolean;
    setState: React$1.Dispatch<React$1.SetStateAction<boolean>>;
    animationDuration?: number;
    height?: string;
    width?: string;
    minWidth?: string;
    maxWidth?: string;
    minHeight?: string;
    maxHeight?: string;
    padding?: string;
    margin?: string;
    zIndex?: number;
    onInit?: () => void;
    onClose?: () => void;
    animation?: Animation;
    boxShadow?: string;
    scroll?: boolean;
    size?: Size;
    children?: React$1.JSX.Element | React$1.ReactNode;
    leading?: React$1.JSX.Element | React$1.ReactNode;
    action?: React$1.JSX.Element | React$1.ReactNode;
    footer?: React$1.JSX.Element | React$1.ReactNode;
}
declare function Modal({ id, title, titleStyle, borderRadius, border, barrierDismissible, animationDuration, colors, type, state, setState, height, width, minWidth, maxWidth, minHeight, maxHeight, padding, margin, zIndex, onInit, onClose, animation, boxShadow, scroll, size, children, leading, action, footer, }: Props$f): false | react_jsx_runtime.JSX.Element | undefined;

interface Props$e {
    id?: string;
    background?: string;
    borderRadius?: string;
    boxShadow?: string;
    padding?: string;
    color?: StatusColor;
    textStyle?: TextStyleProps;
    animationDuration?: string;
}
declare function SnackBarV2({ id, background, borderRadius, boxShadow, padding, color, textStyle, animationDuration, }: Props$e): react_jsx_runtime.JSX.Element;
declare function showSnackBar(message: string, type?: "SUCCESS" | "ERROR" | "WARN" | "INFO", closeDuration?: number): void;

interface ProgressData {
    id: string;
    fileName: string;
    progress: number;
    isCompleted: boolean;
}
interface Props$d extends SizingProps {
    id?: string;
    backgroundColor?: string;
    borderColor?: string;
    iconStyle?: IconStyle;
    deleteIconStyle?: IconStyle;
    color?: string;
    acceptFileType?: string;
    label?: string;
    onPicked: (files: Array<File>) => void;
    pickMultiple?: boolean;
    previewBar?: boolean;
    showIcon?: boolean;
    textStyle?: TextStyleProps;
    progress?: Array<ProgressData>;
    onDone?: (fileId: string) => void;
}
declare function FilePicker({ id, width, height, padding, borderRadius, backgroundColor, borderColor, iconStyle, deleteIconStyle, acceptFileType, label, onPicked, pickMultiple, previewBar, showIcon, textStyle, progress, onDone, }: Props$d): react_jsx_runtime.JSX.Element;

interface Props$c {
    padding?: number;
    borderRadius?: string;
    background?: string;
    textStyle?: TextStyleProps;
    zIndex?: number;
    animationDuration?: string;
}
declare function Tooltip({ padding, borderRadius, background, textStyle, zIndex, animationDuration, }: Props$c): react_jsx_runtime.JSX.Element;

interface DataProps$3 {
    id: number;
    label: string;
    children: React$1.ReactNode;
    collapsed: boolean;
    height?: string;
    onLabelOpen?: () => void;
}
interface Props$b {
    id?: string;
    items: Array<DataProps$3>;
    type: "accordion" | "collapse";
    width?: string;
    background?: string;
    contentBackground?: string;
    borderRadius?: string;
    borderColor?: string;
    iconStyle?: IconStyle;
    textStyle?: TextStyleProps;
    animationDuration?: string;
    reRenderWhen?: Array<any>;
}
declare function Collapse({ items, type, width, background, contentBackground, borderRadius, borderColor, iconStyle, textStyle, animationDuration, id, reRenderWhen, }: Props$b): react_jsx_runtime.JSX.Element;

declare function PopOverDialog({ childComponent, buttonColor, backgroundColor, buttonRadius, borderRadius, size, position, icon }: {
    childComponent?: react_jsx_runtime.JSX.Element | undefined;
    buttonColor?: string | undefined;
    backgroundColor?: string | undefined;
    buttonRadius?: number | undefined;
    borderRadius?: number | undefined;
    size?: number | undefined;
    position?: string | undefined;
    icon?: react_jsx_runtime.JSX.Element | undefined;
}): react_jsx_runtime.JSX.Element;

interface Props$a extends ColorProps {
    id?: string;
    dropDownMenuWidth?: string;
    dropDownMenuHeight?: string;
    menuPadding?: string;
    menuIcon?: React$1.ReactNode;
    menuPosition?: "top-left" | "top-right" | "top-center" | "bottom-left" | "bottom-right" | "bottom-center";
    size?: string;
    menuRadius?: string;
    menuBackgroundColor?: string;
    options?: Array<DataProps$2>;
    textStyle?: TextStyleProps;
    iconStyle?: IconStyle;
    borderRadius?: string;
    animationDuration?: string;
    boxShadow?: string;
    defaultSelectedIndex?: number;
    onSelect?: (data: DataProps$2, index: number) => void;
}
declare function DropDownMenu({ dropDownMenuHeight, dropDownMenuWidth, menuPadding, menuIcon, menuPosition, size, menuRadius, menuBackgroundColor, options, background, activeColor, hoverColor, focusedColor, borderRadius, animationDuration, boxShadow, defaultSelectedIndex, textStyle, iconStyle, onSelect, }: Props$a): react_jsx_runtime.JSX.Element;
interface DataProps$2 {
    id: string | number;
    name: string;
    icon?: React$1.ReactNode;
    isSelected?: boolean;
}

interface Props$9 {
    id?: string;
    url?: string;
    padding?: React$1.CSSProperties["padding"];
    borderRadius?: React$1.CSSProperties["borderRadius"];
    textStyle?: TextStyleProps;
    icon?: React$1.JSX.Element;
    iconStyle?: IconStyle;
    onClick?: (path: string) => void;
}
declare function BreadCrumbs({ id, url, icon, padding, borderRadius, textStyle, iconStyle, onClick, }: Props$9): react_jsx_runtime.JSX.Element;

interface Args$7 extends FloatingAreaStyle {
    children?: React$1.ReactNode;
}
declare function FloatingArea(p: Args$7): react_jsx_runtime.JSX.Element;

interface Props$8 extends FloatingActionButtonStyle {
    ref?: React$1.RefObject<HTMLButtonElement>;
    onClick?: (e: React$1.MouseEvent<HTMLButtonElement>) => void;
}
declare function FloatingActionButton(p: Props$8): react_jsx_runtime.JSX.Element;

interface Props$7 extends FloatingActionButtonStyle {
    items: Array<React$1.ReactNode>;
}
declare function FloatingActionButtonExpandable(p: Props$7): react_jsx_runtime.JSX.Element;

interface Props$6 {
    maxValue?: number;
    minValue?: number;
    value?: number;
    height?: string;
    width?: string;
    orientation?: "horizontal" | "vertical";
    sliderThickness?: string;
    showThumb?: boolean;
    thumbSize?: string;
    thumbBorderSize?: string;
    thumbBorderColor?: string;
    thumbColor?: string;
    inActiveColor?: string;
    activeColor?: string;
    borderRadius?: string;
    disabled?: boolean;
    onChange?: (e: number) => void;
}
declare function Slider({ onChange, maxValue, minValue, value, height, width, orientation, sliderThickness, showThumb, thumbSize, thumbBorderSize, thumbBorderColor, thumbColor, activeColor, inActiveColor, borderRadius, disabled, }: Props$6): react_jsx_runtime.JSX.Element;

interface DataProps$1 {
    id: string | number;
    value: string;
}
interface Props$5 {
    id?: string;
    items?: Array<DataProps$1>;
    onSelected?: (index: number | Array<number>, value: DataProps$1 | Array<DataProps$1>) => void;
    defaultSelectedIndexs?: Array<number>;
    defaultSelectedValues?: Array<DataProps$1>;
    selectedColor?: string;
    unSelectedColor?: string;
    textStyle?: TextStyleProps;
    iconStyle?: IconStyle;
    borderRadius?: string;
    radioSize?: number;
    padding?: string;
    flexDirection?: "row" | "column";
    gap?: string;
    multiSelect?: boolean;
    disabled?: boolean;
    disabledColor?: string;
}
declare function SelectionGroup({ id, items, onSelected, defaultSelectedIndexs, defaultSelectedValues, selectedColor, unSelectedColor, textStyle, iconStyle, borderRadius, radioSize, padding, flexDirection, gap, multiSelect, disabled, disabledColor, }: Props$5): react_jsx_runtime.JSX.Element;

interface DropDownItemData {
    id: number | string;
    name?: string | number;
    value?: string | number;
    icon?: React$1.ReactNode;
    isSelected?: boolean;
}

interface Args$6 extends ColorProps, React$1.DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
    defaultSelected?: DropDownItemData[];
    onValueChange?: (data: DropDownItemData[]) => void;
    options?: DropDownItemData[];
    isMultiSelect?: boolean;
    mode?: "compact" | "chip";
    fillColor?: string;
    chipColor?: string;
    errorMessage?: string;
    errorTextStyle?: TextStyleProps;
    textStyle?: TextStyleProps;
    iconStyle?: IconStyle;
    itemIconStyle?: IconStyle;
    boxShadow?: string;
    optionHeight?: number;
    zIndex?: string;
    isDisabled?: boolean;
    minHeight?: React$1.CSSProperties["minHeight"];
    maxHeight?: React$1.CSSProperties["maxHeight"];
    minWidth?: React$1.CSSProperties["minWidth"];
    maxWidth?: React$1.CSSProperties["maxWidth"];
    padding?: React$1.CSSProperties["padding"];
    borderRadius?: React$1.CSSProperties["borderRadius"];
}
declare function DropDown({ defaultSelected, onValueChange, options, isMultiSelect, mode, fillColor, chipColor, errorMessage, errorTextStyle, textStyle, iconStyle, itemIconStyle, boxShadow, optionHeight, zIndex, isDisabled, minHeight, maxHeight, minWidth, maxWidth, padding, borderRadius, activeColor, inActiveColor, animationDuration, ...a }: Args$6): react_jsx_runtime.JSX.Element;

interface DataProps {
    id: number;
    value: string;
    label: string;
}
interface Props$4 {
    defaultValue?: string;
    buttonWidth?: string;
    buttonHeight?: string;
    buttonPadding?: string;
    contentHeight?: string;
    borderRadius?: string;
    backgroundColor?: string;
    shadowColor?: string;
    itemHoverColor?: string;
    itemSelectedColor?: string;
    placeholder?: string;
    fontSize?: string;
    fontWeight?: string;
    color?: string;
    zIndex?: number;
    showSearchBar?: boolean;
    searchBarBackgroundColor?: string;
    errorText?: string;
    errorColor?: string;
    options?: Array<DataProps>;
    onSelected?: (value: DataProps) => void;
}
/** Custom drop down button */
declare function Dropdown({ defaultValue, buttonWidth, buttonHeight, buttonPadding, contentHeight, borderRadius, backgroundColor, shadowColor, itemHoverColor, itemSelectedColor, placeholder, fontSize, fontWeight, color, zIndex, showSearchBar, searchBarBackgroundColor, errorText, errorColor, options, onSelected, }: Props$4): react_jsx_runtime.JSX.Element;

interface Props$3 {
    minHeight?: React$1.CSSProperties["minHeight"];
    maxHeight?: React$1.CSSProperties["maxHeight"];
    minWidth?: React$1.CSSProperties["minWidth"];
    maxWidth?: React$1.CSSProperties["maxWidth"];
    padding?: React$1.CSSProperties["padding"];
    margin?: React$1.CSSProperties["margin"];
    boxShadow?: React$1.CSSProperties["boxShadow"];
    borderRadius?: React$1.CSSProperties["borderRadius"];
    children?: React$1.ReactNode;
}
declare function Card({ minHeight, maxHeight, minWidth, maxWidth, padding, margin, boxShadow, borderRadius, children }: Props$3): react_jsx_runtime.JSX.Element;

interface Props$2 extends IconButtonProps {
    onClick?: (e: React$1.MouseEvent<HTMLButtonElement>) => void;
}
declare function IconButton(p: Props$2): react_jsx_runtime.JSX.Element;

interface LinearGradient {
    direction: string;
    colors: Array<string>;
}
interface ContainerProps {
    children: React$1.ReactNode | React$1.JSX.Element;
    height?: React$1.CSSProperties["height"];
    width?: React$1.CSSProperties["width"];
    maxHeight?: React$1.CSSProperties["maxHeight"];
    maxWidth?: React$1.CSSProperties["maxWidth"];
    minHeight?: React$1.CSSProperties["minHeight"];
    minWidth?: React$1.CSSProperties["minWidth"];
    padding?: React$1.CSSProperties["padding"];
    margin?: React$1.CSSProperties["margin"];
    boxShadow?: React$1.CSSProperties["boxShadow"];
    border?: React$1.CSSProperties["border"];
    borderRadius?: React$1.CSSProperties["borderRadius"];
    background?: React$1.CSSProperties["background"];
    gradientBackground?: LinearGradient;
    display?: React$1.CSSProperties["display"];
    flexDirection?: React$1.CSSProperties["flexDirection"];
    alignItems?: React$1.CSSProperties["alignItems"];
    justifyContent?: React$1.CSSProperties["justifyContent"];
    placeContent?: React$1.CSSProperties["placeContent"];
    placeItems?: React$1.CSSProperties["placeItems"];
    gap?: React$1.CSSProperties["gap"];
    gridColTemplate?: ResolutionProps;
    gridRowTemplate?: ResolutionProps;
    animationDuration?: string;
    overFlow?: React$1.CSSProperties["overflow"];
    onClick?: (e: React$1.MouseEvent<HTMLDivElement>) => void;
}
declare function Container(p: ContainerProps): react_jsx_runtime.JSX.Element;

interface FormProps extends React$1.DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement> {
    ref?: React$1.RefObject<HTMLFormElement>;
    id?: string;
    children?: React$1.ReactNode;
}
declare function Form(p: FormProps): react_jsx_runtime.JSX.Element;

interface ChipProps extends ChipStyleProps {
    text: string;
    onClick?: (e: React$1.MouseEvent<HTMLElement>) => void;
    onClose?: (e: React$1.MouseEvent<HTMLButtonElement>) => void;
}
declare function Chip(p: ChipProps): react_jsx_runtime.JSX.Element;

interface Args$5 extends SizingProps, ColorProps {
    text: string;
    data: any;
    icon?: React$1.ReactNode;
    isSelected?: boolean;
    isMultiSelect?: boolean;
    onClick?: (e: React$1.MouseEvent<HTMLDivElement>, value: string, data: any, isMultiSelect: boolean) => void;
    iconStyle?: IconStyle;
    multiSelectIconStyle?: IconStyle;
    textStyle?: TextStyleProps;
}
declare function SelectMenuItem(a: Args$5): react_jsx_runtime.JSX.Element;

interface Args$4 extends ImageProps {
    id?: string;
    onClick?: (e: React$1.MouseEvent<HTMLImageElement>) => void;
}
declare function ImageView(a: Args$4): react_jsx_runtime.JSX.Element;

interface Data {
    id: string | number;
    name: string;
    displayName?: string;
}
interface TabData extends Data {
    icon?: React$1.ReactNode;
}
interface Args$3 extends TabStyle {
    options?: Array<TabData>;
    defaultSelectedId?: number;
    onClick?: (e: React$1.MouseEvent, data: Data) => void;
}
declare function Tab(a: Args$3): React$1.JSX.Element;

interface InputArgs extends React$1.DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
    label?: string;
    error?: string | any;
    width?: React$1.CSSProperties["width"];
    height?: React$1.CSSProperties["height"];
    padding?: React$1.CSSProperties["padding"];
    labelTextStyle?: TextStyleProps;
    placeholderStyle?: TextStyleProps;
    errorTextStyle?: TextStyleProps;
    background?: React$1.CSSProperties["background"];
    borderRadius?: React$1.CSSProperties["borderRadius"];
    suffixIcon?: React$1.ReactElement;
    suffixIconStyle?: IconStyle;
    inputStyle?: InputStyleProps;
    onValueChange?: (valueMap: any, value: string) => void;
}
declare function Input({ width, height, padding, labelTextStyle, placeholderStyle, errorTextStyle, background, borderRadius, suffixIcon, suffixIconStyle, inputStyle, onValueChange, label, error, ...a }: InputArgs): react_jsx_runtime.JSX.Element;

interface Props$1 extends React$1.DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
    width?: React$1.CSSProperties["width"];
    onChecked?: (event: boolean) => void;
    checkedColor?: string;
    unCheckedColor?: string;
    thumbColor?: string;
    label?: React$1.ReactNode;
    labelPosition?: "left" | "right";
    size?: number;
    gap?: string;
    padding?: React$1.CSSProperties["padding"];
    error?: string | any;
    errorTextStyle?: TextStyleProps;
}
declare function Toggle({ onChecked, width, checkedColor, unCheckedColor, thumbColor, label, labelPosition, size, gap, padding, error, errorTextStyle, ...a }: Props$1): react_jsx_runtime.JSX.Element;

interface Props extends React$1.DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
    width?: React$1.CSSProperties["width"];
    onChecked?: (event: boolean) => void;
    checkedColor?: string;
    unCheckedColor?: string;
    thumbColor?: string;
    label?: React$1.ReactNode;
    labelPosition?: "left" | "right";
    size?: number;
    gap?: string;
    error?: string | any;
    errorTextStyle?: TextStyleProps;
}
declare function CheckBox({ onChecked, width, checkedColor, unCheckedColor, thumbColor, label, labelPosition, size, gap, error, errorTextStyle, ...a }: Props): react_jsx_runtime.JSX.Element;

interface Args$2 {
    children?: React$1.ReactNode;
    value?: number;
    size?: number;
    lineWidth?: number;
    trackColor?: string;
    thumbColor?: string;
    duration?: number;
    frameRate?: number;
    labelStyle?: TextStyleProps;
}
declare function CircularProgress(a: Args$2): react_jsx_runtime.JSX.Element;

interface PaginationProps {
    totalPages: number;
    currentPage: number;
    onPageChange: (page: number) => void;
    siblingCount?: number;
    boundaryCount?: number;
    style?: {
        selectedColor?: string;
        selectedBackground?: string;
        borderColor?: string;
        textStyle?: TextStyleProps;
        borderRadius?: React$1.CSSProperties["borderRadius"];
        animationDuration?: string;
    };
}

declare function Pagination({ totalPages, currentPage, onPageChange, siblingCount, boundaryCount, style, }: PaginationProps): react_jsx_runtime.JSX.Element | null;

interface MiniCalendarArgs {
    defaultDate?: Date;
    width?: string;
}

declare function MiniCalendar({ defaultDate, width, }: MiniCalendarArgs): react_jsx_runtime.JSX.Element;

declare function SizedBox({ height, width, maxHeight, maxWidth, minHight, minWidth, children, }: SizedBoxArgs): react_jsx_runtime.JSX.Element;

declare function Column({ children, space, padding, mainAxisAlignment, crossAxisAlignment, }: ColumnArgs): react_jsx_runtime.JSX.Element;

declare function Row({ children, space, padding, mainAxisAlignment, crossAxisAlignment, }: RowArgs): react_jsx_runtime.JSX.Element;

declare function Stack({ children, height, width, padding, overFlow, }: StackArgs): react_jsx_runtime.JSX.Element;

declare function Positioned({ children, isCentered, top, bottom, left, right, zIndex, }: PositionedArgs): react_jsx_runtime.JSX.Element;

declare function ScrollView({ thumbColor, borderRadius, direction, thumbStrokeWidth, height, width, ref, children }: ScrollViewArgs): react_jsx_runtime.JSX.Element;

interface Args$1 {
    ref: React$1.RefObject<HTMLVideoElement>;
    src?: string;
    draggable?: boolean;
    defaultPosition?: {
        top?: string;
        bottom?: string;
        left?: string;
        right?: string;
    };
    height?: string;
    width?: string;
    borderRadius?: string;
    borderColor?: string;
    background?: string;
}
declare function PipVideo(args: Args$1): react_jsx_runtime.JSX.Element;

interface MediaInfo {
    title?: string;
    artist?: string;
}
interface MediaControlProps {
    isVisible?: boolean;
    hiddenDuration?: number;
    animationDuration?: string;
    textStyle?: TextStyleProps;
    background?: React$1.CSSProperties["background"];
    borderRadius?: React$1.CSSProperties["borderRadius"];
    mediaRef: React$1.RefObject<HTMLVideoElement | HTMLAudioElement | null>;
    mediaInfo?: MediaInfo;
    onPlayPause?: (isPlaying: boolean) => void;
    onMuted?: (isMuted: boolean) => void;
    onSeeked?: (maxDuration: number, currentDuration: number, seekedDuration: number) => void;
    onCaptionToggle?: (isCaption: boolean) => void;
    onNext?: () => void;
    onPrevious?: () => void;
}
declare function MediaControl(p: MediaControlProps): react_jsx_runtime.JSX.Element;

interface SubtitleData {
    default?: boolean;
    lang: string;
    label: string;
    /**
     * src should be a .vtt format (or) source vtt url
     */
    src: any;
}
interface VideoPlayerProps extends SizingProps {
    background?: React$1.CSSProperties["background"];
    url: string;
    defaultControl?: boolean;
    customControl?: boolean;
    autoPlay?: boolean;
    loop?: boolean;
    spinnerStyle?: SpinnerProps;
    onSeeked?: (e: React$1.SyntheticEvent<HTMLVideoElement>) => void;
    subtitles?: Array<SubtitleData>;
}
declare function VideoPlayer(p: VideoPlayerProps): react_jsx_runtime.JSX.Element;

interface AudioPlayerProps extends SizingProps {
    background?: React$1.CSSProperties["background"];
    url: string;
    defaultControl?: boolean;
    customControl?: boolean;
    autoPlay?: boolean;
    loop?: boolean;
    onSeeked?: (e: React$1.SyntheticEvent<HTMLVideoElement>) => void;
}
declare function AudioPlayer(p: AudioPlayerProps): react_jsx_runtime.JSX.Element;

interface BaseTheme {
    backgroundColor: string;
    primaryColor: string;
    secondaryColor: string;
    tertiaryColor: string;
    errorColor: string;
    primaryTextColor: string;
    secondaryTextColor: string;
    tertiaryTextColor: string;
    errorTextColor: string;
    iconStyle: IconStyle;
    animationDuration: string;
    borderRadius: string;
    font: Font;
    textStyle: TextStyleProps;
    boxShadow: string;
    statusColor: StatusColor;
    spinnerStyle: SpinnerProps;
}
interface Font {
    fontFamily?: React$1.CSSProperties["fontFamily"];
    fontSize?: React$1.CSSProperties["fontSize"];
    fontWeight?: React$1.CSSProperties["fontWeight"];
}
interface ThemeConTextStyleProps {
    theme: BaseTheme;
    primarySwatch: PrimarySwatch;
    setTheme: (theme: Partial<BaseTheme>) => void;
    setPrimarySwatch: (color: string) => void;
}
interface Args {
    children: React$1.ReactNode;
    theme: Partial<BaseTheme>;
}
declare function ThemeProvider(a: Args): react_jsx_runtime.JSX.Element;
declare const useUiTheme: () => ThemeConTextStyleProps;

export { AudioPlayer, Avatar, BreadCrumbs, Button, Card, CheckBox, Chip, CircularProgress, Collapse, Column, Container, DropDown, DropDownMenu, Dropdown as DropDownV2, FilePicker, FloatingActionButton, FloatingActionButtonExpandable, FloatingArea, Form, HeatMap, IconButton, ImageView, Input, Layout, MediaControl, MiniCalendar, Modal, Pagination, PipVideo, PopOverDialog, Positioned, Progress, RichTextBox, Row, ScrollView, SelectMenuItem, SelectionGroup, SizedBox, Slider, SnackBarV2 as SnackBar, Spinner, Stack, Tab, Tag, TextComponent as Text, TextBox, ThemeProvider, Toggle, Tooltip, VideoPlayer, showSnackBar, useUiTheme as useTheme };