import React from "react";
import { BinaryNode, PathNode, LiteralNode, BlockNode, ConditionNode, VariableNode, ObjectUnaryNode, ArrayUnaryNode, FunctionNode, ApplyNode, BindNode } from "jsonata-ui-core";
import { ParsingState, Mode, AST, NodeEditorProps, SchemaProvider } from "./Types";
declare type Callback = () => void;
declare type OnChange<T> = (val: T) => void;
declare type Children = JSX.Element[];
declare type Comp<T> = React.ComponentType<T>;
export declare type Theme = {
    Base: Comp<BaseEditorProps>;
    RootNodeEditor: Comp<RootNodeEditorProps>;
    IDETextarea: Comp<IDETextareaProps>;
    ComparisonEditor: Comp<ComparisonEditorProps>;
    CombinerEditor: Comp<CombinerEditorProps>;
    BlockEditor: Comp<BlockEditorProps>;
    ConditionEditor: Comp<ConditionEditorProps>;
    ObjectUnaryEditor: Comp<ObjectUnaryEditorProps>;
    ArrayUnaryEditor: Comp<ArrayUnaryEditorProps>;
    ApplyEditor: Comp<ApplyEditorProps>;
    FunctionEditor: Comp<FunctionEditorProps>;
    BindEditor: Comp<BindEditorProps>;
    VariableEditor: Comp<VariableEditorProps>;
    LeafValueEditor: Comp<LeafValueEditorProps>;
    PathEditor: Comp<PathEditorProps>;
    MathEditor: Comp<MathEditorProps>;
};
export interface IDETextareaProps {
    textChange: OnChange<string>;
    text: string;
    parsing: ParsingState;
}
export declare type ChildNodeProps = {
    editor: JSX.Element;
    ast: NodeEditorProps<AST>["ast"];
    onChange: NodeEditorProps<AST>["onChange"];
};
export declare type CombinerEditorProps = NodeEditorProps<BinaryNode> & {
    addNew: Callback;
    removeLast: Callback;
    combinerOperators: {
        [key: string]: string;
    };
    children: JSX.Element[];
    childNodes: ChildNodeProps[];
};
export declare type BlockEditorProps = NodeEditorProps<BlockNode> & {
    children: Children;
    childNodes: ChildNodeProps[];
};
export declare type ObjectUnaryEditorProps = NodeEditorProps<ObjectUnaryNode> & {
    addNew: Callback;
    removeLast: Callback;
    children: {
        key: JSX.Element;
        value: JSX.Element;
        remove: Callback;
        keyProps: NodeEditorProps<AST>;
        valueProps: NodeEditorProps<AST>;
    }[];
};
export declare type VariableEditorProps = NodeEditorProps<VariableNode> & {
    boundVariables: string[];
};
export declare type ArrayUnaryEditorProps = NodeEditorProps<ArrayUnaryNode> & {
    children: (ChildNodeProps & {
        remove: Callback;
    })[];
    addNew: Callback;
    removeLast: Callback;
};
export declare type LeafValueEditorProps = NodeEditorProps<LiteralNode> & {
    text: string;
    onChangeText: OnChange<string>;
    changeType: Callback;
};
export declare type PathEditorProps = NodeEditorProps<PathNode> & {
    changeType: Callback;
    schemaProvider?: SchemaProvider;
};
export declare type BaseEditorProps = {
    toggleMode: Callback;
    toggleBlock: string | null;
    mode: Mode;
    editor: JSX.Element;
};
export declare type RootNodeEditorProps = NodeEditorProps<AST> & {
    editor: JSX.Element;
};
export declare type ConditionEditorProps = NodeEditorProps<ConditionNode> & {
    addNew: Callback;
    removeLast: Callback;
    elseEditor?: JSX.Element;
    children: {
        Then: JSX.Element;
        Condition: JSX.Element;
        remove: Callback;
        ast: NodeEditorProps<ConditionNode>["ast"];
        onChange: NodeEditorProps<ConditionNode>["onChange"];
    }[];
};
export declare type ComparisonEditorProps = NodeEditorProps<BinaryNode> & {
    lhs: JSX.Element;
    rhs: JSX.Element;
    lhsProps: NodeEditorProps<AST>;
    rhsProps: NodeEditorProps<AST>;
    changeOperator: OnChange<BinaryNode["value"]>;
};
export declare type ApplyEditorProps = NodeEditorProps<ApplyNode> & {
    lhs: JSX.Element;
    children: Children;
    lhsProps: NodeEditorProps<AST>;
    childNodes: ChildNodeProps[];
};
export declare type FunctionEditorProps = NodeEditorProps<FunctionNode> & {
    args: Children;
    argumentNodes: ChildNodeProps[];
    changeProcedure: OnChange<String>;
};
export declare type BindEditorProps = NodeEditorProps<BindNode> & {
    lhs: JSX.Element;
    rhs: JSX.Element;
    lhsProps: NodeEditorProps<AST>;
    rhsProps: NodeEditorProps<AST>;
};
export declare type MathEditorProps = NodeEditorProps<BinaryNode> & {
    text: string;
    children: MathPart[];
    changeType: Callback;
} & IDETextareaProps;
export declare type MathPart = ({
    type: "ast";
    children?: MathPart[];
} & ChildNodeProps) | {
    type: "operator";
    operator: string;
    onChangeOperator: OnChange<string>;
};
export {};