import type { ToolItem } from '../parts/Panel.vue';
import type { editor } from 'monaco-editor';
import type { LooseRequired } from '@vue/shared';
import type { InputAutoSize, FormContext, FormItemContext, ButtonGroupContext, ButtonConfigContext } from 'element-plus';
import type { SFCWithInstall, EpPropFinalized, EpPropMergeType, Mutable } from 'element-plus/es/utils';
import type { DefineComponent, Ref, PropType, Component, ComputedOptions, MethodOptions, StyleValue, ExtractPropTypes, ComponentInternalInstance, Slot, ComputedRef, ShallowRef, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps, CSSProperties } from 'vue';
import type { Engine, JSONValue } from '../..';
export interface Props {
    modelValue?: JSONValue;
}
declare const _sfc_main: DefineComponent<{
    modelValue: {
        type: null;
        required: false;
        default: string;
    };
}, {
    props: {
        modelValue: JSONValue;
    };
    codeEditor: Ref<any>;
    textValue: Ref<string>;
    dialogVisible: Ref<boolean>;
    emit: (event: "change", ...args: any[]) => void;
    handleSubmit: () => void;
    openDialog: () => void;
    ElInput: SFCWithInstall<DefineComponent<{
        readonly id: EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
        readonly size: {
            readonly type: PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly disabled: BooleanConstructor;
        readonly modelValue: EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;
        readonly type: EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;
        readonly resize: {
            readonly type: PropType<EpPropMergeType<StringConstructor, "vertical" | "none" | "both" | "horizontal", unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly autosize: EpPropFinalized<(new (...args: any[]) => InputAutoSize & {}) | (() => InputAutoSize) | ((new (...args: any[]) => InputAutoSize & {}) | (() => InputAutoSize))[], unknown, unknown, false, boolean>;
        readonly autocomplete: EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;
        readonly formatter: {
            readonly type: PropType<Function>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly parser: {
            readonly type: PropType<Function>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly placeholder: {
            readonly type: PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly form: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
        readonly readonly: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly clearable: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly showPassword: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly showWordLimit: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly suffixIcon: {
            readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly prefixIcon: {
            readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly containerRole: EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
        readonly label: EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
        readonly tabindex: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
        readonly validateEvent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly inputStyle: EpPropFinalized<(new (...args: any[]) => StyleValue & {}) | (() => StyleValue) | ((new (...args: any[]) => StyleValue & {}) | (() => StyleValue))[], unknown, unknown, () => Mutable<{}>, boolean>;
    }, {
        PENDANT_MAP: {
            readonly suffix: "append";
            readonly prefix: "prepend";
        };
        props: Readonly<LooseRequired<Readonly<ExtractPropTypes<{
            readonly id: EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
            readonly size: {
                readonly type: PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly disabled: BooleanConstructor;
            readonly modelValue: EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;
            readonly type: EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;
            readonly resize: {
                readonly type: PropType<EpPropMergeType<StringConstructor, "vertical" | "none" | "both" | "horizontal", unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly autosize: EpPropFinalized<(new (...args: any[]) => InputAutoSize & {}) | (() => InputAutoSize) | ((new (...args: any[]) => InputAutoSize & {}) | (() => InputAutoSize))[], unknown, unknown, false, boolean>;
            readonly autocomplete: EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;
            readonly formatter: {
                readonly type: PropType<Function>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly parser: {
                readonly type: PropType<Function>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly placeholder: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly form: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
            readonly readonly: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly clearable: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly showPassword: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly showWordLimit: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly suffixIcon: {
                readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly prefixIcon: {
                readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly containerRole: EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
            readonly label: EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
            readonly tabindex: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
            readonly validateEvent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly inputStyle: EpPropFinalized<(new (...args: any[]) => StyleValue & {}) | (() => StyleValue) | ((new (...args: any[]) => StyleValue & {}) | (() => StyleValue))[], unknown, unknown, () => Mutable<{}>, boolean>;
        }>> & {
            onChange?: ((value: string) => any) | undefined;
            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
            onInput?: ((value: string) => any) | undefined;
            onFocus?: ((evt: FocusEvent) => any) | undefined;
            onBlur?: ((evt: FocusEvent) => any) | undefined;
            onClear?: (() => any) | undefined;
            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
            onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
            onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
            onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
            onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
        }>>;
        emit: ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "input", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "clear") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void);
        instance: ComponentInternalInstance;
        rawAttrs: {
            [x: string]: unknown;
        };
        slots: Readonly<{
            [name: string]: Slot | undefined;
        }>;
        containerAttrs: ComputedRef<Record<string, unknown>>;
        attrs: ComputedRef<Record<string, unknown>>;
        form: FormContext | undefined;
        formItem: FormItemContext | undefined;
        inputId: Ref<string | undefined>;
        inputSize: ComputedRef<"" | "default" | "small" | "large">;
        inputDisabled: ComputedRef<boolean>;
        nsInput: {
            namespace: Ref<string>;
            b: (blockSuffix?: string | undefined) => string;
            e: (element?: string | undefined) => string;
            m: (modifier?: string | undefined) => string;
            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
            em: (element?: string | undefined, modifier?: string | undefined) => string;
            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
            is: {
                (name: string, state: boolean | undefined): string;
                (name: string): string;
            };
            cssVar: (object: Record<string, string>) => Record<string, string>;
            cssVarName: (name: string) => string;
            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
            cssVarBlockName: (name: string) => string;
        };
        nsTextarea: {
            namespace: Ref<string>;
            b: (blockSuffix?: string | undefined) => string;
            e: (element?: string | undefined) => string;
            m: (modifier?: string | undefined) => string;
            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
            em: (element?: string | undefined, modifier?: string | undefined) => string;
            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
            is: {
                (name: string, state: boolean | undefined): string;
                (name: string): string;
            };
            cssVar: (object: Record<string, string>) => Record<string, string>;
            cssVarName: (name: string) => string;
            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
            cssVarBlockName: (name: string) => string;
        };
        input: ShallowRef<HTMLInputElement | undefined>;
        textarea: ShallowRef<HTMLTextAreaElement | undefined>;
        focused: Ref<boolean>;
        hovering: Ref<boolean>;
        isComposing: Ref<boolean>;
        passwordVisible: Ref<boolean>;
        countStyle: Ref<StyleValue | undefined>;
        textareaCalcStyle: ShallowRef<StyleValue>;
        _ref: ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
        needStatusIcon: ComputedRef<boolean>;
        validateState: ComputedRef<"" | "success" | "error" | "validating">;
        validateIcon: ComputedRef<"" | DefineComponent<{}, {}, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>>;
        passwordIcon: ComputedRef<DefineComponent<{}, {}, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>>;
        containerStyle: ComputedRef<StyleValue>;
        textareaStyle: ComputedRef<StyleValue>;
        nativeInputValue: ComputedRef<string>;
        showClear: ComputedRef<boolean>;
        showPwdVisible: ComputedRef<boolean>;
        isWordLimitVisible: ComputedRef<boolean>;
        textLength: ComputedRef<number>;
        inputExceed: ComputedRef<boolean>;
        suffixVisible: ComputedRef<boolean>;
        recordCursor: () => void;
        setCursor: () => void;
        resizeTextarea: () => void;
        setNativeInputValue: () => void;
        calcIconOffset: (place: "prefix" | "suffix") => void;
        updateIconOffset: () => void;
        handleInput: (event: Event) => Promise<void>;
        handleChange: (event: Event) => void;
        handleCompositionStart: (event: CompositionEvent) => void;
        handleCompositionUpdate: (event: CompositionEvent) => void;
        handleCompositionEnd: (event: CompositionEvent) => void;
        handlePasswordVisible: () => void;
        focus: () => Promise<void>;
        blur: () => void | undefined;
        handleFocus: (event: FocusEvent) => void;
        handleBlur: (event: FocusEvent) => void;
        handleMouseLeave: (evt: MouseEvent) => void;
        handleMouseEnter: (evt: MouseEvent) => void;
        handleKeydown: (evt: KeyboardEvent) => void;
        select: () => void;
        clear: () => void;
        ElIcon: SFCWithInstall<DefineComponent<{
            readonly size: {
                readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }, {
            props: Readonly<LooseRequired<Readonly<ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>> & {
                [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
            }>>;
            ns: {
                namespace: Ref<string>;
                b: (blockSuffix?: string | undefined) => string;
                e: (element?: string | undefined) => string;
                m: (modifier?: string | undefined) => string;
                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
                em: (element?: string | undefined, modifier?: string | undefined) => string;
                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            style: ComputedRef<CSSProperties>;
        }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, Record<string, any>, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}>> & Record<string, any>;
        CircleClose: DefineComponent<{}, {}, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>;
        NOOP: () => void;
    }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
        "update:modelValue": (value: string) => boolean;
        input: (value: string) => boolean;
        change: (value: string) => boolean;
        focus: (evt: FocusEvent) => boolean;
        blur: (evt: FocusEvent) => boolean;
        clear: () => boolean;
        mouseleave: (evt: MouseEvent) => boolean;
        mouseenter: (evt: MouseEvent) => boolean;
        keydown: (evt: Event | KeyboardEvent) => boolean;
        compositionstart: (evt: CompositionEvent) => boolean;
        compositionupdate: (evt: CompositionEvent) => boolean;
        compositionend: (evt: CompositionEvent) => boolean;
    }, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
        readonly id: EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
        readonly size: {
            readonly type: PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly disabled: BooleanConstructor;
        readonly modelValue: EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;
        readonly type: EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;
        readonly resize: {
            readonly type: PropType<EpPropMergeType<StringConstructor, "vertical" | "none" | "both" | "horizontal", unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly autosize: EpPropFinalized<(new (...args: any[]) => InputAutoSize & {}) | (() => InputAutoSize) | ((new (...args: any[]) => InputAutoSize & {}) | (() => InputAutoSize))[], unknown, unknown, false, boolean>;
        readonly autocomplete: EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;
        readonly formatter: {
            readonly type: PropType<Function>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly parser: {
            readonly type: PropType<Function>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly placeholder: {
            readonly type: PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly form: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
        readonly readonly: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly clearable: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly showPassword: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly showWordLimit: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly suffixIcon: {
            readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly prefixIcon: {
            readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly containerRole: EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
        readonly label: EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
        readonly tabindex: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
        readonly validateEvent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly inputStyle: EpPropFinalized<(new (...args: any[]) => StyleValue & {}) | (() => StyleValue) | ((new (...args: any[]) => StyleValue & {}) | (() => StyleValue))[], unknown, unknown, () => Mutable<{}>, boolean>;
    }>> & {
        onChange?: ((value: string) => any) | undefined;
        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
        onInput?: ((value: string) => any) | undefined;
        onFocus?: ((evt: FocusEvent) => any) | undefined;
        onBlur?: ((evt: FocusEvent) => any) | undefined;
        onClear?: (() => any) | undefined;
        onMouseleave?: ((evt: MouseEvent) => any) | undefined;
        onMouseenter?: ((evt: MouseEvent) => any) | undefined;
        onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
        onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
        onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
        onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
    }, {
        readonly type: string;
        readonly disabled: boolean;
        readonly label: string;
        readonly id: string;
        readonly modelValue: EpPropMergeType<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown>;
        readonly validateEvent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly autosize: InputAutoSize;
        readonly autocomplete: string;
        readonly form: string;
        readonly readonly: EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly clearable: EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly showPassword: EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly showWordLimit: EpPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly containerRole: string;
        readonly tabindex: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
        readonly inputStyle: StyleValue;
    }>> & Record<string, any>;
    CodeEditor: DefineComponent<{
        lang: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        modelValue: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        options: {
            type: null;
            required: false;
            default: () => {};
        };
        height: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        readonly: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        dark: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        border: {
            type: BooleanConstructor;
            required: false;
        };
        minimap: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }, {
        engine: Engine;
        props: {
            lang: string;
            modelValue: string;
            options: editor.IEditorConstructionOptions;
            height: string;
            readonly: boolean;
            dark: boolean;
            border?: boolean | undefined;
            minimap: boolean;
        };
        emit: (event: "blur" | "change", ...args: any[]) => void;
        container: Ref<any>;
        editor: null;
        handleBlur: () => void;
        createEditor: () => void;
        getEditor: () => editor.IStandaloneCodeEditor | null;
    }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("blur" | "change")[], "blur" | "change", VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
        lang: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        modelValue: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        options: {
            type: null;
            required: false;
            default: () => {};
        };
        height: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        readonly: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        dark: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        border: {
            type: BooleanConstructor;
            required: false;
        };
        minimap: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & {
        onBlur?: ((...args: any[]) => any) | undefined;
        onChange?: ((...args: any[]) => any) | undefined;
    }, {
        height: string;
        dark: boolean;
        modelValue: string;
        readonly: boolean;
        border: boolean;
        lang: string;
        options: any;
        minimap: boolean;
    }>;
    Dialog: DefineComponent<{
        modelValue: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        modal: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        width: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        height: {
            type: StringConstructor;
            required: false;
        };
        top: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        cancel: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        submit: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        closable: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }, {
        attrs: {
            [x: string]: unknown;
        };
        props: {
            modelValue: boolean;
            modal: boolean;
            width: string;
            height?: string | undefined;
            top: string;
            cancel: boolean;
            submit: boolean;
            closable: boolean;
        };
        styles: ComputedRef<{
            width: string;
            height: string | undefined;
            top: string;
        }>;
        tools: ComputedRef<ToolItem[]>;
        emit: (event: "submit" | "close" | "update:modelValue", ...args: any[]) => void;
        handleToolClick: (item: ToolItem) => void;
        handleCancel: () => void;
        handleSubmit: () => void;
        Panel: DefineComponent<unknown, object, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<unknown>, {}>;
        ElButton: SFCWithInstall<DefineComponent<{
            readonly size: {
                readonly type: PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly disabled: BooleanConstructor;
            readonly type: EpPropFinalized<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger", unknown, "", boolean>;
            readonly icon: {
                readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly nativeType: EpPropFinalized<StringConstructor, "reset" | "button" | "submit", unknown, "button", boolean>;
            readonly loading: BooleanConstructor;
            readonly loadingIcon: EpPropFinalized<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown, () => DefineComponent<{}, {}, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>, boolean>;
            readonly plain: BooleanConstructor;
            readonly text: BooleanConstructor;
            readonly link: BooleanConstructor;
            readonly bg: BooleanConstructor;
            readonly autofocus: BooleanConstructor;
            readonly round: BooleanConstructor;
            readonly circle: BooleanConstructor;
            readonly color: StringConstructor;
            readonly dark: BooleanConstructor;
            readonly autoInsertSpace: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
        }, {
            props: Readonly<LooseRequired<Readonly<ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
                readonly type: EpPropFinalized<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger", unknown, "", boolean>;
                readonly icon: {
                    readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly nativeType: EpPropFinalized<StringConstructor, "reset" | "button" | "submit", unknown, "button", boolean>;
                readonly loading: BooleanConstructor;
                readonly loadingIcon: EpPropFinalized<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown, () => DefineComponent<{}, {}, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>, boolean>;
                readonly plain: BooleanConstructor;
                readonly text: BooleanConstructor;
                readonly link: BooleanConstructor;
                readonly bg: BooleanConstructor;
                readonly autofocus: BooleanConstructor;
                readonly round: BooleanConstructor;
                readonly circle: BooleanConstructor;
                readonly color: StringConstructor;
                readonly dark: BooleanConstructor;
                readonly autoInsertSpace: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
            }>> & {
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }>>;
            emit: (event: "click", evt: MouseEvent) => void;
            slots: Readonly<{
                [name: string]: Slot | undefined;
            }>;
            buttonGroupContext: ButtonGroupContext | undefined;
            globalConfig: Ref<ButtonConfigContext | undefined>;
            ns: {
                namespace: Ref<string>;
                b: (blockSuffix?: string | undefined) => string;
                e: (element?: string | undefined) => string;
                m: (modifier?: string | undefined) => string;
                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
                em: (element?: string | undefined, modifier?: string | undefined) => string;
                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            form: FormContext | undefined;
            _size: ComputedRef<"" | "default" | "small" | "large">;
            _disabled: ComputedRef<boolean>;
            _ref: Ref<HTMLButtonElement | undefined>;
            _type: ComputedRef<"" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger">;
            autoInsertSpace: ComputedRef<EpPropMergeType<BooleanConstructor, unknown, unknown>>;
            shouldAddSpace: ComputedRef<boolean>;
            buttonStyle: ComputedRef<Record<string, string>>;
            handleClick: (evt: MouseEvent) => void;
            ElIcon: SFCWithInstall<DefineComponent<{
                readonly size: {
                    readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }, {
                props: Readonly<LooseRequired<Readonly<ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>> & {
                    [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
                }>>;
                ns: {
                    namespace: Ref<string>;
                    b: (blockSuffix?: string | undefined) => string;
                    e: (element?: string | undefined) => string;
                    m: (modifier?: string | undefined) => string;
                    be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
                    em: (element?: string | undefined, modifier?: string | undefined) => string;
                    bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
                    bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
                    is: {
                        (name: string, state: boolean | undefined): string;
                        (name: string): string;
                    };
                    cssVar: (object: Record<string, string>) => Record<string, string>;
                    cssVarName: (name: string) => string;
                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                    cssVarBlockName: (name: string) => string;
                };
                style: ComputedRef<CSSProperties>;
            }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, Record<string, any>, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}>> & Record<string, any>;
        }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
            click: (evt: MouseEvent) => boolean;
        }, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly disabled: BooleanConstructor;
            readonly type: EpPropFinalized<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger", unknown, "", boolean>;
            readonly icon: {
                readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly nativeType: EpPropFinalized<StringConstructor, "reset" | "button" | "submit", unknown, "button", boolean>;
            readonly loading: BooleanConstructor;
            readonly loadingIcon: EpPropFinalized<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown, () => DefineComponent<{}, {}, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{}>>, {}>, boolean>;
            readonly plain: BooleanConstructor;
            readonly text: BooleanConstructor;
            readonly link: BooleanConstructor;
            readonly bg: BooleanConstructor;
            readonly autofocus: BooleanConstructor;
            readonly round: BooleanConstructor;
            readonly circle: BooleanConstructor;
            readonly color: StringConstructor;
            readonly dark: BooleanConstructor;
            readonly autoInsertSpace: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
        }>> & {
            onClick?: ((evt: MouseEvent) => any) | undefined;
        }, {
            readonly type: EpPropMergeType<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger", unknown>;
            readonly text: boolean;
            readonly nativeType: EpPropMergeType<StringConstructor, "reset" | "button" | "submit", unknown>;
            readonly loadingIcon: EpPropMergeType<(new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>;
            readonly autoInsertSpace: EpPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly disabled: boolean;
            readonly loading: boolean;
            readonly plain: boolean;
            readonly link: boolean;
            readonly bg: boolean;
            readonly autofocus: boolean;
            readonly round: boolean;
            readonly circle: boolean;
            readonly dark: boolean;
        }>> & {
            ButtonGroup: DefineComponent<{
                readonly size: {
                    readonly type: PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly type: EpPropFinalized<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger", unknown, "", boolean>;
            }, {
                props: Readonly<LooseRequired<Readonly<ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly type: EpPropFinalized<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger", unknown, "", boolean>;
                }>> & {
                    [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
                }>>;
                ns: {
                    namespace: Ref<string>;
                    b: (blockSuffix?: string | undefined) => string;
                    e: (element?: string | undefined) => string;
                    m: (modifier?: string | undefined) => string;
                    be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
                    em: (element?: string | undefined, modifier?: string | undefined) => string;
                    bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
                    bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
                    is: {
                        (name: string, state: boolean | undefined): string;
                        (name: string): string;
                    };
                    cssVar: (object: Record<string, string>) => Record<string, string>;
                    cssVarName: (name: string) => string;
                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                    cssVarBlockName: (name: string) => string;
                };
            }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, Record<string, any>, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly type: EpPropFinalized<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger", unknown, "", boolean>;
            }>>, {
                readonly type: EpPropMergeType<StringConstructor, "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger", unknown>;
            }>;
        };
    }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("submit" | "close" | "update:modelValue")[], "submit" | "close" | "update:modelValue", VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
        modelValue: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        modal: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        width: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        height: {
            type: StringConstructor;
            required: false;
        };
        top: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        cancel: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        submit: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        closable: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & {
        onSubmit?: ((...args: any[]) => any) | undefined;
        onClose?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }, {
        width: string;
        top: string;
        submit: boolean;
        modelValue: boolean;
        closable: boolean;
        modal: boolean;
        cancel: boolean;
    }>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "change"[], "change", VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
    modelValue: {
        type: null;
        required: false;
        default: string;
    };
}>> & {
    onChange?: ((...args: any[]) => any) | undefined;
}, {
    modelValue: any;
}>;
export default _sfc_main;
