## API Report File for "@strata/tempo"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { CheckboxChangeEvent } from 'antd/lib/checkbox/Checkbox';
import { CheckboxOptionType } from 'antd/lib/checkbox/Group';
import { ColumnProps } from 'primereact/column';
import { CustomIconComponentProps } from '@ant-design/icons/lib/components/Icon';
import { DataTable } from 'primereact/datatable';
import { DataTableProps } from 'primereact/datatable';
import { DateTimeFormat } from '@strata/intl/lib';
import * as dayjs from 'dayjs';
import { FormInstance } from 'antd/lib/form/Form';
import { FormListFieldData } from 'antd/lib/form/FormList';
import { FormListOperation } from 'antd/lib/form/FormList';
import { IFormatNumberOptions } from '@strata/intl/lib';
import { IntRange } from 'rc-picker/lib/interface';
import { Key } from 'rc-tree/lib/interface';
import { Location as Location_2 } from 'history';
import { MouseEventHandler } from 'react';
import { NumberFormat } from '@strata/intl/lib';
import { RadioChangeEvent } from 'antd/lib/radio/interface';
import { RangeValueType } from 'rc-picker/lib/PickerInput/RangePicker';
import * as React_2 from 'react';
import { default as React_3 } from 'react';
import { Rule } from 'rc-field-form/lib/interface';
import { RuleItem } from 'async-validator';
import { RuleObject } from 'rc-field-form/lib/interface';
import { TreeTable } from 'primereact/treetable';
import { TreeTableProps } from 'primereact/treetable';
import { UploadChangeParam } from 'antd/lib/upload/interface';
import { useForm } from 'antd/lib/form/Form';
import { useWatch } from 'antd/lib/form/Form';
import { ValidateOption } from 'async-validator';
import { ValidatorRule } from 'rc-field-form/lib/interface';

// @beta
export const Accordion: React_2.FC<IAccordionProps>;

// @beta
export const ActionBar: React_2.FC<IActionBarProps>;

// @public
export const Banner: React_2.FC<IBannerProps>;

// @public
export const Button: React_2.FC<IButtonProps>;

// @beta
export const ButtonMenu: React_2.FC<IButtonMenuProps>;

// @public (undocumented)
export type ButtonType = "primary" | "secondary" | "tertiary" | "link";

// @public
export const Card: React_2.FC<ICardProps>;

// @beta
export const Cascader: React_2.FC<ICascaderProps>;

// @public
export const Checkbox: React_2.FC<ICheckboxProps>;

export { CheckboxChangeEvent }

// @public
export const CheckboxGroup: React_2.FC<ICheckboxGroupProps>;

// @beta
export const Chip: React_2.FC<IChipProps>;

// @beta
export const Chips: React_2.FC<IChipsProps>;

// @beta
export const ColorPicker: React_2.FC<IColorPickerProps>;

export { ColumnProps }

// @public (undocumented)
export const CustomIcon: React_2.FC<ICustomIconProps>;

// @beta (undocumented)
export const DataCell: React_2.FC<IDataCellProps>;

// @beta (undocumented)
export const DataColumn: React_2.FC<IDataColumnProps> & IColumn;

// Warning: (ae-forgotten-export) The symbol "IDataGridState" needs to be exported by the entry point index.d.ts
//
// @beta
export class DataGrid extends React_2.Component<IDataGridProps, IDataGridState> {
    constructor(props: IDataGridProps);
    // (undocumented)
    calculateBodyOffsetTop(): void;
    // (undocumented)
    static CheckboxColumn: React_2.FC<import("../datacolumn").ICheckboxColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    cleanInvalidCells(): void;
    // (undocumented)
    clearInvalidCells(): void;
    // (undocumented)
    static Column: React_2.FC<import("../datacolumn").IDataColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IDataGridProps): void;
    // (undocumented)
    static DateColumn: React_2.FC<IDateColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static DefaultProps: IDataGridProps;
    // (undocumented)
    static DragDropColumn: React_2.FC<import("../datacolumn").IDragDropColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static DropDownColumn: React_2.FC<IDropDownColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static EmptyColumn: React_2.FC<import("../datacolumn").IEmptyColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static ExpandColumn: React_2.FC<import("../datacolumn").IExpandColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    exportCSV(): void;
    // (undocumented)
    static GapColumn: React_2.FC<import("../datacolumn").IGapColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    grid: React_2.RefObject<DataTable>;
    // (undocumented)
    mergeProps(validChildren: any[]): DataTableProps;
    // (undocumented)
    static NumberColumn: React_2.FC<import("../datacolumn").INumberColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    onCellClick(cellArgs: ICellClickArgs): void;
    // (undocumented)
    onCellEditChange(editArgs: ICellEditorArgs, newCellValue: any): Promise<void>;
    // (undocumented)
    onCellExport(e: {
        data: any;
        field: string;
    }): any;
    // (undocumented)
    onCellValidate(cellArgs: ICellEditorArgs, rules: RuleItem[]): void;
    // (undocumented)
    onDataChange(values: []): void;
    // (undocumented)
    onRowClassName(rowData: any): any;
    // (undocumented)
    refreshGrid(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    static RowClass: {
        Highlight: string;
        ParentRow: string;
        ChildRow: string;
        Disabled: string;
        Bold: string;
        Borderless: string;
    };
    // (undocumented)
    static RowNumber: React_2.FC<import("../datacolumn").IRowNumberColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static SelectionColumn: React_2.FC<import("../datacolumn").ISelectionColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static TextAreaColumn: React_2.FC<import("../datacolumn").ITextAreaColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    transformChildren(): React_2.ReactElement[];
    // (undocumented)
    validateGrid(): Promise<IInvalidCell[]>;
    // (undocumented)
    validateGridAndNotify(): void;
}

// @beta (undocumented)
export const DataHeaderCell: React_2.FC<IDataHeaderCellProps>;

// @beta (undocumented)
export const DataHeaderGroup: React_2.FC<IDataHeaderGroupProps>;

// @beta (undocumented)
export const DataHeaderRow: React_2.FC<IDataHeaderRowProps>;

// @public (undocumented)
export const DataRowClass: {
    Highlight: string;
    ParentRow: string;
    ChildRow: string;
    Disabled: string;
    Bold: string;
    Borderless: string;
};

// @beta
export const DatePicker: React_2.FC<IDatePickerProps> & {
    MonthPicker: React_2.FC<IMonthPickerProps>;
} & {
    RangePicker: React_2.FC<IRangePickerProps>;
} & {
    YearPicker: React_2.FC<IYearPickerProps>;
} & {
    TimePicker: React_2.FC<ITimePickerProps>;
};

// @public
export const Divider: React_2.FC<IDividerProps>;

// @beta
export const Drawer: React_2.FC<IDrawerProps>;

// @public
export const DropDown: React_2.FC<IDropDownProps> & {
    Item: React_2.FC<IDropDownItemProps>;
    ItemGroup: React_2.FC<IDropDownItemGroupProps>;
};

// @public (undocumented)
export type DropDownValue = string | string[] | number | number[];

// @beta
export const Empty: React_2.FC<IEmptyProps>;

// @public (undocumented)
const Error_2: (props: IErrorProps) => React_3.JSX.Element;

export { Error_2 as Error }

// Warning: (ae-forgotten-export) The symbol "IErrorBoundaryState" needs to be exported by the entry point index.d.ts
//
// @beta (undocumented)
export class ErrorBoundary extends React_2.Component<IErrorBoundaryProps, IErrorBoundaryState> {
    constructor(props: IErrorBoundaryProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static getDerivedStateFromError(error: any): {
        errorType: string;
        error: any;
        hasReactError: boolean;
    };
    // (undocumented)
    handleError(errorType: ErrorType, error: any): true | undefined;
    // (undocumented)
    handleGenericError(event: Event | string, source?: string, lineno?: number, colno?: number, error?: Error): boolean;
    // (undocumented)
    handlePromiseError(ev: PromiseRejectionEvent): boolean;
    // (undocumented)
    render(): React_2.ReactNode;
}

// @public (undocumented)
export class ErrorBoundaryEvent {
    constructor(source: ErrorType, error: any);
    // (undocumented)
    error: any;
    // (undocumented)
    isPreventDefault: boolean;
    // (undocumented)
    preventDefault(): void;
    // (undocumented)
    source: ErrorType;
}

// @public (undocumented)
export type ErrorType = 'promise' | 'generic' | 'none';

// @beta
export const FixedActionBar: React_2.FC<IFixedActionBarProps>;

// @beta
export const Form: React_2.FC<IFormProps & React_2.RefAttributes<FormInstance>> & {
    Item: React_2.FC<IFormItemProps>;
    List: React_2.FC<IFormListProps>;
    ItemSpacing: React_2.FC<IFormItemSpacingProps>;
    useForm: typeof useForm;
    useWatch: typeof useWatch;
};

export { FormInstance }

// @beta (undocumented)
export const FormItem: React_2.FC<IFormItemProps>;

export { FormListFieldData }

export { FormListOperation }

// @beta
export const Header: React_2.FC<IHeaderProps>;

// @beta (undocumented)
export const Heading: React_2.FC<IHeadingProps>;

// @public (undocumented)
export interface IAccordionItem {
    children?: React_2.ReactNode;
    collapsible?: 'header' | 'icon' | 'disabled';
    extra?: React_2.ReactNode;
    forceRender?: boolean;
    icon?: React_2.ReactElement<IIconProps>;
    key: React_2.Key;
    label: React_2.ReactNode;
    removeBodyPadding?: boolean;
    showArrow?: boolean;
}

// @public (undocumented)
export interface IAccordionProps {
    activeKey?: React_2.Key | React_2.Key[];
    collapse?: boolean;
    defaultActiveKey?: React_2.Key | React_2.Key[];
    destroyInactivePanel?: boolean;
    items?: IAccordionItem[];
    onChange?: (key: string | string[]) => void;
}

// @public (undocumented)
export interface IActionBarProps {
    actions?: React_2.ReactNode;
    filters?: React_2.ReactNode;
    paddingLeftRight?: 0 | 8 | 12 | 16 | 24 | 32 | 40 | 48;
    style?: React_2.CSSProperties;
    viewToggle?: React_2.ReactNode;
}

// @public (undocumented)
export interface IAlertProps {
    alertType?: "info" | "success" | "error" | "attention";
    content?: React_3.ReactNode;
    onClose?: (e: React_3.MouseEvent<HTMLElement>) => void;
    title: React_3.ReactNode | string;
}

// @public (undocumented)
export interface IBannerProps {
    extra?: React_2.ReactNode;
    icon?: React_2.ReactElement<IIconProps>;
    size?: "normal" | "small";
    type?: "info" | "error" | "success" | "attention";
}

// @public (undocumented)
export interface IBaseColumnProps {
    align?: "left" | "center" | "right";
    body?: (rowData: any, column: any) => any;
    bodyStyle?: React.CSSProperties;
    className?: string;
    customCellValue?: (cellArgs: ICellArgs) => any;
    editable?: boolean;
    editor?: (cellEditorArgs: ICellEditorArgs) => JSX.Element | undefined;
    expander?: boolean;
    field?: string;
    filter?: boolean;
    filterElement?: object;
    filterFunction?: (cellValue: any, filterValue: any) => boolean;
    filterMatchMode?: "endsWith" | "startsWith" | "custom" | "lt" | "contains" | "equals" | "notEquals" | "in" | "lte" | "gt" | "gte";
    filterMaxLength?: number;
    filterPlaceholder?: string;
    filterType?: string;
    frozen?: boolean;
    header?: any;
    headerStyle?: React.CSSProperties;
    hidden?: boolean;
    isCellClickable?: (cellEditorArgs: ICellArgs) => boolean;
    isCellEditable?: (cellEditorArgs: ICellArgs) => boolean;
    sortable?: boolean;
    sortField?: string;
    style?: React.CSSProperties;
    validationRules?: RuleItem[];
    width: number;
}

// @public (undocumented)
export interface IButtonMenuClickEvent {
    domEvent: React_2.MouseEvent<HTMLElement> | React_2.KeyboardEvent<HTMLElement>;
    item: React_2.ReactInstance;
    key: React_2.Key;
    keyPath: React_2.Key[];
}

// @public (undocumented)
export interface IButtonMenuProps {
    buttonStyle?: React_2.CSSProperties;
    buttonText?: React_2.ReactNode;
    disabled?: boolean;
    icon?: React_2.ReactElement<IIconProps>;
    items?: IMenuItem[];
    onClick?: (e: IButtonMenuClickEvent) => void;
    onOpenChange?: (open: boolean) => void;
    placement?: "topLeft" | "topCenter" | "topRight" | "bottomLeft" | "bottomCenter" | "bottomRight";
    selectedKeys?: Array<string>;
    stayOpen?: boolean;
    tooltip?: string;
    tooltipPlacement?: 'top' | 'left' | 'right';
    type?: ButtonType;
}

// @public (undocumented)
export interface IButtonProps {
    block?: boolean;
    className?: string;
    danger?: boolean;
    disabled?: boolean;
    disableLogging?: boolean;
    htmlType?: "submit" | "button";
    icon?: React_2.ReactElement<IIconProps>;
    logData?: object;
    onClick?: React_2.MouseEventHandler<HTMLElement>;
    style?: React_2.CSSProperties;
    type?: ButtonType;
}

// @public (undocumented)
export interface ICardProps {
    description?: string;
    extra?: React_2.ReactNode;
    footer?: React_2.ReactNode;
    height?: number | string;
    href?: string;
    icon?: React_2.ReactElement<IIconProps>;
    image?: string;
    loading?: boolean;
    onClick?: () => void;
    removeBodyPadding?: boolean;
    selected?: boolean;
    title?: React_2.ReactNode;
    type?: "normal" | "success" | "error" | "attention";
}

// @public (undocumented)
export interface ICascaderOption {
    children?: ICascaderOption[];
    disabled?: boolean;
    label?: React_2.ReactNode;
    value?: string | number | null;
}

// @public (undocumented)
export interface ICascaderProps {
    allowClear?: boolean;
    autoFocus?: boolean;
    changeOnSelect?: boolean;
    defaultValue?: (string | number)[];
    disabled?: boolean;
    onChange?: (value: (string | number | null)[], selectOptions: ICascaderOption[]) => void;
    onOpenChange?: (visible: boolean) => void;
    onSearch?: (value: string) => void;
    open?: boolean;
    options?: ICascaderOption[];
    placeholder?: string;
    placement?: "bottomLeft" | "bottomRight" | "topLeft" | "topRight";
    showSearch?: boolean;
    status?: 'error';
    value?: string[] | number[];
}

// @public (undocumented)
export interface ICellArgs {
    cellKey: string;
    field: string;
    gridData?: any[];
    row: any;
    rowData: any;
    rowIndex?: number;
    rowKey: string;
}

// @public (undocumented)
export interface ICellClickArgs extends ICellArgs {
    isEditable: boolean;
}

// @public (undocumented)
export interface ICellEditorArgs extends ICellArgs {
}

// @public (undocumented)
export interface ICheckboxGroupProps {
    children?: React_2.ReactNode;
    // Warning: (ae-forgotten-export) The symbol "CheckboxValueType" needs to be exported by the entry point index.d.ts
    defaultValue?: Array<CheckboxValueType>;
    disabled?: boolean;
    onChange?: (checkedValue: Array<CheckboxValueType>) => void;
    options?: Array<CheckboxOptionType | string>;
    value?: Array<CheckboxValueType>;
    vertical?: boolean;
}

// @public (undocumented)
export interface ICheckboxProps {
    autoFocus?: boolean;
    checked?: boolean;
    defaultChecked?: boolean;
    disabled?: boolean;
    disableLogging?: boolean;
    id?: string;
    indeterminate?: boolean;
    logData?: object;
    name?: string;
    onChange?: (e: CheckboxChangeEvent) => void;
}

// @public (undocumented)
export interface IChip {
    id: React_2.Key;
    name: string;
    tooltip?: string | React_2.ReactNode;
}

// @public (undocumented)
export interface IChipProps {
    active?: boolean;
    disabled?: boolean;
    id: React_2.Key;
    name: string | React_2.ReactNode;
    onClick?: (chipId: React_2.Key) => void;
    onDelete?: (chipId: React_2.Key) => void;
    style?: React_2.CSSProperties;
    tooltip?: string | React_2.ReactNode;
}

// @public (undocumented)
export interface IChipsProps {
    children?: React_2.ReactNode;
    disableLogging?: boolean;
    items?: IChip[];
    logData?: object;
    onDelete: (chip: IChip) => void;
}

// @public (undocumented)
export interface IColorPickerProps {
    allowClear?: boolean;
    defaultValue?: string;
    disabled?: boolean;
    onChange?: (hex: string) => void;
    onClear?: () => void;
    onOpenChange?: (open: boolean) => void;
    open?: boolean;
    placement?: 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight';
    presets?: IColorsPreset[];
    trigger?: 'click' | 'hover';
    value?: string;
}

// @public (undocumented)
export interface IColorsPreset {
    // (undocumented)
    colors: string[];
    // (undocumented)
    label: React_2.ReactNode;
}

// @public (undocumented)
export interface IColumn {
    // (undocumented)
    className: string;
    // (undocumented)
    getColumnProps: (args: IGetColumnPropsArgs) => ColumnProps;
}

// @public (undocumented)
export interface IConfirmProps {
    cancelButtonProps?: IButtonProps;
    cancelText?: React_3.ReactNode;
    confirmType?: "normal" | "danger" | "attention";
    content?: React_3.ReactNode;
    okText?: React_3.ReactNode;
    onCancel?: (e: React_3.MouseEvent<HTMLElement>) => void;
    onOk?: (e: React_3.MouseEvent<HTMLElement>) => void;
    title: React_3.ReactNode | string;
}

// @public (undocumented)
export interface ICustomIconProps extends IIconProps {
    component?: React_2.ComponentType<CustomIconComponentProps | React_2.SVGProps<SVGSVGElement>>;
}

// @public (undocumented)
export interface IDataCellProps {
    className?: string;
    editable?: boolean;
    isSelected?: boolean;
    onClick?: MouseEventHandler<HTMLDivElement>;
    validationMessages?: string[];
}

// @public (undocumented)
export interface IDataColumnProps extends IBaseColumnProps {
    collapseLongText?: boolean;
}

// @public (undocumented)
export interface IDataGridBaseProps {
    border?: string | string[];
    children?: React_2.ReactElement[] | React_2.ReactElement;
    className?: string;
    columnHeaderGroup?: React_2.ReactElement;
    defaultSortOrder?: number;
    density?: "normal" | "dense" | "minimal";
    disableLogging?: boolean;
    emptyMessage?: React_2.ReactNode;
    filters?: any;
    first?: number;
    frozenColumnHeaderGroup?: React_2.ReactElement;
    getRowClassName?: (data: any) => object;
    globalFilterValue?: IGlobalFilterValue;
    id?: string;
    itemName?: string;
    lazy?: boolean;
    loading?: boolean;
    logData?: object;
    onCellClick?: (args: ICellClickArgs) => void;
    onCellEdit?: (cellEditArgs: ICellEditorArgs, newCellValue: any, oldCellValue: any) => void;
    onFilter?: (e: IDataGridFilterEvent) => void;
    onPage?: (e: IDataGridPageEvent) => void;
    onSort?: (e: IDataGridSortEvent) => void;
    onValidationChange?: (invalidCells: IInvalidCell[]) => void;
    paginator?: boolean;
    paginatorRight?: React_2.ReactNode;
    resizableColumns?: boolean;
    rows?: number;
    scrollable?: boolean;
    scrollableOffset?: number;
    scrollHeight?: string;
    selectedCellKey?: string;
    sortField?: string;
    sortMode?: string;
    sortOrder?: number;
    totalRecords?: number;
    totalRowCalculations?: ITotalRowCalculation[];
    totalRowCellsMetaData?: IDataGridTotalCellMetaData[];
    totalRowData?: object;
    totalRowHref?: string;
    totalRowLabel?: string;
    totalRowOnClick?: React_2.MouseEventHandler<HTMLElement>;
    truncateColumnHeaders?: boolean;
    validationMode?: 'single-cell' | 'all-cells' | 'manual';
    value?: any[];
}

// @public (undocumented)
export interface IDataGridFilterEvent {
    filters: any;
}

// @public (undocumented)
export interface IDataGridPageEvent {
    first: number;
}

// @public (undocumented)
export interface IDataGridProps extends IDataGridBaseProps {
    dataKey?: string;
    expandedRowKeys?: any[];
    exportFilename?: string;
    hideSelectAll?: boolean;
    onDataChange?: (data: any) => void;
    onRowReorder?(e: {
        originalEvent: Event;
        value: any;
        dragIndex: number;
        dropIndex: number;
    }): void;
    onSelectionChange?: (e: IDataGridSelectionEvent) => void;
    rowExpansionTemplate?: (rowData: any) => any;
    selection?: any;
    showRowReorderElement?: (row: any) => boolean;
    showSelectionElement?: (row: any) => boolean;
}

// @public (undocumented)
export interface IDataGridSelectionEvent {
    originalEvent: Event;
    value: any;
}

// @public (undocumented)
export interface IDataGridSortEvent {
    sortField: string;
    sortOrder: number;
}

// @public (undocumented)
export interface IDataGridTotalCellMetaData {
    field: string;
    textColor?: "error" | "success";
}

// @public (undocumented)
export interface IDataHeaderCellProps extends Partial<IBaseColumnProps> {
    colSpan?: number;
    expanded?: boolean;
    isExpandable?: boolean;
    isGap?: boolean;
    onExpand?: (expanded: boolean) => void;
    rowSpan?: number;
}

// @public (undocumented)
export interface IDataHeaderGroupProps {
    children?: React_2.ReactElement | React_2.ReactElement[];
}

// @public (undocumented)
export interface IDataHeaderRowProps {
    children?: React_2.ReactElement | React_2.ReactElement[];
}

// @public (undocumented)
export interface IDateColumnProps extends IBaseColumnProps {
    format?: DateTimeFormat;
    inputProps?: IDatePickerProps;
}

// @public (undocumented)
export interface IDatePickerProps {
    allowClear?: boolean;
    autoFocus?: boolean;
    bordered?: boolean;
    defaultPickerValue?: dayjs.Dayjs;
    defaultValue?: dayjs.Dayjs;
    disabled?: boolean;
    disabledDate?: (current: dayjs.Dayjs | null) => boolean;
    format?: "L" | "ll";
    onChange?: (date: dayjs.Dayjs | null, dateString: string | string[]) => void;
    onFocus?: React_2.FocusEventHandler<HTMLInputElement>;
    placeholder?: string;
    showToday?: boolean;
    size?: "dense" | "normal" | "large";
    value?: dayjs.Dayjs;
    width?: number | string;
}

// @public (undocumented)
export interface IDividerProps {
    extended?: boolean;
    margin?: 0 | 8 | 16 | 24 | 32;
    type?: "line" | "dot";
    vertical?: boolean;
}

// @public (undocumented)
export interface IDragDropColumnProps {
    frozen?: boolean;
}

// @public (undocumented)
export interface IDrawerProps {
    closable?: boolean;
    destroyOnClose?: boolean;
    footer?: React_2.ReactNode;
    getContainer?: string | HTMLElement | false;
    loading?: boolean;
    mask?: boolean;
    onClose?: (e: React_2.MouseEvent | React_2.KeyboardEvent) => void;
    placement?: "left" | "right";
    removeBodyPadding?: boolean;
    removeHeaderPadding?: boolean;
    title?: React_2.ReactNode;
    type?: "success" | "error" | "attention";
    visible?: boolean;
    width?: number | string;
}

// @public (undocumented)
export interface IDropDownColumnProps extends IBaseColumnProps {
    inputProps?: IDropDownProps;
    items?: any[];
    itemTextField?: string;
    itemValueField?: string;
}

// @public (undocumented)
export interface IDropDownItemGroupProps {
    // (undocumented)
    label?: React_2.ReactNode;
}

// @public (undocumented)
export interface IDropDownItemProps {
    disabled?: boolean;
    hierarchy?: "parent" | "child";
    value?: string | number;
}

// @public (undocumented)
export interface IDropDownProps {
    allowClear?: boolean;
    autoFocus?: boolean;
    defaultValue?: DropDownValue;
    disabled?: boolean;
    disableLogging?: boolean;
    extra?: React_2.ReactNode;
    itemGroupField?: string;
    items?: any[];
    itemTextField?: string;
    itemValueField?: string;
    logData?: object;
    maxTagCount?: number | 'responsive';
    maxTagPlaceholder?: React_2.ReactNode | ((omittedValues: any[]) => React_2.ReactNode);
    maxTagTextLength?: number;
    multiSelect?: boolean;
    notFoundContent?: string;
    onChange?: (value: DropDownValue, option: any) => void;
    onDropdownVisibleChange?: (open: boolean) => void;
    onSearch?: (value: string) => void;
    placeholder?: string | React_2.ReactNode;
    selectAllText?: string;
    selectAllValue?: string | number;
    selectedText?: string;
    showSearch?: boolean;
    size?: "dense" | "normal";
    tokenSeparators?: string[];
    useTags?: boolean;
    value?: DropDownValue;
    width?: number | string;
    wrap?: boolean;
}

// @public (undocumented)
export interface IEmptyProps {
    actions?: React_2.ReactNode;
    description?: React_2.ReactNode;
    icon?: React_2.ReactElement<IIconProps>;
    style?: React_2.CSSProperties;
    title?: string | React_2.ReactNode;
}

// @public (undocumented)
export interface IErrorBoundaryProps {
    disableGlobalJavascriptErrorHandling?: boolean;
    onError?: (evt: ErrorBoundaryEvent) => void;
    show403ErrorInModal?: boolean;
    show404ErrorInModal?: boolean;
}

// @public (undocumented)
export interface IErrorProps {
    // (undocumented)
    message?: string;
    // (undocumented)
    title?: string;
}

// @public (undocumented)
export interface IFixedActionBarProps {
    height?: number;
    leftContent?: React_2.ReactNode;
    loading?: boolean;
    rightContent?: React_2.ReactNode;
    visible?: boolean;
}

// @public (undocumented)
export interface IFormItemProps {
    children?: React_2.ReactNode | (() => React_2.ReactNode);
    extra?: string | React_2.ReactNode;
    help?: React_2.ReactNode;
    htmlFor?: string;
    initialValue?: any;
    itemAlign?: "left" | "right";
    label?: string | React_2.ReactNode;
    labelCol?: {};
    name?: string | number | (string | number)[];
    noStyle?: boolean;
    rules?: Rule[];
    shouldUpdate?: boolean | ((previousFormValues: any, currentFormValues: any) => boolean);
    style?: React_2.CSSProperties;
    validateStatus?: "success" | "warning" | "error" | "validating" | "";
    validateTrigger?: string | string[] | false;
    valuePropName?: string;
    wrapperCol?: {};
}

// @public (undocumented)
export interface IFormProps {
    className?: string;
    form?: FormInstance;
    height?: number;
    hideOptionalLabels?: boolean;
    initialValues?: any;
    labelCol?: {};
    layout?: "horizontal" | "vertical";
    maxWidth?: number | string;
    onFinish?: (values: {
        [name: string]: any;
    }) => void;
    onFinishFailed?: (errorInfo: {
        values: {
            [name: string]: any;
        };
        errorFields: {
            name: React_2.ReactText[];
            errors: string[];
        }[];
        outOfDate: boolean;
    }) => void;
    onValuesChange?: (changedValues: {
        [name: string]: any;
    }, values: {
        [name: string]: any;
    }) => void;
    preserve?: boolean;
    style?: React_2.CSSProperties;
    wrapperCol?: {};
}

// @public (undocumented)
export interface IGetColumnPropsArgs {
    // (undocumented)
    dataCellClassName?: string;
    // (undocumented)
    invalidCells?: IInvalidCell[];
    // (undocumented)
    onCellClick: (args: ICellClickArgs) => void;
    // (undocumented)
    onCellEditChange: (args: ICellEditorArgs, newCellValue: any) => void;
    // (undocumented)
    onCellValidate: (args: ICellEditorArgs, rules: RuleItem[]) => void;
    // (undocumented)
    props: any;
    // (undocumented)
    rowDataKeyField: string;
    // (undocumented)
    rowIndexOffset: number;
    // (undocumented)
    selectedCellKey?: string;
    // (undocumented)
    validationMode: 'single-cell' | 'entire-grid' | 'manual';
}

// @public (undocumented)
export interface IGlobalFilterValue {
    fields: string[];
    value: string;
}

// @public (undocumented)
export interface IHeaderProps {
    breadcrumbHref?: string;
    breadcrumbOnClick?: React_2.MouseEventHandler<HTMLElement>;
    breadcrumbText?: string;
    extra?: React_2.ReactNode;
    subtitle?: React_2.ReactNode;
    title: string | React_2.ReactNode;
    titleHeadingLevel?: 1 | 2;
}

// @public (undocumented)
export interface IHeadingProps {
    color?: "black" | "secondary" | "white";
    ellipsis?: boolean | {
        rows?: number;
        expandable?: boolean;
    };
    level?: 1 | 2 | 3 | 4;
    marginBottom?: 0 | 4 | 8 | 16;
    strong?: boolean;
}

// @public (undocumented)
export interface IIconProps {
    className?: string;
    color?: "black" | "secondary" | "white" | "blue-500" | "blue-700" | "success" | "error" | "attention" | "attention-700";
    size?: 14 | 20 | 24 | 32 | 48;
    style?: React.CSSProperties;
}

// @public (undocumented)
export interface IImageProps {
    alt?: string;
    backgroundColor?: string;
    border?: string | string[];
    height: number | string;
    lightbox?: boolean | {
        src: string;
    };
    link?: string;
    newTab?: boolean;
    src: string;
    width?: number | string;
}

// @public (undocumented)
export interface IInputNumberProps {
    autoFocus?: boolean;
    defaultValue?: number;
    disabled?: boolean;
    format?: "currency" | "percent" | "number";
    id?: string;
    name?: string;
    onChange?: (value: number | string | undefined | null) => void;
    onFocus?: React_2.FocusEventHandler<HTMLInputElement>;
    onPressEnter?: React_2.KeyboardEventHandler<HTMLInputElement>;
    placeholder?: string;
    precision?: number;
    required?: boolean;
    size?: "dense" | "normal";
    value?: number;
    width?: number | string;
}

// @public (undocumented)
export interface IInputProps {
    autoFocus?: boolean;
    debounce?: boolean;
    defaultValue?: string;
    disabled?: boolean;
    id?: string;
    maxLength?: number;
    name?: string;
    numbersOnly?: boolean;
    onChange?: React_2.ChangeEventHandler<HTMLInputElement>;
    onFocus?: React_2.FocusEventHandler<HTMLInputElement>;
    onPaste?: React_2.ClipboardEventHandler<HTMLInputElement>;
    onPressEnter?: React_2.KeyboardEventHandler<HTMLInputElement>;
    placeholder?: string;
    readOnly?: boolean;
    required?: boolean;
    search?: boolean;
    size?: "dense" | "normal";
    type?: string;
    value?: string;
    width?: number | string;
}

// @public (undocumented)
export interface IInputTextAreaProps extends React_2.TextareaHTMLAttributes<HTMLTextAreaElement> {
    autoFocus?: boolean;
    autoSize?: boolean | {
        minRows: number;
        maxRows: number;
    };
    defaultValue?: string;
    disabled?: boolean;
    id?: string;
    maxLength?: number;
    name?: string;
    onChange?: React_2.ChangeEventHandler<HTMLTextAreaElement>;
    onPressEnter?: React_2.KeyboardEventHandler<HTMLTextAreaElement>;
    placeholder?: string;
    readOnly?: boolean;
    required?: boolean;
    rows?: number;
    value?: string;
    width?: number | string;
}

// @public (undocumented)
export interface IInvalidCell {
    // (undocumented)
    cellKey: string;
    // (undocumented)
    field: string;
    // (undocumented)
    rowKey: string;
    // (undocumented)
    validationMessages: string[];
    // (undocumented)
    value: any;
}

// @public (undocumented)
export interface ILayoutColumnProps {
    span?: number;
    spanLarge?: number;
    spanMedium?: number;
    spanSmall?: number;
    spanXSmall?: number;
}

// @public (undocumented)
export interface ILayoutGridProps {
    children?: React_2.ReactElement<ILayoutRowProps>[] | React_2.ReactElement<ILayoutRowProps>;
    fullWidth?: boolean;
    loading?: boolean;
    removeMargin?: boolean;
}

// @public (undocumented)
export interface ILayoutProps {
    children?: React_2.ReactNode | undefined;
}

// @public (undocumented)
export interface ILayoutRowProps {
    children?: React_2.ReactElement<ILayoutColumnProps>[] | React_2.ReactElement<ILayoutColumnProps>;
    stretchContent?: boolean;
}

// @public (undocumented)
export interface ILayoutSiderProps {
    collapsible?: boolean;
    style?: React_2.CSSProperties;
    width?: string | number;
}

// @public (undocumented)
export interface ILinkProps {
    breadcrumb?: boolean;
    className?: string;
    disabled?: boolean;
    disableLogging?: boolean;
    href: string;
    icon?: React_2.ReactElement<IIconProps>;
    logData?: object;
    newTab?: boolean;
}

// @public (undocumented)
export interface IListItemMetaProps {
    description?: React_2.ReactNode;
    title: React_2.ReactNode;
}

// @public (undocumented)
export interface IListItemProps {
    actions?: React_2.ReactNode[];
}

// @public (undocumented)
export interface IListProps<T> {
    addItemText?: string;
    dataSource: T[];
    emptyText?: React_2.ReactNode;
    header?: React_2.ReactNode;
    height?: number;
    loading?: boolean;
    onAddItem?: () => void;
    renderItem: (item: T, index: number) => React_2.ReactNode;
}

// @beta
const Image_2: React_2.FC<IImageProps>;

export { Image_2 as Image }

// @public (undocumented)
export interface IMenuItem {
    children?: IMenuItem[];
    disabled?: boolean;
    hidden?: boolean;
    href?: string;
    icon?: React_2.ReactElement<IIconProps>;
    key: React_2.Key;
    label?: React_2.ReactNode;
    onClick?: () => void;
    type?: 'group' | 'divider';
}

// @public (undocumented)
export interface IMenuProps {
    defaultOpenKeys?: string[];
    expandableGroups?: boolean;
    items?: IMenuItem[];
    mode?: 'vertical' | 'horizontal' | 'inline';
    onClick?: (e: {
        key: React_2.Key;
        keyPath: React_2.Key[];
        item: React_2.ReactInstance;
        domEvent: React_2.MouseEvent<HTMLElement> | React_2.KeyboardEvent<HTMLElement>;
    }) => void;
    onOpenChange?: (keys: string[]) => void;
    openKeys?: string[];
    selectedKeys?: Array<string>;
    style?: object;
}

// @public (undocumented)
export interface IMetricGroupProps {
    items?: IMetricItem[];
}

// @public (undocumented)
export interface IMetricItem {
    key: React_2.Key;
    label?: React_2.ReactNode;
    values?: IMetricItemValue[];
}

// @public (undocumented)
export interface IMetricItemValue {
    color?: "black" | "success" | "error" | "secondary";
    format?: NumberFormat;
    formatOptions?: IFormatNumberOptions;
    key: React_2.Key;
    label?: React_2.ReactNode;
    value?: React_2.ReactNode;
}

// @public (undocumented)
export interface IModalButtonProps {
    disabled?: boolean;
}

// @public (undocumented)
export interface IModalProps {
    afterClose?: () => void;
    // (undocumented)
    bodyBorder?: 'top' | 'bottom' | ('top' | 'bottom')[];
    cancelText?: React_2.ReactNode;
    destroyOnClose?: boolean;
    footer?: React_2.ReactNode;
    forceRender?: boolean;
    loading?: boolean;
    maskClosable?: boolean;
    okButtonProps?: IModalButtonProps;
    okText?: React_2.ReactNode;
    onCancel?: (e: React_2.MouseEvent<HTMLElement>) => void;
    onOk?: (e: React_2.MouseEvent<HTMLElement>) => void;
    removeBodyPadding?: boolean;
    style?: React_2.CSSProperties;
    title: React_2.ReactNode | string;
    visible?: boolean;
    width?: "normal" | "large" | "extraLarge" | "fullWidth";
    zIndex?: number;
}

// @public (undocumented)
export interface IMonthPickerProps {
    allowClear?: boolean;
    bordered?: boolean;
    defaultPickerValue?: dayjs.Dayjs;
    defaultValue?: dayjs.Dayjs;
    disabled?: boolean;
    disabledDate?: (current: dayjs.Dayjs | null) => boolean;
    format?: string;
    onChange?: (date: dayjs.Dayjs | null, dateString: string | string[]) => void;
    placeholder?: string;
    size?: "dense" | "normal";
    value?: dayjs.Dayjs;
    width?: number | string;
}

// @public
export const Input: React_2.FC<IInputProps>;

// @public
export const InputNumber: React_2.FC<IInputNumberProps>;

// @public
export const InputTextArea: React_2.FC<IInputTextAreaProps>;

// @public (undocumented)
export interface INumberColumnProps extends IBaseColumnProps {
    format?: NumberFormat;
    formatOptions?: IFormatNumberOptions;
    inputProps?: IInputNumberProps;
}

// @public (undocumented)
export interface IPageLoaderContext {
    loading: boolean;
    setLoading: (loading: boolean) => void;
}

// @public (undocumented)
export interface IPagerProps {
    current?: number;
    disabled?: boolean;
    disableLogging?: boolean;
    extra?: React_2.ReactNode;
    itemName?: string;
    logData?: object;
    onChange?: (page: number, pageSize?: number) => void;
    pageSize?: number;
    total?: number;
    totalItemNumber?: number;
}

// @public (undocumented)
export interface IPickerBaseProps {
    items?: any[];
    itemTextField?: string;
    onEdit?: () => void;
    width?: number | string;
}

// @public (undocumented)
export interface IPopConfirmProps {
    cancelText?: React_2.ReactNode;
    confirmType?: "normal" | "danger" | "attention";
    description?: React_2.ReactNode;
    okText?: React_2.ReactNode;
    onCancel?: (e?: React_2.MouseEvent<HTMLElement>) => void;
    onOk?: (e?: React_2.MouseEvent<HTMLElement>) => void;
    title: React_2.ReactNode;
}

// @public (undocumented)
export interface IPopoverProps {
    children: React_2.ReactElement;
    content: React_2.ReactNode | (() => React_2.ReactNode);
    onOpenChange?: (open: boolean) => void;
    open?: boolean;
    overlayClassName?: string;
    placement?: 'top' | 'left' | 'right' | 'bottom' | 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom';
    title: string | React_2.ReactNode | (() => React_2.ReactNode);
    trigger?: 'click' | 'hover';
}

// @public (undocumented)
export interface IRadioGroupProps {
    children?: React_2.ReactNode;
    defaultValue?: any;
    disabled?: boolean;
    onChange?: (e: RadioChangeEvent) => void;
    options?: Array<CheckboxOptionType | string>;
    value?: any;
    vertical?: boolean;
}

// @public (undocumented)
export interface IRadioProps {
    autoFocus?: boolean;
    checked?: boolean;
    disabled?: boolean;
    disableLogging?: boolean;
    id?: string;
    logData?: object;
    name?: string;
    onChange?: (e: RadioChangeEvent) => void;
    value?: any;
}

// @public (undocumented)
export interface IRangePickerProps {
    allowClear?: boolean;
    allowEmpty?: [boolean, boolean];
    autoFocus?: boolean;
    bordered?: boolean;
    defaultPickerValue?: [dayjs.Dayjs, dayjs.Dayjs];
    defaultValue?: RangeValue;
    disabled?: [boolean, boolean];
    disabledDate?: (current: dayjs.Dayjs | null) => boolean;
    format?: "L" | "ll" | string;
    onChange?: (values: RangeValue, formatString: [string, string]) => void;
    onFocus?: React_2.FocusEventHandler<HTMLInputElement>;
    picker?: "date" | "week" | "month" | "quarter" | "year";
    placeholder?: [string, string];
    ranges?: Record<string, [dayjs.Dayjs, dayjs.Dayjs] | (() => [dayjs.Dayjs, dayjs.Dayjs])>;
    size?: "dense" | "normal" | "large";
    value?: RangeValue;
    width?: number | string;
}

// @public (undocumented)
export interface IRouteConfirmProps {
    cancelText?: React_3.ReactNode;
    confirmType?: "normal" | "danger" | "attention";
    content?: React_3.ReactNode;
    okText?: React_3.ReactNode;
    onBeforePrompt?: (nextLocation: Location_2) => boolean;
    showPrompt: boolean;
    title: React_3.ReactNode | string;
}

// @public (undocumented)
export interface ISpacingProps {
    background?: "white" | "gray-100" | "blue-700";
    border?: string | string[];
    column?: boolean | "small" | "medium" | "large";
    hAlign?: "left" | "center" | "right" | "space-between";
    height?: number | string;
    itemSpacing?: 0 | 4 | 8 | 12 | 16 | 24 | 32 | 48;
    margin?: number | string;
    padding?: number | string;
    shadow?: boolean;
    style?: React_2.CSSProperties;
    vAlign?: "top" | "center" | "bottom" | "space-between";
    width?: number | string;
    wrap?: boolean | 4 | 8 | 12 | 16 | 24 | 32 | 48;
}

// @public (undocumented)
export interface ISplitButtonProps {
    buttonText?: React_2.ReactNode;
    className?: string;
    disabled?: boolean;
    icon?: React_2.ReactElement<IIconProps>;
    items: IMenuItem[];
    onClick?: React_2.MouseEventHandler<HTMLElement>;
    // Warning: (ae-forgotten-export) The symbol "SplitButtonType" needs to be exported by the entry point index.d.ts
    type?: SplitButtonType;
}

// @public (undocumented)
export interface ISplitterPanelProps {
    className?: string;
    defaultSize?: number | string;
    max?: number | string;
    min?: number | string;
    size?: number | string;
    style?: React_2.CSSProperties;
}

// @public (undocumented)
export interface ISplitterProps {
    border?: string | string[];
    className?: string;
    layout?: 'horizontal' | 'vertical';
    onResizeEnd?: (sizes: number[]) => void;
    style?: React_2.CSSProperties;
}

// @public (undocumented)
export interface ISwitchProps {
    checked?: boolean;
    defaultChecked?: boolean;
    disabled?: boolean;
    disableLogging?: boolean;
    labelText?: string;
    logData?: object;
    // Warning: (ae-forgotten-export) The symbol "SwitchChangeEventHandler" needs to be exported by the entry point index.d.ts
    onClick?: SwitchChangeEventHandler;
}

// @public (undocumented)
export interface ITab {
    children?: React_2.ReactNode;
    disabled?: boolean;
    hidden?: boolean;
    href?: string;
    key: string;
    label: React_2.ReactNode | string;
}

// @public (undocumented)
export interface ITabsProps {
    activeKey?: string;
    className?: string;
    defaultActiveKey?: string;
    destroyInactiveTabPane?: boolean;
    disableLogging?: boolean;
    extra?: React_2.ReactNode;
    items?: ITab[];
    loading?: boolean;
    logData?: object;
    onChange?: (activeKey: string) => void;
    type?: 'line' | 'pill';
}

// @public (undocumented)
export interface ITagProps {
    color?: "black" | "secondary" | "blue-700" | "error" | "success" | "attention";
    hoverable?: boolean;
    icon?: React_2.ReactElement<IIconProps>;
    removeStrong?: boolean;
    type?: 'normal' | 'pill';
}

// @public (undocumented)
export interface ITextAreaColumnProps extends IBaseColumnProps {
}

// @public (undocumented)
export interface ITextProps {
    color?: "black" | "secondary" | "white" | "success" | "error" | "attention";
    ellipsis?: boolean | {
        rows?: number;
        expandable?: boolean;
    };
    noWrap?: boolean;
    size?: "small" | "normal" | "large";
    strong?: boolean;
}

// @public (undocumented)
export interface ITimelineItem {
    date: React_2.ReactNode;
    events: React_2.ReactNode | React_2.ReactNode[];
    status?: 'completed' | 'current' | 'unfinished';
}

// @public (undocumented)
export interface ITimelineProps {
    height?: number;
    items?: ITimelineItem[];
}

// @public (undocumented)
export interface ITimePickerProps {
    allowClear?: boolean;
    autoFocus?: boolean;
    bordered?: boolean;
    defaultValue?: dayjs.Dayjs;
    disabled?: boolean;
    minuteStep?: IntRange<1, 59>;
    onChange?: (time: dayjs.Dayjs | null, timeString: string | string[]) => void;
    placeholder?: string;
    size?: "dense" | "normal";
    value?: dayjs.Dayjs;
    width?: number | string;
}

// @public (undocumented)
export interface IToastProps {
    duration?: number | null;
    key?: string;
    message: React_2.ReactNode;
    onClose?: () => void;
    placement?: 'topRight' | 'bottomRight';
    toastType?: 'success' | 'info' | 'error' | 'loading' | 'attention';
}

// @public (undocumented)
export interface IToggleItemProps {
    disabled?: boolean;
    name: string | React_2.ReactNode;
    value: any;
}

// @public (undocumented)
export interface IToggleProps {
    defaultValue: any;
    disableLogging?: boolean;
    items: IToggleItemProps[];
    logData?: object;
    onChange?: (e: RadioChangeEvent) => void;
    value?: any;
}

// @public (undocumented)
export interface ITooltipProps {
    children: React_2.ReactElement;
    placement?: 'top' | 'left' | 'right';
    title: string | React_2.ReactNode | (() => React_2.ReactNode);
}

// @public (undocumented)
export interface ITotalRowCalculation {
    calculationType: "sum" | "avg" | "custom";
    customCalculation?: (fieldValues: any[], allData: any[]) => number;
    field: string;
}

// @public (undocumented)
export interface ITreeCheckedKeys {
    checked: Key[];
    halfChecked: Key[];
}

// @public (undocumented)
export interface ITreeCheckInfo {
    // (undocumented)
    checked: boolean;
    // (undocumented)
    checkedNodes: ITreeNode[];
    // (undocumented)
    checkedNodesPositions?: {
        node: ITreeNode;
        pos: string;
    }[];
    // (undocumented)
    event: 'check';
    // (undocumented)
    halfCheckedKeys?: Key[];
    // (undocumented)
    nativeEvent: MouseEvent;
    // (undocumented)
    node: ITreeNode;
}

// @public (undocumented)
export interface ITreeDropDownNode {
    children?: ITreeDropDownNode[];
    disabled?: boolean;
    isLeaf?: boolean;
    key?: Key;
    title?: React_2.ReactNode;
    value?: Key;
}

// @public (undocumented)
export interface ITreeDropDownProps {
    allowClear?: boolean;
    defaultValue?: Key | Key[];
    disabled?: boolean;
    loadData?: (node: ITreeDropDownNode) => Promise<unknown>;
    maxTagPlaceholder?: React_2.ReactNode | ((selectedValues: any[]) => React_2.ReactNode);
    onChange?: (value: Key | Key[], label: React_2.ReactNode[]) => void;
    onSearch?: (value: Key) => void;
    onSelect?: (value: Key | Key[], node: any) => void;
    placeholder?: string;
    selectedText?: string;
    selectionMode?: 'single' | 'multiple';
    treeCheckStrictly?: boolean;
    treeData?: ITreeDropDownNode[];
    treeDefaultExpandAll?: boolean;
    treeDefaultExpandedKeys?: Key[];
    value?: Key | Key[];
    width?: string | number;
}

// @public (undocumented)
export interface ITreeGridExpandEvent {
    node: any;
    originalEvent: Event;
}

// @public (undocumented)
export interface ITreeGridProps extends IDataGridBaseProps {
    defaultExpandAll?: boolean;
    disableExpandCollapse?: boolean;
    expandedRowKeys?: any[];
    loading?: boolean;
    onExpand?: (e: ITreeGridExpandEvent) => void;
    onRowToggle?: (expandedKeys: any[]) => void;
    onSelectionChange?: (e: ITreeGridSelectionEvent) => void;
    selectionKeys?: any;
    selectionMode?: 'checkbox';
}

// @public (undocumented)
export interface ITreeGridSelectionEvent {
    originalEvent: Event;
    value: any;
}

// @public (undocumented)
export interface ITreeNode {
    checkable?: boolean;
    children?: ITreeNode[];
    disabled?: boolean;
    icon?: React_2.ReactElement<IIconProps>;
    isLeaf?: boolean;
    key: Key;
    selectable?: boolean;
    title?: React_2.ReactNode;
}

// @public (undocumented)
export interface ITreeNodeMapping {
    // (undocumented)
    keyField: string;
    // (undocumented)
    titleField: string;
    // (undocumented)
    valueField?: string;
}

// @public (undocumented)
export interface ITreeProps {
    checkedKeys?: Key[] | {
        checked: Key[];
        halfChecked: Key[];
    };
    checkStrictly?: boolean;
    className?: string;
    defaultCheckedKeys?: Key[];
    defaultExpandAll?: boolean;
    defaultExpandedKeys?: Key[];
    defaultSelectedKeys?: Key[];
    expandedKeys?: Key[];
    filterTreeNode?: (node: ITreeNode) => boolean;
    height?: number | string;
    loadData?: (node: ITreeNode) => Promise<void>;
    loadedKeys?: Key[];
    loading?: boolean;
    onCheck?: (checkedKeys: Key[] | ITreeCheckedKeys, info: ITreeCheckInfo) => void;
    onExpand?: (expandedKeys: Key[]) => void;
    onLoad?: (loadedKeys: Key[]) => void;
    onSelect?: (selectedKeys: Key[], info: ITreeSelectInfo) => void;
    selectedKeys?: Key[];
    selectionMode?: 'single' | 'multiple';
    showIcon?: boolean;
    treeData?: ITreeNode[];
}

// @public (undocumented)
export interface ITreeSelectInfo {
    event: 'select';
    nativeEvent: MouseEvent;
    node: ITreeNode;
    selected: boolean;
    selectedNodes: ITreeNode[];
}

// @public (undocumented)
export interface IUnloadProps {
    // (undocumented)
    children?: React_2.ReactNode;
}

// @public (undocumented)
export interface IUploadButtonProps {
    accept?: string;
    buttonBlock?: boolean;
    buttonText: string;
    buttonType?: ButtonType;
    multiple?: boolean;
    onChange?: (info: UploadChangeParam) => void;
}

// @public (undocumented)
export interface IValidateOptions extends ValidateOption {
    // (undocumented)
    cellArgs?: ICellArgs;
    // (undocumented)
    messages?: any;
}

// @public (undocumented)
export interface IWindowSize {
    // (undocumented)
    height: number;
    // (undocumented)
    width: number;
}

// @public (undocumented)
export interface IWizardProps {
    children: React_2.ReactElement[] | React_2.ReactElement;
    currentStep?: number;
    footerExtra?: React_2.ReactNode;
    loading?: boolean;
    onCancel?: () => void;
    onChange?: (currentStep: number, newStep: number, action: StepChangeAction) => void;
    onSubmit?: () => void;
    onSubmitSecondary?: () => void;
    submitAndNextButtonText?: string;
    submitButtonText?: string;
}

// @public (undocumented)
export interface IWizardStepProps {
    description?: React_2.ReactNode;
    disabled?: boolean;
    title: React_2.ReactNode;
}

// @public (undocumented)
export interface IYearPickerProps {
    allowClear?: boolean;
    autoFocus?: boolean;
    bordered?: boolean;
    defaultPickerValue?: dayjs.Dayjs;
    defaultValue?: dayjs.Dayjs;
    disabled?: boolean;
    disabledDate?: (current: dayjs.Dayjs | null) => boolean;
    format?: string;
    onChange?: (date: dayjs.Dayjs | null, dateString: string | string[]) => void;
    placeholder?: string;
    size?: "dense" | "normal";
    value?: dayjs.Dayjs;
    width?: number | string;
}

export { Key }

// @beta
export const Layout: React_2.FC<ILayoutProps> & {
    Nav: React_2.FC;
} & {
    Content: React_2.FC<ILayoutContentProps>;
} & {
    Sider: React_2.FC<ILayoutSiderProps>;
};

// @public (undocumented)
export const LayoutColumn: React_2.FC<ILayoutColumnProps>;

// @public (undocumented)
export const LayoutContent: React_2.FC<ILayoutContentProps>;

// @public
export const LayoutGrid: React_2.FC<ILayoutGridProps> & {
    Column: React_2.FC<ILayoutColumnProps>;
    Row: React_2.FC<ILayoutRowProps>;
};

// @public (undocumented)
export const LayoutNav: React_2.FC;

// @public (undocumented)
export const LayoutRow: React_2.FC<ILayoutRowProps>;

// @public (undocumented)
export const LayoutSider: React_2.FC<ILayoutSiderProps>;

// @public
export const Link: React_2.FC<ILinkProps>;

// @beta
export const List: {
    <T extends object>(props: IListProps<T>): React_2.JSX.Element;
    Item: React_2.FC<import("./ListItem").IListItemProps> & {
        Meta: React_2.FC<import("./ListItemMeta").IListItemMetaProps>;
    };
};

// @beta
export const Menu: React_2.FC<IMenuProps>;

// @beta
export const MetricGroup: React_2.FC<IMetricGroupProps>;

// @public
export const Modal: React_2.FC<IModalProps>;

// @beta (undocumented)
export const MonthPicker: React_2.FC<IMonthPickerProps>;

// @public (undocumented)
export const NotAllowed: () => React_3.JSX.Element;

// @public (undocumented)
export const NotFound: () => React_3.JSX.Element;

// @beta
export const PageLoader: React_2.FC;

// @beta
export const Pager: React_2.FC<IPagerProps>;

// @public
export const PickerBase: React_2.FC<IPickerBaseProps>;

// @beta
export const PopConfirm: React_2.FC<IPopConfirmProps>;

// @beta
export const Popover: React_2.FC<IPopoverProps>;

// @public (undocumented)
export const Radio: React_2.FC<IRadioProps>;

export { RadioChangeEvent }

// @public
export const RadioGroup: React_2.FC<IRadioGroupProps>;

// @beta (undocumented)
export const RangePicker: React_2.FC<IRangePickerProps>;

// @public (undocumented)
export type RangeValue = RangeValueType<dayjs.Dayjs>;

// @public
export const RouteConfirm: React_3.FC<IRouteConfirmProps>;

export { Rule }

export { RuleObject }

// @beta
export const Spacing: React_2.FC<ISpacingProps>;

// @public
export const SplitButton: React_2.FC<ISplitButtonProps>;

// @public
export const Splitter: React_2.FC<ISplitterProps> & {
    Panel: React_2.FC<ISplitterPanelProps>;
};

// @public
export const SplitterPanel: React_2.FC<ISplitterPanelProps>;

// @public (undocumented)
export type StepChangeAction = "next" | "prev";

// @beta
export const Switch: React_2.FC<ISwitchProps>;

// @public
export const Tabs: React_2.FC<ITabsProps>;

// @beta
export const Tag: React_2.FC<ITagProps>;

// @public (undocumented)
const tempo: {
    CustomIcon: import("react").FC<ICustomIconProps>;
    Button: import("react").FC<IButtonProps>;
    Link: import("react").FC<ILinkProps>;
    Checkbox: import("react").FC<ICheckboxProps>;
    CheckboxGroup: import("react").FC<ICheckboxGroupProps>;
    Radio: import("react").FC<IRadioProps>;
    RadioGroup: import("react").FC<IRadioGroupProps>;
    DropDown: import("react").FC<IDropDownProps> & {
        Item: import("react").FC<IDropDownItemProps>;
        ItemGroup: import("react").FC<IDropDownItemGroupProps>;
    };
    LayoutGrid: import("react").FC<ILayoutGridProps> & {
        Column: import("react").FC<ILayoutColumnProps>;
        Row: import("react").FC<ILayoutRowProps>;
    };
    LayoutColumn: import("react").FC<ILayoutColumnProps>;
    LayoutRow: import("react").FC<ILayoutRowProps>;
    Card: import("react").FC<ICardProps>;
    Tabs: import("react").FC<ITabsProps>;
    Drawer: import("react").FC<IDrawerProps>;
    Pager: import("react").FC<IPagerProps>;
    Input: import("react").FC<IInputProps>;
    InputNumber: import("react").FC<IInputNumberProps>;
    InputTextArea: import("react").FC<IInputTextAreaProps>;
    Spacing: import("react").FC<ISpacingProps>;
    Text: import("react").FC<ITextProps> & {
        Heading: import("react").FC<IHeadingProps>;
    };
    Heading: import("react").FC<IHeadingProps>;
    Tag: import("react").FC<ITagProps>;
    DataGrid: typeof DataGrid;
    DataColumn: import("react").FC<IDataColumnProps> & IColumn;
    DataCell: import("react").FC<IDataCellProps>;
    DataHeaderGroup: import("react").FC<IDataHeaderGroupProps>;
    DataHeaderRow: import("react").FC<IDataHeaderRowProps>;
    DataHeaderCell: import("react").FC<IDataHeaderCellProps>;
    Switch: import("react").FC<ISwitchProps>;
    DatePicker: import("react").FC<IDatePickerProps> & {
        MonthPicker: import("react").FC<IMonthPickerProps>;
    } & {
        RangePicker: import("react").FC<IRangePickerProps>;
    } & {
        YearPicker: import("react").FC<IYearPickerProps>;
    } & {
        TimePicker: import("react").FC<ITimePickerProps>;
    };
    MonthPicker: import("react").FC<IMonthPickerProps>;
    YearPicker: import("react").FC<IYearPickerProps>;
    RangePicker: import("react").FC<IRangePickerProps>;
    Form: import("react").FC<IFormProps & import("react").RefAttributes<FormInstance<any>>> & {
        Item: import("react").FC<IFormItemProps>;
        List: import("react").FC<import("./form/FormList").IFormListProps>;
        ItemSpacing: import("react").FC<import("./form/FormItemSpacing").IFormItemSpacingProps>;
        useForm: typeof useForm;
        useWatch: typeof useWatch;
    };
    Modal: import("react").FC<IModalProps>;
    useModal: () => {
        alert: (props: IAlertProps) => {
            destroy: () => void;
            update: (configUpdate: import("antd/lib").ModalFuncProps | ((prevConfig: import("antd/lib").ModalFuncProps) => import("antd/lib").ModalFuncProps)) => void;
        } & {
            then<T>(resolve: (confirmed: boolean) => T, reject: VoidFunction): Promise<T>;
        };
        confirm: (props: IConfirmProps) => void;
        confirmChanges: (props: IConfirmProps) => void;
    };
    ErrorBoundary: typeof ErrorBoundary;
    Error: (props: IErrorProps) => import("react").JSX.Element;
    NotAllowed: () => import("react").JSX.Element;
    NotFound: () => import("react").JSX.Element;
    ButtonMenu: import("react").FC<IButtonMenuProps>;
    Menu: import("react").FC<IMenuProps>;
    TreeGrid: typeof TreeGrid;
    Toggle: import("react").FC<IToggleProps>;
    UploadButton: import("react").FC<IUploadButtonProps>;
    useToast: () => {
        show: (props: IToastProps) => void;
        close: (key: string) => void;
    };
    Image: import("react").FC<IImageProps>;
    Tree: import("react").FC<ITreeProps>;
    TreeDropDown: import("react").FC<ITreeDropDownProps>;
    FixedActionBar: import("react").FC<IFixedActionBarProps>;
    Tooltip: import("react").FC<ITooltipProps>;
    RouteConfirm: import("react").FC<IRouteConfirmProps>;
    Wizard: import("react").FC<IWizardProps> & {
        Step: import("react").FC<IWizardStepProps>;
    };
    ActionBar: import("react").FC<IActionBarProps>;
    Layout: import("react").FC<ILayoutProps> & {
        Nav: import("react").FC<{}>;
    } & {
        Content: import("react").FC<import("./layout/LayoutContent").ILayoutContentProps>;
    } & {
        Sider: import("react").FC<ILayoutSiderProps>;
    };
    Banner: import("react").FC<IBannerProps>;
    Header: import("react").FC<IHeaderProps>;
    Divider: import("react").FC<IDividerProps>;
    PageLoader: import("react").FC<{}>;
    usePageLoader: () => IPageLoaderContext;
    List: {
        <T_1 extends object>(props: IListProps<T_1>): import("react").JSX.Element;
        Item: import("react").FC<IListItemProps> & {
            Meta: import("react").FC<IListItemMetaProps>;
        };
    };
    Timeline: import("react").FC<ITimelineProps>;
    PickerBase: import("react").FC<IPickerBaseProps>;
    Chips: import("react").FC<IChipsProps>;
    Chip: import("react").FC<IChipProps>;
    TimePicker: import("react").FC<ITimePickerProps>;
    PopConfirm: import("react").FC<IPopConfirmProps>;
    TempoProvider: import("react").FC<{}>;
    Accordion: import("react").FC<IAccordionProps>;
    ColorPicker: import("react").FC<IColorPickerProps>;
    MetricGroup: import("react").FC<IMetricGroupProps>;
    Popover: import("react").FC<IPopoverProps>;
    Empty: import("react").FC<IEmptyProps>;
    SplitButton: import("react").FC<ISplitButtonProps>;
    Splitter: import("react").FC<ISplitterProps> & {
        Panel: import("react").FC<ISplitterPanelProps>;
    };
    Cascader: import("react").FC<ICascaderProps>;
};

export default tempo;

// @public (undocumented)
export const TempoProvider: React_2.FC;

// @public
const Text_2: React_2.FC<ITextProps> & {
    Heading: React_2.FC<IHeadingProps>;
};

export { Text_2 as Text }

// @beta
export const Timeline: React_2.FC<ITimelineProps>;

// @beta (undocumented)
export const TimePicker: React_2.FC<ITimePickerProps>;

// @public
export const Toggle: React_2.FC<IToggleProps>;

// @beta
export const Tooltip: React_2.FC<ITooltipProps>;

// @beta
export const Tree: React_2.FC<ITreeProps>;

// @beta
export const TreeDropDown: React_2.FC<ITreeDropDownProps>;

// Warning: (ae-forgotten-export) The symbol "ITreeGridState" needs to be exported by the entry point index.d.ts
//
// @beta
export class TreeGrid extends React_2.Component<ITreeGridProps, ITreeGridState> {
    constructor(props: ITreeGridProps);
    // (undocumented)
    calculateBodyOffsetTop(): void;
    // (undocumented)
    static CheckboxColumn: React_2.FC<import("../datacolumn").ICheckboxColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    clearInvalidCells(): void;
    // (undocumented)
    static Column: React_2.FC<import("../datacolumn").IDataColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: ITreeGridProps): void;
    // (undocumented)
    static DateColumn: React_2.FC<import("../datacolumn").IDateColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static DefaultProps: ITreeGridProps;
    // (undocumented)
    static DropDownColumn: React_2.FC<import("../datacolumn").IDropDownColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static EmptyColumn: React_2.FC<import("../datacolumn").IEmptyColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static ExpandColumn: React_2.FC<import("../datacolumn").IExpandColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static GapColumn: React_2.FC<import("../datacolumn").IGapColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    getExpandedKeysFromProps(props: ITreeGridProps): any[];
    // (undocumented)
    getExpandedKeysFromState(): any;
    // (undocumented)
    grid: React_2.RefObject<TreeTable>;
    // (undocumented)
    mergeProps(validChildren: any[]): TreeTableProps;
    // (undocumented)
    static NumberColumn: React_2.FC<import("../datacolumn").INumberColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    onCellClick(args: ICellClickArgs): void;
    // (undocumented)
    onCellEditChange(editArgs: ICellEditorArgs, newCellValue: any): Promise<void>;
    // (undocumented)
    onCellValidate(cellArgs: ICellEditorArgs, rules: RuleItem[]): Promise<void>;
    // (undocumented)
    onRowClassName(rowData: any): any;
    // (undocumented)
    onToggle(e: {
        originalEvent: React_2.SyntheticEvent;
        value: any;
    }): void;
    // (undocumented)
    refreshGrid(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    static RowClass: {
        Highlight: string;
        ParentRow: string;
        ChildRow: string;
        Expanded: string;
        Disabled: string;
        Bold: string;
        Borderless: string;
    };
    // (undocumented)
    static RowNumber: React_2.FC<import("../datacolumn").IRowNumberColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    static TextAreaColumn: React_2.FC<import("../datacolumn").ITextAreaColumnProps> & import("../datacolumn").IColumn;
    // (undocumented)
    transformChildren(): React_2.ReactElement[];
    // (undocumented)
    validateGrid(): Promise<IInvalidCell[]>;
}

// @public (undocumented)
export const TreeRowClass: {
    Highlight: string;
    ParentRow: string;
    ChildRow: string;
    Expanded: string;
    Disabled: string;
    Bold: string;
    Borderless: string;
};

// @public (undocumented)
export const TreeUtils: {
    findNode(nodes: any[], key: string): any | null;
    flatten(nodes: any[]): any[];
    flattenLeafOnly(nodes: any[]): any[];
    fromFlatData(flatData: any[], mappings: ITreeNodeMapping, rootNode?: ITreeNode): ITreeNode[];
};

// Warning: (ae-forgotten-export) The symbol "IUnloadState" needs to be exported by the entry point index.d.ts
//
// @beta
export class Unload extends React_2.Component<IUnloadProps, IUnloadState> {
    constructor(props: IUnloadProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    render(): React_2.JSX.Element;
}

// @public
export const UploadButton: React_2.FC<IUploadButtonProps>;

export { useForm }

// @public (undocumented)
export const useModal: () => {
    alert: (props: IAlertProps) => {
        destroy: () => void;
        update: (configUpdate: import("antd/lib").ModalFuncProps | ((prevConfig: import("antd/lib").ModalFuncProps) => import("antd/lib").ModalFuncProps)) => void;
    } & {
        then<T>(resolve: (confirmed: boolean) => T, reject: VoidFunction): Promise<T>;
    };
    confirm: (props: IConfirmProps) => void;
    confirmChanges: (props: IConfirmProps) => void;
};

// @public (undocumented)
export const usePageLoader: () => import("./PageLoaderContext").IPageLoaderContext;

// @public (undocumented)
export const useToast: () => {
    show: (props: IToastProps) => void;
    close: (key: string) => void;
};

export { useWatch }

// @public (undocumented)
export const useWindowSize: () => IWindowSize;

export { ValidatorRule }

// @beta
export const Wizard: React_2.FC<IWizardProps> & {
    Step: React_2.FC<IWizardStepProps>;
};

// @beta (undocumented)
export const YearPicker: React_2.FC<IYearPickerProps>;


// Warnings were encountered during analysis:
//
// lib/form/Form.d.ts:58:5 - (ae-forgotten-export) The symbol "IFormListProps" needs to be exported by the entry point index.d.ts
// lib/form/Form.d.ts:59:5 - (ae-forgotten-export) The symbol "IFormItemSpacingProps" needs to be exported by the entry point index.d.ts
// lib/index.d.ts:104:5 - (ae-incompatible-release-tags) The symbol "DataGrid" is marked as @public, but its signature references "DataGrid" which is marked as @beta
// lib/index.d.ts:141:5 - (ae-incompatible-release-tags) The symbol "ErrorBoundary" is marked as @public, but its signature references "ErrorBoundary" which is marked as @beta
// lib/index.d.ts:147:5 - (ae-incompatible-release-tags) The symbol "TreeGrid" is marked as @public, but its signature references "TreeGrid" which is marked as @beta
// lib/layout/Layout.d.ts:15:5 - (ae-forgotten-export) The symbol "ILayoutContentProps" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)

```