/// <reference types="react" />
import React$1 from 'react';

interface ThemeTypes {
    palette: {
        [k: string]: any;
    };
    shadows?: {
        [k: string]: any;
    };
    typography: {
        fontFamily: {
            [k: string]: any;
        };
        fontWeight: {
            [k: string]: any;
        };
        lineHeight: {
            [k: string]: any;
        };
    };
    zIndex?: {
        [k: string]: any;
    };
    fontSizes: {
        [k: string]: any;
    };
    shape: {
        borderRadius: {
            [k: string]: any;
        };
    };
}

interface BoxTypes extends UnknownType {
    justifyContent?: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
    alignItems?: "flex-start" | "flex-end" | "center" | "baseline" | "stretch";
    alignContent?: "flex-start" | "flex-end" | "center" | "space-between" | "space-around" | "stretch";
    width?: string;
    height?: string;
    wrap?: "nowrap" | "wrap" | "wrap-reverse";
    direction?: "row" | "row-reverse" | "column" | "column-reverse";
    margin?: string;
    pad?: string;
    bgColor?: string;
    children?: any;
}
declare type UnknownType = {
    [k: string]: any;
};
interface FrameTypes extends UnknownType {
    width?: string;
    height?: string;
    wrap?: "nowrap" | "wrap" | "wrap-reverse";
    object?: 'fill' | 'contain' | 'cover' | "none" | "scale-down";
    rounded?: string;
    children?: any;
}
interface GridTypes extends BoxTypes {
    columns?: string;
    rows?: string;
    gap?: string;
    children?: any;
    width?: string;
}

interface AccordionProps {
    accordions: {
        details: any;
        head: any;
        key: number;
    }[];
    gap: string;
    visible: number;
    setVisible: React$1.Dispatch<React$1.SetStateAction<number>>;
}

interface AccordionMultiTypeProps {
    accordions: {
        details: any;
        head: any;
        key: number;
    }[];
    gap: string;
    visible: number[];
    setVisible: React$1.Dispatch<React$1.SetStateAction<number[]>>;
}

interface ImageProps {
    src: string;
    alt?: string;
    height?: string;
    width?: string;
    loading?: boolean;
    error?: boolean;
    radius?: string;
    object?: 'fill' | 'contain' | 'cover' | "none" | "scale-down";
    loader: any;
    fallBackImage?: string;
}

declare type HeadBgColorType = {
    headBgColor: string;
};
declare type HeadColorType = {
    headColor: string;
};
declare type BodyColorType = {
    bodyColor: string;
};
interface TableTypes extends HeadBgColorType, HeadColorType, BodyColorType {
    tableBodys: object[];
    tableHead: string[];
    moreDetail?: any[];
    gap?: string;
    handleRowClick?: (a?: any, b?: any, idx?: number) => any;
    clickableTableBodyDataHead?: string[];
    handleRowTabClick?: (a?: any, b?: any, index?: number) => any;
}

interface TypeProps {
    type: "number" | 'password' | 'text';
}
interface BorderColType {
    activeBorderCol?: string;
    borderCol?: string;
}
interface ActiveBgColType {
    activeBgCol?: string;
}
interface BorderRadiusType {
    borderRadius?: string;
}
interface ColorType$2 {
    colour?: string;
}
interface InputTypes extends TypeProps, ColorType$2, BorderRadiusType, ActiveBgColType, BorderColType {
    handleChange: (e: React.FormEvent<HTMLInputElement>) => any;
    name: string;
    value: string | number;
    disabled?: boolean;
    iconAfterInput?: any;
    iconBeforeInput?: any;
    handleOnFocus?: (e: React.FormEvent<HTMLInputElement>) => any;
    handleOnBlur?: (e: React.FormEvent<HTMLInputElement>) => any;
    handleOnEmptyInputValue?: (e: React.FormEvent<HTMLInputElement>) => any;
    placeholder?: string;
    bgCol?: string;
    borderRadius?: string;
    [k: string]: any;
}

interface ButtonTypes extends StyleTypes, UnknownType {
    icon?: any;
    text?: any;
    children?: any;
}
interface StyleTypes {
    isLoading?: boolean;
    disabled?: boolean;
    bgColor?: string;
    size: string;
    hasIcon?: boolean;
    fullwidth?: boolean;
    nonActiveColor: string;
    activeColor: string;
    nonActiveBgColor: string;
    activeBgColor: string;
    nonActiveBorderColor: string;
    activeBorderColor: string;
    borderRadius?: string;
    pad?: string;
    loaderSize?: string | number;
}

declare type DropdownType = CanClickType & WeightType & DirectionType & PaddingType & ColourType & HovBgColorType & DropHovColorType & DropColorType & {
    data: {
        returnedValue: any;
        displayedValue: any;
        dropdownValue: any;
    }[];
    handleSelect: (returnedValue: any, selectedvalue: any, dropdownValue: any) => void;
    initial?: any;
    icon?: any;
    type?: 'showmore';
    placeholder?: string;
    clearSelected?: boolean;
    searchField?: boolean;
};
interface CanClickType {
    canClick?: boolean;
}
interface WeightType {
    weight: string;
}
interface DirectionType {
    direction?: "start" | "end";
}
interface PaddingType {
    padding?: string;
}
interface ColourType {
    colour: string;
}
interface HovBgColorType {
    hovBgColor: string;
}
interface DropColorType {
    dropColor: string;
}
interface DropHovColorType {
    dropHovColor: string;
}

declare type CarouselTypes = Variant & {
    delay?: number;
    children: any;
    rightIcon: any;
    leftIcon: any;
    transition?: string;
    auto?: boolean;
};
declare type Variant = {
    indicatorType?: 'arrow';
    indicatorPosition?: undefined;
    activeColor?: undefined;
    color?: undefined;
} | {
    indicatorType: 'buttons';
    indicatorPosition?: string;
    activeColor: string;
    color: string;
};

interface BgColorType {
    bgColor?: string;
}
interface PercentageWidthType {
    percentageWidth?: number;
}
interface CardTypes {
    cardWidth?: string;
    cardBgColor?: string;
    gap?: string;
}
interface CardSliderTypes extends BgColorType, PercentageWidthType, CardTypes {
    children: any;
    rightIcon: any;
    leftIcon: any;
    onEnd?: () => any;
    onStart?: () => any;
    onScrolling?: () => any;
    delay?: number;
    auto?: boolean;
}

declare type ModalType = {
    show: boolean;
    handleClose: () => void;
    title?: any;
    noHeader?: boolean;
    noCancel?: boolean;
    clickOut?: boolean;
    children: any;
    width?: string;
    direction?: "up" | "down" | "left" | "right";
    mobilViewDirection?: "up" | "down" | "left" | "right";
    innerRef: React$1.RefObject<HandleScrollTypes>;
};
declare type HandleScrollTypes = {
    preventBodyScroll: () => void;
    addBodyScroll: () => void;
};

interface FontTypes {
    children?: any;
    fontFamily: string;
    weight?: string;
    lineHeight: string;
    textAlign?: string;
    center?: boolean;
    size: string;
    colour: string;
    [k: string]: any;
}

interface ColorType$1 {
    activeColor: string;
    nonActiveColor: string;
}
declare type SwitchType = ColorType$1 & {
    click: (e: boolean) => void;
    initialState: boolean;
    ball?: "big" | "small";
    reValidate?: boolean;
};

interface FullType {
    full?: boolean;
}
interface ColorType {
    nonActiveColor: string;
    activeColor: string;
}
declare type TabsType = FullType & ColorType & {
    click: (tab: any) => void;
    data: {
        head: any;
        body: any;
        key: any;
    }[];
    initialState?: any;
    revalidate?: boolean;
};

declare const Components: (theme: ThemeTypes) => {
    Header1: (arg: FontTypes) => JSX.Element;
    Header2: (arg: FontTypes) => JSX.Element;
    Header3: (arg: FontTypes) => JSX.Element;
    Header4: (arg: FontTypes) => JSX.Element;
    Header5: (arg: FontTypes) => JSX.Element;
    Paragraph: (arg: FontTypes) => JSX.Element;
    Bold: (arg: FontTypes) => JSX.Element;
    Span: (arg: FontTypes) => JSX.Element;
    Small: (arg: FontTypes) => JSX.Element;
    Sub: (arg: FontTypes) => JSX.Element;
    Italics: (arg: FontTypes) => JSX.Element;
    Anchor: (arg: FontTypes & {
        href: string;
    }) => JSX.Element;
    ListItem: (arg: FontTypes) => JSX.Element;
    Image: (arg: ImageProps) => JSX.Element;
    Accordion: (arg: AccordionProps) => JSX.Element;
    AccordionMultiType: (arg: AccordionMultiTypeProps) => JSX.Element;
    Container: (arg: BoxTypes) => JSX.Element;
    Flex: (arg: BoxTypes) => JSX.Element;
    Grid: (arg: GridTypes) => JSX.Element;
    Frame: (arg: FrameTypes) => JSX.Element;
    Table: (arg: TableTypes) => JSX.Element;
    Input: (arg: InputTypes) => JSX.Element;
    Button: (arg: ButtonTypes) => JSX.Element;
    CardSliders: (arg: CardSliderTypes) => JSX.Element;
    Dropdown: (arg: DropdownType) => JSX.Element;
    Carousel: (arg: CarouselTypes) => JSX.Element;
    Modal: (arg: ModalType) => JSX.Element;
    Switch: (arg: SwitchType) => JSX.Element;
    Tabs: (arg: TabsType) => JSX.Element;
};

export { AccordionMultiTypeProps, AccordionProps, BoxTypes, ButtonTypes, CardSliderTypes, CarouselTypes, Components, DropdownType, FontTypes, FrameTypes, GridTypes, HandleScrollTypes, ImageProps, InputTypes, ModalType, SwitchType, TableTypes, TabsType, ThemeTypes };