import loader from '@vue-monaco/loader';
export { default as loader } from '@vue-monaco/loader';
import * as vue_demi from 'vue-demi';
import { SlotsType } from 'vue-demi';
import * as monaco_editor from 'monaco-editor';
import { editor } from 'monaco-editor';
export { editor as Editor } from 'monaco-editor';
import { PropType, ExtractPropTypes, ComponentPublicInstance } from 'vue';
import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';

declare const diffEditorProps: {
    /**
     * The original source (left one) value
     */
    original: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The modified source (right one) value
     */
    modified: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Language for the both models - original and modified
     */
    language: {
        type: StringConstructor;
    };
    /**
     * This prop gives you the opportunity to specify the language of the
     * original source separately, otherwise, it will get the value of the language property
     */
    originalLanguage: {
        type: StringConstructor;
    };
    /**
     * This prop gives you the opportunity to specify the language of the
     * modified source separately, otherwise, it will get the value of language property
     */
    modifiedLanguage: {
        type: StringConstructor;
    };
    /**
     * Path for the "original" model
     * Will be passed as a third argument to `.createModel` method
     * `monaco.editor.createModel(..., ..., monaco.Uri.parse(originalModelPath))`
     */
    originalModelPath: {
        type: StringConstructor;
    };
    /**
     * Path for the "modified" model
     * Will be passed as a third argument to `.createModel` method
     * `monaco.editor.createModel(..., ..., monaco.Uri.parse(modifiedModelPath))`
     */
    modifiedModelPath: {
        type: StringConstructor;
    };
    /**
     * Indicator whether to dispose the current original model when the DiffEditor is unmounted or not
     * @default false
     */
    keepCurrentOriginalModel: {
        type: BooleanConstructor;
    };
    /**
     * Indicator whether to dispose the current modified model when the DiffEditor is unmounted or not
     * @default false
     */
    keepCurrentModifiedModel: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The theme for the monaco
     * Available options "vs-dark" | "light"
     * Define new themes by `monaco.editor.defineTheme`
     * @default "light"
     */
    theme: {
        type: PropType<string>;
        default: string;
    };
    /**
     * IDiffEditorConstructionOptions
     */
    options: {
        type: PropType<editor.IDiffEditorConstructionOptions>;
        default: () => {};
    };
    /**
     * Width of the editor wrapper
     * @default "100%"
     */
    width: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    /**
     * Height of the editor wrapper
     * @default "100%"
     */
    height: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    /**
     * Class name for the editor container
     */
    className: {
        type: StringConstructor;
    };
};

declare const editorProps: {
    /**
     * Default value of the current model
     */
    defaultValue: {
        type: StringConstructor;
    };
    /**
     * Default language of the current model
     */
    defaultLanguage: {
        type: StringConstructor;
    };
    /**
     * Default path of the current model
     * Will be passed as the third argument to `.createModel` method
     * `monaco.editor.createModel(..., ..., monaco.Uri.parse(defaultPath))`
     */
    defaultPath: {
        type: StringConstructor;
    };
    /**
     * Value of the current model
     */
    value: {
        type: StringConstructor;
        value: string;
    };
    /**
     * Language of the current model
     */
    language: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Path of the current model
     * Will be passed as the third argument to `.createModel` method
     * `monaco.editor.createModel(..., ..., monaco.Uri.parse(defaultPath))`
     */
    path: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The theme for the monaco
     * Available options "vs-dark" | "light"
     * Define new themes by `monaco.editor.defineTheme`
     * @default "light"
     */
    theme: {
        type: PropType<string>;
        default: string;
    };
    /**
     * The line to jump on it
     */
    line: {
        type: NumberConstructor;
    };
    /**
     * IStandaloneEditorConstructionOptions
     */
    options: {
        type: PropType<editor.IStandaloneEditorConstructionOptions>;
        default: () => {};
    };
    /**
     * IEditorOverrideServices
     */
    overrideServices: {
        type: PropType<editor.IEditorOverrideServices>;
    };
    /**
     * Indicator whether to save the models' view states between model changes or not
     * Defaults to true
     */
    saveViewState: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Indicator whether to dispose the current model when the Editor is unmounted or not
     * @default false
     */
    keepCurrentModel: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Width of the editor wrapper
     * @default "100%"
     */
    width: {
        type: PropType<string | number>;
        default: string;
    };
    /**
     * Height of the editor wrapper
     * @default "100%"
     */
    height: {
        type: PropType<string | number>;
        default: string;
    };
    /**
     * Class name for the editor container
     */
    className: {
        type: StringConstructor;
    };
};

type MonacoDiffEditor = editor.IStandaloneDiffEditor;
type DiffOnMount = (editor: MonacoDiffEditor, monaco: Monaco) => void;
type DiffBeforeMount = (monaco: Monaco) => void;
type DiffEditorProps = ExtractPropTypes<typeof diffEditorProps>;
type DiffEditorInstance = ComponentPublicInstance<DiffEditorProps, EditorEmitsOptions>;
type EditorProps = ExtractPropTypes<typeof editorProps>;
type EditorInstance = ComponentPublicInstance<EditorProps, EditorEmitsOptions>;
type Monaco = typeof monaco;

type Theme = 'vs-dark' | 'light';
interface EditorEmitsOptions {
    'update:value': (value: string | undefined) => void;
    beforeMount: (monaco: Monaco) => void;
    mount: (editor: editor.IStandaloneCodeEditor, monaco: Monaco) => void;
    change: (value: string | undefined, event: editor.IModelContentChangedEvent) => void;
    validate: (markers: editor.IMarker[]) => void;
}

declare const _default$1: vue_demi.DefineComponent<{
    original: {
        type: StringConstructor;
        default: string;
    };
    modified: {
        type: StringConstructor;
        default: string;
    };
    language: {
        type: StringConstructor;
    };
    originalLanguage: {
        type: StringConstructor;
    };
    modifiedLanguage: {
        type: StringConstructor;
    };
    originalModelPath: {
        type: StringConstructor;
    };
    modifiedModelPath: {
        type: StringConstructor;
    };
    keepCurrentOriginalModel: {
        type: BooleanConstructor;
    };
    keepCurrentModifiedModel: {
        type: BooleanConstructor;
        default: boolean;
    };
    theme: {
        type: vue_demi.PropType<string>;
        default: string;
    };
    options: {
        type: vue_demi.PropType<editor.IDiffEditorConstructionOptions>;
        default: () => {};
    };
    width: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    height: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    className: {
        type: StringConstructor;
    };
}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.VNodeProps & vue_demi.AllowedComponentProps & vue_demi.ComponentCustomProps, Readonly<vue_demi.ExtractPropTypes<{
    original: {
        type: StringConstructor;
        default: string;
    };
    modified: {
        type: StringConstructor;
        default: string;
    };
    language: {
        type: StringConstructor;
    };
    originalLanguage: {
        type: StringConstructor;
    };
    modifiedLanguage: {
        type: StringConstructor;
    };
    originalModelPath: {
        type: StringConstructor;
    };
    modifiedModelPath: {
        type: StringConstructor;
    };
    keepCurrentOriginalModel: {
        type: BooleanConstructor;
    };
    keepCurrentModifiedModel: {
        type: BooleanConstructor;
        default: boolean;
    };
    theme: {
        type: vue_demi.PropType<string>;
        default: string;
    };
    options: {
        type: vue_demi.PropType<editor.IDiffEditorConstructionOptions>;
        default: () => {};
    };
    width: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    height: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    className: {
        type: StringConstructor;
    };
}>>, {
    theme: string;
    options: editor.IDiffEditorConstructionOptions;
    width: string | number;
    height: string | number;
    original: string;
    modified: string;
    keepCurrentOriginalModel: boolean;
    keepCurrentModifiedModel: boolean;
}, SlotsType<{
    default: any;
    failure: any;
    loading: any;
}>>;

declare const _default: vue_demi.DefineComponent<{
    defaultValue: {
        type: StringConstructor;
    };
    defaultLanguage: {
        type: StringConstructor;
    };
    defaultPath: {
        type: StringConstructor;
    };
    value: {
        type: StringConstructor;
        value: string;
    };
    language: {
        type: StringConstructor;
        default: string;
    };
    path: {
        type: StringConstructor;
        default: string;
    };
    theme: {
        type: vue_demi.PropType<string>;
        default: string;
    };
    line: {
        type: NumberConstructor;
    };
    options: {
        type: vue_demi.PropType<editor.IStandaloneEditorConstructionOptions>;
        default: () => {};
    };
    overrideServices: {
        type: vue_demi.PropType<editor.IEditorOverrideServices>;
    };
    saveViewState: {
        type: BooleanConstructor;
        default: boolean;
    };
    keepCurrentModel: {
        type: BooleanConstructor;
        default: boolean;
    };
    width: {
        type: vue_demi.PropType<string | number>;
        default: string;
    };
    height: {
        type: vue_demi.PropType<string | number>;
        default: string;
    };
    className: {
        type: StringConstructor;
    };
}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, ("update:value" | "beforeMount" | "mount" | "change" | "validate")[], "update:value" | "beforeMount" | "mount" | "change" | "validate", vue_demi.VNodeProps & vue_demi.AllowedComponentProps & vue_demi.ComponentCustomProps, Readonly<vue_demi.ExtractPropTypes<{
    defaultValue: {
        type: StringConstructor;
    };
    defaultLanguage: {
        type: StringConstructor;
    };
    defaultPath: {
        type: StringConstructor;
    };
    value: {
        type: StringConstructor;
        value: string;
    };
    language: {
        type: StringConstructor;
        default: string;
    };
    path: {
        type: StringConstructor;
        default: string;
    };
    theme: {
        type: vue_demi.PropType<string>;
        default: string;
    };
    line: {
        type: NumberConstructor;
    };
    options: {
        type: vue_demi.PropType<editor.IStandaloneEditorConstructionOptions>;
        default: () => {};
    };
    overrideServices: {
        type: vue_demi.PropType<editor.IEditorOverrideServices>;
    };
    saveViewState: {
        type: BooleanConstructor;
        default: boolean;
    };
    keepCurrentModel: {
        type: BooleanConstructor;
        default: boolean;
    };
    width: {
        type: vue_demi.PropType<string | number>;
        default: string;
    };
    height: {
        type: vue_demi.PropType<string | number>;
        default: string;
    };
    className: {
        type: StringConstructor;
    };
}>> & {
    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
    onBeforeMount?: ((...args: any[]) => any) | undefined;
    onMount?: ((...args: any[]) => any) | undefined;
    onChange?: ((...args: any[]) => any) | undefined;
    onValidate?: ((...args: any[]) => any) | undefined;
}, {
    language: string;
    path: string;
    theme: string;
    options: editor.IStandaloneEditorConstructionOptions;
    saveViewState: boolean;
    keepCurrentModel: boolean;
    width: string | number;
    height: string | number;
}, SlotsType<{
    default: any;
    failure: any;
    loading: any;
}>>;

declare function useMonaco(): {
    monacoRef: vue_demi.ShallowRef<typeof monaco_editor | null>;
    unload: () => void;
    isLoadFailed: vue_demi.Ref<boolean>;
};

type Options = Parameters<typeof loader.config>[0];
declare function install(app: any, options?: Options): void;

export { type DiffBeforeMount, type DiffEditorInstance, type DiffEditorProps, type DiffOnMount, type EditorEmitsOptions, type EditorInstance, type EditorProps, type Monaco, _default$1 as MonacoDiffEditor, _default as MonacoEditor, type Theme, install, useMonaco };