import { Model, Components } from '@singularsystems/neo-core';
import { IInputSpecificProps } from './Input';
import DropDown, { IDropDownSpecificProps } from './DropDown/DropDown';
import NumberInput, { INumberInputSpecificProps } from './NumberInput';
import DatePicker from './DatePicker';
import Input from './Input';
import RadioList, { IRadioListSpecificProps } from './RadioList';
import * as React from 'react';
import { TransformMetaType } from '@singularsystems/neo-core/dist/Model/IModelBase';
import PropertyInfo from '@singularsystems/neo-core/dist/Model/PropertyInfo';
import { IComponentBase } from './ComponentBase';
import FileInput, { IFileEditorProps } from './FileManager/FileInput';
import { FormContextParams } from './FormContext';
export type ItemCallback<T> = (item: T, meta: TransformMetaType<T>, isHeader: boolean, index: number) => React.ReactNode;
export declare enum ControlType {
    Date = 0,
    Number = 1,
    DropDown = 2,
    Text = 3,
    File = 4,
    RadioList = 5
}
export declare enum CheckboxType {
    None = 0,
    Checkbox = 1,
    Switch = 2
}
export interface ICommonEditorProps<TInputRef = HTMLElement> {
    /** True if the editor should be readonly. This is set automatically if you use display instead of bind on a FormGroup / Column. */
    isReadOnly?: boolean;
    /** True if the editor should be readonly. This is set automatically if you use display instead of bind on a FormGroup / Column. */
    readOnly?: boolean;
    /** True if the editor should be disabled */
    isDisabled?: boolean;
    /** True if the editor should be disabled */
    disabled?: boolean;
    /** Will show this text in a block before the input */
    prependText?: string;
    /** Will show this text in a block after the input */
    appendText?: string;
    /** Additional element to include before the input element */
    prepend?: (() => React.ReactNode) | React.ReactNode | null;
    /** Additional element to include after the input element */
    append?: (() => React.ReactNode) | React.ReactNode | null;
    /** Icon name or component */
    prependIcon?: any;
    /** Icon name or component */
    appendIcon?: any;
    /** True if append / prepend is set, which means this must be an editor as part of a bs editor group. */
    requiresGroup?: boolean;
    /** Reference to the input dom element */
    inputElement?: React.RefObject<TInputRef | null>;
}
export interface IBindableEditorPropsNoBase extends ICommonEditorProps {
    bind: Model.IPropertyInstance;
    placeholder?: string | boolean;
}
export interface IBindableEditorProps<T = HTMLElement> extends IBindableEditorPropsNoBase, React.HTMLProps<T> {
    /**
     * HTML Placeholder to display when the input control has no value.
     * Value of true results in the readable property name being used.
     */
    placeholder?: any;
    children?: any;
}
interface IEditorSelectorProps<T> {
    /** Drop down props if this editor must be a drop down */
    select?: IDropDownSpecificProps<T>;
    /** Input props if this editor is a text / check input */
    input?: IInputSpecificProps;
    /** Number props if this editor is a numeric editor  */
    numProps?: INumberInputSpecificProps;
    /** Date props if this editor is a date editor */
    dateProps?: Components.IPartialDateProps;
    /** Radio list props if this is a radio button list. */
    radioList?: IRadioListSpecificProps<T>;
    /** File props if this editor is a file editor */
    fileProps?: IFileEditorProps;
}
interface ICommonContainerOwnProps {
    /** Label / header text */
    label?: string | React.ReactNode;
    /** True if the editor / display value should be suppressed. Children will still be rendered. */
    suppressDefaultContent?: boolean;
    /**
     * Allows use of a custom component in a form group / column.
     * Child components can read information from the container using the EditorContainerContext.
     * suppressDefaultContent will be set to true if unset.
     */
    bindContext?: Model.IPropertyInstance;
    /**
     * Tooltip to display on hover of the editor.
     */
    editorTooltip?: string | Components.Tooltip.ITooltipOptions;
    /**
     * Classname to add to the editor.
     */
    editorClassName?: string;
    /**
     * Styles to apply to the editor.
     */
    editorStyle?: React.CSSProperties;
}
interface IEditorAndSelectorProps<TElement, TData> extends IBindableEditorProps<TElement>, IEditorSelectorProps<TData> {
}
export interface IEditorContainerProps<TElement, TData> extends Partial<IEditorAndSelectorProps<TElement, TData>>, ICommonContainerOwnProps {
    label?: Components.ElementOrText;
    /** Bind property if you want the editor to be readonly. */
    display?: Model.IPropertyInstance;
    /** Dom properties to apply to the underlying editor. */
    editorProps?: React.HTMLProps<HTMLElement>;
    /** Id for the editor element. */
    id?: string;
}
export interface IEditorNormalisedProps<TDom, TData> extends IEditorSelectorProps<TData> {
    bind: Model.IPropertyInstance;
    editor: IBindableEditorProps;
    editorDom: TDom;
    /** True if the editor is in a form group with a label and error display. */
    inGroup: boolean;
    /** Unique id for the editor and label. */
    uniqueID: string;
    isBootstrap: boolean;
}
export interface IEditorContainerNormalisedProps<TDom, TData> extends IEditorNormalisedProps<any, TData> {
    container: ICommonContainerOwnProps;
    containerDom: TDom;
}
export declare class BindPropsHelper {
    static readonly DataFieldName = "data-field-name";
    private static _config;
    private static get config();
    /**
     * Gets the correct input control type based on the props. E.g. Input / DatePicker / Select
     * @param props Props passed to a multi type input container. E.g. FormGroup / Column
     */
    static getFormControl(props: IEditorNormalisedProps<any, any>): React.CElement<import("./DatePicker").INeoDatePickerProps, DatePicker> | React.CElement<import("./NumberInput").INumberInputProps, NumberInput> | React.CElement<import("./DropDown/DropDown").IDropDownProps<unknown, unknown>, DropDown<unknown, unknown>> | React.CElement<IFileEditorProps, FileInput> | React.CElement<import("./Input").IInputProps, Input> | React.CElement<import("./RadioList").IRadioListProps<unknown>, RadioList<unknown>>;
    static getControlType(props: IEditorNormalisedProps<any, any>): ControlType;
    static getCheckBoxType(props: IEditorNormalisedProps<any, any>, instance?: any): CheckboxType;
    /**
     * Get the main bind property from a props object
     */
    static getBindProperty<T>(allProps: IEditorContainerProps<T, any>): Model.IPropertyInstance;
    static splitCommonEditorProps<T extends ICommonEditorProps>(props: T): {
        editor: ICommonEditorProps;
        rest: Omit<T, "disabled" | "readOnly" | "isReadOnly" | "isDisabled" | "prependText" | "appendText" | "prepend" | "append" | "prependIcon" | "appendIcon" | "requiresGroup" | "inputElement">;
    };
    static normaliseContainerProps<T, TContainerDom = React.HTMLProps<T>, TData = any>(component: IComponentBase, props: IEditorContainerProps<T, TData>, inGroup: boolean, isBootstrap?: boolean): IEditorContainerNormalisedProps<TContainerDom, TData>;
    static normaliseEditorProps<T, TDom = React.HTMLProps<T>>(component: IComponentBase, props: (IEditorAndSelectorProps<T, any> & TDom) | IEditorNormalisedProps<TDom, any>): IEditorNormalisedProps<TDom, any>;
    static getUniqueId(bindProperty: Model.IPropertyInstance, component: IComponentBase): string;
    static getPlaceholderText(placeholder: string | boolean | undefined, property: PropertyInfo): string | undefined;
    static autoSetDomProperties<TDom extends React.HTMLProps<HTMLElement>>(props: IEditorNormalisedProps<TDom, any>, formContext: FormContextParams, componentBlurFn?: (e: React.FocusEvent<HTMLElement>) => void, componentFocusFn?: (e: React.FocusEvent<HTMLElement>) => void): TDom;
    static isReadOnly(editorProps: ICommonEditorProps, formContext: FormContextParams): boolean;
    static isDisabled(editorProps: ICommonEditorProps, formContext: FormContextParams): boolean;
    /**
     * Intercept the user specified blur event, and run the validation onBlur logic first.
     * @param props Props specified on component.
     * @param blurFn Blur function used internally by component.
     */
    private static blurIntercept;
}
export {};