import * as react from 'react';
import { ButtonHTMLAttributes, ComponentType, HTMLAttributes, AnchorHTMLAttributes, DependencyList, ReactElement, ReactNode, ForwardRefRenderFunction, ForwardRefExoticComponent, PropsWithoutRef, RefAttributes, useEffect, Dispatch, SetStateAction, EffectCallback, SVGAttributes, HtmlHTMLAttributes, CSSProperties, PureComponent, InputHTMLAttributes, TextareaHTMLAttributes, FC } from 'react';
import { Placement as Placement$1 } from '@floating-ui/react-dom-interactions';
import * as _theme_ui_core from '@theme-ui/core';
import { Theme, jsx } from '@theme-ui/core';
import { EChartsOption, ECharts } from 'echarts';
import { Placement } from '@floating-ui/react-dom';
import { UseFormReturn, SubmitHandler, UseFormProps } from 'react-hook-form';
import * as delta_jsf from 'delta-jsf';
import { FieldProps, ValidateAgainstSchemaOptions, FormManagerOptions, FormManager, TemplateProps } from 'delta-jsf';
export { Form as JsForm, FormManager as JsFormManager, FormManagerOptions as JsFormManagerOptions, FormProps as JsFormProps, ValidateAgainstSchemaOptions, validateAgainstSchemaViaAjv } from 'delta-jsf';
import FocusTrap from 'focus-trap-react';

interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
    variant?: 'contained' | 'contained-dimmed' | 'outlined' | 'text' | 'icon';
    color?: 'primary' | 'secondary' | 'info' | 'success' | 'error';
    size?: 'small' | 'medium' | 'large';
    icon?: ComponentType<HTMLAttributes<Element>>;
}
declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;

interface AccountProps extends ButtonProps {
}
declare const Account: react.ForwardRefExoticComponent<AccountProps & react.RefAttributes<HTMLButtonElement>>;

interface AnchorProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
    variant?: 'pure';
}
declare const Anchor: react.ForwardRefExoticComponent<AnchorProps & react.RefAttributes<HTMLAnchorElement>>;

interface BoxProps extends HTMLAttributes<HTMLDivElement> {
}
declare const Box: react.ForwardRefExoticComponent<BoxProps & react.RefAttributes<HTMLDivElement>>;

interface AlertProps extends BoxProps {
    onClose?: () => void;
    color?: 'info' | 'success' | 'warning' | 'error';
}
declare const Alert: react.ForwardRefExoticComponent<AlertProps & react.RefAttributes<HTMLDivElement>>;

interface AlertHolderProps extends Omit<BoxProps, 'children'> {
    children?: any;
}
declare const AlertHolder: react.ForwardRefExoticComponent<AlertHolderProps & react.RefAttributes<HTMLDivElement>>;

declare const useCleanableRef: <T extends unknown>(callback: (instance: T) => (() => void) | void | undefined, deps: DependencyList) => (instance: T) => void;

declare const useClickOutside: <T extends HTMLElement, E extends Event = Event>(onClickOutside: (event: E) => void, events?: string[]) => react.MutableRefObject<T | null>;

interface Stack<T> {
    pop: () => T | undefined;
    push: (v: T) => void;
    reset: () => void;
}
declare const useDataStack: <T>(init?: T[] | undefined) => [T, T[], Stack<T>];

declare const useDebounce: <T extends unknown>(value: T, delay: number) => T;

declare const useDeltaTheme: (overrides?: Theme) => {
    mode: string;
    fontFamily: string;
    colors: {
        context: string;
        accentContext: string;
        onContext: string;
        accentOnContext: string;
        brandAlpha: string;
        brandBeta: string;
        primary: string;
        secondary: string;
        info: string;
        warning: string;
        success: string;
        error: string;
        background: string;
        mundane: string;
        celestial: string;
        contrast: string;
        exterior: string;
        border: string;
        accentPrimary: string;
        accentSecondary: string;
        accentInfo: string;
        accentWarning: string;
        accentSuccess: string;
        accentError: string;
        accentBackground: string;
        accentMundane: string;
        accentCelestial: string;
        accentContrast: string;
        accentExterior: string;
        accentBorder: string;
        onPrimary: string;
        onSecondary: string;
        onInfo: string;
        onSuccess: string;
        onWarning: string;
        onError: string;
        onBackground: string;
        onMundane: string;
        onCelestial: string;
        onContrast: string;
        onExterior: string;
        accentOnPrimary: string;
        accentOnSecondary: string;
        accentOnInfo: string;
        accentOnSuccess: string;
        accentOnWarning: string;
        accentOnError: string;
        accentOnBackground: string;
        accentOnMundane: string;
        accentOnCelestial: string;
        accentOnContrast: string;
        accentOnExterior: string;
    };
    letterSpacings: number[];
    sizes: number[];
    ticks: number[];
    space: number[];
    fontSizes: number[];
    fontWeights: {
        light: number;
        normal: number;
        bold: number;
    };
    radii: number[];
    shadows: {
        soft: string;
        hard: string;
    };
};

interface ImperativePortal extends ReactElement {
    set: (children: ReactNode[]) => void;
    push: (child: ReactNode) => void;
    remove: (child: ReactNode) => void;
}
declare const useImperativePortal: (target: HTMLElement | ImperativePortal | null) => ImperativePortal;

type ForwardRefCRF<T, P> = ForwardRefRenderFunction<T, P> | ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;
declare const useForwardRef: <T, P>(componentOrRenderFunction: ForwardRefCRF<T, P>, deps: DependencyList) => ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;

interface PortalledProps<C = never> {
    handleClose: () => void;
    context?: C;
}
type PortalledCRF<T, C = never> = ForwardRefCRF<T, PortalledProps<C>>;
interface PortalledOptions {
    deps: DependencyList;
    portal: ImperativePortal;
}
declare const usePortalled: <T extends HTMLElement, C = never>(crf: PortalledCRF<T, C>, { deps, portal: { push, remove } }: PortalledOptions) => (context?: C | undefined) => () => void;

interface DialogProps<C extends unknown = never> extends PortalledProps<C> {
}
interface DialogRenderFn<C extends unknown = never> {
    (props: DialogProps<C>): JSX.Element;
}
interface DialogOptions {
    deps: DependencyList;
    portal?: ImperativePortal;
    focusTrap?: boolean | FocusTrap.Props['focusTrapOptions'];
    onClose?: () => void;
}
declare const useDialog: <C extends unknown = never>(render: DialogRenderFn<C>, options: DialogOptions) => (context?: C | undefined) => () => void;

interface DropRendererProps<C extends unknown = never> extends PortalledProps<C> {
}
interface DropRenderer<C extends unknown = never> {
    (props: DropRendererProps<C>): JSX.Element;
}
interface DropOptions extends Omit<DropProps, 'children'> {
    deps: DependencyList;
    placement?: Placement;
    portal?: ImperativePortal;
    multiple?: boolean;
    tailored?: boolean;
    blurResistant?: boolean;
    onClose?: () => void;
}
declare const useDrop: <T extends Element, C extends unknown = never>(render: DropRenderer<C>, options: DropOptions) => readonly [() => () => void, (v: T | null) => void];

declare const useEChartDefalults: () => {
    line: {
        grid: () => {
            left: number;
            right: number;
            top: number;
            bottom: number;
        };
        xAxis: () => {
            type: "time";
            axisTick: {
                length: number;
                lineStyle: {
                    type: "dashed";
                };
            };
            splitLine: {
                show: boolean;
                lineStyle: {
                    color: string;
                };
            };
            boundaryGap: boolean;
        };
        yAxis: () => {
            type: "value";
            splitLine: {
                show: boolean;
                lineStyle: {
                    color: string;
                };
            };
        };
        itemStyle: (color: string) => {
            color: string;
        };
        areaStyle: (color: string) => {
            color: any;
        };
    };
    pie: {
        tooltip: () => {
            trigger: "item";
            formatter: string;
        };
        radius: () => string[];
        itemStyle: () => {
            borderWidth: number;
            borderRadius: number;
            borderColor: string;
        };
        emphasis: () => {
            label: {
                show: boolean;
                fontSize: number;
                fontWeight: "bold";
            };
        };
        label: () => {
            position: "inner";
            fontSize: number;
            color: string;
            formatter: ({ data }: {
                data: any;
            }) => any;
        };
    };
};

declare const useGeoLocDescription: (geoLoc?: {
    lat: number;
    lng: number;
}) => readonly [string | undefined, boolean];

interface GridAxisOptions {
    count?: number;
    minWidth?: string;
}
interface GridOptions<Element extends HTMLElement, Extras extends object> {
    columns?: GridAxisOptions;
    rows?: GridAxisOptions;
    getExtras?: (element?: Element) => Extras;
}
interface GridMeasurements {
    gap?: number;
    rowsCount?: number;
    columnsCount?: number;
}
declare const useGrid: <Element_1 extends HTMLElement, Extras extends object = {}>({ columns, rows, getExtras, }: GridOptions<Element_1, Extras>) => {
    style: {
        display: string;
        gridTemplateColumns: string | undefined;
        gridTemplateRows: string | undefined;
    };
    measureElement: react.Dispatch<Element_1>;
    handleElement: (instance: Element_1) => void;
} & GridMeasurements & Extras;

declare const useIsomorphicLayoutEffect: typeof useEffect;

declare const useLeafletDefaults: () => {
    mapContainer: {
        attributionControl: boolean;
        center: {
            lat: number;
            lng: number;
        };
        zoom: number;
    };
    tileLayer: {
        url: string;
    };
    icon: {
        iconUrl: string;
        shadowUrl: string;
        iconAnchor: number[];
        popupAnchor: number[];
        iconSize: number[];
    };
};

interface LoaderRegistryDatum {
    count: number;
    subscriptions: Dispatch<SetStateAction<boolean>>[];
}
declare class LoaderRegistry {
    data: Map<any, LoaderRegistryDatum>;
    globalDatum: LoaderRegistryDatum;
    addDelta(ids: any[] | undefined, delta: 1 | -1): void;
    bind(ids: any[] | undefined, fn: Dispatch<SetStateAction<boolean>>): void;
    clean(ids: any[] | undefined): void;
    load(ids: any[] | undefined): void;
    unbind(ids: any[] | undefined, fn: Dispatch<SetStateAction<boolean>>): void;
    unload(ids: any[] | undefined): void;
    update(ids: any[] | undefined): void;
}
declare const loaderRegistry: LoaderRegistry;
declare const useLoader: (ids?: any[]) => readonly [boolean, <T extends unknown>(promise: Promise<T>) => Promise<T>];

declare const useModal: <C extends unknown = never>(render: DialogRenderFn<C>, { deps, portal, onClose, ...modalProps }: DialogOptions & Partial<ModalProps>) => (context?: C | undefined) => () => void;

interface TransitionProps {
    isVisible: boolean;
    isEntering: boolean;
}
type TransitionCRF<T, P = TransitionProps> = ForwardRefCRF<T, P>;
interface TransitionOptions {
    deps: DependencyList;
    isMounted: boolean;
}
declare const useTransition: <T extends HTMLElement>(crf: TransitionCRF<T, TransitionProps>, { deps, isMounted }: TransitionOptions) => jsx.JSX.Element | null;

type PortalledTransitionProps<C = never> = PortalledProps<C> & TransitionProps;
type PortalledTransitionCRF<T, C = never> = TransitionCRF<T, PortalledTransitionProps<C>>;
interface PortalledTransitionOptions {
    deps: DependencyList;
    portal: ImperativePortal;
}
declare const usePortalledTransition: <T extends HTMLElement, C = never>(crf: PortalledTransitionCRF<T, C>, { deps, portal }: PortalledTransitionOptions) => (context?: C | undefined) => () => void;

declare enum NotificationPlacement {
    TopLeft = "topLeft",
    TopRight = "topRight",
    BottomLeft = "bottomLeft",
    BottomRight = "bottomRight"
}
interface NotificationOptions extends Omit<NotificationProps, 'children'> {
    duration?: number;
    placement?: NotificationPlacement;
    onClose?: () => void;
    render: (props: PortalledTransitionProps) => ReactNode;
}
declare const useNotification: () => (context?: NotificationOptions | undefined) => () => void;

interface QuestionRendererProps<C> extends Omit<DialogProps<C>, 'handleClose'> {
    handleClose: (v: boolean) => void;
}
interface QuestionRenderer<C> {
    (props: QuestionRendererProps<C>): JSX.Element;
}
type QuestionDescription<C = never> = {
    content?: ReactNode;
    heading: ReactNode;
    okText?: string;
    cancelText?: string;
} | QuestionRenderer<C>;
declare const useQuestion: <C extends unknown = never>(description: QuestionDescription<C>, { deps, portal, onClose, ...questionProps }: DialogOptions & Partial<QuestionProps>) => (context?: C | undefined) => Promise<boolean>;

interface OperationOptions<OperationInput, OperationOutput> {
    deps: any[];
    loaderIds?: any[];
    getQuestion?: (input?: OperationInput) => QuestionDescription;
    getNotification?: <T extends boolean>(isOk: T, output: T extends true ? OperationOutput : Error) => ReactNode | NotificationOptions;
    getAlert?: <T extends boolean>(isOk: T, output: T extends true ? OperationOutput : Error) => ReactNode | AlertProps;
}
declare const useOperation: <OperationInput, OperationOutput>(fn: (input?: OperationInput | undefined) => Promise<OperationOutput>, { deps, loaderIds, getQuestion, getNotification, getAlert, }: OperationOptions<OperationInput, OperationOutput>) => readonly [(input?: OperationInput | undefined) => Promise<void>, ReactElement<AlertProps, string | react.JSXElementConstructor<any>>[]];

declare const useSticked: <T extends HTMLElement>(stickyOffset?: number) => readonly [boolean, react.Dispatch<react.SetStateAction<T | null>>];

declare const useThrottledCallback: <T extends (...args: any) => any>(callback: T, delay: number) => (...args: Parameters<T>) => void;

declare const useUpdateEffect: (fn: EffectCallback, deps: DependencyList) => void;

interface DropProps extends BoxProps, Partial<PortalledProps> {
}
declare const Drop: react.ForwardRefExoticComponent<DropProps & react.RefAttributes<HTMLDivElement>>;
interface DropOptionProps extends ButtonProps {
    size?: 'small' | 'medium';
}
declare const DropOption: react.ForwardRefExoticComponent<DropOptionProps & react.RefAttributes<HTMLButtonElement>>;

interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
    level?: 1 | 2 | 3 | 4 | 5 | 6;
}
declare const Heading: react.ForwardRefExoticComponent<HeadingProps & react.RefAttributes<HTMLHeadingElement>>;

interface LayoutProps extends BoxProps {
}
declare const Layout: react.ForwardRefExoticComponent<LayoutProps & react.RefAttributes<HTMLDivElement>>;

interface LayoutMainProps extends BoxProps {
}
declare const LayoutMain: (props: LayoutMainProps) => jsx.JSX.Element;

interface LayoutMainBodyProps extends BoxProps {
    variant?: 'wide';
    size?: 'small' | 'medium' | 'large';
}
declare const LayoutMainBody: ({ variant, size, children, ...rest }: LayoutMainBodyProps) => jsx.JSX.Element;
declare const layoutMainNoise: string;

interface LayoutMainFooterProps extends BoxProps {
}
declare const LayoutMainFooter: (props: LayoutMainFooterProps) => jsx.JSX.Element;

interface LayoutMainHeaderProps extends BoxProps {
}
declare const LayoutMainHeader: (props: LayoutMainHeaderProps) => jsx.JSX.Element;

declare const layoutMainNavbarHeight = 52;
interface LayoutMainNavbarProps extends Omit<BoxProps, 'children'> {
    children?: ReactNode | ((ratio: boolean) => ReactNode);
}
declare const LayoutMainNavbar: react.ForwardRefExoticComponent<LayoutMainNavbarProps & react.RefAttributes<HTMLDivElement>>;

interface LayoutNavigationProps extends BoxProps {
    activeId: string;
}
declare const LayoutNavigation: ({ activeId, children, ...rest }: LayoutNavigationProps) => jsx.JSX.Element;
declare const NavigationContext: react.Context<NavigationContextProps>;
interface NavigationContextProps {
    activeId?: string;
}

interface LayoutNavigationItemProps extends Omit<AnchorProps, 'onClick'> {
    id: string;
    icon?: ComponentType<HTMLAttributes<Element>>;
    onClick?: () => void;
}
declare const LayoutNavigationItem: react.ForwardRefExoticComponent<LayoutNavigationItemProps & react.RefAttributes<HTMLAnchorElement>>;

interface LayoutNavigationGroupProps extends Omit<BoxProps, 'title'> {
    title: ReactNode;
}
declare const LayoutNavigationGroup: react.ForwardRefExoticComponent<LayoutNavigationGroupProps & react.RefAttributes<HTMLDivElement>>;

interface ResizableBoxProps extends BoxProps {
    onResize?: (width: number) => void;
    width?: number;
    maxWidth?: number;
    minWidth?: number;
    axis?: ('w' | 'e')[];
}

interface LayoutSidebarProps extends ResizableBoxProps {
}
declare const LayoutSidebar: react.ForwardRefExoticComponent<LayoutSidebarProps & react.RefAttributes<HTMLDivElement>>;

interface LayoutSidebarHeaderProps extends BoxProps {
}
declare const LayoutSidebarHeader: react.ForwardRefExoticComponent<LayoutSidebarHeaderProps & react.RefAttributes<HTMLDivElement>>;

interface LayoutSidebarBodyProps extends BoxProps {
}
declare const LayoutSidebarBody: react.ForwardRefExoticComponent<LayoutSidebarBodyProps & react.RefAttributes<HTMLDivElement>>;

interface MasonryProps extends HTMLAttributes<HTMLDivElement> {
    columns: GridAxisOptions & {
        getProps?: (options: {
            index: number;
        }) => Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
    };
}
declare const Masonry: react.ForwardRefExoticComponent<MasonryProps & react.RefAttributes<HTMLDivElement>>;

interface ModalProps extends BoxProps, Partial<PortalledProps> {
    size?: 'small' | 'medium' | 'large';
    closeVariant?: 'inside';
}
declare const Modal: react.ForwardRefExoticComponent<ModalProps & react.RefAttributes<HTMLDivElement>>;

interface ModalBodyProps extends BoxProps {
    variant?: 'wide';
}
declare const ModalBody: react.ForwardRefExoticComponent<ModalBodyProps & react.RefAttributes<HTMLDivElement>>;

interface ModalFooterProps extends HTMLAttributes<HTMLDivElement> {
}
declare const ModalFooter: react.ForwardRefExoticComponent<ModalFooterProps & react.RefAttributes<HTMLDivElement>>;

interface ModalHeaderProps extends HTMLAttributes<HTMLDivElement> {
}
declare const ModalHeader: react.ForwardRefExoticComponent<ModalHeaderProps & react.RefAttributes<HTMLDivElement>>;

interface NotificationProps extends BoxProps, Partial<PortalledTransitionProps> {
    color?: 'info' | 'success' | 'warning' | 'error';
}
declare const Notification: react.ForwardRefExoticComponent<NotificationProps & react.RefAttributes<HTMLDivElement>>;

interface BasicQuestionProps extends Omit<BoxProps, 'children'> {
    content?: ReactNode;
    heading: ReactNode;
    okText?: string;
    cancelText?: string;
    onClose?: (output: boolean) => void;
}
declare const BasicQuestion: react.ForwardRefExoticComponent<BasicQuestionProps & react.RefAttributes<HTMLDivElement>>;

interface QuestionProps extends BoxProps, Partial<PortalledProps> {
}
declare const Question: react.ForwardRefExoticComponent<QuestionProps & react.RefAttributes<HTMLDivElement>>;

interface QuestionHeaderProps extends BoxProps {
}
declare const QuestionHeader: react.ForwardRefExoticComponent<QuestionHeaderProps & react.RefAttributes<HTMLDivElement>>;

interface QuestionBodyProps extends BoxProps {
}
declare const QuestionBody: react.ForwardRefExoticComponent<QuestionBodyProps & react.RefAttributes<HTMLDivElement>>;

interface QuestionFooterProps extends BoxProps {
}
declare const QuestionFooter: react.ForwardRefExoticComponent<QuestionFooterProps & react.RefAttributes<HTMLDivElement>>;

interface ScrollProps extends BoxProps {
    slideStep?: number;
    buttonProps?: Omit<ButtonProps, 'children'>;
}
declare const Scroll: react.ForwardRefExoticComponent<ScrollProps & react.RefAttributes<HTMLDivElement>>;

interface FormWidgetProps<T = unknown> {
    value?: T;
    disabled?: boolean;
    invalid?: boolean;
    onChange?: (value: T) => void;
    onFocus?: () => void;
    onBlur?: () => void;
}

interface System {
    floatingPortal: ImperativePortal;
}

declare const system: System;

declare const deltaTheme: {
    mode: string;
    fontFamily: string;
    colors: {
        context: string;
        accentContext: string;
        onContext: string;
        accentOnContext: string;
        brandAlpha: string;
        brandBeta: string;
        primary: string;
        secondary: string;
        info: string;
        warning: string;
        success: string;
        error: string;
        background: string;
        mundane: string;
        celestial: string;
        contrast: string;
        exterior: string;
        border: string;
        accentPrimary: string;
        accentSecondary: string;
        accentInfo: string;
        accentWarning: string;
        accentSuccess: string;
        accentError: string;
        accentBackground: string;
        accentMundane: string;
        accentCelestial: string;
        accentContrast: string;
        accentExterior: string;
        accentBorder: string;
        onPrimary: string;
        onSecondary: string;
        onInfo: string;
        onSuccess: string;
        onWarning: string;
        onError: string;
        onBackground: string;
        onMundane: string;
        onCelestial: string;
        onContrast: string;
        onExterior: string;
        accentOnPrimary: string;
        accentOnSecondary: string;
        accentOnInfo: string;
        accentOnSuccess: string;
        accentOnWarning: string;
        accentOnError: string;
        accentOnBackground: string;
        accentOnMundane: string;
        accentOnCelestial: string;
        accentOnContrast: string;
        accentOnExterior: string;
    };
    letterSpacings: number[];
    sizes: number[];
    ticks: number[];
    space: number[];
    fontSizes: number[];
    fontWeights: {
        light: number;
        normal: number;
        bold: number;
    };
    radii: number[];
    shadows: {
        soft: string;
        hard: string;
    };
};
declare const deltaLightTheme: {
    mode: string;
    fontFamily: string;
    colors: {
        context: string;
        accentContext: string;
        onContext: string;
        accentOnContext: string;
        brandAlpha: string;
        brandBeta: string;
        primary: string;
        secondary: string;
        info: string;
        warning: string;
        success: string;
        error: string;
        background: string;
        mundane: string;
        celestial: string;
        contrast: string;
        exterior: string;
        border: string;
        accentPrimary: string;
        accentSecondary: string;
        accentInfo: string;
        accentWarning: string;
        accentSuccess: string;
        accentError: string;
        accentBackground: string;
        accentMundane: string;
        accentCelestial: string;
        accentContrast: string;
        accentExterior: string;
        accentBorder: string;
        onPrimary: string;
        onSecondary: string;
        onInfo: string;
        onSuccess: string;
        onWarning: string;
        onError: string;
        onBackground: string;
        onMundane: string;
        onCelestial: string;
        onContrast: string;
        onExterior: string;
        accentOnPrimary: string;
        accentOnSecondary: string;
        accentOnInfo: string;
        accentOnSuccess: string;
        accentOnWarning: string;
        accentOnError: string;
        accentOnBackground: string;
        accentOnMundane: string;
        accentOnCelestial: string;
        accentOnContrast: string;
        accentOnExterior: string;
    };
    letterSpacings: number[];
    sizes: number[];
    ticks: number[];
    space: number[];
    fontSizes: number[];
    fontWeights: {
        light: number;
        normal: number;
        bold: number;
    };
    radii: number[];
    shadows: {
        soft: string;
        hard: string;
        drop: string;
    };
};
type DeltaTheme = typeof deltaTheme;

declare const SystemContext: react.Context<System>;
interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
    theme?: DeltaTheme;
}
declare const SystemContainer: react.ForwardRefExoticComponent<ContainerProps & react.RefAttributes<HTMLDivElement>>;

interface CardProps extends BoxProps {
}
declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>>;

interface CardBodyProps extends BoxProps {
    variant?: 'wide';
}
declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;

interface CardFooterProps extends HTMLAttributes<HTMLDivElement> {
}
declare const CardFooter: react.ForwardRefExoticComponent<CardFooterProps & react.RefAttributes<HTMLDivElement>>;

interface CardHeaderProps extends HTMLAttributes<HTMLDivElement> {
}
declare const CardHeader: react.ForwardRefExoticComponent<CardHeaderProps & react.RefAttributes<HTMLDivElement>>;

interface BadgeProps extends BoxProps {
    color?: 'primary' | 'secondary' | 'info' | 'success' | 'warning' | 'error';
}
declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLDivElement>>;

interface TooltipProps extends Omit<BoxProps, 'children'> {
    content: ReactNode;
    disabled?: boolean;
    delay?: number;
    placement?: Placement$1;
    children: ReactElement;
}
declare const Tooltip: ({ content, disabled, delay, placement, children, ...rest }: TooltipProps) => jsx.JSX.Element | null;

interface DeltaLogoProps extends SVGAttributes<SVGSVGElement> {
    topColor?: string;
    bottomColor?: string;
}
declare const DeltaLogo: ({ topColor, bottomColor, ...rest }: DeltaLogoProps) => jsx.JSX.Element;

interface ChipProps extends HtmlHTMLAttributes<HTMLDivElement> {
    variant?: 'contained' | 'outlined';
    onDelete?: (id: ChipProps['id']) => void;
}
declare const Chip: react.ForwardRefExoticComponent<ChipProps & react.RefAttributes<HTMLDivElement>>;

interface Opts {
    readonly devicePixelRatio?: number;
    readonly renderer?: 'canvas' | 'svg';
    readonly width?: number | null | undefined | 'auto';
    readonly height?: number | null | undefined | 'auto';
    readonly locale?: string;
}
interface EChartsReactProps {
    readonly className?: string;
    readonly echarts?: EChartsOption;
    readonly style?: CSSProperties;
    readonly option: EChartsOption;
    readonly theme?: string | {
        [key: string]: any;
    };
    readonly notMerge?: boolean;
    readonly lazyUpdate?: boolean;
    readonly showLoading?: boolean;
    readonly loadingOption?: any;
    readonly opts?: Opts;
    readonly onEvents?: {
        [key: string]: Function;
    };
    readonly autoResize?: boolean;
    readonly onChartReady?: (instance: any) => void;
    readonly shouldSetOption?: (prevProps: EChartsReactProps, props: EChartsReactProps) => boolean;
}
declare class EChart extends PureComponent<EChartsReactProps> {
    element: HTMLElement | null;
    protected echarts: any;
    private isInitialResize;
    constructor(props: EChartsReactProps);
    componentDidMount(): void;
    componentDidUpdate(prevProps: EChartsReactProps): void;
    componentWillUnmount(): void;
    initEchartsInstance(): Promise<ECharts>;
    getEchartsInstance(): ECharts;
    private dispose;
    private renderNewEcharts;
    private bindEvents;
    private updateEChartsOption;
    private resize;
    render(): JSX.Element;
}

interface LoaderProps extends HtmlHTMLAttributes<HTMLDivElement> {
    size?: 'small' | 'medium' | 'large';
    color?: string;
}
declare const Loader: react.ForwardRefExoticComponent<LoaderProps & react.RefAttributes<HTMLDivElement>>;

interface PairListProps extends BoxProps {
    pairs: any[][];
    variant?: 'column' | 'row' | 'row-space';
    loading?: boolean;
}
declare const PairList: react.ForwardRefExoticComponent<PairListProps & react.RefAttributes<HTMLDivElement>>;

interface SkeletonProps extends Omit<BoxProps, 'children'> {
}
declare const Skeleton: (props: SkeletonProps) => jsx.JSX.Element;

interface TableProps extends HTMLAttributes<HTMLTableElement> {
}
declare const Table: react.ForwardRefExoticComponent<TableProps & react.RefAttributes<HTMLTableElement>>;

interface TableBodyProps extends HTMLAttributes<HTMLTableSectionElement> {
}
declare const TableBody: react.ForwardRefExoticComponent<TableBodyProps & react.RefAttributes<HTMLTableSectionElement>>;

interface TableBodyCellProps extends HTMLAttributes<HTMLTableCellElement> {
}
declare const TableBodyCell: react.ForwardRefExoticComponent<TableBodyCellProps & react.RefAttributes<HTMLTableCellElement>>;

declare const TableHeaderContext: react.Context<{
    sticked: boolean;
}>;
interface TableHeaderProps extends HTMLAttributes<HTMLTableSectionElement> {
    stickyOffset?: number;
}
declare const TableHeader: react.ForwardRefExoticComponent<TableHeaderProps & react.RefAttributes<HTMLTableSectionElement>>;

interface TableHeaderCellProps extends HTMLAttributes<HTMLTableCellElement> {
    label?: ReactNode;
}
declare const TableHeaderCell: react.ForwardRefExoticComponent<TableHeaderCellProps & react.RefAttributes<HTMLTableCellElement>>;

interface TableBodyRowProps extends HTMLAttributes<HTMLTableRowElement> {
}
declare const TableBodyRow: react.ForwardRefExoticComponent<TableBodyRowProps & react.RefAttributes<HTMLTableRowElement>>;

interface TableHeaderRowProps extends HTMLAttributes<HTMLTableRowElement> {
}
declare const TableHeaderRow: react.ForwardRefExoticComponent<TableHeaderRowProps & react.RefAttributes<HTMLTableRowElement>>;

interface AutocompleteProps extends Omit<HTMLAttributes<HTMLLabelElement>, 'children' | keyof FormWidgetProps>, FormWidgetProps<unknown> {
    multiple?: boolean;
    placeholder?: string;
    initialQuery?: string;
    getOptions?: (query?: string) => unknown[] | Promise<unknown[]>;
    renderOption?: (v: unknown) => ReactNode;
    renderSelection?: (v: unknown) => ReactNode;
}
declare const Autocomplete: react.ForwardRefExoticComponent<AutocompleteProps & react.RefAttributes<HTMLLabelElement>>;

interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, keyof FormWidgetProps>, FormWidgetProps<boolean> {
    variant?: 'contained' | 'outlined';
}
declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;

interface ColorPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, keyof FormWidgetProps>, FormWidgetProps<string> {
    variant?: 'pure';
    startIcon?: ReactNode;
    endIcon?: ReactNode;
}
declare const ColorPicker: react.ForwardRefExoticComponent<ColorPickerProps & react.RefAttributes<HTMLInputElement>>;

interface DropMenuItemProps extends Omit<ButtonProps, 'value' | 'title' | 'index' | 'active'> {
    value: unknown;
    index?: number;
    active?: boolean;
    selected?: boolean;
    onClick?: () => void;
    size?: 'medium' | 'large';
}
declare const DropMenuItem: react.ForwardRefExoticComponent<DropMenuItemProps & react.RefAttributes<HTMLButtonElement>>;

declare const DropMenuContext: react.Context<{
    activeIndex: number | null;
    setActiveIndex: Dispatch<React.SetStateAction<number | null>>;
}>;
interface DropMenuProps extends DropRendererProps, BoxProps {
    children: ReactElement<DropMenuItemProps>[];
    selectedValues?: unknown[];
    onItemClick?: (value: unknown) => void;
    closeOnEscape?: boolean;
}
declare const DropMenu: react.ForwardRefExoticComponent<DropMenuProps & react.RefAttributes<HTMLDivElement>>;

interface FilePickerProps extends Omit<BoxProps, keyof FormWidgetProps>, FormWidgetProps<FileList | undefined> {
    accept?: string;
    multiple?: boolean;
    children?: ReactNode;
    buttonProps?: Omit<ButtonProps, 'children'>;
}
declare const FilePicker: react.ForwardRefExoticComponent<FilePickerProps & react.RefAttributes<HTMLDivElement>>;

interface FormFieldProps extends Omit<BoxProps, 'children'> {
    name: string;
    label?: string;
    description?: string;
    required?: boolean;
    children?: ReactElement<FormWidgetProps>;
}
declare const FormField: react.ForwardRefExoticComponent<FormFieldProps & react.RefAttributes<HTMLDivElement>>;
interface ControlledFormProps extends Omit<HTMLAttributes<HTMLFormElement>, 'onSubmit' | 'onChange'> {
    form: UseFormReturn;
    onSubmit?: SubmitHandler<any>;
}
declare const ControlledForm: react.ForwardRefExoticComponent<ControlledFormProps & react.RefAttributes<HTMLFormElement>>;
interface UncontrolledFormProps extends Omit<ControlledFormProps, 'form'> {
    options?: UseFormProps;
}
declare const UncontrolledForm: ({ options, ...rest }: UncontrolledFormProps) => jsx.JSX.Element;
type FormProps = ControlledFormProps | UncontrolledFormProps;
declare const Form: (props: FormProps) => jsx.JSX.Element;
interface FormGridProps extends BoxProps {
    columns?: GridAxisOptions;
}
declare const FormGrid: react.ForwardRefExoticComponent<FormGridProps & react.RefAttributes<HTMLDivElement>>;

declare const PasswordField: (props: FieldProps) => jsx.JSX.Element;

declare const ColorPickerField: (props: FieldProps) => jsx.JSX.Element;

interface AutocompleteFieldSource extends Pick<AutocompleteProps, 'getOptions' | 'renderOption' | 'renderSelection'> {
}
declare const AutocompleteField: (props: FieldProps) => jsx.JSX.Element;

declare const BadgesField: (props: FieldProps) => jsx.JSX.Element;
interface BadgeItemProps extends HTMLAttributes<HTMLDivElement> {
    colorMap?: {
        [key: string]: any;
    }[];
    maxLength?: number;
    onDelete?: (value: any) => void;
    value: any;
}
declare const BadgeItem: (props: BadgeItemProps) => jsx.JSX.Element;

declare const BaseInput: (props: FieldProps) => jsx.JSX.Element;

declare const CheckboxField: (props: FieldProps) => jsx.JSX.Element;

declare const FilePickerField: (props: FieldProps) => jsx.JSX.Element;

declare const GeoLocPickerField: (props: FieldProps) => jsx.JSX.Element;

declare const SelectField: (props: FieldProps) => jsx.JSX.Element;

declare const SliderField: (props: FieldProps) => jsx.JSX.Element;

declare const SwitchField: (props: FieldProps) => jsx.JSX.Element;

declare const TableField: (props: FieldProps) => jsx.JSX.Element;

declare const jsFormFields: {
    'file-picker': (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    'geo-loc-picker': (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    'text-area': (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    'color-picker': (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    autocomplete: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    badges: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    boolean: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    checkbox: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    integer: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    number: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    select: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    slider: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    string: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    switch: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    table: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
    password: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
};

declare const useJsFormDefaults: () => {
    registry: {
        fields: {
            'file-picker': (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            'geo-loc-picker': (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            'text-area': (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            'color-picker': (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            autocomplete: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            badges: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            boolean: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            checkbox: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            integer: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            number: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            select: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            slider: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            string: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            switch: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            table: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            password: (props: delta_jsf.FieldProps<any>) => _theme_ui_core.jsx.JSX.Element;
            array: typeof delta_jsf.ArrayField;
            domain: typeof delta_jsf.DomainField;
            hidden: (props: delta_jsf.FieldProps<any>) => null;
            null: (props: delta_jsf.FieldProps<any>) => null;
            object: typeof delta_jsf.ObjectField;
        };
        templates: {
            ArrayTemplate: (props: delta_jsf.TemplateProps) => _theme_ui_core.jsx.JSX.Element;
            ObjectTemplate: ({ children, schema: { title }, validity, required, }: delta_jsf.TemplateProps) => _theme_ui_core.jsx.JSX.Element;
            PrimitiveTemplate: ({ children, schema: { type, title, description, layout: { field } }, validity, required, }: delta_jsf.TemplateProps) => _theme_ui_core.jsx.JSX.Element;
            PanicTemplate: typeof delta_jsf.PanicTemplate;
        };
        utils: {
            validateAgainstSchema: (options: ValidateAgainstSchemaOptions) => delta_jsf.Validity;
        };
    };
};
declare const useJsFormManager: <T extends unknown, O extends FormManagerOptions<T> = FormManagerOptions<T>>(options: O) => O extends {
    initialValue: T;
} ? FormManager<T> : FormManager<T | undefined>;

declare const ArrayTemplate: (props: TemplateProps) => jsx.JSX.Element;

declare const ObjectTemplate: ({ children, schema: { title }, validity, required, }: TemplateProps) => jsx.JSX.Element;

declare const PrimitiveTemplate: ({ children, schema: { type, title, description, layout: { field } }, validity, required, }: TemplateProps) => jsx.JSX.Element;

declare const jsFormTemplates: {
    ArrayTemplate: (props: delta_jsf.TemplateProps) => _theme_ui_core.jsx.JSX.Element;
    ObjectTemplate: ({ children, schema: { title }, validity, required, }: delta_jsf.TemplateProps) => _theme_ui_core.jsx.JSX.Element;
    PrimitiveTemplate: ({ children, schema: { type, title, description, layout: { field } }, validity, required, }: delta_jsf.TemplateProps) => _theme_ui_core.jsx.JSX.Element;
};

declare const PasswordInput: (props: any) => jsx.JSX.Element;

interface RadioProps extends Omit<BoxProps, 'children' | keyof FormWidgetProps>, FormWidgetProps {
    children: ReactElement<RadioOptionProps>[];
    placeholder?: string;
    onChange?: (v: unknown) => void;
}
declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLDivElement>>;
interface RadioOptionProps extends Omit<BoxProps, 'value' | 'children'> {
    value: unknown;
    children: ReactNode;
    active?: boolean;
    disabled?: boolean;
}
declare const RadioOption: ({ value, children, active, disabled, ...rest }: RadioOptionProps) => jsx.JSX.Element;

interface SelectProps extends Omit<BoxProps, 'children' | keyof FormWidgetProps>, FormWidgetProps {
    children: (ReactElement<SelectOptionProps> | null | undefined | false)[];
    placeholder?: string;
}
declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLDivElement>>;
interface SelectOptionProps extends Omit<DropMenuItemProps, 'children'> {
    children: string;
}
declare const SelectOption: (props: SelectOptionProps) => jsx.JSX.Element;

interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, keyof FormWidgetProps>, FormWidgetProps<number> {
    min?: number;
    max?: number;
}
declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLInputElement>>;

interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, keyof FormWidgetProps>, FormWidgetProps<boolean> {
}
declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;

interface TextAreaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, keyof FormWidgetProps>, FormWidgetProps<string | undefined> {
}
declare const TextArea: react.ForwardRefExoticComponent<TextAreaProps & react.RefAttributes<HTMLTextAreaElement>>;

interface TextInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, keyof FormWidgetProps>, FormWidgetProps<string | number> {
    variant?: 'pure';
    startIcon?: ReactNode;
    endIcon?: ReactNode;
}
declare const TextInput: react.ForwardRefExoticComponent<TextInputProps & react.RefAttributes<HTMLInputElement>>;

interface ComplexSearchProposal {
    key: string;
    label: string;
    operators: ComplexSearchOperator[];
    getOptions?: (query?: string) => string[] | Promise<string[]>;
    getSelectionQuery?: (value: string) => string;
    renderSelection?: (value: string) => ReactNode;
    renderOption?: (option?: string) => ReactNode;
}
interface ComplexSearchOperator {
    key: string;
    label: string;
}
interface ComplexSearchSegment {
    key?: string;
    operator?: string;
    value?: string;
}

interface ComplexSearchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'children' | keyof FormWidgetProps>, FormWidgetProps<unknown> {
    value?: ComplexSearchSegment[];
    proposals: ComplexSearchProposal[];
}
declare const ComplexSearch: ({ value, proposals, onChange, disabled, ...inputPropos }: ComplexSearchProps) => jsx.JSX.Element;

interface BreadcrumbsProps extends BoxProps {
}
declare const Breadcrumbs: ({ children, ...rest }: BreadcrumbsProps) => jsx.JSX.Element;
interface BreadcrumbsItemProps extends Omit<AnchorProps, 'variant'> {
}
declare const BreadcrumbsItem: react.ForwardRefExoticComponent<BreadcrumbsItemProps & react.RefAttributes<HTMLAnchorElement>>;
declare const BreadcrumbsHome: react.ForwardRefExoticComponent<BreadcrumbsItemProps & react.RefAttributes<HTMLAnchorElement>>;

interface TabOptionProps extends Omit<AnchorProps, 'variant'> {
    id: string;
    variant?: 'bookmark' | 'chip' | 'underline';
    icon?: ComponentType<HTMLAttributes<Element>>;
}
declare const TabOption: react.ForwardRefExoticComponent<TabOptionProps & react.RefAttributes<HTMLAnchorElement>>;

interface TabGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'value' | 'children'> {
    activeId?: string;
    children: ReactElement<TabOptionProps> | ReactElement<TabOptionProps>[];
}
declare const TabGroup: FC<TabGroupProps>;

export { Account, AccountProps, Alert, AlertHolder, AlertHolderProps, AlertProps, Anchor, AnchorProps, ArrayTemplate, Autocomplete, AutocompleteField, AutocompleteFieldSource, AutocompleteProps, Badge, BadgeItem, BadgeItemProps, BadgeProps, BadgesField, BaseInput, BasicQuestion, BasicQuestionProps, Box, BoxProps, Breadcrumbs, BreadcrumbsHome, BreadcrumbsItem, BreadcrumbsItemProps, BreadcrumbsProps, Button, ButtonProps, Card, CardBody, CardBodyProps, CardFooter, CardFooterProps, CardHeader, CardHeaderProps, CardProps, Checkbox, CheckboxField, CheckboxProps, Chip, ChipProps, ColorPicker, ColorPickerField, ColorPickerProps, ComplexSearch, ComplexSearchOperator, ComplexSearchProposal, ComplexSearchProps, ComplexSearchSegment, ContainerProps, ControlledForm, ControlledFormProps, DeltaLogo, DeltaLogoProps, DeltaTheme, DialogOptions, DialogProps, DialogRenderFn, Drop, DropMenu, DropMenuContext, DropMenuItem, DropMenuItemProps, DropMenuProps, DropOption, DropOptionProps, DropOptions, DropProps, DropRenderer, DropRendererProps, EChart, EChartsReactProps, FilePicker, FilePickerField, FilePickerProps, Form, FormField, FormFieldProps, FormGrid, FormGridProps, FormProps, FormWidgetProps, ForwardRefCRF, GeoLocPickerField, GridAxisOptions, GridMeasurements, GridOptions, Heading, HeadingProps, ImperativePortal, Layout, LayoutMain, LayoutMainBody, LayoutMainBodyProps, LayoutMainFooter, LayoutMainFooterProps, LayoutMainHeader, LayoutMainHeaderProps, LayoutMainNavbar, LayoutMainNavbarProps, LayoutMainProps, LayoutNavigation, LayoutNavigationGroup, LayoutNavigationGroupProps, LayoutNavigationItem, LayoutNavigationItemProps, LayoutNavigationProps, LayoutProps, LayoutSidebar, LayoutSidebarBody, LayoutSidebarBodyProps, LayoutSidebarHeader, LayoutSidebarHeaderProps, LayoutSidebarProps, Loader, LoaderProps, Masonry, MasonryProps, Modal, ModalBody, ModalBodyProps, ModalFooter, ModalFooterProps, ModalHeader, ModalHeaderProps, ModalProps, NavigationContext, NavigationContextProps, Notification, NotificationOptions, NotificationPlacement, NotificationProps, ObjectTemplate, OperationOptions, Opts, PairList, PairListProps, PasswordField, PasswordInput, PortalledCRF, PortalledOptions, PortalledProps, PortalledTransitionCRF, PortalledTransitionOptions, PortalledTransitionProps, PrimitiveTemplate, Question, QuestionBody, QuestionBodyProps, QuestionDescription, QuestionFooter, QuestionFooterProps, QuestionHeader, QuestionHeaderProps, QuestionProps, QuestionRenderer, QuestionRendererProps, Radio, RadioOption, RadioOptionProps, RadioProps, Scroll, ScrollProps, Select, SelectField, SelectOption, SelectOptionProps, SelectProps, Skeleton, SkeletonProps, Slider, SliderField, SliderProps, Stack, Switch, SwitchField, SwitchProps, System, SystemContainer, SystemContext, TabGroup, TabGroupProps, TabOption, TabOptionProps, Table, TableBody, TableBodyCell, TableBodyCellProps, TableBodyProps, TableBodyRow, TableBodyRowProps, TableField, TableHeader, TableHeaderCell, TableHeaderCellProps, TableHeaderContext, TableHeaderProps, TableHeaderRow, TableHeaderRowProps, TableProps, TextArea, TextAreaProps, TextInput, TextInputProps, Tooltip, TooltipProps, TransitionCRF, TransitionOptions, TransitionProps, UncontrolledForm, UncontrolledFormProps, deltaLightTheme, deltaTheme, jsFormFields, jsFormTemplates, layoutMainNavbarHeight, layoutMainNoise, loaderRegistry, system, useCleanableRef, useClickOutside, useDataStack, useDebounce, useDeltaTheme, useDialog, useDrop, useEChartDefalults, useForwardRef, useGeoLocDescription, useGrid, useImperativePortal, useIsomorphicLayoutEffect, useJsFormDefaults, useJsFormManager, useLeafletDefaults, useLoader, useModal, useNotification, useOperation, usePortalled, usePortalledTransition, useQuestion, useSticked, useThrottledCallback, useTransition, useUpdateEffect };
