/// <reference types="react" />
import * as _mui_material_styles from '@mui/material/styles';
export { ThemeProvider as LuneThemeProvider } from '@mui/material/styles';
import { PaletteOptions } from '@mui/material/styles/createPalette';
import * as React from 'react';
import React__default, { FC, MouseEventHandler, ReactNode, ReactElement, HTMLAttributes } from 'react';
import { SxProps } from '@mui/material';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { Breakpoint, SxProps as SxProps$1 } from '@mui/system';
import { ContainerProps as ContainerProps$1 } from '@mui/material/Container';
import { TableProps } from '@mui/material/Table';
import { TableBodyProps } from '@mui/material/TableBody';
import { TableCellProps } from '@mui/material/TableCell';
import { TableContainerProps } from '@mui/material/TableContainer';
import { TableHeadProps } from '@mui/material/TableHead';
import { TableRowProps } from '@mui/material/TableRow';
import { MenuItemProps } from '@mui/material/MenuItem';
import { SwitchProps } from '@mui/material/Switch';
import { Range } from 'react-date-range';
import Collapse from '@mui/material/Collapse';
import { DialogProps } from '@mui/material/Dialog';
import Fade from '@mui/material/Fade';
import Grow from '@mui/material/Grow';
import Slide from '@mui/material/Slide';
import Zoom from '@mui/material/Zoom';
import { TabProps as TabProps$1 } from '@mui/material/Tab';
import { TabsProps } from '@mui/material/Tabs';
import { TooltipProps } from '@mui/material/Tooltip';
import { SliderProps } from '@mui/material/Slider';
import { DropzoneOptions } from 'react-dropzone';
export { default as Text } from '@mui/material/Typography';

declare const fontFamily = "Helvetica Neue, Arial, sans-serif";
declare module '@mui/material/styles/createPalette' {
    interface PaletteOptions {
        Grey50: React__default.CSSProperties['color'];
        Grey100: React__default.CSSProperties['color'];
        Grey200: React__default.CSSProperties['color'];
        Grey300: React__default.CSSProperties['color'];
        Grey400: React__default.CSSProperties['color'];
        Grey500: React__default.CSSProperties['color'];
        Grey600: React__default.CSSProperties['color'];
        Grey700: React__default.CSSProperties['color'];
        Grey800: React__default.CSSProperties['color'];
        Grey900: React__default.CSSProperties['color'];
        Black: React__default.CSSProperties['color'];
        White: React__default.CSSProperties['color'];
        Blue50: React__default.CSSProperties['color'];
        Blue100: React__default.CSSProperties['color'];
        Blue200: React__default.CSSProperties['color'];
        Blue300: React__default.CSSProperties['color'];
        Blue400: React__default.CSSProperties['color'];
        Blue500: React__default.CSSProperties['color'];
        Blue600: React__default.CSSProperties['color'];
        Blue700: React__default.CSSProperties['color'];
        Blue800: React__default.CSSProperties['color'];
        Blue900: React__default.CSSProperties['color'];
        Green50: React__default.CSSProperties['color'];
        Green100: React__default.CSSProperties['color'];
        Green200: React__default.CSSProperties['color'];
        Green300: React__default.CSSProperties['color'];
        Green400: React__default.CSSProperties['color'];
        Green500: React__default.CSSProperties['color'];
        Green600: React__default.CSSProperties['color'];
        Green700: React__default.CSSProperties['color'];
        Green800: React__default.CSSProperties['color'];
        Green900: React__default.CSSProperties['color'];
        Yellow50: React__default.CSSProperties['color'];
        Yellow100: React__default.CSSProperties['color'];
        Yellow200: React__default.CSSProperties['color'];
        Yellow300: React__default.CSSProperties['color'];
        Yellow400: React__default.CSSProperties['color'];
        Yellow500: React__default.CSSProperties['color'];
        Yellow600: React__default.CSSProperties['color'];
        Yellow700: React__default.CSSProperties['color'];
        Yellow800: React__default.CSSProperties['color'];
        Yellow900: React__default.CSSProperties['color'];
        Red50: React__default.CSSProperties['color'];
        Red500: React__default.CSSProperties['color'];
        Red900: React__default.CSSProperties['color'];
    }
}
declare module '@mui/material/styles/createTypography' {
    interface TypographyOptions {
        section: React__default.CSSProperties;
        sectionMobile: React__default.CSSProperties;
        testimonial: React__default.CSSProperties;
        testimonialMobile: React__default.CSSProperties;
    }
}
declare module '@mui/material/Typography' {
    interface TypographyPropsVariantOverrides {
        body3: true;
        section: true;
        sectionMobile: true;
        testimonial: true;
        testimonialMobile: true;
    }
}
declare module '@mui/material/styles' {
    interface Theme {
        palette: PaletteOptions;
    }
    interface TypographyVariants {
        body3: React__default.CSSProperties;
        section: React__default.CSSProperties;
        sectionMobile: React__default.CSSProperties;
        testimonial: React__default.CSSProperties;
        testimonialMobile: React__default.CSSProperties;
    }
    interface TypographyVariantsOptions {
        body3: React__default.CSSProperties;
        section: React__default.CSSProperties;
        sectionMobile: React__default.CSSProperties;
        testimonial: React__default.CSSProperties;
        testimonialMobile: React__default.CSSProperties;
    }
}
declare const theme: _mui_material_styles.Theme;

interface ButtonProps {
    children?: React__default.ReactNode;
    variant?: ButtonVariant;
    sx?: SxProps;
    wide?: boolean;
    disabled?: boolean;
    iconButton?: boolean;
    leftIcon?: JSX.Element;
    rightIcon?: JSX.Element;
    onClick?: (f: React__default.MouseEvent<HTMLElement>) => void;
    type?: 'button' | 'submit' | 'reset';
    /**
     * You're expected to provide something like
     *
     * ```
     * <Loading light={variant === ButtonVariants.CONTAINED} />
     * ```
     *
     * here, if the button is in the loading state.
     */
    loading?: React__default.ReactNode;
    loadingLabel?: string;
    light?: boolean;
    href?: string;
    target?: string;
}
type ButtonVariant = 'contained' | 'outlined' | 'text';
declare const Button: FC<ButtonProps>;

type TileVariant = 'default' | 'light';
declare const Tile: ({ children, button, icon, rightSide, rightIcon, onClick, href, target, variant, selected, sx, compact, ...rest }: {
    children: React__default.ReactNode;
    button?: React__default.ReactNode;
    icon?: JSX.Element;
    rightIcon?: JSX.Element;
    rightSide?: JSX.Element;
    onClick?: (f: React__default.MouseEvent<HTMLElement>) => void;
    href?: string;
    target?: string;
    variant?: TileVariant;
    selected?: boolean;
    compact?: boolean;
    sx?: SxProps;
}) => react_jsx_runtime.JSX.Element;

interface ContainerProps {
    sx?: SxProps;
    maxWidth?: Breakpoint | false;
    children: React.ReactNode;
}
declare const Container: FC<ContainerProps>;

declare const GreyGradient: ({ children, sx }: {
    children: React__default.ReactNode;
    sx?: SxProps;
}) => JSX.Element;

interface CardProps {
    children?: React__default.ReactNode;
    sx?: SxProps;
    backgroundImage: string;
    gradientColor: string;
    onClick?: MouseEventHandler<HTMLElement>;
    compact?: boolean;
}
declare const CardContainer: FC<CardProps>;

interface LuneCardProps extends CardProps {
    title: React__default.ReactNode;
    tiles?: JSX.Element[];
    extraTiles?: JSX.Element[];
    description?: string;
    map?: JSX.Element;
    buttons?: JSX.Element[];
    removeTopPadding?: boolean;
    compact?: boolean;
}
declare const Card: (props: LuneCardProps) => JSX.Element;

interface LayoutProps {
    children: React__default.ReactNode;
    sideBar: JSX.Element;
    isResponsive?: boolean;
    sx?: SxProps;
    menuButtonSx?: SxProps;
    menuButtonContainerSx?: SxProps;
}
declare const Layout: React__default.ForwardRefExoticComponent<LayoutProps & React__default.RefAttributes<unknown>>;

declare const PoweredByLune: () => react_jsx_runtime.JSX.Element;
type Next12Image = React__default.ComponentType<{
    alt?: string;
    src: any;
    width?: number;
    height?: number;
    layout?: any;
}>;
type Next14Image = React__default.ComponentType<{
    alt: string;
    src: any;
    width?: number | `${number}`;
    height?: number | `${number}`;
    layout?: any;
}>;
type NextImage = Next12Image | Next14Image;
declare const PoweredByLuneNext: (props: {
    Image?: NextImage;
}) => react_jsx_runtime.JSX.Element;

declare const BackButton: ({ label, onClick, sx, iconColor, href, ...rest }: {
    label?: string;
    onClick: () => void;
    sx?: SxProps;
    iconColor?: string;
    href?: string;
}) => JSX.Element;

declare const Input: ({ id, name, disabled, error, hint, placeholder, type, onChange, onKeyDown, onBlur, onFocus, className, wide, percentage, startAdornment, endAdornment, sx, highlightOnFocus, autoFocus, tabIndex, ...rest }: {
    id?: string;
    disabled?: boolean;
    error?: string | boolean;
    hint?: string;
    placeholder?: string;
    type?: 'text' | 'password' | 'checkbox' | 'number';
    name?: string;
    onChange?: React__default.ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>;
    onKeyDown?: React__default.KeyboardEventHandler<HTMLTextAreaElement | HTMLInputElement>;
    onBlur?: React__default.ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>;
    onFocus?: React__default.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
    value?: string | number;
    percentage?: boolean;
    className?: string;
    wide?: boolean;
    startAdornment?: React__default.ReactNode;
    endAdornment?: React__default.ReactNode;
    sx?: SxProps;
    highlightOnFocus?: boolean;
    autoFocus?: boolean;
    tabIndex?: number;
}) => react_jsx_runtime.JSX.Element;

interface MainLayoutContainerProps extends ContainerProps$1 {
    headerComponent?: React__default.ReactNode;
    children: React__default.ReactNode;
    maxWidth?: Breakpoint | false;
}
/**
 * A layout container for the main content of standard views
 * Provides a maxWidth for a container with your content and center it within the view,
 * so you don't have to worry about padding on x-axis.
 * Adds margins on y-axis;
 * [Story](https://storybook.lune.co/?path=/story/MainLayoutContainer)
 * @param headerComponent - top part of the column (title or back button usually)
 * @param children - your content (the component will NOT provide spacing the children)
 * @param maxWidth - can be used to change the container maxWidth by passing a breakpoint or 'false' to remove it
 * by default is set to 'md' breakpoint
 */
declare const MainLayoutContainer: ({ headerComponent, children, maxWidth, ...rest }: MainLayoutContainerProps) => react_jsx_runtime.JSX.Element;

declare const Loading: ({ light, sx, ...rest }: {
    light?: boolean;
    sx?: SxProps;
}) => react_jsx_runtime.JSX.Element;

declare const LoadingWrapper: ({ loading, children, className, bigLoader, light, sx, ...rest }: {
    loading?: boolean;
    children: React__default.ReactNode;
    className?: string;
    bigLoader?: boolean;
    light?: boolean;
    sx?: SxProps;
}) => react_jsx_runtime.JSX.Element;

declare const Textarea: ({ id, name, disabled, error, placeholder, onChange, onBlur, onFocus, className, wide, rows, maxRows, autofocus, inputRef, sx, singleLine, ...rest }: {
    id?: string;
    disabled?: boolean;
    error?: string | boolean;
    placeholder?: string;
    name?: string;
    onChange?: React__default.ChangeEventHandler<HTMLTextAreaElement>;
    onBlur?: React__default.FocusEventHandler<HTMLTextAreaElement>;
    onFocus?: React__default.FocusEventHandler<HTMLTextAreaElement>;
    value?: string;
    className?: string;
    wide?: boolean;
    rows?: number;
    maxRows?: number;
    autofocus?: boolean;
    inputRef?: React__default.Ref<any>;
    sx?: SxProps;
    singleLine?: boolean;
}) => react_jsx_runtime.JSX.Element;

interface Props$6<T> {
    value: T;
    items: {
        value: T;
        label: string;
    }[];
    onChange: (value: T) => void;
    sx?: SxProps;
    menuSx?: SxProps;
    menuElevation?: number;
    disabled?: boolean;
    label?: string;
    error?: string | boolean;
}
/**
 * Controlled select component
 * Supports using objects as values (not just strings/numbers),
 * which is useful for complex forms
 * @param prop
 * @param value - the currently selected value - its inferred type is used to infer the type of the items' value
 * @param items - array of objects with value and label properties
 * @param onChange - callback to be called with the selected item's value
 * @param disabled - disables select
 * @param label - used as a placeholder
 * @param error - used to show error state
 * @param sx
 * @constructor
 */
declare const Select: <T>({ value, items, onChange, sx, menuSx, menuElevation, disabled, label, error, ...rest }: Props$6<T>) => react_jsx_runtime.JSX.Element;

declare const ImageUpload: ({ imgSrc, title, isUploading, onButtonClick, }: {
    imgSrc?: string;
    title?: string;
    isUploading: boolean;
    onButtonClick: () => void;
}) => react_jsx_runtime.JSX.Element;

/**
 * Controlled Modal component
 * @param open - Used to show/hide Modal
 * @param children - Children nodes that go inside Modal tags, will be rendered inside Modal content
 * @param header - Nodes that will be rendered on the Modal header.
 * Can be used to render a modal title
 * @param subheader - Nodes that will be rendered on the Modal header.
 * Can be used to render a modal description
 * @param actions - Nodes that will be rendered on the Modal footer.
 * Can be used to render modal action buttons
 * @param className - Override or extend the classes applied to the component
 * @param disableEscapeKeyDown - `false` by default; used to disable closing modal on ESC press
 * @param fullScreen - If `true`, the modal is full-screen.
 * @param fullWidth - If true, the dialog stretches to `maxWidth`.
 * Notice that the dialog width grow is limited by the default margin.
 * @param maxWidth - Determine the max-width of the Modal. The Modal width grows with the size of the screen.
 * Set to `false` to disable maxWidth
 * @param onClose - Callback fired when the component requests to be closed.
 * should be used to set 'open' prop to false in order to close the modal
 */
declare const Modal: ({ open, children, header, subheader, actions, className, disableEscapeKeyDown, fullScreen, fullWidth, maxWidth, onClose, sx, withoutSpacing, stickyFooter, ...rest }: {
    open: boolean;
    children?: React__default.ReactNode;
    onClose: (event: any, reason: string) => void;
    header?: React__default.ReactNode;
    subheader?: React__default.ReactNode;
    actions?: React__default.ReactNode;
    className?: string;
    disableEscapeKeyDown?: boolean;
    fullScreen?: boolean;
    fullWidth?: boolean;
    maxWidth?: false | Breakpoint | undefined;
    withoutSpacing?: boolean;
    sx?: SxProps;
    stickyFooter?: boolean;
}) => JSX.Element;

declare const LabeledFormSection: ({ title, subTile, children, sx, titlePros, }: {
    children: React__default.ReactNode;
    title: string;
    subTile?: React__default.ReactNode;
    sx?: SxProps;
    titlePros?: Record<string, any>;
}) => react_jsx_runtime.JSX.Element;

declare const MemberInfoCard: ({ name, suffix, email, sx, src, }: {
    src?: string;
    name: string;
    suffix?: string;
    email: string;
    sx?: SxProps;
}) => react_jsx_runtime.JSX.Element;

declare const CurrencyPicker: ({ value, onChange, disabled, error, placeholder, ...rest }: {
    value: string;
    onChange: (value: string | undefined) => void;
    error?: string;
    placeholder?: string;
    disabled?: boolean;
}) => JSX.Element;

interface Props$5 {
    image: ReactNode;
    title: React__default.ReactNode;
    onHoverContent?: ReactNode;
    subTitle?: React__default.ReactNode;
    sx?: SxProps$1;
    compact?: boolean;
    dataTestId?: string;
}
declare const ListItemLayout: FC<Props$5>;

declare const Table: {
    (props: TableProps): react_jsx_runtime.JSX.Element;
    TableCell: (props: CellProps) => react_jsx_runtime.JSX.Element;
    TableHead: (props: TableHeadProps) => react_jsx_runtime.JSX.Element;
    TableBody: (props: TableBodyProps) => react_jsx_runtime.JSX.Element;
    TableRow: (props: TableRowProps) => react_jsx_runtime.JSX.Element;
    TableContainer: (props: TableContainerProps) => react_jsx_runtime.JSX.Element;
};
interface CellProps extends TableCellProps {
    disabled?: boolean;
    shrink?: boolean;
    alignEnd?: boolean;
    colSize?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
}

type FilterFunction = (option: {
    label: string;
}, key: string) => boolean;
interface Props$4<T> {
    value: T;
    items: T[];
    onChange: (value: T) => void;
    sx?: SxProps;
    disabled?: boolean;
    label?: string;
    error?: string | boolean;
    groupBy?: (option: T) => string;
    showGroupName?: boolean;
    filter?: FilterFunction;
    customOptions?: (option: T) => React__default.ReactNode;
}
declare const AutocompleteSelect: <T>({ value, items, onChange, sx, disabled, label, error, groupBy, customOptions, filter, showGroupName, ...rest }: Props$4<T>) => React__default.ReactElement;

interface Props$3 {
    value: string;
    onChange: (value: string | undefined) => void;
    error?: string;
    placeholder?: string;
    disabled?: boolean;
    filter?: FilterFunction;
}
declare const CountryPicker: FC<Props$3>;

interface Props$2 {
    value: string | undefined;
    onChange: (value: string | undefined) => void;
    error?: string;
    placeholder?: string;
    disabled?: boolean;
}
declare const SeaportPicker: FC<Props$2>;

interface Props$1 {
    value: string | undefined;
    onChange: (value: string | undefined) => void;
    error?: string;
    placeholder?: string;
    disabled?: boolean;
}
declare const AirportPicker: FC<Props$1>;

interface MultiSelectProps<T> {
    options: T[];
    getOptionLabel: (option: T) => string;
    onChange: (value: readonly T[]) => void;
    value?: T[];
    sx?: SxProps;
    disabled?: boolean;
    label?: string;
    error?: string | boolean;
    showAllSelectedItems?: boolean;
    loadingOptions?: boolean;
}
declare const AutocompleteMultiSelect: <T>({ options, getOptionLabel, onChange, value, sx, disabled, label, error, showAllSelectedItems, loadingOptions, ...rest }: MultiSelectProps<T>) => React__default.ReactElement;

declare const DropdownItem: FC<MenuItemProps>;
/**
 * Dropdown component
 * @param buttonLabel - label shown on the button
 * @param children - list of `DropdownItem` elements or other react nodes, which will be rendered as dropdown items
 * @param active - sets button's active state; false by default
 * @param closeOnClick - if set to false, prevents dropdown from closing on any item click; true by default
 * @param compact - compact version of the dropdown button; false by default
 * @param menuAutoWidth - forcing the dropdown's width to match its items' width ; false by default
 * @param sx - custom style that applies to dropdown button
 * @param labelSx - custom style that applies to the button label
 * @constructor
 */
declare const Dropdown: FC<{
    buttonLabel: string;
    active?: boolean;
    closeOnClick?: boolean;
    menuAutoWidth?: boolean;
    compact?: boolean;
    sx?: SxProps;
    labelSx?: SxProps;
    dataTestId?: string;
    children: React.ReactNode;
}>;

/**
 * ButtonGroup uses width:100% and resizes its child buttons to be of equal size and to fit the available space.
 * @param value
 * @param items
 * @param onChange
 * @param disabled
 * @constructor
 */
declare const ButtonGroup: FC<{
    value: string;
    items: {
        value: string;
        label: string | ReactNode;
        dataTestId?: string;
    }[];
    onChange?: (value: string) => void;
    disabled?: boolean;
    sx?: SxProps;
}>;

declare const CustomizedSwitches: FC<SwitchProps>;

declare const SearchInput: FC<{
    onSearch: (searchKey: string) => void;
    onClear: () => void;
    sx?: SxProps;
}>;

declare enum StepState$1 {
    PENDING = 0,
    ACTIVE = 1,
    COMPLETED = 2,
    CANCELED = 3
}
interface Step$1 {
    label: string;
    state: StepState$1;
    icon?: JSX.Element;
    color?: string;
    backgroundColor?: string;
}
interface StepperProps {
    steps: Step$1[];
    sx: SxProps;
}
declare const Stepper: FC<StepperProps>;

declare enum StepState {
    PENDING = 0,
    ACTIVE = 1,
    COMPLETED = 2,
    CANCELED = 3
}
interface Step {
    label: string;
    state: StepState;
    icon?: JSX.Element;
    backgroundColor?: string;
}
interface ProgressStepsProps {
    steps: Step[];
    sx?: SxProps;
}
declare const ProgressSteps: FC<ProgressStepsProps>;

declare const CtaTile: FC<{
    title: string;
    subTitle?: string;
    image: string | React__default.ReactNode;
    onClick?: () => void;
    disabled?: boolean;
    sxProps?: SxProps;
    mini?: boolean;
    showArrow?: boolean;
    href?: string;
    icon?: React__default.ReactNode;
    newPage?: boolean;
}>;

interface CheckboxProps {
    checked: boolean;
    onChange: (event: React__default.ChangeEvent<HTMLInputElement>, checked: boolean) => void;
    disabled?: boolean;
    indeterminate?: boolean;
    sx?: SxProps;
    label?: string;
}
declare const Checkbox: FC<CheckboxProps>;

declare const IconButtonDropdown: {
    ({ icon, id, children, closeOnClick, menuAutoWidth, sx, position, }: {
        icon: JSX.Element;
        id?: string;
        closeOnClick?: boolean;
        menuAutoWidth?: boolean;
        sx?: SxProps;
        position?: 'left' | 'right' | 'center';
        children: ReactNode;
    }): react_jsx_runtime.JSX.Element;
    MenuItem: ({ icon, title, onClick, disabled, }: {
        icon: ReactElement;
        title: ReactNode;
        onClick: () => void;
        disabled?: boolean;
    }) => react_jsx_runtime.JSX.Element;
};

declare const CodeBox: FC<{
    children: ReactNode;
    sx?: SxProps;
}>;

declare const NoResultsPlaceholder: FC<{
    message: React__default.ReactNode;
}>;

interface DateRangePickerComponentProps {
    onChange: (range: Range) => void;
    predefinedRange?: PredefinedRange;
}
interface PredefinedRange {
    startDate: Date;
    endDate: Date;
}
declare const DateRangePickerComponent: FC<DateRangePickerComponentProps>;

declare const Chip: FC<{
    label: string;
    icon?: React__default.ReactElement;
    sx?: SxProps;
    href?: string;
}>;

type MediaItem = {
    url: string;
    type: 'image' | 'video';
    attributionText?: string;
    attributionUrl?: string;
    previewWidth?: number;
    previewHeight?: number;
};
declare const MediaBox: FC<{
    media: MediaItem[];
    sx?: SxProps;
}>;

type Props = {
    url: string;
    attributionUrl?: string;
    attributionText?: string;
};
type ImageProps = Props & {
    type: 'image';
} & HTMLAttributes<HTMLImageElement>;
type VideoProps = Props & {
    type: 'video';
} & HTMLAttributes<HTMLVideoElement>;
type MediaProps$1 = ImageProps | VideoProps;
interface ControlledLightboxProps {
    onPrevious(): unknown;
    onNext(): unknown;
    activeIndex: number;
}
interface LightboxProps extends Omit<DialogProps, 'children'> {
    media: MediaProps$1[];
    TransitionComponent?: typeof Collapse | typeof Fade | typeof Slide | typeof Grow | typeof Zoom;
}
declare const Lightbox: (props: LightboxProps & Partial<ControlledLightboxProps>) => react_jsx_runtime.JSX.Element;

declare const Pin: FC<{
    src?: string;
    title?: string;
    subTitle?: string;
    onClick?: () => void;
    children?: React__default.ReactNode;
    active?: boolean;
}>;

type UnSDGNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17;
declare const UnSDG: ({ n, sx, ...rest }: {
    n: UnSDGNumber;
    sx?: SxProps;
}) => react_jsx_runtime.JSX.Element;

interface RadioButtonGroupProps {
    defaultValue: any;
    value: any;
    name: string;
    onChange: (event: React__default.ChangeEvent<HTMLInputElement>, value: string) => void;
    items: RadioButtonProps[];
}
interface RadioButtonProps {
    label: React__default.ReactNode;
    value: any;
    disabled?: boolean;
}
/**
 * Controlled Radio button group component
 * @param defaultValue - The default/initial value. Use when the component is not controlled.
 * @param value - Value of the selected radio button. The DOM API casts this to a string.
 * @param name - The name used to reference the value of the control
 * @param onChange - Callback fired when a radio button is selected.
 * @param items - Radio buttons containing a value, and a label that can be a string, Text, Textarea, Input, or any other ReactNode
 */
declare const RadioButtonGroup: FC<RadioButtonGroupProps>;

interface CertificateProps {
    id: string;
    allocatedAmount: string;
    retiredAmount: string;
    clientName: string;
    createdDate: string;
    QRCodeUrl: string;
    backgroundGradientHash: number;
    updatedDate?: string;
    onClick?: MouseEventHandler<HTMLElement>;
}
declare const Certificate: FC<CertificateProps>;

declare const CertificateModal: FC<{
    openModal: boolean;
    onClose: () => void;
    tilesRetired?: React__default.ReactNode;
    tilesAllocated?: React__default.ReactNode;
    registries: React__default.ReactNode;
    certificate: React__default.ReactNode;
    clientName: string;
    loading?: boolean;
    disableModal?: boolean;
}>;

declare const ExpandableList: FC<{
    open?: boolean;
    title?: string;
    children: React__default.ReactNode[];
    sx?: SxProps;
}>;

type BaseJsonProperty = {
    name: string;
    required?: boolean;
    nullable?: boolean;
    description?: string;
};
type SimpleJsonProperty = BaseJsonProperty & {
    type: 'string' | 'number' | 'float' | 'boolean' | 'integer';
    format?: string;
    pattern?: string;
    $enum?: readonly (string | number)[];
};
type ArrayJsonProperty = BaseJsonProperty & {
    type: 'array';
    $ref?: string;
    jsons: readonly AnyJsonProperty[];
};
type ObjectJsonProperty = BaseJsonProperty & {
    type: 'object';
    $ref?: string;
    jsons: readonly AnyJsonProperty[];
};
type AllOfProperty = BaseJsonProperty & {
    type: 'allOf';
    jsons: readonly AnyJsonProperty[];
};
type OneOfProperty = BaseJsonProperty & {
    type: 'oneOf';
    defaultName?: string;
    jsons: readonly AnyJsonProperty[];
};
type AnyJsonProperty = SimpleJsonProperty | ArrayJsonProperty | ObjectJsonProperty | AllOfProperty | OneOfProperty;
type JsonPropertyProps = {
    level?: number;
    hasSiblings?: boolean;
    json: AnyJsonProperty;
    sx?: SxProps;
};
declare const JsonProperty: FC<JsonPropertyProps>;

declare const JsonObjectTable: FC<{
    title?: string;
    description?: string;
    children: React__default.ReactNode;
    sx?: SxProps;
}>;

/**
 * GradientSVG component.
 *
 * This component generates an SVG with either a radial or linear gradient based on the given hashNumber prop.
 * The gradient style is determined by the characteristics of the hashNumber in the following manner:
 *
 * Color pick is determined by [0]
 * Frequency is determined by [1] and [2]
 * Rotate is determined by [3]
 * Octaves is determined by [4]
 * The gradient type (either 'radial' or 'linear') is determined by [5]
 * The seed for fractalNoise is determined by [6] + [9] * 110
 *
 * @param {object} props - Component props.
 * @param {number} props.hashNumber - A number used to generate the gradient SVG.
 *
 * @example
 * return <GradientSVG hashNumber={1234567890} />;
 *
 * @returns {React.Element} The GradientSVG component.
 */
declare const GradientSVG: FC<{
    hashNumber: number;
}>;

interface ISnippetItemProps {
    toCopy?: string;
    language?: string;
    lineNumbers?: boolean;
    label?: string;
    children: React__default.ReactNode;
}
declare const SnippetItem: FC<ISnippetItemProps>;
interface ISnippetProps {
    header: string;
    sx?: SxProps;
    children: React__default.ReactElement<ISnippetItemProps> | React__default.ReactElement<ISnippetItemProps>[];
    onChange?: (i: number) => void;
}
declare const Snippet: FC<ISnippetProps>;

declare const MutuallyExclusiveListOption: ({ children, }: {
    name: string;
    children: React__default.ReactNode | React__default.ReactNode[];
}) => react_jsx_runtime.JSX.Element;
declare const MutuallyExclusiveList: FC<{
    title?: string;
    defaultName?: string;
    discriminator?: string;
    children: React__default.ReactNode[];
    sx?: SxProps;
}>;

interface ApiReferenceSectionProps {
    children: React.ReactNode[];
    sx?: SxProps;
}
declare const ApiReferenceSection: ({ children, sx, ...rest }: ApiReferenceSectionProps) => JSX.Element;

interface ResultTileProps {
    iconName: string;
    text: string;
    iconSx?: SxProps;
    textSx?: SxProps;
}
declare const ProjectResultsTile: FC<ResultTileProps>;

type BarProps = {
    label: string;
    percentage: number;
    subLabel?: string;
    color?: string;
};
type HorizontalBarChartProps = {
    items: BarProps[];
    sort?: 'asc' | 'desc';
};
declare const HorizontalBarChart: FC<HorizontalBarChartProps>;

declare const countriesList: string[][];

declare const currencies: {
    label: string;
    value: string;
}[];

declare const airports: string[][];

declare const ports: string[][];

declare const AccordionTile: FC<{
    children: React__default.ReactNode;
    title?: React__default.ReactNode;
    icon?: React__default.ReactNode;
    expanded?: boolean;
    sx?: SxProps;
}>;

declare const XlContainer: ({ children, sx }: {
    children: React.ReactNode;
    sx?: SxProps;
}) => react_jsx_runtime.JSX.Element;

interface TabProps {
    label: string;
    value: string;
    dataTestId: string;
}
type TabsSubcomponent = {
    Tab: typeof Tab;
};
declare const Tab: FC<{
    children: React__default.ReactNode;
} & {
    label: string;
    value: string;
}>;
declare const ToggleTabs: FC<{
    children: React__default.ReactNode[];
    defaultActive?: string;
    sx?: SxProps;
    onChange?: (selected: TabProps | undefined) => void;
}> & TabsSubcomponent;

declare function Tabs(props: TabsProps): react_jsx_runtime.JSX.Element;
declare namespace Tabs {
    var Tab: React__default.FC<TabProps$1>;
}

type ITooltip = TooltipProps & {
    contentWidth?: boolean;
};
declare const Tooltip: FC<ITooltip & {
    style?: React__default.CSSProperties;
}>;
declare const TooltipList: FC<{
    items: React__default.ReactNode[] | string[];
}>;

/**
 * A "standard" Layout for a title/subTitle-type Header of a Modal Dialog
 * Only meant to be passed as "header" prop to ui-lib's Modal (help with DRY)
 * @param title
 * @param subTitle - optional
 * @param sx - optional custom style
 * @constructor
 */
declare const StandardModalHeader: ({ title, subTitle, sx }: {
    title: string;
    subTitle?: string;
    sx?: SxProps;
}) => react_jsx_runtime.JSX.Element;

declare const BannerMessage: FC<({
    message: string;
} | {
    children: React__default.ReactNode;
}) & {
    sx?: SxProps;
    textSx?: SxProps;
}>;

declare enum ColumnWrapOrder {
    REVERSE = "reverse",
    NORMAL = "normal"
}
type MuiValues = number | {
    xs: number;
    sm: number;
    md: number;
    lg: number;
    xl: number;
};
declare const TwoColumnLayout: ({ children, leftCol, rightCol, columnWrapOrderOnMobile, spacing, pb, sx, }: {
    children: [React.ReactNode, React.ReactNode];
    leftCol?: number;
    rightCol?: number;
    columnWrapOrderOnMobile: ColumnWrapOrder;
    spacing?: MuiValues;
    pb?: MuiValues;
    sx?: SxProps;
}) => react_jsx_runtime.JSX.Element;

interface MediaProps {
    src: string;
    type: 'image' | 'video';
    alt?: string;
    placeholderSrc?: string;
    dynamicPlaceholder?: {
        width: number;
        height: number;
        color?: string;
    };
    width?: number;
    height?: number;
    key?: string;
    sx?: SxProps;
    autoPlay?: boolean;
    muted?: boolean;
    loop?: boolean;
    backgroundImage?: boolean;
    onLoad?: (loaded: boolean) => void;
}
/**
 * Media component
 * @param src - main image source
 * @param type - media type -> image or video
 * @param placeholderSrc - placeholder image source
 * @param dynamicPlaceholder - setting an autogenerated placeholder with specific width, height and color(optional)
 * @param alt - default image and video alt prop
 * @param sx - custom style that applies to dropdown button
 * @param width - media width
 * @param height - media height
 * @param key - default key prop
 * @param autoPlay - video specific -> default video autoplay prop
 * @param loop -  video specific -> default video loop prop
 * @param muted -  video specific -> default video muted prop
 * @param backgroundImage - setting image as a background image
 */
declare const Media: FC<MediaProps>;

declare const ScrollableContainer: FC<{
    sessionStoragePositionName?: string;
    containerRef?: React__default.RefObject<HTMLDivElement>;
    children: ReactNode;
    ignoreElements?: string;
}>;

declare const Slider: FC<SliderProps>;

declare const Markdown: React__default.FC<{
    children: string;
}>;

interface DragAndDropFileUploadProps extends DropzoneOptions {
    description?: string;
    children?: React__default.ReactNode;
    isUploading?: boolean;
    rejectDescription?: string;
}
declare const DragAndDropFileUpload: React__default.ForwardRefExoticComponent<DragAndDropFileUploadProps & React__default.RefAttributes<Pick<HTMLInputElement, "click">>>;

interface NumberStepsProps {
    steps: ReactNode[];
    sx?: SxProps;
}
declare const NumberSteps: FC<NumberStepsProps>;

declare const useIsMobile: () => {
    isMobile: boolean;
};

declare const searchByWordPrefix: (option: {
    label: string;
}, key: string) => boolean;

declare const luneAssetsToDynamicAssets: (imageUrl: string, width: number, height: number) => string;

/**
 * A helper to get statically imported images' paths.
 *
 * It's needed because this code is used in two contexts and static image imports behave
 * differently in them:
 *
 * * lune-ui-lib standalone when building it with Rollup
 * * lune-ui-lib code included and built as part of the website (a Next.js application)
 * @param image Whatever an import like `import LuneLogo from '../images/lune-logo.png';`
 * produces.
 * @returns An image path.
 */
declare function staticImagePath(image: string | {
    src: string;
}): string;

export { AccordionTile, AirportPicker, type AllOfProperty, type AnyJsonProperty, ApiReferenceSection, type ArrayJsonProperty, AutocompleteMultiSelect, AutocompleteSelect, BackButton, BannerMessage, Button, ButtonGroup, Card, CardContainer, Certificate, CertificateModal, Checkbox, Chip, CodeBox, ColumnWrapOrder, Container, CountryPicker, CtaTile, CurrencyPicker, DateRangePickerComponent as DateRangePicker, DragAndDropFileUpload, Dropdown, DropdownItem, ExpandableList, GradientSVG, GreyGradient, HorizontalBarChart, IconButtonDropdown, ImageUpload, Input, JsonObjectTable, JsonProperty, LabeledFormSection, Layout, Lightbox, ListItemLayout, Loading, LoadingWrapper, theme as LuneTheme, MainLayoutContainer, Markdown, Media, MediaBox, MemberInfoCard, Modal, MutuallyExclusiveList, MutuallyExclusiveListOption, NoResultsPlaceholder, NumberSteps, type ObjectJsonProperty, type OneOfProperty, Pin, PoweredByLune, PoweredByLuneNext, ProgressSteps, StepState as ProgressStepsState, ProjectResultsTile, RadioButtonGroup, ScrollableContainer, SeaportPicker, SearchInput, Select, type SimpleJsonProperty, Slider, Snippet, SnippetItem, StandardModalHeader, StepState$1 as StepState, Stepper, CustomizedSwitches as Switch, Table, Tabs, Textarea, Tile, ToggleTabs, Tooltip, TooltipList, TwoColumnLayout, UnSDG, XlContainer, airports as airportsList, countriesList, currencies as currenciesList, fontFamily, luneAssetsToDynamicAssets, ports as seaportsList, searchByWordPrefix, staticImagePath, useIsMobile };