import * as react from 'react';
import react__default, { ElementType, AllHTMLAttributes, ReactNode, InputHTMLAttributes, ButtonHTMLAttributes } from 'react';
import { IconType } from 'react-icons';
import { Language } from 'prism-react-renderer';
import { TooltipContentProps } from '@radix-ui/react-tooltip';
import { IconBaseProps } from 'react-icons/lib';

declare type Size = 'tiny' | 'small' | 'medium' | 'large';

declare type HTMLProps = Omit<AllHTMLAttributes<HTMLElement>, 'as'>;
interface Props$c extends Omit<HTMLProps, 'size'> {
    as?: ElementType;
    size?: Size;
}
declare const Box: react.ForwardRefExoticComponent<Props$c & react.RefAttributes<HTMLElement>>;

declare type Variant$1 = 'primary' | 'secondary' | 'outlined-primary' | 'transparent';
interface Props$b extends Props$c {
    iconRight?: ReactNode;
    iconLeft?: ReactNode;
    loading?: boolean;
    variant?: Variant$1;
}
declare const Button: react.ForwardRefExoticComponent<Props$b & react.RefAttributes<HTMLButtonElement>>;

interface Props$a {
    isOpen: boolean;
    setIsOpen: (isOpen: boolean) => void;
    text: string;
    title: string;
}
/**
 * An alert component
 * Usage: Import both the `Alert` component and `useAlert` hook into your own components.
 * Hook:
 * const { openAlert, alertProps } = useAlert()
 * Render:
 * <Alert {...alertProps} />
 */
declare function Alert({ isOpen, setIsOpen, text, title }: Props$a): JSX.Element;

interface DrawerProps {
    isOpen: boolean;
    setIsOpen: (isOpen: boolean) => void;
    children: react__default.ReactNode;
    title: string;
    description?: string;
}
/**
 * A side drawer component
 */
declare const Drawer: ({ isOpen, setIsOpen, children, title, description, }: DrawerProps) => JSX.Element;

interface Props$9 {
    label?: string;
    size?: Size;
    error?: string;
    success?: string;
    description?: string;
    children: ReactNode;
}
declare function FieldLayout(props: Props$9): JSX.Element;

interface Props$8 extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'id' | 'children'> {
    label?: string;
    size?: Size;
    success?: string;
    error?: string;
    description?: string;
    icon?: IconType;
    copy?: boolean;
}
declare const Input: react.ForwardRefExoticComponent<Props$8 & react.RefAttributes<HTMLInputElement>>;

interface Props$7 extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'size' | 'ref' | 'children'> {
    size?: Size;
    icon: ReactNode;
    label: string;
}
declare const IconButton: react.ForwardRefExoticComponent<Props$7 & react.RefAttributes<HTMLButtonElement>>;

interface Props$6 {
    lang: Language;
    code: string;
}
declare function CodeBox({ lang, code }: Props$6): JSX.Element;

interface CodeBlock {
    code: string;
    name: string;
    lang: Language;
}
interface Props$5 {
    blocks: CodeBlock[];
}
declare function TabbedCodeBox({ blocks }: Props$5): JSX.Element;

interface Props$4 {
    isOpen: boolean;
    setIsOpen: (isOpen: boolean) => void;
    children: ReactNode;
}
declare function Modal({ isOpen, setIsOpen, children }: Props$4): JSX.Element;

declare type Variant = 'dark' | 'orange' | 'red' | 'yellow' | 'green' | 'blue' | 'default';
interface Props$3 extends Props$c {
    iconRight?: ReactNode;
    iconLeft?: ReactNode;
    variant?: Variant;
}
declare function Badge(props: Props$3): JSX.Element;

interface Props$2 extends Pick<TooltipContentProps, 'side' | 'sideOffset'> {
    tip: ReactNode;
    children: ReactNode;
    label?: string;
    delay?: number;
}
declare function Tooltip({ children, delay, tip, label, side, sideOffset, }: Props$2): JSX.Element;

interface Props$1 extends IconBaseProps {
    size?: Size | number;
    icon: IconType;
}
declare function Icon({ className, size, icon, ...rest }: Props$1): JSX.Element;

interface Option {
    label: string;
    value: string | number;
}
interface SelectProps<T> {
    label?: string;
    options: Option[];
    size?: Size;
    onChange?: (value: string | number) => void;
    defaultValue?: T;
}
declare const Select: <T extends unknown>({ options, onChange, label, size, defaultValue, }: SelectProps<T>) => JSX.Element;

interface CollapseProps {
    isOpen: boolean;
    setIsOpen: (open: boolean) => void;
    content: React.ReactNode;
    children: React.ReactNode;
    disabled?: boolean;
}
declare const Collapse: ({ children, content, disabled, }: CollapseProps) => JSX.Element;

interface ToggleSwitchProps {
    enabled: boolean;
    setEnabled: (enabled: boolean) => void;
    title?: string;
    onChange?: (enabled: boolean) => void;
    disabled?: boolean;
}
declare const ToggleSwitch: ({ title, enabled, setEnabled, onChange, disabled, }: ToggleSwitchProps) => JSX.Element;

interface Props {
    id: string;
    recipient: string;
    title: string;
    iconURL: string;
    bottomItems?: ReactNode[];
    topItems?: ReactNode[];
    location?: string;
    time?: string;
    date?: string;
    lockAddress: string;
    network: number;
    QRCodeURL: string;
}
declare function Ticket({ iconURL, title, bottomItems, topItems, recipient, id, QRCodeURL, date, time, location, lockAddress, network, }: Props): JSX.Element;
interface TicketLabelProps {
    label: string;
    value: string;
}
declare function TicketLabel({ label, value }: TicketLabelProps): JSX.Element;
interface TicketItemProps {
    icon: ReactNode;
    value: string;
}
declare function TicketItem({ icon, value }: TicketItemProps): JSX.Element;

declare const minifyAddress: (address: string) => string;

export { Alert, Badge, Box, Button, CodeBox, Collapse, Drawer, FieldLayout, Icon, IconButton, Input, Modal, Select, TabbedCodeBox, Ticket, TicketItem, TicketLabel, ToggleSwitch, Tooltip, minifyAddress };
